Merge pull request #8919 from home-assistant/release-0-51

0.51

.coveragerc

@@ -29,6 +29,9 @@ omit =
     homeassistant/components/arlo.py
     homeassistant/components/*/arlo.py
 
+    homeassistant/components/asterisk_mbox.py
+    homeassistant/components/*/asterisk_mbox.py
+
     homeassistant/components/axis.py
     homeassistant/components/*/axis.py
 
@@ -173,6 +176,9 @@ omit =
     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 +199,13 @@ omit =
     homeassistant/components/wink.py
     homeassistant/components/*/wink.py
 
+    homeassistant/components/xiaomi.py
+    homeassistant/components/binary_sensor/xiaomi.py
+    homeassistant/components/cover/xiaomi.py
+    homeassistant/components/light/xiaomi.py
+    homeassistant/components/sensor/xiaomi.py
+    homeassistant/components/switch/xiaomi.py
+
     homeassistant/components/zabbix.py
     homeassistant/components/*/zabbix.py
 
@@ -208,6 +221,8 @@ omit =
 
     homeassistant/components/alarm_control_panel/alarmdotcom.py
     homeassistant/components/alarm_control_panel/concord232.py
+    homeassistant/components/alarm_control_panel/egardia.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
@@ -257,6 +272,7 @@ omit =
     homeassistant/components/device_tracker/cisco_ios.py
     homeassistant/components/device_tracker/fritz.py
     homeassistant/components/device_tracker/gpslogger.py
+    homeassistant/components/device_tracker/huawei_router.py
     homeassistant/components/device_tracker/icloud.py
     homeassistant/components/device_tracker/linksys_ap.py
     homeassistant/components/device_tracker/linksys_smart.py
@@ -274,7 +290,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
@@ -291,6 +306,7 @@ omit =
     homeassistant/components/light/blinkt.py
     homeassistant/components/light/blinksticklight.py
     homeassistant/components/light/decora.py
+    homeassistant/components/light/decora_wifi.py
     homeassistant/components/light/flux_led.py
     homeassistant/components/light/hue.py
     homeassistant/components/light/hyperion.py
@@ -303,6 +319,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
@@ -315,6 +332,7 @@ omit =
     homeassistant/components/media_extractor.py
     homeassistant/components/media_player/anthemav.py
     homeassistant/components/media_player/aquostv.py
+    homeassistant/components/media_player/bluesound.py
     homeassistant/components/media_player/braviatv.py
     homeassistant/components/media_player/cast.py
     homeassistant/components/media_player/clementine.py
@@ -344,6 +362,7 @@ omit =
     homeassistant/components/media_player/pioneer.py
     homeassistant/components/media_player/plex.py
     homeassistant/components/media_player/roku.py
+    homeassistant/components/media_player/russound_rio.py
     homeassistant/components/media_player/russound_rnet.py
     homeassistant/components/media_player/samsungtv.py
     homeassistant/components/media_player/snapcast.py
@@ -430,6 +449,7 @@ omit =
     homeassistant/components/sensor/fixer.py
     homeassistant/components/sensor/fritzbox_callmonitor.py
     homeassistant/components/sensor/fritzbox_netmonitor.py
+    homeassistant/components/sensor/geizhals.py
     homeassistant/components/sensor/gitter.py
     homeassistant/components/sensor/glances.py
     homeassistant/components/sensor/google_travel_time.py
@@ -476,6 +496,7 @@ omit =
     homeassistant/components/sensor/scrape.py
     homeassistant/components/sensor/sensehat.py
     homeassistant/components/sensor/serial_pm.py
+    homeassistant/components/sensor/shodan.py
     homeassistant/components/sensor/skybeacon.py
     homeassistant/components/sensor/sma.py
     homeassistant/components/sensor/snmp.py
@@ -520,17 +541,18 @@ omit =
     homeassistant/components/switch/orvibo.py
     homeassistant/components/switch/pilight.py
     homeassistant/components/switch/pulseaudio_loopback.py
+    homeassistant/components/switch/rainmachine.py
     homeassistant/components/switch/rest.py
     homeassistant/components/switch/rpi_rf.py
     homeassistant/components/switch/tplink.py
     homeassistant/components/switch/transmission.py
     homeassistant/components/switch/wake_on_lan.py
-    homeassistant/components/switch/xiaomi_vacuum.py
     homeassistant/components/telegram_bot/*
     homeassistant/components/thingspeak.py
     homeassistant/components/tts/amazon_polly.py
     homeassistant/components/tts/picotts.py
     homeassistant/components/upnp.py
+    homeassistant/components/vacuum/roomba.py
     homeassistant/components/weather/bom.py
     homeassistant/components/weather/buienradar.py
     homeassistant/components/weather/metoffice.py

.gitignore

@@ -73,6 +73,7 @@ pyvenv.cfg
 pip-selfcheck.json
 venv
 .venv
+Pipfile*
 
 # vimmy stuff
 *.swp

CONTRIBUTING.md

@@ -4,11 +4,11 @@ Everybody is invited and welcome to contribute to Home Assistant. There is a lot
 
 The process is straight-forward.
 
- - Read [How to get faster PR reviews](https://github.com/kubernetes/community/blob/master/contributors/devel/faster_reviews.md) by Kubernetes (but skip step 0)
+ - Read [How to get faster PR reviews](https://github.com/kubernetes/community/blob/master/contributors/devel/pull-requests.md#best-practices-for-faster-reviews) by Kubernetes (but skip step 0)
  - Fork the Home Assistant [git repository](https://github.com/home-assistant/home-assistant).
  - Write the code for your device, notification service, sensor, or IoT thing.
  - Ensure tests work.
  - Create a Pull Request against the [**dev**](https://github.com/home-assistant/home-assistant/tree/dev) branch of Home Assistant.
 
-Still interested? Then you should take a peak at the [developer documentation](https://home-assistant.io/developers/) to get more details.
+Still interested? Then you should take a peek at the [developer documentation](https://home-assistant.io/developers/) to get more details.
 

Dockerfile

@@ -29,8 +29,7 @@ COPY requirements_all.txt requirements_all.txt
 # Uninstall enum34 because some depenndecies install it but breaks Python 3.4+.
 # See PR #8103 for more info.
 RUN pip3 install --no-cache-dir -r requirements_all.txt && \
-    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop cchardet && \
-    pip3 uninstall -y enum34
+    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop cchardet
 
 # Copy source
 COPY . .

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/egardia.py

@@ -0,0 +1,182 @@
+"""
+Interfaces with Egardia/Woonveilig alarm control panel.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.egardia/
+"""
+import logging
+
+import requests
+import voluptuous as vol
+
+import homeassistant.components.alarm_control_panel as alarm
+import homeassistant.exceptions as exc
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.alarm_control_panel import PLATFORM_SCHEMA
+from homeassistant.const import (
+    CONF_PORT, CONF_HOST, CONF_PASSWORD, CONF_USERNAME, STATE_UNKNOWN,
+    CONF_NAME, STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME,
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_TRIGGERED)
+
+REQUIREMENTS = ['pythonegardia==1.0.17']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_REPORT_SERVER_CODES = 'report_server_codes'
+CONF_REPORT_SERVER_ENABLED = 'report_server_enabled'
+CONF_REPORT_SERVER_PORT = 'report_server_port'
+
+DEFAULT_NAME = 'Egardia'
+DEFAULT_PORT = 80
+DEFAULT_REPORT_SERVER_ENABLED = False
+DEFAULT_REPORT_SERVER_PORT = 85
+DOMAIN = 'egardia'
+
+NOTIFICATION_ID = 'egardia_notification'
+NOTIFICATION_TITLE = 'Egardia'
+
+STATES = {
+    'ARM': STATE_ALARM_ARMED_AWAY,
+    'DAY HOME': STATE_ALARM_ARMED_HOME,
+    'DISARM': STATE_ALARM_DISARMED,
+    'HOME': STATE_ALARM_ARMED_HOME,
+    'TRIGGERED': STATE_ALARM_TRIGGERED,
+    'UNKNOWN': STATE_UNKNOWN,
+}
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_REPORT_SERVER_CODES): vol.All(cv.ensure_list),
+    vol.Optional(CONF_REPORT_SERVER_ENABLED,
+                 default=DEFAULT_REPORT_SERVER_ENABLED): cv.boolean,
+    vol.Optional(CONF_REPORT_SERVER_PORT, default=DEFAULT_REPORT_SERVER_PORT):
+        cv.port,
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Egardia platform."""
+    from pythonegardia import egardiadevice
+
+    name = config.get(CONF_NAME)
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    rs_enabled = config.get(CONF_REPORT_SERVER_ENABLED)
+    rs_port = config.get(CONF_REPORT_SERVER_PORT)
+    rs_codes = config.get(CONF_REPORT_SERVER_CODES)
+
+    try:
+        egardiasystem = egardiadevice.EgardiaDevice(
+            host, port, username, password, '')
+    except requests.exceptions.RequestException:
+        raise exc.PlatformNotReady()
+    except egardiadevice.UnauthorizedError:
+        _LOGGER.error("Unable to authorize. Wrong password or username")
+        return False
+
+    add_devices([EgardiaAlarm(
+        name, egardiasystem, hass, rs_enabled, rs_port, rs_codes)], True)
+
+
+class EgardiaAlarm(alarm.AlarmControlPanel):
+    """Representation of a Egardia alarm."""
+
+    def __init__(self, name, egardiasystem, hass, rs_enabled=False,
+                 rs_port=None, rs_codes=None):
+        """Initialize object."""
+        self._name = name
+        self._egardiasystem = egardiasystem
+        self._status = STATE_UNKNOWN
+        self._rs_enabled = rs_enabled
+        self._rs_port = rs_port
+        self._hass = hass
+
+        if rs_codes is not None:
+            self._rs_codes = rs_codes[0]
+        else:
+            self._rs_codes = rs_codes
+
+        if self._rs_enabled:
+            self.listen_to_system_status()
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._status
+
+    def handle_system_status_event(self, event):
+        """Handle egardia_system_status_event."""
+        if event.data.get('status') is not None:
+            statuscode = event.data.get('status')
+            status = self.lookupstatusfromcode(statuscode)
+            self.parsestatus(status)
+
+    def listen_to_system_status(self):
+        """Subscribe to egardia_system_status event."""
+        self._hass.bus.listen(
+            'egardia_system_status', self.handle_system_status_event)
+
+    def lookupstatusfromcode(self, statuscode):
+        """Look at the rs_codes and returns the status from the code."""
+        status = 'UNKNOWN'
+        if self._rs_codes is not None:
+            statuscode = str(statuscode).strip()
+            for i in self._rs_codes:
+                val = str(self._rs_codes[i]).strip()
+                if ',' in val:
+                    splitted = val.split(',')
+                    for code in splitted:
+                        code = str(code).strip()
+                        if statuscode == code:
+                            status = i.upper()
+                            break
+                elif statuscode == val:
+                    status = i.upper()
+                    break
+        return status
+
+    def parsestatus(self, status):
+        """Parse the status."""
+        newstatus = ([v for k, v in STATES.items()
+                      if status.upper() == k][0])
+        self._status = newstatus
+
+    def update(self):
+        """Update the alarm status."""
+        status = self._egardiasystem.getstate()
+        self.parsestatus(status)
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        try:
+            self._egardiasystem.alarm_disarm()
+        except requests.exceptions.RequestException as err:
+            _LOGGER.error("Egardia device exception occurred when "
+                          "sending disarm command: %s", err)
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        try:
+            self._egardiasystem.alarm_arm_home()
+        except requests.exceptions.RequestException as err:
+            _LOGGER.error("Egardia device exception occurred when "
+                          "sending arm home command: %s", err)
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        try:
+            self._egardiasystem.alarm_arm_away()
+        except requests.exceptions.RequestException as err:
+            _LOGGER.error("Egardia device exception occurred when "
+                          "sending arm away command: %s", err)

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.4']
 
 _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,53 +125,61 @@ 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(
-                SpeechType.plaintext,
-                "Hello, and welcome to the future. How may I help?")
-            return self.json(response)
-
-        if req_type != 'IntentRequest':
+        if req_type != 'IntentRequest' and req_type != 'LaunchRequest':
             _LOGGER.warning('Received unsupported request: %s', req_type)
             return self.json_message(
                 'Received unsupported request: {}'.format(req_type),
                 HTTP_BAD_REQUEST)
 
-        intent_name = intent['name']
-        config = self.intents.get(intent_name)
+        if req_type == 'LaunchRequest':
+            intent_name = data.get('session', {})       \
+                              .get('application', {})   \
+                              .get('applicationId')
+        else:
+            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 +188,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 +207,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 +217,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 +257,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/asterisk_mbox.py

@@ -0,0 +1,82 @@
+"""Support for Asterisk Voicemail interface."""
+
+import logging
+
+import voluptuous as vol
+
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import discovery
+from homeassistant.const import (CONF_HOST,
+                                 CONF_PORT, CONF_PASSWORD)
+
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import (async_dispatcher_connect,
+                                              async_dispatcher_send)
+
+REQUIREMENTS = ['asterisk_mbox==0.4.0']
+
+SIGNAL_MESSAGE_UPDATE = 'asterisk_mbox.message_updated'
+SIGNAL_MESSAGE_REQUEST = 'asterisk_mbox.message_request'
+
+DOMAIN = 'asterisk_mbox'
+
+_LOGGER = logging.getLogger(__name__)
+
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_HOST): cv.string,
+        vol.Required(CONF_PORT): int,
+        vol.Required(CONF_PASSWORD): cv.string,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+def setup(hass, config):
+    """Set up for the Asterisk Voicemail box."""
+    conf = config.get(DOMAIN)
+
+    host = conf.get(CONF_HOST)
+    port = conf.get(CONF_PORT)
+    password = conf.get(CONF_PASSWORD)
+
+    hass.data[DOMAIN] = AsteriskData(hass, host, port, password)
+
+    discovery.load_platform(hass, "mailbox", DOMAIN, {}, config)
+
+    return True
+
+
+class AsteriskData(object):
+    """Store Asterisk mailbox data."""
+
+    def __init__(self, hass, host, port, password):
+        """Init the Asterisk data object."""
+        from asterisk_mbox import Client as asteriskClient
+
+        self.hass = hass
+        self.client = asteriskClient(host, port, password, self.handle_data)
+        self.messages = []
+
+        async_dispatcher_connect(
+            self.hass, SIGNAL_MESSAGE_REQUEST, self._request_messages)
+
+    @callback
+    def handle_data(self, command, msg):
+        """Handle changes to the mailbox."""
+        from asterisk_mbox.commands import CMD_MESSAGE_LIST
+
+        if command == CMD_MESSAGE_LIST:
+            _LOGGER.info("AsteriskVM sent updated message list")
+            self.messages = sorted(msg,
+                                   key=lambda item: item['info']['origtime'],
+                                   reverse=True)
+            async_dispatcher_send(self.hass, SIGNAL_MESSAGE_UPDATE,
+                                  self.messages)
+
+    @callback
+    def _request_messages(self):
+        """Handle changes to the mailbox."""
+        _LOGGER.info("Requesting message list")
+        self.client.messages()

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,
@@ -26,7 +27,6 @@ from homeassistant.helpers.restore_state import async_get_last_state
 from homeassistant.loader import get_platform
 from homeassistant.util.dt import utcnow
 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.frontend import register_built_in_panel
 
 DOMAIN = 'automation'
 DEPENDENCIES = ['group']
@@ -105,6 +105,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 +115,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.
 
@@ -224,10 +231,6 @@ def async_setup(hass, config):
             DOMAIN, service, turn_onoff_service_handler,
             descriptions.get(service), schema=SERVICE_SCHEMA)
 
-    if 'frontend' in hass.config.components:
-        register_built_in_panel(hass, 'automation', 'Automations',
-                                'mdi:playlist-play')
-
     return True
 
 

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/__init__.py

@@ -14,7 +14,6 @@ from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
 from homeassistant.const import (STATE_ON, STATE_OFF)
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
-from homeassistant.helpers.deprecation import deprecated_substitute
 
 DOMAIN = 'binary_sensor'
 SCAN_INTERVAL = timedelta(seconds=30)
@@ -66,7 +65,6 @@ class BinarySensorDevice(Entity):
         return STATE_ON if self.is_on else STATE_OFF
 
     @property
-    @deprecated_substitute('sensor_class')
     def device_class(self):
         """Return the class of this device, from component DEVICE_CLASSES."""
         return None

homeassistant/components/binary_sensor/apcupsd.py

@@ -20,9 +20,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })
 
 
-def setup_platform(hass, config, add_entities, discovery_info=None):
-    """Set up an Online Status binary sensor."""
-    add_entities((OnlineStatus(config, apcupsd.DATA),))
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up an APCUPSd Online Status binary sensor."""
+    add_devices([OnlineStatus(config, apcupsd.DATA)], True)
 
 
 class OnlineStatus(BinarySensorDevice):
@@ -33,7 +33,6 @@ class OnlineStatus(BinarySensorDevice):
         self._config = config
         self._data = data
         self._state = None
-        self.update()
 
     @property
     def name(self):

homeassistant/components/binary_sensor/arest.py

@@ -13,10 +13,9 @@ import voluptuous as vol
 from homeassistant.components.binary_sensor import (
     BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    CONF_RESOURCE, CONF_PIN, CONF_NAME, CONF_SENSOR_CLASS, CONF_DEVICE_CLASS)
+    CONF_RESOURCE, CONF_PIN, CONF_NAME, CONF_DEVICE_CLASS)
 from homeassistant.util import Throttle
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -26,7 +25,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_RESOURCE): cv.url,
     vol.Optional(CONF_NAME): cv.string,
     vol.Required(CONF_PIN): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })
 
@@ -35,7 +33,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the aREST binary sensor."""
     resource = config.get(CONF_RESOURCE)
     pin = config.get(CONF_PIN)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)
 
     try:
         response = requests.get(resource, timeout=10).json()

homeassistant/components/binary_sensor/bloomsky.py

@@ -37,7 +37,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     for device in bloomsky.BLOOMSKY.devices.values():
         for variable in sensors:
-            add_devices([BloomSkySensor(bloomsky.BLOOMSKY, device, variable)])
+            add_devices(
+                [BloomSkySensor(bloomsky.BLOOMSKY, device, variable)], True)
 
 
 class BloomSkySensor(BinarySensorDevice):
@@ -50,7 +51,7 @@ class BloomSkySensor(BinarySensorDevice):
         self._sensor_name = sensor_name
         self._name = '{} {}'.format(device['DeviceName'], sensor_name)
         self._unique_id = 'bloomsky_binary_sensor {}'.format(self._name)
-        self.update()
+        self._state = None
 
     @property
     def name(self):

homeassistant/components/binary_sensor/command_line.py

@@ -4,19 +4,18 @@ Support for custom shell commands to retrieve values.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.command_line/
 """
-from datetime import timedelta
 import logging
+from datetime import timedelta
 
 import voluptuous as vol
 
+import homeassistant.helpers.config_validation as cv
 from homeassistant.components.binary_sensor import (
     BinarySensorDevice, DEVICE_CLASSES_SCHEMA, PLATFORM_SCHEMA)
 from homeassistant.components.sensor.command_line import CommandSensorData
 from homeassistant.const import (
     CONF_PAYLOAD_OFF, CONF_PAYLOAD_ON, CONF_NAME, CONF_VALUE_TEMPLATE,
-    CONF_SENSOR_CLASS, CONF_COMMAND, CONF_DEVICE_CLASS)
-import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated
+    CONF_COMMAND, CONF_DEVICE_CLASS)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -31,7 +30,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string,
     vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
 })
@@ -44,15 +42,15 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     command = config.get(CONF_COMMAND)
     payload_off = config.get(CONF_PAYLOAD_OFF)
     payload_on = config.get(CONF_PAYLOAD_ON)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)
     value_template = config.get(CONF_VALUE_TEMPLATE)
     if value_template is not None:
         value_template.hass = hass
-    data = CommandSensorData(command)
+    data = CommandSensorData(hass, command)
 
     add_devices([CommandBinarySensor(
         hass, data, name, device_class, payload_on, payload_off,
-        value_template)])
+        value_template)], True)
 
 
 class CommandBinarySensor(BinarySensorDevice):
@@ -69,7 +67,6 @@ class CommandBinarySensor(BinarySensorDevice):
         self._payload_on = payload_on
         self._payload_off = payload_off
         self._value_template = value_template
-        self.update()
 
     @property
     def name(self):

homeassistant/components/binary_sensor/concord232.py

@@ -72,9 +72,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 )
             )
 
-        add_devices(sensors)
-
-    return True
+        add_devices(sensors, True)
 
 
 def get_opening_type(zone):
@@ -100,7 +98,6 @@ class Concord232ZoneSensor(BinarySensorDevice):
         self._zone = zone
         self._number = zone['number']
         self._zone_type = zone_type
-        self.update()
 
     @property
     def device_class(self):
@@ -130,7 +127,7 @@ class Concord232ZoneSensor(BinarySensorDevice):
         if last_update > datetime.timedelta(seconds=1):
             self._client.zones = self._client.list_zones()
             self._client.last_zone_update = datetime.datetime.now()
-            _LOGGER.debug("Updated from Zone: %s", self._zone['name'])
+            _LOGGER.debug("Updated from zone: %s", self._zone['name'])
 
         if hasattr(self._client, 'zones'):
             self._zone = next((x for x in self._client.zones

homeassistant/components/binary_sensor/digital_ocean.py

@@ -19,7 +19,7 @@ from homeassistant.components.digital_ocean import (
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME = 'Droplet'
-DEFAULT_SENSOR_CLASS = 'moving'
+DEFAULT_DEVICE_CLASS = 'moving'
 DEPENDENCIES = ['digital_ocean']
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -69,7 +69,7 @@ class DigitalOceanBinarySensor(BinarySensorDevice):
     @property
     def device_class(self):
         """Return the class of this sensor."""
-        return DEFAULT_SENSOR_CLASS
+        return DEFAULT_DEVICE_CLASS
 
     @property
     def device_state_attributes(self):

homeassistant/components/binary_sensor/ecobee.py

@@ -26,7 +26,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
                 dev.append(EcobeeBinarySensor(sensor['name'], index))
 
-    add_devices(dev)
+    add_devices(dev, True)
 
 
 class EcobeeBinarySensor(BinarySensorDevice):
@@ -39,7 +39,6 @@ class EcobeeBinarySensor(BinarySensorDevice):
         self.index = sensor_index
         self._state = None
         self._device_class = 'occupancy'
-        self.update()
 
     @property
     def name(self):

homeassistant/components/binary_sensor/enocean.py

@@ -12,9 +12,8 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
 from homeassistant.components import enocean
 from homeassistant.const import (
-    CONF_NAME, CONF_ID, CONF_SENSOR_CLASS, CONF_DEVICE_CLASS)
+    CONF_NAME, CONF_ID, CONF_DEVICE_CLASS)
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -24,7 +23,6 @@ DEFAULT_NAME = 'EnOcean binary sensor'
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_ID): vol.All(cv.ensure_list, [vol.Coerce(int)]),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })
 
@@ -33,7 +31,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Binary Sensor platform for EnOcean."""
     dev_id = config.get(CONF_ID)
     devname = config.get(CONF_NAME)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)
 
     add_devices([EnOceanBinarySensor(dev_id, devname, device_class)])
 

homeassistant/components/binary_sensor/iss.py

@@ -64,7 +64,6 @@ class IssBinarySensor(BinarySensorDevice):
         self._state = None
         self._name = name
         self._show_on_map = show
-        self.update()
 
     @property
     def name(self):

homeassistant/components/binary_sensor/mqtt.py

@@ -15,10 +15,9 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDevice, DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
     CONF_NAME, CONF_VALUE_TEMPLATE, CONF_PAYLOAD_ON, CONF_PAYLOAD_OFF,
-    CONF_SENSOR_CLASS, CONF_DEVICE_CLASS)
+    CONF_DEVICE_CLASS)
 from homeassistant.components.mqtt import (CONF_STATE_TOPIC, CONF_QOS)
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -31,7 +30,6 @@ PLATFORM_SCHEMA = mqtt.MQTT_RO_PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string,
     vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })
 
@@ -49,7 +47,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     async_add_devices([MqttBinarySensor(
         config.get(CONF_NAME),
         config.get(CONF_STATE_TOPIC),
-        get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS),
+        config.get(CONF_DEVICE_CLASS),
         config.get(CONF_QOS),
         config.get(CONF_PAYLOAD_ON),
         config.get(CONF_PAYLOAD_OFF),

homeassistant/components/binary_sensor/netatmo.py

@@ -44,18 +44,19 @@ CONF_WELCOME_SENSORS = 'welcome_sensors'
 CONF_PRESENCE_SENSORS = 'presence_sensors'
 CONF_TAG_SENSORS = 'tag_sensors'
 
+DEFAULT_TIMEOUT = 15
+DEFAULT_OFFSET = 90
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_HOME): cv.string,
-    vol.Optional(CONF_TIMEOUT): cv.positive_int,
-    vol.Optional(CONF_OFFSET): cv.positive_int,
     vol.Optional(CONF_CAMERAS, default=[]):
         vol.All(cv.ensure_list, [cv.string]),
-    vol.Optional(
-        CONF_WELCOME_SENSORS, default=WELCOME_SENSOR_TYPES.keys()):
-        vol.All(cv.ensure_list, [vol.In(WELCOME_SENSOR_TYPES)]),
-    vol.Optional(
-        CONF_PRESENCE_SENSORS, default=PRESENCE_SENSOR_TYPES.keys()):
+    vol.Optional(CONF_HOME): cv.string,
+    vol.Optional(CONF_OFFSET, default=DEFAULT_OFFSET): cv.positive_int,
+    vol.Optional(CONF_PRESENCE_SENSORS, default=PRESENCE_SENSOR_TYPES):
         vol.All(cv.ensure_list, [vol.In(PRESENCE_SENSOR_TYPES)]),
+    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
+    vol.Optional(CONF_WELCOME_SENSORS, default=WELCOME_SENSOR_TYPES):
+        vol.All(cv.ensure_list, [vol.In(WELCOME_SENSOR_TYPES)]),
 })
 
 
@@ -63,16 +64,16 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the access to Netatmo binary sensor."""
     netatmo = get_component('netatmo')
-    home = config.get(CONF_HOME, None)
-    timeout = config.get(CONF_TIMEOUT, 15)
-    offset = config.get(CONF_OFFSET, 90)
+    home = config.get(CONF_HOME)
+    timeout = config.get(CONF_TIMEOUT)
+    offset = config.get(CONF_OFFSET)
 
     module_name = None
 
     import lnetatmo
     try:
         data = CameraData(netatmo.NETATMO_AUTH, home)
-        if data.get_camera_names() == []:
+        if not data.get_camera_names():
             return None
     except lnetatmo.NoDevice:
         return None
@@ -93,7 +94,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             for variable in welcome_sensors:
                 add_devices([NetatmoBinarySensor(
                     data, camera_name, module_name, home, timeout,
-                    offset, camera_type, variable)])
+                    offset, camera_type, variable)], True)
         if camera_type == 'NOC':
             if CONF_CAMERAS in config:
                 if config[CONF_CAMERAS] != [] and \
@@ -102,14 +103,14 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             for variable in presence_sensors:
                 add_devices([NetatmoBinarySensor(
                     data, camera_name, module_name, home, timeout, offset,
-                    camera_type, variable)])
+                    camera_type, variable)], True)
 
         for module_name in data.get_module_names(camera_name):
             for variable in tag_sensors:
                 camera_type = None
                 add_devices([NetatmoBinarySensor(
                     data, camera_name, module_name, home, timeout, offset,
-                    camera_type, variable)])
+                    camera_type, variable)], True)
 
 
 class NetatmoBinarySensor(BinarySensorDevice):
@@ -137,7 +138,7 @@ class NetatmoBinarySensor(BinarySensorDevice):
         self._unique_id = "Netatmo_binary_sensor {0} - {1}".format(
             self._name, camera_id)
         self._cameratype = camera_type
-        self.update()
+        self._state = None
 
     @property
     def name(self):

homeassistant/components/binary_sensor/octoprint.py

@@ -48,7 +48,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             name, SENSOR_TYPES[octo_type][3], SENSOR_TYPES[octo_type][0],
             SENSOR_TYPES[octo_type][1], 'flags')
         devices.append(new_sensor)
-    add_devices(devices)
+    add_devices(devices, True)
 
 
 class OctoPrintBinarySensor(BinarySensorDevice):
@@ -69,8 +69,6 @@ class OctoPrintBinarySensor(BinarySensorDevice):
         self.api_endpoint = endpoint
         self.api_group = group
         self.api_tool = tool
-        # Set initial state
-        self.update()
         _LOGGER.debug("Created OctoPrint binary sensor %r", self)
 
     @property

homeassistant/components/binary_sensor/ping.py

@@ -28,13 +28,16 @@ CONF_PING_COUNT = 'count'
 
 DEFAULT_NAME = 'Ping Binary sensor'
 DEFAULT_PING_COUNT = 5
-DEFAULT_SENSOR_CLASS = 'connectivity'
+DEFAULT_DEVICE_CLASS = 'connectivity'
 
 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')
 
@@ -70,7 +73,7 @@ class PingBinarySensor(BinarySensorDevice):
     @property
     def device_class(self):
         """Return the class of this sensor."""
-        return DEFAULT_SENSOR_CLASS
+        return DEFAULT_DEVICE_CLASS
 
     @property
     def is_on(self):
@@ -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

@@ -14,11 +14,10 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.components.sensor.rest import RestData
 from homeassistant.const import (
     CONF_PAYLOAD, CONF_NAME, CONF_VALUE_TEMPLATE, CONF_METHOD, CONF_RESOURCE,
-    CONF_SENSOR_CLASS, CONF_VERIFY_SSL, CONF_USERNAME, CONF_PASSWORD,
+    CONF_VERIFY_SSL, CONF_USERNAME, CONF_PASSWORD,
     CONF_HEADERS, CONF_AUTHENTICATION, HTTP_BASIC_AUTHENTICATION,
     HTTP_DIGEST_AUTHENTICATION, CONF_DEVICE_CLASS)
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -35,7 +34,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_PASSWORD): cv.string,
     vol.Optional(CONF_PAYLOAD): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_USERNAME): cv.string,
     vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
@@ -53,7 +51,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     username = config.get(CONF_USERNAME)
     password = config.get(CONF_PASSWORD)
     headers = config.get(CONF_HEADERS)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)
     value_template = config.get(CONF_VALUE_TEMPLATE)
     if value_template is not None:
         value_template.hass = hass
@@ -74,7 +72,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         return False
 
     add_devices([RestBinarySensor(
-        hass, rest, name, device_class, value_template)])
+        hass, rest, name, device_class, value_template)], True)
 
 
 class RestBinarySensor(BinarySensorDevice):
@@ -89,7 +87,6 @@ class RestBinarySensor(BinarySensorDevice):
         self._state = False
         self._previous_data = None
         self._value_template = value_template
-        self.update()
 
     @property
     def name(self):
@@ -107,6 +104,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/template.py

@@ -15,11 +15,9 @@ from homeassistant.components.binary_sensor import (
     DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
     ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_VALUE_TEMPLATE,
-    CONF_SENSOR_CLASS, CONF_SENSORS, CONF_DEVICE_CLASS,
-    EVENT_HOMEASSISTANT_START, STATE_ON)
+    CONF_SENSORS, CONF_DEVICE_CLASS, EVENT_HOMEASSISTANT_START, STATE_ON)
 from homeassistant.exceptions import TemplateError
 import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.deprecation import get_deprecated
 from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.event import async_track_state_change
 from homeassistant.helpers.restore_state import async_get_last_state
@@ -30,7 +28,6 @@ SENSOR_SCHEMA = vol.Schema({
     vol.Required(CONF_VALUE_TEMPLATE): cv.template,
     vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
     vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })
 
@@ -49,8 +46,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
         entity_ids = (device_config.get(ATTR_ENTITY_ID) or
                       value_template.extract_entities())
         friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
-        device_class = get_deprecated(
-            device_config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+        device_class = device_config.get(CONF_DEVICE_CLASS)
 
         if value_template is not None:
             value_template.hass = hass

homeassistant/components/binary_sensor/threshold.py

@@ -13,10 +13,9 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.binary_sensor import (
     BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    CONF_NAME, CONF_ENTITY_ID, CONF_TYPE, STATE_UNKNOWN, CONF_SENSOR_CLASS,
+    CONF_NAME, CONF_ENTITY_ID, CONF_TYPE, STATE_UNKNOWN,
     ATTR_ENTITY_ID, CONF_DEVICE_CLASS)
 from homeassistant.core import callback
-from homeassistant.helpers.deprecation import get_deprecated
 from homeassistant.helpers.event import async_track_state_change
 
 _LOGGER = logging.getLogger(__name__)
@@ -38,7 +37,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_THRESHOLD): vol.Coerce(float),
     vol.Required(CONF_TYPE): vol.In(SENSOR_TYPES),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })
 
@@ -50,7 +48,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     name = config.get(CONF_NAME)
     threshold = config.get(CONF_THRESHOLD)
     limit_type = config.get(CONF_TYPE)
-    device_class = get_deprecated(config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+    device_class = config.get(CONF_DEVICE_CLASS)
 
     async_add_devices(
         [ThresholdSensor(hass, entity_id, name, threshold, limit_type,

homeassistant/components/binary_sensor/trend.py

@@ -16,9 +16,7 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDevice, ENTITY_ID_FORMAT, PLATFORM_SCHEMA,
     DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_SENSOR_CLASS,
-    CONF_DEVICE_CLASS, STATE_UNKNOWN,)
-from homeassistant.helpers.deprecation import get_deprecated
+    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_DEVICE_CLASS, STATE_UNKNOWN)
 from homeassistant.helpers.entity import generate_entity_id
 from homeassistant.helpers.event import track_state_change
 
@@ -32,7 +30,6 @@ SENSOR_SCHEMA = vol.Schema({
     vol.Optional(CONF_ATTRIBUTE): cv.string,
     vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
     vol.Optional(CONF_INVERT, default=False): cv.boolean,
-    vol.Optional(CONF_SENSOR_CLASS): DEVICE_CLASSES_SCHEMA,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })
 
@@ -50,8 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         entity_id = device_config[ATTR_ENTITY_ID]
         attribute = device_config.get(CONF_ATTRIBUTE)
         friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
-        device_class = get_deprecated(
-            device_config, CONF_DEVICE_CLASS, CONF_SENSOR_CLASS)
+        device_class = device_config.get(CONF_DEVICE_CLASS)
         invert = device_config[CONF_INVERT]
 
         sensors.append(

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/volvooncall.py

@@ -34,5 +34,5 @@ class VolvoSensor(VolvoEntity, BinarySensorDevice):
 
     @property
     def device_class(self):
-        """Return the class of this sensor, from SENSOR_CLASSES."""
+        """Return the class of this sensor, from DEVICE_CLASSES."""
         return 'safety'

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/binary_sensor/zwave.py

@@ -23,9 +23,7 @@ def get_device(values, **kwargs):
     """Create Z-Wave entity device."""
     device_mapping = workaround.get_device_mapping(values.primary)
     if device_mapping == workaround.WORKAROUND_NO_OFF_EVENT:
-        # Default the multiplier to 4
-        re_arm_multiplier = zwave.get_config_value(values.primary.node, 9) or 4
-        return ZWaveTriggerSensor(values, "motion", re_arm_multiplier * 8)
+        return ZWaveTriggerSensor(values, "motion")
 
     if workaround.get_device_component_mapping(values.primary) == DOMAIN:
         return ZWaveBinarySensor(values, None)
@@ -62,15 +60,21 @@ class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity):
 class ZWaveTriggerSensor(ZWaveBinarySensor):
     """Representation of a stateless sensor within Z-Wave."""
 
-    def __init__(self, values, device_class, re_arm_sec=60):
+    def __init__(self, values, device_class):
         """Initialize the sensor."""
         super(ZWaveTriggerSensor, self).__init__(values, device_class)
-        self.re_arm_sec = re_arm_sec
+        # Set default off delay to 60 sec
+        self.re_arm_sec = 60
         self.invalidate_after = None
 
     def update_properties(self):
         """Handle value changes for this entity's node."""
         self._state = self.values.primary.data
+        _LOGGER.debug('off_delay=%s', self.values.off_delay)
+        # Set re_arm_sec if off_delay is provided from the sensor
+        if self.values.off_delay:
+            _LOGGER.debug('off_delay.data=%s', self.values.off_delay.data)
+            self.re_arm_sec = self.values.off_delay.data * 8
         # only allow this value to be true for re_arm secs
         if not self.hass:
             return

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/foscam.py

@@ -6,7 +6,6 @@ https://home-assistant.io/components/camera.foscam/
 """
 import logging
 
-import requests
 import voluptuous as vol
 
 from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
@@ -16,11 +15,15 @@ from homeassistant.helpers import config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
+REQUIREMENTS = ['pyfoscam==1.2']
+
 CONF_IP = 'ip'
 
 DEFAULT_NAME = 'Foscam Camera'
 DEFAULT_PORT = 88
 
+FOSCAM_COMM_ERROR = -8
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_IP): cv.string,
     vol.Required(CONF_PASSWORD): cv.string,
@@ -33,46 +36,60 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up a Foscam IP Camera."""
-    add_devices([FoscamCamera(config)])
+    add_devices([FoscamCam(config)])
 
 
-class FoscamCamera(Camera):
+class FoscamCam(Camera):
     """An implementation of a Foscam IP camera."""
 
     def __init__(self, device_info):
         """Initialize a Foscam camera."""
-        super(FoscamCamera, self).__init__()
+        super(FoscamCam, self).__init__()
 
         ip_address = device_info.get(CONF_IP)
         port = device_info.get(CONF_PORT)
-
-        self._base_url = 'http://{}:{}/'.format(ip_address, port)
-
-        uri_template = self._base_url \
-            + 'cgi-bin/CGIProxy.fcgi?' \
-            + 'cmd=snapPicture2&usr={}&pwd={}'
-
         self._username = device_info.get(CONF_USERNAME)
         self._password = device_info.get(CONF_PASSWORD)
-        self._snap_picture_url = uri_template.format(
-            self._username,
-            self._password
-        )
         self._name = device_info.get(CONF_NAME)
+        self._motion_status = False
 
-        _LOGGER.info("Using the following URL for %s: %s",
-                     self._name, uri_template.format('***', '***'))
+        from foscam import FoscamCamera
+
+        self._foscam_session = FoscamCamera(ip_address, port, self._username,
+                                            self._password)
 
     def camera_image(self):
         """Return a still image reponse from the camera."""
         # Send the request to snap a picture and return raw jpg data
         # Handle exception if host is not reachable or url failed
-        try:
-            response = requests.get(self._snap_picture_url, timeout=10)
-        except requests.exceptions.ConnectionError:
+        result, response = self._foscam_session.snap_picture_2()
+        if result == FOSCAM_COMM_ERROR:
             return None
+
+        return response
+
+    @property
+    def motion_detection_enabled(self):
+        """Camera Motion Detection Status."""
+        return self._motion_status
+
+    def enable_motion_detection(self):
+        """Enable motion detection in camera."""
+        ret, err = self._foscam_session.enable_motion_detection()
+        if ret == FOSCAM_COMM_ERROR:
+            _LOGGER.debug("Unable to communicate with Foscam Camera: %s", err)
+            self._motion_status = True
         else:
-            return response.content
+            self._motion_status = False
+
+    def disable_motion_detection(self):
+        """Disable motion detection."""
+        ret, err = self._foscam_session.disable_motion_detection()
+        if ret == FOSCAM_COMM_ERROR:
+            _LOGGER.debug("Unable to communicate with Foscam Camera: %s", err)
+            self._motion_status = True
+        else:
+            self._motion_status = False
 
     @property
     def name(self):

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
@@ -85,13 +86,17 @@ SET_AUX_HEAT_SCHEMA = vol.Schema({
     vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
     vol.Required(ATTR_AUX_HEAT): cv.boolean,
 })
-SET_TEMPERATURE_SCHEMA = vol.Schema({
-    vol.Exclusive(ATTR_TEMPERATURE, 'temperature'): vol.Coerce(float),
-    vol.Inclusive(ATTR_TARGET_TEMP_HIGH, 'temperature'): vol.Coerce(float),
-    vol.Inclusive(ATTR_TARGET_TEMP_LOW, 'temperature'): vol.Coerce(float),
-    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
-    vol.Optional(ATTR_OPERATION_MODE): cv.string,
-})
+SET_TEMPERATURE_SCHEMA = vol.Schema(vol.All(
+    cv.has_at_least_one_key(
+        ATTR_TEMPERATURE, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW),
+    {
+        vol.Exclusive(ATTR_TEMPERATURE, 'temperature'): vol.Coerce(float),
+        vol.Inclusive(ATTR_TARGET_TEMP_HIGH, 'temperature'): vol.Coerce(float),
+        vol.Inclusive(ATTR_TARGET_TEMP_LOW, 'temperature'): vol.Coerce(float),
+        vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+        vol.Optional(ATTR_OPERATION_MODE): cv.string,
+    }
+))
 SET_FAN_MODE_SCHEMA = vol.Schema({
     vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
     vol.Required(ATTR_FAN_MODE): cv.string,
@@ -114,6 +119,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 +132,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 +145,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 +158,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 +176,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 +187,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 +198,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 +209,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/honeywell.py

@@ -75,7 +75,8 @@ def _setup_round(username, password, config, add_devices):
         zones = evo_api.temperatures(force_refresh=True)
         for i, zone in enumerate(zones):
             add_devices(
-                [RoundThermostat(evo_api, zone['id'], i == 0, away_temp)]
+                [RoundThermostat(evo_api, zone['id'], i == 0, away_temp)],
+                True
             )
     except socket.error:
         _LOGGER.error(
@@ -115,9 +116,9 @@ def _setup_us(username, password, config, add_devices):
 class RoundThermostat(ClimateDevice):
     """Representation of a Honeywell Round Connected thermostat."""
 
-    def __init__(self, device, zone_id, master, away_temp):
+    def __init__(self, client, zone_id, master, away_temp):
         """Initialize the thermostat."""
-        self.device = device
+        self.client = client
         self._current_temperature = None
         self._target_temperature = None
         self._name = 'round connected'
@@ -126,7 +127,6 @@ class RoundThermostat(ClimateDevice):
         self._is_dhw = False
         self._away_temp = away_temp
         self._away = False
-        self.update()
 
     @property
     def name(self):
@@ -155,12 +155,12 @@ class RoundThermostat(ClimateDevice):
         temperature = kwargs.get(ATTR_TEMPERATURE)
         if temperature is None:
             return
-        self.device.set_temperature(self._name, temperature)
+        self.client.set_temperature(self._name, temperature)
 
     @property
     def current_operation(self: ClimateDevice) -> str:
         """Get the current operation of the system."""
-        return getattr(self.device, ATTR_SYSTEM_MODE, None)
+        return getattr(self.client, ATTR_SYSTEM_MODE, None)
 
     @property
     def is_away_mode_on(self):
@@ -169,8 +169,8 @@ class RoundThermostat(ClimateDevice):
 
     def set_operation_mode(self: ClimateDevice, operation_mode: str) -> None:
         """Set the HVAC mode for the thermostat."""
-        if hasattr(self.device, ATTR_SYSTEM_MODE):
-            self.device.system_mode = operation_mode
+        if hasattr(self.client, ATTR_SYSTEM_MODE):
+            self.client.system_mode = operation_mode
 
     def turn_away_mode_on(self):
         """Turn away on.
@@ -180,19 +180,19 @@ class RoundThermostat(ClimateDevice):
         it doesn't get overwritten when away mode is switched on.
         """
         self._away = True
-        self.device.set_temperature(self._name, self._away_temp)
+        self.client.set_temperature(self._name, self._away_temp)
 
     def turn_away_mode_off(self):
         """Turn away off."""
         self._away = False
-        self.device.cancel_temp_override(self._name)
+        self.client.cancel_temp_override(self._name)
 
     def update(self):
         """Get the latest date."""
         try:
             # Only refresh if this is the "master" device,
             # others will pick up the cache
-            for val in self.device.temperatures(force_refresh=self._master):
+            for val in self.client.temperatures(force_refresh=self._master):
                 if val['id'] == self._id:
                     data = val
 
@@ -210,6 +210,12 @@ class RoundThermostat(ClimateDevice):
             self._name = data['name']
             self._is_dhw = False
 
+            # The underlying library doesn't expose the thermostat's mode
+            # but we can pull it out of the big dictionary of information.
+            device = self.client.devices[self._id]
+            self.client.system_mode = device[
+                'thermostat']['changeableValues']['mode']
+
 
 class HoneywellUSThermostat(ClimateDevice):
     """Representation of a Honeywell US Thermostat."""

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/netatmo.py

@@ -36,7 +36,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })
 
 
-def setup_platform(hass, config, add_callback_devices, discovery_info=None):
+def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the NetAtmo Thermostat."""
     netatmo = get_component('netatmo')
     device = config.get(CONF_RELAY)
@@ -49,7 +49,7 @@ def setup_platform(hass, config, add_callback_devices, discovery_info=None):
                 if config[CONF_THERMOSTAT] != [] and \
                    module_name not in config[CONF_THERMOSTAT]:
                     continue
-            add_callback_devices([NetatmoThermostat(data, module_name)])
+            add_devices([NetatmoThermostat(data, module_name)], True)
     except lnetatmo.NoDevice:
         return None
 
@@ -64,7 +64,6 @@ class NetatmoThermostat(ClimateDevice):
         self._name = module_name
         self._target_temperature = None
         self._away = None
-        self.update()
 
     @property
     def name(self):

homeassistant/components/climate/radiotherm.py

@@ -68,7 +68,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             _LOGGER.exception("Unable to connect to Radio Thermostat: %s",
                               host)
 
-    add_devices(tstats)
+    add_devices(tstats, True)
 
 
 class RadioThermostat(ClimateDevice):
@@ -89,7 +89,6 @@ class RadioThermostat(ClimateDevice):
         self._away = False
         self._away_temps = away_temps
         self._prev_temp = None
-        self.update()
         self._operation_list = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
 
     @property

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_data 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/config/zwave.py

@@ -1,12 +1,17 @@
 """Provide configuration end points for Z-Wave."""
 import asyncio
 
+import homeassistant.core as ha
+from homeassistant.const import HTTP_NOT_FOUND
+from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.config import EditKeyBasedConfigView
-from homeassistant.components.zwave import DEVICE_CONFIG_SCHEMA_ENTRY
+from homeassistant.components.zwave import const, DEVICE_CONFIG_SCHEMA_ENTRY
 import homeassistant.helpers.config_validation as cv
 
 
 CONFIG_PATH = 'zwave_device_config.yaml'
+OZW_LOG_FILENAME = 'OZW_Log.txt'
+URL_API_OZW_LOG = '/api/zwave/ozwlog'
 
 
 @asyncio.coroutine
@@ -16,4 +21,123 @@ def async_setup(hass):
         'zwave', 'device_config', CONFIG_PATH, cv.entity_id,
         DEVICE_CONFIG_SCHEMA_ENTRY
     ))
+    hass.http.register_view(ZWaveNodeValueView)
+    hass.http.register_view(ZWaveNodeGroupView)
+    hass.http.register_view(ZWaveNodeConfigView)
+    hass.http.register_view(ZWaveUserCodeView)
+    hass.http.register_static_path(
+        URL_API_OZW_LOG, hass.config.path(OZW_LOG_FILENAME), False)
+
     return True
+
+
+class ZWaveNodeValueView(HomeAssistantView):
+    """View to return the node values."""
+
+    url = r"/api/zwave/values/{node_id:\d+}"
+    name = "api:zwave:values"
+
+    @ha.callback
+    def get(self, request, node_id):
+        """Retrieve groups of node."""
+        nodeid = int(node_id)
+        hass = request.app['hass']
+        values_list = hass.data[const.DATA_ENTITY_VALUES]
+
+        values_data = {}
+        # Return a list of values for this node that are used as a
+        # primary value for an entity
+        for entity_values in values_list:
+            if entity_values.primary.node.node_id != nodeid:
+                continue
+
+            values_data[entity_values.primary.value_id] = {
+                'label': entity_values.primary.label,
+                'index': entity_values.primary.index,
+                'instance': entity_values.primary.instance,
+            }
+        return self.json(values_data)
+
+
+class ZWaveNodeGroupView(HomeAssistantView):
+    """View to return the nodes group configuration."""
+
+    url = r"/api/zwave/groups/{node_id:\d+}"
+    name = "api:zwave:groups"
+
+    @ha.callback
+    def get(self, request, node_id):
+        """Retrieve groups of node."""
+        nodeid = int(node_id)
+        hass = request.app['hass']
+        network = hass.data.get(const.DATA_NETWORK)
+        node = network.nodes.get(nodeid)
+        if node is None:
+            return self.json_message('Node not found', HTTP_NOT_FOUND)
+        groupdata = node.groups
+        groups = {}
+        for key, value in groupdata.items():
+            groups[key] = {'associations': value.associations,
+                           'association_instances':
+                           value.associations_instances,
+                           'label': value.label,
+                           'max_associations': value.max_associations}
+        return self.json(groups)
+
+
+class ZWaveNodeConfigView(HomeAssistantView):
+    """View to return the nodes configuration options."""
+
+    url = r"/api/zwave/config/{node_id:\d+}"
+    name = "api:zwave:config"
+
+    @ha.callback
+    def get(self, request, node_id):
+        """Retrieve configurations of node."""
+        nodeid = int(node_id)
+        hass = request.app['hass']
+        network = hass.data.get(const.DATA_NETWORK)
+        node = network.nodes.get(nodeid)
+        if node is None:
+            return self.json_message('Node not found', HTTP_NOT_FOUND)
+        config = {}
+        for value in (
+                node.get_values(class_id=const.COMMAND_CLASS_CONFIGURATION)
+                .values()):
+            config[value.index] = {'label': value.label,
+                                   'type': value.type,
+                                   'help': value.help,
+                                   'data_items': value.data_items,
+                                   'data': value.data,
+                                   'max': value.max,
+                                   'min': value.min}
+        return self.json(config)
+
+
+class ZWaveUserCodeView(HomeAssistantView):
+    """View to return the nodes usercode configuration."""
+
+    url = r"/api/zwave/usercodes/{node_id:\d+}"
+    name = "api:zwave:usercodes"
+
+    @ha.callback
+    def get(self, request, node_id):
+        """Retrieve usercodes of node."""
+        nodeid = int(node_id)
+        hass = request.app['hass']
+        network = hass.data.get(const.DATA_NETWORK)
+        node = network.nodes.get(nodeid)
+        if node is None:
+            return self.json_message('Node not found', HTTP_NOT_FOUND)
+        usercodes = {}
+        if not node.has_command_class(const.COMMAND_CLASS_USER_CODE):
+            return self.json(usercodes)
+        for value in (
+                node.get_values(class_id=const.COMMAND_CLASS_USER_CODE)
+                .values()):
+            if value.genre != const.GENRE_USER:
+                continue
+            usercodes[value.index] = {'code': value.data,
+                                      'label': value.label,
+                                      'length': len(value.data)}
+        return self.json(usercodes)

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/garadget.py

@@ -18,10 +18,10 @@ from homeassistant.const import (
 
 _LOGGER = logging.getLogger(__name__)
 
-ATTR_AVAILABLE = "available"
-ATTR_SENSOR_STRENGTH = "sensor reflection rate"
-ATTR_SIGNAL_STRENGTH = "wifi signal strength (dB)"
-ATTR_TIME_IN_STATE = "time in state"
+ATTR_AVAILABLE = 'available'
+ATTR_SENSOR_STRENGTH = 'sensor_reflection_rate'
+ATTR_SIGNAL_STRENGTH = 'wifi_signal_strength'
+ATTR_TIME_IN_STATE = 'time_in_state'
 
 DEFAULT_NAME = 'Garadget'
 

homeassistant/components/cover/lutron_caseta.py

@@ -8,11 +8,10 @@ import logging
 
 
 from homeassistant.components.cover import (
-    CoverDevice, SUPPORT_OPEN, SUPPORT_CLOSE)
+    CoverDevice, SUPPORT_OPEN, SUPPORT_CLOSE, SUPPORT_SET_POSITION)
 from homeassistant.components.lutron_caseta import (
     LUTRON_CASETA_SMARTBRIDGE, LutronCasetaDevice)
 
-
 _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['lutron_caseta']
@@ -23,7 +22,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)
@@ -37,13 +37,18 @@ class LutronCasetaCover(LutronCasetaDevice, CoverDevice):
     @property
     def supported_features(self):
         """Flag supported features."""
-        return SUPPORT_OPEN | SUPPORT_CLOSE
+        return SUPPORT_OPEN | SUPPORT_CLOSE | SUPPORT_SET_POSITION
 
     @property
     def is_closed(self):
         """Return if the cover is closed."""
         return self._state["current_state"] < 1
 
+    @property
+    def current_cover_position(self):
+        """Return the current position of cover."""
+        return self._state["current_state"]
+
     def close_cover(self):
         """Close the cover."""
         self._smartbridge.set_value(self._device_id, 0)

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/rpi_gpio.py

@@ -24,9 +24,13 @@ CONF_RELAY_PIN = 'relay_pin'
 CONF_RELAY_TIME = 'relay_time'
 CONF_STATE_PIN = 'state_pin'
 CONF_STATE_PULL_MODE = 'state_pull_mode'
+CONF_INVERT_STATE = 'invert_state'
+CONF_INVERT_RELAY = 'invert_relay'
 
 DEFAULT_RELAY_TIME = .2
 DEFAULT_STATE_PULL_MODE = 'UP'
+DEFAULT_INVERT_STATE = False
+DEFAULT_INVERT_RELAY = False
 DEPENDENCIES = ['rpi_gpio']
 
 _COVERS_SCHEMA = vol.All(
@@ -45,6 +49,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_STATE_PULL_MODE, default=DEFAULT_STATE_PULL_MODE):
         cv.string,
     vol.Optional(CONF_RELAY_TIME, default=DEFAULT_RELAY_TIME): cv.positive_int,
+    vol.Optional(CONF_INVERT_STATE, default=DEFAULT_INVERT_STATE): cv.boolean,
+    vol.Optional(CONF_INVERT_RELAY, default=DEFAULT_INVERT_RELAY): cv.boolean,
 })
 
 
@@ -53,13 +59,15 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the RPi cover platform."""
     relay_time = config.get(CONF_RELAY_TIME)
     state_pull_mode = config.get(CONF_STATE_PULL_MODE)
+    invert_state = config.get(CONF_INVERT_STATE)
+    invert_relay = config.get(CONF_INVERT_RELAY)
     covers = []
     covers_conf = config.get(CONF_COVERS)
 
     for cover in covers_conf:
         covers.append(RPiGPIOCover(
             cover[CONF_NAME], cover[CONF_RELAY_PIN], cover[CONF_STATE_PIN],
-            state_pull_mode, relay_time))
+            state_pull_mode, relay_time, invert_state, invert_relay))
     add_devices(covers)
 
 
@@ -67,7 +75,7 @@ class RPiGPIOCover(CoverDevice):
     """Representation of a Raspberry GPIO cover."""
 
     def __init__(self, name, relay_pin, state_pin, state_pull_mode,
-                 relay_time):
+                 relay_time, invert_state, invert_relay):
         """Initialize the cover."""
         self._name = name
         self._state = False
@@ -75,9 +83,11 @@ class RPiGPIOCover(CoverDevice):
         self._state_pin = state_pin
         self._state_pull_mode = state_pull_mode
         self._relay_time = relay_time
+        self._invert_state = invert_state
+        self._invert_relay = invert_relay
         rpi_gpio.setup_output(self._relay_pin)
         rpi_gpio.setup_input(self._state_pin, self._state_pull_mode)
-        rpi_gpio.write_output(self._relay_pin, True)
+        rpi_gpio.write_output(self._relay_pin, not self._invert_relay)
 
     @property
     def unique_id(self):
@@ -96,13 +106,13 @@ class RPiGPIOCover(CoverDevice):
     @property
     def is_closed(self):
         """Return true if cover is closed."""
-        return self._state
+        return self._state != self._invert_state
 
     def _trigger(self):
         """Trigger the cover."""
-        rpi_gpio.write_output(self._relay_pin, False)
+        rpi_gpio.write_output(self._relay_pin, self._invert_relay)
         sleep(self._relay_time)
-        rpi_gpio.write_output(self._relay_pin, True)
+        rpi_gpio.write_output(self._relay_pin, not self._invert_relay)
 
     def close_cover(self):
         """Close the cover."""

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']
@@ -32,15 +31,16 @@ COMPONENTS_WITH_DEMO_PLATFORM = [
     'sensor',
     'switch',
     'tts',
+    'mailbox',
 ]
 
 
 @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 +108,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 +206,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/huawei_router.py

@@ -0,0 +1,145 @@
+"""
+Support for HUAWEI routers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.huawei/
+"""
+import base64
+import logging
+import re
+from collections import namedtuple
+
+import requests
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Required(CONF_USERNAME): cv.string
+})
+
+
+# pylint: disable=unused-argument
+def get_scanner(hass, config):
+    """Validate the configuration and return a HUAWEI scanner."""
+    scanner = HuaweiDeviceScanner(config[DOMAIN])
+
+    return scanner
+
+
+Device = namedtuple('Device', ['name', 'ip', 'mac', 'state'])
+
+
+class HuaweiDeviceScanner(DeviceScanner):
+    """This class queries a router running HUAWEI firmware."""
+
+    ARRAY_REGEX = re.compile(r'var UserDevinfo = new Array\((.*),null\);')
+    DEVICE_REGEX = re.compile(r'new USERDevice\((.*?)\),')
+    DEVICE_ATTR_REGEX = re.compile(
+        '"(?P<Domain>.*?)","(?P<IpAddr>.*?)",'
+        '"(?P<MacAddr>.*?)","(?P<Port>.*?)",'
+        '"(?P<IpType>.*?)","(?P<DevType>.*?)",'
+        '"(?P<DevStatus>.*?)","(?P<PortType>.*?)",'
+        '"(?P<Time>.*?)","(?P<HostName>.*?)",'
+        '"(?P<IPv4Enabled>.*?)","(?P<IPv6Enabled>.*?)",'
+        '"(?P<DeviceType>.*?)"')
+    LOGIN_COOKIE = dict(Cookie='body:Language:portuguese:id=-1')
+
+    def __init__(self, config):
+        """Initialize the scanner."""
+        self.host = config[CONF_HOST]
+        self.username = config[CONF_USERNAME]
+        self.password = base64.b64encode(bytes(config[CONF_PASSWORD], 'utf-8'))
+
+        self.last_results = []
+
+    def scan_devices(self):
+        """Scan for new devices and return a list with found device IDs."""
+        self._update_info()
+        return [client.mac for client in self.last_results]
+
+    def get_device_name(self, device):
+        """Return the name of the given device or None if we don't know."""
+        if not self.last_results:
+            return None
+        for client in self.last_results:
+            if client.mac == device:
+                return client.name
+        return None
+
+    def _update_info(self):
+        """Ensure the information from the router is up to date.
+
+        Return boolean if scanning successful.
+        """
+        data = self._get_data()
+        if not data:
+            return False
+
+        active_clients = [client for client in data if client.state]
+        self.last_results = active_clients
+
+        _LOGGER.debug("Active clients: " + "\n"
+                      .join((client.mac + " " + client.name)
+                            for client in active_clients))
+        return True
+
+    def _get_data(self):
+        """Get the devices' data from the router.
+
+        Returns a list with all the devices known to the router DHCP server.
+        """
+        array_regex_res = self.ARRAY_REGEX.search(self._get_devices_response())
+
+        devices = []
+        if array_regex_res:
+            device_regex_res = self.DEVICE_REGEX.findall(
+                array_regex_res.group(1))
+
+            for device in device_regex_res:
+                device_attrs_regex_res = self.DEVICE_ATTR_REGEX.search(device)
+
+                devices.append(Device(device_attrs_regex_res.group('HostName'),
+                                      device_attrs_regex_res.group('IpAddr'),
+                                      device_attrs_regex_res.group('MacAddr'),
+                                      device_attrs_regex_res.group(
+                                          'DevStatus') == "Online"))
+
+        return devices
+
+    def _get_devices_response(self):
+        """Get the raw string with the devices from the router."""
+        cnt = requests.post('http://{}/asp/GetRandCount.asp'.format(self.host))
+        cnt_str = str(cnt.content, cnt.apparent_encoding, errors='replace')
+
+        _LOGGER.debug("Loggin in")
+        cookie = requests.post('http://{}/login.cgi'.format(self.host),
+                               data=[('UserName', self.username),
+                                     ('PassWord', self.password),
+                                     ('x.X_HW_Token', cnt_str)],
+                               cookies=self.LOGIN_COOKIE)
+
+        _LOGGER.debug("Requesting lan user info update")
+        # this request is needed or else some devices' state won't be updated
+        requests.get(
+            'http://{}/html/bbsp/common/lanuserinfo.asp'.format(self.host),
+            cookies=cookie.cookies)
+
+        _LOGGER.debug("Requesting lan user info data")
+        devices = requests.get(
+            'http://{}/html/bbsp/common/GetLanUserDevInfo.asp'.format(
+                self.host),
+            cookies=cookie.cookies)
+
+        # we need to decode() using the request encoding, then encode() and
+        # decode('unicode_escape') to replace \\xXX with \xXX
+        # (i.e. \\x2d -> \x2d)
+        return devices.content.decode(devices.apparent_encoding).encode().\
+            decode('unicode_escape')

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'
 
@@ -33,6 +33,7 @@ SERVICE_IKEA_TRADFRI = 'ikea_tradfri'
 SERVICE_HASSIO = 'hassio'
 SERVICE_AXIS = 'axis'
 SERVICE_APPLE_TV = 'apple_tv'
+SERVICE_WINK = 'wink'
 
 SERVICE_HANDLERS = {
     SERVICE_HASS_IOS_APP: ('ios', None),
@@ -42,6 +43,7 @@ SERVICE_HANDLERS = {
     SERVICE_HASSIO: ('hassio', None),
     SERVICE_AXIS: ('axis', None),
     SERVICE_APPLE_TV: ('apple_tv', None),
+    SERVICE_WINK: ('wink', None),
     'philips_hue': ('light', 'hue'),
     'google_cast': ('media_player', 'cast'),
     'panasonic_viera': ('media_player', 'panasonic_viera'),
@@ -57,7 +59,9 @@ SERVICE_HANDLERS = {
     'frontier_silicon': ('media_player', 'frontier_silicon'),
     'openhome': ('media_player', 'openhome'),
     'harmony': ('remote', 'harmony'),
+    'sabnzbd': ('sensor', 'sabnzbd'),
     'bose_soundtouch': ('media_player', 'soundtouch'),
+    'bluesound': ('media_player', 'bluesound'),
 }
 
 CONF_IGNORE = 'ignore'

homeassistant/components/dyson.py

@@ -13,7 +13,7 @@ from homeassistant.helpers import discovery
 from homeassistant.const import CONF_USERNAME, CONF_PASSWORD, CONF_TIMEOUT, \
     CONF_DEVICES
 
-REQUIREMENTS = ['libpurecoollink==0.2.0']
+REQUIREMENTS = ['libpurecoollink==0.4.2']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -69,14 +69,17 @@ def setup(hass, config):
             dyson_device = next((d for d in dyson_devices if
                                  d.serial == device["device_id"]), None)
             if dyson_device:
-                connected = dyson_device.connect(None, device["device_ip"],
-                                                 timeout, retry)
-                if connected:
-                    _LOGGER.info("Connected to device %s", dyson_device)
-                    hass.data[DYSON_DEVICES].append(dyson_device)
-                else:
-                    _LOGGER.warning("Unable to connect to device %s",
-                                    dyson_device)
+                try:
+                    connected = dyson_device.connect(device["device_ip"])
+                    if connected:
+                        _LOGGER.info("Connected to device %s", dyson_device)
+                        hass.data[DYSON_DEVICES].append(dyson_device)
+                    else:
+                        _LOGGER.warning("Unable to connect to device %s",
+                                        dyson_device)
+                except OSError as ose:
+                    _LOGGER.error("Unable to connect to device %s: %s",
+                                  str(dyson_device.network_device), str(ose))
             else:
                 _LOGGER.warning(
                     "Unable to find device %s in Dyson account",
@@ -86,7 +89,7 @@ def setup(hass, config):
         for device in dyson_devices:
             _LOGGER.info("Trying to connect to device %s with timeout=%i "
                          "and retry=%i", device, timeout, retry)
-            connected = device.connect(None, None, timeout, retry)
+            connected = device.auto_connect(timeout, retry)
             if connected:
                 _LOGGER.info("Connected to device %s", device)
                 hass.data[DYSON_DEVICES].append(device)
@@ -98,5 +101,6 @@ def setup(hass, config):
         _LOGGER.debug("Starting sensor/fan components")
         discovery.load_platform(hass, "sensor", DOMAIN, {}, config)
         discovery.load_platform(hass, "fan", DOMAIN, {}, config)
+        discovery.load_platform(hass, "vacuum", DOMAIN, {}, config)
 
     return True

homeassistant/components/emulated_hue/__init__.py

@@ -193,7 +193,9 @@ class Config(object):
             if entity_id == ent_id:
                 return number
 
-        number = str(len(self.numbers) + 1)
+        number = '1'
+        if self.numbers:
+            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/dyson.py

@@ -36,7 +36,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         hass.data[DYSON_FAN_DEVICES] = []
 
     # Get Dyson Devices from parent component
-    for device in hass.data[DYSON_DEVICES]:
+    from libpurecoollink.dyson_pure_cool_link import DysonPureCoolLink
+    for device in [d for d in hass.data[DYSON_DEVICES] if
+                   isinstance(d, DysonPureCoolLink)]:
         dyson_entity = DysonPureCoolLinkDevice(hass, device)
         hass.data[DYSON_FAN_DEVICES].append(dyson_entity)
 
@@ -83,8 +85,8 @@ class DysonPureCoolLinkDevice(FanEntity):
 
     def on_message(self, message):
         """Called when new messages received from the fan."""
-        from libpurecoollink.dyson import DysonState
-        if isinstance(message, DysonState):
+        from libpurecoollink.dyson_pure_state import DysonPureCoolState
+        if isinstance(message, DysonPureCoolState):
             _LOGGER.debug("Message received for fan device %s : %s", self.name,
                           message)
             self.schedule_update_ha_state()

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