Merge pull request #8757 from home-assistant/release-0-50-2

0.50.2

.coveragerc

@@ -172,6 +172,9 @@ omit =
     homeassistant/components/twilio.py
     homeassistant/components/notify/twilio_sms.py
     homeassistant/components/notify/twilio_call.py
+  
+    homeassistant/components/velbus.py
+    homeassistant/components/*/velbus.py
 
     homeassistant/components/velux.py
     homeassistant/components/*/velux.py
@@ -193,6 +196,9 @@ omit =
     homeassistant/components/wink.py
     homeassistant/components/*/wink.py
 
+    homeassistant/components/xiaomi.py
+    homeassistant/components/*/xiaomi.py
+
     homeassistant/components/zabbix.py
     homeassistant/components/*/zabbix.py
 
@@ -208,6 +214,7 @@ omit =
 
     homeassistant/components/alarm_control_panel/alarmdotcom.py
     homeassistant/components/alarm_control_panel/concord232.py
+    homeassistant/components/alarm_control_panel/manual_mqtt.py
     homeassistant/components/alarm_control_panel/nx584.py
     homeassistant/components/alarm_control_panel/simplisafe.py
     homeassistant/components/alarm_control_panel/totalconnect.py
@@ -274,7 +281,6 @@ omit =
     homeassistant/components/device_tracker/tplink.py
     homeassistant/components/device_tracker/trackr.py
     homeassistant/components/device_tracker/ubus.py
-    homeassistant/components/device_tracker/xiaomi.py
     homeassistant/components/downloader.py
     homeassistant/components/emoncms_history.py
     homeassistant/components/emulated_hue/upnp.py
@@ -303,6 +309,7 @@ omit =
     homeassistant/components/light/piglow.py
     homeassistant/components/light/sensehat.py
     homeassistant/components/light/tikteck.py
+    homeassistant/components/light/tplink.py
     homeassistant/components/light/tradfri.py
     homeassistant/components/light/x10.py
     homeassistant/components/light/yeelight.py

README.rst

@@ -1,5 +1,5 @@
-Home Assistant |Build Status| |Coverage Status| |Join the chat at https://gitter.im/home-assistant/home-assistant| |Join the dev chat at https://gitter.im/home-assistant/home-assistant/devs|
-==============================================================================================================================================================================================
+Home Assistant |Build Status| |Coverage Status| |Chat Status|
+=============================================================
 
 Home Assistant is a home automation platform running on Python 3. It is able to track and control all devices at home and offer a platform for automating control.
 
@@ -31,6 +31,8 @@ of a component, check the `Home Assistant help section <https://home-assistant.i
    :target: https://travis-ci.org/home-assistant/home-assistant
 .. |Coverage Status| image:: https://img.shields.io/coveralls/home-assistant/home-assistant.svg
    :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

homeassistant/bootstrap.py

@@ -19,6 +19,7 @@ from homeassistant.const import EVENT_HOMEASSISTANT_CLOSE
 from homeassistant.setup import async_setup_component
 import homeassistant.loader as loader
 from homeassistant.util.logging import AsyncHandler
+from homeassistant.util.package import async_get_user_site, get_user_site
 from homeassistant.util.yaml import clear_secret_cache
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.signal import async_register_signal_handling
@@ -39,7 +40,7 @@ def from_config_dict(config: Dict[str, Any],
                      skip_pip: bool=False,
                      log_rotate_days: Any=None) \
                      -> Optional[core.HomeAssistant]:
-    """Try to configure Home Assistant from a config dict.
+    """Try to configure Home Assistant from a configuration dictionary.
 
     Dynamically loads required components and its dependencies.
     """
@@ -48,7 +49,8 @@ def from_config_dict(config: Dict[str, Any],
         if config_dir is not None:
             config_dir = os.path.abspath(config_dir)
             hass.config.config_dir = config_dir
-            mount_local_lib_path(config_dir)
+            hass.loop.run_until_complete(
+                async_mount_local_lib_path(config_dir, hass.loop))
 
     # run task
     hass = hass.loop.run_until_complete(
@@ -69,7 +71,7 @@ def async_from_config_dict(config: Dict[str, Any],
                            skip_pip: bool=False,
                            log_rotate_days: Any=None) \
                            -> Optional[core.HomeAssistant]:
-    """Try to configure Home Assistant from a config dict.
+    """Try to configure Home Assistant from a configuration dictionary.
 
     Dynamically loads required components and its dependencies.
     This method is a coroutine.
@@ -90,8 +92,8 @@ def async_from_config_dict(config: Dict[str, Any],
 
     hass.config.skip_pip = skip_pip
     if skip_pip:
-        _LOGGER.warning('Skipping pip installation of required modules. '
-                        'This may cause issues.')
+        _LOGGER.warning("Skipping pip installation of required modules. "
+                        "This may cause issues")
 
     if not loader.PREPARED:
         yield from hass.async_add_job(loader.prepare, hass)
@@ -116,13 +118,13 @@ def async_from_config_dict(config: Dict[str, Any],
     # pylint: disable=not-an-iterable
     res = yield from core_components.async_setup(hass, config)
     if not res:
-        _LOGGER.error('Home Assistant core failed to initialize. '
-                      'Further initialization aborted.')
+        _LOGGER.error("Home Assistant core failed to initialize. "
+                      "further initialization aborted")
         return hass
 
     yield from persistent_notification.async_setup(hass, config)
 
-    _LOGGER.info('Home Assistant core initialized')
+    _LOGGER.info("Home Assistant core initialized")
 
     # stage 1
     for component in components:
@@ -141,7 +143,7 @@ def async_from_config_dict(config: Dict[str, Any],
     yield from hass.async_block_till_done()
 
     stop = time()
-    _LOGGER.info('Home Assistant initialized in %.2fs', stop-start)
+    _LOGGER.info("Home Assistant initialized in %.2fs", stop-start)
 
     async_register_signal_handling(hass)
     return hass
@@ -183,7 +185,7 @@ def async_from_config_file(config_path: str,
     # Set config dir to directory holding config file
     config_dir = os.path.abspath(os.path.dirname(config_path))
     hass.config.config_dir = config_dir
-    yield from hass.async_add_job(mount_local_lib_path, config_dir)
+    yield from async_mount_local_lib_path(config_dir, hass.loop)
 
     async_enable_logging(hass, verbose, log_rotate_days)
 
@@ -191,7 +193,7 @@ def async_from_config_file(config_path: str,
         config_dict = yield from hass.async_add_job(
             conf_util.load_yaml_config_file, config_path)
     except HomeAssistantError as err:
-        _LOGGER.error('Error loading %s: %s', config_path, err)
+        _LOGGER.error("Error loading %s: %s", config_path, err)
         return None
     finally:
         clear_secret_cache()
@@ -276,11 +278,23 @@ def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
 
 
 def mount_local_lib_path(config_dir: str) -> str:
+    """Add local library to Python Path."""
+    deps_dir = os.path.join(config_dir, 'deps')
+    lib_dir = get_user_site(deps_dir)
+    if lib_dir not in sys.path:
+        sys.path.insert(0, lib_dir)
+    return deps_dir
+
+
+@asyncio.coroutine
+def async_mount_local_lib_path(config_dir: str,
+                               loop: asyncio.AbstractEventLoop) -> str:
     """Add local library to Python Path.
 
-    Async friendly.
+    This function is a coroutine.
     """
     deps_dir = os.path.join(config_dir, 'deps')
-    if deps_dir not in sys.path:
-        sys.path.insert(0, os.path.join(config_dir, 'deps'))
+    lib_dir = yield from async_get_user_site(deps_dir, loop=loop)
+    if lib_dir not in sys.path:
+        sys.path.insert(0, lib_dir)
     return deps_dir

homeassistant/components/__init__.py

@@ -15,7 +15,6 @@ import homeassistant.core as ha
 import homeassistant.config as conf_util
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.service import extract_entity_ids
-from homeassistant.loader import get_component
 from homeassistant.const import (
     ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF, SERVICE_TOGGLE,
     SERVICE_HOMEASSISTANT_STOP, SERVICE_HOMEASSISTANT_RESTART,
@@ -33,25 +32,27 @@ def is_on(hass, entity_id=None):
     If there is no entity id given we will check all.
     """
     if entity_id:
-        group = get_component('group')
-
-        entity_ids = group.expand_entity_ids(hass, [entity_id])
+        entity_ids = hass.components.group.expand_entity_ids([entity_id])
     else:
         entity_ids = hass.states.entity_ids()
 
     for ent_id in entity_ids:
         domain = ha.split_entity_id(ent_id)[0]
 
-        module = get_component(domain)
-
         try:
-            if module.is_on(hass, ent_id):
-                return True
+            component = getattr(hass.components, domain)
 
-        except AttributeError:
-            # module is None or method is_on does not exist
-            _LOGGER.exception("Failed to call %s.is_on for %s",
-                              module, ent_id)
+        except ImportError:
+            _LOGGER.error('Failed to call %s.is_on: component not found',
+                          domain)
+            continue
+
+        if not hasattr(component, 'is_on'):
+            _LOGGER.warning("Component %s has no is_on method.", domain)
+            continue
+
+        if component.is_on(ent_id):
+            return True
 
     return False
 
@@ -161,10 +162,9 @@ def async_setup(hass, config):
             return
 
         if errors:
-            notif = get_component('persistent_notification')
             _LOGGER.error(errors)
-            notif.async_create(
-                hass, "Config error. See dev-info panel for details.",
+            hass.components.persistent_notification.async_create(
+                "Config error. See dev-info panel for details.",
                 "Config validating", "{0}.check_config".format(ha.DOMAIN))
             return
 

homeassistant/components/alarm_control_panel/__init__.py

@@ -15,6 +15,7 @@ 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)
 from homeassistant.config import load_yaml_config_file
+from homeassistant.loader import bind_hass
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import Entity
@@ -44,6 +45,7 @@ ALARM_SERVICE_SCHEMA = vol.Schema({
 })
 
 
+@bind_hass
 def alarm_disarm(hass, code=None, entity_id=None):
     """Send the alarm the command for disarm."""
     data = {}
@@ -55,6 +57,7 @@ def alarm_disarm(hass, code=None, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_ALARM_DISARM, data)
 
 
+@bind_hass
 def alarm_arm_home(hass, code=None, entity_id=None):
     """Send the alarm the command for arm home."""
     data = {}
@@ -66,6 +69,7 @@ def alarm_arm_home(hass, code=None, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_ALARM_ARM_HOME, data)
 
 
+@bind_hass
 def alarm_arm_away(hass, code=None, entity_id=None):
     """Send the alarm the command for arm away."""
     data = {}
@@ -77,6 +81,7 @@ def alarm_arm_away(hass, code=None, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_ALARM_ARM_AWAY, data)
 
 
+@bind_hass
 def alarm_trigger(hass, code=None, entity_id=None):
     """Send the alarm the command for trigger."""
     data = {}

homeassistant/components/alarm_control_panel/manual_mqtt.py

@@ -0,0 +1,235 @@
+"""
+Support for manual alarms controllable via MQTT.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.manual_mqtt/
+"""
+import asyncio
+import datetime
+import logging
+
+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)
+import homeassistant.components.mqtt as mqtt
+
+from homeassistant.helpers.event import async_track_state_change
+from homeassistant.core import callback
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.event import track_point_in_time
+
+CONF_PAYLOAD_DISARM = 'payload_disarm'
+CONF_PAYLOAD_ARM_HOME = 'payload_arm_home'
+CONF_PAYLOAD_ARM_AWAY = 'payload_arm_away'
+
+DEFAULT_ALARM_NAME = 'HA Alarm'
+DEFAULT_PENDING_TIME = 60
+DEFAULT_TRIGGER_TIME = 120
+DEFAULT_DISARM_AFTER_TRIGGER = False
+DEFAULT_ARM_AWAY = 'ARM_AWAY'
+DEFAULT_ARM_HOME = 'ARM_HOME'
+DEFAULT_DISARM = 'DISARM'
+
+DEPENDENCIES = ['mqtt']
+
+PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PLATFORM): 'manual_mqtt',
+    vol.Optional(CONF_NAME, default=DEFAULT_ALARM_NAME): cv.string,
+    vol.Optional(CONF_CODE): cv.string,
+    vol.Optional(CONF_PENDING_TIME, default=DEFAULT_PENDING_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=0)),
+    vol.Optional(CONF_TRIGGER_TIME, default=DEFAULT_TRIGGER_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=1)),
+    vol.Optional(CONF_DISARM_AFTER_TRIGGER,
+                 default=DEFAULT_DISARM_AFTER_TRIGGER): cv.boolean,
+    vol.Required(mqtt.CONF_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Required(mqtt.CONF_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_PAYLOAD_ARM_AWAY, default=DEFAULT_ARM_AWAY): cv.string,
+    vol.Optional(CONF_PAYLOAD_ARM_HOME, default=DEFAULT_ARM_HOME): cv.string,
+    vol.Optional(CONF_PAYLOAD_DISARM, default=DEFAULT_DISARM): cv.string,
+})
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the manual MQTT alarm platform."""
+    add_devices([ManualMQTTAlarm(
+        hass,
+        config[CONF_NAME],
+        config.get(CONF_CODE),
+        config.get(CONF_PENDING_TIME, DEFAULT_PENDING_TIME),
+        config.get(CONF_TRIGGER_TIME, DEFAULT_TRIGGER_TIME),
+        config.get(CONF_DISARM_AFTER_TRIGGER, DEFAULT_DISARM_AFTER_TRIGGER),
+        config.get(mqtt.CONF_STATE_TOPIC),
+        config.get(mqtt.CONF_COMMAND_TOPIC),
+        config.get(mqtt.CONF_QOS),
+        config.get(CONF_PAYLOAD_DISARM),
+        config.get(CONF_PAYLOAD_ARM_HOME),
+        config.get(CONF_PAYLOAD_ARM_AWAY))])
+
+
+class ManualMQTTAlarm(alarm.AlarmControlPanel):
+    """
+    Representation of an alarm status.
+
+    When armed, will be pending for 'pending_time', after that armed.
+    When triggered, will be pending for 'trigger_time'. After that will be
+    triggered for 'trigger_time', after that we return to the previous state
+    or disarm if `disarm_after_trigger` is true.
+    """
+
+    def __init__(self, hass, name, code, pending_time,
+                 trigger_time, disarm_after_trigger,
+                 state_topic, command_topic, qos,
+                 payload_disarm, payload_arm_home, payload_arm_away):
+        """Init the manual MQTT alarm panel."""
+        self._state = STATE_ALARM_DISARMED
+        self._hass = hass
+        self._name = name
+        self._code = str(code) if code else None
+        self._pending_time = datetime.timedelta(seconds=pending_time)
+        self._trigger_time = datetime.timedelta(seconds=trigger_time)
+        self._disarm_after_trigger = disarm_after_trigger
+        self._pre_trigger_state = self._state
+        self._state_ts = None
+
+        self._state_topic = state_topic
+        self._command_topic = command_topic
+        self._qos = qos
+        self._payload_disarm = payload_disarm
+        self._payload_arm_home = payload_arm_home
+        self._payload_arm_away = payload_arm_away
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        if self._state in (STATE_ALARM_ARMED_HOME,
+                           STATE_ALARM_ARMED_AWAY) and \
+           self._pending_time and self._state_ts + self._pending_time > \
+           dt_util.utcnow():
+            return STATE_ALARM_PENDING
+
+        if self._state == STATE_ALARM_TRIGGERED and self._trigger_time:
+            if self._state_ts + self._pending_time > dt_util.utcnow():
+                return STATE_ALARM_PENDING
+            elif (self._state_ts + self._pending_time +
+                  self._trigger_time) < dt_util.utcnow():
+                if self._disarm_after_trigger:
+                    return STATE_ALARM_DISARMED
+                return self._pre_trigger_state
+
+        return self._state
+
+    @property
+    def code_format(self):
+        """One or more characters."""
+        return None if self._code is None else '.+'
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        if not self._validate_code(code, STATE_ALARM_DISARMED):
+            return
+
+        self._state = STATE_ALARM_DISARMED
+        self._state_ts = dt_util.utcnow()
+        self.schedule_update_ha_state()
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_HOME):
+            return
+
+        self._state = STATE_ALARM_ARMED_HOME
+        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_arm_away(self, code=None):
+        """Send arm away command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_AWAY):
+            return
+
+        self._state = STATE_ALARM_ARMED_AWAY
+        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
+        self._state = STATE_ALARM_TRIGGERED
+        self._state_ts = dt_util.utcnow()
+        self.schedule_update_ha_state()
+
+        if self._trigger_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + self._pending_time)
+
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + self._pending_time + self._trigger_time)
+
+    def _validate_code(self, code, state):
+        """Validate given code."""
+        check = self._code is None or code == self._code
+        if not check:
+            _LOGGER.warning("Invalid code given for %s", state)
+        return check
+
+    def async_added_to_hass(self):
+        """Subscribe mqtt events.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        async_track_state_change(
+            self.hass, self.entity_id, self._async_state_changed_listener
+        )
+
+        @callback
+        def message_received(topic, payload, qos):
+            """Run when new MQTT message has been received."""
+            if payload == self._payload_disarm:
+                self.async_alarm_disarm(self._code)
+            elif payload == self._payload_arm_home:
+                self.async_alarm_arm_home(self._code)
+            elif payload == self._payload_arm_away:
+                self.async_alarm_arm_away(self._code)
+            else:
+                _LOGGER.warning("Received unexpected payload: %s", payload)
+                return
+
+        return mqtt.async_subscribe(
+            self.hass, self._command_topic, message_received, self._qos)
+
+    @asyncio.coroutine
+    def _async_state_changed_listener(self, entity_id, old_state, new_state):
+        """Publish state change to MQTT."""
+        mqtt.async_publish(self.hass, self._state_topic, new_state.state,
+                           self._qos, True)

homeassistant/components/alarm_control_panel/simplisafe.py

@@ -15,9 +15,8 @@ from homeassistant.const import (
     STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_AWAY,
     EVENT_HOMEASSISTANT_STOP)
 import homeassistant.helpers.config_validation as cv
-import homeassistant.loader as loader
 
-REQUIREMENTS = ['simplisafe-python==1.0.2']
+REQUIREMENTS = ['simplisafe-python==1.0.3']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -42,7 +41,6 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     username = config.get(CONF_USERNAME)
     password = config.get(CONF_PASSWORD)
 
-    persistent_notification = loader.get_component('persistent_notification')
     simplisafe = SimpliSafeApiInterface()
     status = simplisafe.set_credentials(username, password)
     if status:
@@ -53,8 +51,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     else:
         message = 'Failed to log into SimpliSafe. Check credentials.'
         _LOGGER.error(message)
-        persistent_notification.create(
-            hass, message,
+        hass.components.persistent_notification.create(
+            message,
             title=NOTIFICATION_TITLE,
             notification_id=NOTIFICATION_ID)
         return False

homeassistant/components/alarmdecoder.py

@@ -15,7 +15,7 @@ from homeassistant.const import EVENT_HOMEASSISTANT_STOP
 from homeassistant.helpers.discovery import async_load_platform
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
-REQUIREMENTS = ['alarmdecoder==0.12.1.0']
+REQUIREMENTS = ['alarmdecoder==0.12.3']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/alexa.py

@@ -15,8 +15,8 @@ import voluptuous as vol
 
 from homeassistant.core import callback
 from homeassistant.const import HTTP_BAD_REQUEST
-from homeassistant.helpers import template, script, config_validation as cv
-from homeassistant.components.http import HomeAssistantView
+from homeassistant.helpers import intent, template, config_validation as cv
+from homeassistant.components import http
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -60,6 +60,12 @@ class SpeechType(enum.Enum):
     ssml = "SSML"
 
 
+SPEECH_MAPPINGS = {
+    'plain': SpeechType.plaintext,
+    'ssml': SpeechType.ssml,
+}
+
+
 class CardType(enum.Enum):
     """The Alexa card types."""
 
@@ -69,20 +75,6 @@ class CardType(enum.Enum):
 
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: {
-        CONF_INTENTS: {
-            cv.string: {
-                vol.Optional(CONF_ACTION): cv.SCRIPT_SCHEMA,
-                vol.Optional(CONF_CARD): {
-                    vol.Required(CONF_TYPE): cv.enum(CardType),
-                    vol.Required(CONF_TITLE): cv.template,
-                    vol.Required(CONF_CONTENT): cv.template,
-                },
-                vol.Optional(CONF_SPEECH): {
-                    vol.Required(CONF_TYPE): cv.enum(SpeechType),
-                    vol.Required(CONF_TEXT): cv.template,
-                }
-            }
-        },
         CONF_FLASH_BRIEFINGS: {
             cv.string: vol.All(cv.ensure_list, [{
                 vol.Required(CONF_UID, default=str(uuid.uuid4())): cv.string,
@@ -96,40 +88,27 @@ CONFIG_SCHEMA = vol.Schema({
 }, extra=vol.ALLOW_EXTRA)
 
 
-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
     """Activate Alexa component."""
-    intents = config[DOMAIN].get(CONF_INTENTS, {})
     flash_briefings = config[DOMAIN].get(CONF_FLASH_BRIEFINGS, {})
 
-    hass.http.register_view(AlexaIntentsView(hass, intents))
+    hass.http.register_view(AlexaIntentsView)
     hass.http.register_view(AlexaFlashBriefingView(hass, flash_briefings))
 
     return True
 
 
-class AlexaIntentsView(HomeAssistantView):
+class AlexaIntentsView(http.HomeAssistantView):
     """Handle Alexa requests."""
 
     url = INTENTS_API_ENDPOINT
     name = 'api:alexa'
 
-    def __init__(self, hass, intents):
-        """Initialize Alexa view."""
-        super().__init__()
-
-        intents = copy.deepcopy(intents)
-        template.attach(hass, intents)
-
-        for name, intent in intents.items():
-            if CONF_ACTION in intent:
-                intent[CONF_ACTION] = script.Script(
-                    hass, intent[CONF_ACTION], "Alexa intent {}".format(name))
-
-        self.intents = intents
-
     @asyncio.coroutine
     def post(self, request):
         """Handle Alexa."""
+        hass = request.app['hass']
         data = yield from request.json()
 
         _LOGGER.debug('Received Alexa request: %s', data)
@@ -146,14 +125,14 @@ class AlexaIntentsView(HomeAssistantView):
         if req_type == 'SessionEndedRequest':
             return None
 
-        intent = req.get('intent')
-        response = AlexaResponse(request.app['hass'], intent)
+        alexa_intent_info = req.get('intent')
+        alexa_response = AlexaResponse(hass, alexa_intent_info)
 
         if req_type == 'LaunchRequest':
-            response.add_speech(
+            alexa_response.add_speech(
                 SpeechType.plaintext,
                 "Hello, and welcome to the future. How may I help?")
-            return self.json(response)
+            return self.json(alexa_response)
 
         if req_type != 'IntentRequest':
             _LOGGER.warning('Received unsupported request: %s', req_type)
@@ -161,38 +140,47 @@ class AlexaIntentsView(HomeAssistantView):
                 'Received unsupported request: {}'.format(req_type),
                 HTTP_BAD_REQUEST)
 
-        intent_name = intent['name']
-        config = self.intents.get(intent_name)
+        intent_name = alexa_intent_info['name']
 
-        if config is None:
+        try:
+            intent_response = yield from intent.async_handle(
+                hass, DOMAIN, intent_name,
+                {key: {'value': value} for key, value
+                 in alexa_response.variables.items()})
+        except intent.UnknownIntent as err:
             _LOGGER.warning('Received unknown intent %s', intent_name)
-            response.add_speech(
+            alexa_response.add_speech(
                 SpeechType.plaintext,
                 "This intent is not yet configured within Home Assistant.")
-            return self.json(response)
+            return self.json(alexa_response)
 
-        speech = config.get(CONF_SPEECH)
-        card = config.get(CONF_CARD)
-        action = config.get(CONF_ACTION)
+        except intent.InvalidSlotInfo as err:
+            _LOGGER.error('Received invalid slot data from Alexa: %s', err)
+            return self.json_message('Invalid slot data received',
+                                     HTTP_BAD_REQUEST)
+        except intent.IntentError:
+            _LOGGER.exception('Error handling request for %s', intent_name)
+            return self.json_message('Error handling intent', HTTP_BAD_REQUEST)
 
-        if action is not None:
-            yield from action.async_run(response.variables)
+        for intent_speech, alexa_speech in SPEECH_MAPPINGS.items():
+            if intent_speech in intent_response.speech:
+                alexa_response.add_speech(
+                    alexa_speech,
+                    intent_response.speech[intent_speech]['speech'])
+                break
 
-        # pylint: disable=unsubscriptable-object
-        if speech is not None:
-            response.add_speech(speech[CONF_TYPE], speech[CONF_TEXT])
+        if 'simple' in intent_response.card:
+            alexa_response.add_card(
+                CardType.simple, intent_response.card['simple']['title'],
+                intent_response.card['simple']['content'])
 
-        if card is not None:
-            response.add_card(card[CONF_TYPE], card[CONF_TITLE],
-                              card[CONF_CONTENT])
-
-        return self.json(response)
+        return self.json(alexa_response)
 
 
 class AlexaResponse(object):
     """Help generating the response for Alexa."""
 
-    def __init__(self, hass, intent=None):
+    def __init__(self, hass, intent_info):
         """Initialize the response."""
         self.hass = hass
         self.speech = None
@@ -201,8 +189,9 @@ class AlexaResponse(object):
         self.session_attributes = {}
         self.should_end_session = True
         self.variables = {}
-        if intent is not None and 'slots' in intent:
-            for key, value in intent['slots'].items():
+        # Intent is None if request was a LaunchRequest or SessionEndedRequest
+        if intent_info is not None:
+            for key, value in intent_info.get('slots', {}).items():
                 if 'value' in value:
                     underscored_key = key.replace('.', '_')
                     self.variables[underscored_key] = value['value']
@@ -219,8 +208,8 @@ class AlexaResponse(object):
             self.card = card
             return
 
-        card["title"] = title.async_render(self.variables)
-        card["content"] = content.async_render(self.variables)
+        card["title"] = title
+        card["content"] = content
         self.card = card
 
     def add_speech(self, speech_type, text):
@@ -229,9 +218,6 @@ class AlexaResponse(object):
 
         key = 'ssml' if speech_type == SpeechType.ssml else 'text'
 
-        if isinstance(text, template.Template):
-            text = text.async_render(self.variables)
-
         self.speech = {
             'type': speech_type.value,
             key: text
@@ -272,7 +258,7 @@ class AlexaResponse(object):
         }
 
 
-class AlexaFlashBriefingView(HomeAssistantView):
+class AlexaFlashBriefingView(http.HomeAssistantView):
     """Handle Alexa Flash Briefing skill requests."""
 
     url = FLASH_BRIEFINGS_API_ENDPOINT

homeassistant/components/amcrest.py

@@ -11,14 +11,13 @@ import aiohttp
 import voluptuous as vol
 from requests.exceptions import HTTPError, ConnectTimeout
 
-import homeassistant.loader as loader
 from homeassistant.const import (
     CONF_NAME, CONF_HOST, CONF_PORT, CONF_USERNAME, CONF_PASSWORD,
     CONF_SENSORS, CONF_SCAN_INTERVAL, HTTP_BASIC_AUTHENTICATION)
 from homeassistant.helpers import discovery
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['amcrest==1.2.0']
+REQUIREMENTS = ['amcrest==1.2.1']
 DEPENDENCIES = ['ffmpeg']
 
 _LOGGER = logging.getLogger(__name__)
@@ -92,7 +91,6 @@ def setup(hass, config):
 
     amcrest_cams = config[DOMAIN]
 
-    persistent_notification = loader.get_component('persistent_notification')
     for device in amcrest_cams:
         camera = AmcrestCamera(device.get(CONF_HOST),
                                device.get(CONF_PORT),
@@ -103,8 +101,8 @@ def setup(hass, config):
 
         except (ConnectTimeout, HTTPError) as ex:
             _LOGGER.error("Unable to connect to Amcrest camera: %s", str(ex))
-            persistent_notification.create(
-                hass, 'Error: {}<br />'
+            hass.components.persistent_notification.create(
+                'Error: {}<br />'
                 'You will need to restart hass after fixing.'
                 ''.format(ex),
                 title=NOTIFICATION_TITLE,

homeassistant/components/apiai.py

@@ -5,13 +5,12 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/apiai/
 """
 import asyncio
-import copy
 import logging
 
 import voluptuous as vol
 
 from homeassistant.const import PROJECT_NAME, HTTP_BAD_REQUEST
-from homeassistant.helpers import template, script, config_validation as cv
+from homeassistant.helpers import intent, template
 from homeassistant.components.http import HomeAssistantView
 
 _LOGGER = logging.getLogger(__name__)
@@ -29,24 +28,14 @@ DOMAIN = 'apiai'
 DEPENDENCIES = ['http']
 
 CONFIG_SCHEMA = vol.Schema({
-    DOMAIN: {
-        CONF_INTENTS: {
-            cv.string: {
-                vol.Optional(CONF_SPEECH): cv.template,
-                vol.Optional(CONF_ACTION): cv.SCRIPT_SCHEMA,
-                vol.Optional(CONF_ASYNC_ACTION,
-                             default=DEFAULT_CONF_ASYNC_ACTION): cv.boolean
-            }
-        }
-    }
+    DOMAIN: {}
 }, extra=vol.ALLOW_EXTRA)
 
 
-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
     """Activate API.AI component."""
-    intents = config[DOMAIN].get(CONF_INTENTS, {})
-
-    hass.http.register_view(ApiaiIntentsView(hass, intents))
+    hass.http.register_view(ApiaiIntentsView)
 
     return True
 
@@ -57,24 +46,10 @@ class ApiaiIntentsView(HomeAssistantView):
     url = INTENTS_API_ENDPOINT
     name = 'api:apiai'
 
-    def __init__(self, hass, intents):
-        """Initialize API.AI view."""
-        super().__init__()
-
-        self.hass = hass
-        intents = copy.deepcopy(intents)
-        template.attach(hass, intents)
-
-        for name, intent in intents.items():
-            if CONF_ACTION in intent:
-                intent[CONF_ACTION] = script.Script(
-                    hass, intent[CONF_ACTION], "Apiai intent {}".format(name))
-
-        self.intents = intents
-
     @asyncio.coroutine
     def post(self, request):
         """Handle API.AI."""
+        hass = request.app['hass']
         data = yield from request.json()
 
         _LOGGER.debug("Received api.ai request: %s", data)
@@ -91,55 +66,41 @@ class ApiaiIntentsView(HomeAssistantView):
         if action_incomplete:
             return None
 
-        # use intent to no mix HASS actions with this parameter
-        intent = req.get('action')
+        action = req.get('action')
         parameters = req.get('parameters')
-        # contexts = req.get('contexts')
-        response = ApiaiResponse(parameters)
+        apiai_response = ApiaiResponse(parameters)
 
-        # Default Welcome Intent
-        # Maybe is better to handle this in api.ai directly?
-        #
-        # if intent == 'input.welcome':
-        #     response.add_speech(
-        #     "Hello, and welcome to the future. How may I help?")
-        #     return self.json(response)
-
-        if intent == "":
+        if action == "":
             _LOGGER.warning("Received intent with empty action")
-            response.add_speech(
+            apiai_response.add_speech(
                 "You have not defined an action in your api.ai intent.")
-            return self.json(response)
+            return self.json(apiai_response)
 
-        config = self.intents.get(intent)
+        try:
+            intent_response = yield from intent.async_handle(
+                hass, DOMAIN, action,
+                {key: {'value': value} for key, value
+                 in parameters.items()})
 
-        if config is None:
-            _LOGGER.warning("Received unknown intent %s", intent)
-            response.add_speech(
-                "Intent '%s' is not yet configured within Home Assistant." %
-                intent)
-            return self.json(response)
+        except intent.UnknownIntent as err:
+            _LOGGER.warning('Received unknown intent %s', action)
+            apiai_response.add_speech(
+                "This intent is not yet configured within Home Assistant.")
+            return self.json(apiai_response)
 
-        speech = config.get(CONF_SPEECH)
-        action = config.get(CONF_ACTION)
-        async_action = config.get(CONF_ASYNC_ACTION)
+        except intent.InvalidSlotInfo as err:
+            _LOGGER.error('Received invalid slot data: %s', err)
+            return self.json_message('Invalid slot data received',
+                                     HTTP_BAD_REQUEST)
+        except intent.IntentError:
+            _LOGGER.exception('Error handling request for %s', action)
+            return self.json_message('Error handling intent', HTTP_BAD_REQUEST)
 
-        if action is not None:
-            # API.AI expects a response in less than 5s
-            if async_action:
-                # Do not wait for the action to be executed.
-                # Needed if the action will take longer than 5s to execute
-                self.hass.async_add_job(action.async_run(response.parameters))
-            else:
-                # Wait for the action to be executed so we can use results to
-                # render the answer
-                yield from action.async_run(response.parameters)
+        if 'plain' in intent_response.speech:
+            apiai_response.add_speech(
+                intent_response.speech['plain']['speech'])
 
-        # pylint: disable=unsubscriptable-object
-        if speech is not None:
-            response.add_speech(speech)
-
-        return self.json(response)
+        return self.json(apiai_response)
 
 
 class ApiaiResponse(object):

homeassistant/components/apple_tv.py

@@ -15,10 +15,9 @@ from homeassistant.config import load_yaml_config_file
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers import discovery
 from homeassistant.components.discovery import SERVICE_APPLE_TV
-from homeassistant.loader import get_component
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['pyatv==0.3.2']
+REQUIREMENTS = ['pyatv==0.3.4']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -66,27 +65,24 @@ APPLE_TV_AUTHENTICATE_SCHEMA = vol.Schema({
 
 def request_configuration(hass, config, atv, credentials):
     """Request configuration steps from the user."""
-    configurator = get_component('configurator')
+    configurator = hass.components.configurator
 
     @asyncio.coroutine
     def configuration_callback(callback_data):
         """Handle the submitted configuration."""
         from pyatv import exceptions
         pin = callback_data.get('pin')
-        notification = get_component('persistent_notification')
 
         try:
             yield from atv.airplay.finish_authentication(pin)
-            notification.async_create(
-                hass,
+            hass.components.persistent_notification.async_create(
                 'Authentication succeeded!<br /><br />Add the following '
                 'to credentials: in your apple_tv configuration:<br /><br />'
                 '{0}'.format(credentials),
                 title=NOTIFICATION_AUTH_TITLE,
                 notification_id=NOTIFICATION_AUTH_ID)
         except exceptions.DeviceAuthenticationError as ex:
-            notification.async_create(
-                hass,
+            hass.components.persistent_notification.async_create(
                 'Authentication failed! Did you enter correct PIN?<br /><br />'
                 'Details: {0}'.format(ex),
                 title=NOTIFICATION_AUTH_TITLE,
@@ -119,9 +115,7 @@ def scan_for_apple_tvs(hass):
     if not devices:
         devices = ['No device(s) found']
 
-    notification = get_component('persistent_notification')
-    notification.async_create(
-        hass,
+    hass.components.persistent_notification.async_create(
         'The following devices were found:<br /><br />' +
         '<br /><br />'.join(devices),
         title=NOTIFICATION_SCAN_TITLE,

homeassistant/components/arlo.py

@@ -9,7 +9,6 @@ import logging
 import voluptuous as vol
 from requests.exceptions import HTTPError, ConnectTimeout
 
-import homeassistant.loader as loader
 from homeassistant.helpers import config_validation as cv
 from homeassistant.const import CONF_USERNAME, CONF_PASSWORD
 
@@ -40,7 +39,6 @@ def setup(hass, config):
     username = conf.get(CONF_USERNAME)
     password = conf.get(CONF_PASSWORD)
 
-    persistent_notification = loader.get_component('persistent_notification')
     try:
         from pyarlo import PyArlo
 
@@ -50,8 +48,8 @@ def setup(hass, config):
         hass.data[DATA_ARLO] = arlo
     except (ConnectTimeout, HTTPError) as ex:
         _LOGGER.error("Unable to connect to Netgar Arlo: %s", str(ex))
-        persistent_notification.create(
-            hass, 'Error: {}<br />'
+        hass.components.persistent_notification.create(
+            'Error: {}<br />'
             'You will need to restart hass after fixing.'
             ''.format(ex),
             title=NOTIFICATION_TITLE,

homeassistant/components/automation/__init__.py

@@ -13,6 +13,7 @@ import voluptuous as vol
 
 from homeassistant.setup import async_prepare_setup_platform
 from homeassistant.core import CoreState
+from homeassistant.loader import bind_hass
 from homeassistant import config as conf_util
 from homeassistant.const import (
     ATTR_ENTITY_ID, CONF_PLATFORM, STATE_ON, SERVICE_TURN_ON, SERVICE_TURN_OFF,
@@ -105,6 +106,7 @@ TRIGGER_SERVICE_SCHEMA = vol.Schema({
 RELOAD_SERVICE_SCHEMA = vol.Schema({})
 
 
+@bind_hass
 def is_on(hass, entity_id):
     """
     Return true if specified automation entity_id is on.
@@ -114,35 +116,41 @@ def is_on(hass, entity_id):
     return hass.states.is_state(entity_id, STATE_ON)
 
 
+@bind_hass
 def turn_on(hass, entity_id=None):
     """Turn on specified automation or all."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
     hass.services.call(DOMAIN, SERVICE_TURN_ON, data)
 
 
+@bind_hass
 def turn_off(hass, entity_id=None):
     """Turn off specified automation or all."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
     hass.services.call(DOMAIN, SERVICE_TURN_OFF, data)
 
 
+@bind_hass
 def toggle(hass, entity_id=None):
     """Toggle specified automation or all."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
     hass.services.call(DOMAIN, SERVICE_TOGGLE, data)
 
 
+@bind_hass
 def trigger(hass, entity_id=None):
     """Trigger specified automation or all."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
     hass.services.call(DOMAIN, SERVICE_TRIGGER, data)
 
 
+@bind_hass
 def reload(hass):
     """Reload the automation from config."""
     hass.services.call(DOMAIN, SERVICE_RELOAD)
 
 
+@bind_hass
 def async_reload(hass):
     """Reload the automation from config.
 

homeassistant/components/automation/state.py

@@ -12,13 +12,11 @@ import homeassistant.util.dt as dt_util
 from homeassistant.const import MATCH_ALL, CONF_PLATFORM
 from homeassistant.helpers.event import (
     async_track_state_change, async_track_point_in_utc_time)
-from homeassistant.helpers.deprecation import get_deprecated
 import homeassistant.helpers.config_validation as cv
 
 CONF_ENTITY_ID = 'entity_id'
 CONF_FROM = 'from'
 CONF_TO = 'to'
-CONF_STATE = 'state'
 CONF_FOR = 'for'
 
 TRIGGER_SCHEMA = vol.All(
@@ -28,11 +26,9 @@ TRIGGER_SCHEMA = vol.All(
         # These are str on purpose. Want to catch YAML conversions
         CONF_FROM: str,
         CONF_TO: str,
-        CONF_STATE: str,
         CONF_FOR: vol.All(cv.time_period, cv.positive_timedelta),
     }),
-    vol.Any(cv.key_dependency(CONF_FOR, CONF_TO),
-            cv.key_dependency(CONF_FOR, CONF_STATE))
+    cv.key_dependency(CONF_FOR, CONF_TO),
 )
 
 
@@ -41,7 +37,7 @@ def async_trigger(hass, config, action):
     """Listen for state changes based on configuration."""
     entity_id = config.get(CONF_ENTITY_ID)
     from_state = config.get(CONF_FROM, MATCH_ALL)
-    to_state = get_deprecated(config, CONF_TO, CONF_STATE, 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

homeassistant/components/automation/time.py

@@ -10,7 +10,7 @@ import logging
 import voluptuous as vol
 
 from homeassistant.core import callback
-from homeassistant.const import CONF_AT, CONF_PLATFORM, CONF_AFTER
+from homeassistant.const import CONF_AT, CONF_PLATFORM
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.event import async_track_time_change
 
@@ -23,12 +23,10 @@ _LOGGER = logging.getLogger(__name__)
 TRIGGER_SCHEMA = vol.All(vol.Schema({
     vol.Required(CONF_PLATFORM): 'time',
     CONF_AT: cv.time,
-    CONF_AFTER: cv.time,
     CONF_HOURS: vol.Any(vol.Coerce(int), vol.Coerce(str)),
     CONF_MINUTES: vol.Any(vol.Coerce(int), vol.Coerce(str)),
     CONF_SECONDS: vol.Any(vol.Coerce(int), vol.Coerce(str)),
-}), cv.has_at_least_one_key(CONF_HOURS, CONF_MINUTES,
-                            CONF_SECONDS, CONF_AT, CONF_AFTER))
+}), cv.has_at_least_one_key(CONF_HOURS, CONF_MINUTES, CONF_SECONDS, CONF_AT))
 
 
 @asyncio.coroutine
@@ -37,11 +35,6 @@ def async_trigger(hass, config, action):
     if CONF_AT in config:
         at_time = config.get(CONF_AT)
         hours, minutes, seconds = at_time.hour, at_time.minute, at_time.second
-    elif CONF_AFTER in config:
-        _LOGGER.warning("'after' is deprecated for the time trigger. Please "
-                        "rename 'after' to 'at' in your configuration file.")
-        at_time = config.get(CONF_AFTER)
-        hours, minutes, seconds = at_time.hour, at_time.minute, at_time.second
     else:
         hours = config.get(CONF_HOURS)
         minutes = config.get(CONF_MINUTES)

homeassistant/components/axis.py

@@ -21,7 +21,6 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers import discovery
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.entity import Entity
-from homeassistant.loader import get_component
 
 
 REQUIREMENTS = ['axis==8']
@@ -79,7 +78,7 @@ SERVICE_SCHEMA = vol.Schema({
 
 def request_configuration(hass, name, host, serialnumber):
     """Request configuration steps from the user."""
-    configurator = get_component('configurator')
+    configurator = hass.components.configurator
 
     def configuration_callback(callback_data):
         """Called when config is submitted."""
@@ -242,12 +241,11 @@ def setup_device(hass, config):
     if enable_metadatastream:
         device.initialize_new_event = event_initialized
         if not device.initiate_metadatastream():
-            notification = get_component('persistent_notification')
-            notification.create(hass,
-                                'Dependency missing for sensors, '
-                                'please check documentation',
-                                title=DOMAIN,
-                                notification_id='axis_notification')
+            hass.components.persistent_notification.create(
+                'Dependency missing for sensors, '
+                'please check documentation',
+                title=DOMAIN,
+                notification_id='axis_notification')
 
     AXIS_DEVICES[device.serial_number] = device
 

homeassistant/components/binary_sensor/ping.py

@@ -35,6 +35,9 @@ SCAN_INTERVAL = timedelta(minutes=5)
 PING_MATCHER = re.compile(
     r'(?P<min>\d+.\d+)\/(?P<avg>\d+.\d+)\/(?P<max>\d+.\d+)\/(?P<mdev>\d+.\d+)')
 
+PING_MATCHER_BUSYBOX = re.compile(
+    r'(?P<min>\d+.\d+)\/(?P<avg>\d+.\d+)\/(?P<max>\d+.\d+)')
+
 WIN32_PING_MATCHER = re.compile(
     r'(?P<min>\d+)ms.+(?P<max>\d+)ms.+(?P<avg>\d+)ms')
 
@@ -126,7 +129,14 @@ class PingData(object):
                     'avg': rtt_avg,
                     'max': rtt_max,
                     'mdev': ''}
-
+            if 'max/' not in str(out):
+                match = PING_MATCHER_BUSYBOX.search(str(out).split('\n')[-1])
+                rtt_min, rtt_avg, rtt_max = match.groups()
+                return {
+                    'min': rtt_min,
+                    'avg': rtt_avg,
+                    'max': rtt_max,
+                    'mdev': ''}
             match = PING_MATCHER.search(str(out).split('\n')[-1])
             rtt_min, rtt_avg, rtt_max, rtt_mdev = match.groups()
             return {

homeassistant/components/binary_sensor/rest.py

@@ -107,6 +107,8 @@ class RestBinarySensor(BinarySensorDevice):
         if self.rest.data is None:
             return False
 
+        response = self.rest.data
+
         if self._value_template is not None:
             response = self._value_template.\
                 async_render_with_possible_json_value(self.rest.data, False)

homeassistant/components/binary_sensor/rfxtrx.py

@@ -62,6 +62,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                                     entity[CONF_COMMAND_ON],
                                     entity[CONF_COMMAND_OFF])
         device.hass = hass
+        device.is_lighting4 = (packet_id[2:4] == '13')
         sensors.append(device)
         rfxtrx.RFX_DEVICES[device_id] = device
 
@@ -94,6 +95,8 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
 
             pkt_id = "".join("{0:02x}".format(x) for x in event.data)
             sensor = RfxtrxBinarySensor(event, pkt_id)
+            sensor.hass = hass
+            sensor.is_lighting4 = (pkt_id[2:4] == '13')
             rfxtrx.RFX_DEVICES[device_id] = sensor
             add_devices_callback([sensor])
             _LOGGER.info("Added binary sensor %s "
@@ -111,12 +114,12 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                          slugify(event.device.id_string.lower()),
                          event.device.__class__.__name__,
                          event.device.subtype)
-
-        if sensor.is_pt2262:
-            cmd = rfxtrx.get_pt2262_cmd(device_id, sensor.data_bits)
-            _LOGGER.info("applying cmd %s to device_id: %s)",
-                         cmd, sensor.masked_id)
-            sensor.apply_cmd(int(cmd, 16))
+        if sensor.is_lighting4:
+            if sensor.data_bits is not None:
+                cmd = rfxtrx.get_pt2262_cmd(device_id, sensor.data_bits)
+                sensor.apply_cmd(int(cmd, 16))
+            else:
+                sensor.update_state(True)
         else:
             rfxtrx.apply_received_command(event)
 
@@ -151,6 +154,7 @@ class RfxtrxBinarySensor(BinarySensorDevice):
         self._device_class = device_class
         self._off_delay = off_delay
         self._state = False
+        self.is_lighting4 = False
         self.delay_listener = None
         self._data_bits = data_bits
         self._cmd_on = cmd_on
@@ -170,11 +174,6 @@ class RfxtrxBinarySensor(BinarySensorDevice):
         """Return the device name."""
         return self._name
 
-    @property
-    def is_pt2262(self):
-        """Return true if the device is PT2262-based."""
-        return self._data_bits is not None
-
     @property
     def masked_id(self):
         """Return the masked device id (isolated address bits)."""

homeassistant/components/binary_sensor/velbus.py

@@ -0,0 +1,96 @@
+"""
+Support for Velbus Binary Sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.velbus/
+"""
+import asyncio
+import logging
+
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_NAME, CONF_DEVICES
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.binary_sensor import PLATFORM_SCHEMA
+from homeassistant.components.velbus import DOMAIN
+import homeassistant.helpers.config_validation as cv
+
+
+DEPENDENCIES = ['velbus']
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_DEVICES): vol.All(cv.ensure_list, [
+        {
+            vol.Required('module'): cv.positive_int,
+            vol.Required('channel'): cv.positive_int,
+            vol.Required(CONF_NAME): cv.string,
+            vol.Optional('is_pushbutton'): cv.boolean
+        }
+    ])
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Velbus binary sensors."""
+    velbus = hass.data[DOMAIN]
+
+    add_devices(VelbusBinarySensor(sensor, velbus)
+                for sensor in config[CONF_DEVICES])
+
+
+class VelbusBinarySensor(BinarySensorDevice):
+    """Representation of a Velbus Binary Sensor."""
+
+    def __init__(self, binary_sensor, velbus):
+        """Initialize a Velbus light."""
+        self._velbus = velbus
+        self._name = binary_sensor[CONF_NAME]
+        self._module = binary_sensor['module']
+        self._channel = binary_sensor['channel']
+        self._is_pushbutton = 'is_pushbutton' in binary_sensor \
+                              and binary_sensor['is_pushbutton']
+        self._state = False
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Add listener for Velbus messages on bus."""
+        yield from self.hass.async_add_job(
+            self._velbus.subscribe, self._on_message)
+
+    def _on_message(self, message):
+        import velbus
+        if isinstance(message, velbus.PushButtonStatusMessage):
+            if message.address == self._module and \
+               self._channel in message.get_channels():
+                if self._is_pushbutton:
+                    if self._channel in message.closed:
+                        self._toggle()
+                    else:
+                        pass
+                else:
+                    self._toggle()
+
+    def _toggle(self):
+        if self._state is True:
+            self._state = False
+        else:
+            self._state = True
+        self.schedule_update_ha_state()
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def name(self):
+        """Return the display name of this sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if the sensor is on."""
+        return self._state

homeassistant/components/binary_sensor/xiaomi.py

@@ -0,0 +1,316 @@
+"""Support for Xiaomi binary sensors."""
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.xiaomi import (PY_XIAOMI_GATEWAY, XiaomiDevice)
+
+_LOGGER = logging.getLogger(__name__)
+
+NO_CLOSE = 'no_close'
+ATTR_OPEN_SINCE = 'Open since'
+
+MOTION = 'motion'
+NO_MOTION = 'no_motion'
+ATTR_NO_MOTION_SINCE = 'No motion since'
+
+DENSITY = 'density'
+ATTR_DENSITY = 'Density'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Perform the setup for Xiaomi devices."""
+    devices = []
+    for (_, gateway) in hass.data[PY_XIAOMI_GATEWAY].gateways.items():
+        for device in gateway.devices['binary_sensor']:
+            model = device['model']
+            if model == 'motion':
+                devices.append(XiaomiMotionSensor(device, hass, gateway))
+            elif model == 'sensor_motion.aq2':
+                devices.append(XiaomiMotionSensor(device, hass, gateway))
+            elif model == 'magnet':
+                devices.append(XiaomiDoorSensor(device, gateway))
+            elif model == 'sensor_magnet.aq2':
+                devices.append(XiaomiDoorSensor(device, gateway))
+            elif model == 'smoke':
+                devices.append(XiaomiSmokeSensor(device, gateway))
+            elif model == 'natgas':
+                devices.append(XiaomiNatgasSensor(device, gateway))
+            elif model == 'switch':
+                devices.append(XiaomiButton(device, 'Switch', 'status',
+                                            hass, gateway))
+            elif model == 'sensor_switch.aq2':
+                devices.append(XiaomiButton(device, 'Switch', 'status',
+                                            hass, gateway))
+            elif model == '86sw1':
+                devices.append(XiaomiButton(device, 'Wall Switch', 'channel_0',
+                                            hass, gateway))
+            elif model == '86sw2':
+                devices.append(XiaomiButton(device, 'Wall Switch (Left)',
+                                            'channel_0', hass, gateway))
+                devices.append(XiaomiButton(device, 'Wall Switch (Right)',
+                                            'channel_1', hass, gateway))
+                devices.append(XiaomiButton(device, 'Wall Switch (Both)',
+                                            'dual_channel', hass, gateway))
+            elif model == 'cube':
+                devices.append(XiaomiCube(device, hass, gateway))
+    add_devices(devices)
+
+
+class XiaomiBinarySensor(XiaomiDevice, BinarySensorDevice):
+    """Representation of a base XiaomiBinarySensor."""
+
+    def __init__(self, device, name, xiaomi_hub, data_key, device_class):
+        """Initialize the XiaomiSmokeSensor."""
+        self._data_key = data_key
+        self._device_class = device_class
+        self._should_poll = False
+        self._density = 0
+        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+
+    @property
+    def should_poll(self):
+        """Return True if entity has to be polled for state."""
+        return self._should_poll
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._state
+
+    @property
+    def device_class(self):
+        """Return the class of binary sensor."""
+        return self._device_class
+
+    def update(self):
+        """Update the sensor state."""
+        _LOGGER.debug('Updating xiaomi sensor by polling')
+        self._get_from_hub(self._sid)
+
+
+class XiaomiNatgasSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiNatgasSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiSmokeSensor."""
+        self._density = None
+        XiaomiBinarySensor.__init__(self, device, 'Natgas Sensor', xiaomi_hub,
+                                    'alarm', 'gas')
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_DENSITY: self._density}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        if DENSITY in data:
+            self._density = int(data.get(DENSITY))
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == '1':
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == '0':
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
+class XiaomiMotionSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiMotionSensor."""
+
+    def __init__(self, device, hass, xiaomi_hub):
+        """Initialize the XiaomiMotionSensor."""
+        self._hass = hass
+        self._no_motion_since = 0
+        XiaomiBinarySensor.__init__(self, device, 'Motion Sensor', xiaomi_hub,
+                                    'status', 'motion')
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_NO_MOTION_SINCE: self._no_motion_since}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        self._should_poll = False
+        if NO_MOTION in data:  # handle push from the hub
+            self._no_motion_since = data[NO_MOTION]
+            self._state = False
+            return True
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == MOTION:
+            self._should_poll = True
+            if self.entity_id is not None:
+                self._hass.bus.fire('motion', {
+                    'entity_id': self.entity_id
+                })
+
+            self._no_motion_since = 0
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == NO_MOTION:
+            if not self._state:
+                return False
+            self._state = False
+            return True
+
+
+class XiaomiDoorSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiDoorSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiDoorSensor."""
+        self._open_since = 0
+        XiaomiBinarySensor.__init__(self, device, 'Door Window Sensor',
+                                    xiaomi_hub, 'status', 'opening')
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_OPEN_SINCE: self._open_since}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        self._should_poll = False
+        if NO_CLOSE in data:  # handle push from the hub
+            self._open_since = data[NO_CLOSE]
+            return True
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == 'open':
+            self._should_poll = True
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == 'close':
+            self._open_since = 0
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
+class XiaomiSmokeSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiSmokeSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiSmokeSensor."""
+        self._density = 0
+        XiaomiBinarySensor.__init__(self, device, 'Smoke Sensor', xiaomi_hub,
+                                    'alarm', 'smoke')
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_DENSITY: self._density}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        if DENSITY in data:
+            self._density = int(data.get(DENSITY))
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == '1':
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == '0':
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
+class XiaomiButton(XiaomiBinarySensor):
+    """Representation of a Xiaomi Button."""
+
+    def __init__(self, device, name, data_key, hass, xiaomi_hub):
+        """Initialize the XiaomiButton."""
+        self._hass = hass
+        XiaomiBinarySensor.__init__(self, device, name, xiaomi_hub,
+                                    data_key, None)
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == 'long_click_press':
+            self._state = True
+            click_type = 'long_click_press'
+        elif value == 'long_click_release':
+            self._state = False
+            click_type = 'hold'
+        elif value == 'click':
+            click_type = 'single'
+        elif value == 'double_click':
+            click_type = 'double'
+        elif value == 'both_click':
+            click_type = 'both'
+        else:
+            return False
+
+        self._hass.bus.fire('click', {
+            'entity_id': self.entity_id,
+            'click_type': click_type
+        })
+        if value in ['long_click_press', 'long_click_release']:
+            return True
+        return False
+
+
+class XiaomiCube(XiaomiBinarySensor):
+    """Representation of a Xiaomi Cube."""
+
+    def __init__(self, device, hass, xiaomi_hub):
+        """Initialize the Xiaomi Cube."""
+        self._hass = hass
+        self._state = False
+        XiaomiBinarySensor.__init__(self, device, 'Cube', xiaomi_hub,
+                                    None, None)
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        if 'status' in data:
+            self._hass.bus.fire('cube_action', {
+                'entity_id': self.entity_id,
+                'action_type': data['status']
+            })
+
+        if 'rotate' in data:
+            self._hass.bus.fire('cube_action', {
+                'entity_id': self.entity_id,
+                'action_type': 'rotate',
+                'action_value': float(data['rotate'].replace(",", "."))
+            })
+        return False

homeassistant/components/camera/__init__.py

@@ -23,6 +23,7 @@ from homeassistant.core import callback
 from homeassistant.const import (ATTR_ENTITY_ID, ATTR_ENTITY_PICTURE)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.loader import bind_hass
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
@@ -55,6 +56,7 @@ CAMERA_SERVICE_SCHEMA = vol.Schema({
 })
 
 
+@bind_hass
 def enable_motion_detection(hass, entity_id=None):
     """Enable Motion Detection."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
@@ -62,6 +64,7 @@ def enable_motion_detection(hass, entity_id=None):
         DOMAIN, SERVICE_EN_MOTION, data))
 
 
+@bind_hass
 def disable_motion_detection(hass, entity_id=None):
     """Disable Motion Detection."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None

homeassistant/components/camera/onvif.py

@@ -6,6 +6,7 @@ https://home-assistant.io/components/camera.onvif/
 """
 import asyncio
 import logging
+import os
 
 import voluptuous as vol
 
@@ -54,6 +55,7 @@ class ONVIFCamera(Camera):
     def __init__(self, hass, config):
         """Initialize a ONVIF camera."""
         from onvif import ONVIFService
+        import onvif
         super().__init__()
 
         self._name = config.get(CONF_NAME)
@@ -63,7 +65,7 @@ class ONVIFCamera(Camera):
                 config.get(CONF_HOST), config.get(CONF_PORT)),
             config.get(CONF_USERNAME),
             config.get(CONF_PASSWORD),
-            '{}/deps/onvif/wsdl/media.wsdl'.format(hass.config.config_dir)
+            '{}/wsdl/media.wsdl'.format(os.path.dirname(onvif.__file__))
         )
         self._input = media.GetStreamUri().Uri
         _LOGGER.debug("ONVIF Camera Using the following URL for %s: %s",

homeassistant/components/climate/__init__.py

@@ -14,6 +14,7 @@ from numbers import Number
 import voluptuous as vol
 
 from homeassistant.config import load_yaml_config_file
+from homeassistant.loader import bind_hass
 from homeassistant.util.temperature import convert as convert_temperature
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
@@ -114,6 +115,7 @@ SET_SWING_MODE_SCHEMA = vol.Schema({
 })
 
 
+@bind_hass
 def set_away_mode(hass, away_mode, entity_id=None):
     """Turn all or specified climate devices away mode on."""
     data = {
@@ -126,6 +128,7 @@ def set_away_mode(hass, away_mode, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_AWAY_MODE, data)
 
 
+@bind_hass
 def set_hold_mode(hass, hold_mode, entity_id=None):
     """Set new hold mode."""
     data = {
@@ -138,6 +141,7 @@ def set_hold_mode(hass, hold_mode, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_HOLD_MODE, data)
 
 
+@bind_hass
 def set_aux_heat(hass, aux_heat, entity_id=None):
     """Turn all or specified climate devices auxillary heater on."""
     data = {
@@ -150,6 +154,7 @@ def set_aux_heat(hass, aux_heat, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_AUX_HEAT, data)
 
 
+@bind_hass
 def set_temperature(hass, temperature=None, entity_id=None,
                     target_temp_high=None, target_temp_low=None,
                     operation_mode=None):
@@ -167,6 +172,7 @@ def set_temperature(hass, temperature=None, entity_id=None,
     hass.services.call(DOMAIN, SERVICE_SET_TEMPERATURE, kwargs)
 
 
+@bind_hass
 def set_humidity(hass, humidity, entity_id=None):
     """Set new target humidity."""
     data = {ATTR_HUMIDITY: humidity}
@@ -177,6 +183,7 @@ def set_humidity(hass, humidity, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_HUMIDITY, data)
 
 
+@bind_hass
 def set_fan_mode(hass, fan, entity_id=None):
     """Set all or specified climate devices fan mode on."""
     data = {ATTR_FAN_MODE: fan}
@@ -187,6 +194,7 @@ def set_fan_mode(hass, fan, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_FAN_MODE, data)
 
 
+@bind_hass
 def set_operation_mode(hass, operation_mode, entity_id=None):
     """Set new target operation mode."""
     data = {ATTR_OPERATION_MODE: operation_mode}
@@ -197,6 +205,7 @@ def set_operation_mode(hass, operation_mode, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_OPERATION_MODE, data)
 
 
+@bind_hass
 def set_swing_mode(hass, swing_mode, entity_id=None):
     """Set new target swing mode."""
     data = {ATTR_SWING_MODE: swing_mode}

homeassistant/components/climate/maxcube.py

@@ -10,7 +10,6 @@ import logging
 from homeassistant.components.climate import ClimateDevice, STATE_AUTO
 from homeassistant.components.maxcube import MAXCUBE_HANDLE
 from homeassistant.const import TEMP_CELSIUS, ATTR_TEMPERATURE
-from homeassistant.const import STATE_UNKNOWN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -140,7 +139,7 @@ class MaxCubeClimate(ClimateDevice):
     def map_temperature_max_hass(temperature):
         """Map Temperature from MAX! to HASS."""
         if temperature is None:
-            return STATE_UNKNOWN
+            return 0.0
 
         return temperature
 

homeassistant/components/climate/tado.py

@@ -273,31 +273,38 @@ class TadoClimate(ClimateDevice):
             else:
                 self._device_is_active = True
 
+        overlay = False
+        overlay_data = None
+        termination = self._current_operation
+        cooling = False
+        fan_speed = CONST_MODE_OFF
+
+        if 'overlay' in data:
+            overlay_data = data['overlay']
+            overlay = overlay_data is not None
+
+        if overlay:
+            termination = overlay_data['termination']['type']
+
+            if 'setting' in overlay_data:
+                setting_data = overlay_data['setting']
+                setting = setting is not None
+
+            if setting:
+                if 'mode' in setting_data:
+                    cooling = setting_data['mode'] == 'COOL'
+
+                if 'fanSpeed' in setting_data:
+                    fan_speed = setting_data['fanSpeed']
+
         if self._device_is_active:
-            overlay = False
-            overlay_data = None
-            termination = self._current_operation
-            cooling = False
-            fan_speed = CONST_MODE_OFF
-
-            if 'overlay' in data:
-                overlay_data = data['overlay']
-                overlay = overlay_data is not None
-
-            if overlay:
-                termination = overlay_data['termination']['type']
-
-                if 'setting' in overlay_data:
-                    cooling = overlay_data['setting']['mode'] == 'COOL'
-                    fan_speed = overlay_data['setting']['fanSpeed']
-
             # If you set mode manualy to off, there will be an overlay
             # and a termination, but we want to see the mode "OFF"
-
             self._overlay_mode = termination
             self._current_operation = termination
-            self._cooling = cooling
-            self._current_fan = fan_speed
+
+        self._cooling = cooling
+        self._current_fan = fan_speed
 
     def _control_heating(self):
         """Send new target temperature to mytado."""

homeassistant/components/configurator.py

@@ -12,6 +12,7 @@ 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.util.async import run_callback_threadsafe
 
@@ -37,6 +38,7 @@ STATE_CONFIGURE = 'configure'
 STATE_CONFIGURED = 'configured'
 
 
+@bind_hass
 def request_config(
         hass, name, callback, description=None, description_image=None,
         submit_caption=None, fields=None, link_name=None, link_url=None,

homeassistant/components/conversation.py

@@ -4,6 +4,7 @@ Support for functionality to have conversations with Home Assistant.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/conversation/
 """
+import asyncio
 import logging
 import re
 import warnings
@@ -11,16 +12,17 @@ import warnings
 import voluptuous as vol
 
 from homeassistant import core
+from homeassistant.loader import bind_hass
 from homeassistant.const import (
-    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON)
-import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers import script
+    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON, HTTP_BAD_REQUEST)
+from homeassistant.helpers import intent, config_validation as cv
+from homeassistant.components import http
 
 
-REQUIREMENTS = ['fuzzywuzzy==0.15.0']
+REQUIREMENTS = ['fuzzywuzzy==0.15.1']
+DEPENDENCIES = ['http']
 
 ATTR_TEXT = 'text'
-ATTR_SENTENCE = 'sentence'
 DOMAIN = 'conversation'
 
 REGEX_TURN_COMMAND = re.compile(r'turn (?P<name>(?: |\w)+) (?P<command>\w+)')
@@ -28,79 +30,174 @@ REGEX_TURN_COMMAND = re.compile(r'turn (?P<name>(?: |\w)+) (?P<command>\w+)')
 SERVICE_PROCESS = 'process'
 
 SERVICE_PROCESS_SCHEMA = vol.Schema({
-    vol.Required(ATTR_TEXT): vol.All(cv.string, vol.Lower),
+    vol.Required(ATTR_TEXT): cv.string,
 })
 
 CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.Schema({
-    cv.string: vol.Schema({
-        vol.Required(ATTR_SENTENCE): cv.string,
-        vol.Required('action'): cv.SCRIPT_SCHEMA,
+    vol.Optional('intents'): vol.Schema({
+        cv.string: vol.All(cv.ensure_list, [cv.string])
     })
 })}, extra=vol.ALLOW_EXTRA)
 
+_LOGGER = logging.getLogger(__name__)
 
-def setup(hass, config):
+
+@core.callback
+@bind_hass
+def async_register(hass, intent_type, utterances):
+    """Register an intent.
+
+    Registrations don't require conversations to be loaded. They will become
+    active once the conversation component is loaded.
+    """
+    intents = hass.data.get(DOMAIN)
+
+    if intents is None:
+        intents = hass.data[DOMAIN] = {}
+
+    conf = intents.get(intent_type)
+
+    if conf is None:
+        conf = intents[intent_type] = []
+
+    conf.extend(_create_matcher(utterance) for utterance in utterances)
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
     """Register the process service."""
     warnings.filterwarnings('ignore', module='fuzzywuzzy')
-    from fuzzywuzzy import process as fuzzyExtract
 
-    logger = logging.getLogger(__name__)
     config = config.get(DOMAIN, {})
+    intents = hass.data.get(DOMAIN)
 
-    choices = {attrs[ATTR_SENTENCE]: script.Script(
-        hass,
-        attrs['action'],
-        name)
-               for name, attrs in config.items()}
+    if intents is None:
+        intents = hass.data[DOMAIN] = {}
 
+    for intent_type, utterances in config.get('intents', {}).items():
+        conf = intents.get(intent_type)
+
+        if conf is None:
+            conf = intents[intent_type] = []
+
+        conf.extend(_create_matcher(utterance) for utterance in utterances)
+
+    @asyncio.coroutine
     def process(service):
         """Parse text into commands."""
-        # if actually configured
-        if choices:
-            text = service.data[ATTR_TEXT]
-            match = fuzzyExtract.extractOne(text, choices.keys())
-            scorelimit = 60  # arbitrary value
-            logging.info(
-                'matched up text %s and found %s',
-                text,
-                [match[0] if match[1] > scorelimit else 'nothing']
-                )
-            if match[1] > scorelimit:
-                choices[match[0]].run()  # run respective script
-                return
-
         text = service.data[ATTR_TEXT]
-        match = REGEX_TURN_COMMAND.match(text)
+        yield from _process(hass, text)
 
-        if not match:
-            logger.error("Unable to process: %s", text)
-            return
-
-        name, command = match.groups()
-        entities = {state.entity_id: state.name for state in hass.states.all()}
-        entity_ids = fuzzyExtract.extractOne(
-            name, entities, score_cutoff=65)[2]
-
-        if not entity_ids:
-            logger.error(
-                "Could not find entity id %s from text %s", name, text)
-            return
-
-        if command == 'on':
-            hass.services.call(core.DOMAIN, SERVICE_TURN_ON, {
-                ATTR_ENTITY_ID: entity_ids,
-            }, blocking=True)
-
-        elif command == 'off':
-            hass.services.call(core.DOMAIN, SERVICE_TURN_OFF, {
-                ATTR_ENTITY_ID: entity_ids,
-            }, blocking=True)
-
-        else:
-            logger.error('Got unsupported command %s from text %s',
-                         command, text)
-
-    hass.services.register(
+    hass.services.async_register(
         DOMAIN, SERVICE_PROCESS, process, schema=SERVICE_PROCESS_SCHEMA)
 
+    hass.http.register_view(ConversationProcessView)
+
     return True
+
+
+def _create_matcher(utterance):
+    """Create a regex that matches the utterance."""
+    parts = re.split(r'({\w+})', utterance)
+    group_matcher = re.compile(r'{(\w+)}')
+
+    pattern = ['^']
+
+    for part in parts:
+        match = group_matcher.match(part)
+
+        if match is None:
+            pattern.append(part)
+            continue
+
+        pattern.append('(?P<{}>{})'.format(match.groups()[0], r'[\w ]+'))
+
+    pattern.append('$')
+    return re.compile(''.join(pattern), re.I)
+
+
+@asyncio.coroutine
+def _process(hass, text):
+    """Process a line of text."""
+    intents = hass.data.get(DOMAIN, {})
+
+    for intent_type, matchers in intents.items():
+        for matcher in matchers:
+            match = matcher.match(text)
+
+            if not match:
+                continue
+
+            response = yield from intent.async_handle(
+                hass, DOMAIN, intent_type,
+                {key: {'value': value} for key, value
+                 in match.groupdict().items()}, text)
+            return response
+
+    from fuzzywuzzy import process as fuzzyExtract
+    text = text.lower()
+    match = REGEX_TURN_COMMAND.match(text)
+
+    if not match:
+        _LOGGER.error("Unable to process: %s", text)
+        return None
+
+    name, command = match.groups()
+    entities = {state.entity_id: state.name for state
+                in hass.states.async_all()}
+    entity_ids = fuzzyExtract.extractOne(
+        name, entities, score_cutoff=65)[2]
+
+    if not entity_ids:
+        _LOGGER.error(
+            "Could not find entity id %s from text %s", name, text)
+        return None
+
+    if command == 'on':
+        yield from hass.services.async_call(
+            core.DOMAIN, SERVICE_TURN_ON, {
+                ATTR_ENTITY_ID: entity_ids,
+            }, blocking=True)
+
+    elif command == 'off':
+        yield from hass.services.async_call(
+            core.DOMAIN, SERVICE_TURN_OFF, {
+                ATTR_ENTITY_ID: entity_ids,
+            }, blocking=True)
+
+    else:
+        _LOGGER.error('Got unsupported command %s from text %s',
+                      command, text)
+
+    return None
+
+
+class ConversationProcessView(http.HomeAssistantView):
+    """View to retrieve shopping list content."""
+
+    url = '/api/conversation/process'
+    name = "api:conversation:process"
+
+    @asyncio.coroutine
+    def post(self, request):
+        """Send a request for processing."""
+        hass = request.app['hass']
+        try:
+            data = yield from request.json()
+        except ValueError:
+            return self.json_message('Invalid JSON specified',
+                                     HTTP_BAD_REQUEST)
+
+        text = data.get('text')
+
+        if text is None:
+            return self.json_message('Missing "text" key in JSON.',
+                                     HTTP_BAD_REQUEST)
+
+        intent_result = yield from _process(hass, text)
+
+        if intent_result is None:
+            intent_result = intent.IntentResponse()
+            intent_result.async_set_speech("Sorry, I didn't understand that")
+
+        return self.json(intent_result)

homeassistant/components/cover/__init__.py

@@ -13,6 +13,7 @@ import os
 import voluptuous as vol
 
 from homeassistant.config import load_yaml_config_file
+from homeassistant.loader import bind_hass
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
@@ -22,7 +23,7 @@ from homeassistant.const import (
     SERVICE_OPEN_COVER, SERVICE_CLOSE_COVER, SERVICE_SET_COVER_POSITION,
     SERVICE_STOP_COVER, SERVICE_OPEN_COVER_TILT, SERVICE_CLOSE_COVER_TILT,
     SERVICE_STOP_COVER_TILT, SERVICE_SET_COVER_TILT_POSITION, STATE_OPEN,
-    STATE_CLOSED, STATE_UNKNOWN, ATTR_ENTITY_ID)
+    STATE_CLOSED, STATE_UNKNOWN, STATE_OPENING, STATE_CLOSING, ATTR_ENTITY_ID)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -86,24 +87,28 @@ SERVICE_TO_METHOD = {
 }
 
 
+@bind_hass
 def is_closed(hass, entity_id=None):
     """Return if the cover is closed based on the statemachine."""
     entity_id = entity_id or ENTITY_ID_ALL_COVERS
     return hass.states.is_state(entity_id, STATE_CLOSED)
 
 
+@bind_hass
 def open_cover(hass, entity_id=None):
     """Open all or specified cover."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
     hass.services.call(DOMAIN, SERVICE_OPEN_COVER, data)
 
 
+@bind_hass
 def close_cover(hass, entity_id=None):
     """Close all or specified cover."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
     hass.services.call(DOMAIN, SERVICE_CLOSE_COVER, data)
 
 
+@bind_hass
 def set_cover_position(hass, position, entity_id=None):
     """Move to specific position all or specified cover."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
@@ -111,24 +116,28 @@ def set_cover_position(hass, position, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_COVER_POSITION, data)
 
 
+@bind_hass
 def stop_cover(hass, entity_id=None):
     """Stop all or specified cover."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
     hass.services.call(DOMAIN, SERVICE_STOP_COVER, data)
 
 
+@bind_hass
 def open_cover_tilt(hass, entity_id=None):
     """Open all or specified cover tilt."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
     hass.services.call(DOMAIN, SERVICE_OPEN_COVER_TILT, data)
 
 
+@bind_hass
 def close_cover_tilt(hass, entity_id=None):
     """Close all or specified cover tilt."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
     hass.services.call(DOMAIN, SERVICE_CLOSE_COVER_TILT, data)
 
 
+@bind_hass
 def set_cover_tilt_position(hass, tilt_position, entity_id=None):
     """Move to specific tilt position all or specified cover."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
@@ -136,6 +145,7 @@ def set_cover_tilt_position(hass, tilt_position, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_COVER_TILT_POSITION, data)
 
 
+@bind_hass
 def stop_cover_tilt(hass, entity_id=None):
     """Stop all or specified cover tilt."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
@@ -215,6 +225,11 @@ class CoverDevice(Entity):
     @property
     def state(self):
         """Return the state of the cover."""
+        if self.is_opening:
+            return STATE_OPENING
+        if self.is_closing:
+            return STATE_CLOSING
+
         closed = self.is_closed
 
         if closed is None:
@@ -252,6 +267,16 @@ class CoverDevice(Entity):
 
         return supported_features
 
+    @property
+    def is_opening(self):
+        """Return if the cover is opening or not."""
+        pass
+
+    @property
+    def is_closing(self):
+        """Return if the cover is closing or not."""
+        pass
+
     @property
     def is_closed(self):
         """Return if the cover is closed or not."""

homeassistant/components/cover/demo.py

@@ -35,10 +35,12 @@ class DemoCover(CoverDevice):
         self._set_position = None
         self._set_tilt_position = None
         self._tilt_position = tilt_position
-        self._closing = True
-        self._closing_tilt = True
+        self._requested_closing = True
+        self._requested_closing_tilt = True
         self._unsub_listener_cover = None
         self._unsub_listener_cover_tilt = None
+        self._is_opening = False
+        self._is_closing = False
         if position is None:
             self._closed = True
         else:
@@ -69,6 +71,16 @@ class DemoCover(CoverDevice):
         """Return if the cover is closed."""
         return self._closed
 
+    @property
+    def is_closing(self):
+        """Return if the cover is closing."""
+        return self._is_closing
+
+    @property
+    def is_opening(self):
+        """Return if the cover is opening."""
+        return self._is_opening
+
     @property
     def device_class(self):
         """Return the class of this device, from component DEVICE_CLASSES."""
@@ -90,8 +102,10 @@ class DemoCover(CoverDevice):
             self.schedule_update_ha_state()
             return
 
+        self._is_closing = True
         self._listen_cover()
-        self._closing = True
+        self._requested_closing = True
+        self.schedule_update_ha_state()
 
     def close_cover_tilt(self, **kwargs):
         """Close the cover tilt."""
@@ -99,7 +113,7 @@ class DemoCover(CoverDevice):
             return
 
         self._listen_cover_tilt()
-        self._closing_tilt = True
+        self._requested_closing_tilt = True
 
     def open_cover(self, **kwargs):
         """Open the cover."""
@@ -110,8 +124,10 @@ class DemoCover(CoverDevice):
             self.schedule_update_ha_state()
             return
 
+        self._is_opening = True
         self._listen_cover()
-        self._closing = False
+        self._requested_closing = False
+        self.schedule_update_ha_state()
 
     def open_cover_tilt(self, **kwargs):
         """Open the cover tilt."""
@@ -119,7 +135,7 @@ class DemoCover(CoverDevice):
             return
 
         self._listen_cover_tilt()
-        self._closing_tilt = False
+        self._requested_closing_tilt = False
 
     def set_cover_position(self, position, **kwargs):
         """Move the cover to a specific position."""
@@ -128,7 +144,7 @@ class DemoCover(CoverDevice):
             return
 
         self._listen_cover()
-        self._closing = position < self._position
+        self._requested_closing = position < self._position
 
     def set_cover_tilt_position(self, tilt_position, **kwargs):
         """Move the cover til to a specific position."""
@@ -137,10 +153,12 @@ class DemoCover(CoverDevice):
             return
 
         self._listen_cover_tilt()
-        self._closing_tilt = tilt_position < self._tilt_position
+        self._requested_closing_tilt = tilt_position < self._tilt_position
 
     def stop_cover(self, **kwargs):
         """Stop the cover."""
+        self._is_closing = False
+        self._is_opening = False
         if self._position is None:
             return
         if self._unsub_listener_cover is not None:
@@ -166,7 +184,7 @@ class DemoCover(CoverDevice):
 
     def _time_changed_cover(self, now):
         """Track time changes."""
-        if self._closing:
+        if self._requested_closing:
             self._position -= 10
         else:
             self._position += 10
@@ -186,7 +204,7 @@ class DemoCover(CoverDevice):
 
     def _time_changed_cover_tilt(self, now):
         """Track time changes."""
-        if self._closing_tilt:
+        if self._requested_closing_tilt:
             self._tilt_position -= 10
         else:
             self._tilt_position += 10

homeassistant/components/cover/lutron_caseta.py

@@ -23,7 +23,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Lutron Caseta Serena shades as a cover device."""
     devs = []
     bridge = hass.data[LUTRON_CASETA_SMARTBRIDGE]
-    cover_devices = bridge.get_devices_by_types(["SerenaRollerShade"])
+    cover_devices = bridge.get_devices_by_types(["SerenaRollerShade",
+                                                 "SerenaHoneycombShade"])
     for cover_device in cover_devices:
         dev = LutronCasetaCover(cover_device, bridge)
         devs.append(dev)

homeassistant/components/cover/myq.py

@@ -12,7 +12,6 @@ from homeassistant.components.cover import CoverDevice
 from homeassistant.const import (
     CONF_USERNAME, CONF_PASSWORD, CONF_TYPE, STATE_CLOSED)
 import homeassistant.helpers.config_validation as cv
-import homeassistant.loader as loader
 
 REQUIREMENTS = ['pymyq==0.0.8']
 
@@ -37,7 +36,6 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     username = config.get(CONF_USERNAME)
     password = config.get(CONF_PASSWORD)
     brand = config.get(CONF_TYPE)
-    persistent_notification = loader.get_component('persistent_notification')
     myq = pymyq(username, password, brand)
 
     try:
@@ -52,8 +50,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     except (TypeError, KeyError, NameError, ValueError) as ex:
         _LOGGER.error("%s", ex)
-        persistent_notification.create(
-            hass, 'Error: {}<br />'
+        hass.components.persistent_notification.create(
+            'Error: {}<br />'
             'You will need to restart hass after fixing.'
             ''.format(ex),
             title=NOTIFICATION_TITLE,

homeassistant/components/cover/velbus.py

@@ -0,0 +1,160 @@
+"""
+Support for Velbus covers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/cover.velbus/
+"""
+import logging
+import asyncio
+import time
+
+import voluptuous as vol
+
+from homeassistant.components.cover import (
+    CoverDevice, PLATFORM_SCHEMA, SUPPORT_OPEN, SUPPORT_CLOSE,
+    SUPPORT_STOP)
+from homeassistant.components.velbus import DOMAIN
+from homeassistant.const import (CONF_COVERS, CONF_NAME)
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+COVER_SCHEMA = vol.Schema({
+    vol.Required('module'): cv.positive_int,
+    vol.Required('open_channel'): cv.positive_int,
+    vol.Required('close_channel'): cv.positive_int,
+    vol.Required(CONF_NAME): cv.string
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_COVERS): vol.Schema({cv.slug: COVER_SCHEMA}),
+})
+
+DEPENDENCIES = ['velbus']
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up cover controlled by Velbus."""
+    devices = config.get(CONF_COVERS, {})
+    covers = []
+
+    velbus = hass.data[DOMAIN]
+    for device_name, device_config in devices.items():
+        covers.append(
+            VelbusCover(
+                velbus,
+                device_config.get(CONF_NAME, device_name),
+                device_config.get('module'),
+                device_config.get('open_channel'),
+                device_config.get('close_channel')
+            )
+        )
+
+    if not covers:
+        _LOGGER.error("No covers added")
+        return False
+
+    add_devices(covers)
+
+
+class VelbusCover(CoverDevice):
+    """Representation a Velbus cover."""
+
+    def __init__(self, velbus, name, module, open_channel, close_channel):
+        """Initialize the cover."""
+        self._velbus = velbus
+        self._name = name
+        self._close_channel_state = None
+        self._open_channel_state = None
+        self._module = module
+        self._open_channel = open_channel
+        self._close_channel = close_channel
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Add listener for Velbus messages on bus."""
+        def _init_velbus():
+            """Initialize Velbus on startup."""
+            self._velbus.subscribe(self._on_message)
+            self.get_status()
+
+        yield from self.hass.async_add_job(_init_velbus)
+
+    def _on_message(self, message):
+        import velbus
+        if isinstance(message, velbus.RelayStatusMessage):
+            if message.address == self._module:
+                if message.channel == self._close_channel:
+                    self._close_channel_state = message.is_on()
+                    self.schedule_update_ha_state()
+                if message.channel == self._open_channel:
+                    self._open_channel_state = message.is_on()
+                    self.schedule_update_ha_state()
+
+    @property
+    def supported_features(self):
+        """Flag supported features."""
+        return SUPPORT_OPEN | SUPPORT_CLOSE | SUPPORT_STOP
+
+    @property
+    def should_poll(self):
+        """Disable polling."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the cover."""
+        return self._name
+
+    @property
+    def is_closed(self):
+        """Return if the cover is closed."""
+        return self._close_channel_state
+
+    @property
+    def current_cover_position(self):
+        """Return current position of cover.
+
+        None is unknown.
+        """
+        return None
+
+    def _relay_off(self, channel):
+        import velbus
+        message = velbus.SwitchRelayOffMessage()
+        message.set_defaults(self._module)
+        message.relay_channels = [channel]
+        self._velbus.send(message)
+
+    def _relay_on(self, channel):
+        import velbus
+        message = velbus.SwitchRelayOnMessage()
+        message.set_defaults(self._module)
+        message.relay_channels = [channel]
+        self._velbus.send(message)
+
+    def open_cover(self, **kwargs):
+        """Open the cover."""
+        self._relay_off(self._close_channel)
+        time.sleep(0.3)
+        self._relay_on(self._open_channel)
+
+    def close_cover(self, **kwargs):
+        """Close the cover."""
+        self._relay_off(self._open_channel)
+        time.sleep(0.3)
+        self._relay_on(self._close_channel)
+
+    def stop_cover(self, **kwargs):
+        """Stop the cover."""
+        self._relay_off(self._open_channel)
+        time.sleep(0.3)
+        self._relay_off(self._close_channel)
+
+    def get_status(self):
+        """Retrieve current status."""
+        import velbus
+        message = velbus.ModuleStatusRequestMessage()
+        message.set_defaults(self._module)
+        message.channels = [self._open_channel, self._close_channel]
+        self._velbus.send(message)

homeassistant/components/cover/xiaomi.py

@@ -0,0 +1,66 @@
+"""Support for Xiaomi curtain."""
+import logging
+
+from homeassistant.components.cover import CoverDevice
+from homeassistant.components.xiaomi import (PY_XIAOMI_GATEWAY, XiaomiDevice)
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_CURTAIN_LEVEL = 'curtain_level'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Perform the setup for Xiaomi devices."""
+    devices = []
+    for (_, gateway) in hass.data[PY_XIAOMI_GATEWAY].gateways.items():
+        for device in gateway.devices['cover']:
+            model = device['model']
+            if model == 'curtain':
+                devices.append(XiaomiGenericCover(device, "Curtain",
+                                                  {'status': 'status',
+                                                   'pos': 'curtain_level'},
+                                                  gateway))
+    add_devices(devices)
+
+
+class XiaomiGenericCover(XiaomiDevice, CoverDevice):
+    """Representation of a XiaomiPlug."""
+
+    def __init__(self, device, name, data_key, xiaomi_hub):
+        """Initialize the XiaomiPlug."""
+        self._data_key = data_key
+        self._pos = 0
+        XiaomiDevice.__init__(self, device, name, xiaomi_hub)
+
+    @property
+    def current_cover_position(self):
+        """Return the current position of the cover."""
+        return self._pos
+
+    @property
+    def is_closed(self):
+        """Return if the cover is closed."""
+        return self.current_cover_position < 0
+
+    def close_cover(self, **kwargs):
+        """Close the cover."""
+        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')
+
+    def stop_cover(self, **kwargs):
+        """Stop the cover."""
+        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))
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        if ATTR_CURTAIN_LEVEL in data:
+            self._pos = int(data[ATTR_CURTAIN_LEVEL])
+            return True
+        return False

homeassistant/components/cover/zwave.py

@@ -27,10 +27,12 @@ def get_device(hass, values, node_config, **kwargs):
             zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL
             and values.primary.index == 0):
         return ZwaveRollershutter(hass, values, invert_buttons)
-    elif (values.primary.command_class in [
-            zwave.const.COMMAND_CLASS_SWITCH_BINARY,
-            zwave.const.COMMAND_CLASS_BARRIER_OPERATOR]):
-        return ZwaveGarageDoor(values)
+    elif (values.primary.command_class ==
+          zwave.const.COMMAND_CLASS_SWITCH_BINARY):
+        return ZwaveGarageDoorSwitch(values)
+    elif (values.primary.command_class ==
+          zwave.const.COMMAND_CLASS_BARRIER_OPERATOR):
+        return ZwaveGarageDoorBarrier(values)
     return None
 
 
@@ -104,17 +106,33 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
         self._network.manager.releaseButton(self._open_id)
 
 
-class ZwaveGarageDoor(zwave.ZWaveDeviceEntity, CoverDevice):
-    """Representation of an Zwave garage door device."""
+class ZwaveGarageDoorBase(zwave.ZWaveDeviceEntity, CoverDevice):
+    """Base class for a Zwave garage door device."""
 
     def __init__(self, values):
         """Initialize the zwave garage door."""
         ZWaveDeviceEntity.__init__(self, values, DOMAIN)
+        self._state = None
         self.update_properties()
 
     def update_properties(self):
         """Handle data changes for node values."""
         self._state = self.values.primary.data
+        _LOGGER.debug("self._state=%s", self._state)
+
+    @property
+    def device_class(self):
+        """Return the class of this device, from component DEVICE_CLASSES."""
+        return 'garage'
+
+    @property
+    def supported_features(self):
+        """Flag supported features."""
+        return SUPPORT_GARAGE
+
+
+class ZwaveGarageDoorSwitch(ZwaveGarageDoorBase):
+    """Representation of a switch based Zwave garage door device."""
 
     @property
     def is_closed(self):
@@ -129,12 +147,29 @@ class ZwaveGarageDoor(zwave.ZWaveDeviceEntity, CoverDevice):
         """Open the garage door."""
         self.values.primary.data = True
 
-    @property
-    def device_class(self):
-        """Return the class of this device, from component DEVICE_CLASSES."""
-        return 'garage'
+
+class ZwaveGarageDoorBarrier(ZwaveGarageDoorBase):
+    """Representation of a barrier operator Zwave garage door device."""
 
     @property
-    def supported_features(self):
-        """Flag supported features."""
-        return SUPPORT_GARAGE
+    def is_opening(self):
+        """Return true if cover is in an opening state."""
+        return self._state == "Opening"
+
+    @property
+    def is_closing(self):
+        """Return true if cover is in an closing state."""
+        return self._state == "Closing"
+
+    @property
+    def is_closed(self):
+        """Return the current position of Zwave garage door."""
+        return self._state == "Closed"
+
+    def close_cover(self):
+        """Close the garage door."""
+        self.values.primary.data = "Closed"
+
+    def open_cover(self):
+        """Open the garage door."""
+        self.values.primary.data = "Opened"

homeassistant/components/demo.py

@@ -9,7 +9,6 @@ import time
 
 import homeassistant.bootstrap as bootstrap
 import homeassistant.core as ha
-import homeassistant.loader as loader
 from homeassistant.const import ATTR_ENTITY_ID, CONF_PLATFORM
 
 DEPENDENCIES = ['conversation', 'introduction', 'zone']
@@ -38,9 +37,9 @@ COMPONENTS_WITH_DEMO_PLATFORM = [
 @asyncio.coroutine
 def async_setup(hass, config):
     """Set up the demo environment."""
-    group = loader.get_component('group')
-    configurator = loader.get_component('configurator')
-    persistent_notification = loader.get_component('persistent_notification')
+    group = hass.components.group
+    configurator = hass.components.configurator
+    persistent_notification = hass.components.persistent_notification
 
     config.setdefault(ha.DOMAIN, {})
     config.setdefault(DOMAIN, {})
@@ -108,7 +107,7 @@ def async_setup(hass, config):
 
     # Set up example persistent notification
     persistent_notification.async_create(
-        hass, 'This is an example of a persistent notification.',
+        'This is an example of a persistent notification.',
         title='Example Notification')
 
     # Set up room groups
@@ -206,7 +205,7 @@ def async_setup(hass, config):
     def setup_configurator():
         """Set up a configurator."""
         request_id = 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."),
             description_image="/static/images/config_philips_hue.jpg",

homeassistant/components/device_tracker/__init__.py

@@ -16,6 +16,7 @@ import voluptuous as vol
 
 from homeassistant.setup import async_prepare_setup_platform
 from homeassistant.core import callback
+from homeassistant.loader import bind_hass
 from homeassistant.components import group, zone
 from homeassistant.components.discovery import SERVICE_NETGEAR
 from homeassistant.config import load_yaml_config_file, async_log_exception
@@ -93,6 +94,7 @@ DISCOVERY_PLATFORMS = {
 }
 
 
+@bind_hass
 def is_on(hass: HomeAssistantType, entity_id: str=None):
     """Return the state if any or a specified device is home."""
     entity = entity_id or ENTITY_ID_ALL_DEVICES

homeassistant/components/device_tracker/actiontec.py

@@ -7,9 +7,7 @@ https://home-assistant.io/components/device_tracker.actiontec/
 import logging
 import re
 import telnetlib
-import threading
 from collections import namedtuple
-from datetime import timedelta
 import voluptuous as vol
 
 import homeassistant.helpers.config_validation as cv
@@ -17,9 +15,6 @@ import homeassistant.util.dt as dt_util
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
-
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -54,7 +49,6 @@ class ActiontecDeviceScanner(DeviceScanner):
         self.host = config[CONF_HOST]
         self.username = config[CONF_USERNAME]
         self.password = config[CONF_PASSWORD]
-        self.lock = threading.Lock()
         self.last_results = []
         data = self.get_actiontec_data()
         self.success_init = data is not None
@@ -74,7 +68,6 @@ class ActiontecDeviceScanner(DeviceScanner):
                 return client.ip
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the router is up to date.
 
@@ -84,16 +77,15 @@ class ActiontecDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            now = dt_util.now()
-            actiontec_data = self.get_actiontec_data()
-            if not actiontec_data:
-                return False
-            self.last_results = [Device(data['mac'], name, now)
-                                 for name, data in actiontec_data.items()
-                                 if data['timevalid'] > -60]
-            _LOGGER.info("Scan successful")
-            return True
+        now = dt_util.now()
+        actiontec_data = self.get_actiontec_data()
+        if not actiontec_data:
+            return False
+        self.last_results = [Device(data['mac'], name, now)
+                             for name, data in actiontec_data.items()
+                             if data['timevalid'] > -60]
+        _LOGGER.info("Scan successful")
+        return True
 
     def get_actiontec_data(self):
         """Retrieve data from Actiontec MI424WR and return parsed result."""

homeassistant/components/device_tracker/aruba.py

@@ -6,8 +6,6 @@ https://home-assistant.io/components/device_tracker.aruba/
 """
 import logging
 import re
-import threading
-from datetime import timedelta
 
 import voluptuous as vol
 
@@ -15,14 +13,11 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
 
 _LOGGER = logging.getLogger(__name__)
 
 REQUIREMENTS = ['pexpect==4.0.1']
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
-
 _DEVICES_REGEX = re.compile(
     r'(?P<name>([^\s]+))\s+' +
     r'(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\s+' +
@@ -52,8 +47,6 @@ class ArubaDeviceScanner(DeviceScanner):
         self.username = config[CONF_USERNAME]
         self.password = config[CONF_PASSWORD]
 
-        self.lock = threading.Lock()
-
         self.last_results = {}
 
         # Test the router is accessible.
@@ -74,7 +67,6 @@ class ArubaDeviceScanner(DeviceScanner):
                 return client['name']
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the Aruba Access Point is up to date.
 
@@ -83,13 +75,12 @@ class ArubaDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            data = self.get_aruba_data()
-            if not data:
-                return False
+        data = self.get_aruba_data()
+        if not data:
+            return False
 
-            self.last_results = data.values()
-            return True
+        self.last_results = data.values()
+        return True
 
     def get_aruba_data(self):
         """Retrieve data from Aruba Access Point and return parsed result."""

homeassistant/components/device_tracker/asuswrt.py

@@ -8,9 +8,7 @@ import logging
 import re
 import socket
 import telnetlib
-import threading
 from collections import namedtuple
-from datetime import timedelta
 
 import voluptuous as vol
 
@@ -18,7 +16,6 @@ from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import (
     CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_PORT)
-from homeassistant.util import Throttle
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['pexpect==4.0.1']
@@ -32,8 +29,6 @@ CONF_SSH_KEY = 'ssh_key'
 
 DEFAULT_SSH_PORT = 22
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
-
 SECRET_GROUP = 'Password or SSH Key'
 
 PLATFORM_SCHEMA = vol.All(
@@ -123,8 +118,6 @@ class AsusWrtDeviceScanner(DeviceScanner):
                                                self.password,
                                                self.mode == "ap")
 
-        self.lock = threading.Lock()
-
         self.last_results = {}
 
         # Test the router is accessible.
@@ -145,7 +138,6 @@ class AsusWrtDeviceScanner(DeviceScanner):
                 return client['host']
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the ASUSWRT router is up to date.
 
@@ -154,19 +146,18 @@ class AsusWrtDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            _LOGGER.info('Checking Devices')
-            data = self.get_asuswrt_data()
-            if not data:
-                return False
+        _LOGGER.info('Checking Devices')
+        data = self.get_asuswrt_data()
+        if not data:
+            return False
 
-            active_clients = [client for client in data.values() if
-                              client['status'] == 'REACHABLE' or
-                              client['status'] == 'DELAY' or
-                              client['status'] == 'STALE' or
-                              client['status'] == 'IN_ASSOCLIST']
-            self.last_results = active_clients
-            return True
+        active_clients = [client for client in data.values() if
+                          client['status'] == 'REACHABLE' or
+                          client['status'] == 'DELAY' or
+                          client['status'] == 'STALE' or
+                          client['status'] == 'IN_ASSOCLIST']
+        self.last_results = active_clients
+        return True
 
     def get_asuswrt_data(self):
         """Retrieve data from ASUSWRT and return parsed result."""

homeassistant/components/device_tracker/bt_home_hub_5.py

@@ -6,8 +6,6 @@ https://home-assistant.io/components/device_tracker.bt_home_hub_5/
 """
 import logging
 import re
-import threading
-from datetime import timedelta
 import xml.etree.ElementTree as ET
 import json
 from urllib.parse import unquote
@@ -19,13 +17,10 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
-from homeassistant.util import Throttle
 
 _LOGGER = logging.getLogger(__name__)
 _MAC_REGEX = re.compile(r'(([0-9A-Fa-f]{1,2}\:){5}[0-9A-Fa-f]{1,2})')
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
-
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string
 })
@@ -46,11 +41,7 @@ class BTHomeHub5DeviceScanner(DeviceScanner):
         """Initialise the scanner."""
         _LOGGER.info("Initialising BT Home Hub 5")
         self.host = config.get(CONF_HOST, '192.168.1.254')
-
-        self.lock = threading.Lock()
-
         self.last_results = {}
-
         self.url = 'http://{}/nonAuth/home_status.xml'.format(self.host)
 
         # Test the router is accessible
@@ -65,17 +56,15 @@ class BTHomeHub5DeviceScanner(DeviceScanner):
 
     def get_device_name(self, device):
         """Return the name of the given device or None if we don't know."""
-        with self.lock:
-            # If not initialised and not already scanned and not found.
-            if device not in self.last_results:
-                self._update_info()
+        # If not initialised and not already scanned and not found.
+        if device not in self.last_results:
+            self._update_info()
 
-                if not self.last_results:
-                    return None
+            if not self.last_results:
+                return None
 
-            return self.last_results.get(device)
+        return self.last_results.get(device)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the BT Home Hub 5 is up to date.
 
@@ -84,18 +73,17 @@ class BTHomeHub5DeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            _LOGGER.info("Scanning")
+        _LOGGER.info("Scanning")
 
-            data = _get_homehub_data(self.url)
+        data = _get_homehub_data(self.url)
 
-            if not data:
-                _LOGGER.warning("Error scanning devices")
-                return False
+        if not data:
+            _LOGGER.warning("Error scanning devices")
+            return False
 
-            self.last_results = data
+        self.last_results = data
 
-            return True
+        return True
 
 
 def _get_homehub_data(url):

homeassistant/components/device_tracker/cisco_ios.py

@@ -5,7 +5,6 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.cisco_ios/
 """
 import logging
-from datetime import timedelta
 
 import voluptuous as vol
 
@@ -14,9 +13,6 @@ from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, \
     CONF_PORT
-from homeassistant.util import Throttle
-
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -65,7 +61,6 @@ class CiscoDeviceScanner(DeviceScanner):
 
         return self.last_results
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """
         Ensure the information from the Cisco router is up to date.

homeassistant/components/device_tracker/ddwrt.py

@@ -6,8 +6,6 @@ https://home-assistant.io/components/device_tracker.ddwrt/
 """
 import logging
 import re
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -16,9 +14,6 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
-
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -50,8 +45,6 @@ class DdWrtDeviceScanner(DeviceScanner):
         self.username = config[CONF_USERNAME]
         self.password = config[CONF_PASSWORD]
 
-        self.lock = threading.Lock()
-
         self.last_results = {}
         self.mac2name = {}
 
@@ -69,68 +62,65 @@ class DdWrtDeviceScanner(DeviceScanner):
 
     def get_device_name(self, device):
         """Return the name of the given device or None if we don't know."""
-        with self.lock:
-            # If not initialised and not already scanned and not found.
-            if device not in self.mac2name:
-                url = 'http://{}/Status_Lan.live.asp'.format(self.host)
-                data = self.get_ddwrt_data(url)
+        # If not initialised and not already scanned and not found.
+        if device not in self.mac2name:
+            url = 'http://{}/Status_Lan.live.asp'.format(self.host)
+            data = self.get_ddwrt_data(url)
 
-                if not data:
-                    return None
+            if not data:
+                return None
 
-                dhcp_leases = data.get('dhcp_leases', None)
+            dhcp_leases = data.get('dhcp_leases', None)
 
-                if not dhcp_leases:
-                    return None
+            if not dhcp_leases:
+                return None
 
-                # Remove leading and trailing quotes and spaces
-                cleaned_str = dhcp_leases.replace(
-                    "\"", "").replace("\'", "").replace(" ", "")
-                elements = cleaned_str.split(',')
-                num_clients = int(len(elements) / 5)
-                self.mac2name = {}
-                for idx in range(0, num_clients):
-                    # The data is a single array
-                    # every 5 elements represents one host, the MAC
-                    # is the third element and the name is the first.
-                    mac_index = (idx * 5) + 2
-                    if mac_index < len(elements):
-                        mac = elements[mac_index]
-                        self.mac2name[mac] = elements[idx * 5]
+            # Remove leading and trailing quotes and spaces
+            cleaned_str = dhcp_leases.replace(
+                "\"", "").replace("\'", "").replace(" ", "")
+            elements = cleaned_str.split(',')
+            num_clients = int(len(elements) / 5)
+            self.mac2name = {}
+            for idx in range(0, num_clients):
+                # The data is a single array
+                # every 5 elements represents one host, the MAC
+                # is the third element and the name is the first.
+                mac_index = (idx * 5) + 2
+                if mac_index < len(elements):
+                    mac = elements[mac_index]
+                    self.mac2name[mac] = elements[idx * 5]
 
-            return self.mac2name.get(device)
+        return self.mac2name.get(device)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the DD-WRT router is up to date.
 
         Return boolean if scanning successful.
         """
-        with self.lock:
-            _LOGGER.info("Checking ARP")
+        _LOGGER.info("Checking ARP")
 
-            url = 'http://{}/Status_Wireless.live.asp'.format(self.host)
-            data = self.get_ddwrt_data(url)
+        url = 'http://{}/Status_Wireless.live.asp'.format(self.host)
+        data = self.get_ddwrt_data(url)
 
-            if not data:
-                return False
+        if not data:
+            return False
 
-            self.last_results = []
+        self.last_results = []
 
-            active_clients = data.get('active_wireless', None)
-            if not active_clients:
-                return False
+        active_clients = data.get('active_wireless', None)
+        if not active_clients:
+            return False
 
-            # The DD-WRT UI uses its own data format and then
-            # regex's out values so this is done here too
-            # Remove leading and trailing single quotes.
-            clean_str = active_clients.strip().strip("'")
-            elements = clean_str.split("','")
+        # The DD-WRT UI uses its own data format and then
+        # regex's out values so this is done here too
+        # Remove leading and trailing single quotes.
+        clean_str = active_clients.strip().strip("'")
+        elements = clean_str.split("','")
 
-            self.last_results.extend(item for item in elements
-                                     if _MAC_REGEX.match(item))
+        self.last_results.extend(item for item in elements
+                                 if _MAC_REGEX.match(item))
 
-            return True
+        return True
 
     def get_ddwrt_data(self, url):
         """Retrieve data from DD-WRT and return parsed result."""

homeassistant/components/device_tracker/fritz.py

@@ -5,7 +5,6 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.fritz/
 """
 import logging
-from datetime import timedelta
 
 import voluptuous as vol
 
@@ -13,12 +12,9 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
 
 REQUIREMENTS = ['fritzconnection==0.6.3']
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
-
 _LOGGER = logging.getLogger(__name__)
 
 CONF_DEFAULT_IP = '169.254.1.1'  # This IP is valid for all FRITZ!Box routers.
@@ -88,7 +84,6 @@ class FritzBoxScanner(DeviceScanner):
             return None
         return ret
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Retrieve latest information from the FRITZ!Box."""
         if not self.success_init:

homeassistant/components/device_tracker/linksys_ap.py

@@ -6,8 +6,6 @@ https://home-assistant.io/components/device_tracker.linksys_ap/
 """
 import base64
 import logging
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -16,9 +14,7 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
 from homeassistant.const import (
     CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_VERIFY_SSL)
-from homeassistant.util import Throttle
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 INTERFACES = 2
 DEFAULT_TIMEOUT = 10
 
@@ -51,8 +47,6 @@ class LinksysAPDeviceScanner(object):
         self.username = config[CONF_USERNAME]
         self.password = config[CONF_PASSWORD]
         self.verify_ssl = config[CONF_VERIFY_SSL]
-
-        self.lock = threading.Lock()
         self.last_results = []
 
         # Check if the access point is accessible
@@ -76,24 +70,22 @@ class LinksysAPDeviceScanner(object):
         """
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Check for connected devices."""
         from bs4 import BeautifulSoup as BS
 
-        with self.lock:
-            _LOGGER.info("Checking Linksys AP")
+        _LOGGER.info("Checking Linksys AP")
 
-            self.last_results = []
-            for interface in range(INTERFACES):
-                request = self._make_request(interface)
-                self.last_results.extend(
-                    [x.find_all('td')[1].text
-                     for x in BS(request.content, "html.parser")
-                     .find_all(class_='section-row')]
-                )
+        self.last_results = []
+        for interface in range(INTERFACES):
+            request = self._make_request(interface)
+            self.last_results.extend(
+                [x.find_all('td')[1].text
+                 for x in BS(request.content, "html.parser")
+                 .find_all(class_='section-row')]
+            )
 
-            return True
+        return True
 
     def _make_request(self, unit=0):
         # No, the '&&' is not a typo - this is expected by the web interface.

homeassistant/components/device_tracker/linksys_smart.py

@@ -1,7 +1,5 @@
 """Support for Linksys Smart Wifi routers."""
 import logging
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -10,9 +8,7 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
-from homeassistant.util import Throttle
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 DEFAULT_TIMEOUT = 10
 
 _LOGGER = logging.getLogger(__name__)
@@ -36,8 +32,6 @@ class LinksysSmartWifiDeviceScanner(DeviceScanner):
     def __init__(self, config):
         """Initialize the scanner."""
         self.host = config[CONF_HOST]
-
-        self.lock = threading.Lock()
         self.last_results = {}
 
         # Check if the access point is accessible
@@ -55,48 +49,46 @@ class LinksysSmartWifiDeviceScanner(DeviceScanner):
         """Return the name (if known) of the device."""
         return self.last_results.get(mac)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Check for connected devices."""
-        with self.lock:
-            _LOGGER.info("Checking Linksys Smart Wifi")
+        _LOGGER.info("Checking Linksys Smart Wifi")
 
-            self.last_results = {}
-            response = self._make_request()
-            if response.status_code != 200:
-                _LOGGER.error(
-                    "Got HTTP status code %d when getting device list",
-                    response.status_code)
-                return False
-            try:
-                data = response.json()
-                result = data["responses"][0]
-                devices = result["output"]["devices"]
-                for device in devices:
-                    macs = device["knownMACAddresses"]
-                    if not macs:
-                        _LOGGER.warning(
-                            "Skipping device without known MAC address")
-                        continue
-                    mac = macs[-1]
-                    connections = device["connections"]
-                    if not connections:
-                        _LOGGER.debug("Device %s is not connected", mac)
-                        continue
+        self.last_results = {}
+        response = self._make_request()
+        if response.status_code != 200:
+            _LOGGER.error(
+                "Got HTTP status code %d when getting device list",
+                response.status_code)
+            return False
+        try:
+            data = response.json()
+            result = data["responses"][0]
+            devices = result["output"]["devices"]
+            for device in devices:
+                macs = device["knownMACAddresses"]
+                if not macs:
+                    _LOGGER.warning(
+                        "Skipping device without known MAC address")
+                    continue
+                mac = macs[-1]
+                connections = device["connections"]
+                if not connections:
+                    _LOGGER.debug("Device %s is not connected", mac)
+                    continue
 
-                    name = None
-                    for prop in device["properties"]:
-                        if prop["name"] == "userDeviceName":
-                            name = prop["value"]
-                    if not name:
-                        name = device.get("friendlyName", device["deviceID"])
+                name = None
+                for prop in device["properties"]:
+                    if prop["name"] == "userDeviceName":
+                        name = prop["value"]
+                if not name:
+                    name = device.get("friendlyName", device["deviceID"])
 
-                    _LOGGER.debug("Device %s is connected", mac)
-                    self.last_results[mac] = name
-            except (KeyError, IndexError):
-                _LOGGER.exception("Router returned unexpected response")
-                return False
-            return True
+                _LOGGER.debug("Device %s is connected", mac)
+                self.last_results[mac] = name
+        except (KeyError, IndexError):
+            _LOGGER.exception("Router returned unexpected response")
+            return False
+        return True
 
     def _make_request(self):
         # Weirdly enough, this doesn't seem to require authentication

homeassistant/components/device_tracker/luci.py

@@ -7,8 +7,6 @@ https://home-assistant.io/components/device_tracker.luci/
 import json
 import logging
 import re
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -18,9 +16,6 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
-
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -55,12 +50,8 @@ class LuciDeviceScanner(DeviceScanner):
 
         self.parse_api_pattern = re.compile(r"(?P<param>\w*) = (?P<value>.*);")
 
-        self.lock = threading.Lock()
-
         self.last_results = {}
-
         self.refresh_token()
-
         self.mac2name = None
         self.success_init = self.token is not None
 
@@ -75,24 +66,22 @@ class LuciDeviceScanner(DeviceScanner):
 
     def get_device_name(self, device):
         """Return the name of the given device or None if we don't know."""
-        with self.lock:
-            if self.mac2name is None:
-                url = 'http://{}/cgi-bin/luci/rpc/uci'.format(self.host)
-                result = _req_json_rpc(url, 'get_all', 'dhcp',
-                                       params={'auth': self.token})
-                if result:
-                    hosts = [x for x in result.values()
-                             if x['.type'] == 'host' and
-                             'mac' in x and 'name' in x]
-                    mac2name_list = [
-                        (x['mac'].upper(), x['name']) for x in hosts]
-                    self.mac2name = dict(mac2name_list)
-                else:
-                    # Error, handled in the _req_json_rpc
-                    return
-            return self.mac2name.get(device.upper(), None)
+        if self.mac2name is None:
+            url = 'http://{}/cgi-bin/luci/rpc/uci'.format(self.host)
+            result = _req_json_rpc(url, 'get_all', 'dhcp',
+                                   params={'auth': self.token})
+            if result:
+                hosts = [x for x in result.values()
+                         if x['.type'] == 'host' and
+                         'mac' in x and 'name' in x]
+                mac2name_list = [
+                    (x['mac'].upper(), x['name']) for x in hosts]
+                self.mac2name = dict(mac2name_list)
+            else:
+                # Error, handled in the _req_json_rpc
+                return
+        return self.mac2name.get(device.upper(), None)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the Luci router is up to date.
 
@@ -101,31 +90,30 @@ class LuciDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            _LOGGER.info("Checking ARP")
+        _LOGGER.info("Checking ARP")
 
-            url = 'http://{}/cgi-bin/luci/rpc/sys'.format(self.host)
-
-            try:
-                result = _req_json_rpc(url, 'net.arptable',
-                                       params={'auth': self.token})
-            except InvalidLuciTokenError:
-                _LOGGER.info("Refreshing token")
-                self.refresh_token()
-                return False
-
-            if result:
-                self.last_results = []
-                for device_entry in result:
-                    # Check if the Flags for each device contain
-                    # NUD_REACHABLE and if so, add it to last_results
-                    if int(device_entry['Flags'], 16) & 0x2:
-                        self.last_results.append(device_entry['HW address'])
-
-                return True
+        url = 'http://{}/cgi-bin/luci/rpc/sys'.format(self.host)
 
+        try:
+            result = _req_json_rpc(url, 'net.arptable',
+                                   params={'auth': self.token})
+        except InvalidLuciTokenError:
+            _LOGGER.info("Refreshing token")
+            self.refresh_token()
             return False
 
+        if result:
+            self.last_results = []
+            for device_entry in result:
+                # Check if the Flags for each device contain
+                # NUD_REACHABLE and if so, add it to last_results
+                if int(device_entry['Flags'], 16) & 0x2:
+                    self.last_results.append(device_entry['HW address'])
+
+            return True
+
+        return False
+
 
 def _req_json_rpc(url, method, *args, **kwargs):
     """Perform one JSON RPC operation."""

homeassistant/components/device_tracker/mikrotik.py

@@ -5,25 +5,17 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.mikrotik/
 """
 import logging
-import threading
-from datetime import timedelta
 
 import voluptuous as vol
 
 import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
-from homeassistant.const import (CONF_HOST,
-                                 CONF_PASSWORD,
-                                 CONF_USERNAME,
-                                 CONF_PORT)
-from homeassistant.util import Throttle
+from homeassistant.const import (
+    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_PORT)
 
 REQUIREMENTS = ['librouteros==1.0.2']
 
-# Return cached results if last scan was less then this time ago.
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
-
 MTK_DEFAULT_API_PORT = '8728'
 
 _LOGGER = logging.getLogger(__name__)
@@ -54,12 +46,9 @@ class MikrotikScanner(DeviceScanner):
         self.username = config[CONF_USERNAME]
         self.password = config[CONF_PASSWORD]
 
-        self.lock = threading.Lock()
-
         self.connected = False
         self.success_init = False
         self.client = None
-
         self.wireless_exist = None
         self.success_init = self.connect_to_device()
 
@@ -118,51 +107,48 @@ class MikrotikScanner(DeviceScanner):
 
     def get_device_name(self, mac):
         """Return the name of the given device or None if we don't know."""
-        with self.lock:
-            return self.last_results.get(mac)
+        return self.last_results.get(mac)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Retrieve latest information from the Mikrotik box."""
-        with self.lock:
-            if self.wireless_exist:
-                devices_tracker = 'wireless'
-            else:
-                devices_tracker = 'ip'
+        if self.wireless_exist:
+            devices_tracker = 'wireless'
+        else:
+            devices_tracker = 'ip'
 
-            _LOGGER.info(
-                "Loading %s devices from Mikrotik (%s) ...",
-                devices_tracker,
-                self.host
+        _LOGGER.info(
+            "Loading %s devices from Mikrotik (%s) ...",
+            devices_tracker,
+            self.host
+        )
+
+        device_names = self.client(cmd='/ip/dhcp-server/lease/getall')
+        if self.wireless_exist:
+            devices = self.client(
+                cmd='/interface/wireless/registration-table/getall'
             )
+        else:
+            devices = device_names
 
-            device_names = self.client(cmd='/ip/dhcp-server/lease/getall')
-            if self.wireless_exist:
-                devices = self.client(
-                    cmd='/interface/wireless/registration-table/getall'
-                )
-            else:
-                devices = device_names
+        if device_names is None and devices is None:
+            return False
 
-            if device_names is None and devices is None:
-                return False
+        mac_names = {device.get('mac-address'): device.get('host-name')
+                     for device in device_names
+                     if device.get('mac-address')}
 
-            mac_names = {device.get('mac-address'): device.get('host-name')
-                         for device in device_names
-                         if device.get('mac-address')}
+        if self.wireless_exist:
+            self.last_results = {
+                device.get('mac-address'):
+                    mac_names.get(device.get('mac-address'))
+                for device in devices
+            }
+        else:
+            self.last_results = {
+                device.get('mac-address'):
+                    mac_names.get(device.get('mac-address'))
+                for device in device_names
+                if device.get('active-address')
+            }
 
-            if self.wireless_exist:
-                self.last_results = {
-                    device.get('mac-address'):
-                        mac_names.get(device.get('mac-address'))
-                    for device in devices
-                }
-            else:
-                self.last_results = {
-                    device.get('mac-address'):
-                        mac_names.get(device.get('mac-address'))
-                    for device in device_names
-                    if device.get('active-address')
-                }
-
-            return True
+        return True

homeassistant/components/device_tracker/netgear.py

@@ -5,8 +5,6 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.netgear/
 """
 import logging
-import threading
-from datetime import timedelta
 
 import voluptuous as vol
 
@@ -15,14 +13,11 @@ from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import (
     CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_PORT)
-from homeassistant.util import Throttle
 
 REQUIREMENTS = ['pynetgear==0.3.3']
 
 _LOGGER = logging.getLogger(__name__)
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
-
 DEFAULT_HOST = 'routerlogin.net'
 DEFAULT_USER = 'admin'
 DEFAULT_PORT = 5000
@@ -56,8 +51,6 @@ class NetgearDeviceScanner(DeviceScanner):
         import pynetgear
 
         self.last_results = []
-        self.lock = threading.Lock()
-
         self._api = pynetgear.Netgear(password, host, username, port)
 
         _LOGGER.info("Logging in")
@@ -85,7 +78,6 @@ class NetgearDeviceScanner(DeviceScanner):
         except StopIteration:
             return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Retrieve latest information from the Netgear router.
 
@@ -94,12 +86,11 @@ class NetgearDeviceScanner(DeviceScanner):
         if not self.success_init:
             return
 
-        with self.lock:
-            _LOGGER.info("Scanning")
+        _LOGGER.info("Scanning")
 
-            results = self._api.get_attached_devices()
+        results = self._api.get_attached_devices()
 
-            if results is None:
-                _LOGGER.warning("Error scanning devices")
+        if results is None:
+            _LOGGER.warning("Error scanning devices")
 
-            self.last_results = results or []
+        self.last_results = results or []

homeassistant/components/device_tracker/nmap_tracker.py

@@ -4,11 +4,11 @@ Support for scanning a network with nmap.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.nmap_tracker/
 """
+from datetime import timedelta
 import logging
 import re
 import subprocess
 from collections import namedtuple
-from datetime import timedelta
 
 import voluptuous as vol
 
@@ -17,7 +17,6 @@ import homeassistant.util.dt as dt_util
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOSTS
-from homeassistant.util import Throttle
 
 REQUIREMENTS = ['python-nmap==0.6.1']
 
@@ -29,8 +28,6 @@ CONF_HOME_INTERVAL = 'home_interval'
 CONF_OPTIONS = 'scan_options'
 DEFAULT_OPTIONS = '-F --host-timeout 5s'
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
-
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOSTS): cv.ensure_list,
@@ -97,7 +94,6 @@ class NmapDeviceScanner(DeviceScanner):
             return filter_named[0]
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Scan the network for devices.
 

homeassistant/components/device_tracker/owntracks.py

@@ -21,7 +21,7 @@ from homeassistant.components import zone as zone_comp
 from homeassistant.components.device_tracker import PLATFORM_SCHEMA
 
 DEPENDENCIES = ['mqtt']
-REQUIREMENTS = ['libnacl==1.5.1']
+REQUIREMENTS = ['libnacl==1.5.2']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -353,12 +353,20 @@ def _parse_see_args(topic, data):
     kwargs = {
         'dev_id': dev_id,
         'host_name': host_name,
-        'gps': (data[WAYPOINT_LAT_KEY], data[WAYPOINT_LON_KEY])
+        'gps': (data[WAYPOINT_LAT_KEY], data[WAYPOINT_LON_KEY]),
+        'attributes': {}
     }
     if 'acc' in data:
         kwargs['gps_accuracy'] = data['acc']
     if 'batt' in data:
         kwargs['battery'] = data['batt']
+    if 'vel' in data:
+        kwargs['attributes']['velocity'] = data['vel']
+    if 'tid' in data:
+        kwargs['attributes']['tid'] = data['tid']
+    if 'addr' in data:
+        kwargs['attributes']['address'] = data['addr']
+
     return dev_id, kwargs
 
 

homeassistant/components/device_tracker/sky_hub.py

@@ -6,8 +6,6 @@ https://home-assistant.io/components/device_tracker.sky_hub/
 """
 import logging
 import re
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -16,13 +14,10 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
-from homeassistant.util import Throttle
 
 _LOGGER = logging.getLogger(__name__)
 _MAC_REGEX = re.compile(r'(([0-9A-Fa-f]{1,2}\:){5}[0-9A-Fa-f]{1,2})')
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
-
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string
 })
@@ -43,11 +38,7 @@ class SkyHubDeviceScanner(DeviceScanner):
         """Initialise the scanner."""
         _LOGGER.info("Initialising Sky Hub")
         self.host = config.get(CONF_HOST, '192.168.1.254')
-
-        self.lock = threading.Lock()
-
         self.last_results = {}
-
         self.url = 'http://{}/'.format(self.host)
 
         # Test the router is accessible
@@ -62,17 +53,15 @@ class SkyHubDeviceScanner(DeviceScanner):
 
     def get_device_name(self, device):
         """Return the name of the given device or None if we don't know."""
-        with self.lock:
-            # If not initialised and not already scanned and not found.
-            if device not in self.last_results:
-                self._update_info()
+        # If not initialised and not already scanned and not found.
+        if device not in self.last_results:
+            self._update_info()
 
-                if not self.last_results:
-                    return None
+            if not self.last_results:
+                return None
 
-            return self.last_results.get(device)
+        return self.last_results.get(device)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the Sky Hub is up to date.
 
@@ -81,18 +70,17 @@ class SkyHubDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            _LOGGER.info("Scanning")
+        _LOGGER.info("Scanning")
 
-            data = _get_skyhub_data(self.url)
+        data = _get_skyhub_data(self.url)
 
-            if not data:
-                _LOGGER.warning('Error scanning devices')
-                return False
+        if not data:
+            _LOGGER.warning('Error scanning devices')
+            return False
 
-            self.last_results = data
+        self.last_results = data
 
-            return True
+        return True
 
 
 def _get_skyhub_data(url):

homeassistant/components/device_tracker/snmp.py

@@ -6,8 +6,6 @@ https://home-assistant.io/components/device_tracker.snmp/
 """
 import binascii
 import logging
-import threading
-from datetime import timedelta
 
 import voluptuous as vol
 
@@ -15,11 +13,10 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
-from homeassistant.util import Throttle
 
 _LOGGER = logging.getLogger(__name__)
 
-REQUIREMENTS = ['pysnmp==4.3.8']
+REQUIREMENTS = ['pysnmp==4.3.9']
 
 CONF_COMMUNITY = 'community'
 CONF_AUTHKEY = 'authkey'
@@ -28,8 +25,6 @@ CONF_BASEOID = 'baseoid'
 
 DEFAULT_COMMUNITY = 'public'
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
-
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Optional(CONF_COMMUNITY, default=DEFAULT_COMMUNITY): cv.string,
@@ -68,9 +63,6 @@ class SnmpScanner(DeviceScanner):
                 privProtocol=cfg.usmAesCfb128Protocol
             )
         self.baseoid = cmdgen.MibVariable(config[CONF_BASEOID])
-
-        self.lock = threading.Lock()
-
         self.last_results = []
 
         # Test the router is accessible
@@ -90,7 +82,6 @@ class SnmpScanner(DeviceScanner):
         # We have no names
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the device is up to date.
 
@@ -99,13 +90,12 @@ class SnmpScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            data = self.get_snmp_data()
-            if not data:
-                return False
+        data = self.get_snmp_data()
+        if not data:
+            return False
 
-            self.last_results = data
-            return True
+        self.last_results = data
+        return True
 
     def get_snmp_data(self):
         """Fetch MAC addresses from access point via SNMP."""

homeassistant/components/device_tracker/swisscom.py

@@ -5,8 +5,6 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.swisscom/
 """
 import logging
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -15,9 +13,6 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
-from homeassistant.util import Throttle
-
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,9 +36,6 @@ class SwisscomDeviceScanner(DeviceScanner):
     def __init__(self, config):
         """Initialize the scanner."""
         self.host = config[CONF_HOST]
-
-        self.lock = threading.Lock()
-
         self.last_results = {}
 
         # Test the router is accessible.
@@ -64,7 +56,6 @@ class SwisscomDeviceScanner(DeviceScanner):
                 return client['host']
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the Swisscom router is up to date.
 
@@ -73,16 +64,15 @@ class SwisscomDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            _LOGGER.info("Loading data from Swisscom Internet Box")
-            data = self.get_swisscom_data()
-            if not data:
-                return False
+        _LOGGER.info("Loading data from Swisscom Internet Box")
+        data = self.get_swisscom_data()
+        if not data:
+            return False
 
-            active_clients = [client for client in data.values() if
-                              client['status']]
-            self.last_results = active_clients
-            return True
+        active_clients = [client for client in data.values() if
+                          client['status']]
+        self.last_results = active_clients
+        return True
 
     def get_swisscom_data(self):
         """Retrieve data from Swisscom and return parsed result."""

homeassistant/components/device_tracker/thomson.py

@@ -7,8 +7,6 @@ https://home-assistant.io/components/device_tracker.thomson/
 import logging
 import re
 import telnetlib
-import threading
-from datetime import timedelta
 
 import voluptuous as vol
 
@@ -16,9 +14,6 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
-
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -54,9 +49,6 @@ class ThomsonDeviceScanner(DeviceScanner):
         self.host = config[CONF_HOST]
         self.username = config[CONF_USERNAME]
         self.password = config[CONF_PASSWORD]
-
-        self.lock = threading.Lock()
-
         self.last_results = {}
 
         # Test the router is accessible.
@@ -77,7 +69,6 @@ class ThomsonDeviceScanner(DeviceScanner):
                 return client['host']
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the THOMSON router is up to date.
 
@@ -86,17 +77,16 @@ class ThomsonDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            _LOGGER.info("Checking ARP")
-            data = self.get_thomson_data()
-            if not data:
-                return False
+        _LOGGER.info("Checking ARP")
+        data = self.get_thomson_data()
+        if not data:
+            return False
 
-            # Flag C stands for CONNECTED
-            active_clients = [client for client in data.values() if
-                              client['status'].find('C') != -1]
-            self.last_results = active_clients
-            return True
+        # Flag C stands for CONNECTED
+        active_clients = [client for client in data.values() if
+                          client['status'].find('C') != -1]
+        self.last_results = active_clients
+        return True
 
     def get_thomson_data(self):
         """Retrieve data from THOMSON and return parsed result."""

homeassistant/components/device_tracker/tomato.py

@@ -7,8 +7,6 @@ https://home-assistant.io/components/device_tracker.tomato/
 import json
 import logging
 import re
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -17,9 +15,6 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
-
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 CONF_HTTP_ID = 'http_id'
 
@@ -54,8 +49,6 @@ class TomatoDeviceScanner(DeviceScanner):
         self.parse_api_pattern = re.compile(r"(?P<param>\w*) = (?P<value>.*);")
 
         self.logger = logging.getLogger("{}.{}".format(__name__, "Tomato"))
-        self.lock = threading.Lock()
-
         self.last_results = {"wldev": [], "dhcpd_lease": []}
 
         self.success_init = self._update_tomato_info()
@@ -76,50 +69,48 @@ class TomatoDeviceScanner(DeviceScanner):
 
         return filter_named[0]
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_tomato_info(self):
         """Ensure the information from the Tomato router is up to date.
 
         Return boolean if scanning successful.
         """
-        with self.lock:
-            self.logger.info("Scanning")
+        self.logger.info("Scanning")
 
-            try:
-                response = requests.Session().send(self.req, timeout=3)
-                # Calling and parsing the Tomato api here. We only need the
-                # wldev and dhcpd_lease values.
-                if response.status_code == 200:
+        try:
+            response = requests.Session().send(self.req, timeout=3)
+            # Calling and parsing the Tomato api here. We only need the
+            # wldev and dhcpd_lease values.
+            if response.status_code == 200:
 
-                    for param, value in \
-                            self.parse_api_pattern.findall(response.text):
+                for param, value in \
+                        self.parse_api_pattern.findall(response.text):
 
-                        if param == 'wldev' or param == 'dhcpd_lease':
-                            self.last_results[param] = \
-                                json.loads(value.replace("'", '"'))
-                    return True
+                    if param == 'wldev' or param == 'dhcpd_lease':
+                        self.last_results[param] = \
+                            json.loads(value.replace("'", '"'))
+                return True
 
-                elif response.status_code == 401:
-                    # Authentication error
-                    self.logger.exception((
-                        "Failed to authenticate, "
-                        "please check your username and password"))
-                    return False
-
-            except requests.exceptions.ConnectionError:
-                # We get this if we could not connect to the router or
-                # an invalid http_id was supplied.
-                self.logger.exception("Failed to connect to the router or "
-                                      "invalid http_id supplied")
+            elif response.status_code == 401:
+                # Authentication error
+                self.logger.exception((
+                    "Failed to authenticate, "
+                    "please check your username and password"))
                 return False
 
-            except requests.exceptions.Timeout:
-                # We get this if we could not connect to the router or
-                # an invalid http_id was supplied.
-                self.logger.exception("Connection to the router timed out")
-                return False
+        except requests.exceptions.ConnectionError:
+            # We get this if we could not connect to the router or
+            # an invalid http_id was supplied.
+            self.logger.exception("Failed to connect to the router or "
+                                  "invalid http_id supplied")
+            return False
 
-            except ValueError:
-                # If JSON decoder could not parse the response.
-                self.logger.exception("Failed to parse response from router")
-                return False
+        except requests.exceptions.Timeout:
+            # We get this if we could not connect to the router or
+            # an invalid http_id was supplied.
+            self.logger.exception("Connection to the router timed out")
+            return False
+
+        except ValueError:
+            # If JSON decoder could not parse the response.
+            self.logger.exception("Failed to parse response from router")
+            return False

homeassistant/components/device_tracker/tplink.py

@@ -8,8 +8,7 @@ import base64
 import hashlib
 import logging
 import re
-import threading
-from datetime import timedelta, datetime
+from datetime import datetime
 
 import requests
 import voluptuous as vol
@@ -18,9 +17,6 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
-
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -59,7 +55,6 @@ class TplinkDeviceScanner(DeviceScanner):
         self.password = password
 
         self.last_results = {}
-        self.lock = threading.Lock()
         self.success_init = self._update_info()
 
     def scan_devices(self):
@@ -72,28 +67,26 @@ class TplinkDeviceScanner(DeviceScanner):
         """Get firmware doesn't save the name of the wireless device."""
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the TP-Link router is up to date.
 
         Return boolean if scanning successful.
         """
-        with self.lock:
-            _LOGGER.info("Loading wireless clients...")
+        _LOGGER.info("Loading wireless clients...")
 
-            url = 'http://{}/userRpm/WlanStationRpm.htm'.format(self.host)
-            referer = 'http://{}'.format(self.host)
-            page = requests.get(
-                url, auth=(self.username, self.password),
-                headers={'referer': referer}, timeout=4)
+        url = 'http://{}/userRpm/WlanStationRpm.htm'.format(self.host)
+        referer = 'http://{}'.format(self.host)
+        page = requests.get(
+            url, auth=(self.username, self.password),
+            headers={'referer': referer}, timeout=4)
 
-            result = self.parse_macs.findall(page.text)
+        result = self.parse_macs.findall(page.text)
 
-            if result:
-                self.last_results = [mac.replace("-", ":") for mac in result]
-                return True
+        if result:
+            self.last_results = [mac.replace("-", ":") for mac in result]
+            return True
 
-            return False
+        return False
 
 
 class Tplink2DeviceScanner(TplinkDeviceScanner):
@@ -109,48 +102,46 @@ class Tplink2DeviceScanner(TplinkDeviceScanner):
         """Get firmware doesn't save the name of the wireless device."""
         return self.last_results.get(device)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the TP-Link router is up to date.
 
         Return boolean if scanning successful.
         """
-        with self.lock:
-            _LOGGER.info("Loading wireless clients...")
+        _LOGGER.info("Loading wireless clients...")
 
-            url = 'http://{}/data/map_access_wireless_client_grid.json' \
-                .format(self.host)
-            referer = 'http://{}'.format(self.host)
+        url = 'http://{}/data/map_access_wireless_client_grid.json' \
+            .format(self.host)
+        referer = 'http://{}'.format(self.host)
 
-            # Router uses Authorization cookie instead of header
-            # Let's create the cookie
-            username_password = '{}:{}'.format(self.username, self.password)
-            b64_encoded_username_password = base64.b64encode(
-                username_password.encode('ascii')
-            ).decode('ascii')
-            cookie = 'Authorization=Basic {}' \
-                .format(b64_encoded_username_password)
+        # Router uses Authorization cookie instead of header
+        # Let's create the cookie
+        username_password = '{}:{}'.format(self.username, self.password)
+        b64_encoded_username_password = base64.b64encode(
+            username_password.encode('ascii')
+        ).decode('ascii')
+        cookie = 'Authorization=Basic {}' \
+            .format(b64_encoded_username_password)
 
-            response = requests.post(
-                url, headers={'referer': referer, 'cookie': cookie},
-                timeout=4)
-
-            try:
-                result = response.json().get('data')
-            except ValueError:
-                _LOGGER.error("Router didn't respond with JSON. "
-                              "Check if credentials are correct.")
-                return False
-
-            if result:
-                self.last_results = {
-                    device['mac_addr'].replace('-', ':'): device['name']
-                    for device in result
-                    }
-                return True
+        response = requests.post(
+            url, headers={'referer': referer, 'cookie': cookie},
+            timeout=4)
 
+        try:
+            result = response.json().get('data')
+        except ValueError:
+            _LOGGER.error("Router didn't respond with JSON. "
+                          "Check if credentials are correct.")
             return False
 
+        if result:
+            self.last_results = {
+                device['mac_addr'].replace('-', ':'): device['name']
+                for device in result
+                }
+            return True
+
+        return False
+
 
 class Tplink3DeviceScanner(TplinkDeviceScanner):
     """This class queries the Archer C9 router with version 150811 or high."""
@@ -202,70 +193,67 @@ class Tplink3DeviceScanner(TplinkDeviceScanner):
                           response.text)
             return False
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the TP-Link router is up to date.
 
         Return boolean if scanning successful.
         """
-        with self.lock:
-            if (self.stok == '') or (self.sysauth == ''):
-                self._get_auth_tokens()
+        if (self.stok == '') or (self.sysauth == ''):
+            self._get_auth_tokens()
 
-            _LOGGER.info("Loading wireless clients...")
+        _LOGGER.info("Loading wireless clients...")
 
-            url = ('http://{}/cgi-bin/luci/;stok={}/admin/wireless?'
-                   'form=statistics').format(self.host, self.stok)
-            referer = 'http://{}/webpages/index.html'.format(self.host)
+        url = ('http://{}/cgi-bin/luci/;stok={}/admin/wireless?'
+               'form=statistics').format(self.host, self.stok)
+        referer = 'http://{}/webpages/index.html'.format(self.host)
 
-            response = requests.post(url,
-                                     params={'operation': 'load'},
-                                     headers={'referer': referer},
-                                     cookies={'sysauth': self.sysauth},
-                                     timeout=5)
+        response = requests.post(url,
+                                 params={'operation': 'load'},
+                                 headers={'referer': referer},
+                                 cookies={'sysauth': self.sysauth},
+                                 timeout=5)
 
-            try:
-                json_response = response.json()
+        try:
+            json_response = response.json()
 
-                if json_response.get('success'):
-                    result = response.json().get('data')
-                else:
-                    if json_response.get('errorcode') == 'timeout':
-                        _LOGGER.info("Token timed out. Relogging on next scan")
-                        self.stok = ''
-                        self.sysauth = ''
-                        return False
-                    _LOGGER.error(
-                        "An unknown error happened while fetching data")
+            if json_response.get('success'):
+                result = response.json().get('data')
+            else:
+                if json_response.get('errorcode') == 'timeout':
+                    _LOGGER.info("Token timed out. Relogging on next scan")
+                    self.stok = ''
+                    self.sysauth = ''
                     return False
-            except ValueError:
-                _LOGGER.error("Router didn't respond with JSON. "
-                              "Check if credentials are correct")
+                _LOGGER.error(
+                    "An unknown error happened while fetching data")
                 return False
-
-            if result:
-                self.last_results = {
-                    device['mac'].replace('-', ':'): device['mac']
-                    for device in result
-                    }
-                return True
-
+        except ValueError:
+            _LOGGER.error("Router didn't respond with JSON. "
+                          "Check if credentials are correct")
             return False
 
+        if result:
+            self.last_results = {
+                device['mac'].replace('-', ':'): device['mac']
+                for device in result
+                }
+            return True
+
+        return False
+
     def _log_out(self):
-        with self.lock:
-            _LOGGER.info("Logging out of router admin interface...")
+        _LOGGER.info("Logging out of router admin interface...")
 
-            url = ('http://{}/cgi-bin/luci/;stok={}/admin/system?'
-                   'form=logout').format(self.host, self.stok)
-            referer = 'http://{}/webpages/index.html'.format(self.host)
+        url = ('http://{}/cgi-bin/luci/;stok={}/admin/system?'
+               'form=logout').format(self.host, self.stok)
+        referer = 'http://{}/webpages/index.html'.format(self.host)
 
-            requests.post(url,
-                          params={'operation': 'write'},
-                          headers={'referer': referer},
-                          cookies={'sysauth': self.sysauth})
-            self.stok = ''
-            self.sysauth = ''
+        requests.post(url,
+                      params={'operation': 'write'},
+                      headers={'referer': referer},
+                      cookies={'sysauth': self.sysauth})
+        self.stok = ''
+        self.sysauth = ''
 
 
 class Tplink4DeviceScanner(TplinkDeviceScanner):
@@ -318,38 +306,36 @@ class Tplink4DeviceScanner(TplinkDeviceScanner):
             _LOGGER.error("Couldn't fetch auth tokens")
             return False
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the TP-Link router is up to date.
 
         Return boolean if scanning successful.
         """
-        with self.lock:
-            if (self.credentials == '') or (self.token == ''):
-                self._get_auth_tokens()
+        if (self.credentials == '') or (self.token == ''):
+            self._get_auth_tokens()
 
-            _LOGGER.info("Loading wireless clients...")
+        _LOGGER.info("Loading wireless clients...")
 
-            mac_results = []
+        mac_results = []
 
-            # Check both the 2.4GHz and 5GHz client list URLs
-            for clients_url in ('WlanStationRpm.htm', 'WlanStationRpm_5g.htm'):
-                url = 'http://{}/{}/userRpm/{}' \
-                    .format(self.host, self.token, clients_url)
-                referer = 'http://{}'.format(self.host)
-                cookie = 'Authorization=Basic {}'.format(self.credentials)
+        # Check both the 2.4GHz and 5GHz client list URLs
+        for clients_url in ('WlanStationRpm.htm', 'WlanStationRpm_5g.htm'):
+            url = 'http://{}/{}/userRpm/{}' \
+                .format(self.host, self.token, clients_url)
+            referer = 'http://{}'.format(self.host)
+            cookie = 'Authorization=Basic {}'.format(self.credentials)
 
-                page = requests.get(url, headers={
-                    'cookie': cookie,
-                    'referer': referer
-                })
-                mac_results.extend(self.parse_macs.findall(page.text))
+            page = requests.get(url, headers={
+                'cookie': cookie,
+                'referer': referer
+            })
+            mac_results.extend(self.parse_macs.findall(page.text))
 
-            if not mac_results:
-                return False
+        if not mac_results:
+            return False
 
-            self.last_results = [mac.replace("-", ":") for mac in mac_results]
-            return True
+        self.last_results = [mac.replace("-", ":") for mac in mac_results]
+        return True
 
 
 class Tplink5DeviceScanner(TplinkDeviceScanner):
@@ -365,68 +351,67 @@ class Tplink5DeviceScanner(TplinkDeviceScanner):
         """Get firmware doesn't save the name of the wireless device."""
         return None
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the information from the TP-Link AP is up to date.
 
         Return boolean if scanning successful.
         """
-        with self.lock:
-            _LOGGER.info("Loading wireless clients...")
+        _LOGGER.info("Loading wireless clients...")
 
-            base_url = 'http://{}'.format(self.host)
+        base_url = 'http://{}'.format(self.host)
 
-            header = {
-                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12;"
-                              " rv:53.0) Gecko/20100101 Firefox/53.0",
-                "Accept": "application/json, text/javascript, */*; q=0.01",
-                "Accept-Language": "Accept-Language: en-US,en;q=0.5",
-                "Accept-Encoding": "gzip, deflate",
-                "Content-Type": "application/x-www-form-urlencoded; "
-                                "charset=UTF-8",
-                "X-Requested-With": "XMLHttpRequest",
-                "Referer": "http://" + self.host + "/",
-                "Connection": "keep-alive",
-                "Pragma": "no-cache",
-                "Cache-Control": "no-cache"
-            }
+        header = {
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12;"
+                          " rv:53.0) Gecko/20100101 Firefox/53.0",
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "Accept-Language": "Accept-Language: en-US,en;q=0.5",
+            "Accept-Encoding": "gzip, deflate",
+            "Content-Type": "application/x-www-form-urlencoded; "
+                            "charset=UTF-8",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "http://" + self.host + "/",
+            "Connection": "keep-alive",
+            "Pragma": "no-cache",
+            "Cache-Control": "no-cache"
+        }
 
-            password_md5 = hashlib.md5(self.password).hexdigest().upper()
+        password_md5 = hashlib.md5(
+            self.password.encode('utf')).hexdigest().upper()
 
-            # create a session to handle cookie easier
-            session = requests.session()
-            session.get(base_url, headers=header)
+        # create a session to handle cookie easier
+        session = requests.session()
+        session.get(base_url, headers=header)
 
-            login_data = {"username": self.username, "password": password_md5}
-            session.post(base_url, login_data, headers=header)
+        login_data = {"username": self.username, "password": password_md5}
+        session.post(base_url, login_data, headers=header)
 
-            # a timestamp is required to be sent as get parameter
-            timestamp = int(datetime.now().timestamp() * 1e3)
+        # a timestamp is required to be sent as get parameter
+        timestamp = int(datetime.now().timestamp() * 1e3)
 
-            client_list_url = '{}/data/monitor.client.client.json'.format(
-                base_url)
+        client_list_url = '{}/data/monitor.client.client.json'.format(
+            base_url)
 
-            get_params = {
-                'operation': 'load',
-                '_': timestamp
-            }
-
-            response = session.get(client_list_url,
-                                   headers=header,
-                                   params=get_params)
-            session.close()
-            try:
-                list_of_devices = response.json()
-            except ValueError:
-                _LOGGER.error("AP didn't respond with JSON. "
-                              "Check if credentials are correct.")
-                return False
-
-            if list_of_devices:
-                self.last_results = {
-                    device['MAC'].replace('-', ':'): device['DeviceName']
-                    for device in list_of_devices['data']
-                    }
-                return True
+        get_params = {
+            'operation': 'load',
+            '_': timestamp
+        }
 
+        response = session.get(client_list_url,
+                               headers=header,
+                               params=get_params)
+        session.close()
+        try:
+            list_of_devices = response.json()
+        except ValueError:
+            _LOGGER.error("AP didn't respond with JSON. "
+                          "Check if credentials are correct.")
             return False
+
+        if list_of_devices:
+            self.last_results = {
+                device['MAC'].replace('-', ':'): device['DeviceName']
+                for device in list_of_devices['data']
+                }
+            return True
+
+        return False

homeassistant/components/device_tracker/ubus.py

@@ -7,8 +7,6 @@ https://home-assistant.io/components/device_tracker.ubus/
 import json
 import logging
 import re
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -17,12 +15,8 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
 from homeassistant.exceptions import HomeAssistantError
 
-# Return cached results if last scan was less then this time ago.
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
-
 _LOGGER = logging.getLogger(__name__)
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -70,7 +64,6 @@ class UbusDeviceScanner(DeviceScanner):
         self.password = config[CONF_PASSWORD]
 
         self.parse_api_pattern = re.compile(r"(?P<param>\w*) = (?P<value>.*);")
-        self.lock = threading.Lock()
         self.last_results = {}
         self.url = 'http://{}/ubus'.format(host)
 
@@ -87,35 +80,33 @@ class UbusDeviceScanner(DeviceScanner):
         return self.last_results
 
     @_refresh_on_acccess_denied
-    def get_device_name(self, device):
+    def get_device_name(self, mac):
         """Return the name of the given device or None if we don't know."""
-        with self.lock:
-            if self.leasefile is None:
-                result = _req_json_rpc(
-                    self.url, self.session_id, 'call', 'uci', 'get',
-                    config="dhcp", type="dnsmasq")
-                if result:
-                    values = result["values"].values()
-                    self.leasefile = next(iter(values))["leasefile"]
-                else:
-                    return
+        if self.leasefile is None:
+            result = _req_json_rpc(
+                self.url, self.session_id, 'call', 'uci', 'get',
+                config="dhcp", type="dnsmasq")
+            if result:
+                values = result["values"].values()
+                self.leasefile = next(iter(values))["leasefile"]
+            else:
+                return
 
-            if self.mac2name is None:
-                result = _req_json_rpc(
-                    self.url, self.session_id, 'call', 'file', 'read',
-                    path=self.leasefile)
-                if result:
-                    self.mac2name = dict()
-                    for line in result["data"].splitlines():
-                        hosts = line.split(" ")
-                        self.mac2name[hosts[1].upper()] = hosts[3]
-                else:
-                    # Error, handled in the _req_json_rpc
-                    return
+        if self.mac2name is None:
+            result = _req_json_rpc(
+                self.url, self.session_id, 'call', 'file', 'read',
+                path=self.leasefile)
+            if result:
+                self.mac2name = dict()
+                for line in result["data"].splitlines():
+                    hosts = line.split(" ")
+                    self.mac2name[hosts[1].upper()] = hosts[3]
+            else:
+                # Error, handled in the _req_json_rpc
+                return
 
-            return self.mac2name.get(device.upper(), None)
+        return self.mac2name.get(mac.upper(), None)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     @_refresh_on_acccess_denied
     def _update_info(self):
         """Ensure the information from the Luci router is up to date.
@@ -125,25 +116,24 @@ class UbusDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            _LOGGER.info("Checking ARP")
+        _LOGGER.info("Checking ARP")
 
-            if not self.hostapd:
-                hostapd = _req_json_rpc(
-                    self.url, self.session_id, 'list', 'hostapd.*', '')
-                self.hostapd.extend(hostapd.keys())
+        if not self.hostapd:
+            hostapd = _req_json_rpc(
+                self.url, self.session_id, 'list', 'hostapd.*', '')
+            self.hostapd.extend(hostapd.keys())
 
-            self.last_results = []
-            results = 0
-            for hostapd in self.hostapd:
-                result = _req_json_rpc(
-                    self.url, self.session_id, 'call', hostapd, 'get_clients')
+        self.last_results = []
+        results = 0
+        for hostapd in self.hostapd:
+            result = _req_json_rpc(
+                self.url, self.session_id, 'call', hostapd, 'get_clients')
 
-                if result:
-                    results = results + 1
-                    self.last_results.extend(result['clients'].keys())
+            if result:
+                results = results + 1
+                self.last_results.extend(result['clients'].keys())
 
-            return bool(results)
+        return bool(results)
 
 
 def _req_json_rpc(url, session_id, rpcmethod, subsystem, method, **params):

homeassistant/components/device_tracker/unifi.py

@@ -8,7 +8,6 @@ import logging
 import voluptuous as vol
 
 import homeassistant.helpers.config_validation as cv
-import homeassistant.loader as loader
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD
@@ -48,14 +47,13 @@ def get_scanner(hass, config):
     port = config[DOMAIN].get(CONF_PORT)
     verify_ssl = config[DOMAIN].get(CONF_VERIFY_SSL)
 
-    persistent_notification = loader.get_component('persistent_notification')
     try:
         ctrl = Controller(host, username, password, port, version='v4',
                           site_id=site_id, ssl_verify=verify_ssl)
     except APIError as ex:
         _LOGGER.error("Failed to connect to Unifi: %s", ex)
-        persistent_notification.create(
-            hass, 'Failed to connect to Unifi. '
+        hass.components.persistent_notification.create(
+            'Failed to connect to Unifi. '
             'Error: {}<br />'
             'You will need to restart hass after fixing.'
             ''.format(ex),

homeassistant/components/device_tracker/volvooncall.py

@@ -9,8 +9,7 @@ import logging
 from homeassistant.util import slugify
 from homeassistant.helpers.dispatcher import (
     dispatcher_connect, dispatcher_send)
-from homeassistant.components.volvooncall import (
-    DATA_KEY, SIGNAL_VEHICLE_SEEN)
+from homeassistant.components.volvooncall import DATA_KEY, SIGNAL_VEHICLE_SEEN
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/device_tracker/xiaomi.py

@@ -5,8 +5,6 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.xiaomi/
 """
 import logging
-import threading
-from datetime import timedelta
 
 import requests
 import voluptuous as vol
@@ -15,12 +13,9 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.util import Throttle
 
 _LOGGER = logging.getLogger(__name__)
 
-MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
-
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Required(CONF_USERNAME, default='admin'): cv.string,
@@ -47,8 +42,6 @@ class XiaomiDeviceScanner(DeviceScanner):
         self.username = config[CONF_USERNAME]
         self.password = config[CONF_PASSWORD]
 
-        self.lock = threading.Lock()
-
         self.last_results = {}
         self.token = _get_token(self.host, self.username, self.password)
 
@@ -62,21 +55,19 @@ class XiaomiDeviceScanner(DeviceScanner):
 
     def get_device_name(self, device):
         """Return the name of the given device or None if we don't know."""
-        with self.lock:
-            if self.mac2name is None:
-                result = self._retrieve_list_with_retry()
-                if result:
-                    hosts = [x for x in result
-                             if 'mac' in x and 'name' in x]
-                    mac2name_list = [
-                        (x['mac'].upper(), x['name']) for x in hosts]
-                    self.mac2name = dict(mac2name_list)
-                else:
-                    # Error, handled in the _retrieve_list_with_retry
-                    return
-            return self.mac2name.get(device.upper(), None)
+        if self.mac2name is None:
+            result = self._retrieve_list_with_retry()
+            if result:
+                hosts = [x for x in result
+                         if 'mac' in x and 'name' in x]
+                mac2name_list = [
+                    (x['mac'].upper(), x['name']) for x in hosts]
+                self.mac2name = dict(mac2name_list)
+            else:
+                # Error, handled in the _retrieve_list_with_retry
+                return
+        return self.mac2name.get(device.upper(), None)
 
-    @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
         """Ensure the informations from the router are up to date.
 
@@ -85,12 +76,11 @@ class XiaomiDeviceScanner(DeviceScanner):
         if not self.success_init:
             return False
 
-        with self.lock:
-            result = self._retrieve_list_with_retry()
-            if result:
-                self._store_result(result)
-                return True
-            return False
+        result = self._retrieve_list_with_retry()
+        if result:
+            self._store_result(result)
+            return True
+        return False
 
     def _retrieve_list_with_retry(self):
         """Retrieve the device list with a retry if token is invalid.

homeassistant/components/discovery.py

@@ -21,7 +21,7 @@ from homeassistant.helpers.event import async_track_point_in_utc_time
 from homeassistant.helpers.discovery import async_load_platform, async_discover
 import homeassistant.util.dt as dt_util
 
-REQUIREMENTS = ['netdisco==1.0.1']
+REQUIREMENTS = ['netdisco==1.1.0']
 
 DOMAIN = 'discovery'
 

homeassistant/components/emulated_hue/__init__.py

@@ -193,7 +193,7 @@ class Config(object):
             if entity_id == ent_id:
                 return number
 
-        number = str(len(self.numbers) + 1)
+        number = str(max(int(k) for k in self.numbers) + 1)
         self.numbers[number] = entity_id
         self._save_numbers_json()
         return number

homeassistant/components/fan/__init__.py

@@ -17,6 +17,7 @@ from homeassistant.config import load_yaml_config_file
 from homeassistant.const import (SERVICE_TURN_ON, SERVICE_TOGGLE,
                                  SERVICE_TURN_OFF, ATTR_ENTITY_ID,
                                  STATE_UNKNOWN)
+from homeassistant.loader import bind_hass
 from homeassistant.helpers.entity import ToggleEntity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
@@ -118,6 +119,7 @@ SERVICE_TO_METHOD = {
 }
 
 
+@bind_hass
 def is_on(hass, entity_id: str=None) -> bool:
     """Return if the fans are on based on the statemachine."""
     entity_id = entity_id or ENTITY_ID_ALL_FANS
@@ -125,6 +127,7 @@ def is_on(hass, entity_id: str=None) -> bool:
     return state.attributes[ATTR_SPEED] not in [SPEED_OFF, STATE_UNKNOWN]
 
 
+@bind_hass
 def turn_on(hass, entity_id: str=None, speed: str=None) -> None:
     """Turn all or specified fan on."""
     data = {
@@ -137,6 +140,7 @@ def turn_on(hass, entity_id: str=None, speed: str=None) -> None:
     hass.services.call(DOMAIN, SERVICE_TURN_ON, data)
 
 
+@bind_hass
 def turn_off(hass, entity_id: str=None) -> None:
     """Turn all or specified fan off."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
@@ -144,6 +148,7 @@ def turn_off(hass, entity_id: str=None) -> None:
     hass.services.call(DOMAIN, SERVICE_TURN_OFF, data)
 
 
+@bind_hass
 def toggle(hass, entity_id: str=None) -> None:
     """Toggle all or specified fans."""
     data = {
@@ -153,6 +158,7 @@ def toggle(hass, entity_id: str=None) -> None:
     hass.services.call(DOMAIN, SERVICE_TOGGLE, data)
 
 
+@bind_hass
 def oscillate(hass, entity_id: str=None, should_oscillate: bool=True) -> None:
     """Set oscillation on all or specified fan."""
     data = {
@@ -165,6 +171,7 @@ def oscillate(hass, entity_id: str=None, should_oscillate: bool=True) -> None:
     hass.services.call(DOMAIN, SERVICE_OSCILLATE, data)
 
 
+@bind_hass
 def set_speed(hass, entity_id: str=None, speed: str=None) -> None:
     """Set speed for all or specified fan."""
     data = {
@@ -177,6 +184,7 @@ def set_speed(hass, entity_id: str=None, speed: str=None) -> None:
     hass.services.call(DOMAIN, SERVICE_SET_SPEED, data)
 
 
+@bind_hass
 def set_direction(hass, entity_id: str=None, direction: str=None) -> None:
     """Set direction for all or specified fan."""
     data = {

homeassistant/components/fan/velbus.py

@@ -0,0 +1,187 @@
+"""
+Support for Velbus platform.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/fan.velbus/
+"""
+import asyncio
+import logging
+import voluptuous as vol
+
+from homeassistant.components.fan import (
+    SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH, FanEntity, SUPPORT_SET_SPEED,
+    PLATFORM_SCHEMA)
+from homeassistant.components.velbus import DOMAIN
+from homeassistant.const import CONF_NAME, CONF_DEVICES, STATE_OFF
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['velbus']
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_DEVICES): vol.All(cv.ensure_list, [
+        {
+            vol.Required('module'): cv.positive_int,
+            vol.Required('channel_low'): cv.positive_int,
+            vol.Required('channel_medium'): cv.positive_int,
+            vol.Required('channel_high'): cv.positive_int,
+            vol.Required(CONF_NAME): cv.string,
+        }
+    ])
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Fans."""
+    velbus = hass.data[DOMAIN]
+    add_devices(VelbusFan(fan, velbus) for fan in config[CONF_DEVICES])
+
+
+class VelbusFan(FanEntity):
+    """Representation of a Velbus Fan."""
+
+    def __init__(self, fan, velbus):
+        """Initialize a Velbus light."""
+        self._velbus = velbus
+        self._name = fan[CONF_NAME]
+        self._module = fan['module']
+        self._channel_low = fan['channel_low']
+        self._channel_medium = fan['channel_medium']
+        self._channel_high = fan['channel_high']
+        self._channels = [self._channel_low, self._channel_medium,
+                          self._channel_high]
+        self._channels_state = [False, False, False]
+        self._speed = STATE_OFF
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Add listener for Velbus messages on bus."""
+        def _init_velbus():
+            """Initialize Velbus on startup."""
+            self._velbus.subscribe(self._on_message)
+            self.get_status()
+
+        yield from self.hass.async_add_job(_init_velbus)
+
+    def _on_message(self, message):
+        import velbus
+        if isinstance(message, velbus.RelayStatusMessage) and \
+           message.address == self._module and \
+           message.channel in self._channels:
+            if message.channel == self._channel_low:
+                self._channels_state[0] = message.is_on()
+            elif message.channel == self._channel_medium:
+                self._channels_state[1] = message.is_on()
+            elif message.channel == self._channel_high:
+                self._channels_state[2] = message.is_on()
+            self._calculate_speed()
+            self.schedule_update_ha_state()
+
+    def _calculate_speed(self):
+        if self._is_off():
+            self._speed = STATE_OFF
+        elif self._is_low():
+            self._speed = SPEED_LOW
+        elif self._is_medium():
+            self._speed = SPEED_MEDIUM
+        elif self._is_high():
+            self._speed = SPEED_HIGH
+
+    def _is_off(self):
+        return self._channels_state[0] is False and \
+               self._channels_state[1] is False and \
+               self._channels_state[2] is False
+
+    def _is_low(self):
+        return self._channels_state[0] is True and \
+               self._channels_state[1] is False and \
+               self._channels_state[2] is False
+
+    def _is_medium(self):
+        return self._channels_state[0] is True and \
+               self._channels_state[1] is True and \
+               self._channels_state[2] is False
+
+    def _is_high(self):
+        return self._channels_state[0] is True and \
+               self._channels_state[1] is False and \
+               self._channels_state[2] is True
+
+    @property
+    def name(self):
+        """Return the display name of this light."""
+        return self._name
+
+    @property
+    def should_poll(self):
+        """Disable polling."""
+        return False
+
+    @property
+    def speed(self):
+        """Return the current speed."""
+        return self._speed
+
+    @property
+    def speed_list(self):
+        """Get the list of available speeds."""
+        return [STATE_OFF, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]
+
+    def turn_on(self, speed, **kwargs):
+        """Turn on the entity."""
+        if speed is None:
+            speed = SPEED_MEDIUM
+        self.set_speed(speed)
+
+    def turn_off(self):
+        """Turn off the entity."""
+        self.set_speed(STATE_OFF)
+
+    def set_speed(self, speed):
+        """Set the speed of the fan."""
+        channels_off = []
+        channels_on = []
+        if speed == STATE_OFF:
+            channels_off = self._channels
+        elif speed == SPEED_LOW:
+            channels_off = [self._channel_medium, self._channel_high]
+            channels_on = [self._channel_low]
+        elif speed == SPEED_MEDIUM:
+            channels_off = [self._channel_high]
+            channels_on = [self._channel_low, self._channel_medium]
+        elif speed == SPEED_HIGH:
+            channels_off = [self._channel_medium]
+            channels_on = [self._channel_low, self._channel_high]
+        for channel in channels_off:
+            self._relay_off(channel)
+        for channel in channels_on:
+            self._relay_on(channel)
+        self.schedule_update_ha_state()
+
+    def _relay_on(self, channel):
+        import velbus
+        message = velbus.SwitchRelayOnMessage()
+        message.set_defaults(self._module)
+        message.relay_channels = [channel]
+        self._velbus.send(message)
+
+    def _relay_off(self, channel):
+        import velbus
+        message = velbus.SwitchRelayOffMessage()
+        message.set_defaults(self._module)
+        message.relay_channels = [channel]
+        self._velbus.send(message)
+
+    def get_status(self):
+        """Retrieve current status."""
+        import velbus
+        message = velbus.ModuleStatusRequestMessage()
+        message.set_defaults(self._module)
+        message.channels = self._channels
+        self._velbus.send(message)
+
+    @property
+    def supported_features(self):
+        """Flag supported features."""
+        return SUPPORT_SET_SPEED

homeassistant/components/fan/wink.py

@@ -9,7 +9,8 @@ import logging
 
 from homeassistant.components.fan import (FanEntity, SPEED_HIGH,
                                           SPEED_LOW, SPEED_MEDIUM,
-                                          STATE_UNKNOWN)
+                                          STATE_UNKNOWN, SUPPORT_SET_SPEED,
+                                          SUPPORT_DIRECTION)
 from homeassistant.helpers.entity import ToggleEntity
 from homeassistant.components.wink import WinkDevice, DOMAIN
 
@@ -20,6 +21,8 @@ _LOGGER = logging.getLogger(__name__)
 SPEED_LOWEST = 'lowest'
 SPEED_AUTO = 'auto'
 
+SUPPORTED_FEATURES = SUPPORT_DIRECTION + SUPPORT_SET_SPEED
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Wink platform."""
@@ -44,11 +47,11 @@ class WinkFanDevice(WinkDevice, FanEntity):
 
     def set_speed(self: ToggleEntity, speed: str) -> None:
         """Set the speed of the fan."""
-        self.wink.set_fan_speed(speed)
+        self.wink.set_state(True, speed)
 
     def turn_on(self: ToggleEntity, speed: str=None, **kwargs) -> None:
         """Turn on the fan."""
-        self.wink.set_state(True)
+        self.wink.set_state(True, speed)
 
     def turn_off(self: ToggleEntity, **kwargs) -> None:
         """Turn off the fan."""
@@ -96,3 +99,8 @@ class WinkFanDevice(WinkDevice, FanEntity):
         if SPEED_HIGH in wink_supported_speeds:
             supported_speeds.append(SPEED_HIGH)
         return supported_speeds
+
+    @property
+    def supported_features(self: ToggleEntity) -> int:
+        """Flag supported features."""
+        return SUPPORTED_FEATURES

homeassistant/components/frontend/__init__.py

@@ -12,6 +12,7 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.config import find_config_file, load_yaml_config_file
 from homeassistant.const import CONF_NAME, EVENT_THEMES_UPDATED
 from homeassistant.core import callback
+from homeassistant.loader import bind_hass
 from homeassistant.components import api
 from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.http.auth import is_trusted_ip
@@ -75,6 +76,7 @@ SERVICE_SET_THEME_SCHEMA = vol.Schema({
 })
 
 
+@bind_hass
 def register_built_in_panel(hass, component_name, sidebar_title=None,
                             sidebar_icon=None, url_path=None, config=None):
     """Register a built-in panel."""
@@ -96,6 +98,7 @@ def register_built_in_panel(hass, component_name, sidebar_title=None,
                    sidebar_icon, url_path, url, config)
 
 
+@bind_hass
 def register_panel(hass, component_name, path, md5=None, sidebar_title=None,
                    sidebar_icon=None, url_path=None, url=None, config=None):
     """Register a panel for the frontend.

homeassistant/components/frontend/version.py

@@ -3,21 +3,22 @@
 FINGERPRINTS = {
     "compatibility.js": "8e4c44b5f4288cc48ec1ba94a9bec812",
     "core.js": "d4a7cb8c80c62b536764e0e81385f6aa",
-    "frontend.html": "a7d4cb8260e8094342b5bd8c36c4bf5b",
+    "frontend.html": "7d599996578579600f1000d6d25e649d",
     "mdi.html": "e91f61a039ed0a9936e7ee5360da3870",
     "micromarkdown-js.html": "93b5ec4016f0bba585521cf4d18dec1a",
-    "panels/ha-panel-automation.html": "72a5c1856cece8d9246328e84185ab0b",
-    "panels/ha-panel-config.html": "76853de505d173e82249bf605eb73505",
-    "panels/ha-panel-dev-event.html": "4886c821235492b1b92739b580d21c61",
+    "panels/ha-panel-automation.html": "1982116c49ad26ee8d89295edc797084",
+    "panels/ha-panel-config.html": "fafeac72f83dd6cc42218f8978f6a7af",
+    "panels/ha-panel-dev-event.html": "77784d5f0c73fcc3b29b6cc050bdf324",
     "panels/ha-panel-dev-info.html": "24e888ec7a8acd0c395b34396e9001bc",
-    "panels/ha-panel-dev-service.html": "ac2c50e486927dc4443e93d79f08c06e",
-    "panels/ha-panel-dev-state.html": "8f1a27c04db6329d31cfcc7d0d6a0869",
-    "panels/ha-panel-dev-template.html": "82cd543177c417e5c6612e07df851e6b",
+    "panels/ha-panel-dev-service.html": "86a42a17f4894478b6b77bc636beafd0",
+    "panels/ha-panel-dev-state.html": "31ef6ffe3347cdda5bb0cbbc54b62cde",
+    "panels/ha-panel-dev-template.html": "d1d76e20fe9622cddee33e67318abde8",
     "panels/ha-panel-hassio.html": "262d31efd9add719e0325da5cf79a096",
     "panels/ha-panel-history.html": "35177e2046c9a4191c8f51f8160255ce",
-    "panels/ha-panel-iframe.html": "d920f0aa3c903680f2f8795e2255daab",
+    "panels/ha-panel-iframe.html": "238189f21e670b6dcfac937e5ebd7d3b",
     "panels/ha-panel-kiosk.html": "2ac2df41bd447600692a0054892fc094",
     "panels/ha-panel-logbook.html": "7c45bd41c146ec38b9938b8a5188bb0d",
-    "panels/ha-panel-map.html": "d3dae1400ec4e4cd7681d2aa79131d55",
-    "panels/ha-panel-zwave.html": "2ea2223339d1d2faff478751c2927d11"
+    "panels/ha-panel-map.html": "50501cd53eb4304e9e46eb719aa894b7",
+    "panels/ha-panel-shopping-list.html": "1d7126efc9ff9a102df7465d803a11d1",
+    "panels/ha-panel-zwave.html": "422f95f820f8b6b231265351ffcf4dd1"
 }

homeassistant/components/frontend/www_static/panels/ha-panel-iframe.html

@@ -1 +1 @@
-<html><head><meta charset="UTF-8"></head><body><dom-module id="ha-panel-iframe"><template><style include="ha-style">iframe{border:0;width:100%;height:calc(100% - 64px)}</style><app-toolbar><ha-menu-button narrow="[[narrow]]" show-menu="[[showMenu]]"></ha-menu-button><div main-title="">[[panel.title]]</div></app-toolbar><iframe src="[[panel.config.url]]" sandbox="allow-forms allow-popups allow-pointer-lock allow-same-origin allow-scripts"></iframe></template></dom-module><script>Polymer({is:"ha-panel-iframe",properties:{panel:{type:Object},narrow:{type:Boolean},showMenu:{type:Boolean}}})</script></body></html>
+<html><head><meta charset="UTF-8"></head><body><dom-module id="ha-panel-iframe"><template><style include="ha-style">iframe{border:0;width:100%;height:calc(100% - 64px)}</style><app-toolbar><ha-menu-button narrow="[[narrow]]" show-menu="[[showMenu]]"></ha-menu-button><div main-title="">[[panel.title]]</div></app-toolbar><iframe src="[[panel.config.url]]" sandbox="allow-forms allow-popups allow-pointer-lock allow-same-origin allow-scripts" allowfullscreen="true" webkitallowfullscreen="true" mozallowfullscreen="true"></iframe></template></dom-module><script>Polymer({is:"ha-panel-iframe",properties:{panel:{type:Object},narrow:{type:Boolean},showMenu:{type:Boolean}}})</script></body></html>

homeassistant/components/google.py

@@ -17,7 +17,6 @@ import voluptuous as vol
 from voluptuous.error import Error as VoluptuousError
 
 import homeassistant.helpers.config_validation as cv
-import homeassistant.loader as loader
 from homeassistant.setup import setup_component
 from homeassistant.helpers import discovery
 from homeassistant.helpers.entity import generate_entity_id
@@ -106,32 +105,31 @@ def do_authentication(hass, config):
         'Home-Assistant.io',
     )
 
-    persistent_notification = loader.get_component('persistent_notification')
     try:
         dev_flow = oauth.step1_get_device_and_user_codes()
     except OAuth2DeviceCodeError as err:
-        persistent_notification.create(
-            hass, 'Error: {}<br />You will need to restart hass after fixing.'
-                  ''.format(err),
+        hass.components.persistent_notification.create(
+            'Error: {}<br />You will need to restart hass after fixing.'
+            ''.format(err),
             title=NOTIFICATION_TITLE,
             notification_id=NOTIFICATION_ID)
         return False
 
-    persistent_notification.create(
-        hass, 'In order to authorize Home-Assistant to view your calendars '
-              'you must visit: <a href="{}" target="_blank">{}</a> and enter '
-              'code: {}'.format(dev_flow.verification_url,
-                                dev_flow.verification_url,
-                                dev_flow.user_code),
+    hass.components.persistent_notification.create(
+        'In order to authorize Home-Assistant to view your calendars '
+        'you must visit: <a href="{}" target="_blank">{}</a> and enter '
+        'code: {}'.format(dev_flow.verification_url,
+                          dev_flow.verification_url,
+                          dev_flow.user_code),
         title=NOTIFICATION_TITLE, notification_id=NOTIFICATION_ID
     )
 
     def step2_exchange(now):
         """Keep trying to validate the user_code until it expires."""
         if now >= dt.as_local(dev_flow.user_code_expiry):
-            persistent_notification.create(
-                hass, 'Authenication code expired, please restart '
-                      'Home-Assistant and try again',
+            hass.components.persistent_notification.create(
+                'Authenication code expired, please restart '
+                'Home-Assistant and try again',
                 title=NOTIFICATION_TITLE,
                 notification_id=NOTIFICATION_ID)
             listener()
@@ -146,9 +144,9 @@ def do_authentication(hass, config):
         storage.put(credentials)
         do_setup(hass, config)
         listener()
-        persistent_notification.create(
-            hass, 'We are all setup now. Check {} for calendars that have '
-                  'been found'.format(YAML_DEVICES),
+        hass.components.persistent_notification.create(
+            'We are all setup now. Check {} for calendars that have '
+            'been found'.format(YAML_DEVICES),
             title=NOTIFICATION_TITLE, notification_id=NOTIFICATION_ID)
 
     listener = track_time_change(hass, step2_exchange,

homeassistant/components/group.py

@@ -17,6 +17,7 @@ from homeassistant.const import (
     STATE_UNLOCKED, STATE_OK, STATE_PROBLEM, STATE_UNKNOWN,
     ATTR_ASSUMED_STATE, SERVICE_RELOAD)
 from homeassistant.core import callback
+from homeassistant.loader import bind_hass
 from homeassistant.helpers.entity import Entity, async_generate_entity_id
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.event import async_track_state_change
@@ -108,6 +109,7 @@ def _get_group_on_off(state):
     return None, None
 
 
+@bind_hass
 def is_on(hass, entity_id):
     """Test if the group state is in its ON-state."""
     state = hass.states.get(entity_id)
@@ -121,23 +123,27 @@ def is_on(hass, entity_id):
     return False
 
 
+@bind_hass
 def reload(hass):
     """Reload the automation from config."""
     hass.add_job(async_reload, hass)
 
 
 @callback
+@bind_hass
 def async_reload(hass):
     """Reload the automation from config."""
     hass.async_add_job(hass.services.async_call(DOMAIN, SERVICE_RELOAD))
 
 
+@bind_hass
 def set_visibility(hass, entity_id=None, visible=True):
     """Hide or shows a group."""
     data = {ATTR_ENTITY_ID: entity_id, ATTR_VISIBLE: visible}
     hass.services.call(DOMAIN, SERVICE_SET_VISIBILITY, data)
 
 
+@bind_hass
 def set_group(hass, object_id, name=None, entity_ids=None, visible=None,
               icon=None, view=None, control=None, add=None):
     """Create a new user group."""
@@ -147,6 +153,7 @@ def set_group(hass, object_id, name=None, entity_ids=None, visible=None,
 
 
 @callback
+@bind_hass
 def async_set_group(hass, object_id, name=None, entity_ids=None, visible=None,
                     icon=None, view=None, control=None, add=None):
     """Create a new user group."""
@@ -166,18 +173,21 @@ def async_set_group(hass, object_id, name=None, entity_ids=None, visible=None,
     hass.async_add_job(hass.services.async_call(DOMAIN, SERVICE_SET, data))
 
 
+@bind_hass
 def remove(hass, name):
     """Remove a user group."""
     hass.add_job(async_remove, hass, name)
 
 
 @callback
+@bind_hass
 def async_remove(hass, object_id):
     """Remove a user group."""
     data = {ATTR_OBJECT_ID: object_id}
     hass.async_add_job(hass.services.async_call(DOMAIN, SERVICE_REMOVE, data))
 
 
+@bind_hass
 def expand_entity_ids(hass, entity_ids):
     """Return entity_ids with group entity ids replaced by their members.
 
@@ -215,6 +225,7 @@ def expand_entity_ids(hass, entity_ids):
     return found_ids
 
 
+@bind_hass
 def get_entity_ids(hass, entity_id, domain_filter=None):
     """Get members of this group.
 

homeassistant/components/hassio.py

@@ -25,8 +25,15 @@ _LOGGER = logging.getLogger(__name__)
 DOMAIN = 'hassio'
 DEPENDENCIES = ['http']
 
-TIMEOUT = 10
-NO_TIMEOUT = set(['homeassistant/update', 'host/update', 'supervisor/update'])
+NO_TIMEOUT = {
+    re.compile(r'^homeassistant/update$'), re.compile(r'^host/update$'),
+    re.compile(r'^supervisor/update$'), re.compile(r'^addons/[^/]*/update$'),
+    re.compile(r'^addons/[^/]*/install$')
+}
+
+NO_AUTH = {
+    re.compile(r'^panel$'), re.compile(r'^addons/[^/]*/logo$')
+}
 
 
 @asyncio.coroutine
@@ -71,7 +78,7 @@ class HassIO(object):
         This method is a coroutine.
         """
         try:
-            with async_timeout.timeout(TIMEOUT, loop=self.loop):
+            with async_timeout.timeout(10, loop=self.loop):
                 request = yield from self.websession.get(
                     "http://{}{}".format(self._ip, "/supervisor/ping")
                 )
@@ -97,12 +104,12 @@ class HassIO(object):
 
         This method is a coroutine.
         """
-        read_timeout = 0 if path in NO_TIMEOUT else 300
+        read_timeout = _get_timeout(path)
 
         try:
             data = None
             headers = None
-            with async_timeout.timeout(TIMEOUT, loop=self.loop):
+            with async_timeout.timeout(10, loop=self.loop):
                 data = yield from request.read()
                 if data:
                     headers = {CONTENT_TYPE: request.content_type}
@@ -140,7 +147,7 @@ class HassIOView(HomeAssistantView):
     @asyncio.coroutine
     def _handle(self, request, path):
         """Route data to hassio."""
-        if path != 'panel' and not request[KEY_AUTHENTICATED]:
+        if _need_auth(path) and not request[KEY_AUTHENTICATED]:
             return web.Response(status=401)
 
         client = yield from self.hassio.command_proxy(path, request)
@@ -173,3 +180,19 @@ def _create_response_log(client, data):
         status=client.status,
         content_type=CONTENT_TYPE_TEXT_PLAIN,
     )
+
+
+def _get_timeout(path):
+    """Return timeout for a url path."""
+    for re_path in NO_TIMEOUT:
+        if re_path.match(path):
+            return 0
+    return 300
+
+
+def _need_auth(path):
+    """Return if a path need a auth."""
+    for re_path in NO_AUTH:
+        if re_path.match(path):
+            return False
+    return True

homeassistant/components/history.py

@@ -119,19 +119,42 @@ def get_states(hass, utc_point_in_time, entity_ids=None, run=None,
     from sqlalchemy import and_, func
 
     with session_scope(hass=hass) as session:
-        most_recent_state_ids = session.query(
-            func.max(States.state_id).label('max_state_id')
-        ).filter(
-            (States.created >= run.start) &
-            (States.created < utc_point_in_time) &
-            (~States.domain.in_(IGNORE_DOMAINS)))
+        if entity_ids and len(entity_ids) == 1:
+            # Use an entirely different (and extremely fast) query if we only
+            # have a single entity id
+            most_recent_state_ids = session.query(
+                States.state_id.label('max_state_id')
+            ).filter(
+                (States.created < utc_point_in_time) &
+                (States.entity_id.in_(entity_ids))
+            ).order_by(
+                States.created.desc())
 
-        if filters:
-            most_recent_state_ids = filters.apply(most_recent_state_ids,
-                                                  entity_ids)
+            if filters:
+                most_recent_state_ids = filters.apply(most_recent_state_ids,
+                                                      entity_ids)
 
-        most_recent_state_ids = most_recent_state_ids.group_by(
-            States.entity_id).subquery()
+            most_recent_state_ids = most_recent_state_ids.limit(1)
+
+        else:
+            # We have more than one entity to look at (most commonly we want
+            # all entities,) so we need to do a search on all states since the
+            # last recorder run started.
+            most_recent_state_ids = session.query(
+                func.max(States.state_id).label('max_state_id')
+            ).filter(
+                (States.created >= run.start) &
+                (States.created < utc_point_in_time) &
+                (~States.domain.in_(IGNORE_DOMAINS)))
+
+            if filters:
+                most_recent_state_ids = filters.apply(most_recent_state_ids,
+                                                      entity_ids)
+
+            most_recent_state_ids = most_recent_state_ids.group_by(
+                States.entity_id)
+
+        most_recent_state_ids = most_recent_state_ids.subquery()
 
         query = session.query(States).join(most_recent_state_ids, and_(
             States.state_id == most_recent_state_ids.c.max_state_id))