Version bump to 0.53

0.53

.coveragerc

@@ -8,6 +8,9 @@ omit =
     homeassistant/helpers/signal.py
 
     # omit pieces of code that rely on external devices being present
+    homeassistant/components/abode.py
+    homeassistant/components/*/abode.py
+
     homeassistant/components/alarmdecoder.py
     homeassistant/components/*/alarmdecoder.py
 
@@ -167,6 +170,9 @@ omit =
     homeassistant/components/tellstick.py
     homeassistant/components/*/tellstick.py
 
+    homeassistant/components/tesla.py
+    homeassistant/components/*/tesla.py
+
     homeassistant/components/*/thinkingcleaner.py
 
     homeassistant/components/tradfri.py
@@ -176,6 +182,9 @@ omit =
     homeassistant/components/notify/twilio_sms.py
     homeassistant/components/notify/twilio_call.py
 
+    homeassistant/components/usps.py
+    homeassistant/components/*/usps.py
+
     homeassistant/components/velbus.py
     homeassistant/components/*/velbus.py
 
@@ -322,10 +331,12 @@ omit =
     homeassistant/components/light/tplink.py
     homeassistant/components/light/tradfri.py
     homeassistant/components/light/x10.py
+    homeassistant/components/light/xiaomi_philipslight.py
     homeassistant/components/light/yeelight.py
     homeassistant/components/light/yeelightsunflower.py
     homeassistant/components/light/zengge.py
     homeassistant/components/lirc.py
+    homeassistant/components/lock/nello.py
     homeassistant/components/lock/nuki.py
     homeassistant/components/lock/lockitron.py
     homeassistant/components/lock/sesame.py
@@ -373,6 +384,8 @@ omit =
     homeassistant/components/media_player/vlc.py
     homeassistant/components/media_player/volumio.py
     homeassistant/components/media_player/yamaha.py
+    homeassistant/components/media_player/yamaha_musiccast.py
+    homeassistant/components/mycroft.py
     homeassistant/components/notify/aws_lambda.py
     homeassistant/components/notify/aws_sns.py
     homeassistant/components/notify/aws_sqs.py
@@ -383,14 +396,17 @@ omit =
     homeassistant/components/notify/free_mobile.py
     homeassistant/components/notify/gntp.py
     homeassistant/components/notify/group.py
+    homeassistant/components/notify/hipchat.py
     homeassistant/components/notify/instapush.py
     homeassistant/components/notify/kodi.py
     homeassistant/components/notify/lannouncer.py
     homeassistant/components/notify/llamalab_automate.py
     homeassistant/components/notify/matrix.py
     homeassistant/components/notify/message_bird.py
+    homeassistant/components/notify/mycroft.py
     homeassistant/components/notify/nfandroidtv.py
     homeassistant/components/notify/nma.py
+    homeassistant/components/notify/prowl.py
     homeassistant/components/notify/pushbullet.py
     homeassistant/components/notify/pushetta.py
     homeassistant/components/notify/pushover.py
@@ -411,6 +427,7 @@ omit =
     homeassistant/components/remote/itach.py
     homeassistant/components/scene/hunterdouglas_powerview.py
     homeassistant/components/scene/lifx_cloud.py
+    homeassistant/components/sensor/airvisual.py
     homeassistant/components/sensor/arest.py
     homeassistant/components/sensor/arwn.py
     homeassistant/components/sensor/bbox.py
@@ -436,6 +453,7 @@ omit =
     homeassistant/components/sensor/dovado.py
     homeassistant/components/sensor/dte_energy_bridge.py
     homeassistant/components/sensor/dublin_bus_transport.py
+    homeassistant/components/sensor/dwd_weather_warnings.py
     homeassistant/components/sensor/ebox.py
     homeassistant/components/sensor/eddystone_temperature.py
     homeassistant/components/sensor/eliqonline.py
@@ -471,6 +489,7 @@ omit =
     homeassistant/components/sensor/metoffice.py
     homeassistant/components/sensor/miflora.py
     homeassistant/components/sensor/modem_callerid.py
+    homeassistant/components/sensor/mopar.py
     homeassistant/components/sensor/mqtt_room.py
     homeassistant/components/sensor/mvglive.py
     homeassistant/components/sensor/netdata.py
@@ -508,6 +527,7 @@ omit =
     homeassistant/components/sensor/swiss_public_transport.py
     homeassistant/components/sensor/synologydsm.py
     homeassistant/components/sensor/systemmonitor.py
+    homeassistant/components/sensor/tank_utility.py
     homeassistant/components/sensor/ted5000.py
     homeassistant/components/sensor/temper.py
     homeassistant/components/sensor/time_date.py
@@ -517,9 +537,9 @@ omit =
     homeassistant/components/sensor/uber.py
     homeassistant/components/sensor/upnp.py
     homeassistant/components/sensor/ups.py
-    homeassistant/components/sensor/usps.py
     homeassistant/components/sensor/vasttrafik.py
     homeassistant/components/sensor/waqi.py
+    homeassistant/components/sensor/worldtidesinfo.py
     homeassistant/components/sensor/xbox_live.py
     homeassistant/components/sensor/yweather.py
     homeassistant/components/sensor/zamg.py

.gitignore

@@ -94,3 +94,6 @@ docs/build
 
 # Windows Explorer
 desktop.ini
+/home-assistant.pyproj
+/home-assistant.sln
+/.vs/home-assistant/v14

README.rst

@@ -33,10 +33,6 @@ of a component, check the `Home Assistant help section <https://home-assistant.i
    :target: https://coveralls.io/r/home-assistant/home-assistant?branch=master
 .. |Chat Status| image:: https://img.shields.io/discord/330944238910963714.svg
    :target: https://discord.gg/c5DvZ4e
-.. |Join the chat at https://gitter.im/home-assistant/home-assistant| image:: https://img.shields.io/badge/gitter-general-blue.svg
-   :target: https://gitter.im/home-assistant/home-assistant?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-.. |Join the dev chat at https://gitter.im/home-assistant/home-assistant/devs| image:: https://img.shields.io/badge/gitter-development-yellowgreen.svg
-   :target: https://gitter.im/home-assistant/home-assistant/devs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 .. |screenshot-states| image:: https://raw.github.com/home-assistant/home-assistant/master/docs/screenshots.png
    :target: https://home-assistant.io/demo/
 .. |screenshot-components| image:: https://raw.github.com/home-assistant/home-assistant/dev/docs/screenshot-components.png

homeassistant/components/__init__.py

@@ -101,6 +101,12 @@ def reload_core_config(hass):
     hass.services.call(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG)
 
 
+@asyncio.coroutine
+def async_reload_core_config(hass):
+    """Reload the core config."""
+    yield from hass.services.async_call(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG)
+
+
 @asyncio.coroutine
 def async_setup(hass, config):
     """Set up general services related to Home Assistant."""

homeassistant/components/abode.py

@@ -0,0 +1,126 @@
+"""
+This component provides basic support for Abode Home Security system.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/abode/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+from requests.exceptions import HTTPError, ConnectTimeout
+from homeassistant.helpers import discovery
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity import Entity
+from homeassistant.const import (ATTR_ATTRIBUTION,
+                                 CONF_USERNAME, CONF_PASSWORD,
+                                 CONF_NAME, EVENT_HOMEASSISTANT_STOP,
+                                 EVENT_HOMEASSISTANT_START)
+
+REQUIREMENTS = ['abodepy==0.9.0']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ATTRIBUTION = "Data provided by goabode.com"
+
+DOMAIN = 'abode'
+DEFAULT_NAME = 'Abode'
+DATA_ABODE = 'abode'
+
+NOTIFICATION_ID = 'abode_notification'
+NOTIFICATION_TITLE = 'Abode Security Setup'
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_USERNAME): cv.string,
+        vol.Required(CONF_PASSWORD): cv.string,
+        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+ABODE_PLATFORMS = [
+    'alarm_control_panel', 'binary_sensor', 'lock', 'switch', 'cover'
+]
+
+
+def setup(hass, config):
+    """Set up Abode component."""
+    import abodepy
+
+    conf = config[DOMAIN]
+    username = conf.get(CONF_USERNAME)
+    password = conf.get(CONF_PASSWORD)
+
+    try:
+        hass.data[DATA_ABODE] = abode = abodepy.Abode(
+            username, password, auto_login=True, get_devices=True)
+
+    except (ConnectTimeout, HTTPError) as ex:
+        _LOGGER.error("Unable to connect to Abode: %s", str(ex))
+        hass.components.persistent_notification.create(
+            'Error: {}<br />'
+            'You will need to restart hass after fixing.'
+            ''.format(ex),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
+        return False
+
+    for platform in ABODE_PLATFORMS:
+        discovery.load_platform(hass, platform, DOMAIN, {}, config)
+
+    def logout(event):
+        """Logout of Abode."""
+        abode.stop_listener()
+        abode.logout()
+        _LOGGER.info("Logged out of Abode")
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, logout)
+
+    def startup(event):
+        """Listen for push events."""
+        abode.start_listener()
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_START, startup)
+
+    return True
+
+
+class AbodeDevice(Entity):
+    """Representation of an Abode device."""
+
+    def __init__(self, controller, device):
+        """Initialize a sensor for Abode device."""
+        self._controller = controller
+        self._device = device
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Subscribe Abode events."""
+        self.hass.async_add_job(
+            self._controller.register, self._device,
+            self._update_callback
+        )
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._device.name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._device.device_id,
+            'battery_low': self._device.battery_low,
+            'no_response': self._device.no_response
+        }
+
+    def _update_callback(self, device):
+        """Update the device state."""
+        self.schedule_update_ha_state()

homeassistant/components/alarm_control_panel/__init__.py

@@ -13,7 +13,8 @@ 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_DISARM, SERVICE_ALARM_ARM_HOME, SERVICE_ALARM_ARM_AWAY,
+    SERVICE_ALARM_ARM_NIGHT)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.loader import bind_hass
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
@@ -31,6 +32,7 @@ SERVICE_TO_METHOD = {
     SERVICE_ALARM_DISARM: 'alarm_disarm',
     SERVICE_ALARM_ARM_HOME: 'alarm_arm_home',
     SERVICE_ALARM_ARM_AWAY: 'alarm_arm_away',
+    SERVICE_ALARM_ARM_NIGHT: 'alarm_arm_night',
     SERVICE_ALARM_TRIGGER: 'alarm_trigger'
 }
 
@@ -81,6 +83,18 @@ def alarm_arm_away(hass, code=None, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_ALARM_ARM_AWAY, data)
 
 
+@bind_hass
+def alarm_arm_night(hass, code=None, entity_id=None):
+    """Send the alarm the command for arm night."""
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_NIGHT, data)
+
+
 @bind_hass
 def alarm_trigger(hass, code=None, entity_id=None):
     """Send the alarm the command for trigger."""
@@ -187,6 +201,17 @@ class AlarmControlPanel(Entity):
         """
         return self.hass.async_add_job(self.alarm_arm_away, code)
 
+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        raise NotImplementedError()
+
+    def async_alarm_arm_night(self, code=None):
+        """Send arm night command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.async_add_job(self.alarm_arm_night, code)
+
     def alarm_trigger(self, code=None):
         """Send alarm trigger command."""
         raise NotImplementedError()

homeassistant/components/alarm_control_panel/abode.py

@@ -0,0 +1,76 @@
+"""
+This component provides HA alarm_control_panel support for Abode System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.abode/
+"""
+import logging
+
+from homeassistant.components.abode import (
+    AbodeDevice, DATA_ABODE, DEFAULT_NAME, CONF_ATTRIBUTION)
+from homeassistant.components.alarm_control_panel import (AlarmControlPanel)
+from homeassistant.const import (ATTR_ATTRIBUTION, STATE_ALARM_ARMED_AWAY,
+                                 STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED)
+
+
+DEPENDENCIES = ['abode']
+
+_LOGGER = logging.getLogger(__name__)
+
+ICON = 'mdi:security'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a sensor for an Abode device."""
+    abode = hass.data[DATA_ABODE]
+
+    add_devices([AbodeAlarm(abode, abode.get_alarm())])
+
+
+class AbodeAlarm(AbodeDevice, AlarmControlPanel):
+    """An alarm_control_panel implementation for Abode."""
+
+    def __init__(self, controller, device):
+        """Initialize the alarm control panel."""
+        AbodeDevice.__init__(self, controller, device)
+        self._name = "{0}".format(DEFAULT_NAME)
+
+    @property
+    def icon(self):
+        """Return icon."""
+        return ICON
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        if self._device.is_standby:
+            state = STATE_ALARM_DISARMED
+        elif self._device.is_away:
+            state = STATE_ALARM_ARMED_AWAY
+        elif self._device.is_home:
+            state = STATE_ALARM_ARMED_HOME
+        else:
+            state = None
+        return state
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        self._device.set_standby()
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        self._device.set_home()
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        self._device.set_away()
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._device.device_id,
+            'battery_backup': self._device.battery,
+            'cellular_backup': self._device.is_cellular
+        }

homeassistant/components/alarm_control_panel/egardia.py

@@ -18,7 +18,7 @@ from homeassistant.const import (
     CONF_NAME, STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME,
     STATE_ALARM_ARMED_AWAY, STATE_ALARM_TRIGGERED)
 
-REQUIREMENTS = ['pythonegardia==1.0.17']
+REQUIREMENTS = ['pythonegardia==1.0.20']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -29,7 +29,7 @@ CONF_REPORT_SERVER_PORT = 'report_server_port'
 DEFAULT_NAME = 'Egardia'
 DEFAULT_PORT = 80
 DEFAULT_REPORT_SERVER_ENABLED = False
-DEFAULT_REPORT_SERVER_PORT = 85
+DEFAULT_REPORT_SERVER_PORT = 52010
 DOMAIN = 'egardia'
 
 NOTIFICATION_ID = 'egardia_notification'
@@ -154,8 +154,9 @@ class EgardiaAlarm(alarm.AlarmControlPanel):
 
     def update(self):
         """Update the alarm status."""
-        status = self._egardiasystem.getstate()
-        self.parsestatus(status)
+        if not self._rs_enabled:
+            status = self._egardiasystem.getstate()
+            self.parsestatus(status)
 
     def alarm_disarm(self, code=None):
         """Send disarm command."""

homeassistant/components/alarm_control_panel/manual.py

@@ -12,9 +12,10 @@ import voluptuous as vol
 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_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_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)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import track_point_in_time
 
@@ -23,6 +24,8 @@ DEFAULT_PENDING_TIME = 60
 DEFAULT_TRIGGER_TIME = 120
 DEFAULT_DISARM_AFTER_TRIGGER = False
 
+ATTR_POST_PENDING_STATE = 'post_pending_state'
+
 PLATFORM_SCHEMA = vol.Schema({
     vol.Required(CONF_PLATFORM): 'manual',
     vol.Optional(CONF_NAME, default=DEFAULT_ALARM_NAME): cv.string,
@@ -87,7 +90,8 @@ class ManualAlarm(alarm.AlarmControlPanel):
     def state(self):
         """Return the state of the device."""
         if self._state in (STATE_ALARM_ARMED_HOME,
-                           STATE_ALARM_ARMED_AWAY) and \
+                           STATE_ALARM_ARMED_AWAY,
+                           STATE_ALARM_ARMED_NIGHT) and \
            self._pending_time and self._state_ts + self._pending_time > \
            dt_util.utcnow():
             return STATE_ALARM_PENDING
@@ -99,7 +103,9 @@ class ManualAlarm(alarm.AlarmControlPanel):
                   self._trigger_time) < dt_util.utcnow():
                 if self._disarm_after_trigger:
                     return STATE_ALARM_DISARMED
-                return self._pre_trigger_state
+                else:
+                    self._state = self._pre_trigger_state
+                    return self._state
 
         return self._state
 
@@ -145,6 +151,20 @@ class ManualAlarm(alarm.AlarmControlPanel):
                 self._hass, self.async_update_ha_state,
                 self._state_ts + self._pending_time)
 
+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_NIGHT):
+            return
+
+        self._state = STATE_ALARM_ARMED_NIGHT
+        self._state_ts = dt_util.utcnow()
+        self.schedule_update_ha_state()
+
+        if self._pending_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + self._pending_time)
+
     def alarm_trigger(self, code=None):
         """Send alarm trigger command. No code needed."""
         self._pre_trigger_state = self._state
@@ -167,3 +187,13 @@ class ManualAlarm(alarm.AlarmControlPanel):
         if not check:
             _LOGGER.warning("Invalid code given for %s", state)
         return check
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        state_attr = {}
+
+        if self.state == STATE_ALARM_PENDING:
+            state_attr[ATTR_POST_PENDING_STATE] = self._state
+
+        return state_attr

homeassistant/components/alarm_control_panel/services.yaml

@@ -31,6 +31,17 @@ alarm_arm_away:
       description: An optional code to arm away the alarm control panel with
       example: 1234
 
+alarm_arm_night:
+  description: Send the alarm the command for arm night
+
+  fields:
+    entity_id:
+      description: Name of alarm control panel to arm night
+      example: 'alarm_control_panel.downstairs'
+    code:
+      description: An optional code to arm night the alarm control panel with
+      example: 1234
+
 alarm_trigger:
   description: Send the alarm the command for trigger
 

homeassistant/components/alarm_control_panel/simplisafe.py

@@ -16,7 +16,7 @@ from homeassistant.const import (
     EVENT_HOMEASSISTANT_STOP)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['simplisafe-python==1.0.4']
+REQUIREMENTS = ['simplisafe-python==1.0.5']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -89,11 +89,11 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
     def state(self):
         """Return the state of the device."""
         status = self.simplisafe.state()
-        if status == 'Off':
+        if status == 'off':
             state = STATE_ALARM_DISARMED
-        elif status == 'Home':
+        elif status == 'home':
             state = STATE_ALARM_ARMED_HOME
-        elif status == 'Away':
+        elif status == 'away':
             state = STATE_ALARM_ARMED_AWAY
         else:
             state = STATE_UNKNOWN

homeassistant/components/alarm_control_panel/totalconnect.py

@@ -13,8 +13,8 @@ import homeassistant.components.alarm_control_panel as alarm
 from homeassistant.components.alarm_control_panel import PLATFORM_SCHEMA
 from homeassistant.const import (
     CONF_PASSWORD, CONF_USERNAME, STATE_ALARM_ARMED_AWAY,
-    STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED, STATE_UNKNOWN,
-    CONF_NAME)
+    STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT, STATE_ALARM_DISARMED,
+    STATE_ALARM_ARMING, STATE_ALARM_DISARMING, STATE_UNKNOWN, CONF_NAME)
 
 REQUIREMENTS = ['total_connect_client==0.11']
 
@@ -74,6 +74,12 @@ class TotalConnect(alarm.AlarmControlPanel):
             state = STATE_ALARM_ARMED_HOME
         elif status == self._client.ARMED_AWAY:
             state = STATE_ALARM_ARMED_AWAY
+        elif status == self._client.ARMED_STAY_NIGHT:
+            state = STATE_ALARM_ARMED_NIGHT
+        elif status == self._client.ARMING:
+            state = STATE_ALARM_ARMING
+        elif status == self._client.DISARMING:
+            state = STATE_ALARM_DISARMING
         else:
             state = STATE_UNKNOWN
 
@@ -90,3 +96,7 @@ class TotalConnect(alarm.AlarmControlPanel):
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         self._client.arm_away()
+
+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        self._client.arm_stay_night()

homeassistant/components/apple_tv.py

@@ -91,7 +91,7 @@ def request_configuration(hass, config, atv, credentials):
         hass.async_add_job(configurator.request_done, instance)
 
     instance = configurator.request_config(
-        hass, 'Apple TV Authentication', configuration_callback,
+        'Apple TV Authentication', configuration_callback,
         description='Please enter PIN code shown on screen.',
         submit_caption='Confirm',
         fields=[{'id': 'pin', 'name': 'PIN Code', 'type': 'password'}]

homeassistant/components/automation/numeric_state.py

@@ -12,16 +12,18 @@ import voluptuous as vol
 from homeassistant.core import callback
 from homeassistant.const import (
     CONF_VALUE_TEMPLATE, CONF_PLATFORM, CONF_ENTITY_ID,
-    CONF_BELOW, CONF_ABOVE)
-from homeassistant.helpers.event import async_track_state_change
+    CONF_BELOW, CONF_ABOVE, CONF_FOR)
+from homeassistant.helpers.event import (
+    async_track_state_change, async_track_same_state)
 from homeassistant.helpers import condition, config_validation as cv
 
 TRIGGER_SCHEMA = vol.All(vol.Schema({
     vol.Required(CONF_PLATFORM): 'numeric_state',
     vol.Required(CONF_ENTITY_ID): cv.entity_ids,
-    CONF_BELOW: vol.Coerce(float),
-    CONF_ABOVE: vol.Coerce(float),
+    vol.Optional(CONF_BELOW): vol.Coerce(float),
+    vol.Optional(CONF_ABOVE): vol.Coerce(float),
     vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
+    vol.Optional(CONF_FOR): vol.All(cv.time_period, cv.positive_timedelta),
 }), cv.has_at_least_one_key(CONF_BELOW, CONF_ABOVE))
 
 _LOGGER = logging.getLogger(__name__)
@@ -33,15 +35,18 @@ def async_trigger(hass, config, action):
     entity_id = config.get(CONF_ENTITY_ID)
     below = config.get(CONF_BELOW)
     above = config.get(CONF_ABOVE)
+    time_delta = config.get(CONF_FOR)
     value_template = config.get(CONF_VALUE_TEMPLATE)
+    async_remove_track_same = None
+
     if value_template is not None:
         value_template.hass = hass
 
     @callback
-    def state_automation_listener(entity, from_s, to_s):
-        """Listen for state changes and calls action."""
+    def check_numeric_state(entity, from_s, to_s):
+        """Return True if they should trigger."""
         if to_s is None:
-            return
+            return False
 
         variables = {
             'trigger': {
@@ -55,17 +60,56 @@ def async_trigger(hass, config, action):
         # If new one doesn't match, nothing to do
         if not condition.async_numeric_state(
                 hass, to_s, below, above, value_template, variables):
+            return False
+
+        return True
+
+    @callback
+    def state_automation_listener(entity, from_s, to_s):
+        """Listen for state changes and calls action."""
+        nonlocal async_remove_track_same
+
+        if not check_numeric_state(entity, from_s, to_s):
             return
 
+        variables = {
+            'trigger': {
+                'platform': 'numeric_state',
+                'entity_id': entity,
+                'below': below,
+                'above': above,
+                'from_state': from_s,
+                'to_state': to_s,
+            }
+        }
+
         # Only match if old didn't exist or existed but didn't match
         # Written as: skip if old one did exist and matched
         if from_s is not None and condition.async_numeric_state(
                 hass, from_s, below, above, value_template, variables):
             return
 
-        variables['trigger']['from_state'] = from_s
-        variables['trigger']['to_state'] = to_s
+        @callback
+        def call_action():
+            """Call action with right context."""
+            hass.async_run_job(action, variables)
 
-        hass.async_run_job(action, variables)
+        if not time_delta:
+            call_action()
+            return
 
-    return async_track_state_change(hass, entity_id, state_automation_listener)
+        async_remove_track_same = async_track_same_state(
+            hass, True, time_delta, call_action, entity_ids=entity_id,
+            async_check_func=check_numeric_state)
+
+    unsub = async_track_state_change(
+        hass, entity_id, state_automation_listener)
+
+    @callback
+    def async_remove():
+        """Remove state listeners async."""
+        unsub()
+        if async_remove_track_same:
+            async_remove_track_same()  # pylint: disable=not-callable
+
+    return async_remove

homeassistant/components/automation/state.py

@@ -8,28 +8,23 @@ import asyncio
 import voluptuous as vol
 
 from homeassistant.core import callback
-import homeassistant.util.dt as dt_util
-from homeassistant.const import MATCH_ALL, CONF_PLATFORM
+from homeassistant.const import MATCH_ALL, CONF_PLATFORM, CONF_FOR
 from homeassistant.helpers.event import (
-    async_track_state_change, async_track_point_in_utc_time)
+    async_track_state_change, async_track_same_state)
 import homeassistant.helpers.config_validation as cv
 
 CONF_ENTITY_ID = 'entity_id'
 CONF_FROM = 'from'
 CONF_TO = 'to'
-CONF_FOR = 'for'
 
-TRIGGER_SCHEMA = vol.All(
-    vol.Schema({
-        vol.Required(CONF_PLATFORM): 'state',
-        vol.Required(CONF_ENTITY_ID): cv.entity_ids,
-        # These are str on purpose. Want to catch YAML conversions
-        CONF_FROM: str,
-        CONF_TO: str,
-        CONF_FOR: vol.All(cv.time_period, cv.positive_timedelta),
-    }),
-    cv.key_dependency(CONF_FOR, CONF_TO),
-)
+TRIGGER_SCHEMA = vol.All(vol.Schema({
+    vol.Required(CONF_PLATFORM): 'state',
+    vol.Required(CONF_ENTITY_ID): cv.entity_ids,
+    # These are str on purpose. Want to catch YAML conversions
+    vol.Optional(CONF_FROM): str,
+    vol.Optional(CONF_TO): str,
+    vol.Optional(CONF_FOR): vol.All(cv.time_period, cv.positive_timedelta),
+}), cv.key_dependency(CONF_FOR, CONF_TO))
 
 
 @asyncio.coroutine
@@ -39,28 +34,15 @@ def async_trigger(hass, config, action):
     from_state = config.get(CONF_FROM, MATCH_ALL)
     to_state = config.get(CONF_TO, MATCH_ALL)
     time_delta = config.get(CONF_FOR)
-    async_remove_state_for_cancel = None
-    async_remove_state_for_listener = None
     match_all = (from_state == MATCH_ALL and to_state == MATCH_ALL)
-
-    @callback
-    def clear_listener():
-        """Clear all unsub listener."""
-        nonlocal async_remove_state_for_cancel, async_remove_state_for_listener
-
-        # pylint: disable=not-callable
-        if async_remove_state_for_listener is not None:
-            async_remove_state_for_listener()
-            async_remove_state_for_listener = None
-        if async_remove_state_for_cancel is not None:
-            async_remove_state_for_cancel()
-            async_remove_state_for_cancel = None
+    async_remove_track_same = None
 
     @callback
     def state_automation_listener(entity, from_s, to_s):
         """Listen for state changes and calls action."""
-        nonlocal async_remove_state_for_cancel, async_remove_state_for_listener
+        nonlocal async_remove_track_same
 
+        @callback
         def call_action():
             """Call action with right context."""
             hass.async_run_job(action, {
@@ -78,33 +60,12 @@ def async_trigger(hass, config, action):
                 from_s.last_changed == to_s.last_changed):
             return
 
-        if time_delta is None:
+        if not time_delta:
             call_action()
             return
 
-        @callback
-        def state_for_listener(now):
-            """Fire on state changes after a delay and calls action."""
-            nonlocal async_remove_state_for_listener
-            async_remove_state_for_listener = None
-            clear_listener()
-            call_action()
-
-        @callback
-        def state_for_cancel_listener(entity, inner_from_s, inner_to_s):
-            """Fire on changes and cancel for listener if changed."""
-            if inner_to_s.state == to_s.state:
-                return
-            clear_listener()
-
-        # cleanup previous listener
-        clear_listener()
-
-        async_remove_state_for_listener = async_track_point_in_utc_time(
-            hass, state_for_listener, dt_util.utcnow() + time_delta)
-
-        async_remove_state_for_cancel = async_track_state_change(
-            hass, entity, state_for_cancel_listener)
+        async_remove_track_same = async_track_same_state(
+            hass, to_s.state, time_delta, call_action, entity_ids=entity_id)
 
     unsub = async_track_state_change(
         hass, entity_id, state_automation_listener, from_state, to_state)
@@ -113,6 +74,7 @@ def async_trigger(hass, config, action):
     def async_remove():
         """Remove state listeners async."""
         unsub()
-        clear_listener()
+        if async_remove_track_same:
+            async_remove_track_same()  # pylint: disable=not-callable
 
     return async_remove

homeassistant/components/axis.py

@@ -110,7 +110,7 @@ def request_configuration(hass, name, host, serialnumber):
 
     title = '{} ({})'.format(name, host)
     request_id = configurator.request_config(
-        hass, title, configuration_callback,
+        title, configuration_callback,
         description='Functionality: ' + str(AXIS_INCLUDE),
         entity_picture="/static/images/logo_axis.png",
         link_name='Axis platform documentation',

homeassistant/components/binary_sensor/abode.py

@@ -0,0 +1,61 @@
+"""
+This component provides HA binary_sensor support for Abode Security System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.abode/
+"""
+import logging
+
+from homeassistant.components.abode import AbodeDevice, DATA_ABODE
+from homeassistant.components.binary_sensor import BinarySensorDevice
+
+
+DEPENDENCIES = ['abode']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a sensor for an Abode device."""
+    abode = hass.data[DATA_ABODE]
+
+    device_types = map_abode_device_class().keys()
+
+    sensors = []
+    for sensor in abode.get_devices(type_filter=device_types):
+        sensors.append(AbodeBinarySensor(abode, sensor))
+
+    add_devices(sensors)
+
+
+def map_abode_device_class():
+    """Map Abode device types to Home Assistant binary sensor class."""
+    import abodepy.helpers.constants as CONST
+
+    return {
+        CONST.DEVICE_GLASS_BREAK: 'connectivity',
+        CONST.DEVICE_KEYPAD: 'connectivity',
+        CONST.DEVICE_DOOR_CONTACT: 'opening',
+        CONST.DEVICE_STATUS_DISPLAY: 'connectivity',
+        CONST.DEVICE_MOTION_CAMERA: 'connectivity',
+        CONST.DEVICE_WATER_SENSOR: 'moisture'
+    }
+
+
+class AbodeBinarySensor(AbodeDevice, BinarySensorDevice):
+    """A binary sensor implementation for Abode device."""
+
+    def __init__(self, controller, device):
+        """Initialize a sensor for Abode device."""
+        AbodeDevice.__init__(self, controller, device)
+        self._device_class = map_abode_device_class().get(self._device.type)
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._device.is_on
+
+    @property
+    def device_class(self):
+        """Return the class of the binary sensor."""
+        return self._device_class

homeassistant/components/binary_sensor/bayesian.py

@@ -0,0 +1,211 @@
+"""
+Use Bayesian Inference to trigger a binary sensor.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.bayesian/
+"""
+import asyncio
+import logging
+from collections import OrderedDict
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import (
+    CONF_ABOVE, CONF_BELOW, CONF_DEVICE_CLASS, CONF_ENTITY_ID, CONF_NAME,
+    CONF_PLATFORM, CONF_STATE, STATE_UNKNOWN)
+from homeassistant.core import callback
+from homeassistant.helpers import condition
+from homeassistant.helpers.event import async_track_state_change
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_OBSERVATIONS = 'observations'
+CONF_PRIOR = 'prior'
+CONF_PROBABILITY_THRESHOLD = 'probability_threshold'
+CONF_P_GIVEN_F = 'prob_given_false'
+CONF_P_GIVEN_T = 'prob_given_true'
+CONF_TO_STATE = 'to_state'
+
+DEFAULT_NAME = 'BayesianBinary'
+
+NUMERIC_STATE_SCHEMA = vol.Schema({
+    CONF_PLATFORM: 'numeric_state',
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Optional(CONF_ABOVE): vol.Coerce(float),
+    vol.Optional(CONF_BELOW): vol.Coerce(float),
+    vol.Required(CONF_P_GIVEN_T): vol.Coerce(float),
+    vol.Optional(CONF_P_GIVEN_F): vol.Coerce(float)
+}, required=True)
+
+STATE_SCHEMA = vol.Schema({
+    CONF_PLATFORM: CONF_STATE,
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_TO_STATE): cv.string,
+    vol.Required(CONF_P_GIVEN_T): vol.Coerce(float),
+    vol.Optional(CONF_P_GIVEN_F): vol.Coerce(float)
+}, required=True)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME):
+        cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): cv.string,
+    vol.Required(CONF_OBSERVATIONS): vol.Schema(
+        vol.All(cv.ensure_list, [vol.Any(NUMERIC_STATE_SCHEMA,
+                                         STATE_SCHEMA)])
+    ),
+    vol.Required(CONF_PRIOR): vol.Coerce(float),
+    vol.Optional(CONF_PROBABILITY_THRESHOLD):
+        vol.Coerce(float),
+})
+
+
+def update_probability(prior, prob_true, prob_false):
+    """Update probability using Bayes' rule."""
+    numerator = prob_true * prior
+    denominator = numerator + prob_false * (1 - prior)
+
+    probability = numerator / denominator
+    return probability
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Threshold sensor."""
+    name = config.get(CONF_NAME)
+    observations = config.get(CONF_OBSERVATIONS)
+    prior = config.get(CONF_PRIOR)
+    probability_threshold = config.get(CONF_PROBABILITY_THRESHOLD, 0.5)
+    device_class = config.get(CONF_DEVICE_CLASS)
+
+    async_add_devices([
+        BayesianBinarySensor(name, prior, observations, probability_threshold,
+                             device_class)
+    ], True)
+
+
+class BayesianBinarySensor(BinarySensorDevice):
+    """Representation of a Bayesian sensor."""
+
+    def __init__(self, name, prior, observations, probability_threshold,
+                 device_class):
+        """Initialize the Bayesian sensor."""
+        self._name = name
+        self._observations = observations
+        self._probability_threshold = probability_threshold
+        self._device_class = device_class
+        self._deviation = False
+        self.prior = prior
+        self.probability = prior
+
+        self.current_obs = OrderedDict({})
+
+        self.entity_obs = {obs['entity_id']: obs for obs in self._observations}
+
+        self.watchers = {
+            'numeric_state': self._process_numeric_state,
+            'state': self._process_state
+        }
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Call when entity about to be added to hass."""
+        @callback
+        # pylint: disable=invalid-name
+        def async_threshold_sensor_state_listener(entity, old_state,
+                                                  new_state):
+            """Handle sensor state changes."""
+            if new_state.state == STATE_UNKNOWN:
+                return
+
+            entity_obs = self.entity_obs[entity]
+            platform = entity_obs['platform']
+
+            self.watchers[platform](entity_obs)
+
+            prior = self.prior
+            print(self.current_obs.values())
+            for obs in self.current_obs.values():
+                prior = update_probability(prior, obs['prob_true'],
+                                           obs['prob_false'])
+
+            self.probability = prior
+
+            self.hass.async_add_job(self.async_update_ha_state, True)
+
+        entities = [obs['entity_id'] for obs in self._observations]
+        async_track_state_change(
+            self.hass, entities, async_threshold_sensor_state_listener)
+
+    def _update_current_obs(self, entity_observation, should_trigger):
+        """Update current observation."""
+        entity = entity_observation['entity_id']
+
+        if should_trigger:
+            prob_true = entity_observation['prob_given_true']
+            prob_false = entity_observation.get(
+                'prob_given_false', 1 - prob_true)
+
+            self.current_obs[entity] = {
+                'prob_true': prob_true,
+                'prob_false': prob_false
+            }
+
+        else:
+            self.current_obs.pop(entity, None)
+
+    def _process_numeric_state(self, entity_observation):
+        """Add entity to current_obs if numeric state conditions are met."""
+        entity = entity_observation['entity_id']
+
+        should_trigger = condition.async_numeric_state(
+            self.hass, entity,
+            entity_observation.get('below'),
+            entity_observation.get('above'), None, entity_observation)
+
+        self._update_current_obs(entity_observation, should_trigger)
+
+    def _process_state(self, entity_observation):
+        """Add entity to current observations if state conditions are met."""
+        entity = entity_observation['entity_id']
+
+        should_trigger = condition.state(
+            self.hass, entity, entity_observation.get('to_state'))
+
+        self._update_current_obs(entity_observation, should_trigger)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._deviation
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def device_class(self):
+        """Return the sensor class of the sensor."""
+        return self._device_class
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        return {
+            'observations': [val for val in self.current_obs.values()],
+            'probability': self.probability,
+            'probability_threshold': self._probability_threshold
+        }
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Get the latest data and update the states."""
+        self._deviation = bool(self.probability > self._probability_threshold)

homeassistant/components/binary_sensor/hikvision.py

@@ -18,7 +18,7 @@ from homeassistant.const import (
     CONF_SSL, EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_START,
     ATTR_LAST_TRIP_TIME, CONF_CUSTOMIZE)
 
-REQUIREMENTS = ['pyhik==0.1.3']
+REQUIREMENTS = ['pyhik==0.1.4']
 _LOGGER = logging.getLogger(__name__)
 
 CONF_IGNORED = 'ignored'
@@ -47,6 +47,7 @@ DEVICE_CLASS_MAP = {
     'PIR Alarm': 'motion',
     'Face Detection': 'motion',
     'Scene Change Detection': 'motion',
+    'I/O': None,
 }
 
 CUSTOMIZE_SCHEMA = vol.Schema({

homeassistant/components/binary_sensor/homematic.py

@@ -35,8 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     devices = []
     for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMBinarySensor(hass, conf)
-        new_device.link_homematic()
+        new_device = HMBinarySensor(conf)
         devices.append(new_device)
 
     add_devices(devices)

homeassistant/components/binary_sensor/knx.py

@@ -1,21 +1,145 @@
 """
-Contains functionality to use a KNX group address as a binary.
+Support for KNX/IP binary sensors.
 
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.knx/
 """
-from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.knx import (KNXConfig, KNXGroupAddress)
+import asyncio
+import voluptuous as vol
 
+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES, \
+    KNXAutomation
+from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, \
+    BinarySensorDevice
+from homeassistant.const import CONF_NAME
+from homeassistant.core import callback
+import homeassistant.helpers.config_validation as cv
+
+CONF_ADDRESS = 'address'
+CONF_DEVICE_CLASS = 'device_class'
+CONF_SIGNIFICANT_BIT = 'significant_bit'
+CONF_DEFAULT_SIGNIFICANT_BIT = 1
+CONF_AUTOMATION = 'automation'
+CONF_HOOK = 'hook'
+CONF_DEFAULT_HOOK = 'on'
+CONF_COUNTER = 'counter'
+CONF_DEFAULT_COUNTER = 1
+CONF_ACTION = 'action'
+
+CONF__ACTION = 'turn_off_action'
+
+DEFAULT_NAME = 'KNX Binary Sensor'
 DEPENDENCIES = ['knx']
 
+AUTOMATION_SCHEMA = vol.Schema({
+    vol.Optional(CONF_HOOK, default=CONF_DEFAULT_HOOK): cv.string,
+    vol.Optional(CONF_COUNTER, default=CONF_DEFAULT_COUNTER): cv.port,
+    vol.Required(CONF_ACTION, default=None): cv.SCRIPT_SCHEMA
+})
 
-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the KNX binary sensor platform."""
-    add_devices([KNXSwitch(hass, KNXConfig(config))])
+AUTOMATIONS_SCHEMA = vol.All(
+    cv.ensure_list,
+    [AUTOMATION_SCHEMA]
+)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ADDRESS): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): cv.string,
+    vol.Optional(CONF_SIGNIFICANT_BIT, default=CONF_DEFAULT_SIGNIFICANT_BIT):
+        cv.positive_int,
+    vol.Optional(CONF_AUTOMATION, default=None): AUTOMATIONS_SCHEMA,
+})
 
 
-class KNXSwitch(KNXGroupAddress, BinarySensorDevice):
-    """Representation of a KNX binary sensor device."""
+@asyncio.coroutine
+def async_setup_platform(hass, config, add_devices,
+                         discovery_info=None):
+    """Set up binary sensor(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False
 
-    pass
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, add_devices)
+    else:
+        async_add_devices_config(hass, config, add_devices)
+
+    return True
+
+
+@callback
+def async_add_devices_discovery(hass, discovery_info, add_devices):
+    """Set up binary sensors for KNX platform configured via xknx.yaml."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXBinarySensor(hass, device))
+    add_devices(entities)
+
+
+@callback
+def async_add_devices_config(hass, config, add_devices):
+    """Set up binary senor for KNX platform configured within plattform."""
+    name = config.get(CONF_NAME)
+    import xknx
+    binary_sensor = xknx.devices.BinarySensor(
+        hass.data[DATA_KNX].xknx,
+        name=name,
+        group_address=config.get(CONF_ADDRESS),
+        device_class=config.get(CONF_DEVICE_CLASS),
+        significant_bit=config.get(CONF_SIGNIFICANT_BIT))
+    hass.data[DATA_KNX].xknx.devices.add(binary_sensor)
+
+    entity = KNXBinarySensor(hass, binary_sensor)
+    automations = config.get(CONF_AUTOMATION)
+    if automations is not None:
+        for automation in automations:
+            counter = automation.get(CONF_COUNTER)
+            hook = automation.get(CONF_HOOK)
+            action = automation.get(CONF_ACTION)
+            entity.automations.append(KNXAutomation(
+                hass=hass, device=binary_sensor, hook=hook,
+                action=action, counter=counter))
+    add_devices([entity])
+
+
+class KNXBinarySensor(BinarySensorDevice):
+    """Representation of a KNX binary sensor."""
+
+    def __init__(self, hass, device):
+        """Initialization of KNXBinarySensor."""
+        self.device = device
+        self.hass = hass
+        self.async_register_callbacks()
+        self.automations = []
+
+    @callback
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
+
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name
+
+    @property
+    def should_poll(self):
+        """No polling needed within KNX."""
+        return False
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return self.device.device_class
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.device.is_on()

homeassistant/components/binary_sensor/mysensors.py

@@ -4,62 +4,27 @@ Support for MySensors binary sensors.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
-from homeassistant.components.binary_sensor import (DEVICE_CLASSES,
+from homeassistant.components.binary_sensor import (DEVICE_CLASSES, DOMAIN,
                                                     BinarySensorDevice)
 from homeassistant.const import STATE_ON
 
-_LOGGER = logging.getLogger(__name__)
-DEPENDENCIES = []
-
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the MySensors platform for sensors."""
-    # Only act if loaded via mysensors by discovery event.
-    # Otherwise gateway is not setup.
-    if discovery_info is None:
-        return
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-    if not gateways:
-        return
-
-    for gateway in gateways:
-        # Define the S_TYPES and V_TYPES that the platform should handle as
-        # states. Map them in a dict of lists.
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-        map_sv_types = {
-            pres.S_DOOR: [set_req.V_TRIPPED],
-            pres.S_MOTION: [set_req.V_TRIPPED],
-            pres.S_SMOKE: [set_req.V_TRIPPED],
-        }
-        if float(gateway.protocol_version) >= 1.5:
-            map_sv_types.update({
-                pres.S_SPRINKLER: [set_req.V_TRIPPED],
-                pres.S_WATER_LEAK: [set_req.V_TRIPPED],
-                pres.S_SOUND: [set_req.V_TRIPPED],
-                pres.S_VIBRATION: [set_req.V_TRIPPED],
-                pres.S_MOISTURE: [set_req.V_TRIPPED],
-            })
-
-        devices = {}
-        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, MySensorsBinarySensor, add_devices))
+    """Setup the mysensors platform for binary sensors."""
+    mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsBinarySensor,
+        add_devices=add_devices)
 
 
 class MySensorsBinarySensor(
-        mysensors.MySensorsDeviceEntity, BinarySensorDevice):
+        mysensors.MySensorsEntity, BinarySensorDevice):
     """Represent the value of a MySensors Binary Sensor child node."""
 
     @property
     def is_on(self):
         """Return True if the binary sensor is on."""
-        if self.value_type in self._values:
-            return self._values[self.value_type] == STATE_ON
-        return False
+        return self._values.get(self.value_type) == STATE_ON
 
     @property
     def device_class(self):

homeassistant/components/binary_sensor/ring.py

@@ -103,7 +103,8 @@ class RingBinarySensor(BinarySensorDevice):
         self._data.check_alerts()
 
         if self._data.alert:
-            self._state = (self._sensor_type ==
-                           self._data.alert.get('kind'))
+            if self._sensor_type == self._data.alert.get('kind') and \
+               self._data.account_id == self._data.alert.get('doorbot_id'):
+                self._state = True
         else:
             self._state = False

homeassistant/components/binary_sensor/template.py

@@ -19,16 +19,24 @@ from homeassistant.const import (
 from homeassistant.exceptions import TemplateError
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
-from homeassistant.helpers.event import async_track_state_change
+from homeassistant.helpers.event import (
+    async_track_state_change, async_track_same_state)
 from homeassistant.helpers.restore_state import async_get_last_state
 
 _LOGGER = logging.getLogger(__name__)
 
+CONF_DELAY_ON = 'delay_on'
+CONF_DELAY_OFF = 'delay_off'
+
 SENSOR_SCHEMA = vol.Schema({
     vol.Required(CONF_VALUE_TEMPLATE): cv.template,
     vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
     vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_DELAY_ON):
+        vol.All(cv.time_period, cv.positive_timedelta),
+    vol.Optional(CONF_DELAY_OFF):
+        vol.All(cv.time_period, cv.positive_timedelta),
 })
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -47,6 +55,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
                       value_template.extract_entities())
         friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
         device_class = device_config.get(CONF_DEVICE_CLASS)
+        delay_on = device_config.get(CONF_DELAY_ON)
+        delay_off = device_config.get(CONF_DELAY_OFF)
 
         if value_template is not None:
             value_template.hass = hass
@@ -54,13 +64,13 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
         sensors.append(
             BinarySensorTemplate(
                 hass, device, friendly_name, device_class, value_template,
-                entity_ids)
+                entity_ids, delay_on, delay_off)
             )
     if not sensors:
         _LOGGER.error("No sensors added")
         return False
 
-    async_add_devices(sensors, True)
+    async_add_devices(sensors)
     return True
 
 
@@ -68,7 +78,7 @@ class BinarySensorTemplate(BinarySensorDevice):
     """A virtual binary sensor that triggers from another sensor."""
 
     def __init__(self, hass, device, friendly_name, device_class,
-                 value_template, entity_ids):
+                 value_template, entity_ids, delay_on, delay_off):
         """Initialize the Template binary sensor."""
         self.hass = hass
         self.entity_id = async_generate_entity_id(
@@ -78,6 +88,8 @@ class BinarySensorTemplate(BinarySensorDevice):
         self._template = value_template
         self._state = None
         self._entities = entity_ids
+        self._delay_on = delay_on
+        self._delay_off = delay_off
 
     @asyncio.coroutine
     def async_added_to_hass(self):
@@ -89,7 +101,7 @@ class BinarySensorTemplate(BinarySensorDevice):
         @callback
         def template_bsensor_state_listener(entity, old_state, new_state):
             """Handle the target device state changes."""
-            self.hass.async_add_job(self.async_update_ha_state(True))
+            self.async_check_state()
 
         @callback
         def template_bsensor_startup(event):
@@ -97,7 +109,7 @@ class BinarySensorTemplate(BinarySensorDevice):
             async_track_state_change(
                 self.hass, self._entities, template_bsensor_state_listener)
 
-            self.hass.async_add_job(self.async_update_ha_state(True))
+            self.hass.async_add_job(self.async_check_state)
 
         self.hass.bus.async_listen_once(
             EVENT_HOMEASSISTANT_START, template_bsensor_startup)
@@ -122,11 +134,11 @@ class BinarySensorTemplate(BinarySensorDevice):
         """No polling needed."""
         return False
 
-    @asyncio.coroutine
-    def async_update(self):
-        """Update the state from the template."""
+    @callback
+    def _async_render(self, *args):
+        """Get the state of template."""
         try:
-            self._state = self._template.async_render().lower() == 'true'
+            return self._template.async_render().lower() == 'true'
         except TemplateError as ex:
             if ex.args and ex.args[0].startswith(
                     "UndefinedError: 'None' has no attribute"):
@@ -135,4 +147,29 @@ class BinarySensorTemplate(BinarySensorDevice):
                                 "the state is unknown", self._name)
                 return
             _LOGGER.error("Could not render template %s: %s", self._name, ex)
-            self._state = False
+
+    @callback
+    def async_check_state(self):
+        """Update the state from the template."""
+        state = self._async_render()
+
+        # return if the state don't change or is invalid
+        if state is None or state == self.state:
+            return
+
+        @callback
+        def set_state():
+            """Set state of template binary sensor."""
+            self._state = state
+            self.hass.async_add_job(self.async_update_ha_state())
+
+        # state without delay
+        if (state and not self._delay_on) or \
+                (not state and not self._delay_off):
+            set_state()
+            return
+
+        period = self._delay_on if state else self._delay_off
+        async_track_same_state(
+            self.hass, state, period, set_state, entity_ids=self._entities,
+            async_check_func=self._async_render)

homeassistant/components/binary_sensor/tesla.py

@@ -0,0 +1,57 @@
+"""
+Support for Tesla binary sensor.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.tesla/
+"""
+import logging
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, ENTITY_ID_FORMAT)
+from homeassistant.components.tesla import DOMAIN as TESLA_DOMAIN, TeslaDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['tesla']
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Tesla binary sensor."""
+    devices = [
+        TeslaBinarySensor(
+            device, hass.data[TESLA_DOMAIN]['controller'], 'connectivity')
+        for device in hass.data[TESLA_DOMAIN]['devices']['binary_sensor']]
+    add_devices(devices, True)
+
+
+class TeslaBinarySensor(TeslaDevice, BinarySensorDevice):
+    """Implement an Tesla binary sensor for parking and charger."""
+
+    def __init__(self, tesla_device, controller, sensor_type):
+        """Initialisation of binary sensor."""
+        super().__init__(tesla_device, controller)
+        self._name = self.tesla_device.name
+        self._state = False
+        self.entity_id = ENTITY_ID_FORMAT.format(self.tesla_id)
+        self._sensor_type = sensor_type
+
+    @property
+    def device_class(self):
+        """Return the class of this binary sensor."""
+        return self._sensor_type
+
+    @property
+    def name(self):
+        """Return the name of the binary sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the binary sensor."""
+        return self._state
+
+    def update(self):
+        """Update the state of the device."""
+        _LOGGER.debug("Updating sensor: %s", self._name)
+        self.tesla_device.update()
+        self._state = self.tesla_device.get_value()

homeassistant/components/binary_sensor/workday.py

@@ -6,13 +6,12 @@ https://home-assistant.io/components/binary_sensor.workday/
 """
 import asyncio
 import logging
-import datetime
+from datetime import datetime, timedelta
 
 import voluptuous as vol
 
 from homeassistant.components.sensor import PLATFORM_SCHEMA
 from homeassistant.const import CONF_NAME, WEEKDAYS
-import homeassistant.util.dt as dt_util
 from homeassistant.components.binary_sensor import BinarySensorDevice
 import homeassistant.helpers.config_validation as cv
 
@@ -39,11 +38,14 @@ CONF_EXCLUDES = 'excludes'
 DEFAULT_EXCLUDES = ['sat', 'sun', 'holiday']
 DEFAULT_NAME = 'Workday Sensor'
 ALLOWED_DAYS = WEEKDAYS + ['holiday']
+CONF_OFFSET = 'days_offset'
+DEFAULT_OFFSET = 0
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_COUNTRY): vol.In(ALL_COUNTRIES),
     vol.Optional(CONF_PROVINCE, default=None): cv.string,
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_OFFSET, default=DEFAULT_OFFSET): vol.Coerce(int),
     vol.Optional(CONF_WORKDAYS, default=DEFAULT_WORKDAYS):
         vol.All(cv.ensure_list, [vol.In(ALLOWED_DAYS)]),
     vol.Optional(CONF_EXCLUDES, default=DEFAULT_EXCLUDES):
@@ -60,8 +62,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     province = config.get(CONF_PROVINCE)
     workdays = config.get(CONF_WORKDAYS)
     excludes = config.get(CONF_EXCLUDES)
+    days_offset = config.get(CONF_OFFSET)
 
-    year = datetime.datetime.now().year
+    year = (datetime.now() + timedelta(days=days_offset)).year
     obj_holidays = getattr(holidays, country)(years=year)
 
     if province:
@@ -85,7 +88,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         _LOGGER.debug("%s %s", date, name)
 
     add_devices([IsWorkdaySensor(
-        obj_holidays, workdays, excludes, sensor_name)], True)
+        obj_holidays, workdays, excludes, days_offset, sensor_name)], True)
 
 
 def day_to_string(day):
@@ -99,12 +102,13 @@ def day_to_string(day):
 class IsWorkdaySensor(BinarySensorDevice):
     """Implementation of a Workday sensor."""
 
-    def __init__(self, obj_holidays, workdays, excludes, name):
+    def __init__(self, obj_holidays, workdays, excludes, days_offset, name):
         """Initialize the Workday sensor."""
         self._name = name
         self._obj_holidays = obj_holidays
         self._workdays = workdays
         self._excludes = excludes
+        self._days_offset = days_offset
         self._state = None
 
     @property
@@ -135,6 +139,16 @@ class IsWorkdaySensor(BinarySensorDevice):
 
         return False
 
+    @property
+    def state_attributes(self):
+        """Return the attributes of the entity."""
+        # return self._attributes
+        return {
+            CONF_WORKDAYS: self._workdays,
+            CONF_EXCLUDES: self._excludes,
+            CONF_OFFSET: self._days_offset
+        }
+
     @asyncio.coroutine
     def async_update(self):
         """Get date and look whether it is a holiday."""
@@ -142,11 +156,12 @@ class IsWorkdaySensor(BinarySensorDevice):
         self._state = False
 
         # Get iso day of the week (1 = Monday, 7 = Sunday)
-        day = datetime.datetime.today().isoweekday() - 1
+        date = datetime.today() + timedelta(days=self._days_offset)
+        day = date.isoweekday() - 1
         day_of_week = day_to_string(day)
 
-        if self.is_include(day_of_week, dt_util.now()):
+        if self.is_include(day_of_week, date):
             self._state = True
 
-        if self.is_exclude(day_of_week, dt_util.now()):
+        if self.is_exclude(day_of_week, date):
             self._state = False

homeassistant/components/binary_sensor/xiaomi.py

@@ -31,6 +31,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 devices.append(XiaomiDoorSensor(device, gateway))
             elif model == 'sensor_magnet.aq2':
                 devices.append(XiaomiDoorSensor(device, gateway))
+            elif model == 'sensor_wleak.aq1':
+                devices.append(XiaomiWaterLeakSensor(device, gateway))
             elif model == 'smoke':
                 devices.append(XiaomiSmokeSensor(device, gateway))
             elif model == 'natgas':
@@ -214,6 +216,35 @@ class XiaomiDoorSensor(XiaomiBinarySensor):
             return False
 
 
+class XiaomiWaterLeakSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiWaterLeakSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiWaterLeakSensor."""
+        XiaomiBinarySensor.__init__(self, device, 'Water Leak Sensor',
+                                    xiaomi_hub, 'status', 'moisture')
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        self._should_poll = False
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == 'leak':
+            self._should_poll = True
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == 'no_leak':
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
 class XiaomiSmokeSensor(XiaomiBinarySensor):
     """Representation of a XiaomiSmokeSensor."""
 

homeassistant/components/camera/foscam.py

@@ -53,7 +53,7 @@ class FoscamCam(Camera):
         self._name = device_info.get(CONF_NAME)
         self._motion_status = False
 
-        from foscam import FoscamCamera
+        from foscam.foscam import FoscamCamera
 
         self._foscam_session = FoscamCamera(ip_address, port, self._username,
                                             self._password, verbose=False)

homeassistant/components/camera/usps.py

@@ -0,0 +1,94 @@
+"""
+Support for a camera made up of usps mail images.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/camera.usps/
+"""
+from datetime import timedelta
+import logging
+
+from homeassistant.components.camera import Camera
+from homeassistant.components.usps import DATA_USPS
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['usps']
+
+SCAN_INTERVAL = timedelta(seconds=10)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up USPS mail camera."""
+    if discovery_info is None:
+        return
+
+    usps = hass.data[DATA_USPS]
+    add_devices([USPSCamera(usps)])
+
+
+class USPSCamera(Camera):
+    """Representation of the images available from USPS."""
+
+    def __init__(self, usps):
+        """Initialize the USPS camera images."""
+        super().__init__()
+
+        self._usps = usps
+        self._name = self._usps.name
+        self._session = self._usps.session
+
+        self._mail_img = []
+        self._last_mail = None
+        self._mail_index = 0
+        self._mail_count = 0
+
+        self._timer = None
+
+    def camera_image(self):
+        """Update the camera's image if it has changed."""
+        self._usps.update()
+        try:
+            self._mail_count = len(self._usps.mail)
+        except TypeError:
+            # No mail
+            return None
+
+        if self._usps.mail != self._last_mail:
+            # Mail items must have changed
+            self._mail_img = []
+            if len(self._usps.mail) >= 1:
+                self._last_mail = self._usps.mail
+                for article in self._usps.mail:
+                    _LOGGER.debug("Fetching article image: %s", article)
+                    img = self._session.get(article['image']).content
+                    self._mail_img.append(img)
+
+        try:
+            return self._mail_img[self._mail_index]
+        except IndexError:
+            return None
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return '{} mail'.format(self._name)
+
+    @property
+    def model(self):
+        """Return date of mail as model."""
+        try:
+            return 'Date: {}'.format(self._usps.mail[0]['date'])
+        except IndexError:
+            return None
+
+    @property
+    def should_poll(self):
+        """Update the mail image index periodically."""
+        return True
+
+    def update(self):
+        """Update mail image index."""
+        if self._mail_index < (self._mail_count - 1):
+            self._mail_index += 1
+        else:
+            self._mail_index = 0

homeassistant/components/climate/homematic.py

@@ -47,8 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     devices = []
     for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMThermostat(hass, conf)
-        new_device.link_homematic()
+        new_device = HMThermostat(conf)
         devices.append(new_device)
 
     add_devices(devices)

homeassistant/components/climate/honeywell.py

@@ -196,6 +196,11 @@ class RoundThermostat(ClimateDevice):
                 if val['id'] == self._id:
                     data = val
 
+        except KeyError:
+            _LOGGER.error("Update failed from Honeywell server")
+            self.client.user_data = None
+            return
+
         except StopIteration:
             _LOGGER.error("Did not receive any temperature data from the "
                           "evohomeclient API")

homeassistant/components/climate/knx.py

@@ -1,68 +1,136 @@
 """
-Support for KNX thermostats.
+Support for KNX/IP climate devices.
 
-For more details about this platform, please refer to the documentation
+For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.knx/
 """
-import logging
-
+import asyncio
 import voluptuous as vol
 
-from homeassistant.components.climate import (ClimateDevice, PLATFORM_SCHEMA)
-from homeassistant.components.knx import (KNXConfig, KNXMultiAddressDevice)
-from homeassistant.const import (CONF_NAME, TEMP_CELSIUS, ATTR_TEMPERATURE)
+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES
+from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateDevice
+from homeassistant.const import CONF_NAME, TEMP_CELSIUS, ATTR_TEMPERATURE
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
-_LOGGER = logging.getLogger(__name__)
-
-CONF_ADDRESS = 'address'
 CONF_SETPOINT_ADDRESS = 'setpoint_address'
 CONF_TEMPERATURE_ADDRESS = 'temperature_address'
+CONF_TARGET_TEMPERATURE_ADDRESS = 'target_temperature_address'
+CONF_OPERATION_MODE_ADDRESS = 'operation_mode_address'
+CONF_OPERATION_MODE_STATE_ADDRESS = 'operation_mode_state_address'
+CONF_CONTROLLER_STATUS_ADDRESS = 'controller_status_address'
+CONF_CONTROLLER_STATUS_STATE_ADDRESS = 'controller_status_state_address'
+CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS = \
+    'operation_mode_frost_protection_address'
+CONF_OPERATION_MODE_NIGHT_ADDRESS = 'operation_mode_night_address'
+CONF_OPERATION_MODE_COMFORT_ADDRESS = 'operation_mode_comfort_address'
 
-DEFAULT_NAME = 'KNX Thermostat'
+DEFAULT_NAME = 'KNX Climate'
 DEPENDENCIES = ['knx']
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_ADDRESS): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Required(CONF_SETPOINT_ADDRESS): cv.string,
     vol.Required(CONF_TEMPERATURE_ADDRESS): cv.string,
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Required(CONF_TARGET_TEMPERATURE_ADDRESS): cv.string,
+    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,
+    vol.Optional(CONF_CONTROLLER_STATUS_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_NIGHT_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_COMFORT_ADDRESS): cv.string,
 })
 
 
-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Create and add an entity based on the configuration."""
-    add_devices([KNXThermostat(hass, KNXConfig(config))])
+@asyncio.coroutine
+def async_setup_platform(hass, config, add_devices,
+                         discovery_info=None):
+    """Set up climate(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False
+
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, add_devices)
+    else:
+        async_add_devices_config(hass, config, add_devices)
+
+    return True
 
 
-class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
-    """Representation of a KNX thermostat.
+@callback
+def async_add_devices_discovery(hass, discovery_info, add_devices):
+    """Set up climates for KNX platform configured within plattform."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXClimate(hass, device))
+    add_devices(entities)
 
-    A KNX thermostat will has the following parameters:
-    - temperature (current temperature)
-    - setpoint (target temperature in HASS terms)
-    - operation mode selection (comfort/night/frost protection)
 
-    This version supports only polling. Messages from the KNX bus do not
-    automatically update the state of the thermostat (to be implemented
-    in future releases)
-    """
+@callback
+def async_add_devices_config(hass, config, 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),
+        group_address_temperature=config.get(
+            CONF_TEMPERATURE_ADDRESS),
+        group_address_target_temperature=config.get(
+            CONF_TARGET_TEMPERATURE_ADDRESS),
+        group_address_setpoint=config.get(
+            CONF_SETPOINT_ADDRESS),
+        group_address_operation_mode=config.get(
+            CONF_OPERATION_MODE_ADDRESS),
+        group_address_operation_mode_state=config.get(
+            CONF_OPERATION_MODE_STATE_ADDRESS),
+        group_address_controller_status=config.get(
+            CONF_CONTROLLER_STATUS_ADDRESS),
+        group_address_controller_status_state=config.get(
+            CONF_CONTROLLER_STATUS_STATE_ADDRESS),
+        group_address_operation_mode_protection=config.get(
+            CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS),
+        group_address_operation_mode_night=config.get(
+            CONF_OPERATION_MODE_NIGHT_ADDRESS),
+        group_address_operation_mode_comfort=config.get(
+            CONF_OPERATION_MODE_COMFORT_ADDRESS))
+    hass.data[DATA_KNX].xknx.devices.add(climate)
+    add_devices([KNXClimate(hass, climate)])
 
-    def __init__(self, hass, config):
-        """Initialize the thermostat based on the given configuration."""
-        KNXMultiAddressDevice.__init__(
-            self, hass, config, ['temperature', 'setpoint'], ['mode'])
 
-        self._unit_of_measurement = TEMP_CELSIUS  # KNX always used celsius
+class KNXClimate(ClimateDevice):
+    """Representation of a KNX climate."""
+
+    def __init__(self, hass, device):
+        """Initialization of KNXClimate."""
+        self.device = device
+        self.hass = hass
+        self.async_register_callbacks()
+
+        self._unit_of_measurement = TEMP_CELSIUS
         self._away = False  # not yet supported
         self._is_fan_on = False  # not yet supported
-        self._current_temp = None
-        self._target_temp = None
+
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
+
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name
 
     @property
     def should_poll(self):
-        """Return the polling state, is needed for the KNX thermostat."""
-        return True
+        """No polling needed within KNX."""
+        return False
 
     @property
     def temperature_unit(self):
@@ -72,32 +140,42 @@ class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
     @property
     def current_temperature(self):
         """Return the current temperature."""
-        return self._current_temp
+        return self.device.temperature
 
     @property
     def target_temperature(self):
         """Return the temperature we try to reach."""
-        return self._target_temp
+        if self.device.supports_target_temperature:
+            return self.device.target_temperature
+        return None
 
-    def set_temperature(self, **kwargs):
+    @asyncio.coroutine
+    def async_set_temperature(self, **kwargs):
         """Set new target temperature."""
         temperature = kwargs.get(ATTR_TEMPERATURE)
         if temperature is None:
             return
-        from knxip.conversion import float_to_knx2
+        if self.device.supports_target_temperature:
+            yield from self.device.set_target_temperature(temperature)
 
-        self.set_value('setpoint', float_to_knx2(temperature))
-        _LOGGER.debug("Set target temperature to %s", temperature)
+    @property
+    def current_operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        if self.device.supports_operation_mode:
+            return self.device.operation_mode.value
+        return None
 
-    def set_operation_mode(self, operation_mode):
+    @property
+    def operation_list(self):
+        """Return the list of available operation modes."""
+        return [operation_mode.value for
+                operation_mode in
+                self.device.get_supported_operation_modes()]
+
+    @asyncio.coroutine
+    def async_set_operation_mode(self, operation_mode):
         """Set operation mode."""
-        raise NotImplementedError()
-
-    def update(self):
-        """Update KNX climate."""
-        from knxip.conversion import knx2_to_float
-
-        super().update()
-
-        self._current_temp = knx2_to_float(self.value('temperature'))
-        self._target_temp = knx2_to_float(self.value('setpoint'))
+        if self.device.supports_operation_mode:
+            from xknx.knx import HVACOperationMode
+            knx_operation_mode = HVACOperationMode(operation_mode)
+            yield from self.device.set_operation_mode(knx_operation_mode)

homeassistant/components/climate/mysensors.py

@@ -4,15 +4,11 @@ MySensors platform that offers a Climate (MySensors-HVAC) component.
 For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/climate.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
 from homeassistant.components.climate import (
-    STATE_COOL, STATE_HEAT, STATE_OFF, STATE_AUTO, ClimateDevice,
-    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW)
-from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, ATTR_TEMPERATURE
-
-_LOGGER = logging.getLogger(__name__)
+    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW, DOMAIN, STATE_AUTO,
+    STATE_COOL, STATE_HEAT, STATE_OFF, ClimateDevice)
+from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS, TEMP_FAHRENHEIT
 
 DICT_HA_TO_MYS = {
     STATE_AUTO: 'AutoChangeOver',
@@ -29,28 +25,12 @@ DICT_MYS_TO_HA = {
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the mysensors climate."""
-    if discovery_info is None:
-        return
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-    if not gateways:
-        return
-
-    for gateway in gateways:
-        if float(gateway.protocol_version) < 1.5:
-            continue
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-        map_sv_types = {
-            pres.S_HVAC: [set_req.V_HVAC_FLOW_STATE],
-        }
-        devices = {}
-        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, MySensorsHVAC, add_devices))
+    """Setup the mysensors climate."""
+    mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsHVAC, add_devices=add_devices)
 
 
-class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
+class MySensorsHVAC(mysensors.MySensorsEntity, ClimateDevice):
     """Representation of a MySensors HVAC."""
 
     @property
@@ -84,26 +64,28 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
         temp = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
         if temp is None:
             temp = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
-        return float(temp)
+        return float(temp) if temp is not None else None
 
     @property
     def target_temperature_high(self):
         """Return the highbound target temperature we try to reach."""
         set_req = self.gateway.const.SetReq
         if set_req.V_HVAC_SETPOINT_HEAT in self._values:
-            return float(self._values.get(set_req.V_HVAC_SETPOINT_COOL))
+            temp = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
+            return float(temp) if temp is not None else None
 
     @property
     def target_temperature_low(self):
         """Return the lowbound target temperature we try to reach."""
         set_req = self.gateway.const.SetReq
         if set_req.V_HVAC_SETPOINT_COOL in self._values:
-            return float(self._values.get(set_req.V_HVAC_SETPOINT_HEAT))
+            temp = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
+            return float(temp) if temp is not None else None
 
     @property
     def current_operation(self):
         """Return current operation ie. heat, cool, idle."""
-        return self._values.get(self.gateway.const.SetReq.V_HVAC_FLOW_STATE)
+        return self._values.get(self.value_type)
 
     @property
     def operation_list(self):
@@ -128,7 +110,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
         high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
         heat = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
         cool = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
-        updates = ()
+        updates = []
         if temp is not None:
             if heat is not None:
                 # Set HEAT Target temperature
@@ -146,7 +128,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
             self.gateway.set_child_value(
                 self.node_id, self.child_id, value_type, value)
             if self.gateway.optimistic:
-                # optimistically assume that switch has changed state
+                # optimistically assume that device has changed state
                 self._values[value_type] = value
                 self.schedule_update_ha_state()
 
@@ -156,54 +138,22 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
         self.gateway.set_child_value(
             self.node_id, self.child_id, set_req.V_HVAC_SPEED, fan)
         if self.gateway.optimistic:
-            # optimistically assume that switch has changed state
+            # optimistically assume that device has changed state
             self._values[set_req.V_HVAC_SPEED] = fan
             self.schedule_update_ha_state()
 
     def set_operation_mode(self, operation_mode):
         """Set new target temperature."""
-        set_req = self.gateway.const.SetReq
         self.gateway.set_child_value(
-            self.node_id, self.child_id, set_req.V_HVAC_FLOW_STATE,
+            self.node_id, self.child_id, self.value_type,
             DICT_HA_TO_MYS[operation_mode])
         if self.gateway.optimistic:
-            # optimistically assume that switch has changed state
-            self._values[set_req.V_HVAC_FLOW_STATE] = operation_mode
+            # optimistically assume that device has changed state
+            self._values[self.value_type] = operation_mode
             self.schedule_update_ha_state()
 
     def update(self):
         """Update the controller with the latest value from a sensor."""
-        set_req = self.gateway.const.SetReq
-        node = self.gateway.sensors[self.node_id]
-        child = node.children[self.child_id]
-        for value_type, value in child.values.items():
-            _LOGGER.debug(
-                "%s: value_type %s, value = %s", self._name, value_type, value)
-            if value_type == set_req.V_HVAC_FLOW_STATE:
-                self._values[value_type] = DICT_MYS_TO_HA[value]
-            else:
-                self._values[value_type] = value
-
-    def set_humidity(self, humidity):
-        """Set new target humidity."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def set_swing_mode(self, swing_mode):
-        """Set new target swing operation."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_away_mode_on(self):
-        """Turn away mode on."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_away_mode_off(self):
-        """Turn away mode off."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_aux_heat_on(self):
-        """Turn auxillary heater on."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_aux_heat_off(self):
-        """Turn auxillary heater off."""
-        _LOGGER.error("Service Not Implemented yet")
+        super().update()
+        self._values[self.value_type] = DICT_MYS_TO_HA[
+            self._values[self.value_type]]

homeassistant/components/climate/tesla.py

@@ -0,0 +1,93 @@
+"""
+Support for Tesla HVAC system.
+
+For more details about this platform, please refer to the documentation
+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.tesla import DOMAIN as TESLA_DOMAIN, TeslaDevice
+from homeassistant.const import (
+    TEMP_FAHRENHEIT, TEMP_CELSIUS, ATTR_TEMPERATURE)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['tesla']
+
+OPERATION_LIST = [STATE_ON, STATE_OFF]
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Tesla climate platform."""
+    devices = [TeslaThermostat(device, hass.data[TESLA_DOMAIN]['controller'])
+               for device in hass.data[TESLA_DOMAIN]['devices']['climate']]
+    add_devices(devices, True)
+
+
+class TeslaThermostat(TeslaDevice, ClimateDevice):
+    """Representation of a Tesla climate."""
+
+    def __init__(self, tesla_device, controller):
+        """Initialize the Tesla device."""
+        super().__init__(tesla_device, controller)
+        self.entity_id = ENTITY_ID_FORMAT.format(self.tesla_id)
+        self._target_temperature = None
+        self._temperature = None
+        self._name = self.tesla_device.name
+
+    @property
+    def current_operation(self):
+        """Return current operation ie. On or Off."""
+        mode = self.tesla_device.is_hvac_enabled()
+        if mode:
+            return OPERATION_LIST[0]  # On
+        else:
+            return OPERATION_LIST[1]  # Off
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        return OPERATION_LIST
+
+    def update(self):
+        """Called by the Tesla device callback to update state."""
+        _LOGGER.debug("Updating: %s", self._name)
+        self.tesla_device.update()
+        self._target_temperature = self.tesla_device.get_goal_temp()
+        self._temperature = self.tesla_device.get_current_temp()
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        tesla_temp_units = self.tesla_device.measurement
+
+        if tesla_temp_units == 'F':
+            return TEMP_FAHRENHEIT
+        return TEMP_CELSIUS
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self._temperature
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._target_temperature
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperatures."""
+        _LOGGER.debug("Setting temperature for: %s", self._name)
+        temperature = kwargs.get(ATTR_TEMPERATURE)
+        if temperature:
+            self.tesla_device.set_temperature(temperature)
+
+    def set_operation_mode(self, operation_mode):
+        """Set HVAC mode (auto, cool, heat, off)."""
+        _LOGGER.debug("Setting mode for: %s", self._name)
+        if operation_mode == OPERATION_LIST[1]:  # off
+            self.tesla_device.set_status(False)
+        elif operation_mode == OPERATION_LIST[0]:  # heat
+            self.tesla_device.set_status(True)

homeassistant/components/cloud/__init__.py

@@ -0,0 +1,49 @@
+"""Component to integrate the Home Assistant cloud."""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from . import http_api, cloud_api
+from .const import DOMAIN
+
+
+DEPENDENCIES = ['http']
+CONF_MODE = 'mode'
+MODE_DEV = 'development'
+MODE_STAGING = 'staging'
+MODE_PRODUCTION = 'production'
+DEFAULT_MODE = MODE_DEV
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Optional(CONF_MODE, default=DEFAULT_MODE):
+        vol.In([MODE_DEV, MODE_STAGING, MODE_PRODUCTION]),
+    }),
+}, extra=vol.ALLOW_EXTRA)
+_LOGGER = logging.getLogger(__name__)
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Initialize the Home Assistant cloud."""
+    mode = MODE_PRODUCTION
+
+    if DOMAIN in config:
+        mode = config[DOMAIN].get(CONF_MODE)
+
+    if mode != 'development':
+        _LOGGER.error('Only development mode is currently allowed.')
+        return False
+
+    data = hass.data[DOMAIN] = {
+        'mode': mode
+    }
+
+    cloud = yield from cloud_api.async_load_auth(hass)
+
+    if cloud is not None:
+        data['cloud'] = cloud
+
+    yield from http_api.async_setup(hass)
+    return True

homeassistant/components/cloud/cloud_api.py

@@ -0,0 +1,297 @@
+"""Package to offer tools to communicate with the cloud."""
+import asyncio
+from datetime import timedelta
+import json
+import logging
+import os
+from urllib.parse import urljoin
+
+import aiohttp
+import async_timeout
+
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.util.dt import utcnow
+
+from .const import AUTH_FILE, REQUEST_TIMEOUT, SERVERS
+from .util import get_mode
+
+_LOGGER = logging.getLogger(__name__)
+
+
+URL_CREATE_TOKEN = 'o/token/'
+URL_REVOKE_TOKEN = 'o/revoke_token/'
+URL_ACCOUNT = 'account.json'
+
+
+class CloudError(Exception):
+    """Base class for cloud related errors."""
+
+    def __init__(self, reason=None, status=None):
+        """Initialize a cloud error."""
+        super().__init__(reason)
+        self.status = status
+
+
+class Unauthenticated(CloudError):
+    """Raised when authentication failed."""
+
+
+class UnknownError(CloudError):
+    """Raised when an unknown error occurred."""
+
+
+@asyncio.coroutine
+def async_load_auth(hass):
+    """Load authentication from disk and verify it."""
+    auth = yield from hass.async_add_job(_read_auth, hass)
+
+    if not auth:
+        return None
+
+    cloud = Cloud(hass, auth)
+
+    try:
+        with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
+            auth_check = yield from cloud.async_refresh_account_info()
+
+            if not auth_check:
+                _LOGGER.error('Unable to validate credentials.')
+                return None
+
+            return cloud
+
+    except asyncio.TimeoutError:
+        _LOGGER.error('Unable to reach server to validate credentials.')
+        return None
+
+
+@asyncio.coroutine
+def async_login(hass, username, password, scope=None):
+    """Get a token using a username and password.
+
+    Returns a coroutine.
+    """
+    data = {
+        'grant_type': 'password',
+        'username': username,
+        'password': password
+    }
+    if scope is not None:
+        data['scope'] = scope
+
+    auth = yield from _async_get_token(hass, data)
+
+    yield from hass.async_add_job(_write_auth, hass, auth)
+
+    return Cloud(hass, auth)
+
+
+@asyncio.coroutine
+def _async_get_token(hass, data):
+    """Get a new token and return it as a dictionary.
+
+    Raises exceptions when errors occur:
+     - Unauthenticated
+     - UnknownError
+    """
+    session = async_get_clientsession(hass)
+    auth = aiohttp.BasicAuth(*_client_credentials(hass))
+
+    try:
+        req = yield from session.post(
+            _url(hass, URL_CREATE_TOKEN),
+            data=data,
+            auth=auth
+        )
+
+        if req.status == 401:
+            _LOGGER.error('Cloud login failed: %d', req.status)
+            raise Unauthenticated(status=req.status)
+        elif req.status != 200:
+            _LOGGER.error('Cloud login failed: %d', req.status)
+            raise UnknownError(status=req.status)
+
+        response = yield from req.json()
+        response['expires_at'] = \
+            (utcnow() + timedelta(seconds=response['expires_in'])).isoformat()
+
+        return response
+
+    except aiohttp.ClientError:
+        raise UnknownError()
+
+
+class Cloud:
+    """Store Hass Cloud info."""
+
+    def __init__(self, hass, auth):
+        """Initialize Hass cloud info object."""
+        self.hass = hass
+        self.auth = auth
+        self.account = None
+
+    @property
+    def access_token(self):
+        """Return access token."""
+        return self.auth['access_token']
+
+    @property
+    def refresh_token(self):
+        """Get refresh token."""
+        return self.auth['refresh_token']
+
+    @asyncio.coroutine
+    def async_refresh_account_info(self):
+        """Refresh the account info."""
+        req = yield from self.async_request('get', URL_ACCOUNT)
+
+        if req.status != 200:
+            return False
+
+        self.account = yield from req.json()
+        return True
+
+    @asyncio.coroutine
+    def async_refresh_access_token(self):
+        """Get a token using a refresh token."""
+        try:
+            self.auth = yield from _async_get_token(self.hass, {
+                'grant_type': 'refresh_token',
+                'refresh_token': self.refresh_token,
+            })
+
+            yield from self.hass.async_add_job(
+                _write_auth, self.hass, self.auth)
+
+            return True
+        except CloudError:
+            return False
+
+    @asyncio.coroutine
+    def async_revoke_access_token(self):
+        """Revoke active access token."""
+        session = async_get_clientsession(self.hass)
+        client_id, client_secret = _client_credentials(self.hass)
+        data = {
+            'token': self.access_token,
+            'client_id': client_id,
+            'client_secret': client_secret
+        }
+        try:
+            req = yield from session.post(
+                _url(self.hass, URL_REVOKE_TOKEN),
+                data=data,
+            )
+
+            if req.status != 200:
+                _LOGGER.error('Cloud logout failed: %d', req.status)
+                raise UnknownError(status=req.status)
+
+            self.auth = None
+            yield from self.hass.async_add_job(
+                _write_auth, self.hass, None)
+
+        except aiohttp.ClientError:
+            raise UnknownError()
+
+    @asyncio.coroutine
+    def async_request(self, method, path, **kwargs):
+        """Make a request to Home Assistant cloud.
+
+        Will refresh the token if necessary.
+        """
+        session = async_get_clientsession(self.hass)
+        url = _url(self.hass, path)
+
+        if 'headers' not in kwargs:
+            kwargs['headers'] = {}
+
+        kwargs['headers']['authorization'] = \
+            'Bearer {}'.format(self.access_token)
+
+        request = yield from session.request(method, url, **kwargs)
+
+        if request.status != 403:
+            return request
+
+        # Maybe token expired. Try refreshing it.
+        reauth = yield from self.async_refresh_access_token()
+
+        if not reauth:
+            return request
+
+        # Release old connection back to the pool.
+        yield from request.release()
+
+        kwargs['headers']['authorization'] = \
+            'Bearer {}'.format(self.access_token)
+
+        # If we are not already fetching the account info,
+        # refresh the account info.
+
+        if path != URL_ACCOUNT:
+            yield from self.async_refresh_account_info()
+
+        request = yield from session.request(method, url, **kwargs)
+
+        return request
+
+
+def _read_auth(hass):
+    """Read auth file."""
+    path = hass.config.path(AUTH_FILE)
+
+    if not os.path.isfile(path):
+        return None
+
+    with open(path) as file:
+        return json.load(file).get(get_mode(hass))
+
+
+def _write_auth(hass, data):
+    """Write auth info for specified mode.
+
+    Pass in None for data to remove authentication for that mode.
+    """
+    path = hass.config.path(AUTH_FILE)
+    mode = get_mode(hass)
+
+    if os.path.isfile(path):
+        with open(path) as file:
+            content = json.load(file)
+    else:
+        content = {}
+
+    if data is None:
+        content.pop(mode, None)
+    else:
+        content[mode] = data
+
+    with open(path, 'wt') as file:
+        file.write(json.dumps(content, indent=4, sort_keys=True))
+
+
+def _client_credentials(hass):
+    """Get the client credentials.
+
+    Async friendly.
+    """
+    mode = get_mode(hass)
+
+    if mode not in SERVERS:
+        raise ValueError('Mode {} is not supported.'.format(mode))
+
+    return SERVERS[mode]['client_id'], SERVERS[mode]['client_secret']
+
+
+def _url(hass, path):
+    """Generate a url for the cloud.
+
+    Async friendly.
+    """
+    mode = get_mode(hass)
+
+    if mode not in SERVERS:
+        raise ValueError('Mode {} is not supported.'.format(mode))
+
+    return urljoin(SERVERS[mode]['host'], path)

homeassistant/components/cloud/const.py

@@ -0,0 +1,14 @@
+"""Constants for the cloud component."""
+DOMAIN = 'cloud'
+REQUEST_TIMEOUT = 10
+AUTH_FILE = '.cloud'
+
+SERVERS = {
+    'development': {
+        'host': 'http://localhost:8000',
+        'client_id': 'HBhQxeV8H4aFBcs7jrZUeeDud0FjGEJJSZ9G6gNu',
+        'client_secret': ('V1qw2NhB32cSAlP7DOezjgWNgn7ZKgq0jvVZoYSI0KCmg9rg7q4'
+                          'BSzoebnQnX6tuHCJiZjm2479mZmmtf2LOUdnSqOqkSpjc3js7Wu'
+                          'VBJrRyfgTVd43kbrEQtuOiaUpK')
+    }
+}

homeassistant/components/cloud/http_api.py

@@ -0,0 +1,119 @@
+"""The HTTP api to control the cloud integration."""
+import asyncio
+import logging
+
+import voluptuous as vol
+import async_timeout
+
+from homeassistant.components.http import HomeAssistantView
+
+from . import cloud_api
+from .const import DOMAIN, REQUEST_TIMEOUT
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@asyncio.coroutine
+def async_setup(hass):
+    """Initialize the HTTP api."""
+    hass.http.register_view(CloudLoginView)
+    hass.http.register_view(CloudLogoutView)
+    hass.http.register_view(CloudAccountView)
+
+
+class CloudLoginView(HomeAssistantView):
+    """Login to Home Assistant cloud."""
+
+    url = '/api/cloud/login'
+    name = 'api:cloud:login'
+    schema = vol.Schema({
+        vol.Required('username'): str,
+        vol.Required('password'): str,
+    })
+
+    @asyncio.coroutine
+    def post(self, request):
+        """Validate config and return results."""
+        try:
+            data = yield from request.json()
+        except ValueError:
+            _LOGGER.error('Login with invalid JSON')
+            return self.json_message('Invalid JSON.', 400)
+
+        try:
+            self.schema(data)
+        except vol.Invalid as err:
+            _LOGGER.error('Login with invalid formatted data')
+            return self.json_message(
+                'Message format incorrect: {}'.format(err), 400)
+
+        hass = request.app['hass']
+        phase = 1
+        try:
+            with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
+                cloud = yield from cloud_api.async_login(
+                    hass, data['username'], data['password'])
+
+            phase += 1
+
+            with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
+                yield from cloud.async_refresh_account_info()
+
+        except cloud_api.Unauthenticated:
+            return self.json_message(
+                'Authentication failed (phase {}).'.format(phase), 401)
+        except cloud_api.UnknownError:
+            return self.json_message(
+                'Unknown error occurred (phase {}).'.format(phase), 500)
+        except asyncio.TimeoutError:
+            return self.json_message(
+                'Unable to reach Home Assistant cloud '
+                '(phase {}).'.format(phase), 502)
+
+        hass.data[DOMAIN]['cloud'] = cloud
+        return self.json(cloud.account)
+
+
+class CloudLogoutView(HomeAssistantView):
+    """Log out of the Home Assistant cloud."""
+
+    url = '/api/cloud/logout'
+    name = 'api:cloud:logout'
+
+    @asyncio.coroutine
+    def post(self, request):
+        """Validate config and return results."""
+        hass = request.app['hass']
+        try:
+            with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
+                yield from \
+                    hass.data[DOMAIN]['cloud'].async_revoke_access_token()
+
+            hass.data[DOMAIN].pop('cloud')
+
+            return self.json({
+                'result': 'ok',
+            })
+        except asyncio.TimeoutError:
+            return self.json_message("Could not reach the server.", 502)
+        except cloud_api.UnknownError as err:
+            return self.json_message(
+                "Error communicating with the server ({}).".format(err.status),
+                502)
+
+
+class CloudAccountView(HomeAssistantView):
+    """Log out of the Home Assistant cloud."""
+
+    url = '/api/cloud/account'
+    name = 'api:cloud:account'
+
+    @asyncio.coroutine
+    def get(self, request):
+        """Validate config and return results."""
+        hass = request.app['hass']
+
+        if 'cloud' not in hass.data[DOMAIN]:
+            return self.json_message('Not logged in', 400)
+
+        return self.json(hass.data[DOMAIN]['cloud'].account)

homeassistant/components/cloud/util.py

@@ -0,0 +1,10 @@
+"""Utilities for the cloud integration."""
+from .const import DOMAIN
+
+
+def get_mode(hass):
+    """Return the current mode of the cloud component.
+
+    Async friendly.
+    """
+    return hass.data[DOMAIN]['mode']

homeassistant/components/config/__init__.py

@@ -14,7 +14,7 @@ from homeassistant.util.yaml import load_yaml, dump
 
 DOMAIN = 'config'
 DEPENDENCIES = ['http']
-SECTIONS = ('core', 'group', 'hassbian', 'automation')
+SECTIONS = ('core', 'customize', 'group', 'hassbian', 'automation', 'script')
 ON_DEMAND = ('zwave')
 
 
@@ -77,11 +77,11 @@ class BaseEditConfigView(HomeAssistantView):
         """Empty config if file not found."""
         raise NotImplementedError
 
-    def _get_value(self, data, config_key):
+    def _get_value(self, hass, data, config_key):
         """Get value."""
         raise NotImplementedError
 
-    def _write_value(self, data, config_key, new_value):
+    def _write_value(self, hass, data, config_key, new_value):
         """Set value."""
         raise NotImplementedError
 
@@ -90,7 +90,7 @@ class BaseEditConfigView(HomeAssistantView):
         """Fetch device specific config."""
         hass = request.app['hass']
         current = yield from self.read_config(hass)
-        value = self._get_value(current, config_key)
+        value = self._get_value(hass, current, config_key)
 
         if value is None:
             return self.json_message('Resource not found', 404)
@@ -121,7 +121,7 @@ class BaseEditConfigView(HomeAssistantView):
         path = hass.config.path(self.path)
 
         current = yield from self.read_config(hass)
-        self._write_value(current, config_key, data)
+        self._write_value(hass, current, config_key, data)
 
         yield from hass.async_add_job(_write, path, current)
 
@@ -149,11 +149,11 @@ class EditKeyBasedConfigView(BaseEditConfigView):
         """Return an empty config."""
         return {}
 
-    def _get_value(self, data, config_key):
+    def _get_value(self, hass, data, config_key):
         """Get value."""
         return data.get(config_key, {})
 
-    def _write_value(self, data, config_key, new_value):
+    def _write_value(self, hass, data, config_key, new_value):
         """Set value."""
         data.setdefault(config_key, {}).update(new_value)
 
@@ -165,14 +165,14 @@ class EditIdBasedConfigView(BaseEditConfigView):
         """Return an empty config."""
         return []
 
-    def _get_value(self, data, config_key):
+    def _get_value(self, hass, data, config_key):
         """Get value."""
         return next(
             (val for val in data if val.get(CONF_ID) == config_key), None)
 
-    def _write_value(self, data, config_key, new_value):
+    def _write_value(self, hass, data, config_key, new_value):
         """Set value."""
-        value = self._get_value(data, config_key)
+        value = self._get_value(hass, data, config_key)
 
         if value is None:
             value = {CONF_ID: config_key}

homeassistant/components/config/customize.py

@@ -0,0 +1,39 @@
+"""Provide configuration end points for Customize."""
+import asyncio
+
+from homeassistant.components.config import EditKeyBasedConfigView
+from homeassistant.components import async_reload_core_config
+from homeassistant.config import DATA_CUSTOMIZE
+
+import homeassistant.helpers.config_validation as cv
+
+CONFIG_PATH = 'customize.yaml'
+
+
+@asyncio.coroutine
+def async_setup(hass):
+    """Set up the Customize config API."""
+    hass.http.register_view(CustomizeConfigView(
+        'customize', 'config', CONFIG_PATH, cv.entity_id, dict,
+        post_write_hook=async_reload_core_config
+    ))
+
+    return True
+
+
+class CustomizeConfigView(EditKeyBasedConfigView):
+    """Configure a list of entries."""
+
+    def _get_value(self, hass, data, config_key):
+        """Get value."""
+        customize = hass.data.get(DATA_CUSTOMIZE, {}).get(config_key) or {}
+        return {'global': customize, 'local': data.get(config_key, {})}
+
+    def _write_value(self, hass, data, config_key, new_value):
+        """Set value."""
+        data[config_key] = new_value
+
+        state = hass.states.get(config_key)
+        state_attributes = dict(state.attributes)
+        state_attributes.update(new_value)
+        hass.states.async_set(config_key, state.state, state_attributes)

homeassistant/components/config/script.py

@@ -0,0 +1,19 @@
+"""Provide configuration end points for scripts."""
+import asyncio
+
+from homeassistant.components.config import EditKeyBasedConfigView
+from homeassistant.components.script import SCRIPT_ENTRY_SCHEMA, async_reload
+import homeassistant.helpers.config_validation as cv
+
+
+CONFIG_PATH = 'scripts.yaml'
+
+
+@asyncio.coroutine
+def async_setup(hass):
+    """Set up the script config API."""
+    hass.http.register_view(EditKeyBasedConfigView(
+        'script', 'config', CONFIG_PATH, cv.slug, SCRIPT_ENTRY_SCHEMA,
+        post_write_hook=async_reload
+    ))
+    return True

homeassistant/components/configurator.py

@@ -7,19 +7,21 @@ A callback has to be provided to `request_config` which will be called when
 the user has submitted configuration information.
 """
 import asyncio
+import functools as ft
 import logging
 
 from homeassistant.core import callback as async_callback
 from homeassistant.const import EVENT_TIME_CHANGED, ATTR_FRIENDLY_NAME, \
     ATTR_ENTITY_PICTURE
 from homeassistant.loader import bind_hass
-from homeassistant.helpers.entity import generate_entity_id
+from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.util.async import run_callback_threadsafe
 
 _LOGGER = logging.getLogger(__name__)
-_REQUESTS = {}
 _KEY_INSTANCE = 'configurator'
 
+DATA_REQUESTS = 'configurator_requests'
+
 ATTR_CONFIGURE_ID = 'configure_id'
 ATTR_DESCRIPTION = 'description'
 ATTR_DESCRIPTION_IMAGE = 'description_image'
@@ -39,63 +41,89 @@ STATE_CONFIGURED = 'configured'
 
 
 @bind_hass
-def request_config(
-        hass, name, callback, description=None, description_image=None,
+@async_callback
+def async_request_config(
+        hass, name, callback=None, description=None, description_image=None,
         submit_caption=None, fields=None, link_name=None, link_url=None,
         entity_picture=None):
     """Create a new request for configuration.
 
     Will return an ID to be used for sequent calls.
     """
-    instance = run_callback_threadsafe(hass.loop,
-                                       _async_get_instance,
-                                       hass).result()
+    instance = hass.data.get(_KEY_INSTANCE)
 
-    request_id = instance.request_config(
+    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)
 
-    _REQUESTS[request_id] = instance
+    if DATA_REQUESTS not in hass.data:
+        hass.data[DATA_REQUESTS] = {}
+
+    hass.data[DATA_REQUESTS][request_id] = instance
 
     return request_id
 
 
-def notify_errors(request_id, error):
+@bind_hass
+def request_config(hass, *args, **kwargs):
+    """Create a new request for configuration.
+
+    Will return an ID to be used for sequent calls.
+    """
+    return run_callback_threadsafe(
+        hass.loop, ft.partial(async_request_config, hass, *args, **kwargs)
+    ).result()
+
+
+@bind_hass
+@async_callback
+def async_notify_errors(hass, request_id, error):
     """Add errors to a config request."""
     try:
-        _REQUESTS[request_id].notify_errors(request_id, error)
+        hass.data[DATA_REQUESTS][request_id].async_notify_errors(
+            request_id, error)
     except KeyError:
         # If request_id does not exist
         pass
 
 
-def request_done(request_id):
+@bind_hass
+def notify_errors(hass, request_id, error):
+    """Add errors to a config request."""
+    return run_callback_threadsafe(
+        hass.loop, async_notify_errors, hass, request_id, error
+    ).result()
+
+
+@bind_hass
+@async_callback
+def async_request_done(hass, request_id):
     """Mark a configuration request as done."""
     try:
-        _REQUESTS.pop(request_id).request_done(request_id)
+        hass.data[DATA_REQUESTS].pop(request_id).async_request_done(request_id)
     except KeyError:
         # If request_id does not exist
         pass
 
 
+@bind_hass
+def request_done(hass, request_id):
+    """Mark a configuration request as done."""
+    return run_callback_threadsafe(
+        hass.loop, async_request_done, hass, request_id
+    ).result()
+
+
 @asyncio.coroutine
 def async_setup(hass, config):
     """Set up the configurator component."""
     return True
 
 
-@async_callback
-def _async_get_instance(hass):
-    """Get an instance per hass object."""
-    instance = hass.data.get(_KEY_INSTANCE)
-
-    if instance is None:
-        instance = hass.data[_KEY_INSTANCE] = Configurator(hass)
-
-    return instance
-
-
 class Configurator(object):
     """The class to keep track of current configuration requests."""
 
@@ -105,14 +133,16 @@ class Configurator(object):
         self._cur_id = 0
         self._requests = {}
         hass.services.async_register(
-            DOMAIN, SERVICE_CONFIGURE, self.handle_service_call)
+            DOMAIN, SERVICE_CONFIGURE, self.async_handle_service_call)
 
-    def request_config(
+    @async_callback
+    def async_request_config(
             self, name, callback,
             description, description_image, submit_caption,
             fields, link_name, link_url, entity_picture):
         """Set up a request for configuration."""
-        entity_id = generate_entity_id(ENTITY_ID_FORMAT, name, hass=self.hass)
+        entity_id = async_generate_entity_id(
+            ENTITY_ID_FORMAT, name, hass=self.hass)
 
         if fields is None:
             fields = []
@@ -138,11 +168,12 @@ class Configurator(object):
             ] if value is not None
         })
 
-        self.hass.states.set(entity_id, STATE_CONFIGURE, data)
+        self.hass.states.async_set(entity_id, STATE_CONFIGURE, data)
 
         return request_id
 
-    def notify_errors(self, request_id, error):
+    @async_callback
+    def async_notify_errors(self, request_id, error):
         """Update the state with errors."""
         if not self._validate_request_id(request_id):
             return
@@ -154,9 +185,10 @@ class Configurator(object):
         new_data = dict(state.attributes)
         new_data[ATTR_ERRORS] = error
 
-        self.hass.states.set(entity_id, STATE_CONFIGURE, new_data)
+        self.hass.states.async_set(entity_id, STATE_CONFIGURE, new_data)
 
-    def request_done(self, request_id):
+    @async_callback
+    def async_request_done(self, request_id):
         """Remove the configuration request."""
         if not self._validate_request_id(request_id):
             return
@@ -167,15 +199,16 @@ class Configurator(object):
         # the result fo the service call (current design limitation).
         # Instead, we will set it to configured to give as feedback but delete
         # it shortly after so that it is deleted when the client updates.
-        self.hass.states.set(entity_id, STATE_CONFIGURED)
+        self.hass.states.async_set(entity_id, STATE_CONFIGURED)
 
         def deferred_remove(event):
             """Remove the request state."""
-            self.hass.states.remove(entity_id)
+            self.hass.states.async_remove(entity_id)
 
-        self.hass.bus.listen_once(EVENT_TIME_CHANGED, deferred_remove)
+        self.hass.bus.async_listen_once(EVENT_TIME_CHANGED, deferred_remove)
 
-    def handle_service_call(self, call):
+    @async_callback
+    def async_handle_service_call(self, call):
         """Handle a configure service call."""
         request_id = call.data.get(ATTR_CONFIGURE_ID)
 
@@ -186,8 +219,8 @@ class Configurator(object):
         entity_id, fields, callback = self._requests[request_id]
 
         # field validation goes here?
-
-        self.hass.async_add_job(callback, call.data.get(ATTR_FIELDS, {}))
+        if callback:
+            self.hass.async_add_job(callback, call.data.get(ATTR_FIELDS, {}))
 
     def _generate_unique_id(self):
         """Generate a unique configurator ID."""

homeassistant/components/counter.py

@@ -0,0 +1,220 @@
+"""
+Component to count within automations.
+
+For more details about this component, please refer to the documentation
+at https://home-assistant.io/components/counter/
+"""
+import asyncio
+import logging
+import os
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (ATTR_ENTITY_ID, CONF_ICON, CONF_NAME)
+from homeassistant.core import callback
+from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.restore_state import async_get_last_state
+from homeassistant.loader import bind_hass
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_INITIAL = 'initial'
+ATTR_STEP = 'step'
+
+CONF_INITIAL = 'initial'
+CONF_STEP = 'step'
+
+DEFAULT_INITIAL = 0
+DEFAULT_STEP = 1
+DOMAIN = 'counter'
+
+ENTITY_ID_FORMAT = DOMAIN + '.{}'
+
+SERVICE_DECREMENT = 'decrement'
+SERVICE_INCREMENT = 'increment'
+SERVICE_RESET = 'reset'
+
+SERVICE_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+})
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        cv.slug: vol.Any({
+            vol.Optional(CONF_ICON): cv.icon,
+            vol.Optional(CONF_INITIAL, default=DEFAULT_INITIAL):
+                cv.positive_int,
+            vol.Optional(CONF_NAME): cv.string,
+            vol.Optional(CONF_STEP, default=DEFAULT_STEP): cv.positive_int,
+        }, None)
+    })
+}, extra=vol.ALLOW_EXTRA)
+
+
+@bind_hass
+def increment(hass, entity_id):
+    """Increment a counter."""
+    hass.add_job(async_increment, hass, entity_id)
+
+
+@callback
+@bind_hass
+def async_increment(hass, entity_id):
+    """Increment a counter."""
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_INCREMENT, {ATTR_ENTITY_ID: entity_id}))
+
+
+@bind_hass
+def decrement(hass, entity_id):
+    """Decrement a counter."""
+    hass.add_job(async_decrement, hass, entity_id)
+
+
+@callback
+@bind_hass
+def async_decrement(hass, entity_id):
+    """Decrement a counter."""
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_DECREMENT, {ATTR_ENTITY_ID: entity_id}))
+
+
+@bind_hass
+def reset(hass, entity_id):
+    """Reset a counter."""
+    hass.add_job(async_reset, hass, entity_id)
+
+
+@callback
+@bind_hass
+def async_reset(hass, entity_id):
+    """Reset a counter."""
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_RESET, {ATTR_ENTITY_ID: entity_id}))
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Set up a counter."""
+    component = EntityComponent(_LOGGER, DOMAIN, hass)
+
+    entities = []
+
+    for object_id, cfg in config[DOMAIN].items():
+        if not cfg:
+            cfg = {}
+
+        name = cfg.get(CONF_NAME)
+        initial = cfg.get(CONF_INITIAL)
+        step = cfg.get(CONF_STEP)
+        icon = cfg.get(CONF_ICON)
+
+        entities.append(Counter(object_id, name, initial, step, icon))
+
+    if not entities:
+        return False
+
+    @asyncio.coroutine
+    def async_handler_service(service):
+        """Handle a call to the counter services."""
+        target_counters = component.async_extract_from_service(service)
+
+        if service.service == SERVICE_INCREMENT:
+            attr = 'async_increment'
+        elif service.service == SERVICE_DECREMENT:
+            attr = 'async_decrement'
+        elif service.service == SERVICE_RESET:
+            attr = 'async_reset'
+
+        tasks = [getattr(counter, attr)() for counter in target_counters]
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
+
+    descriptions = yield from hass.async_add_job(
+        load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml')
+    )
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_INCREMENT, async_handler_service,
+        descriptions[DOMAIN][SERVICE_INCREMENT], SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_DECREMENT, async_handler_service,
+        descriptions[DOMAIN][SERVICE_DECREMENT], SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_RESET, async_handler_service,
+        descriptions[DOMAIN][SERVICE_RESET], SERVICE_SCHEMA)
+
+    yield from component.async_add_entities(entities)
+    return True
+
+
+class Counter(Entity):
+    """Representation of a counter."""
+
+    def __init__(self, object_id, name, initial, step, icon):
+        """Initialize a counter."""
+        self.entity_id = ENTITY_ID_FORMAT.format(object_id)
+        self._name = name
+        self._step = step
+        self._state = self._initial = initial
+        self._icon = icon
+
+    @property
+    def should_poll(self):
+        """If entity should be polled."""
+        return False
+
+    @property
+    def name(self):
+        """Return name of the counter."""
+        return self._name
+
+    @property
+    def icon(self):
+        """Return the icon to be used for this entity."""
+        return self._icon
+
+    @property
+    def state(self):
+        """Return the current value of the counter."""
+        return self._state
+
+    @property
+    def state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_INITIAL: self._initial,
+            ATTR_STEP: self._step,
+        }
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Call when entity about to be added to Home Assistant."""
+        # If not None, we got an initial value.
+        if self._state is not None:
+            return
+
+        state = yield from async_get_last_state(self.hass, self.entity_id)
+        self._state = state and state.state == state
+
+    @asyncio.coroutine
+    def async_decrement(self):
+        """Decrement the counter."""
+        self._state -= self._step
+        yield from self.async_update_ha_state()
+
+    @asyncio.coroutine
+    def async_increment(self):
+        """Increment a counter."""
+        self._state += self._step
+        yield from self.async_update_ha_state()
+
+    @asyncio.coroutine
+    def async_reset(self):
+        """Reset a counter."""
+        self._state = self._initial
+        yield from self.async_update_ha_state()

homeassistant/components/cover/abode.py

@@ -0,0 +1,49 @@
+"""
+This component provides HA cover support for Abode Security System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/cover.abode/
+"""
+import logging
+
+from homeassistant.components.abode import AbodeDevice, DATA_ABODE
+from homeassistant.components.cover import CoverDevice
+
+
+DEPENDENCIES = ['abode']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Abode cover devices."""
+    import abodepy.helpers.constants as CONST
+
+    abode = hass.data[DATA_ABODE]
+
+    sensors = []
+    for sensor in abode.get_devices(type_filter=(CONST.DEVICE_SECURE_BARRIER)):
+        sensors.append(AbodeCover(abode, sensor))
+
+    add_devices(sensors)
+
+
+class AbodeCover(AbodeDevice, CoverDevice):
+    """Representation of an Abode cover."""
+
+    def __init__(self, controller, device):
+        """Initialize the Abode device."""
+        AbodeDevice.__init__(self, controller, device)
+
+    @property
+    def is_closed(self):
+        """Return true if cover is closed, else False."""
+        return self._device.is_open is False
+
+    def close_cover(self):
+        """Issue close command to cover."""
+        self._device.close_cover()
+
+    def open_cover(self):
+        """Issue open command to cover."""
+        self._device.open_cover()

homeassistant/components/cover/homematic.py

@@ -21,8 +21,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     devices = []
     for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMCover(hass, conf)
-        new_device.link_homematic()
+        new_device = HMCover(conf)
         devices.append(new_device)
 
     add_devices(devices)

homeassistant/components/cover/knx.py

@@ -1,185 +1,239 @@
 """
-Support for KNX covers.
+Support for KNX/IP covers.
 
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/cover.knx/
 """
-import logging
-
+import asyncio
 import voluptuous as vol
 
+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES
+from homeassistant.helpers.event import async_track_utc_time_change
 from homeassistant.components.cover import (
-    CoverDevice, PLATFORM_SCHEMA, ATTR_POSITION, DEVICE_CLASSES_SCHEMA,
-    SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_SET_POSITION, SUPPORT_STOP,
-    SUPPORT_SET_TILT_POSITION
-)
-from homeassistant.components.knx import (KNXConfig, KNXMultiAddressDevice)
-from homeassistant.const import (CONF_NAME, CONF_DEVICE_CLASS)
+    CoverDevice, PLATFORM_SCHEMA, SUPPORT_OPEN, SUPPORT_CLOSE,
+    SUPPORT_SET_POSITION, SUPPORT_STOP, SUPPORT_SET_TILT_POSITION,
+    ATTR_POSITION, ATTR_TILT_POSITION)
+from homeassistant.core import callback
+from homeassistant.const import CONF_NAME
 import homeassistant.helpers.config_validation as cv
 
-_LOGGER = logging.getLogger(__name__)
-
-CONF_GETPOSITION_ADDRESS = 'getposition_address'
-CONF_SETPOSITION_ADDRESS = 'setposition_address'
-CONF_GETANGLE_ADDRESS = 'getangle_address'
-CONF_SETANGLE_ADDRESS = 'setangle_address'
-CONF_STOP = 'stop_address'
-CONF_UPDOWN = 'updown_address'
+CONF_MOVE_LONG_ADDRESS = 'move_long_address'
+CONF_MOVE_SHORT_ADDRESS = 'move_short_address'
+CONF_POSITION_ADDRESS = 'position_address'
+CONF_POSITION_STATE_ADDRESS = 'position_state_address'
+CONF_ANGLE_ADDRESS = 'angle_address'
+CONF_ANGLE_STATE_ADDRESS = 'angle_state_address'
+CONF_TRAVELLING_TIME_DOWN = 'travelling_time_down'
+CONF_TRAVELLING_TIME_UP = 'travelling_time_up'
 CONF_INVERT_POSITION = 'invert_position'
 CONF_INVERT_ANGLE = 'invert_angle'
 
+DEFAULT_TRAVEL_TIME = 25
 DEFAULT_NAME = 'KNX Cover'
 DEPENDENCIES = ['knx']
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_UPDOWN): cv.string,
-    vol.Required(CONF_STOP): cv.string,
-    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
-    vol.Optional(CONF_GETPOSITION_ADDRESS): cv.string,
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_SETPOSITION_ADDRESS): cv.string,
+    vol.Optional(CONF_MOVE_LONG_ADDRESS): cv.string,
+    vol.Optional(CONF_MOVE_SHORT_ADDRESS): cv.string,
+    vol.Optional(CONF_POSITION_ADDRESS): cv.string,
+    vol.Optional(CONF_POSITION_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_ANGLE_ADDRESS): cv.string,
+    vol.Optional(CONF_ANGLE_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_TRAVELLING_TIME_DOWN, default=DEFAULT_TRAVEL_TIME):
+        cv.positive_int,
+    vol.Optional(CONF_TRAVELLING_TIME_UP, default=DEFAULT_TRAVEL_TIME):
+        cv.positive_int,
     vol.Optional(CONF_INVERT_POSITION, default=False): cv.boolean,
-    vol.Inclusive(CONF_GETANGLE_ADDRESS, 'angle'): cv.string,
-    vol.Inclusive(CONF_SETANGLE_ADDRESS, 'angle'): cv.string,
     vol.Optional(CONF_INVERT_ANGLE, default=False): cv.boolean,
 })
 
 
-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Create and add an entity based on the configuration."""
-    add_devices([KNXCover(hass, KNXConfig(config))])
+@asyncio.coroutine
+def async_setup_platform(hass, config, add_devices,
+                         discovery_info=None):
+    """Set up cover(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False
+
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, add_devices)
+    else:
+        async_add_devices_config(hass, config, add_devices)
+
+    return True
 
 
-class KNXCover(KNXMultiAddressDevice, CoverDevice):
-    """Representation of a KNX cover. e.g. a rollershutter."""
+@callback
+def async_add_devices_discovery(hass, discovery_info, add_devices):
+    """Set up covers for KNX platform configured via xknx.yaml."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXCover(hass, device))
+    add_devices(entities)
 
-    def __init__(self, hass, config):
+
+@callback
+def async_add_devices_config(hass, config, add_devices):
+    """Set up cover for KNX platform configured within plattform."""
+    import xknx
+    cover = xknx.devices.Cover(
+        hass.data[DATA_KNX].xknx,
+        name=config.get(CONF_NAME),
+        group_address_long=config.get(CONF_MOVE_LONG_ADDRESS),
+        group_address_short=config.get(CONF_MOVE_SHORT_ADDRESS),
+        group_address_position_state=config.get(
+            CONF_POSITION_STATE_ADDRESS),
+        group_address_angle=config.get(CONF_ANGLE_ADDRESS),
+        group_address_angle_state=config.get(CONF_ANGLE_STATE_ADDRESS),
+        group_address_position=config.get(CONF_POSITION_ADDRESS),
+        travel_time_down=config.get(CONF_TRAVELLING_TIME_DOWN),
+        travel_time_up=config.get(CONF_TRAVELLING_TIME_UP))
+
+    invert_position = config.get(CONF_INVERT_POSITION)
+    invert_angle = config.get(CONF_INVERT_ANGLE)
+    hass.data[DATA_KNX].xknx.devices.add(cover)
+    add_devices([KNXCover(hass, cover, invert_position, invert_angle)])
+
+
+class KNXCover(CoverDevice):
+    """Representation of a KNX cover."""
+
+    def __init__(self, hass, device, invert_position=False,
+                 invert_angle=False):
         """Initialize the cover."""
-        KNXMultiAddressDevice.__init__(
-            self, hass, config,
-            ['updown', 'stop'],  # required
-            optional=['setposition', 'getposition',
-                      'getangle', 'setangle']
-        )
-        self._device_class = config.config.get(CONF_DEVICE_CLASS)
-        self._invert_position = config.config.get(CONF_INVERT_POSITION)
-        self._invert_angle = config.config.get(CONF_INVERT_ANGLE)
-        self._hass = hass
-        self._current_pos = None
-        self._target_pos = None
-        self._current_tilt = None
-        self._target_tilt = None
-        self._supported_features = SUPPORT_OPEN | SUPPORT_CLOSE | \
-            SUPPORT_SET_POSITION | SUPPORT_STOP
+        self.device = device
+        self.invert_position = invert_position
+        self.invert_angle = invert_angle
+        self.hass = hass
+        self.async_register_callbacks()
 
-        # Tilt is only supported, if there is a angle get and set address
-        if CONF_SETANGLE_ADDRESS in config.config:
-            _LOGGER.debug("%s: Tilt supported at addresses %s, %s",
-                          self.name, config.config.get(CONF_SETANGLE_ADDRESS),
-                          config.config.get(CONF_GETANGLE_ADDRESS))
-            self._supported_features = self._supported_features | \
-                SUPPORT_SET_TILT_POSITION
+        self._unsubscribe_auto_updater = None
+
+    @callback
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
+
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name
 
     @property
     def should_poll(self):
-        """Polling is needed for the KNX cover."""
-        return True
+        """No polling needed within KNX."""
+        return False
 
     @property
     def supported_features(self):
         """Flag supported features."""
-        return self._supported_features
+        supported_features = SUPPORT_OPEN | SUPPORT_CLOSE | \
+            SUPPORT_SET_POSITION | SUPPORT_STOP
+        if self.device.supports_angle:
+            supported_features |= SUPPORT_SET_TILT_POSITION
+        return supported_features
+
+    @property
+    def current_cover_position(self):
+        """Return the current position of the cover."""
+        return int(self.from_knx_position(
+            self.device.current_position(),
+            self.invert_position))
 
     @property
     def is_closed(self):
         """Return if the cover is closed."""
-        if self.current_cover_position is not None:
-            if self.current_cover_position > 0:
-                return False
-            else:
-                return True
+        return self.device.is_closed()
 
-    @property
-    def current_cover_position(self):
-        """Return current position of cover.
+    @asyncio.coroutine
+    def async_close_cover(self, **kwargs):
+        """Close the cover."""
+        if not self.device.is_closed():
+            yield from self.device.set_down()
+            self.start_auto_updater()
 
-        None is unknown, 0 is closed, 100 is fully open.
-        """
-        return self._current_pos
+    @asyncio.coroutine
+    def async_open_cover(self, **kwargs):
+        """Open the cover."""
+        if not self.device.is_open():
+            yield from self.device.set_up()
+            self.start_auto_updater()
 
-    @property
-    def target_position(self):
-        """Return the position we are trying to reach: 0 - 100."""
-        return self._target_pos
+    @asyncio.coroutine
+    def async_set_cover_position(self, **kwargs):
+        """Move the cover to a specific position."""
+        if ATTR_POSITION in kwargs:
+            position = kwargs[ATTR_POSITION]
+            knx_position = self.to_knx_position(position, self.invert_position)
+            yield from self.device.set_position(knx_position)
+            self.start_auto_updater()
+
+    @asyncio.coroutine
+    def async_stop_cover(self, **kwargs):
+        """Stop the cover."""
+        yield from self.device.stop()
+        self.stop_auto_updater()
 
     @property
     def current_cover_tilt_position(self):
-        """Return current position of cover.
+        """Return current tilt position of cover."""
+        if not self.device.supports_angle:
+            return None
+        return int(self.from_knx_position(
+            self.device.angle,
+            self.invert_angle))
 
-        None is unknown, 0 is closed, 100 is fully open.
-        """
-        return self._current_tilt
+    @asyncio.coroutine
+    def async_set_cover_tilt_position(self, **kwargs):
+        """Move the cover tilt to a specific position."""
+        if ATTR_TILT_POSITION in kwargs:
+            position = kwargs[ATTR_TILT_POSITION]
+            knx_position = self.to_knx_position(position, self.invert_angle)
+            yield from self.device.set_angle(knx_position)
 
-    @property
-    def target_tilt(self):
-        """Return the tilt angle (in %) we are trying to reach: 0 - 100."""
-        return self._target_tilt
+    def start_auto_updater(self):
+        """Start the autoupdater to update HASS while cover is moving."""
+        if self._unsubscribe_auto_updater is None:
+            self._unsubscribe_auto_updater = async_track_utc_time_change(
+                self.hass, self.auto_updater_hook)
 
-    def set_cover_position(self, **kwargs):
-        """Set new target position."""
-        position = kwargs.get(ATTR_POSITION)
-        if position is None:
-            return
+    def stop_auto_updater(self):
+        """Stop the autoupdater."""
+        if self._unsubscribe_auto_updater is not None:
+            self._unsubscribe_auto_updater()
+            self._unsubscribe_auto_updater = None
 
-        if self._invert_position:
-            position = 100-position
+    @callback
+    def auto_updater_hook(self, now):
+        """Callback for autoupdater."""
+        # pylint: disable=unused-argument
+        self.hass.async_add_job(self.async_update_ha_state())
+        if self.device.position_reached():
+            self.stop_auto_updater()
 
-        self._target_pos = position
-        self.set_percentage('setposition', position)
-        _LOGGER.debug("%s: Set target position to %d", self.name, position)
+        self.hass.add_job(self.device.auto_stop_if_necessary())
 
-    def update(self):
-        """Update device state."""
-        super().update()
-        value = self.get_percentage('getposition')
-        if value is not None:
-            self._current_pos = value
-            if self._invert_position:
-                self._current_pos = 100-value
-            _LOGGER.debug("%s: position = %d", self.name, value)
+    @staticmethod
+    def from_knx_position(raw, invert):
+        """Convert KNX position [0...255] to hass position [100...0]."""
+        position = round((raw/256)*100)
+        if not invert:
+            position = 100 - position
+        return position
 
-        if self._supported_features & SUPPORT_SET_TILT_POSITION:
-            value = self.get_percentage('getangle')
-            if value is not None:
-                self._current_tilt = value
-                if self._invert_angle:
-                    self._current_tilt = 100-value
-                _LOGGER.debug("%s: tilt = %d", self.name, value)
-
-    def open_cover(self, **kwargs):
-        """Open the cover."""
-        _LOGGER.debug("%s: open: updown = 0", self.name)
-        self.set_int_value('updown', 0)
-
-    def close_cover(self, **kwargs):
-        """Close the cover."""
-        _LOGGER.debug("%s: open: updown = 1", self.name)
-        self.set_int_value('updown', 1)
-
-    def stop_cover(self, **kwargs):
-        """Stop the cover movement."""
-        _LOGGER.debug("%s: stop: stop = 1", self.name)
-        self.set_int_value('stop', 1)
-
-    def set_cover_tilt_position(self, tilt_position, **kwargs):
-        """Move the cover til to a specific position."""
-        if self._invert_angle:
-            tilt_position = 100-tilt_position
-
-        self._target_tilt = round(tilt_position, -1)
-        self.set_percentage('setangle', tilt_position)
-
-    @property
-    def device_class(self):
-        """Return the class of this device, from component DEVICE_CLASSES."""
-        return self._device_class
+    @staticmethod
+    def to_knx_position(value, invert):
+        """Convert hass position [100...0] to KNX position [0...255]."""
+        knx_position = round(value/100*255.4)
+        if not invert:
+            knx_position = 255-knx_position
+        print(value, " -> ", knx_position)
+        return knx_position

homeassistant/components/cover/lutron_caseta.py

@@ -1,14 +1,14 @@
 """
-Support for Lutron Caseta SerenaRollerShade.
+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 logging
 
-
 from homeassistant.components.cover import (
-    CoverDevice, SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_SET_POSITION)
+    CoverDevice, SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_SET_POSITION,
+    ATTR_POSITION, DOMAIN)
 from homeassistant.components.lutron_caseta import (
     LUTRON_CASETA_SMARTBRIDGE, LutronCasetaDevice)
 
@@ -19,11 +19,10 @@ DEPENDENCIES = ['lutron_caseta']
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the Lutron Caseta Serena shades as a cover device."""
+    """Set up the Lutron Caseta shades as a cover device."""
     devs = []
     bridge = hass.data[LUTRON_CASETA_SMARTBRIDGE]
-    cover_devices = bridge.get_devices_by_types(["SerenaRollerShade",
-                                                 "SerenaHoneycombShade"])
+    cover_devices = bridge.get_devices_by_domain(DOMAIN)
     for cover_device in cover_devices:
         dev = LutronCasetaCover(cover_device, bridge)
         devs.append(dev)
@@ -32,7 +31,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class LutronCasetaCover(LutronCasetaDevice, CoverDevice):
-    """Representation of a Lutron Serena shade."""
+    """Representation of a Lutron shade."""
 
     @property
     def supported_features(self):
@@ -42,24 +41,26 @@ class LutronCasetaCover(LutronCasetaDevice, CoverDevice):
     @property
     def is_closed(self):
         """Return if the cover is closed."""
-        return self._state["current_state"] < 1
+        return self._state['current_state'] < 1
 
     @property
     def current_cover_position(self):
         """Return the current position of cover."""
-        return self._state["current_state"]
+        return self._state['current_state']
 
-    def close_cover(self):
+    def close_cover(self, **kwargs):
         """Close the cover."""
         self._smartbridge.set_value(self._device_id, 0)
 
-    def open_cover(self):
+    def open_cover(self, **kwargs):
         """Open the cover."""
         self._smartbridge.set_value(self._device_id, 100)
 
-    def set_cover_position(self, position, **kwargs):
-        """Move the roller shutter to a specific position."""
-        self._smartbridge.set_value(self._device_id, position)
+    def 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):
         """Call when forcing a refresh of the device."""

homeassistant/components/cover/mysensors.py

@@ -4,42 +4,18 @@ Support for MySensors covers.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/cover.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
-from homeassistant.components.cover import CoverDevice, ATTR_POSITION
+from homeassistant.components.cover import CoverDevice, ATTR_POSITION, DOMAIN
 from homeassistant.const import STATE_ON, STATE_OFF
 
-_LOGGER = logging.getLogger(__name__)
-
-DEPENDENCIES = []
-
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the MySensors platform for covers."""
-    if discovery_info is None:
-        return
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-    if not gateways:
-        return
-
-    for gateway in gateways:
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-        map_sv_types = {
-            pres.S_COVER: [set_req.V_DIMMER, set_req.V_LIGHT],
-        }
-        if float(gateway.protocol_version) >= 1.5:
-            map_sv_types.update({
-                pres.S_COVER: [set_req.V_PERCENTAGE, set_req.V_STATUS],
-            })
-        devices = {}
-        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, MySensorsCover, add_devices))
+    """Setup the mysensors platform for covers."""
+    mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsCover, add_devices=add_devices)
 
 
-class MySensorsCover(mysensors.MySensorsDeviceEntity, CoverDevice):
+class MySensorsCover(mysensors.MySensorsEntity, CoverDevice):
     """Representation of the value of a MySensors Cover child node."""
 
     @property

homeassistant/components/cover/rfxtrx.py

@@ -16,7 +16,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
     """Set up the RFXtrx cover."""
     import RFXtrx as rfxtrxmod
 
-    covers = rfxtrx.get_devices_from_config(config, RfxtrxCover, hass)
+    covers = rfxtrx.get_devices_from_config(config, RfxtrxCover)
     add_devices_callback(covers)
 
     def cover_update(event):
@@ -26,7 +26,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                 not event.device.known_to_be_rollershutter:
             return
 
-        new_device = rfxtrx.get_new_device(event, config, RfxtrxCover, hass)
+        new_device = rfxtrx.get_new_device(event, config, RfxtrxCover)
         if new_device:
             add_devices_callback([new_device])
 

homeassistant/components/cover/template.py

@@ -19,7 +19,7 @@ from homeassistant.const import (
     CONF_FRIENDLY_NAME, CONF_ENTITY_ID,
     EVENT_HOMEASSISTANT_START, MATCH_ALL,
     CONF_VALUE_TEMPLATE, CONF_ICON_TEMPLATE,
-    STATE_OPEN, STATE_CLOSED)
+    CONF_OPTIMISTIC, STATE_OPEN, STATE_CLOSED)
 from homeassistant.exceptions import TemplateError
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
@@ -39,6 +39,8 @@ CLOSE_ACTION = 'close_cover'
 STOP_ACTION = 'stop_cover'
 POSITION_ACTION = 'set_cover_position'
 TILT_ACTION = 'set_cover_tilt_position'
+CONF_TILT_OPTIMISTIC = 'tilt_optimistic'
+
 CONF_VALUE_OR_POSITION_TEMPLATE = 'value_or_position'
 CONF_OPEN_OR_CLOSE = 'open_or_close'
 
@@ -56,6 +58,8 @@ COVER_SCHEMA = vol.Schema({
     vol.Optional(CONF_POSITION_TEMPLATE): cv.template,
     vol.Optional(CONF_TILT_TEMPLATE): cv.template,
     vol.Optional(CONF_ICON_TEMPLATE): cv.template,
+    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
+    vol.Optional(CONF_TILT_OPTIMISTIC): cv.boolean,
     vol.Optional(POSITION_ACTION): cv.SCRIPT_SCHEMA,
     vol.Optional(TILT_ACTION): cv.SCRIPT_SCHEMA,
     vol.Optional(CONF_FRIENDLY_NAME, default=None): cv.string,
@@ -83,11 +87,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
         stop_action = device_config.get(STOP_ACTION)
         position_action = device_config.get(POSITION_ACTION)
         tilt_action = device_config.get(TILT_ACTION)
-
-        if position_template is None and state_template is None:
-            _LOGGER.error('Must specify either %s' or '%s',
-                          CONF_VALUE_TEMPLATE, CONF_VALUE_TEMPLATE)
-            continue
+        optimistic = device_config.get(CONF_OPTIMISTIC)
+        tilt_optimistic = device_config.get(CONF_TILT_OPTIMISTIC)
 
         if position_action is None and open_action is None:
             _LOGGER.error('Must specify at least one of %s' or '%s',
@@ -125,7 +126,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
                 device, friendly_name, state_template,
                 position_template, tilt_template, icon_template,
                 open_action, close_action, stop_action,
-                position_action, tilt_action, entity_ids
+                position_action, tilt_action,
+                optimistic, tilt_optimistic, entity_ids
             )
         )
     if not covers:
@@ -142,7 +144,8 @@ class CoverTemplate(CoverDevice):
     def __init__(self, hass, device_id, friendly_name, state_template,
                  position_template, tilt_template, icon_template,
                  open_action, close_action, stop_action,
-                 position_action, tilt_action, entity_ids):
+                 position_action, tilt_action,
+                 optimistic, tilt_optimistic, entity_ids):
         """Initialize the Template cover."""
         self.hass = hass
         self.entity_id = async_generate_entity_id(
@@ -167,6 +170,9 @@ class CoverTemplate(CoverDevice):
         self._tilt_script = None
         if tilt_action is not None:
             self._tilt_script = Script(hass, tilt_action)
+        self._optimistic = (optimistic or
+                            (not state_template and not position_template))
+        self._tilt_optimistic = tilt_optimistic or not tilt_template
         self._icon = None
         self._position = None
         self._tilt_value = None
@@ -260,19 +266,23 @@ class CoverTemplate(CoverDevice):
     def async_open_cover(self, **kwargs):
         """Move the cover up."""
         if self._open_script:
-            self.hass.async_add_job(self._open_script.async_run())
+            yield from self._open_script.async_run()
         elif self._position_script:
-            self.hass.async_add_job(self._position_script.async_run(
-                {"position": 100}))
+            yield from self._position_script.async_run({"position": 100})
+        if self._optimistic:
+            self._position = 100
+            self.hass.async_add_job(self.async_update_ha_state())
 
     @asyncio.coroutine
     def async_close_cover(self, **kwargs):
         """Move the cover down."""
         if self._close_script:
-            self.hass.async_add_job(self._close_script.async_run())
+            yield from self._close_script.async_run()
         elif self._position_script:
-            self.hass.async_add_job(self._position_script.async_run(
-                {"position": 0}))
+            yield from self._position_script.async_run({"position": 0})
+        if self._optimistic:
+            self._position = 0
+            self.hass.async_add_job(self.async_update_ha_state())
 
     @asyncio.coroutine
     def async_stop_cover(self, **kwargs):
@@ -284,29 +294,35 @@ class CoverTemplate(CoverDevice):
     def async_set_cover_position(self, **kwargs):
         """Set cover position."""
         self._position = kwargs[ATTR_POSITION]
-        self.hass.async_add_job(self._position_script.async_run(
-            {"position": self._position}))
+        yield from self._position_script.async_run(
+            {"position": self._position})
+        if self._optimistic:
+            self.hass.async_add_job(self.async_update_ha_state())
 
     @asyncio.coroutine
     def async_open_cover_tilt(self, **kwargs):
         """Tilt the cover open."""
         self._tilt_value = 100
-        self.hass.async_add_job(self._tilt_script.async_run(
-            {"tilt": self._tilt_value}))
+        yield from self._tilt_script.async_run({"tilt": self._tilt_value})
+        if self._tilt_optimistic:
+            self.hass.async_add_job(self.async_update_ha_state())
 
     @asyncio.coroutine
     def async_close_cover_tilt(self, **kwargs):
         """Tilt the cover closed."""
         self._tilt_value = 0
-        self.hass.async_add_job(self._tilt_script.async_run(
-            {"tilt": self._tilt_value}))
+        yield from self._tilt_script.async_run(
+            {"tilt": self._tilt_value})
+        if self._tilt_optimistic:
+            self.hass.async_add_job(self.async_update_ha_state())
 
     @asyncio.coroutine
     def async_set_cover_tilt_position(self, **kwargs):
         """Move the cover tilt to a specific position."""
         self._tilt_value = kwargs[ATTR_TILT_POSITION]
-        self.hass.async_add_job(self._tilt_script.async_run(
-            {"tilt": self._tilt_value}))
+        yield from self._tilt_script.async_run({"tilt": self._tilt_value})
+        if self._tilt_optimistic:
+            self.hass.async_add_job(self.async_update_ha_state())
 
     @asyncio.coroutine
     def async_update(self):

homeassistant/components/cover/xiaomi.py

@@ -24,10 +24,10 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class XiaomiGenericCover(XiaomiDevice, CoverDevice):
-    """Representation of a XiaomiPlug."""
+    """Representation of a XiaomiGenericCover."""
 
     def __init__(self, device, name, data_key, xiaomi_hub):
-        """Initialize the XiaomiPlug."""
+        """Initialize the XiaomiGenericCover."""
         self._data_key = data_key
         self._pos = 0
         XiaomiDevice.__init__(self, device, name, xiaomi_hub)
@@ -44,19 +44,19 @@ class XiaomiGenericCover(XiaomiDevice, CoverDevice):
 
     def close_cover(self, **kwargs):
         """Close the cover."""
-        self._write_to_hub(self._sid, self._data_key['status'], 'close')
+        self._write_to_hub(self._sid, **{self._data_key['status']: 'close'})
 
     def open_cover(self, **kwargs):
         """Open the cover."""
-        self._write_to_hub(self._sid, self._data_key['status'], 'open')
+        self._write_to_hub(self._sid, **{self._data_key['status']: 'open'})
 
     def stop_cover(self, **kwargs):
         """Stop the cover."""
-        self._write_to_hub(self._sid, self._data_key['status'], 'stop')
+        self._write_to_hub(self._sid, **{self._data_key['status']: 'stop'})
 
     def set_cover_position(self, position, **kwargs):
         """Move the cover to a specific position."""
-        self._write_to_hub(self._sid, self._data_key['pos'], str(position))
+        self._write_to_hub(self._sid, **{self._data_key['pos']: str(position)})
 
     def parse_data(self, data):
         """Parse data sent by gateway."""

homeassistant/components/device_tracker/automatic.py

@@ -6,28 +6,32 @@ https://home-assistant.io/components/device_tracker.automatic/
 """
 import asyncio
 from datetime import timedelta
+import json
 import logging
+import os
 
+from aiohttp import web
 import voluptuous as vol
 
 from homeassistant.components.device_tracker import (
     PLATFORM_SCHEMA, ATTR_ATTRIBUTES, ATTR_DEV_ID, ATTR_HOST_NAME, ATTR_MAC,
     ATTR_GPS, ATTR_GPS_ACCURACY)
-from homeassistant.const import (
-    CONF_USERNAME, CONF_PASSWORD, EVENT_HOMEASSISTANT_STOP,
-    EVENT_HOMEASSISTANT_START)
+from homeassistant.components.http import HomeAssistantView
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import async_track_time_interval
 
-REQUIREMENTS = ['aioautomatic==0.4.0']
+REQUIREMENTS = ['aioautomatic==0.6.2']
+DEPENDENCIES = ['http']
 
 _LOGGER = logging.getLogger(__name__)
 
 CONF_CLIENT_ID = 'client_id'
 CONF_SECRET = 'secret'
 CONF_DEVICES = 'devices'
+CONF_CURRENT_LOCATION = 'current_location'
 
 DEFAULT_TIMEOUT = 5
 
@@ -38,38 +42,74 @@ ATTR_FUEL_LEVEL = 'fuel_level'
 
 EVENT_AUTOMATIC_UPDATE = 'automatic_update'
 
+AUTOMATIC_CONFIG_FILE = '.automatic/session-{}.json'
+
+DATA_CONFIGURING = 'automatic_configurator_clients'
+DATA_REFRESH_TOKEN = 'refresh_token'
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_CLIENT_ID): cv.string,
     vol.Required(CONF_SECRET): cv.string,
-    vol.Required(CONF_USERNAME): cv.string,
-    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_CURRENT_LOCATION, default=False): cv.boolean,
     vol.Optional(CONF_DEVICES, default=None): vol.All(
         cv.ensure_list, [cv.string])
 })
 
 
+def _get_refresh_token_from_file(hass, filename):
+    """Attempt to load session data from file."""
+    path = hass.config.path(filename)
+
+    if not os.path.isfile(path):
+        return None
+
+    try:
+        with open(path) as data_file:
+            data = json.load(data_file)
+            if data is None:
+                return None
+
+            return data.get(DATA_REFRESH_TOKEN)
+    except ValueError:
+        return None
+
+
+def _write_refresh_token_to_file(hass, filename, refresh_token):
+    """Attempt to store session data to file."""
+    path = hass.config.path(filename)
+
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, 'w+') as data_file:
+        json.dump({
+            DATA_REFRESH_TOKEN: refresh_token
+        }, data_file)
+
+
 @asyncio.coroutine
 def async_setup_scanner(hass, config, async_see, discovery_info=None):
     """Validate the configuration and return an Automatic scanner."""
     import aioautomatic
 
+    hass.http.register_view(AutomaticAuthCallbackView())
+
+    scope = FULL_SCOPE if config.get(CONF_CURRENT_LOCATION) else DEFAULT_SCOPE
+
     client = aioautomatic.Client(
         client_id=config[CONF_CLIENT_ID],
         client_secret=config[CONF_SECRET],
         client_session=async_get_clientsession(hass),
         request_kwargs={'timeout': DEFAULT_TIMEOUT})
-    try:
-        try:
-            session = yield from client.create_session_from_password(
-                FULL_SCOPE, config[CONF_USERNAME], config[CONF_PASSWORD])
-        except aioautomatic.exceptions.ForbiddenError as exc:
-            if not str(exc).startswith("invalid_scope"):
-                raise exc
-            _LOGGER.info("Client not authorized for current_location scope. "
-                         "location:updated events will not be received.")
-            session = yield from client.create_session_from_password(
-                DEFAULT_SCOPE, config[CONF_USERNAME], config[CONF_PASSWORD])
 
+    filename = AUTOMATIC_CONFIG_FILE.format(config[CONF_CLIENT_ID])
+    refresh_token = yield from hass.async_add_job(
+        _get_refresh_token_from_file, hass, filename)
+
+    @asyncio.coroutine
+    def initialize_data(session):
+        """Initialize the AutomaticData object from the created session."""
+        hass.async_add_job(
+            _write_refresh_token_to_file, hass, filename,
+            session.refresh_token)
         data = AutomaticData(
             hass, client, session, config[CONF_DEVICES], async_see)
 
@@ -77,26 +117,86 @@ def async_setup_scanner(hass, config, async_see, discovery_info=None):
         vehicles = yield from session.get_vehicles()
         for vehicle in vehicles:
             hass.async_add_job(data.load_vehicle(vehicle))
-    except aioautomatic.exceptions.AutomaticError as err:
-        _LOGGER.error(str(err))
-        return False
 
-    @callback
-    def ws_connect(event):
-        """Open the websocket connection."""
-        hass.async_add_job(data.ws_connect())
+        # Create a task instead of adding a tracking job, since this task will
+        # run until the websocket connection is closed.
+        hass.loop.create_task(data.ws_connect())
 
-    @callback
-    def ws_close(event):
-        """Close the websocket connection."""
-        hass.async_add_job(data.ws_close())
+    if refresh_token is not None:
+        try:
+            session = yield from client.create_session_from_refresh_token(
+                refresh_token)
+            yield from initialize_data(session)
+            return True
+        except aioautomatic.exceptions.AutomaticError as err:
+            _LOGGER.error(str(err))
 
-    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, ws_connect)
-    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, ws_close)
+    configurator = hass.components.configurator
+    request_id = configurator.async_request_config(
+        "Automatic", description=(
+            "Authorization required for Automatic device tracker."),
+        link_name="Click here to authorize Home Assistant.",
+        link_url=client.generate_oauth_url(scope),
+        entity_picture="/static/images/logo_automatic.png",
+    )
 
+    @asyncio.coroutine
+    def initialize_callback(code, state):
+        """Callback after OAuth2 response is returned."""
+        try:
+            session = yield from client.create_session_from_oauth_code(
+                code, state)
+            yield from initialize_data(session)
+            configurator.async_request_done(request_id)
+        except aioautomatic.exceptions.AutomaticError as err:
+            _LOGGER.error(str(err))
+            configurator.async_notify_errors(request_id, str(err))
+            return False
+
+    if DATA_CONFIGURING not in hass.data:
+        hass.data[DATA_CONFIGURING] = {}
+
+    hass.data[DATA_CONFIGURING][client.state] = initialize_callback
     return True
 
 
+class AutomaticAuthCallbackView(HomeAssistantView):
+    """Handle OAuth finish callback requests."""
+
+    requires_auth = False
+    url = '/api/automatic/callback'
+    name = 'api:automatic:callback'
+
+    @callback
+    def get(self, request):  # pylint: disable=no-self-use
+        """Finish OAuth callback request."""
+        hass = request.app['hass']
+        params = request.query
+        response = web.HTTPFound('/states')
+
+        if 'state' not in params or 'code' not in params:
+            if 'error' in params:
+                _LOGGER.error(
+                    "Error authorizing Automatic: %s", params['error'])
+                return response
+            else:
+                _LOGGER.error(
+                    "Error authorizing Automatic. Invalid response returned.")
+                return response
+
+        if DATA_CONFIGURING not in hass.data or \
+                params['state'] not in hass.data[DATA_CONFIGURING]:
+            _LOGGER.error("Automatic configuration request not found.")
+            return response
+
+        code = params['code']
+        state = params['state']
+        initialize_callback = hass.data[DATA_CONFIGURING][state]
+        hass.async_add_job(initialize_callback(code, state))
+
+        return response
+
+
 class AutomaticData(object):
     """A class representing an Automatic cloud service connection."""
 
@@ -105,6 +205,7 @@ class AutomaticData(object):
         self.hass = hass
         self.devices = devices
         self.vehicle_info = {}
+        self.vehicle_seen = {}
         self.client = client
         self.session = session
         self.async_see = async_see
@@ -115,6 +216,8 @@ class AutomaticData(object):
             lambda name, event: self.hass.async_add_job(
                 self.handle_event(name, event)))
 
+        hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self.ws_close())
+
     @asyncio.coroutine
     def handle_event(self, name, event):
         """Coroutine to update state for a realtime event."""
@@ -134,6 +237,14 @@ class AutomaticData(object):
                 return
             yield from self.get_vehicle_info(vehicle)
 
+        if event.created_at < self.vehicle_seen[event.vehicle.id]:
+            # Skip events received out of order
+            _LOGGER.debug("Skipping out of order event. Event Created %s. "
+                          "Last seen event: %s.", event.created_at,
+                          self.vehicle_seen[event.vehicle.id])
+            return
+        self.vehicle_seen[event.vehicle.id] = event.created_at
+
         kwargs = self.vehicle_info[event.vehicle.id]
         if kwargs is None:
             # Ignored device
@@ -221,15 +332,17 @@ class AutomaticData(object):
         if self.devices is not None and name not in self.devices:
             self.vehicle_info[vehicle.id] = None
             return
-        else:
-            self.vehicle_info[vehicle.id] = kwargs = {
-                ATTR_DEV_ID: vehicle.id,
-                ATTR_HOST_NAME: name,
-                ATTR_MAC: vehicle.id,
-                ATTR_ATTRIBUTES: {
-                    ATTR_FUEL_LEVEL: vehicle.fuel_level_percent,
-                }
+
+        self.vehicle_info[vehicle.id] = kwargs = {
+            ATTR_DEV_ID: vehicle.id,
+            ATTR_HOST_NAME: name,
+            ATTR_MAC: vehicle.id,
+            ATTR_ATTRIBUTES: {
+                ATTR_FUEL_LEVEL: vehicle.fuel_level_percent,
             }
+        }
+        self.vehicle_seen[vehicle.id] = \
+            vehicle.updated_at or vehicle.created_at
 
         if vehicle.latest_location is not None:
             location = vehicle.latest_location
@@ -250,4 +363,7 @@ class AutomaticData(object):
             kwargs[ATTR_GPS] = (location.lat, location.lon)
             kwargs[ATTR_GPS_ACCURACY] = location.accuracy_m
 
+            if trips[0].ended_at >= self.vehicle_seen[vehicle.id]:
+                self.vehicle_seen[vehicle.id] = trips[0].ended_at
+
         return kwargs

homeassistant/components/device_tracker/geofency.py

@@ -0,0 +1,127 @@
+"""
+Support for the Geofency platform.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.geofency/
+"""
+import asyncio
+from functools import partial
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.device_tracker import PLATFORM_SCHEMA
+from homeassistant.components.http import HomeAssistantView
+from homeassistant.const import (
+    ATTR_LATITUDE, ATTR_LONGITUDE, HTTP_UNPROCESSABLE_ENTITY, STATE_NOT_HOME)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.util import slugify
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['http']
+
+BEACON_DEV_PREFIX = 'beacon'
+CONF_MOBILE_BEACONS = 'mobile_beacons'
+
+LOCATION_ENTRY = '1'
+LOCATION_EXIT = '0'
+
+URL = '/api/geofency'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_MOBILE_BEACONS): vol.All(
+        cv.ensure_list, [cv.string]),
+})
+
+
+def setup_scanner(hass, config, see, discovery_info=None):
+    """Set up an endpoint for the Geofency application."""
+    mobile_beacons = config.get(CONF_MOBILE_BEACONS) or []
+
+    hass.http.register_view(GeofencyView(see, mobile_beacons))
+
+    return True
+
+
+class GeofencyView(HomeAssistantView):
+    """View to handle Geofency requests."""
+
+    url = URL
+    name = 'api:geofency'
+
+    def __init__(self, see, mobile_beacons):
+        """Initialize Geofency url endpoints."""
+        self.see = see
+        self.mobile_beacons = [slugify(beacon) for beacon in mobile_beacons]
+
+    @asyncio.coroutine
+    def post(self, request):
+        """Handle Geofency requests."""
+        data = yield from request.post()
+        hass = request.app['hass']
+
+        data = self._validate_data(data)
+        if not data:
+            return ("Invalid data", HTTP_UNPROCESSABLE_ENTITY)
+
+        if self._is_mobile_beacon(data):
+            return (yield from self._set_location(hass, data, None))
+        else:
+            if data['entry'] == LOCATION_ENTRY:
+                location_name = data['name']
+            else:
+                location_name = STATE_NOT_HOME
+
+            return (yield from self._set_location(hass, data, location_name))
+
+    @staticmethod
+    def _validate_data(data):
+        """Validate POST payload."""
+        data = data.copy()
+
+        required_attributes = ['address', 'device', 'entry',
+                               'latitude', 'longitude', 'name']
+
+        valid = True
+        for attribute in required_attributes:
+            if attribute not in data:
+                valid = False
+                _LOGGER.error("'%s' not specified in message", attribute)
+
+        if not valid:
+            return False
+
+        data['address'] = data['address'].replace('\n', ' ')
+        data['device'] = slugify(data['device'])
+        data['name'] = slugify(data['name'])
+
+        data[ATTR_LATITUDE] = float(data[ATTR_LATITUDE])
+        data[ATTR_LONGITUDE] = float(data[ATTR_LONGITUDE])
+
+        return data
+
+    def _is_mobile_beacon(self, data):
+        """Check if we have a mobile beacon."""
+        return 'beaconUUID' in data and data['name'] in self.mobile_beacons
+
+    @staticmethod
+    def _device_name(data):
+        """Return name of device tracker."""
+        if 'beaconUUID' in data:
+            return "{}_{}".format(BEACON_DEV_PREFIX, data['name'])
+        else:
+            return data['device']
+
+    @asyncio.coroutine
+    def _set_location(self, hass, data, location_name):
+        """Fire HA event to set location."""
+        device = self._device_name(data)
+
+        yield from hass.async_add_job(
+            partial(self.see, dev_id=device,
+                    gps=(data[ATTR_LATITUDE], data[ATTR_LONGITUDE]),
+                    location_name=location_name,
+                    attributes=data))
+
+        return "Setting location for {}".format(device)

homeassistant/components/device_tracker/icloud.py

@@ -19,7 +19,6 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.util import slugify
 import homeassistant.util.dt as dt_util
 from homeassistant.util.location import distance
-from homeassistant.loader import get_component
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -209,7 +208,7 @@ class Icloud(DeviceScanner):
 
         if self.accountname in _CONFIGURING:
             request_id = _CONFIGURING.pop(self.accountname)
-            configurator = get_component('configurator')
+            configurator = self.hass.components.configurator
             configurator.request_done(request_id)
 
         # Trigger the next step immediately
@@ -217,7 +216,7 @@ class Icloud(DeviceScanner):
 
     def icloud_need_trusted_device(self):
         """We need a trusted device."""
-        configurator = get_component('configurator')
+        configurator = self.hass.components.configurator
         if self.accountname in _CONFIGURING:
             return
 
@@ -229,7 +228,7 @@ class Icloud(DeviceScanner):
             devicesstring += "{}: {};".format(i, devicename)
 
         _CONFIGURING[self.accountname] = configurator.request_config(
-            self.hass, 'iCloud {}'.format(self.accountname),
+            'iCloud {}'.format(self.accountname),
             self.icloud_trusted_device_callback,
             description=(
                 'Please choose your trusted device by entering'
@@ -259,17 +258,17 @@ class Icloud(DeviceScanner):
 
         if self.accountname in _CONFIGURING:
             request_id = _CONFIGURING.pop(self.accountname)
-            configurator = get_component('configurator')
+            configurator = self.hass.components.configurator
             configurator.request_done(request_id)
 
     def icloud_need_verification_code(self):
         """Return the verification code."""
-        configurator = get_component('configurator')
+        configurator = self.hass.components.configurator
         if self.accountname in _CONFIGURING:
             return
 
         _CONFIGURING[self.accountname] = configurator.request_config(
-            self.hass, 'iCloud {}'.format(self.accountname),
+            'iCloud {}'.format(self.accountname),
             self.icloud_verification_callback,
             description=('Please enter the validation code:'),
             entity_picture="/static/images/config_icloud.png",
@@ -308,12 +307,15 @@ class Icloud(DeviceScanner):
             self.api.authenticate()
 
         currentminutes = dt_util.now().hour * 60 + dt_util.now().minute
-        for devicename in self.devices:
-            interval = self._intervals.get(devicename, 1)
-            if ((currentminutes % interval == 0) or
-                    (interval > 10 and
-                     currentminutes % interval in [2, 4])):
-                self.update_device(devicename)
+        try:
+            for devicename in self.devices:
+                interval = self._intervals.get(devicename, 1)
+                if ((currentminutes % interval == 0) or
+                        (interval > 10 and
+                         currentminutes % interval in [2, 4])):
+                    self.update_device(devicename)
+        except ValueError:
+            _LOGGER.debug("iCloud API returned an error")
 
     def determine_interval(self, devicename, latitude, longitude, battery):
         """Calculate new interval."""
@@ -398,7 +400,7 @@ class Icloud(DeviceScanner):
                     self.see(**kwargs)
                     self.seen_devices[devicename] = True
         except PyiCloudNoDevicesException:
-            _LOGGER.error('No iCloud Devices found!')
+            _LOGGER.error("No iCloud Devices found")
 
     def lost_iphone(self, devicename):
         """Call the lost iPhone function if the device is found."""

homeassistant/components/device_tracker/mysensors.py

@@ -4,61 +4,51 @@ Support for tracking MySensors devices.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
+from homeassistant.components.device_tracker import DOMAIN
+from homeassistant.helpers.dispatcher import dispatcher_connect
 from homeassistant.util import slugify
 
-DEPENDENCIES = ['mysensors']
-
-_LOGGER = logging.getLogger(__name__)
-
 
 def setup_scanner(hass, config, see, discovery_info=None):
-    """Set up the MySensors tracker."""
-    def mysensors_callback(gateway, msg):
-        """Set up callback for mysensors platform."""
-        node = gateway.sensors[msg.node_id]
-        if node.sketch_name is None:
-            _LOGGER.debug("No sketch_name: node %s", msg.node_id)
-            return
+    """Set up the MySensors device scanner."""
+    new_devices = mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsDeviceScanner,
+        device_args=(see, ))
+    if not new_devices:
+        return False
 
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-
-        child = node.children.get(msg.child_id)
-        if child is None:
-            return
-        position = child.values.get(set_req.V_POSITION)
-        if child.type != pres.S_GPS or position is None:
-            return
-        try:
-            latitude, longitude, _ = position.split(',')
-        except ValueError:
-            _LOGGER.error("Payload for V_POSITION %s is not of format "
-                          "latitude, longitude, altitude", position)
-            return
-        name = '{} {} {}'.format(
-            node.sketch_name, msg.node_id, child.id)
-        attr = {
-            mysensors.ATTR_CHILD_ID: child.id,
-            mysensors.ATTR_DESCRIPTION: child.description,
-            mysensors.ATTR_DEVICE: gateway.device,
-            mysensors.ATTR_NODE_ID: msg.node_id,
-        }
-        see(
-            dev_id=slugify(name),
-            host_name=name,
-            gps=(latitude, longitude),
-            battery=node.battery_level,
-            attributes=attr
-        )
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-
-    for gateway in gateways:
-        if float(gateway.protocol_version) < 2.0:
-            continue
-        gateway.platform_callbacks.append(mysensors_callback)
+    for device in new_devices:
+        dev_id = (
+            id(device.gateway), device.node_id, device.child_id,
+            device.value_type)
+        dispatcher_connect(
+            hass, mysensors.SIGNAL_CALLBACK.format(*dev_id),
+            device.update_callback)
 
     return True
+
+
+class MySensorsDeviceScanner(mysensors.MySensorsDevice):
+    """Represent a MySensors scanner."""
+
+    def __init__(self, see, *args):
+        """Set up instance."""
+        super().__init__(*args)
+        self.see = see
+
+    def update_callback(self):
+        """Update the device."""
+        self.update()
+        node = self.gateway.sensors[self.node_id]
+        child = node.children[self.child_id]
+        position = child.values[self.value_type]
+        latitude, longitude, _ = position.split(',')
+
+        self.see(
+            dev_id=slugify(self.name),
+            host_name=self.name,
+            gps=(latitude, longitude),
+            battery=node.battery_level,
+            attributes=self.device_state_attributes
+        )

homeassistant/components/device_tracker/tesla.py

@@ -0,0 +1,57 @@
+"""
+Support for the Tesla platform.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.tesla/
+"""
+import logging
+
+from homeassistant.components.tesla import DOMAIN as TESLA_DOMAIN
+from homeassistant.helpers.event import track_utc_time_change
+from homeassistant.util import slugify
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['tesla']
+
+
+def setup_scanner(hass, config, see, discovery_info=None):
+    """Set up the Tesla tracker."""
+    TeslaDeviceTracker(
+        hass, config, see,
+        hass.data[TESLA_DOMAIN]['devices']['devices_tracker'])
+    return True
+
+
+class TeslaDeviceTracker(object):
+    """A class representing a Tesla device."""
+
+    def __init__(self, hass, config, see, tesla_devices):
+        """Initialize the Tesla device scanner."""
+        self.hass = hass
+        self.see = see
+        self.devices = tesla_devices
+        self._update_info()
+
+        track_utc_time_change(
+            self.hass, self._update_info, second=range(0, 60, 30))
+
+    def _update_info(self, now=None):
+        """Update the device info."""
+        for device in self.devices:
+            device.update()
+            name = device.name
+            _LOGGER.debug("Updating device position: %s", name)
+            dev_id = slugify(device.uniq_name)
+            location = device.get_location()
+            lat = location['latitude']
+            lon = location['longitude']
+            attrs = {
+                'trackr_id': dev_id,
+                'id': dev_id,
+                'name': name
+            }
+            self.see(
+                dev_id=dev_id, host_name=name,
+                gps=(lat, lon), attributes=attrs
+            )

homeassistant/components/device_tracker/volvooncall.py

@@ -20,11 +20,12 @@ def setup_scanner(hass, config, see, discovery_info=None):
         return
 
     vin, _ = discovery_info
-    vehicle = hass.data[DATA_KEY].vehicles[vin]
+    voc = hass.data[DATA_KEY]
+    vehicle = voc.vehicles[vin]
 
     def see_vehicle(vehicle):
         """Handle the reporting of the vehicle position."""
-        host_name = vehicle.registration_number
+        host_name = voc.vehicle_name(vehicle)
         dev_id = 'volvo_{}'.format(slugify(host_name))
         see(dev_id=dev_id,
             host_name=host_name,

homeassistant/components/discovery.py

@@ -100,6 +100,7 @@ def async_setup(hass, config):
 
         # We do not know how to handle this service.
         if not comp_plat:
+            logger.info("Unknown service discovered: %s %s", service, info)
             return
 
         discovery_hash = json.dumps([service, info], sort_keys=True)

homeassistant/components/ecobee.py

@@ -13,10 +13,9 @@ import voluptuous as vol
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers import discovery
 from homeassistant.const import CONF_API_KEY
-from homeassistant.loader import get_component
 from homeassistant.util import Throttle
 
-REQUIREMENTS = ['python-ecobee-api==0.0.7']
+REQUIREMENTS = ['python-ecobee-api==0.0.9']
 
 _CONFIGURING = {}
 _LOGGER = logging.getLogger(__name__)
@@ -41,7 +40,7 @@ CONFIG_SCHEMA = vol.Schema({
 
 def request_configuration(network, hass, config):
     """Request configuration steps from the user."""
-    configurator = get_component('configurator')
+    configurator = hass.components.configurator
     if 'ecobee' in _CONFIGURING:
         configurator.notify_errors(
             _CONFIGURING['ecobee'], "Failed to register, please try again.")
@@ -56,7 +55,7 @@ def request_configuration(network, hass, config):
         setup_ecobee(hass, network, config)
 
     _CONFIGURING['ecobee'] = configurator.request_config(
-        hass, "Ecobee", ecobee_configuration_callback,
+        "Ecobee", ecobee_configuration_callback,
         description=(
             'Please authorize this app at https://www.ecobee.com/consumer'
             'portal/index.html with pin code: ' + network.pin),
@@ -73,7 +72,7 @@ def setup_ecobee(hass, network, config):
         return
 
     if 'ecobee' in _CONFIGURING:
-        configurator = get_component('configurator')
+        configurator = hass.components.configurator
         configurator.request_done(_CONFIGURING.pop('ecobee'))
 
     hold_temp = config[DOMAIN].get(CONF_HOLD_TEMP)

homeassistant/components/emulated_hue/upnp.py

@@ -2,7 +2,6 @@
 import threading
 import socket
 import logging
-import os
 import select
 
 from aiohttp import web
@@ -86,18 +85,6 @@ USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1
             advertise_ip, advertise_port).replace("\n", "\r\n") \
                                          .encode('utf-8')
 
-        # Set up a pipe for signaling to the receiver that it's time to
-        # shutdown. Essentially, we place the SSDP socket into nonblocking
-        # mode and use select() to wait for data to arrive on either the SSDP
-        # socket or the pipe. If data arrives on either one, select() returns
-        # and tells us which filenos have data ready to read.
-        #
-        # When we want to stop the responder, we write data to the pipe, which
-        # causes the select() to return and indicate that said pipe has data
-        # ready to be read, which indicates to us that the responder needs to
-        # be shutdown.
-        self._interrupted_read_pipe, self._interrupted_write_pipe = os.pipe()
-
     def run(self):
         """Run the server."""
         # Listen for UDP port 1900 packets sent to SSDP multicast address
@@ -119,7 +106,7 @@ USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1
             socket.inet_aton(self.host_ip_addr))
 
         if self.upnp_bind_multicast:
-            ssdp_socket.bind(("239.255.255.250", 1900))
+            ssdp_socket.bind(("", 1900))
         else:
             ssdp_socket.bind((self.host_ip_addr, 1900))
 
@@ -130,16 +117,13 @@ USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1
 
             try:
                 read, _, _ = select.select(
-                    [self._interrupted_read_pipe, ssdp_socket], [],
-                    [ssdp_socket])
+                    [ssdp_socket], [],
+                    [ssdp_socket], 2)
 
-                if self._interrupted_read_pipe in read:
-                    # Implies self._interrupted is True
-                    clean_socket_close(ssdp_socket)
-                    return
-                elif ssdp_socket in read:
+                if ssdp_socket in read:
                     data, addr = ssdp_socket.recvfrom(1024)
                 else:
+                    # most likely the timeout, so check for interupt
                     continue
             except socket.error as ex:
                 if self._interrupted:
@@ -148,6 +132,9 @@ USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1
 
                 _LOGGER.error("UPNP Responder socket exception occured: %s",
                               ex.__str__)
+                # without the following continue, a second exception occurs
+                # because the data object has not been initialized
+                continue
 
             if "M-SEARCH" in data.decode('utf-8'):
                 # SSDP M-SEARCH method received, respond to it with our info
@@ -161,7 +148,6 @@ USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1
         """Stop the server."""
         # Request for server
         self._interrupted = True
-        os.write(self._interrupted_write_pipe, bytes([0]))
         self.join()
 
 

homeassistant/components/envisalink.py

@@ -16,7 +16,7 @@ from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.discovery import async_load_platform
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
-REQUIREMENTS = ['pyenvisalink==2.1']
+REQUIREMENTS = ['pyenvisalink==2.2']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -74,9 +74,9 @@ CONFIG_SCHEMA = vol.Schema({
             vol.All(vol.Coerce(int), vol.Range(min=3, max=4)),
         vol.Optional(CONF_EVL_KEEPALIVE, default=DEFAULT_KEEPALIVE):
             vol.All(vol.Coerce(int), vol.Range(min=15)),
-        vol.Optional(CONF_ZONEDUMP_INTERVAL,
-                     default=DEFAULT_ZONEDUMP_INTERVAL):
-            vol.All(vol.Coerce(int), vol.Range(min=15)),
+        vol.Optional(
+            CONF_ZONEDUMP_INTERVAL,
+            default=DEFAULT_ZONEDUMP_INTERVAL): vol.Coerce(int),
     }),
 }, extra=vol.ALLOW_EXTRA)
 

homeassistant/components/fan/insteon_local.py

@@ -13,7 +13,6 @@ from homeassistant.components.fan import (
     ATTR_SPEED, SPEED_OFF, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH,
     SUPPORT_SET_SPEED, FanEntity)
 from homeassistant.helpers.entity import ToggleEntity
-from homeassistant.loader import get_component
 import homeassistant.util as util
 
 _CONFIGURING = {}
@@ -57,7 +56,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 def request_configuration(device_id, insteonhub, model, hass,
                           add_devices_callback):
     """Request configuration steps from the user."""
-    configurator = get_component('configurator')
+    configurator = hass.components.configurator
 
     # We got an error if this method is called while we are configuring
     if device_id in _CONFIGURING:
@@ -72,7 +71,7 @@ def request_configuration(device_id, insteonhub, model, hass,
                   add_devices_callback)
 
     _CONFIGURING[device_id] = configurator.request_config(
-        hass, 'Insteon  ' + model + ' addr: ' + device_id,
+        'Insteon  ' + model + ' addr: ' + device_id,
         insteon_fan_config_callback,
         description=('Enter a name for ' + model + ' Fan addr: ' + device_id),
         entity_picture='/static/images/config_insteon.png',
@@ -85,7 +84,7 @@ def setup_fan(device_id, name, insteonhub, hass, add_devices_callback):
     """Set up the fan."""
     if device_id in _CONFIGURING:
         request_id = _CONFIGURING.pop(device_id)
-        configurator = get_component('configurator')
+        configurator = hass.components.configurator
         configurator.request_done(request_id)
         _LOGGER.info("Device configuration done!")
 

homeassistant/components/fan/isy994.py

@@ -16,6 +16,11 @@ from homeassistant.helpers.typing import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
 
+# Define term used for medium speed. This must be set as the fan component uses
+# 'medium' which the ISY does not understand
+ISY_SPEED_MEDIUM = 'med'
+
+
 VALUE_TO_STATE = {
     0: SPEED_OFF,
     63: SPEED_LOW,
@@ -29,7 +34,7 @@ STATE_TO_VALUE = {}
 for key in VALUE_TO_STATE:
     STATE_TO_VALUE[VALUE_TO_STATE[key]] = key
 
-STATES = [SPEED_OFF, SPEED_LOW, 'med', SPEED_HIGH]
+STATES = [SPEED_OFF, SPEED_LOW, ISY_SPEED_MEDIUM, SPEED_HIGH]
 
 
 # pylint: disable=unused-argument
@@ -93,6 +98,11 @@ class ISYFanDevice(isy.ISYDevice, FanEntity):
         else:
             self.speed = self.state
 
+    @property
+    def speed_list(self) -> list:
+        """Get the list of available speeds."""
+        return [SPEED_OFF, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]
+
 
 class ISYFanProgram(ISYFanDevice):
     """Representation of an ISY994 fan program."""

homeassistant/components/ffmpeg.py

@@ -19,7 +19,7 @@ from homeassistant.helpers.dispatcher import (
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import Entity
 
-REQUIREMENTS = ['ha-ffmpeg==1.5']
+REQUIREMENTS = ['ha-ffmpeg==1.7']
 
 DOMAIN = 'ffmpeg'
 

homeassistant/components/frontend/__init__.py

@@ -28,6 +28,7 @@ URL_PANEL_COMPONENT_FP = '/frontend/panels/{}-{}.html'
 STATIC_PATH = os.path.join(os.path.dirname(__file__), 'www_static/')
 
 ATTR_THEMES = 'themes'
+ATTR_EXTRA_HTML_URL = 'extra_html_url'
 DEFAULT_THEME_COLOR = '#03A9F4'
 MANIFEST_JSON = {
     'background_color': '#FFFFFF',
@@ -50,6 +51,7 @@ for size in (192, 384, 512, 1024):
     })
 
 DATA_PANELS = 'frontend_panels'
+DATA_EXTRA_HTML_URL = 'frontend_extra_html_url'
 DATA_INDEX_VIEW = 'frontend_index_view'
 DATA_THEMES = 'frontend_themes'
 DATA_DEFAULT_THEME = 'frontend_default_theme'
@@ -66,6 +68,8 @@ CONFIG_SCHEMA = vol.Schema({
         vol.Optional(ATTR_THEMES): vol.Schema({
             cv.string: {cv.string: cv.string}
         }),
+        vol.Optional(ATTR_EXTRA_HTML_URL):
+            vol.All(cv.ensure_list, [cv.string]),
     }),
 }, extra=vol.ALLOW_EXTRA)
 
@@ -105,14 +109,13 @@ def register_panel(hass, component_name, path, md5=None, sidebar_title=None,
 
     component_name: name of the web component
     path: path to the HTML of the web component
+          (required unless url is provided)
     md5: the md5 hash of the web component (for versioning, optional)
     sidebar_title: title to show in the sidebar (optional)
     sidebar_icon: icon to show next to title in sidebar (optional)
     url_path: name to use in the url (defaults to component_name)
-    url: for the web component (for dev environment, optional)
+    url: for the web component (optional)
     config: config to be passed into the web component
-
-    Warning: this API will probably change. Use at own risk.
     """
     panels = hass.data.get(DATA_PANELS)
     if panels is None:
@@ -123,14 +126,16 @@ def register_panel(hass, component_name, path, md5=None, sidebar_title=None,
 
     if url_path in panels:
         _LOGGER.warning("Overwriting component %s", url_path)
-    if not os.path.isfile(path):
-        _LOGGER.error(
-            "Panel %s component does not exist: %s", component_name, path)
-        return
 
-    if md5 is None:
-        with open(path) as fil:
-            md5 = hashlib.md5(fil.read().encode('utf-8')).hexdigest()
+    if url is None:
+        if not os.path.isfile(path):
+            _LOGGER.error(
+                "Panel %s component does not exist: %s", component_name, path)
+            return
+
+        if md5 is None:
+            with open(path) as fil:
+                md5 = hashlib.md5(fil.read().encode('utf-8')).hexdigest()
 
     data = {
         'url_path': url_path,
@@ -169,6 +174,15 @@ def register_panel(hass, component_name, path, md5=None, sidebar_title=None,
             'get', '/{}/{{extra:.+}}'.format(url_path), index_view.get)
 
 
+@bind_hass
+def add_extra_html_url(hass, url):
+    """Register extra html url to load."""
+    url_set = hass.data.get(DATA_EXTRA_HTML_URL)
+    if url_set is None:
+        url_set = hass.data[DATA_EXTRA_HTML_URL] = set()
+    url_set.add(url)
+
+
 def add_manifest_json_key(key, val):
     """Add a keyval to the manifest.json."""
     MANIFEST_JSON[key] = val
@@ -208,6 +222,9 @@ def setup(hass, config):
     else:
         hass.data[DATA_PANELS] = {}
 
+    if DATA_EXTRA_HTML_URL not in hass.data:
+        hass.data[DATA_EXTRA_HTML_URL] = set()
+
     register_built_in_panel(hass, 'map', 'Map', 'mdi:account-location')
 
     for panel in ('dev-event', 'dev-info', 'dev-service', 'dev-state',
@@ -217,6 +234,9 @@ def setup(hass, config):
     themes = config.get(DOMAIN, {}).get(ATTR_THEMES)
     setup_themes(hass, themes)
 
+    for url in config.get(DOMAIN, {}).get(ATTR_EXTRA_HTML_URL, []):
+        add_extra_html_url(hass, url)
+
     return True
 
 
@@ -362,7 +382,9 @@ class IndexView(HomeAssistantView):
             compatibility_url=compatibility_url, no_auth=no_auth,
             icons_url=icons_url, icons=FINGERPRINTS['mdi.html'],
             panel_url=panel_url, panels=hass.data[DATA_PANELS],
-            dev_mode=request.app[KEY_DEVELOPMENT])
+            dev_mode=request.app[KEY_DEVELOPMENT],
+            theme_color=MANIFEST_JSON['theme_color'],
+            extra_urls=hass.data[DATA_EXTRA_HTML_URL])
 
         return web.Response(text=resp, content_type='text/html')
 

homeassistant/components/frontend/templates/index.html

@@ -21,7 +21,7 @@
     <meta name="msapplication-TileColor" content="#3fbbf4ff"/>
     <meta name='mobile-web-app-capable' content='yes'>
     <meta name='viewport' content='width=device-width, user-scalable=no'>
-    <meta name='theme-color' content='#03a9f4'>
+    <meta name='theme-color' content='{{ theme_color }}'>
     <style>
       body {
         font-family: 'Roboto', 'Noto', sans-serif;
@@ -97,6 +97,10 @@
       <link rel='import' href='{{ panel_url }}' onerror='initError()' async>
     {% endif -%}
     <link rel='import' href='{{ icons_url }}' async>
+    {% for extra_url in extra_urls -%}
+      <link rel='import' href='{{ extra_url }}' async>
+    {% endfor -%}
+
     <script>
       var webComponentsSupported = (
         'registerElement' in document &&

homeassistant/components/frontend/version.py

@@ -3,22 +3,22 @@
 FINGERPRINTS = {
     "compatibility.js": "1686167ff210e001f063f5c606b2e74b",
     "core.js": "2a7d01e45187c7d4635da05065b5e54e",
-    "frontend.html": "5a2a3d6181cc820f5b3e94d1a50def74",
-    "mdi.html": "e91f61a039ed0a9936e7ee5360da3870",
+    "frontend.html": "c04709d3517dd3fd34b2f7d6bba6ec8e",
+    "mdi.html": "89074face5529f5fe6fbae49ecb3e88b",
     "micromarkdown-js.html": "93b5ec4016f0bba585521cf4d18dec1a",
-    "panels/ha-panel-config.html": "ec48185c79000d0cfe5bbf38c7974944",
+    "panels/ha-panel-config.html": "0091008947ed61a6691c28093a6a6fcd",
     "panels/ha-panel-dev-event.html": "d409e7ab537d9fe629126d122345279c",
     "panels/ha-panel-dev-info.html": "b0e55eb657fd75f21aba2426ac0cedc0",
     "panels/ha-panel-dev-mqtt.html": "94b222b013a98583842de3e72d5888c6",
     "panels/ha-panel-dev-service.html": "422b2c181ee0713fa31d45a64e605baf",
     "panels/ha-panel-dev-state.html": "7948d3dba058f31517d880df8ed0e857",
-    "panels/ha-panel-dev-template.html": "f47b6910d8e4880e22cc508ca452f9b6",
+    "panels/ha-panel-dev-template.html": "928e7b81b9c113b70edc9f4a1d051827",
     "panels/ha-panel-hassio.html": "b46e7619f3c355f872d5370741d89f6a",
     "panels/ha-panel-history.html": "fe2daac10a14f51fa3eb7d23978df1f7",
     "panels/ha-panel-iframe.html": "56930204d6e067a3d600cf030f4b34c8",
     "panels/ha-panel-kiosk.html": "b40aa5cb52dd7675bea744afcf9eebf8",
     "panels/ha-panel-logbook.html": "771afdcf48dc7e308b0282417d2e02d8",
     "panels/ha-panel-mailbox.html": "a8cca44ca36553e91565e3c894ea6323",
-    "panels/ha-panel-map.html": "c2544fff3eedb487d44105cf94b335ec",
+    "panels/ha-panel-map.html": "565db019147162080c21af962afc097f",
     "panels/ha-panel-shopping-list.html": "d8cfd0ecdb3aa6214c0f6908c34c7141"
 }

homeassistant/components/frontend/www_static/panels/ha-panel-dev-template.html

@@ -1,2 +1,2 @@
 <html><head></head><body><dom-module id="ha-panel-dev-template"><template><style is="custom-style" include="ha-style iron-flex iron-positioning"></style><style>:host{-ms-user-select:initial;-webkit-user-select:initial;-moz-user-select:initial;}.content{padding:16px;}.edit-pane{margin-right:16px;}.edit-pane a{color:var(--dark-primary-color);}.horizontal .edit-pane{max-width:50%;}.render-pane{position:relative;max-width:50%;}.render-spinner{position:absolute;top:8px;right:8px;}.rendered{@apply (--paper-font-code1)
-        clear: both;white-space:pre-wrap;}.rendered.error{color:red;}</style><app-header-layout has-scrolling-region=""><app-header slot="header" fixed=""><app-toolbar><ha-menu-button narrow="[[narrow]]" show-menu="[[showMenu]]"></ha-menu-button><div main-title="">Templates</div></app-toolbar></app-header><div class$="[[computeFormClasses(narrow)]]"><div class="edit-pane"><p>Templates are rendered using the Jinja2 template engine with some Home Assistant specific extensions.</p><ul><li><a href="http://jinja.pocoo.org/docs/dev/templates/" target="_blank">Jinja2 template documentation</a></li><li><a href="https://home-assistant.io/topics/templating/" target="_blank">Home Assistant template extensions</a></li></ul><paper-textarea label="Template" value="{{template}}"></paper-textarea></div><div class="render-pane"><paper-spinner class="render-spinner" active="[[rendering]]"></paper-spinner><pre class$="[[computeRenderedClasses(error)]]">[[processed]]</pre></div></div></app-header-layout></template></dom-module><script>Polymer({is:"ha-panel-dev-template",properties:{hass:{type:Object},narrow:{type:Boolean,value:!1},showMenu:{type:Boolean,value:!1},error:{type:Boolean,value:!1},rendering:{type:Boolean,value:!1},template:{type:String,value:'Imitate available variables:\n{% set my_test_json = {\n  "temperature": 25,\n  "unit": "°C"\n} %}\n\nThe temperature is {{ my_test_json.temperature }} {{ my_test_json.unit }}. \n\n{% if is_state("device_tracker.paulus", "home") and \n       is_state("device_tracker.anne_therese", "home") -%}\n\n  You are both home, you silly\n\n{%- else -%}\n\n  Anne Therese is at {{ states("device_tracker.anne_therese") }} and Paulus is at {{ states("device_tracker.paulus") }}\n\n{%- endif %}\n\nFor loop example:\n{% for state in states.sensor -%}\n  {%- if loop.first %}The {% elif loop.last %} and the {% else %}, the {% endif -%}\n  {{ state.name | lower }} is {{state.state}} {{- state.attributes.unit_of_measurement}}\n{%- endfor -%}.',observer:"templateChanged"},processed:{type:String,value:""}},computeFormClasses:function(e){return e?"content fit":"content fit layout horizontal"},computeRenderedClasses:function(e){return e?"error rendered":"rendered"},templateChanged:function(){this.error&&(this.error=!1),this.debounce("render-template",this.renderTemplate.bind(this),500)},renderTemplate:function(){this.rendering=!0,this.hass.callApi("POST","template",{template:this.template}).then(function(e){this.processed=e,this.rendering=!1}.bind(this),function(e){this.processed=e.body.message,this.error=!0,this.rendering=!1}.bind(this))}});</script></body></html>
+        clear: both;white-space:pre-wrap;}.rendered.error{color:red;}</style><app-header-layout has-scrolling-region=""><app-header slot="header" fixed=""><app-toolbar><ha-menu-button narrow="[[narrow]]" show-menu="[[showMenu]]"></ha-menu-button><div main-title="">Templates</div></app-toolbar></app-header><div class$="[[computeFormClasses(narrow)]]"><div class="edit-pane"><p>Templates are rendered using the Jinja2 template engine with some Home Assistant specific extensions.</p><ul><li><a href="http://jinja.pocoo.org/docs/dev/templates/" target="_blank">Jinja2 template documentation</a></li><li><a href="https://home-assistant.io/topics/templating/" target="_blank">Home Assistant template extensions</a></li></ul><paper-textarea label="Template" value="{{template}}"></paper-textarea></div><div class="render-pane"><paper-spinner class="render-spinner" active="[[rendering]]"></paper-spinner><pre class$="[[computeRenderedClasses(error)]]">[[processed]]</pre></div></div></app-header-layout></template></dom-module><script>Polymer({is:"ha-panel-dev-template",properties:{hass:{type:Object},narrow:{type:Boolean,value:!1},showMenu:{type:Boolean,value:!1},error:{type:Boolean,value:!1},rendering:{type:Boolean,value:!1},template:{type:String,value:'Imitate available variables:\n{% set my_test_json = {\n  "temperature": 25,\n  "unit": "°C"\n} %}\n\nThe temperature is {{ my_test_json.temperature }} {{ my_test_json.unit }}. \n\n{% if is_state("device_tracker.paulus", "home") and \n       is_state("device_tracker.anne_therese", "home") -%}\n\n  You are both home, you silly\n\n{%- else -%}\n\n  Anne Therese is at {{ states("device_tracker.anne_therese") }} and Paulus is at {{ states("device_tracker.paulus") }}\n\n{%- endif %}\n\nFor loop example:\n{% for state in states.sensor -%}\n  {%- if loop.first %}The {% elif loop.last %} and the {% else %}, the {% endif -%}\n  {{ state.name | lower }} is {{state.state_with_unit}}\n{%- endfor -%}.',observer:"templateChanged"},processed:{type:String,value:""}},computeFormClasses:function(e){return e?"content fit":"content fit layout horizontal"},computeRenderedClasses:function(e){return e?"error rendered":"rendered"},templateChanged:function(){this.error&&(this.error=!1),this.debounce("render-template",this.renderTemplate.bind(this),500)},renderTemplate:function(){this.rendering=!0,this.hass.callApi("POST","template",{template:this.template}).then(function(e){this.processed=e,this.rendering=!1}.bind(this),function(e){this.processed=e.body.message,this.error=!0,this.rendering=!1}.bind(this))}});</script></body></html>

homeassistant/components/frontend/www_static/service_worker.js

@@ -37,7 +37,7 @@
 /* eslint-disable indent, no-unused-vars, no-multiple-empty-lines, max-nested-callbacks, space-before-function-paren, quotes, comma-spacing */
 'use strict';
 
-var precacheConfig = [["/","07ae53d16e9e97de8c721f5032cf79bf"],["/frontend/panels/dev-event-d409e7ab537d9fe629126d122345279c.html","936814991f2a5e23d61d29f0d40f81b8"],["/frontend/panels/dev-info-b0e55eb657fd75f21aba2426ac0cedc0.html","1fa953b0224470f70d4e87bbe4dff191"],["/frontend/panels/dev-mqtt-94b222b013a98583842de3e72d5888c6.html","dc3ddfac58397feda97317358f0aecbb"],["/frontend/panels/dev-service-422b2c181ee0713fa31d45a64e605baf.html","ae7d26b1c8c3309fd3c65944f89ea03f"],["/frontend/panels/dev-state-7948d3dba058f31517d880df8ed0e857.html","ff8156bb1a52490fcc07466556fce0e1"],["/frontend/panels/dev-template-f47b6910d8e4880e22cc508ca452f9b6.html","9aa0675e01373c6bc2737438bb84a9ec"],["/frontend/panels/map-c2544fff3eedb487d44105cf94b335ec.html","113c5bf9a68a74c62e50cd354034e78b"],["/static/compatibility-1686167ff210e001f063f5c606b2e74b.js","6ee7b5e2dd82b510c3bd92f7e215988e"],["/static/core-2a7d01e45187c7d4635da05065b5e54e.js","90a0a8a6a6dd0ca41b16f40e7d23924d"],["/static/frontend-5a2a3d6181cc820f5b3e94d1a50def74.html","6cd425233aeb180178dccae238533d65"],["/static/mdi-e91f61a039ed0a9936e7ee5360da3870.html","5e587bc82719b740a4f0798722a83aee"],["static/fonts/roboto/Roboto-Bold.ttf","d329cc8b34667f114a95422aaad1b063"],["static/fonts/roboto/Roboto-Light.ttf","7b5fb88f12bec8143f00e21bc3222124"],["static/fonts/roboto/Roboto-Medium.ttf","fe13e4170719c2fc586501e777bde143"],["static/fonts/roboto/Roboto-Regular.ttf","ac3f799d5bbaf5196fab15ab8de8431c"],["static/icons/favicon-192x192.png","419903b8422586a7e28021bbe9011175"],["static/icons/favicon.ico","04235bda7843ec2fceb1cbe2bc696cf4"],["static/images/card_media_player_bg.png","a34281d1c1835d338a642e90930e61aa"]];
+var precacheConfig = [["/","eceffe0debe81636e1eb8604e6eefbd6"],["/frontend/panels/dev-event-d409e7ab537d9fe629126d122345279c.html","936814991f2a5e23d61d29f0d40f81b8"],["/frontend/panels/dev-info-b0e55eb657fd75f21aba2426ac0cedc0.html","1fa953b0224470f70d4e87bbe4dff191"],["/frontend/panels/dev-mqtt-94b222b013a98583842de3e72d5888c6.html","dc3ddfac58397feda97317358f0aecbb"],["/frontend/panels/dev-service-422b2c181ee0713fa31d45a64e605baf.html","ae7d26b1c8c3309fd3c65944f89ea03f"],["/frontend/panels/dev-state-7948d3dba058f31517d880df8ed0e857.html","ff8156bb1a52490fcc07466556fce0e1"],["/frontend/panels/dev-template-928e7b81b9c113b70edc9f4a1d051827.html","312c8313800b44c83bcb8dc2df30c759"],["/frontend/panels/map-565db019147162080c21af962afc097f.html","a1a360042395682335e2f471dddad309"],["/static/compatibility-1686167ff210e001f063f5c606b2e74b.js","6ee7b5e2dd82b510c3bd92f7e215988e"],["/static/core-2a7d01e45187c7d4635da05065b5e54e.js","90a0a8a6a6dd0ca41b16f40e7d23924d"],["/static/frontend-c04709d3517dd3fd34b2f7d6bba6ec8e.html","e072f7bbe595bcb104d117a45592459d"],["/static/mdi-89074face5529f5fe6fbae49ecb3e88b.html","97754e463f9e56a95c813d4d8e792347"],["static/fonts/roboto/Roboto-Bold.ttf","d329cc8b34667f114a95422aaad1b063"],["static/fonts/roboto/Roboto-Light.ttf","7b5fb88f12bec8143f00e21bc3222124"],["static/fonts/roboto/Roboto-Medium.ttf","fe13e4170719c2fc586501e777bde143"],["static/fonts/roboto/Roboto-Regular.ttf","ac3f799d5bbaf5196fab15ab8de8431c"],["static/icons/favicon-192x192.png","419903b8422586a7e28021bbe9011175"],["static/icons/favicon.ico","04235bda7843ec2fceb1cbe2bc696cf4"],["static/images/card_media_player_bg.png","a34281d1c1835d338a642e90930e61aa"]];
 var cacheName = 'sw-precache-v3--' + (self.registration ? self.registration.scope : '');
 
 

homeassistant/components/graphite.py

@@ -45,13 +45,12 @@ def setup(hass, config):
     try:
         sock.connect((host, port))
         sock.shutdown(2)
-        _LOGGER.debug('Connection to Graphite possible')
+        _LOGGER.debug("Connection to Graphite possible")
     except socket.error:
-        _LOGGER.error('Not able to connect to Graphite')
+        _LOGGER.error("Not able to connect to Graphite")
         return False
 
     GraphiteFeeder(hass, host, port, prefix)
-
     return True
 
 
@@ -143,15 +142,15 @@ class GraphiteFeeder(threading.Thread):
                 _LOGGER.debug("Processing STATE_CHANGED event for %s",
                               event.data['entity_id'])
                 try:
-                    self._report_attributes(event.data['entity_id'],
-                                            event.data['new_state'])
+                    self._report_attributes(
+                        event.data['entity_id'], event.data['new_state'])
                 # pylint: disable=broad-except
                 except Exception:
                     # Catch this so we can avoid the thread dying and
                     # make it visible.
                     _LOGGER.exception("Failed to process STATE_CHANGED event")
             else:
-                _LOGGER.warning("Processing unexpected event type %s",
-                                event.event_type)
+                _LOGGER.warning(
+                    "Processing unexpected event type %s", event.event_type)
 
             self._queue.task_done()

homeassistant/components/hdmi_cec.py

@@ -31,7 +31,7 @@ DOMAIN = 'hdmi_cec'
 
 _LOGGER = logging.getLogger(__name__)
 
-DEFAULT_DISPLAY_NAME = "HomeAssistant"
+DEFAULT_DISPLAY_NAME = "HA"
 CONF_TYPES = 'types'
 
 ICON_UNKNOWN = 'mdi:help'
@@ -181,7 +181,7 @@ def setup(hass: HomeAssistant, base_config):
     if host:
         adapter = TcpAdapter(host, name=display_name, activate_source=False)
     else:
-        adapter = CecAdapter(name=display_name, activate_source=False)
+        adapter = CecAdapter(name=display_name[:12], activate_source=False)
     hdmi_network = HDMINetwork(adapter, loop=loop)
 
     def _volume(call):

homeassistant/components/homematic.py

@@ -4,8 +4,8 @@ Support for HomeMatic devices.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/homematic/
 """
+import asyncio
 import os
-import time
 import logging
 from datetime import timedelta
 from functools import partial
@@ -18,7 +18,7 @@ from homeassistant.const import (
     CONF_PLATFORM, CONF_HOSTS, CONF_NAME, ATTR_ENTITY_ID)
 from homeassistant.helpers import discovery
 from homeassistant.helpers.entity import Entity
-from homeassistant.helpers.event import track_time_interval
+from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.config import load_yaml_config_file
 
 REQUIREMENTS = ['pyhomematic==0.1.30']
@@ -121,7 +121,6 @@ CONF_RESOLVENAMES_OPTIONS = [
 ]
 
 DATA_HOMEMATIC = 'homematic'
-DATA_DELAY = 'homematic_delay'
 DATA_DEVINIT = 'homematic_devinit'
 DATA_STORE = 'homematic_store'
 
@@ -134,7 +133,6 @@ CONF_CALLBACK_PORT = 'callback_port'
 CONF_RESOLVENAMES = 'resolvenames'
 CONF_VARIABLES = 'variables'
 CONF_DEVICES = 'devices'
-CONF_DELAY = 'delay'
 CONF_PRIMARY = 'primary'
 
 DEFAULT_LOCAL_IP = '0.0.0.0'
@@ -145,7 +143,6 @@ DEFAULT_USERNAME = 'Admin'
 DEFAULT_PASSWORD = ''
 DEFAULT_VARIABLES = False
 DEFAULT_DEVICES = True
-DEFAULT_DELAY = 0.5
 DEFAULT_PRIMARY = False
 
 
@@ -177,7 +174,6 @@ CONFIG_SCHEMA = vol.Schema({
         }},
         vol.Optional(CONF_LOCAL_IP, default=DEFAULT_LOCAL_IP): cv.string,
         vol.Optional(CONF_LOCAL_PORT, default=DEFAULT_LOCAL_PORT): cv.port,
-        vol.Optional(CONF_DELAY, default=DEFAULT_DELAY): vol.Coerce(float),
     }),
 }, extra=vol.ALLOW_EXTRA)
 
@@ -249,7 +245,6 @@ def setup(hass, config):
     """Set up the Homematic component."""
     from pyhomematic import HMConnection
 
-    hass.data[DATA_DELAY] = config[DOMAIN].get(CONF_DELAY)
     hass.data[DATA_DEVINIT] = {}
     hass.data[DATA_STORE] = set()
 
@@ -277,7 +272,7 @@ def setup(hass, config):
 
     # Create server thread
     bound_system_callback = partial(_system_callback_handler, hass, config)
-    hass.data[DATA_HOMEMATIC] = HMConnection(
+    hass.data[DATA_HOMEMATIC] = homematic = HMConnection(
         local=config[DOMAIN].get(CONF_LOCAL_IP),
         localport=config[DOMAIN].get(CONF_LOCAL_PORT),
         remotes=remotes,
@@ -286,7 +281,7 @@ def setup(hass, config):
     )
 
     # Start server thread, connect to hosts, initialize to receive events
-    hass.data[DATA_HOMEMATIC].start()
+    homematic.start()
 
     # Stops server when HASS is shutting down
     hass.bus.listen_once(
@@ -296,7 +291,7 @@ def setup(hass, config):
     entity_hubs = []
     for _, hub_data in hosts.items():
         entity_hubs.append(HMHub(
-            hass, hub_data[CONF_NAME], hub_data[CONF_VARIABLES]))
+            homematic, hub_data[CONF_NAME], hub_data[CONF_VARIABLES]))
 
     # Register HomeMatic services
     descriptions = load_yaml_config_file(
@@ -359,7 +354,7 @@ def setup(hass, config):
 
     def _service_handle_reconnect(service):
         """Service to reconnect all HomeMatic hubs."""
-        hass.data[DATA_HOMEMATIC].reconnect()
+        homematic.reconnect()
 
     hass.services.register(
         DOMAIN, SERVICE_RECONNECT, _service_handle_reconnect,
@@ -575,24 +570,27 @@ def _device_from_servicecall(hass, service):
 class HMHub(Entity):
     """The HomeMatic hub. (CCU2/HomeGear)."""
 
-    def __init__(self, hass, name, use_variables):
+    def __init__(self, homematic, name, use_variables):
         """Initialize HomeMatic hub."""
-        self.hass = hass
         self.entity_id = "{}.{}".format(DOMAIN, name.lower())
-        self._homematic = hass.data[DATA_HOMEMATIC]
+        self._homematic = homematic
         self._variables = {}
         self._name = name
         self._state = STATE_UNKNOWN
         self._use_variables = use_variables
 
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Load data init callbacks."""
         # Load data
-        track_time_interval(hass, self._update_hub, SCAN_INTERVAL_HUB)
-        self._update_hub(None)
+        async_track_time_interval(
+            self.hass, self._update_hub, SCAN_INTERVAL_HUB)
+        yield from self.hass.async_add_job(self._update_hub, None)
 
         if self._use_variables:
-            track_time_interval(
-                hass, self._update_variables, SCAN_INTERVAL_VARIABLES)
-            self._update_variables(None)
+            async_track_time_interval(
+                self.hass, self._update_variables, SCAN_INTERVAL_VARIABLES)
+            yield from self.hass.async_add_job(self._update_variables, None)
 
     @property
     def name(self):
@@ -624,7 +622,9 @@ class HMHub(Entity):
         """Retrieve latest state."""
         state = self._homematic.getServiceMessages(self._name)
         self._state = STATE_UNKNOWN if state is None else len(state)
-        self.schedule_update_ha_state()
+
+        if now:
+            self.schedule_update_ha_state()
 
     def _update_variables(self, now):
         """Retrive all variable data and update hmvariable states."""
@@ -640,7 +640,7 @@ class HMHub(Entity):
             state_change = True
             self._variables.update({key: value})
 
-        if state_change:
+        if state_change and now:
             self.schedule_update_ha_state()
 
     def hm_set_variable(self, name, value):
@@ -662,16 +662,15 @@ class HMHub(Entity):
 class HMDevice(Entity):
     """The HomeMatic device base object."""
 
-    def __init__(self, hass, config):
+    def __init__(self, config):
         """Initialize a generic HomeMatic device."""
-        self.hass = hass
-        self._homematic = hass.data[DATA_HOMEMATIC]
         self._name = config.get(ATTR_NAME)
         self._address = config.get(ATTR_ADDRESS)
         self._proxy = config.get(ATTR_PROXY)
         self._channel = config.get(ATTR_CHANNEL)
         self._state = config.get(ATTR_PARAM)
         self._data = {}
+        self._homematic = None
         self._hmdevice = None
         self._connected = False
         self._available = False
@@ -680,6 +679,11 @@ class HMDevice(Entity):
         if self._state:
             self._state = self._state.upper()
 
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Load data init callbacks."""
+        yield from self.hass.async_add_job(self.link_homematic)
+
     @property
     def should_poll(self):
         """Return false. HomeMatic states are pushed by the XML-RPC Server."""
@@ -728,16 +732,13 @@ class HMDevice(Entity):
             return True
 
         # Initialize
+        self._homematic = self.hass.data[DATA_HOMEMATIC]
         self._hmdevice = self._homematic.devices[self._proxy][self._address]
         self._connected = True
 
         try:
             # Initialize datapoints of this object
             self._init_data()
-            if self.hass.data[DATA_DELAY]:
-                # We optionally delay / pause loading of data to avoid
-                # overloading of CCU / Homegear
-                time.sleep(self.hass.data[DATA_DELAY])
             self._load_data_from_hm()
 
             # Link events from pyhomematic

homeassistant/components/image_processing/dlib_face_detect.py

@@ -15,7 +15,7 @@ from homeassistant.components.image_processing import (
 from homeassistant.components.image_processing.microsoft_face_identify import (
     ImageProcessingFaceEntity)
 
-REQUIREMENTS = ['face_recognition==0.2.0']
+REQUIREMENTS = ['face_recognition==1.0.0']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/image_processing/dlib_face_identify.py

@@ -16,7 +16,7 @@ from homeassistant.components.image_processing.microsoft_face_identify import (
     ImageProcessingFaceEntity)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['face_recognition==0.2.0']
+REQUIREMENTS = ['face_recognition==1.0.0']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/input_text.py

@@ -0,0 +1,191 @@
+"""
+Component to offer a way to enter a value into a text box.
+
+For more details about this component, please refer to the documentation
+at https://home-assistant.io/components/input_text/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import (
+    ATTR_ENTITY_ID, ATTR_UNIT_OF_MEASUREMENT, CONF_ICON, CONF_NAME)
+from homeassistant.loader import bind_hass
+from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.restore_state import async_get_last_state
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = 'input_text'
+ENTITY_ID_FORMAT = DOMAIN + '.{}'
+
+CONF_INITIAL = 'initial'
+CONF_MIN = 'min'
+CONF_MAX = 'max'
+
+ATTR_VALUE = 'value'
+ATTR_MIN = 'min'
+ATTR_MAX = 'max'
+ATTR_PATTERN = 'pattern'
+
+SERVICE_SET_VALUE = 'set_value'
+
+SERVICE_SET_VALUE_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Required(ATTR_VALUE): cv.string,
+})
+
+
+def _cv_input_text(cfg):
+    """Configure validation helper for input box (voluptuous)."""
+    minimum = cfg.get(CONF_MIN)
+    maximum = cfg.get(CONF_MAX)
+    if minimum > maximum:
+        raise vol.Invalid('Max len ({}) is not greater than min len ({})'
+                          .format(minimum, maximum))
+    state = cfg.get(CONF_INITIAL)
+    if state is not None and (len(state) < minimum or len(state) > maximum):
+        raise vol.Invalid('Initial value {} length not in range {}-{}'
+                          .format(state, minimum, maximum))
+    return cfg
+
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        cv.slug: vol.All({
+            vol.Optional(CONF_NAME): cv.string,
+            vol.Optional(CONF_MIN, default=0): vol.Coerce(int),
+            vol.Optional(CONF_MAX, default=100): vol.Coerce(int),
+            vol.Optional(CONF_INITIAL, ''): cv.string,
+            vol.Optional(CONF_ICON): cv.icon,
+            vol.Optional(ATTR_UNIT_OF_MEASUREMENT): cv.string,
+            vol.Optional(ATTR_PATTERN): cv.string,
+        }, _cv_input_text)
+    })
+}, required=True, extra=vol.ALLOW_EXTRA)
+
+
+@bind_hass
+def set_value(hass, entity_id, value):
+    """Set input_text to value."""
+    hass.services.call(DOMAIN, SERVICE_SET_VALUE, {
+        ATTR_ENTITY_ID: entity_id,
+        ATTR_VALUE: value,
+    })
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Set up an input text box."""
+    component = EntityComponent(_LOGGER, DOMAIN, hass)
+
+    entities = []
+
+    for object_id, cfg in config[DOMAIN].items():
+        name = cfg.get(CONF_NAME)
+        minimum = cfg.get(CONF_MIN)
+        maximum = cfg.get(CONF_MAX)
+        initial = cfg.get(CONF_INITIAL)
+        icon = cfg.get(CONF_ICON)
+        unit = cfg.get(ATTR_UNIT_OF_MEASUREMENT)
+        pattern = cfg.get(ATTR_PATTERN)
+
+        entities.append(InputText(
+            object_id, name, initial, minimum, maximum, icon, unit,
+            pattern))
+
+    if not entities:
+        return False
+
+    @asyncio.coroutine
+    def async_set_value_service(call):
+        """Handle a calls to the input box services."""
+        target_inputs = component.async_extract_from_service(call)
+
+        tasks = [input_text.async_set_value(call.data[ATTR_VALUE])
+                 for input_text in target_inputs]
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_VALUE, async_set_value_service,
+        schema=SERVICE_SET_VALUE_SCHEMA)
+
+    yield from component.async_add_entities(entities)
+    return True
+
+
+class InputText(Entity):
+    """Represent a text box."""
+
+    def __init__(self, object_id, name, initial, minimum, maximum, icon,
+                 unit, pattern):
+        """Initialize a text input."""
+        self.entity_id = ENTITY_ID_FORMAT.format(object_id)
+        self._name = name
+        self._current_value = initial
+        self._minimum = minimum
+        self._maximum = maximum
+        self._icon = icon
+        self._unit = unit
+        self._pattern = pattern
+
+    @property
+    def should_poll(self):
+        """If entity should be polled."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the text input entity."""
+        return self._name
+
+    @property
+    def icon(self):
+        """Return the icon to be used for this entity."""
+        return self._icon
+
+    @property
+    def state(self):
+        """Return the state of the component."""
+        return self._current_value
+
+    @property
+    def unit_of_measurement(self):
+        """Return the unit the value is expressed in."""
+        return self._unit
+
+    @property
+    def state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_MIN: self._minimum,
+            ATTR_MAX: self._maximum,
+            ATTR_PATTERN: self._pattern,
+        }
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Run when entity about to be added to hass."""
+        if self._current_value is not None:
+            return
+
+        state = yield from async_get_last_state(self.hass, self.entity_id)
+        value = state and state.state
+
+        # Check against None because value can be 0
+        if value is not None and self._minimum <= len(value) <= self._maximum:
+            self._current_value = value
+
+    @asyncio.coroutine
+    def async_set_value(self, value):
+        """Select new value."""
+        if len(value) < self._minimum or len(value) > self._maximum:
+            _LOGGER.warning("Invalid value: %s (length range %s - %s)",
+                            value, self._minimum, self._maximum)
+            return
+        self._current_value = value
+        yield from self.async_update_ha_state()

homeassistant/components/insteon_plm.py

@@ -79,8 +79,12 @@ def async_setup(hass, config):
         #
         # Override the device default capabilities for a specific address
         #
-        plm.protocol.devices.add_override(
-            device['address'], 'capabilities', [device['platform']])
+        if isinstance(device['platform'], list):
+            plm.protocol.devices.add_override(
+                device['address'], 'capabilities', device['platform'])
+        else:
+            plm.protocol.devices.add_override(
+                device['address'], 'capabilities', [device['platform']])
 
     hass.data['insteon_plm'] = plm
 
@@ -98,7 +102,7 @@ def common_attributes(entity):
         'address': 'INSTEON Address',
         'description': 'Description',
         'model': 'Model',
-        'cat': 'Cagegory',
+        'cat': 'Category',
         'subcat': 'Subcategory',
         'firmware': 'Firmware',
         'product_key': 'Product Key'

homeassistant/components/isy994.py

@@ -17,7 +17,7 @@ from homeassistant.helpers import discovery, config_validation as cv
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.typing import ConfigType, Dict  # noqa
 
-REQUIREMENTS = ['PyISY==1.0.7']
+REQUIREMENTS = ['PyISY==1.0.8']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/knx.py

@@ -1,495 +1,255 @@
 """
-Support for KNX components.
 
-For more details about this component, please refer to the documentation at
+Connects to KNX platform.
+
+For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/knx/
+
 """
 import logging
-import os
+import asyncio
 
 import voluptuous as vol
 
+from homeassistant.helpers import discovery
 import homeassistant.helpers.config_validation as cv
-from homeassistant.const import (
-    EVENT_HOMEASSISTANT_STOP, CONF_HOST, CONF_PORT)
-from homeassistant.helpers.entity import Entity
-from homeassistant.config import load_yaml_config_file
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP, \
+    CONF_HOST, CONF_PORT
+from homeassistant.helpers.script import Script
 
-REQUIREMENTS = ['knxip==0.5']
+DOMAIN = "knx"
+DATA_KNX = "data_knx"
+CONF_KNX_CONFIG = "config_file"
+
+CONF_KNX_ROUTING = "routing"
+CONF_KNX_TUNNELING = "tunneling"
+CONF_KNX_LOCAL_IP = "local_ip"
+CONF_KNX_FIRE_EVENT = "fire_event"
+CONF_KNX_FIRE_EVENT_FILTER = "fire_event_filter"
+
+SERVICE_KNX_SEND = "send"
+SERVICE_KNX_ATTR_ADDRESS = "address"
+SERVICE_KNX_ATTR_PAYLOAD = "payload"
+
+ATTR_DISCOVER_DEVICES = 'devices'
 
 _LOGGER = logging.getLogger(__name__)
 
-DEFAULT_HOST = '0.0.0.0'
-DEFAULT_PORT = 3671
-DOMAIN = 'knx'
+REQUIREMENTS = ['xknx==0.7.13']
 
-EVENT_KNX_FRAME_RECEIVED = 'knx_frame_received'
-EVENT_KNX_FRAME_SEND = 'knx_frame_send'
+TUNNELING_SCHEMA = vol.Schema({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Optional(CONF_PORT): cv.port,
+    vol.Required(CONF_KNX_LOCAL_IP): cv.string,
+})
 
-KNXTUNNEL = None
-KNX_ADDRESS = "address"
-KNX_DATA = "data"
-KNX_GROUP_WRITE = "group_write"
-CONF_LISTEN = "listen"
+ROUTING_SCHEMA = vol.Schema({
+    vol.Required(CONF_KNX_LOCAL_IP): cv.string,
+})
 
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: vol.Schema({
-        vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string,
-        vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
-        vol.Optional(CONF_LISTEN, default=[]):
-            vol.All(cv.ensure_list, [cv.string]),
-    }),
+        vol.Optional(CONF_KNX_CONFIG): cv.string,
+        vol.Exclusive(CONF_KNX_ROUTING, 'connection_type'): ROUTING_SCHEMA,
+        vol.Exclusive(CONF_KNX_TUNNELING, 'connection_type'):
+            TUNNELING_SCHEMA,
+        vol.Inclusive(CONF_KNX_FIRE_EVENT, 'fire_ev'):
+            cv.boolean,
+        vol.Inclusive(CONF_KNX_FIRE_EVENT_FILTER, 'fire_ev'):
+            vol.All(
+                cv.ensure_list,
+                [cv.string])
+    })
 }, extra=vol.ALLOW_EXTRA)
 
-KNX_WRITE_SCHEMA = vol.Schema({
-    vol.Required(KNX_ADDRESS): vol.All(cv.ensure_list, [cv.string]),
-    vol.Required(KNX_DATA): vol.All(cv.ensure_list, [cv.byte])
+SERVICE_KNX_SEND_SCHEMA = vol.Schema({
+    vol.Required(SERVICE_KNX_ATTR_ADDRESS): cv.string,
+    vol.Required(SERVICE_KNX_ATTR_PAYLOAD): vol.Any(
+        cv.positive_int, [cv.positive_int]),
 })
 
 
-def setup(hass, config):
-    """Set up the connection to the KNX IP interface."""
-    global KNXTUNNEL
-
-    from knxip.ip import KNXIPTunnel
-    from knxip.core import KNXException, parse_group_address
-
-    host = config[DOMAIN].get(CONF_HOST)
-    port = config[DOMAIN].get(CONF_PORT)
-
-    if host == '0.0.0.0':
-        _LOGGER.debug("Will try to auto-detect KNX/IP gateway")
-
-    KNXTUNNEL = KNXIPTunnel(host, port)
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Set up knx component."""
+    from xknx.exceptions import XKNXException
     try:
-        res = KNXTUNNEL.connect()
-        _LOGGER.debug("Res = %s", res)
-        if not res:
-            _LOGGER.error("Could not connect to KNX/IP interface %s", host)
-            return False
+        hass.data[DATA_KNX] = KNXModule(hass, config)
+        yield from hass.data[DATA_KNX].start()
 
-    except KNXException as ex:
-        _LOGGER.exception("Can't connect to KNX/IP interface: %s", ex)
-        KNXTUNNEL = None
+    except XKNXException as ex:
+        _LOGGER.exception("Can't connect to KNX interface: %s", ex)
         return False
 
-    _LOGGER.info("KNX IP tunnel to %s:%i established", host, port)
+    for component, discovery_type in (
+            ('switch', 'Switch'),
+            ('climate', 'Climate'),
+            ('cover', 'Cover'),
+            ('light', 'Light'),
+            ('sensor', 'Sensor'),
+            ('binary_sensor', 'BinarySensor'),
+            ('notify', 'Notification')):
+        found_devices = _get_devices(hass, discovery_type)
+        hass.async_add_job(
+            discovery.async_load_platform(hass, component, DOMAIN, {
+                ATTR_DISCOVER_DEVICES: found_devices
+            }, config))
 
-    descriptions = load_yaml_config_file(
-        os.path.join(os.path.dirname(__file__), 'services.yaml'))
-
-    def received_knx_event(address, data):
-        """Process received KNX message."""
-        if len(data) == 1:
-            data = data[0]
-        hass.bus.fire('knx_event', {
-            'address': address,
-            'data': data
-        })
-
-    for listen in config[DOMAIN].get(CONF_LISTEN):
-        _LOGGER.debug("Registering listener for %s", listen)
-        try:
-            KNXTUNNEL.register_listener(parse_group_address(listen),
-                                        received_knx_event)
-        except KNXException as knxexception:
-            _LOGGER.error("Can't register KNX listener for address %s (%s)",
-                          listen, knxexception)
-
-    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, close_tunnel)
-
-    # Listen to KNX events and send them to the bus
-    def handle_group_write(call):
-        """Bridge knx_frame_send events to the KNX bus."""
-        # parameters are pre-validated using KNX_WRITE_SCHEMA
-        addrlist = call.data.get("address")
-        knxdata = call.data.get("data")
-
-        knxaddrlist = []
-        for addr in addrlist:
-            try:
-                _LOGGER.debug("Found %s", addr)
-                knxaddr = int(addr)
-            except ValueError:
-                knxaddr = None
-
-            if knxaddr is None:
-                try:
-                    knxaddr = parse_group_address(addr)
-                except KNXException:
-                    _LOGGER.error("KNX address format incorrect: %s", addr)
-
-            knxaddrlist.append(knxaddr)
-
-        for addr in knxaddrlist:
-            KNXTUNNEL.group_write(addr, knxdata)
-
-    # Listen for when knx_frame_send event is fired
-    hass.services.register(DOMAIN,
-                           KNX_GROUP_WRITE,
-                           handle_group_write,
-                           descriptions[DOMAIN][KNX_GROUP_WRITE],
-                           schema=KNX_WRITE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_KNX_SEND,
+        hass.data[DATA_KNX].service_send_to_knx_bus,
+        schema=SERVICE_KNX_SEND_SCHEMA)
 
     return True
 
 
-def close_tunnel(_data):
-    """Close the NKX tunnel connection on shutdown."""
-    global KNXTUNNEL
-
-    KNXTUNNEL.disconnect()
-    KNXTUNNEL = None
+def _get_devices(hass, discovery_type):
+    return list(
+        map(lambda device: device.name,
+            filter(
+                lambda device: type(device).__name__ == discovery_type,
+                hass.data[DATA_KNX].xknx.devices)))
 
 
-class KNXConfig(object):
-    """Handle the fetching of configuration from the config file."""
-
-    def __init__(self, config):
-        """Initialize the configuration."""
-        from knxip.core import parse_group_address
-
-        self.config = config
-        self.should_poll = config.get('poll', True)
-        if config.get('address'):
-            self._address = parse_group_address(config.get('address'))
-        else:
-            self._address = None
-        if self.config.get('state_address'):
-            self._state_address = parse_group_address(
-                self.config.get('state_address'))
-        else:
-            self._state_address = None
-
-    @property
-    def name(self):
-        """Return the name given to the entity."""
-        return self.config['name']
-
-    @property
-    def address(self):
-        """Return the address of the device as an integer value.
-
-        3 types of addresses are supported:
-        integer - 0-65535
-        2 level - a/b
-        3 level - a/b/c
-        """
-        return self._address
-
-    @property
-    def state_address(self):
-        """Return the group address the device sends its current state to.
-
-        Some KNX devices can send the current state to a seperate
-        group address. This makes send e.g. when an actuator can
-        be switched but also have a timer functionality.
-        """
-        return self._state_address
-
-
-class KNXGroupAddress(Entity):
-    """Representation of devices connected to a KNX group address."""
+class KNXModule(object):
+    """Representation of KNX Object."""
 
     def __init__(self, hass, config):
-        """Initialize the device."""
-        self._config = config
-        self._state = False
-        self._data = None
-        _LOGGER.debug(
-            "Initalizing KNX group address for %s (%s)",
-            self.name, self.address
-        )
+        """Initialization of KNXModule."""
+        self.hass = hass
+        self.config = config
+        self.initialized = False
+        self.init_xknx()
+        self.register_callbacks()
 
-        def handle_knx_message(addr, data):
-            """Handle an incoming KNX frame.
+    def init_xknx(self):
+        """Initialization of KNX object."""
+        from xknx import XKNX
+        self.xknx = XKNX(
+            config=self.config_file(),
+            loop=self.hass.loop)
 
-            Handle an incoming frame and update our status if it contains
-            information relating to this device.
-            """
-            if (addr == self.state_address) or (addr == self.address):
-                self._state = data[0]
-                self.schedule_update_ha_state()
+    @asyncio.coroutine
+    def start(self):
+        """Start KNX object. Connect to tunneling or Routing device."""
+        connection_config = self.connection_config()
+        yield from self.xknx.start(
+            state_updater=True,
+            connection_config=connection_config)
+        self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self.stop)
+        self.initialized = True
 
-        KNXTUNNEL.register_listener(self.address, handle_knx_message)
-        if self.state_address:
-            KNXTUNNEL.register_listener(self.state_address, handle_knx_message)
+    @asyncio.coroutine
+    def stop(self, event):
+        """Stop KNX object. Disconnect from tunneling or Routing device."""
+        yield from self.xknx.stop()
 
-    @property
-    def name(self):
-        """Return the entity's display name."""
-        return self._config.name
+    def config_file(self):
+        """Resolve and return the full path of xknx.yaml if configured."""
+        config_file = self.config[DOMAIN].get(CONF_KNX_CONFIG)
+        if not config_file:
+            return None
+        if not config_file.startswith("/"):
+            return self.hass.config.path(config_file)
+        return config_file
 
-    @property
-    def config(self):
-        """Return the entity's configuration."""
-        return self._config
+    def connection_config(self):
+        """Return the connection_config."""
+        if CONF_KNX_TUNNELING in self.config[DOMAIN]:
+            return self.connection_config_tunneling()
+        elif CONF_KNX_ROUTING in self.config[DOMAIN]:
+            return self.connection_config_routing()
+        return self.connection_config_auto()
 
-    @property
-    def should_poll(self):
-        """Return the state of the polling, if needed."""
-        return self._config.should_poll
+    def connection_config_routing(self):
+        """Return the connection_config if routing is configured."""
+        from xknx.io import ConnectionConfig, ConnectionType
+        local_ip = \
+            self.config[DOMAIN][CONF_KNX_ROUTING].get(CONF_KNX_LOCAL_IP)
+        return ConnectionConfig(
+            connection_type=ConnectionType.ROUTING,
+            local_ip=local_ip)
 
-    @property
-    def is_on(self):
-        """Return True if the value is not 0 is on, else False."""
-        return self._state != 0
+    def connection_config_tunneling(self):
+        """Return the connection_config if tunneling is configured."""
+        from xknx.io import ConnectionConfig, ConnectionType, \
+            DEFAULT_MCAST_PORT
+        gateway_ip = \
+            self.config[DOMAIN][CONF_KNX_TUNNELING].get(CONF_HOST)
+        gateway_port = \
+            self.config[DOMAIN][CONF_KNX_TUNNELING].get(CONF_PORT)
+        local_ip = \
+            self.config[DOMAIN][CONF_KNX_TUNNELING].get(CONF_KNX_LOCAL_IP)
+        if gateway_port is None:
+            gateway_port = DEFAULT_MCAST_PORT
+        return ConnectionConfig(
+            connection_type=ConnectionType.TUNNELING,
+            gateway_ip=gateway_ip,
+            gateway_port=gateway_port,
+            local_ip=local_ip)
 
-    @property
-    def address(self):
-        """Return the KNX group address."""
-        return self._config.address
+    def connection_config_auto(self):
+        """Return the connection_config if auto is configured."""
+        # pylint: disable=no-self-use
+        from xknx.io import ConnectionConfig
+        return ConnectionConfig()
 
-    @property
-    def state_address(self):
-        """Return the KNX group address."""
-        return self._config.state_address
+    def register_callbacks(self):
+        """Register callbacks within XKNX object."""
+        if CONF_KNX_FIRE_EVENT in self.config[DOMAIN] and \
+                self.config[DOMAIN][CONF_KNX_FIRE_EVENT]:
+            from xknx.knx import AddressFilter
+            address_filters = list(map(
+                AddressFilter,
+                self.config[DOMAIN][CONF_KNX_FIRE_EVENT_FILTER]))
+            self.xknx.telegram_queue.register_telegram_received_cb(
+                self.telegram_received_cb, address_filters)
 
-    @property
-    def cache(self):
-        """Return the name given to the entity."""
-        return self._config.config.get('cache', True)
-
-    def group_write(self, value):
-        """Write to the group address."""
-        KNXTUNNEL.group_write(self.address, [value])
-
-    def update(self):
-        """Get the state from KNX bus or cache."""
-        from knxip.core import KNXException
-
-        try:
-            if self.state_address:
-                res = KNXTUNNEL.group_read(
-                    self.state_address, use_cache=self.cache)
-            else:
-                res = KNXTUNNEL.group_read(self.address, use_cache=self.cache)
-
-            if res:
-                self._state = res[0]
-                self._data = res
-            else:
-                _LOGGER.debug(
-                    "%s: unable to read from KNX address: %s (None)",
-                    self.name, self.address
-                )
-
-        except KNXException:
-            _LOGGER.exception(
-                "%s: unable to read from KNX address: %s",
-                self.name, self.address
-            )
-            return False
-
-
-class KNXMultiAddressDevice(Entity):
-    """Representation of devices connected to a multiple KNX group address.
-
-    This is needed for devices like dimmers or shutter actuators as they have
-    to be controlled by multiple group addresses.
-    """
-
-    def __init__(self, hass, config, required, optional=None):
-        """Initialize the device.
-
-        The namelist argument lists the required addresses. E.g. for a dimming
-        actuators, the namelist might look like:
-        onoff_address: 0/0/1
-        brightness_address: 0/0/2
-        """
-        from knxip.core import parse_group_address, KNXException
-
-        self.names = {}
-        self.values = {}
-
-        self._config = config
-        self._state = False
-        self._data = None
-        _LOGGER.debug(
-            "%s: initalizing KNX multi address device",
-            self.name
-        )
-
-        settings = self._config.config
-        if config.address:
-            _LOGGER.debug(
-                "%s: base address: address=%s",
-                self.name, settings.get('address')
-            )
-            self.names[config.address] = 'base'
-        if config.state_address:
-            _LOGGER.debug(
-                "%s, state address: state_address=%s",
-                self.name, settings.get('state_address')
-            )
-            self.names[config.state_address] = 'state'
-
-        # parse required addresses
-        for name in required:
-            paramname = '{}{}'.format(name, '_address')
-            addr = settings.get(paramname)
-            if addr is None:
-                _LOGGER.error(
-                    "%s: Required KNX group address %s missing",
-                    self.name, paramname
-                )
-                raise KNXException(
-                    "%s: Group address for {} missing in "
-                    "configuration for {}".format(
-                        self.name, paramname
-                    )
-                )
-            _LOGGER.debug(
-                "%s: (required parameter) %s=%s",
-                self.name, paramname, addr
-            )
-            addr = parse_group_address(addr)
-            self.names[addr] = name
-
-        # parse optional addresses
-        for name in optional:
-            paramname = '{}{}'.format(name, '_address')
-            addr = settings.get(paramname)
-            _LOGGER.debug(
-                "%s: (optional parameter) %s=%s",
-                self.name, paramname, addr
-            )
-            if addr:
-                try:
-                    addr = parse_group_address(addr)
-                except KNXException:
-                    _LOGGER.exception(
-                        "%s: cannot parse group address %s",
-                        self.name, addr
-                    )
-                self.names[addr] = name
-
-    @property
-    def name(self):
-        """Return the entity's display name."""
-        return self._config.name
-
-    @property
-    def config(self):
-        """Return the entity's configuration."""
-        return self._config
-
-    @property
-    def should_poll(self):
-        """Return the state of the polling, if needed."""
-        return self._config.should_poll
-
-    @property
-    def cache(self):
-        """Return the name given to the entity."""
-        return self._config.config.get('cache', True)
-
-    def has_attribute(self, name):
-        """Check if the attribute with the given name is defined.
-
-        This is mostly important for optional addresses.
-        """
-        for attributename in self.names.values():
-            if attributename == name:
-                return True
+    @asyncio.coroutine
+    def telegram_received_cb(self, telegram):
+        """Callback invoked after a KNX telegram was received."""
+        self.hass.bus.fire('knx_event', {
+            'address': telegram.group_address.str(),
+            'data': telegram.payload.value
+        })
+        # False signals XKNX to proceed with processing telegrams.
         return False
 
-    def set_percentage(self, name, percentage):
-        """Set a percentage in knx for a given attribute.
+    @asyncio.coroutine
+    def service_send_to_knx_bus(self, call):
+        """Service for sending an arbitray KNX message to the KNX bus."""
+        from xknx.knx import Telegram, Address, DPTBinary, DPTArray
+        attr_payload = call.data.get(SERVICE_KNX_ATTR_PAYLOAD)
+        attr_address = call.data.get(SERVICE_KNX_ATTR_ADDRESS)
 
-        DPT_Scaling / DPT 5.001 is a single byte scaled percentage
-        """
-        percentage = abs(percentage)  # only accept positive values
-        scaled_value = percentage * 255 / 100
-        value = min(255, scaled_value)
-        return self.set_int_value(name, value)
+        def calculate_payload(attr_payload):
+            """Calculate payload depending on type of attribute."""
+            if isinstance(attr_payload, int):
+                return DPTBinary(attr_payload)
+            return DPTArray(attr_payload)
+        payload = calculate_payload(attr_payload)
+        address = Address(attr_address)
 
-    def get_percentage(self, name):
-        """Get a percentage from knx for a given attribute.
+        telegram = Telegram()
+        telegram.payload = payload
+        telegram.group_address = address
+        yield from self.xknx.telegrams.put(telegram)
 
-        DPT_Scaling / DPT 5.001 is a single byte scaled percentage
-        """
-        value = self.get_int_value(name)
-        percentage = round(value * 100 / 255)
-        return percentage
 
-    def set_int_value(self, name, value, num_bytes=1):
-        """Set an integer value for a given attribute."""
-        # KNX packets are big endian
-        value = round(value)      # only accept integers
-        b_value = value.to_bytes(num_bytes, byteorder='big')
-        return self.set_value(name, list(b_value))
+class KNXAutomation():
+    """Wrapper around xknx.devices.ActionCallback object.."""
 
-    def get_int_value(self, name):
-        """Get an integer value for a given attribute."""
-        # KNX packets are big endian
-        summed_value = 0
-        raw_value = self.value(name)
-        try:
-            # convert raw value in bytes
-            for val in raw_value:
-                summed_value *= 256
-                summed_value += val
-        except TypeError:
-            # pknx returns a non-iterable type for unsuccessful reads
-            pass
+    def __init__(self, hass, device, hook, action, counter=1):
+        """Initialize Automation class."""
+        self.hass = hass
+        self.device = device
+        script_name = "{} turn ON script".format(device.get_name())
+        self.script = Script(hass, action, script_name)
 
-        return summed_value
-
-    def value(self, name):
-        """Return the value to a given named attribute."""
-        from knxip.core import KNXException
-
-        addr = None
-        for attributeaddress, attributename in self.names.items():
-            if attributename == name:
-                addr = attributeaddress
-
-        if addr is None:
-            _LOGGER.error("%s: attribute '%s' undefined",
-                          self.name, name)
-            _LOGGER.debug(
-                "%s: defined attributes: %s",
-                self.name, str(self.names)
-            )
-            return False
-
-        try:
-            res = KNXTUNNEL.group_read(addr, use_cache=self.cache)
-        except KNXException:
-            _LOGGER.exception(
-                "%s: unable to read from KNX address: %s",
-                self.name, addr
-            )
-            return False
-
-        return res
-
-    def set_value(self, name, value):
-        """Set the value of a given named attribute."""
-        from knxip.core import KNXException
-
-        addr = None
-        for attributeaddress, attributename in self.names.items():
-            if attributename == name:
-                addr = attributeaddress
-
-        if addr is None:
-            _LOGGER.error("%s: attribute '%s' undefined",
-                          self.name, name)
-            _LOGGER.debug(
-                "%s: defined attributes: %s",
-                self.name, str(self.names)
-            )
-            return False
-
-        try:
-            KNXTUNNEL.group_write(addr, value)
-        except KNXException:
-            _LOGGER.exception(
-                "%s: unable to write to KNX address: %s",
-                self.name, addr
-            )
-            return False
-
-        return True
+        import xknx
+        self.action = xknx.devices.ActionCallback(
+            hass.data[DATA_KNX].xknx,
+            self.script.async_run,
+            hook=hook,
+            counter=counter)
+        device.actions.append(self.action)

homeassistant/components/light/decora_wifi.py

@@ -116,8 +116,8 @@ class DecoraWifiLight(Light):
         attribs = {'power': 'ON'}
 
         if ATTR_BRIGHTNESS in kwargs:
-            min_level = self._switch.get('minLevel', 0)
-            max_level = self._switch.get('maxLevel', 100)
+            min_level = self._switch.data.get('minLevel', 0)
+            max_level = self._switch.data.get('maxLevel', 100)
             brightness = int(kwargs[ATTR_BRIGHTNESS] * max_level / 255)
             brightness = max(brightness, min_level)
             attribs['brightness'] = brightness

homeassistant/components/light/flux_led.py

@@ -122,7 +122,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         if ipaddr in light_ips:
             continue
         device['name'] = '{} {}'.format(device['id'], ipaddr)
-        device[ATTR_MODE] = 'rgbw'
+        device[ATTR_MODE] = MODE_RGBW
         device[CONF_PROTOCOL] = None
         light = FluxLight(device)
         lights.append(light)
@@ -216,9 +216,9 @@ class FluxLight(Light):
         elif rgb is not None:
             self._bulb.setRgb(*tuple(rgb))
         elif brightness is not None:
-            if self._mode == 'rgbw':
+            if self._mode == MODE_RGBW:
                 self._bulb.setWarmWhite255(brightness)
-            elif self._mode == 'rgb':
+            elif self._mode == MODE_RGB:
                 (red, green, blue) = self._bulb.getRgb()
                 self._bulb.setRgb(red, green, blue, brightness=brightness)
         elif effect == EFFECT_RANDOM:

homeassistant/components/light/homematic.py

@@ -24,8 +24,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     devices = []
     for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMLight(hass, conf)
-        new_device.link_homematic()
+        new_device = HMLight(conf)
         devices.append(new_device)
 
     add_devices(devices)

homeassistant/components/light/hue.py

@@ -23,7 +23,6 @@ from homeassistant.components.light import (
     SUPPORT_XY_COLOR, Light, PLATFORM_SCHEMA)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.const import (CONF_FILENAME, CONF_HOST, DEVICE_DEFAULT_NAME)
-from homeassistant.loader import get_component
 from homeassistant.components.emulated_hue import ATTR_EMULATED_HUE
 import homeassistant.helpers.config_validation as cv
 
@@ -84,6 +83,7 @@ SCENE_SCHEMA = vol.Schema({
 })
 
 ATTR_IS_HUE_GROUP = "is_hue_group"
+GROUP_NAME_ALL_HUE_LIGHTS = "All Hue Lights"
 
 
 def _find_host_from_config(hass, filename=PHUE_CONFIG_FILE):
@@ -164,9 +164,7 @@ def setup_bridge(host, hass, add_devices, filename, allow_unreachable,
     # If we came here and configuring this host, mark as done
     if host in _CONFIGURING:
         request_id = _CONFIGURING.pop(host)
-
-        configurator = get_component('configurator')
-
+        configurator = hass.components.configurator
         configurator.request_done(request_id)
 
     lights = {}
@@ -206,6 +204,21 @@ def setup_bridge(host, hass, add_devices, filename, allow_unreachable,
             _LOGGER.error("Got unexpected result from Hue API")
             return
 
+        if not skip_groups:
+            # Group ID 0 is a special group in the hub for all lights, but it
+            # is not returned by get_api() so explicity get it and include it.
+            # See https://developers.meethue.com/documentation/
+            #               groups-api#21_get_all_groups
+            _LOGGER.debug("Getting group 0 from bridge")
+            all_lights = bridge.get_group(0)
+            if not isinstance(all_lights, dict):
+                _LOGGER.error("Got unexpected result from Hue API for group 0")
+                return
+            # Hue hub returns name of group 0 as "Group 0", so rename
+            # for ease of use in HA.
+            all_lights['name'] = GROUP_NAME_ALL_HUE_LIGHTS
+            api_groups["0"] = all_lights
+
         new_lights = []
 
         api_name = api.get('config').get('name')
@@ -268,7 +281,7 @@ def request_configuration(host, hass, add_devices, filename,
                           allow_unreachable, allow_in_emulated_hue,
                           allow_hue_groups):
     """Request configuration steps from the user."""
-    configurator = get_component('configurator')
+    configurator = hass.components.configurator
 
     # We got an error if this method is called while we are configuring
     if host in _CONFIGURING:
@@ -284,7 +297,7 @@ def request_configuration(host, hass, add_devices, filename,
                      allow_in_emulated_hue, allow_hue_groups)
 
     _CONFIGURING[host] = configurator.request_config(
-        hass, "Philips Hue", hue_configuration_callback,
+        "Philips Hue", hue_configuration_callback,
         description=("Press the button on the bridge to register Philips Hue "
                      "with Home Assistant."),
         entity_picture="/static/images/logo_philips_hue.png",
@@ -384,7 +397,6 @@ class HueLight(Light):
                 hue, sat = color_util.color_xy_to_hs(*kwargs[ATTR_XY_COLOR])
                 command['hue'] = hue
                 command['sat'] = sat
-                command['bri'] = self.info['bri']
             else:
                 command['xy'] = kwargs[ATTR_XY_COLOR]
         elif ATTR_RGB_COLOR in kwargs:
@@ -399,14 +411,13 @@ class HueLight(Light):
                     *(int(val) for val in kwargs[ATTR_RGB_COLOR]))
                 command['xy'] = xyb[0], xyb[1]
                 command['bri'] = xyb[2]
+        elif ATTR_COLOR_TEMP in kwargs:
+            temp = kwargs[ATTR_COLOR_TEMP]
+            command['ct'] = max(self.min_mireds, min(temp, self.max_mireds))
 
         if ATTR_BRIGHTNESS in kwargs:
             command['bri'] = kwargs[ATTR_BRIGHTNESS]
 
-        if ATTR_COLOR_TEMP in kwargs:
-            temp = kwargs[ATTR_COLOR_TEMP]
-            command['ct'] = max(self.min_mireds, min(temp, self.max_mireds))
-
         flash = kwargs.get(ATTR_FLASH)
 
         if flash == FLASH_LONG:
@@ -425,9 +436,9 @@ class HueLight(Light):
         elif effect == EFFECT_RANDOM:
             command['hue'] = random.randrange(0, 65535)
             command['sat'] = random.randrange(150, 254)
-        elif self.bridge_type == 'hue':
-            if self.info.get('manufacturername') != "OSRAM":
-                command['effect'] = 'none'
+        elif (self.bridge_type == 'hue' and
+              self.info.get('manufacturername') == 'Philips'):
+            command['effect'] = 'none'
 
         self._command_func(self.light_id, command)
 

homeassistant/components/light/insteon_local.py

@@ -11,7 +11,6 @@ from datetime import timedelta
 
 from homeassistant.components.light import (
     ATTR_BRIGHTNESS, SUPPORT_BRIGHTNESS, Light)
-from homeassistant.loader import get_component
 import homeassistant.util as util
 
 _CONFIGURING = {}
@@ -54,7 +53,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 def request_configuration(device_id, insteonhub, model, hass,
                           add_devices_callback):
     """Request configuration steps from the user."""
-    configurator = get_component('configurator')
+    configurator = hass.components.configurator
 
     # We got an error if this method is called while we are configuring
     if device_id in _CONFIGURING:
@@ -69,7 +68,7 @@ def request_configuration(device_id, insteonhub, model, hass,
                     add_devices_callback)
 
     _CONFIGURING[device_id] = configurator.request_config(
-        hass, 'Insteon  ' + model + ' addr: ' + device_id,
+        'Insteon  ' + model + ' addr: ' + device_id,
         insteon_light_config_callback,
         description=('Enter a name for ' + model + ' addr: ' + device_id),
         entity_picture='/static/images/config_insteon.png',
@@ -82,7 +81,7 @@ def setup_light(device_id, name, insteonhub, hass, add_devices_callback):
     """Set up the light."""
     if device_id in _CONFIGURING:
         request_id = _CONFIGURING.pop(device_id)
-        configurator = get_component('configurator')
+        configurator = hass.components.configurator
         configurator.request_done(request_id)
         _LOGGER.debug("Device configuration done")
 

homeassistant/components/light/knx.py

@@ -1,17 +1,17 @@
 """
-Support KNX Lighting actuators.
+Support for KNX/IP lights.
 
 For more details about this platform, please refer to the documentation at
-https://home-assistant.io/components/Light.knx/
+https://home-assistant.io/components/light.knx/
 """
-import logging
+import asyncio
 import voluptuous as vol
 
-from homeassistant.components.knx import (KNXConfig, KNXMultiAddressDevice)
-from homeassistant.components.light import (Light, PLATFORM_SCHEMA,
-                                            SUPPORT_BRIGHTNESS,
-                                            ATTR_BRIGHTNESS)
+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES
+from homeassistant.components.light import PLATFORM_SCHEMA, Light, \
+    SUPPORT_BRIGHTNESS, ATTR_BRIGHTNESS
 from homeassistant.const import CONF_NAME
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
 CONF_ADDRESS = 'address'
@@ -19,8 +19,6 @@ CONF_STATE_ADDRESS = 'state_address'
 CONF_BRIGHTNESS_ADDRESS = 'brightness_address'
 CONF_BRIGHTNESS_STATE_ADDRESS = 'brightness_state_address'
 
-_LOGGER = logging.getLogger(__name__)
-
 DEFAULT_NAME = 'KNX Light'
 DEPENDENCIES = ['knx']
 
@@ -33,84 +31,136 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })
 
 
-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the KNX light platform."""
-    add_devices([KNXLight(hass, KNXConfig(config))])
+@asyncio.coroutine
+def async_setup_platform(hass, config, add_devices,
+                         discovery_info=None):
+    """Set up light(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False
+
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, add_devices)
+    else:
+        async_add_devices_config(hass, config, add_devices)
+
+    return True
 
 
-class KNXLight(KNXMultiAddressDevice, Light):
-    """Representation of a KNX Light device."""
+@callback
+def async_add_devices_discovery(hass, discovery_info, add_devices):
+    """Set up lights for KNX platform configured via xknx.yaml."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXLight(hass, device))
+    add_devices(entities)
 
-    def __init__(self, hass, config):
-        """Initialize the cover."""
-        KNXMultiAddressDevice.__init__(
-            self, hass, config,
-            [],  # required
-            optional=['state', 'brightness', 'brightness_state']
-        )
-        self._hass = hass
-        self._supported_features = 0
 
-        if CONF_BRIGHTNESS_ADDRESS in config.config:
-            _LOGGER.debug("%s is dimmable", self.name)
-            self._supported_features = self._supported_features | \
-                SUPPORT_BRIGHTNESS
-            self._brightness = None
+@callback
+def async_add_devices_config(hass, config, add_devices):
+    """Set up light for KNX platform configured within plattform."""
+    import xknx
+    light = xknx.devices.Light(
+        hass.data[DATA_KNX].xknx,
+        name=config.get(CONF_NAME),
+        group_address_switch=config.get(CONF_ADDRESS),
+        group_address_switch_state=config.get(CONF_STATE_ADDRESS),
+        group_address_brightness=config.get(CONF_BRIGHTNESS_ADDRESS),
+        group_address_brightness_state=config.get(
+            CONF_BRIGHTNESS_STATE_ADDRESS))
+    hass.data[DATA_KNX].xknx.devices.add(light)
+    add_devices([KNXLight(hass, light)])
 
-    def turn_on(self, **kwargs):
-        """Turn the switch on.
 
-        This sends a value 1 to the group address of the device
-        """
-        _LOGGER.debug("%s: turn on", self.name)
-        self.set_value('base', [1])
-        self._state = 1
+class KNXLight(Light):
+    """Representation of a KNX light."""
 
-        if ATTR_BRIGHTNESS in kwargs:
-            self._brightness = kwargs[ATTR_BRIGHTNESS]
-            _LOGGER.debug("turn_on requested brightness for light: %s is: %s ",
-                          self.name, self._brightness)
-            assert self._brightness <= 255
-            self.set_value("brightness", [self._brightness])
+    def __init__(self, hass, device):
+        """Initialization of KNXLight."""
+        self.device = device
+        self.hass = hass
+        self.async_register_callbacks()
 
-        if not self.should_poll:
-            self.schedule_update_ha_state()
+    @callback
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
 
-    def turn_off(self, **kwargs):
-        """Turn the switch off.
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name
 
-        This sends a value 1 to the group address of the device
-        """
-        _LOGGER.debug("%s: turn off", self.name)
-        self.set_value('base', [0])
-        self._state = 0
-        if not self.should_poll:
-            self.schedule_update_ha_state()
+    @property
+    def should_poll(self):
+        """No polling needed within KNX."""
+        return False
+
+    @property
+    def brightness(self):
+        """Return the brightness of this light between 0..255."""
+        return self.device.brightness \
+            if self.device.supports_dimming else \
+            None
+
+    @property
+    def xy_color(self):
+        """Return the XY color value [float, float]."""
+        return None
+
+    @property
+    def rgb_color(self):
+        """Return the RBG color value."""
+        return None
+
+    @property
+    def color_temp(self):
+        """Return the CT color temperature."""
+        return None
+
+    @property
+    def white_value(self):
+        """Return the white value of this light between 0..255."""
+        return None
+
+    @property
+    def effect_list(self):
+        """Return the list of supported effects."""
+        return None
+
+    @property
+    def effect(self):
+        """Return the current effect."""
+        return None
 
     @property
     def is_on(self):
-        """Return True if the value is not 0 is on, else False."""
-        return self._state != 0
+        """Return true if light is on."""
+        return self.device.state
 
     @property
     def supported_features(self):
         """Flag supported features."""
-        return self._supported_features
+        flags = 0
+        if self.device.supports_dimming:
+            flags |= SUPPORT_BRIGHTNESS
+        return flags
 
-    def update(self):
-        """Update device state."""
-        super().update()
-        if self.has_attribute('brightness_state'):
-            value = self.value('brightness_state')
-            if value is not None:
-                self._brightness = int.from_bytes(value, byteorder='little')
-                _LOGGER.debug("%s: brightness = %d",
-                              self.name, self._brightness)
+    @asyncio.coroutine
+    def async_turn_on(self, **kwargs):
+        """Turn the light on."""
+        if ATTR_BRIGHTNESS in kwargs and self.device.supports_dimming:
+            yield from self.device.set_brightness(int(kwargs[ATTR_BRIGHTNESS]))
+        else:
+            yield from self.device.set_on()
 
-        if self.has_attribute('state'):
-            self._state = self.value("state")[0]
-            _LOGGER.debug("%s: state = %d", self.name, self._state)
-
-    def should_poll(self):
-        """No polling needed for a KNX light."""
-        return False
+    @asyncio.coroutine
+    def async_turn_off(self, **kwargs):
+        """Turn the light off."""
+        yield from self.device.set_off()

homeassistant/components/light/lifx.py

@@ -325,29 +325,33 @@ class LIFXManager(object):
             entity = self.entities[device.mac_addr]
             entity.registered = True
             _LOGGER.debug("%s register AGAIN", entity.who)
-            yield from entity.async_update()
-            yield from entity.async_update_ha_state()
+            yield from entity.update_hass()
         else:
             _LOGGER.debug("%s register NEW", device.ip_addr)
-            device.timeout = MESSAGE_TIMEOUT
-            device.retry_count = MESSAGE_RETRIES
-            device.unregister_timeout = UNAVAILABLE_GRACE
 
+            # Read initial state
             ack = AwaitAioLIFX().wait
-            yield from ack(device.get_version)
-            yield from ack(device.get_color)
+            version_resp = yield from ack(device.get_version)
+            if version_resp:
+                color_resp = yield from ack(device.get_color)
 
-            if lifxwhite(device):
-                entity = LIFXWhite(device, self.effects_conductor)
-            elif lifxmultizone(device):
-                yield from ack(partial(device.get_color_zones, start_index=0))
-                entity = LIFXStrip(device, self.effects_conductor)
+            if version_resp is None or color_resp is None:
+                _LOGGER.error("Failed to initialize %s", device.ip_addr)
             else:
-                entity = LIFXColor(device, self.effects_conductor)
+                device.timeout = MESSAGE_TIMEOUT
+                device.retry_count = MESSAGE_RETRIES
+                device.unregister_timeout = UNAVAILABLE_GRACE
 
-            _LOGGER.debug("%s register READY", entity.who)
-            self.entities[device.mac_addr] = entity
-            self.async_add_devices([entity])
+                if lifxwhite(device):
+                    entity = LIFXWhite(device, self.effects_conductor)
+                elif lifxmultizone(device):
+                    entity = LIFXStrip(device, self.effects_conductor)
+                else:
+                    entity = LIFXColor(device, self.effects_conductor)
+
+                _LOGGER.debug("%s register READY", entity.who)
+                self.entities[device.mac_addr] = entity
+                self.async_add_devices([entity], True)
 
     @callback
     def unregister(self, device):
@@ -674,9 +678,14 @@ class LIFXStrip(LIFXColor):
     @asyncio.coroutine
     def update_color_zones(self):
         """Get updated color information for each zone."""
-        ack = AwaitAioLIFX().wait
-        bulb = self.device
-
-        # Each get_color_zones returns the next 8 zones
-        for zone in range(0, len(bulb.color_zones), 8):
-            yield from ack(partial(bulb.get_color_zones, start_index=zone))
+        zone = 0
+        top = 1
+        while self.available and zone < top:
+            # Each get_color_zones can update 8 zones at once
+            resp = yield from AwaitAioLIFX().wait(partial(
+                self.device.get_color_zones,
+                start_index=zone,
+                end_index=zone+7))
+            if resp:
+                zone += 8
+                top = resp.count

homeassistant/components/light/lutron_caseta.py

@@ -7,7 +7,7 @@ https://home-assistant.io/components/light.lutron_caseta/
 import logging
 
 from homeassistant.components.light import (
-    ATTR_BRIGHTNESS, SUPPORT_BRIGHTNESS, Light)
+    ATTR_BRIGHTNESS, SUPPORT_BRIGHTNESS, Light, DOMAIN)
 from homeassistant.components.light.lutron import (
     to_hass_level, to_lutron_level)
 from homeassistant.components.lutron_caseta import (
@@ -23,7 +23,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Lutron Caseta lights."""
     devs = []
     bridge = hass.data[LUTRON_CASETA_SMARTBRIDGE]
-    light_devices = bridge.get_devices_by_types(["WallDimmer", "PlugInDimmer"])
+    light_devices = bridge.get_devices_by_domain(DOMAIN)
     for light_device in light_devices:
         dev = LutronCasetaLight(light_device, bridge)
         devs.append(dev)

homeassistant/components/light/mqtt.py

@@ -39,6 +39,7 @@ CONF_EFFECT_COMMAND_TOPIC = 'effect_command_topic'
 CONF_EFFECT_LIST = 'effect_list'
 CONF_EFFECT_STATE_TOPIC = 'effect_state_topic'
 CONF_EFFECT_VALUE_TEMPLATE = 'effect_value_template'
+CONF_RGB_COMMAND_TEMPLATE = 'rgb_command_template'
 CONF_RGB_COMMAND_TOPIC = 'rgb_command_topic'
 CONF_RGB_STATE_TOPIC = 'rgb_state_topic'
 CONF_RGB_VALUE_TEMPLATE = 'rgb_value_template'
@@ -75,6 +76,7 @@ PLATFORM_SCHEMA = mqtt.MQTT_RW_PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean,
     vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string,
     vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
+    vol.Optional(CONF_RGB_COMMAND_TEMPLATE): cv.template,
     vol.Optional(CONF_RGB_COMMAND_TOPIC): mqtt.valid_publish_topic,
     vol.Optional(CONF_RGB_STATE_TOPIC): mqtt.valid_subscribe_topic,
     vol.Optional(CONF_RGB_VALUE_TEMPLATE): cv.template,
@@ -125,6 +127,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
             CONF_COLOR_TEMP: config.get(CONF_COLOR_TEMP_VALUE_TEMPLATE),
             CONF_EFFECT: config.get(CONF_EFFECT_VALUE_TEMPLATE),
             CONF_RGB: config.get(CONF_RGB_VALUE_TEMPLATE),
+            CONF_RGB_COMMAND_TEMPLATE: config.get(CONF_RGB_COMMAND_TEMPLATE),
             CONF_STATE: config.get(CONF_STATE_VALUE_TEMPLATE),
             CONF_WHITE_VALUE: config.get(CONF_WHITE_VALUE_TEMPLATE),
             CONF_XY: config.get(CONF_XY_VALUE_TEMPLATE),
@@ -397,10 +400,17 @@ class MqttLight(Light):
         if ATTR_RGB_COLOR in kwargs and \
            self._topic[CONF_RGB_COMMAND_TOPIC] is not None:
 
+            tpl = self._templates[CONF_RGB_COMMAND_TEMPLATE]
+            if tpl:
+                colors = {'red', 'green', 'blue'}
+                variables = {key: val for key, val in
+                             zip(colors, kwargs[ATTR_RGB_COLOR])}
+                rgb_color_str = tpl.async_render(variables)
+            else:
+                rgb_color_str = '{},{},{}'.format(*kwargs[ATTR_RGB_COLOR])
             mqtt.async_publish(
                 self.hass, self._topic[CONF_RGB_COMMAND_TOPIC],
-                '{},{},{}'.format(*kwargs[ATTR_RGB_COLOR]), self._qos,
-                self._retain)
+                rgb_color_str, self._qos, self._retain)
 
             if self._optimistic_rgb:
                 self._rgb = kwargs[ATTR_RGB_COLOR]