Merge pull request #7866 from home-assistant/release-0-46

0.46

.coveragerc

@@ -20,6 +20,12 @@ omit =
     homeassistant/components/android_ip_webcam.py
     homeassistant/components/*/android_ip_webcam.py
 
+    homeassistant/components/arlo.py
+    homeassistant/components/*/arlo.py
+
+    homeassistant/components/axis.py
+    homeassistant/components/*/axis.py
+
     homeassistant/components/bbb_gpio.py
     homeassistant/components/*/bbb_gpio.py
 
@@ -59,6 +65,9 @@ omit =
     homeassistant/components/isy994.py
     homeassistant/components/*/isy994.py
 
+    homeassistant/components/kira.py
+    homeassistant/components/*/kira.py
+
     homeassistant/components/lutron.py
     homeassistant/components/*/lutron.py
 
@@ -77,15 +86,27 @@ omit =
     homeassistant/components/octoprint.py
     homeassistant/components/*/octoprint.py
 
+    homeassistant/components/opencv.py
+    homeassistant/components/*/opencv.py
+
     homeassistant/components/qwikswitch.py
     homeassistant/components/*/qwikswitch.py
 
+    homeassistant/components/rachio.py
+    homeassistant/components/*/rachio.py
+
+    homeassistant/components/raspihats.py
+    homeassistant/components/*/raspihats.py
+
     homeassistant/components/rfxtrx.py
     homeassistant/components/*/rfxtrx.py
 
     homeassistant/components/rpi_gpio.py
     homeassistant/components/*/rpi_gpio.py
 
+    homeassistant/components/rpi_pfio.py
+    homeassistant/components/*/rpi_pfio.py
+
     homeassistant/components/scsgate.py
     homeassistant/components/*/scsgate.py
 
@@ -154,6 +175,13 @@ omit =
     homeassistant/components/tado.py
     homeassistant/components/*/tado.py
 
+    homeassistant/components/zha/__init__.py
+    homeassistant/components/zha/const.py
+    homeassistant/components/*/zha.py
+
+    homeassistant/components/eight_sleep.py
+    homeassistant/components/*/eight_sleep.py
+
     homeassistant/components/alarm_control_panel/alarmdotcom.py
     homeassistant/components/alarm_control_panel/concord232.py
     homeassistant/components/alarm_control_panel/nx584.py
@@ -165,6 +193,8 @@ omit =
     homeassistant/components/binary_sensor/flic.py
     homeassistant/components/binary_sensor/hikvision.py
     homeassistant/components/binary_sensor/iss.py
+    homeassistant/components/binary_sensor/mystrom.py
+    homeassistant/components/binary_sensor/pilight.py
     homeassistant/components/binary_sensor/ping.py
     homeassistant/components/binary_sensor/rest.py
     homeassistant/components/browser.py
@@ -182,15 +212,18 @@ omit =
     homeassistant/components/climate/oem.py
     homeassistant/components/climate/proliphix.py
     homeassistant/components/climate/radiotherm.py
+    homeassistant/components/climate/sensibo.py
     homeassistant/components/cover/garadget.py
     homeassistant/components/cover/homematic.py
     homeassistant/components/cover/myq.py
+    homeassistant/components/cover/opengarage.py
     homeassistant/components/cover/rpi_gpio.py
     homeassistant/components/cover/scsgate.py
     homeassistant/components/cover/wink.py
     homeassistant/components/device_tracker/actiontec.py
     homeassistant/components/device_tracker/aruba.py
     homeassistant/components/device_tracker/asuswrt.py
+    homeassistant/components/device_tracker/automatic.py
     homeassistant/components/device_tracker/bbox.py
     homeassistant/components/device_tracker/bluetooth_le_tracker.py
     homeassistant/components/device_tracker/bluetooth_tracker.py
@@ -201,6 +234,7 @@ omit =
     homeassistant/components/device_tracker/icloud.py
     homeassistant/components/device_tracker/linksys_ap.py
     homeassistant/components/device_tracker/luci.py
+    homeassistant/components/device_tracker/mikrotik.py
     homeassistant/components/device_tracker/netgear.py
     homeassistant/components/device_tracker/nmap_tracker.py
     homeassistant/components/device_tracker/ping.py
@@ -222,10 +256,14 @@ omit =
     homeassistant/components/foursquare.py
     homeassistant/components/hdmi_cec.py
     homeassistant/components/ifttt.py
+    homeassistant/components/image_processing/dlib_face_detect.py
+    homeassistant/components/image_processing/dlib_face_identify.py
+    homeassistant/components/image_processing/seven_segments.py
     homeassistant/components/joaoapps_join.py
     homeassistant/components/keyboard.py
     homeassistant/components/keyboard_remote.py
     homeassistant/components/light/avion.py
+    homeassistant/components/light/blinkt.py
     homeassistant/components/light/blinksticklight.py
     homeassistant/components/light/decora.py
     homeassistant/components/light/flux_led.py
@@ -238,6 +276,7 @@ omit =
     homeassistant/components/light/osramlightify.py
     homeassistant/components/light/rpi_gpio_pwm.py
     homeassistant/components/light/piglow.py
+    homeassistant/components/light/sensehat.py
     homeassistant/components/light/tikteck.py
     homeassistant/components/light/tradfri.py
     homeassistant/components/light/x10.py
@@ -335,6 +374,7 @@ omit =
     homeassistant/components/sensor/broadlink.py
     homeassistant/components/sensor/dublin_bus_transport.py
     homeassistant/components/sensor/coinmarketcap.py
+    homeassistant/components/sensor/cert_expiry.py
     homeassistant/components/sensor/comed_hourly_pricing.py
     homeassistant/components/sensor/cpuspeed.py
     homeassistant/components/sensor/crimereports.py
@@ -350,6 +390,7 @@ omit =
     homeassistant/components/sensor/eddystone_temperature.py
     homeassistant/components/sensor/eliqonline.py
     homeassistant/components/sensor/emoncms.py
+    homeassistant/components/sensor/envirophat.py
     homeassistant/components/sensor/fastdotcom.py
     homeassistant/components/sensor/fedex.py
     homeassistant/components/sensor/fido.py
@@ -391,6 +432,7 @@ omit =
     homeassistant/components/sensor/pi_hole.py
     homeassistant/components/sensor/plex.py
     homeassistant/components/sensor/pocketcasts.py
+    homeassistant/components/sensor/pushbullet.py
     homeassistant/components/sensor/pvoutput.py
     homeassistant/components/sensor/qnap.py
     homeassistant/components/sensor/sabnzbd.py

.travis.yml

@@ -1,13 +1,15 @@
 sudo: false
+addons:
+  apt:
+    packages:
+      - libudev-dev
 matrix:
   fast_finish: true
   include:
-    - python: "3.4.2"
-      env: TOXENV=py34
-    - python: "3.4.2"
-      env: TOXENV=requirements
     - python: "3.4.2"
       env: TOXENV=lint
+    - python: "3.4.2"
+      env: TOXENV=py34
     # - python: "3.5"
     #   env: TOXENV=typing
     - python: "3.5"
@@ -16,6 +18,8 @@ matrix:
       env: TOXENV=py36
     - python: "3.6-dev"
       env: TOXENV=py36
+    - python: "3.4.2"
+      env: TOXENV=requirements
   # allow_failures:
   #   - python: "3.5"
   #     env: TOXENV=typing
@@ -25,5 +29,5 @@ cache:
     - $HOME/.cache/pip
 install: pip install -U tox coveralls
 language: python
-script: tox
+script: travis_wait tox
 after_success: coveralls

Dockerfile

@@ -1,11 +1,10 @@
-FROM python:3.5
+FROM python:3.6
 MAINTAINER Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>
 
 # Uncomment any of the following lines to disable the installation.
 #ENV INSTALL_TELLSTICK no
 #ENV INSTALL_OPENALPR no
 #ENV INSTALL_FFMPEG no
-#ENV INSTALL_OPENZWAVE no
 #ENV INSTALL_LIBCEC no
 #ENV INSTALL_PHANTOMJS no
 #ENV INSTALL_COAP_CLIENT no
@@ -27,4 +26,4 @@ RUN pip3 install --no-cache-dir -r requirements_all.txt && \
 # Copy source
 COPY . .
 
-CMD [ "python", "-m", "homeassistant", "--config", "/config" ]
+CMD [ "python", "-m", "homeassistant", "--config", "/config" ]

docs/source/_templates/links.html

@@ -1,8 +1,6 @@
 <ul>
-    <li><a href="https://community.home-assistant.io">📌 Community Forums</a></li>
-    <li><a href="https://github.com/home-assistant/home-assistant">🚀 GitHub</a></li>
-    <li><a href="https://home-assistant.io/">🏡 Homepage</a></li>
-    <li><a href="https://gitter.im/home-assistant/home-assistant">💬 Gitter</a></li>
-    <li><a href="https://pypi.python.org/pypi/homeassistant">💾 Download Releases</a></li>
+    <li><a href="https://home-assistant.io/">Homepage</a></li>
+    <li><a href="https://community.home-assistant.io">Community Forums</a></li>
+    <li><a href="https://github.com/home-assistant/home-assistant">GitHub</a></li>
+    <li><a href="https://gitter.im/home-assistant/home-assistant">Gitter</a></li>
 </ul>
-<hr>

homeassistant/__main__.py

@@ -1,4 +1,4 @@
-"""Starts home assistant."""
+"""Start Home Assistant."""
 from __future__ import print_function
 
 import argparse
@@ -10,6 +10,7 @@ import threading
 
 from typing import Optional, List
 
+from homeassistant import monkey_patch
 from homeassistant.const import (
     __version__,
     EVENT_HOMEASSISTANT_START,
@@ -17,7 +18,6 @@ from homeassistant.const import (
     REQUIRED_PYTHON_VER_WIN,
     RESTART_EXIT_CODE,
 )
-from homeassistant.util.async import run_callback_threadsafe
 
 
 def attempt_use_uvloop():
@@ -277,7 +277,7 @@ def cmdline() -> List[str]:
 
 def setup_and_run_hass(config_dir: str,
                        args: argparse.Namespace) -> Optional[int]:
-    """Setup HASS and run."""
+    """Set up HASS and run."""
     from homeassistant import bootstrap
 
     # Run a simple daemon runner process on Windows to handle restarts
@@ -310,6 +310,9 @@ def setup_and_run_hass(config_dir: str,
         return None
 
     if args.open_ui:
+        # Imported here to avoid importing asyncio before monkey patch
+        from homeassistant.util.async import run_callback_threadsafe
+
         def open_browser(event):
             """Open the webinterface in a browser."""
             if hass.config.api is not None:
@@ -371,6 +374,13 @@ def main() -> int:
     """Start Home Assistant."""
     validate_python()
 
+    if os.environ.get('HASS_MONKEYPATCH_ASYNCIO') == '1':
+        if sys.version_info[:3] >= (3, 6):
+            monkey_patch.disable_c_asyncio()
+        monkey_patch.patch_weakref_tasks()
+    elif sys.version_info[:3] < (3, 5, 3):
+        monkey_patch.patch_weakref_tasks()
+
     attempt_use_uvloop()
 
     if sys.version_info[:3] < (3, 5, 3):

homeassistant/bootstrap.py

@@ -1,4 +1,4 @@
-"""Provides methods to bootstrap a home assistant instance."""
+"""Provide methods to bootstrap a Home Assistant instance."""
 import asyncio
 import logging
 import logging.handlers
@@ -83,8 +83,7 @@ def async_from_config_dict(config: Dict[str, Any],
         conf_util.async_log_exception(ex, 'homeassistant', core_config, hass)
         return None
 
-    yield from hass.loop.run_in_executor(
-        None, conf_util.process_ha_config_upgrade, hass)
+    yield from hass.async_add_job(conf_util.process_ha_config_upgrade, hass)
 
     if enable_log:
         async_enable_logging(hass, verbose, log_rotate_days)
@@ -95,7 +94,7 @@ def async_from_config_dict(config: Dict[str, Any],
                         'This may cause issues.')
 
     if not loader.PREPARED:
-        yield from hass.loop.run_in_executor(None, loader.prepare, hass)
+        yield from hass.async_add_job(loader.prepare, hass)
 
     # Merge packages
     conf_util.merge_packages_config(
@@ -184,14 +183,13 @@ 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.loop.run_in_executor(
-        None, mount_local_lib_path, config_dir)
+    yield from hass.async_add_job(mount_local_lib_path, config_dir)
 
     async_enable_logging(hass, verbose, log_rotate_days)
 
     try:
-        config_dict = yield from hass.loop.run_in_executor(
-            None, conf_util.load_yaml_config_file, config_path)
+        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)
         return None
@@ -206,7 +204,7 @@ def async_from_config_file(config_path: str,
 @core.callback
 def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
                          log_rotate_days=None) -> None:
-    """Setup the logging.
+    """Set up the logging.
 
     This method must be run in the event loop.
     """
@@ -214,12 +212,12 @@ def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
     fmt = ("%(asctime)s %(levelname)s (%(threadName)s) "
            "[%(name)s] %(message)s")
     colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
-    datefmt = '%y-%m-%d %H:%M:%S'
+    datefmt = '%Y-%m-%d %H:%M:%S'
 
-    # suppress overly verbose logs from libraries that aren't helpful
-    logging.getLogger("requests").setLevel(logging.WARNING)
-    logging.getLogger("urllib3").setLevel(logging.WARNING)
-    logging.getLogger("aiohttp.access").setLevel(logging.WARNING)
+    # Suppress overly verbose logs from libraries that aren't helpful
+    logging.getLogger('requests').setLevel(logging.WARNING)
+    logging.getLogger('urllib3').setLevel(logging.WARNING)
+    logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
 
     try:
         from colorlog import ColoredFormatter
@@ -274,7 +272,7 @@ def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
 
     else:
         _LOGGER.error(
-            'Unable to setup error log %s (access denied)', err_log_path)
+            "Unable to setup error log %s (access denied)", err_log_path)
 
 
 def mount_local_lib_path(config_dir: str) -> str:

homeassistant/components/__init__.py

@@ -102,10 +102,10 @@ def reload_core_config(hass):
 
 @asyncio.coroutine
 def async_setup(hass, config):
-    """Setup general services related to Home Assistant."""
+    """Set up general services related to Home Assistant."""
     @asyncio.coroutine
     def async_handle_turn_service(service):
-        """Method to handle calls to homeassistant.turn_on/off."""
+        """Handle calls to homeassistant.turn_on/off."""
         entity_ids = extract_entity_ids(hass, service)
 
         # Generic turn on/off method requires entity id

homeassistant/components/alarm_control_panel/__init__.py

@@ -123,8 +123,8 @@ def async_setup(hass, config):
         if update_tasks:
             yield from asyncio.wait(update_tasks, loop=hass.loop)
 
-    descriptions = yield from hass.loop.run_in_executor(
-        None, load_yaml_config_file, os.path.join(
+    descriptions = yield from hass.async_add_job(
+        load_yaml_config_file, os.path.join(
             os.path.dirname(__file__), 'services.yaml'))
 
     for service in SERVICE_TO_METHOD:
@@ -158,8 +158,7 @@ class AlarmControlPanel(Entity):
 
         This method must be run in the event loop and returns a coroutine.
         """
-        return self.hass.loop.run_in_executor(
-            None, self.alarm_disarm, code)
+        return self.hass.async_add_job(self.alarm_disarm, code)
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
@@ -170,8 +169,7 @@ class AlarmControlPanel(Entity):
 
         This method must be run in the event loop and returns a coroutine.
         """
-        return self.hass.loop.run_in_executor(
-            None, self.alarm_arm_home, code)
+        return self.hass.async_add_job(self.alarm_arm_home, code)
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
@@ -182,8 +180,7 @@ class AlarmControlPanel(Entity):
 
         This method must be run in the event loop and returns a coroutine.
         """
-        return self.hass.loop.run_in_executor(
-            None, self.alarm_arm_away, code)
+        return self.hass.async_add_job(self.alarm_arm_away, code)
 
     def alarm_trigger(self, code=None):
         """Send alarm trigger command."""
@@ -194,8 +191,7 @@ class AlarmControlPanel(Entity):
 
         This method must be run in the event loop and returns a coroutine.
         """
-        return self.hass.loop.run_in_executor(
-            None, self.alarm_trigger, code)
+        return self.hass.async_add_job(self.alarm_trigger, code)
 
     @property
     def state_attributes(self):

homeassistant/components/alarm_control_panel/alarmdecoder.py

@@ -25,7 +25,7 @@ DEPENDENCIES = ['alarmdecoder']
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Perform the setup for AlarmDecoder alarm panels."""
+    """Set up for AlarmDecoder alarm panels."""
     _LOGGER.debug("AlarmDecoderAlarmPanel: setup")
 
     device = AlarmDecoderAlarmPanel("Alarm Panel", hass)
@@ -44,7 +44,7 @@ class AlarmDecoderAlarmPanel(alarm.AlarmControlPanel):
         self._name = name
         self._state = STATE_UNKNOWN
 
-        _LOGGER.debug("AlarmDecoderAlarm: Setting up panel")
+        _LOGGER.debug("Setting up panel")
 
     @asyncio.coroutine
     def async_added_to_hass(self):
@@ -78,12 +78,12 @@ class AlarmDecoderAlarmPanel(alarm.AlarmControlPanel):
 
     @property
     def should_poll(self):
-        """No polling needed."""
+        """Return the polling state."""
         return False
 
     @property
     def code_format(self):
-        """Regex for code format or None if no code is required."""
+        """Return the regex for code format or None if no code is required."""
         return '^\\d{4,6}$'
 
     @property
@@ -94,26 +94,23 @@ class AlarmDecoderAlarmPanel(alarm.AlarmControlPanel):
     @asyncio.coroutine
     def async_alarm_disarm(self, code=None):
         """Send disarm command."""
-        _LOGGER.debug("AlarmDecoderAlarm::alarm_disarm: %s", code)
+        _LOGGER.debug("alarm_disarm: %s", code)
         if code:
-            _LOGGER.debug("AlarmDecoderAlarm::alarm_disarm: sending %s1",
-                          str(code))
+            _LOGGER.debug("alarm_disarm: sending %s1", str(code))
             self.hass.data[DATA_AD].send("{!s}1".format(code))
 
     @asyncio.coroutine
     def async_alarm_arm_away(self, code=None):
         """Send arm away command."""
-        _LOGGER.debug("AlarmDecoderAlarm::alarm_arm_away: %s", code)
+        _LOGGER.debug("alarm_arm_away: %s", code)
         if code:
-            _LOGGER.debug("AlarmDecoderAlarm::alarm_arm_away: sending %s2",
-                          str(code))
+            _LOGGER.debug("alarm_arm_away: sending %s2", str(code))
             self.hass.data[DATA_AD].send("{!s}2".format(code))
 
     @asyncio.coroutine
     def async_alarm_arm_home(self, code=None):
         """Send arm home command."""
-        _LOGGER.debug("AlarmDecoderAlarm::alarm_arm_home: %s", code)
+        _LOGGER.debug("alarm_arm_home: %s", code)
         if code:
-            _LOGGER.debug("AlarmDecoderAlarm::alarm_arm_home: sending %s3",
-                          str(code))
+            _LOGGER.debug("alarm_arm_home: sending %s3", str(code))
             self.hass.data[DATA_AD].send("{!s}3".format(code))

homeassistant/components/alarm_control_panel/alarmdotcom.py

@@ -1,5 +1,4 @@
 """
-
 Interfaces with Alarm.com alarm control panels.
 
 For more details about this platform, please refer to the documentation at
@@ -33,7 +32,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Setup a Alarm.com control panel."""
+    """Set up a Alarm.com control panel."""
     name = config.get(CONF_NAME)
     code = config.get(CONF_CODE)
     username = config.get(CONF_USERNAME)

homeassistant/components/alarm_control_panel/concord232.py

@@ -51,7 +51,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class Concord232Alarm(alarm.AlarmControlPanel):
-    """Represents the Concord232-based alarm panel."""
+    """Representation of the Concord232-based alarm panel."""
 
     def __init__(self, hass, url, name):
         """Initialize the Concord232 alarm panel."""
@@ -79,7 +79,7 @@ class Concord232Alarm(alarm.AlarmControlPanel):
 
     @property
     def code_format(self):
-        """The characters if code is defined."""
+        """Return the characters if code is defined."""
         return '[0-9]{4}([0-9]{2})?'
 
     @property
@@ -117,7 +117,7 @@ class Concord232Alarm(alarm.AlarmControlPanel):
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
-        self._alarm.arm('home')
+        self._alarm.arm('stay')
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""

homeassistant/components/alarm_control_panel/demo.py

@@ -8,7 +8,7 @@ import homeassistant.components.alarm_control_panel.manual as manual
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Demo alarm control panel platform."""
+    """Set up the Demo alarm control panel platform."""
     add_devices([
         manual.ManualAlarm(hass, 'Alarm', '1234', 5, 10, False),
     ])

homeassistant/components/alarm_control_panel/envisalink.py

@@ -70,8 +70,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
             device.async_alarm_keypress(keypress)
 
     # Register Envisalink specific services
-    descriptions = yield from hass.loop.run_in_executor(
-        None, load_yaml_config_file, os.path.join(
+    descriptions = yield from hass.async_add_job(
+        load_yaml_config_file, os.path.join(
             os.path.dirname(__file__), 'services.yaml'))
 
     hass.services.async_register(
@@ -104,7 +104,7 @@ class EnvisalinkAlarm(EnvisalinkDevice, alarm.AlarmControlPanel):
 
     @callback
     def _update_callback(self, partition):
-        """Update HA state, if needed."""
+        """Update Home Assistant state, if needed."""
         if partition is None or int(partition) == self._partition_number:
             self.hass.async_add_job(self.async_update_ha_state())
 

homeassistant/components/alarm_control_panel/manual.py

@@ -39,7 +39,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the manual alarm platform."""
+    """Set up the manual alarm platform."""
     add_devices([ManualAlarm(
         hass,
         config[CONF_NAME],
@@ -52,7 +52,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 class ManualAlarm(alarm.AlarmControlPanel):
     """
-    Represents an alarm status.
+    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
@@ -62,7 +62,7 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
     def __init__(self, hass, name, code, pending_time,
                  trigger_time, disarm_after_trigger):
-        """Initalize the manual alarm panel."""
+        """Init the manual alarm panel."""
         self._state = STATE_ALARM_DISARMED
         self._hass = hass
         self._name = name
@@ -75,7 +75,7 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
     @property
     def should_poll(self):
-        """No polling needed."""
+        """Return the plling state."""
         return False
 
     @property
@@ -166,5 +166,5 @@ class ManualAlarm(alarm.AlarmControlPanel):
         """Validate given code."""
         check = self._code is None or code == self._code
         if not check:
-            _LOGGER.warning('Invalid code given for %s', state)
+            _LOGGER.warning("Invalid code given for %s", state)
         return check

homeassistant/components/alarm_control_panel/mqtt.py

@@ -45,7 +45,7 @@ PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Setup the MQTT platform."""
+    """Set up the MQTT Alarm Control Panel platform."""
     async_add_devices([MqttAlarm(
         config.get(CONF_NAME),
         config.get(CONF_STATE_TOPIC),
@@ -62,7 +62,7 @@ class MqttAlarm(alarm.AlarmControlPanel):
 
     def __init__(self, name, state_topic, command_topic, qos, payload_disarm,
                  payload_arm_home, payload_arm_away, code):
-        """Initalize the MQTT alarm panel."""
+        """Init the MQTT Alarm Control Panel."""
         self._state = STATE_UNKNOWN
         self._name = name
         self._state_topic = state_topic
@@ -80,11 +80,11 @@ class MqttAlarm(alarm.AlarmControlPanel):
         """
         @callback
         def message_received(topic, payload, qos):
-            """A new MQTT message has been received."""
+            """Run when new MQTT message has been received."""
             if payload not in (STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME,
                                STATE_ALARM_ARMED_AWAY, STATE_ALARM_PENDING,
                                STATE_ALARM_TRIGGERED):
-                _LOGGER.warning('Received unexpected payload: %s', payload)
+                _LOGGER.warning("Received unexpected payload: %s", payload)
                 return
             self._state = payload
             self.hass.async_add_job(self.async_update_ha_state())

homeassistant/components/alarm_control_panel/nx584.py

@@ -32,7 +32,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup nx584 platform."""
+    """Set up the nx584 platform."""
     name = config.get(CONF_NAME)
     host = config.get(CONF_HOST)
     port = config.get(CONF_PORT)
@@ -42,15 +42,15 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     try:
         add_devices([NX584Alarm(hass, url, name)])
     except requests.exceptions.ConnectionError as ex:
-        _LOGGER.error('Unable to connect to NX584: %s', str(ex))
+        _LOGGER.error("Unable to connect to NX584: %s", str(ex))
         return False
 
 
 class NX584Alarm(alarm.AlarmControlPanel):
-    """Represents the NX584-based alarm panel."""
+    """Representation of a NX584-based alarm panel."""
 
     def __init__(self, hass, url, name):
-        """Initalize the nx584 alarm panel."""
+        """Init the nx584 alarm panel."""
         from nx584 import client
         self._hass = hass
         self._name = name
@@ -69,7 +69,7 @@ class NX584Alarm(alarm.AlarmControlPanel):
 
     @property
     def code_format(self):
-        """The characters if code is defined."""
+        """Return che characters if code is defined."""
         return '[0-9]{4}([0-9]{2})?'
 
     @property
@@ -83,20 +83,19 @@ class NX584Alarm(alarm.AlarmControlPanel):
             part = self._alarm.list_partitions()[0]
             zones = self._alarm.list_zones()
         except requests.exceptions.ConnectionError as ex:
-            _LOGGER.error('Unable to connect to %(host)s: %(reason)s',
+            _LOGGER.error("Unable to connect to %(host)s: %(reason)s",
                           dict(host=self._url, reason=ex))
             self._state = STATE_UNKNOWN
             zones = []
         except IndexError:
-            _LOGGER.error('nx584 reports no partitions')
+            _LOGGER.error("nx584 reports no partitions")
             self._state = STATE_UNKNOWN
             zones = []
 
         bypassed = False
         for zone in zones:
             if zone['bypassed']:
-                _LOGGER.debug('Zone %(zone)s is bypassed, '
-                              'assuming HOME',
+                _LOGGER.debug("Zone %(zone)s is bypassed, assuming HOME",
                               dict(zone=zone['number']))
                 bypassed = True
                 break

homeassistant/components/alarm_control_panel/simplisafe.py

@@ -123,25 +123,25 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
         if not self._validate_code(code, 'disarming'):
             return
         self.simplisafe.set_state('off')
-        _LOGGER.info('SimpliSafe alarm disarming')
+        _LOGGER.info("SimpliSafe alarm disarming")
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
         if not self._validate_code(code, 'arming home'):
             return
         self.simplisafe.set_state('home')
-        _LOGGER.info('SimpliSafe alarm arming home')
+        _LOGGER.info("SimpliSafe alarm arming home")
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         if not self._validate_code(code, 'arming away'):
             return
         self.simplisafe.set_state('away')
-        _LOGGER.info('SimpliSafe alarm arming away')
+        _LOGGER.info("SimpliSafe alarm arming away")
 
     def _validate_code(self, code, state):
         """Validate given code."""
         check = self._code is None or code == self._code
         if not check:
-            _LOGGER.warning('Wrong code entered for %s', state)
+            _LOGGER.warning("Wrong code entered for %s", state)
         return check

homeassistant/components/alarm_control_panel/totalconnect.py

@@ -1,15 +1,20 @@
-"""Interfaces with TotalConnect alarm control panels."""
+"""
+Interfaces with TotalConnect alarm control panels.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.totalconnect/
+"""
 import logging
 
 import voluptuous as vol
 
+import homeassistant.helpers.config_validation as cv
 import homeassistant.components.alarm_control_panel as alarm
 from homeassistant.components.alarm_control_panel import PLATFORM_SCHEMA
 from homeassistant.const import (
     CONF_PASSWORD, CONF_USERNAME, STATE_ALARM_ARMED_AWAY,
     STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED, STATE_UNKNOWN,
     CONF_NAME)
-import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['total_connect_client==0.7']
 
@@ -25,7 +30,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup a TotalConnect control panel."""
+    """Set up a TotalConnect control panel."""
     name = config.get(CONF_NAME)
     username = config.get(CONF_USERNAME)
     password = config.get(CONF_PASSWORD)
@@ -41,13 +46,13 @@ class TotalConnect(alarm.AlarmControlPanel):
         """Initialize the TotalConnect status."""
         from total_connect_client import TotalConnectClient
 
-        _LOGGER.debug('Setting up TotalConnect...')
+        _LOGGER.debug("Setting up TotalConnect...")
         self._name = name
         self._username = username
         self._password = password
         self._state = STATE_UNKNOWN
-        self._client = TotalConnectClient.TotalConnectClient(username,
-                                                             password)
+        self._client = TotalConnectClient.TotalConnectClient(
+            username, password)
 
     @property
     def name(self):

homeassistant/components/alarm_control_panel/verisure.py

@@ -17,7 +17,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Verisure platform."""
+    """Set up the Verisure platform."""
     alarms = []
     if int(hub.config.get(CONF_ALARM, 1)):
         hub.update_alarms()
@@ -29,10 +29,10 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class VerisureAlarm(alarm.AlarmControlPanel):
-    """Represent a Verisure alarm status."""
+    """Representation of a Verisure alarm status."""
 
     def __init__(self, device_id):
-        """Initalize the Verisure alarm panel."""
+        """Initialize the Verisure alarm panel."""
         self._id = device_id
         self._state = STATE_UNKNOWN
         self._digits = hub.config.get(CONF_CODE_DIGITS)
@@ -55,12 +55,12 @@ class VerisureAlarm(alarm.AlarmControlPanel):
 
     @property
     def code_format(self):
-        """The code format as regex."""
+        """Return the code format as regex."""
         return '^\\d{%s}$' % self._digits
 
     @property
     def changed_by(self):
-        """Last change triggered by."""
+        """Return the last change triggered by."""
         return self._changed_by
 
     def update(self):
@@ -75,24 +75,23 @@ class VerisureAlarm(alarm.AlarmControlPanel):
             self._state = STATE_ALARM_ARMED_AWAY
         elif hub.alarm_status[self._id].status != 'pending':
             _LOGGER.error(
-                'Unknown alarm state %s',
-                hub.alarm_status[self._id].status)
+                "Unknown alarm state %s", hub.alarm_status[self._id].status)
         self._changed_by = hub.alarm_status[self._id].name
 
     def alarm_disarm(self, code=None):
         """Send disarm command."""
         hub.my_pages.alarm.set(code, 'DISARMED')
-        _LOGGER.info('verisure alarm disarming')
+        _LOGGER.info("Verisure alarm disarming")
         hub.my_pages.alarm.wait_while_pending()
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
         hub.my_pages.alarm.set(code, 'ARMED_HOME')
-        _LOGGER.info('verisure alarm arming home')
+        _LOGGER.info("Verisure alarm arming home")
         hub.my_pages.alarm.wait_while_pending()
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         hub.my_pages.alarm.set(code, 'ARMED_AWAY')
-        _LOGGER.info('verisure alarm arming away')
+        _LOGGER.info("Verisure alarm arming away")
         hub.my_pages.alarm.wait_while_pending()

homeassistant/components/alarm_control_panel/wink.py

@@ -4,6 +4,7 @@ Interfaces with Wink Cameras.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel.wink/
 """
+import asyncio
 import logging
 
 import homeassistant.components.alarm_control_panel as alarm
@@ -16,11 +17,12 @@ from homeassistant.components.wink import WinkDevice, DOMAIN
 _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['wink']
+
 STATE_ALARM_PRIVACY = 'Private'
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Wink platform."""
+    """Set up the Wink platform."""
     import pywink
 
     for camera in pywink.get_cameras():
@@ -41,6 +43,11 @@ class WinkCameraDevice(WinkDevice, alarm.AlarmControlPanel):
         """Initialize the Wink alarm."""
         super().__init__(wink, hass)
 
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Callback when entity is added to hass."""
+        self.hass.data[DOMAIN]['entities']['alarm_control_panel'].append(self)
+
     @property
     def state(self):
         """Return the state of the device."""

homeassistant/components/alarmdecoder.py

@@ -8,11 +8,10 @@ import asyncio
 import logging
 
 import voluptuous as vol
-import homeassistant.helpers.config_validation as cv
 
+import homeassistant.helpers.config_validation as cv
 from homeassistant.core import callback
 from homeassistant.const import EVENT_HOMEASSISTANT_STOP
-
 from homeassistant.helpers.discovery import async_load_platform
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
@@ -24,19 +23,16 @@ DOMAIN = 'alarmdecoder'
 
 DATA_AD = 'alarmdecoder'
 
-
 CONF_DEVICE = 'device'
-CONF_DEVICE_TYPE = 'type'
-CONF_DEVICE_HOST = 'host'
-CONF_DEVICE_PORT = 'port'
-CONF_DEVICE_PATH = 'path'
 CONF_DEVICE_BAUD = 'baudrate'
-
-CONF_ZONES = 'zones'
+CONF_DEVICE_HOST = 'host'
+CONF_DEVICE_PATH = 'path'
+CONF_DEVICE_PORT = 'port'
+CONF_DEVICE_TYPE = 'type'
+CONF_PANEL_DISPLAY = 'panel_display'
 CONF_ZONE_NAME = 'name'
 CONF_ZONE_TYPE = 'type'
-
-CONF_PANEL_DISPLAY = 'panel_display'
+CONF_ZONES = 'zones'
 
 DEFAULT_DEVICE_TYPE = 'socket'
 DEFAULT_DEVICE_HOST = 'localhost'
@@ -87,7 +83,7 @@ CONFIG_SCHEMA = vol.Schema({
 
 @asyncio.coroutine
 def async_setup(hass, config):
-    """Common setup for AlarmDecoder devices."""
+    """Set up for the AlarmDecoder devices."""
     from alarmdecoder import AlarmDecoder
     from alarmdecoder.devices import (SocketDevice, SerialDevice, USBDevice)
 
@@ -106,28 +102,28 @@ def async_setup(hass, config):
     sync_connect = asyncio.Future(loop=hass.loop)
 
     def handle_open(device):
-        """Callback for a successful connection."""
-        _LOGGER.info("Established a connection with the alarmdecoder.")
+        """Handle the successful connection."""
+        _LOGGER.info("Established a connection with the alarmdecoder")
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, stop_alarmdecoder)
         sync_connect.set_result(True)
 
     @callback
     def stop_alarmdecoder(event):
-        """Callback to handle shutdown alarmdecoder."""
-        _LOGGER.debug("Shutting down alarmdecoder.")
+        """Handle the shutdown of AlarmDecoder."""
+        _LOGGER.debug("Shutting down alarmdecoder")
         controller.close()
 
     @callback
     def handle_message(sender, message):
-        """Callback to handle message from alarmdecoder."""
+        """Handle message from AlarmDecoder."""
         async_dispatcher_send(hass, SIGNAL_PANEL_MESSAGE, message)
 
     def zone_fault_callback(sender, zone):
-        """Callback to handle zone fault from alarmdecoder."""
+        """Handle zone fault from AlarmDecoder."""
         async_dispatcher_send(hass, SIGNAL_ZONE_FAULT, zone)
 
     def zone_restore_callback(sender, zone):
-        """Callback to handle zone restore from alarmdecoder."""
+        """Handle zone restore from AlarmDecoder."""
         async_dispatcher_send(hass, SIGNAL_ZONE_RESTORE, zone)
 
     controller = False
@@ -157,15 +153,16 @@ def async_setup(hass, config):
     if not result:
         return False
 
-    hass.async_add_job(async_load_platform(hass, 'alarm_control_panel', DOMAIN,
-                                           conf, config))
+    hass.async_add_job(
+        async_load_platform(hass, 'alarm_control_panel', DOMAIN, conf,
+                            config))
 
     if zones:
         hass.async_add_job(async_load_platform(
             hass, 'binary_sensor', DOMAIN, {CONF_ZONES: zones}, config))
 
     if display:
-        hass.async_add_job(async_load_platform(hass, 'sensor', DOMAIN,
-                                               conf, config))
+        hass.async_add_job(async_load_platform(
+            hass, 'sensor', DOMAIN, conf, config))
 
     return True

homeassistant/components/alert.py

@@ -128,8 +128,8 @@ def async_setup(hass, config):
         all_alerts[entity.entity_id] = entity
 
     # Read descriptions
-    descriptions = yield from hass.loop.run_in_executor(
-        None, load_yaml_config_file, os.path.join(
+    descriptions = yield from hass.async_add_job(
+        load_yaml_config_file, os.path.join(
             os.path.dirname(__file__), 'services.yaml'))
     descriptions = descriptions.get(DOMAIN, {})
 

homeassistant/components/alexa.py

@@ -17,7 +17,6 @@ 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
-import homeassistant.util.dt as dt_util
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,7 +35,6 @@ CONF_TEXT = 'text'
 
 CONF_FLASH_BRIEFINGS = 'flash_briefings'
 CONF_UID = 'uid'
-CONF_DATE = 'date'
 CONF_TITLE = 'title'
 CONF_AUDIO = 'audio'
 CONF_TEXT = 'text'
@@ -88,7 +86,6 @@ CONFIG_SCHEMA = vol.Schema({
         CONF_FLASH_BRIEFINGS: {
             cv.string: vol.All(cv.ensure_list, [{
                 vol.Required(CONF_UID, default=str(uuid.uuid4())): cv.string,
-                vol.Optional(CONF_DATE, default=datetime.utcnow()): cv.string,
                 vol.Required(CONF_TITLE): cv.template,
                 vol.Optional(CONF_AUDIO): cv.template,
                 vol.Required(CONF_TEXT, default=""): cv.template,
@@ -331,10 +328,7 @@ class AlexaFlashBriefingView(HomeAssistantView):
                 else:
                     output[ATTR_REDIRECTION_URL] = item.get(CONF_DISPLAY_URL)
 
-            if isinstance(item[CONF_DATE], str):
-                item[CONF_DATE] = dt_util.parse_datetime(item[CONF_DATE])
-
-            output[ATTR_UPDATE_DATE] = item[CONF_DATE].strftime(DATE_FORMAT)
+            output[ATTR_UPDATE_DATE] = datetime.now().strftime(DATE_FORMAT)
 
             briefing.append(output)
 

homeassistant/components/apcupsd.py

@@ -13,7 +13,7 @@ from homeassistant.const import (CONF_HOST, CONF_PORT)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util import Throttle
 
-REQUIREMENTS = ['apcaccess==0.0.4']
+REQUIREMENTS = ['apcaccess==0.0.10']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/api.py

@@ -83,7 +83,7 @@ class APIEventStream(HomeAssistantView):
         stop_obj = object()
         to_write = asyncio.Queue(loop=hass.loop)
 
-        restrict = request.GET.get('restrict')
+        restrict = request.query.get('restrict')
         if restrict:
             restrict = restrict.split(',') + [EVENT_HOMEASSISTANT_STOP]
 

homeassistant/components/arlo.py

@@ -0,0 +1,60 @@
+"""
+This component provides basic support for Netgear Arlo IP cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/arlo/
+"""
+import logging
+import voluptuous as vol
+from homeassistant.helpers import config_validation as cv
+
+from homeassistant.const import CONF_USERNAME, CONF_PASSWORD
+import homeassistant.loader as loader
+
+from requests.exceptions import HTTPError, ConnectTimeout
+
+REQUIREMENTS = ['pyarlo==0.0.4']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ATTRIBUTION = 'Data provided by arlo.netgear.com'
+
+DOMAIN = 'arlo'
+
+DEFAULT_BRAND = 'Netgear Arlo'
+
+NOTIFICATION_ID = 'arlo_notification'
+NOTIFICATION_TITLE = 'Arlo Camera Setup'
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_USERNAME): cv.string,
+        vol.Required(CONF_PASSWORD): cv.string,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+def setup(hass, config):
+    """Set up an Arlo component."""
+    conf = config[DOMAIN]
+    username = conf.get(CONF_USERNAME)
+    password = conf.get(CONF_PASSWORD)
+
+    persistent_notification = loader.get_component('persistent_notification')
+    try:
+        from pyarlo import PyArlo
+
+        arlo = PyArlo(username, password, preload=False)
+        if not arlo.is_connected:
+            return False
+        hass.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 />'
+            'You will need to restart hass after fixing.'
+            ''.format(ex),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
+        return False
+    return True

homeassistant/components/automation/__init__.py

@@ -16,7 +16,7 @@ from homeassistant.core import CoreState
 from homeassistant import config as conf_util
 from homeassistant.const import (
     ATTR_ENTITY_ID, CONF_PLATFORM, STATE_ON, SERVICE_TURN_ON, SERVICE_TURN_OFF,
-    SERVICE_TOGGLE, SERVICE_RELOAD, EVENT_HOMEASSISTANT_START)
+    SERVICE_TOGGLE, SERVICE_RELOAD, EVENT_HOMEASSISTANT_START, CONF_ID)
 from homeassistant.components import logbook
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import extract_domain_configs, script, condition
@@ -26,6 +26,7 @@ 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'
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
@@ -81,6 +82,8 @@ _TRIGGER_SCHEMA = vol.All(
 _CONDITION_SCHEMA = vol.All(cv.ensure_list, [cv.CONDITION_SCHEMA])
 
 PLATFORM_SCHEMA = vol.Schema({
+    # str on purpose
+    CONF_ID: str,
     CONF_ALIAS: cv.string,
     vol.Optional(CONF_INITIAL_STATE): cv.boolean,
     vol.Optional(CONF_HIDE_ENTITY, default=DEFAULT_HIDE_ENTITY): cv.boolean,
@@ -139,19 +142,24 @@ def reload(hass):
     hass.services.call(DOMAIN, SERVICE_RELOAD)
 
 
+def async_reload(hass):
+    """Reload the automation from config.
+
+    Returns a coroutine object.
+    """
+    return hass.services.async_call(DOMAIN, SERVICE_RELOAD)
+
+
 @asyncio.coroutine
 def async_setup(hass, config):
-    """Setup the automation."""
+    """Set up the automation."""
     component = EntityComponent(_LOGGER, DOMAIN, hass,
                                 group_name=GROUP_NAME_ALL_AUTOMATIONS)
 
-    success = yield from _async_process_config(hass, config, component)
+    yield from _async_process_config(hass, config, component)
 
-    if not success:
-        return False
-
-    descriptions = yield from hass.loop.run_in_executor(
-        None, conf_util.load_yaml_config_file, os.path.join(
+    descriptions = yield from hass.async_add_job(
+        conf_util.load_yaml_config_file, os.path.join(
             os.path.dirname(__file__), 'services.yaml')
     )
 
@@ -215,15 +223,20 @@ 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
 
 
 class AutomationEntity(ToggleEntity):
     """Entity to show status of entity."""
 
-    def __init__(self, name, async_attach_triggers, cond_func, async_action,
-                 hidden, initial_state):
+    def __init__(self, automation_id, name, async_attach_triggers, cond_func,
+                 async_action, hidden, initial_state):
         """Initialize an automation entity."""
+        self._id = automation_id
         self._name = name
         self._async_attach_triggers = async_attach_triggers
         self._async_detach_triggers = None
@@ -346,6 +359,16 @@ class AutomationEntity(ToggleEntity):
             self.async_trigger)
         yield from self.async_update_ha_state()
 
+    @property
+    def device_state_attributes(self):
+        """Return automation attributes."""
+        if self._id is None:
+            return None
+
+        return {
+            CONF_ID: self._id
+        }
+
 
 @asyncio.coroutine
 def _async_process_config(hass, config, component):
@@ -359,6 +382,7 @@ def _async_process_config(hass, config, component):
         conf = config[config_key]
 
         for list_no, config_block in enumerate(conf):
+            automation_id = config_block.get(CONF_ID)
             name = config_block.get(CONF_ALIAS) or "{} {}".format(config_key,
                                                                   list_no)
 
@@ -383,16 +407,14 @@ def _async_process_config(hass, config, component):
                 config_block.get(CONF_TRIGGER, []), name
             )
             entity = AutomationEntity(
-                name, async_attach_triggers, cond_func, action, hidden,
-                initial_state)
+                automation_id, name, async_attach_triggers, cond_func, action,
+                hidden, initial_state)
 
             entities.append(entity)
 
     if entities:
         yield from component.async_add_entities(entities)
 
-    return len(entities) > 0
-
 
 def _async_get_action(hass, config, name):
     """Return an action based on a configuration."""
@@ -400,7 +422,7 @@ def _async_get_action(hass, config, name):
 
     @asyncio.coroutine
     def action(entity_id, variables):
-        """Action to be executed."""
+        """Execute an action."""
         _LOGGER.info('Executing %s', name)
         logbook.async_log_entry(
             hass, name, 'has been triggered', DOMAIN, entity_id)
@@ -430,7 +452,7 @@ def _async_process_if(hass, config, p_config):
 
 @asyncio.coroutine
 def _async_process_trigger(hass, config, trigger_configs, name, action):
-    """Setup the triggers.
+    """Set up the triggers.
 
     This method is a coroutine.
     """

homeassistant/components/automation/event.py

@@ -9,12 +9,12 @@ import logging
 
 import voluptuous as vol
 
-from homeassistant.core import callback, CoreState
-from homeassistant.const import CONF_PLATFORM, EVENT_HOMEASSISTANT_START
+from homeassistant.core import callback
+from homeassistant.const import CONF_PLATFORM
 from homeassistant.helpers import config_validation as cv
 
-CONF_EVENT_TYPE = "event_type"
-CONF_EVENT_DATA = "event_data"
+CONF_EVENT_TYPE = 'event_type'
+CONF_EVENT_DATA = 'event_data'
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -31,19 +31,6 @@ def async_trigger(hass, config, action):
     event_type = config.get(CONF_EVENT_TYPE)
     event_data = config.get(CONF_EVENT_DATA)
 
-    if (event_type == EVENT_HOMEASSISTANT_START and
-            hass.state == CoreState.starting):
-        _LOGGER.warning('Deprecation: Automations should not listen to event '
-                        "'homeassistant_start'. Use platform 'homeassistant' "
-                        'instead. Feature will be removed in 0.45')
-        hass.async_run_job(action, {
-            'trigger': {
-                'platform': 'event',
-                'event': None,
-            },
-        })
-        return lambda: None
-
     @callback
     def handle_event(event):
         """Listen for events and calls the action when data matches."""

homeassistant/components/automation/homeassistant.py

@@ -31,7 +31,7 @@ def async_trigger(hass, config, action):
     if event == EVENT_SHUTDOWN:
         @callback
         def hass_shutdown(event):
-            """Called when Home Assistant is shutting down."""
+            """Execute when Home Assistant is shutting down."""
             hass.async_run_job(action, {
                 'trigger': {
                     'platform': 'homeassistant',

homeassistant/components/automation/state.py

@@ -12,13 +12,14 @@ 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"
+CONF_ENTITY_ID = 'entity_id'
+CONF_FROM = 'from'
+CONF_TO = 'to'
+CONF_STATE = 'state'
+CONF_FOR = 'for'
 
 TRIGGER_SCHEMA = vol.All(
     vol.Schema({
@@ -40,10 +41,11 @@ 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 = config.get(CONF_TO) or config.get(CONF_STATE) or MATCH_ALL
+    to_state = get_deprecated(config, CONF_TO, CONF_STATE, MATCH_ALL)
     time_delta = config.get(CONF_FOR)
     async_remove_state_for_cancel = None
     async_remove_state_for_listener = None
+    match_all = (from_state == MATCH_ALL and to_state == MATCH_ALL)
 
     @callback
     def clear_listener():
@@ -75,6 +77,11 @@ def async_trigger(hass, config, action):
                 }
             })
 
+        # Ignore changes to state attributes if from/to is in use
+        if (not match_all and from_s is not None and to_s is not None and
+                from_s.last_changed == to_s.last_changed):
+            return
+
         if time_delta is None:
             call_action()
             return

homeassistant/components/automation/sun.py

@@ -16,8 +16,6 @@ from homeassistant.const import (
 from homeassistant.helpers.event import async_track_sunrise, async_track_sunset
 import homeassistant.helpers.config_validation as cv
 
-DEPENDENCIES = ['sun']
-
 _LOGGER = logging.getLogger(__name__)
 
 TRIGGER_SCHEMA = vol.Schema({

homeassistant/components/automation/time.py

@@ -10,32 +10,38 @@ import logging
 import voluptuous as vol
 
 from homeassistant.core import callback
-from homeassistant.const import CONF_AFTER, CONF_PLATFORM
+from homeassistant.const import CONF_AT, CONF_PLATFORM, CONF_AFTER
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.event import async_track_time_change
 
-CONF_HOURS = "hours"
-CONF_MINUTES = "minutes"
-CONF_SECONDS = "seconds"
+CONF_HOURS = 'hours'
+CONF_MINUTES = 'minutes'
+CONF_SECONDS = 'seconds'
 
 _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_AFTER))
+                            CONF_SECONDS, CONF_AT, CONF_AFTER))
 
 
 @asyncio.coroutine
 def async_trigger(hass, config, action):
     """Listen for state changes based on configuration."""
-    if CONF_AFTER in config:
-        after = config.get(CONF_AFTER)
-        hours, minutes, seconds = after.hour, after.minute, after.second
+    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/automation/zone.py

@@ -14,8 +14,8 @@ from homeassistant.helpers.event import async_track_state_change
 from homeassistant.helpers import (
     condition, config_validation as cv, location)
 
-EVENT_ENTER = "enter"
-EVENT_LEAVE = "leave"
+EVENT_ENTER = 'enter'
+EVENT_LEAVE = 'leave'
 DEFAULT_EVENT = EVENT_ENTER
 
 TRIGGER_SCHEMA = vol.Schema({

homeassistant/components/axis.py

@@ -0,0 +1,314 @@
+"""
+Support for Axis devices.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/axis/
+"""
+
+import json
+import logging
+import os
+
+import voluptuous as vol
+
+from homeassistant.const import (ATTR_LOCATION, ATTR_TRIPPED,
+                                 CONF_HOST, CONF_INCLUDE, CONF_NAME,
+                                 CONF_PASSWORD, CONF_TRIGGER_TIME,
+                                 CONF_USERNAME, EVENT_HOMEASSISTANT_STOP)
+from homeassistant.components.discovery import SERVICE_AXIS
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import discovery
+from homeassistant.helpers.entity import Entity
+from homeassistant.loader import get_component
+
+
+REQUIREMENTS = ['axis==7']
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = 'axis'
+CONFIG_FILE = 'axis.conf'
+
+AXIS_DEVICES = {}
+
+EVENT_TYPES = ['motion', 'vmd3', 'pir', 'sound',
+               'daynight', 'tampering', 'input']
+
+PLATFORMS = ['camera']
+
+AXIS_INCLUDE = EVENT_TYPES + PLATFORMS
+
+AXIS_DEFAULT_HOST = '192.168.0.90'
+AXIS_DEFAULT_USERNAME = 'root'
+AXIS_DEFAULT_PASSWORD = 'pass'
+
+DEVICE_SCHEMA = vol.Schema({
+    vol.Required(CONF_INCLUDE):
+        vol.All(cv.ensure_list, [vol.In(AXIS_INCLUDE)]),
+    vol.Optional(CONF_NAME): cv.string,
+    vol.Optional(CONF_HOST, default=AXIS_DEFAULT_HOST): cv.string,
+    vol.Optional(CONF_USERNAME, default=AXIS_DEFAULT_USERNAME): cv.string,
+    vol.Optional(CONF_PASSWORD, default=AXIS_DEFAULT_PASSWORD): cv.string,
+    vol.Optional(CONF_TRIGGER_TIME, default=0): cv.positive_int,
+    vol.Optional(ATTR_LOCATION, default=''): cv.string,
+})
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        cv.slug: DEVICE_SCHEMA,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+def request_configuration(hass, name, host, serialnumber):
+    """Request configuration steps from the user."""
+    configurator = get_component('configurator')
+
+    def configuration_callback(callback_data):
+        """Called when config is submitted."""
+        if CONF_INCLUDE not in callback_data:
+            configurator.notify_errors(request_id,
+                                       "Functionality mandatory.")
+            return False
+        callback_data[CONF_INCLUDE] = callback_data[CONF_INCLUDE].split()
+        callback_data[CONF_HOST] = host
+        if CONF_NAME not in callback_data:
+            callback_data[CONF_NAME] = name
+        try:
+            config = DEVICE_SCHEMA(callback_data)
+        except vol.Invalid:
+            configurator.notify_errors(request_id,
+                                       "Bad input, please check spelling.")
+            return False
+
+        if setup_device(hass, config):
+            config_file = _read_config(hass)
+            config_file[serialnumber] = dict(config)
+            del config_file[serialnumber]['hass']
+            _write_config(hass, config_file)
+            configurator.request_done(request_id)
+        else:
+            configurator.notify_errors(request_id,
+                                       "Failed to register, please try again.")
+            return False
+
+    title = '{} ({})'.format(name, host)
+    request_id = configurator.request_config(
+        hass, title, configuration_callback,
+        description='Functionality: ' + str(AXIS_INCLUDE),
+        entity_picture="/static/images/logo_axis.png",
+        link_name='Axis platform documentation',
+        link_url='https://home-assistant.io/components/axis/',
+        submit_caption="Confirm",
+        fields=[
+            {'id': CONF_NAME,
+             'name': "Device name",
+             'type': 'text'},
+            {'id': CONF_USERNAME,
+             'name': "User name",
+             'type': 'text'},
+            {'id': CONF_PASSWORD,
+             'name': 'Password',
+             'type': 'password'},
+            {'id': CONF_INCLUDE,
+             'name': "Device functionality (space separated list)",
+             'type': 'text'},
+            {'id': ATTR_LOCATION,
+             'name': "Physical location of device (optional)",
+             'type': 'text'},
+            {'id': CONF_TRIGGER_TIME,
+             'name': "Sensor update interval (optional)",
+             'type': 'number'},
+        ]
+    )
+
+
+def setup(hass, base_config):
+    """Common setup for Axis devices."""
+    def _shutdown(call):  # pylint: disable=unused-argument
+        """Stop the metadatastream on shutdown."""
+        for serialnumber, device in AXIS_DEVICES.items():
+            _LOGGER.info("Stopping metadatastream for %s.", serialnumber)
+            device.stop_metadatastream()
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)
+
+    def axis_device_discovered(service, discovery_info):
+        """Called when axis devices has been found."""
+        host = discovery_info['host']
+        name = discovery_info['hostname']
+        serialnumber = discovery_info['properties']['macaddress']
+
+        if serialnumber not in AXIS_DEVICES:
+            config_file = _read_config(hass)
+            if serialnumber in config_file:
+                try:
+                    config = DEVICE_SCHEMA(config_file[serialnumber])
+                except vol.Invalid as err:
+                    _LOGGER.error("Bad data from %s. %s", CONFIG_FILE, err)
+                    return False
+                if not setup_device(hass, config):
+                    _LOGGER.error("Couldn\'t set up %s", config['name'])
+            else:
+                request_configuration(hass, name, host, serialnumber)
+
+    discovery.listen(hass, SERVICE_AXIS, axis_device_discovered)
+
+    if DOMAIN in base_config:
+        for device in base_config[DOMAIN]:
+            config = base_config[DOMAIN][device]
+            if CONF_NAME not in config:
+                config[CONF_NAME] = device
+            if not setup_device(hass, config):
+                _LOGGER.error("Couldn\'t set up %s", config['name'])
+
+    return True
+
+
+def setup_device(hass, config):
+    """Set up device."""
+    from axis import AxisDevice
+
+    config['hass'] = hass
+    device = AxisDevice(config)  # Initialize device
+    enable_metadatastream = False
+
+    if device.serial_number is None:
+        # If there is no serial number a connection could not be made
+        _LOGGER.error("Couldn\'t connect to %s", config[CONF_HOST])
+        return False
+
+    for component in config[CONF_INCLUDE]:
+        if component in EVENT_TYPES:
+            # Sensors are created by device calling event_initialized
+            # when receiving initialize messages on metadatastream
+            device.add_event_topic(convert(component, 'type', 'subscribe'))
+            if not enable_metadatastream:
+                enable_metadatastream = True
+        else:
+            discovery.load_platform(hass, component, DOMAIN, config)
+
+    if enable_metadatastream:
+        device.initialize_new_event = event_initialized
+        device.initiate_metadatastream()
+    AXIS_DEVICES[device.serial_number] = device
+    return True
+
+
+def _read_config(hass):
+    """Read Axis config."""
+    path = hass.config.path(CONFIG_FILE)
+
+    if not os.path.isfile(path):
+        return {}
+
+    with open(path) as f_handle:
+        # Guard against empty file
+        return json.loads(f_handle.read() or '{}')
+
+
+def _write_config(hass, config):
+    """Write Axis config."""
+    data = json.dumps(config)
+    with open(hass.config.path(CONFIG_FILE), 'w', encoding='utf-8') as outfile:
+        outfile.write(data)
+
+
+def event_initialized(event):
+    """Register event initialized on metadatastream here."""
+    hass = event.device_config('hass')
+    discovery.load_platform(hass,
+                            convert(event.topic, 'topic', 'platform'),
+                            DOMAIN, {'axis_event': event})
+
+
+class AxisDeviceEvent(Entity):
+    """Representation of a Axis device event."""
+
+    def __init__(self, axis_event):
+        """Initialize the event."""
+        self.axis_event = axis_event
+        self._event_class = convert(self.axis_event.topic, 'topic', 'class')
+        self._name = '{}_{}_{}'.format(self.axis_event.device_name,
+                                       convert(self.axis_event.topic,
+                                               'topic', 'type'),
+                                       self.axis_event.id)
+        self.axis_event.callback = self._update_callback
+
+    def _update_callback(self):
+        """Update the sensor's state, if needed."""
+        self.update()
+        self.schedule_update_ha_state()
+
+    @property
+    def name(self):
+        """Return the name of the event."""
+        return self._name
+
+    @property
+    def device_class(self):
+        """Return the class of the event."""
+        return self._event_class
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the event."""
+        attr = {}
+
+        tripped = self.axis_event.is_tripped
+        attr[ATTR_TRIPPED] = 'True' if tripped else 'False'
+
+        location = self.axis_event.device_config(ATTR_LOCATION)
+        if location:
+            attr[ATTR_LOCATION] = location
+
+        return attr
+
+
+def convert(item, from_key, to_key):
+    """Translate between Axis and HASS syntax."""
+    for entry in REMAP:
+        if entry[from_key] == item:
+            return entry[to_key]
+
+
+REMAP = [{'type': 'motion',
+          'class': 'motion',
+          'topic': 'tns1:VideoAnalytics/tnsaxis:MotionDetection',
+          'subscribe': 'onvif:VideoAnalytics/axis:MotionDetection',
+          'platform': 'binary_sensor'},
+         {'type': 'vmd3',
+          'class': 'motion',
+          'topic': 'tns1:RuleEngine/tnsaxis:VMD3/vmd3_video_1',
+          'subscribe': 'onvif:RuleEngine/axis:VMD3/vmd3_video_1',
+          'platform': 'binary_sensor'},
+         {'type': 'pir',
+          'class': 'motion',
+          'topic': 'tns1:Device/tnsaxis:Sensor/PIR',
+          'subscribe': 'onvif:Device/axis:Sensor/axis:PIR',
+          'platform': 'binary_sensor'},
+         {'type': 'sound',
+          'class': 'sound',
+          'topic': 'tns1:AudioSource/tnsaxis:TriggerLevel',
+          'subscribe': 'onvif:AudioSource/axis:TriggerLevel',
+          'platform': 'binary_sensor'},
+         {'type': 'daynight',
+          'class': 'light',
+          'topic': 'tns1:VideoSource/tnsaxis:DayNightVision',
+          'subscribe': 'onvif:VideoSource/axis:DayNightVision',
+          'platform': 'binary_sensor'},
+         {'type': 'tampering',
+          'class': 'safety',
+          'topic': 'tns1:VideoSource/tnsaxis:Tampering',
+          'subscribe': 'onvif:VideoSource/axis:Tampering',
+          'platform': 'binary_sensor'},
+         {'type': 'input',
+          'class': 'input',
+          'topic': 'tns1:Device/tnsaxis:IO/Port',
+          'subscribe': 'onvif:Device/axis:IO/Port',
+          'platform': 'sensor'}, ]

homeassistant/components/bbb_gpio.py

@@ -37,14 +37,14 @@ def setup(hass, config):
 # noqa: F821
 
 def setup_output(pin):
-    """Setup a GPIO as output."""
+    """Set up a GPIO as output."""
     # pylint: disable=import-error,undefined-variable
     import Adafruit_BBIO.GPIO as GPIO
     GPIO.setup(pin, GPIO.OUT)
 
 
 def setup_input(pin, pull_mode):
-    """Setup a GPIO as input."""
+    """Set up a GPIO as input."""
     # pylint: disable=import-error,undefined-variable
     import Adafruit_BBIO.GPIO as GPIO
     GPIO.setup(pin, GPIO.IN,                            # noqa: F821

homeassistant/components/binary_sensor/__init__.py

@@ -57,7 +57,7 @@ class BinarySensorDevice(Entity):
 
     @property
     def is_on(self):
-        """Return True if the binary sensor is on."""
+        """Return true if the binary sensor is on."""
         return None
 
     @property

homeassistant/components/binary_sensor/alarmdecoder.py

@@ -11,7 +11,6 @@ from homeassistant.core import callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.components.binary_sensor import BinarySensorDevice
 
-from homeassistant.const import (STATE_ON, STATE_OFF, STATE_OPEN, STATE_CLOSED)
 from homeassistant.components.alarmdecoder import (ZONE_SCHEMA,
                                                    CONF_ZONES,
                                                    CONF_ZONE_NAME,
@@ -27,7 +26,7 @@ _LOGGER = logging.getLogger(__name__)
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Setup AlarmDecoder binary sensor devices."""
+    """Set up the AlarmDecoder binary sensor devices."""
     configured_zones = discovery_info[CONF_ZONES]
 
     devices = []
@@ -36,10 +35,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
         device_config_data = ZONE_SCHEMA(configured_zones[zone_num])
         zone_type = device_config_data[CONF_ZONE_TYPE]
         zone_name = device_config_data[CONF_ZONE_NAME]
-        device = AlarmDecoderBinarySensor(hass,
-                                          zone_num,
-                                          zone_name,
-                                          zone_type)
+        device = AlarmDecoderBinarySensor(
+            hass, zone_num, zone_name, zone_type)
         devices.append(device)
 
     async_add_devices(devices)
@@ -58,7 +55,7 @@ class AlarmDecoderBinarySensor(BinarySensorDevice):
         self._name = zone_name
         self._type = zone_type
 
-        _LOGGER.debug('AlarmDecoderBinarySensor: Setup up zone: ' + zone_name)
+        _LOGGER.debug("Setup up zone: %s", self._name)
 
     @asyncio.coroutine
     def async_added_to_hass(self):
@@ -69,14 +66,6 @@ class AlarmDecoderBinarySensor(BinarySensorDevice):
         async_dispatcher_connect(
             self.hass, SIGNAL_ZONE_RESTORE, self._restore_callback)
 
-    @property
-    def state(self):
-        """Return the state of the binary sensor."""
-        if self._type == 'opening':
-            return STATE_OPEN if self.is_on else STATE_CLOSED
-
-        return STATE_ON if self.is_on else STATE_OFF
-
     @property
     def name(self):
         """Return the name of the entity."""

homeassistant/components/binary_sensor/android_ip_webcam.py

@@ -15,7 +15,7 @@ DEPENDENCIES = ['android_ip_webcam']
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Setup IP Webcam binary sensors."""
+    """Set up the IP Webcam binary sensors."""
     if discovery_info is None:
         return
 
@@ -28,7 +28,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 
 
 class IPWebcamBinarySensor(AndroidIPCamEntity, BinarySensorDevice):
-    """Represents an IP Webcam binary sensor."""
+    """Representation of an IP Webcam binary sensor."""
 
     def __init__(self, name, host, ipcam, sensor):
         """Initialize the binary sensor."""
@@ -47,7 +47,7 @@ class IPWebcamBinarySensor(AndroidIPCamEntity, BinarySensorDevice):
 
     @property
     def is_on(self):
-        """True if the binary sensor is on."""
+        """Return true if the binary sensor is on."""
         return self._state
 
     @asyncio.coroutine

homeassistant/components/binary_sensor/apcupsd.py

@@ -21,7 +21,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_entities, discovery_info=None):
-    """Setup an Online Status binary sensor."""
+    """Set up an Online Status binary sensor."""
     add_entities((OnlineStatus(config, apcupsd.DATA),))
 
 

homeassistant/components/binary_sensor/axis.py

@@ -0,0 +1,68 @@
+"""
+Support for Axis binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.axis/
+"""
+
+import logging
+from datetime import timedelta
+
+from homeassistant.components.binary_sensor import (BinarySensorDevice)
+from homeassistant.components.axis import (AxisDeviceEvent)
+from homeassistant.const import (CONF_TRIGGER_TIME)
+from homeassistant.helpers.event import track_point_in_utc_time
+from homeassistant.util.dt import utcnow
+
+DEPENDENCIES = ['axis']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup Axis device event."""
+    add_devices([AxisBinarySensor(discovery_info['axis_event'], hass)], True)
+
+
+class AxisBinarySensor(AxisDeviceEvent, BinarySensorDevice):
+    """Representation of a binary Axis event."""
+
+    def __init__(self, axis_event, hass):
+        """Initialize the binary sensor."""
+        self.hass = hass
+        self._state = False
+        self._delay = axis_event.device_config(CONF_TRIGGER_TIME)
+        self._timer = None
+        AxisDeviceEvent.__init__(self, axis_event)
+
+    @property
+    def is_on(self):
+        """Return true if event is active."""
+        return self._state
+
+    def update(self):
+        """Get the latest data and update the state."""
+        self._state = self.axis_event.is_tripped
+
+    def _update_callback(self):
+        """Update the sensor's state, if needed."""
+        self.update()
+
+        if self._timer is not None:
+            self._timer()
+            self._timer = None
+
+        if self._delay > 0 and not self.is_on:
+            # Set timer to wait until updating the state
+            def _delay_update(now):
+                """Timer callback for sensor update."""
+                _LOGGER.debug("%s Called delayed (%s sec) update.",
+                              self._name, self._delay)
+                self.schedule_update_ha_state()
+                self._timer = None
+
+            self._timer = track_point_in_utc_time(
+                self.hass, _delay_update,
+                utcnow() + timedelta(seconds=self._delay))
+        else:
+            self.schedule_update_ha_state()

homeassistant/components/binary_sensor/bbb_gpio.py

@@ -42,7 +42,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Beaglebone Black GPIO devices."""
+    """Set up the Beaglebone Black GPIO devices."""
     pins = config.get(CONF_PINS)
 
     binary_sensors = []
@@ -53,7 +53,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class BBBGPIOBinarySensor(BinarySensorDevice):
-    """Represent a binary sensor that uses Beaglebone Black GPIO."""
+    """Representation of a binary sensor that uses Beaglebone Black GPIO."""
 
     def __init__(self, pin, params):
         """Initialize the Beaglebone Black binary sensor."""

homeassistant/components/binary_sensor/blink.py

@@ -24,7 +24,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class BlinkCameraMotionSensor(BinarySensorDevice):
-    """A representation of a Blink binary sensor."""
+    """Representation of a Blink binary sensor."""
 
     def __init__(self, name, data):
         """Initialize the sensor."""

homeassistant/components/binary_sensor/bloomsky.py

@@ -18,7 +18,6 @@ _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['bloomsky']
 
-# These are the available sensors mapped to binary_sensor class
 SENSOR_TYPES = {
     'Rain': 'moisture',
     'Night': None,
@@ -31,7 +30,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the available BloomSky weather binary sensors."""
+    """Set up the available BloomSky weather binary sensors."""
     bloomsky = get_component('bloomsky')
     # Default needed in case of discovery
     sensors = config.get(CONF_MONITORED_CONDITIONS, SENSOR_TYPES)
@@ -42,7 +41,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class BloomSkySensor(BinarySensorDevice):
-    """Represent a single binary sensor in a BloomSky device."""
+    """Representation of a single binary sensor in a BloomSky device."""
 
     def __init__(self, bs, device, sensor_name):
         """Initialize a BloomSky binary sensor."""
@@ -55,7 +54,7 @@ class BloomSkySensor(BinarySensorDevice):
 
     @property
     def name(self):
-        """The name of the BloomSky device and this sensor."""
+        """Return the name of the BloomSky device and this sensor."""
         return self._name
 
     @property

homeassistant/components/binary_sensor/command_line.py

@@ -39,7 +39,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Command line Binary Sensor."""
+    """Set up the Command line Binary Sensor."""
     name = config.get(CONF_NAME)
     command = config.get(CONF_COMMAND)
     payload_off = config.get(CONF_PAYLOAD_OFF)
@@ -56,7 +56,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class CommandBinarySensor(BinarySensorDevice):
-    """Represent a command line binary sensor."""
+    """Representation of a command line binary sensor."""
 
     def __init__(self, hass, data, name, device_class, payload_on,
                  payload_off, value_template):

homeassistant/components/binary_sensor/concord232.py

@@ -67,8 +67,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         if zone['number'] not in exclude:
             sensors.append(
                 Concord232ZoneSensor(
-                    hass, client, zone, zone_types.get(zone['number'],
-                                                       get_opening_type(zone)))
+                    hass, client, zone, zone_types.get(
+                        zone['number'], get_opening_type(zone))
+                )
             )
 
         add_devices(sensors)
@@ -77,7 +78,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 def get_opening_type(zone):
-    """Helper function to try to guess sensor type from name."""
+    """Return the result of the type guessing from name."""
     if 'MOTION' in zone['name']:
         return 'motion'
     if 'KEY' in zone['name']:
@@ -123,7 +124,7 @@ class Concord232ZoneSensor(BinarySensorDevice):
         return bool(self._zone['state'] == 'Normal')
 
     def update(self):
-        """"Get updated stats from API."""
+        """Get updated stats from API."""
         last_update = datetime.datetime.now() - self._client.last_zone_update
         _LOGGER.debug("Zone: %s ", self._zone)
         if last_update > datetime.timedelta(seconds=1):

homeassistant/components/binary_sensor/demo.py

@@ -8,7 +8,7 @@ from homeassistant.components.binary_sensor import BinarySensorDevice
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Demo binary sensor platform."""
+    """Set up the Demo binary sensor platform."""
     add_devices([
         DemoBinarySensor('Basement Floor Wet', False, 'moisture'),
         DemoBinarySensor('Movement Backyard', True, 'motion'),
@@ -16,7 +16,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class DemoBinarySensor(BinarySensorDevice):
-    """A Demo binary sensor."""
+    """representation of a Demo binary sensor."""
 
     def __init__(self, name, state, device_class):
         """Initialize the demo sensor."""

homeassistant/components/binary_sensor/ecobee.py

@@ -13,7 +13,7 @@ ECOBEE_CONFIG_FILE = 'ecobee.conf'
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Ecobee sensors."""
+    """Set up the Ecobee sensors."""
     if discovery_info is None:
         return
     data = ecobee.NETWORK

homeassistant/components/binary_sensor/eight_sleep.py

@@ -0,0 +1,69 @@
+"""
+Support for Eight Sleep binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.eight_sleep/
+"""
+import logging
+import asyncio
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.eight_sleep import (
+    DATA_EIGHT, EightSleepHeatEntity, CONF_BINARY_SENSORS, NAME_MAP)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['eight_sleep']
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the eight sleep binary sensor."""
+    if discovery_info is None:
+        return
+
+    name = 'Eight'
+    sensors = discovery_info[CONF_BINARY_SENSORS]
+    eight = hass.data[DATA_EIGHT]
+
+    all_sensors = []
+
+    for sensor in sensors:
+        all_sensors.append(EightHeatSensor(name, eight, sensor))
+
+    async_add_devices(all_sensors, True)
+
+
+class EightHeatSensor(EightSleepHeatEntity, BinarySensorDevice):
+    """Representation of a Eight Sleep heat-based sensor."""
+
+    def __init__(self, name, eight, sensor):
+        """Initialize the sensor."""
+        super().__init__(eight)
+
+        self._sensor = sensor
+        self._mapped_name = NAME_MAP.get(self._sensor, self._sensor)
+        self._name = '{} {}'.format(name, self._mapped_name)
+        self._state = None
+
+        self._side = self._sensor.split('_')[0]
+        self._userid = self._eight.fetch_userid(self._side)
+        self._usrobj = self._eight.users[self._userid]
+
+        _LOGGER.debug("Presence Sensor: %s, Side: %s, User: %s",
+                      self._sensor, self._side, self._userid)
+
+    @property
+    def name(self):
+        """Return the name of the sensor, if any."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self._state
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Retrieve latest state."""
+        self._state = self._usrobj.bed_presence

homeassistant/components/binary_sensor/enocean.py

@@ -30,7 +30,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Binary Sensor platform fo EnOcean."""
+    """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)
@@ -44,7 +44,7 @@ class EnOceanBinarySensor(enocean.EnOceanDevice, BinarySensorDevice):
     def __init__(self, dev_id, devname, device_class):
         """Initialize the EnOcean binary sensor."""
         enocean.EnOceanDevice.__init__(self)
-        self.stype = "listener"
+        self.stype = 'listener'
         self.dev_id = dev_id
         self.which = -1
         self.onoff = -1
@@ -53,7 +53,7 @@ class EnOceanBinarySensor(enocean.EnOceanDevice, BinarySensorDevice):
 
     @property
     def name(self):
-        """The default name for the binary sensor."""
+        """Return the default name for the binary sensor."""
         return self.devname
 
     @property
@@ -80,7 +80,7 @@ class EnOceanBinarySensor(enocean.EnOceanDevice, BinarySensorDevice):
         elif value2 == 0x10:
             self.which = 1
             self.onoff = 1
-        self.hass.bus.fire('button_pressed', {"id": self.dev_id,
+        self.hass.bus.fire('button_pressed', {'id': self.dev_id,
                                               'pushed': value,
                                               'which': self.which,
                                               'onoff': self.onoff})

homeassistant/components/binary_sensor/envisalink.py

@@ -15,13 +15,14 @@ from homeassistant.components.envisalink import (
     SIGNAL_ZONE_UPDATE)
 from homeassistant.const import ATTR_LAST_TRIP_TIME
 
-DEPENDENCIES = ['envisalink']
 _LOGGER = logging.getLogger(__name__)
 
+DEPENDENCIES = ['envisalink']
+
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Setup Envisalink binary sensor devices."""
+    """Set up the Envisalink binary sensor devices."""
     configured_zones = discovery_info['zones']
 
     devices = []

homeassistant/components/binary_sensor/ffmpeg_motion.py

@@ -48,23 +48,21 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Create the binary sensor."""
+    """Set up the FFmpeg binary moition sensor."""
     manager = hass.data[DATA_FFMPEG]
 
-    # check source
     if not manager.async_run_test(config.get(CONF_INPUT)):
         return
 
-    # generate sensor object
     entity = FFmpegMotion(hass, manager, config)
     async_add_devices([entity])
 
 
 class FFmpegBinarySensor(FFmpegBase, BinarySensorDevice):
-    """A binary sensor which use ffmpeg for noise detection."""
+    """A binary sensor which use FFmpeg for noise detection."""
 
     def __init__(self, config):
-        """Constructor for binary sensor noise detection."""
+        """Init for the binary sensor noise detection."""
         super().__init__(config.get(CONF_INITIAL_STATE))
 
         self._state = False
@@ -79,7 +77,7 @@ class FFmpegBinarySensor(FFmpegBase, BinarySensorDevice):
 
     @property
     def is_on(self):
-        """True if the binary sensor is on."""
+        """Return true if the binary sensor is on."""
         return self._state
 
     @property
@@ -89,10 +87,10 @@ class FFmpegBinarySensor(FFmpegBase, BinarySensorDevice):
 
 
 class FFmpegMotion(FFmpegBinarySensor):
-    """A binary sensor which use ffmpeg for noise detection."""
+    """A binary sensor which use FFmpeg for noise detection."""
 
     def __init__(self, hass, manager, config):
-        """Initialize ffmpeg motion binary sensor."""
+        """Initialize FFmpeg motion binary sensor."""
         from haffmpeg import SensorMotion
 
         super().__init__(config)
@@ -125,4 +123,4 @@ class FFmpegMotion(FFmpegBinarySensor):
     @property
     def device_class(self):
         """Return the class of this sensor, from DEVICE_CLASSES."""
-        return "motion"
+        return 'motion'

homeassistant/components/binary_sensor/ffmpeg_noise.py

@@ -45,23 +45,21 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Create the binary sensor."""
+    """Set up the FFmpeg noise binary sensor."""
     manager = hass.data[DATA_FFMPEG]
 
-    # check source
     if not manager.async_run_test(config.get(CONF_INPUT)):
         return
 
-    # generate sensor object
     entity = FFmpegNoise(hass, manager, config)
     async_add_devices([entity])
 
 
 class FFmpegNoise(FFmpegBinarySensor):
-    """A binary sensor which use ffmpeg for noise detection."""
+    """A binary sensor which use FFmpeg for noise detection."""
 
     def __init__(self, hass, manager, config):
-        """Initialize ffmpeg noise binary sensor."""
+        """Initialize FFmpeg noise binary sensor."""
         from haffmpeg import SensorNoise
 
         super().__init__(config)
@@ -77,14 +75,12 @@ class FFmpegNoise(FFmpegBinarySensor):
         if entity_ids is not None and self.entity_id not in entity_ids:
             return
 
-        # init config
         self.ffmpeg.set_options(
             time_duration=self._config.get(CONF_DURATION),
             time_reset=self._config.get(CONF_RESET),
             peak=self._config.get(CONF_PEAK),
         )
 
-        # run
         yield from self.ffmpeg.open_sensor(
             input_source=self._config.get(CONF_INPUT),
             output_dest=self._config.get(CONF_OUTPUT),
@@ -94,4 +90,4 @@ class FFmpegNoise(FFmpegBinarySensor):
     @property
     def device_class(self):
         """Return the class of this sensor, from DEVICE_CLASSES."""
-        return "sound"
+        return 'sound'

homeassistant/components/binary_sensor/flic.py

@@ -110,7 +110,7 @@ def start_scanning(config, add_entities, client):
 
 
 def setup_button(hass, config, add_entities, client, address):
-    """Setup single button device."""
+    """Set up a single button device."""
     timeout = config.get(CONF_TIMEOUT)
     ignored_click_types = config.get(CONF_IGNORED_CLICK_TYPES)
     button = FlicButton(hass, client, address, timeout, ignored_click_types)

homeassistant/components/binary_sensor/hikvision.py

@@ -67,7 +67,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_entities, discovery_info=None):
-    """Setup Hikvision binary sensor devices."""
+    """Set up the Hikvision binary sensor devices."""
     name = config.get(CONF_NAME)
     host = config.get(CONF_HOST)
     port = config.get(CONF_PORT)
@@ -77,16 +77,16 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
     customize = config.get(CONF_CUSTOMIZE)
 
     if config.get(CONF_SSL):
-        protocol = "https"
+        protocol = 'https'
     else:
-        protocol = "http"
+        protocol = 'http'
 
     url = '{}://{}'.format(protocol, host)
 
     data = HikvisionData(hass, url, port, name, username, password)
 
     if data.sensors is None:
-        _LOGGER.error('Hikvision event stream has no data, unable to setup.')
+        _LOGGER.error("Hikvision event stream has no data, unable to setup")
         return False
 
     entities = []
@@ -104,7 +104,7 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
             ignore = custom.get(CONF_IGNORED)
             delay = custom.get(CONF_DELAY)
 
-            _LOGGER.debug('Entity: %s - %s, Options - Ignore: %s, Delay: %s',
+            _LOGGER.debug("Entity: %s - %s, Options - Ignore: %s, Delay: %s",
                           data.name, sensor_name, ignore, delay)
             if not ignore:
                 entities.append(HikvisionBinarySensor(
@@ -126,8 +126,8 @@ class HikvisionData(object):
         self._password = password
 
         # Establish camera
-        self.camdata = HikCamera(self._url, self._port,
-                                 self._username, self._password)
+        self.camdata = HikCamera(
+            self._url, self._port, self._username, self._password)
 
         if self._name is None:
             self._name = self.camdata.get_name
@@ -251,7 +251,7 @@ class HikvisionBinarySensor(BinarySensorDevice):
             # Set timer to wait until updating the state
             def _delay_update(now):
                 """Timer callback for sensor update."""
-                _LOGGER.debug('%s Called delayed (%ssec) update.',
+                _LOGGER.debug("%s Called delayed (%ssec) update",
                               self._name, self._delay)
                 self.schedule_update_ha_state()
                 self._timer = None

homeassistant/components/binary_sensor/homematic.py

@@ -14,22 +14,22 @@ _LOGGER = logging.getLogger(__name__)
 DEPENDENCIES = ['homematic']
 
 SENSOR_TYPES_CLASS = {
-    "Remote": None,
-    "ShutterContact": "opening",
-    "MaxShutterContact": "opening",
-    "IPShutterContact": "opening",
-    "Smoke": "smoke",
-    "SmokeV2": "smoke",
-    "Motion": "motion",
-    "MotionV2": "motion",
-    "RemoteMotion": None,
-    "WeatherSensor": None,
-    "TiltSensor": None,
+    'Remote': None,
+    'ShutterContact': 'opening',
+    'MaxShutterContact': 'opening',
+    'IPShutterContact': 'opening',
+    'Smoke': 'smoke',
+    'SmokeV2': 'smoke',
+    'Motion': 'motion',
+    'MotionV2': 'motion',
+    'RemoteMotion': None,
+    'WeatherSensor': None,
+    'TiltSensor': None,
 }
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Homematic binary sensor platform."""
+    """Set up the Homematic binary sensor platform."""
     if discovery_info is None:
         return
 
@@ -56,8 +56,8 @@ class HMBinarySensor(HMDevice, BinarySensorDevice):
     def device_class(self):
         """Return the class of this sensor, from DEVICE_CLASSES."""
         # If state is MOTION (RemoteMotion works only)
-        if self._state == "MOTION":
-            return "motion"
+        if self._state == 'MOTION':
+            return 'motion'
         return SENSOR_TYPES_CLASS.get(self._hmdevice.__class__.__name__, None)
 
     def _init_data_struct(self):

homeassistant/components/binary_sensor/insteon_plm.py

@@ -67,7 +67,7 @@ class InsteonPLMBinarySensorDevice(BinarySensorDevice):
     def is_on(self):
         """Return the boolean response if the node is on."""
         sensorstate = self._plm.get_device_attr(self._address, 'sensorstate')
-        _LOGGER.info('sensor state for %s is %s', self._address, sensorstate)
+        _LOGGER.info("Sensor state for %s is %s", self._address, sensorstate)
         return bool(sensorstate)
 
     @property
@@ -83,5 +83,5 @@ class InsteonPLMBinarySensorDevice(BinarySensorDevice):
     @callback
     def async_binarysensor_update(self, message):
         """Receive notification from transport that new data exists."""
-        _LOGGER.info('Received update calback from PLM for %s', self._address)
+        _LOGGER.info("Received update calback from PLM for %s", self._address)
         self._hass.async_add_job(self.async_update_ha_state())

homeassistant/components/binary_sensor/isy994.py

@@ -12,7 +12,6 @@ import homeassistant.components.isy994 as isy
 from homeassistant.const import STATE_ON, STATE_OFF
 from homeassistant.helpers.typing import ConfigType
 
-
 _LOGGER = logging.getLogger(__name__)
 
 VALUE_TO_STATE = {
@@ -27,9 +26,9 @@ STATES = [STATE_OFF, STATE_ON, 'true', 'false']
 # pylint: disable=unused-argument
 def setup_platform(hass, config: ConfigType,
                    add_devices: Callable[[list], None], discovery_info=None):
-    """Setup the ISY994 binary sensor platform."""
+    """Set up the ISY994 binary sensor platform."""
     if isy.ISY is None or not isy.ISY.connected:
-        _LOGGER.error('A connection has not been made to the ISY controller.')
+        _LOGGER.error("A connection has not been made to the ISY controller")
         return False
 
     devices = []

homeassistant/components/binary_sensor/knx.py

@@ -11,7 +11,7 @@ DEPENDENCIES = ['knx']
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the KNX binary sensor platform."""
+    """Set up the KNX binary sensor platform."""
     add_devices([KNXSwitch(hass, KNXConfig(config))])
 
 

homeassistant/components/binary_sensor/maxcube.py

@@ -4,7 +4,6 @@ Support for MAX! Window Shutter via MAX! Cube.
 For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/maxcube/
 """
-
 import logging
 
 from homeassistant.components.binary_sensor import BinarySensorDevice
@@ -15,27 +14,24 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Iterate through all MAX! Devices and add window shutters to HASS."""
+    """Iterate through all MAX! Devices and add window shutters."""
     cube = hass.data[MAXCUBE_HANDLE].cube
-
-    # List of devices
     devices = []
 
     for device in cube.devices:
-        # Create device name by concatenating room name + device name
-        name = "%s %s" % (cube.room_by_id(device.room_id).name, device.name)
+        name = "{} {}".format(
+            cube.room_by_id(device.room_id).name, device.name)
 
         # Only add Window Shutters
         if cube.is_windowshutter(device):
-            # add device to HASS
             devices.append(MaxCubeShutter(hass, name, device.rf_address))
 
-    if len(devices) > 0:
+    if devices:
         add_devices(devices)
 
 
 class MaxCubeShutter(BinarySensorDevice):
-    """MAX! Cube BinarySensor device."""
+    """Representation of a MAX! Cube Binary Sensor device."""
 
     def __init__(self, hass, name, rf_address):
         """Initialize MAX! Cube BinarySensorDevice."""
@@ -47,7 +43,7 @@ class MaxCubeShutter(BinarySensorDevice):
 
     @property
     def should_poll(self):
-        """Polling is required."""
+        """Return the polling state."""
         return True
 
     @property
@@ -68,9 +64,5 @@ class MaxCubeShutter(BinarySensorDevice):
     def update(self):
         """Get latest data from MAX! Cube."""
         self._cubehandle.update()
-
-        # Get the device we want to update
         device = self._cubehandle.cube.device_by_rf(self._rf_address)
-
-        # Update our internal state
         self._state = device.is_open

homeassistant/components/binary_sensor/modbus.py

@@ -16,9 +16,9 @@ from homeassistant.components.sensor import PLATFORM_SCHEMA
 _LOGGER = logging.getLogger(__name__)
 DEPENDENCIES = ['modbus']
 
-CONF_COIL = "coil"
-CONF_COILS = "coils"
-CONF_SLAVE = "slave"
+CONF_COIL = 'coil'
+CONF_COILS = 'coils'
+CONF_SLAVE = 'slave'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_COILS): [{
@@ -30,7 +30,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup Modbus binary sensors."""
+    """Set up the Modbus binary sensors."""
     sensors = []
     for coil in config.get(CONF_COILS):
         sensors.append(ModbusCoilSensor(

homeassistant/components/binary_sensor/mqtt.py

@@ -79,7 +79,7 @@ class MqttBinarySensor(BinarySensorDevice):
         """
         @callback
         def message_received(topic, payload, qos):
-            """A new MQTT message has been received."""
+            """Handle a new received MQTT message."""
             if self._template is not None:
                 payload = self._template.async_render_with_possible_json_value(
                     payload)
@@ -95,7 +95,7 @@ class MqttBinarySensor(BinarySensorDevice):
 
     @property
     def should_poll(self):
-        """No polling needed."""
+        """Return the polling state."""
         return False
 
     @property

homeassistant/components/binary_sensor/mysensors.py

@@ -16,7 +16,7 @@ DEPENDENCIES = []
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the mysensors platform for sensors."""
+    """Set up the MySensors platform for sensors."""
     # Only act if loaded via mysensors by discovery event.
     # Otherwise gateway is not setup.
     if discovery_info is None:

homeassistant/components/binary_sensor/mystrom.py

@@ -0,0 +1,95 @@
+"""
+Support for the myStrom buttons.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.mystrom/
+"""
+import asyncio
+import logging
+
+from homeassistant.components.binary_sensor import (BinarySensorDevice, DOMAIN)
+from homeassistant.components.http import HomeAssistantView
+from homeassistant.const import HTTP_UNPROCESSABLE_ENTITY
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['http']
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up myStrom Binary Sensor."""
+    hass.http.register_view(MyStromView(async_add_devices))
+
+    return True
+
+
+class MyStromView(HomeAssistantView):
+    """View to handle requests from myStrom buttons."""
+
+    url = '/api/mystrom'
+    name = 'api:mystrom'
+
+    def __init__(self, add_devices):
+        """Initialize the myStrom URL endpoint."""
+        self.buttons = {}
+        self.add_devices = add_devices
+
+    @asyncio.coroutine
+    def get(self, request):
+        """The GET request received from a myStrom button."""
+        res = yield from self._handle(request.app['hass'], request.query)
+        return res
+
+    @asyncio.coroutine
+    def _handle(self, hass, data):
+        """Handle requests to the myStrom endpoint."""
+        button_action = list(data.keys())[0]
+        button_id = data[button_action]
+        entity_id = '{}.{}_{}'.format(DOMAIN, button_id, button_action)
+
+        if button_action not in ['single', 'double', 'long', 'touch']:
+            _LOGGER.error(
+                "Received unidentified message from myStrom button: %s", data)
+            return ("Received unidentified message: {}".format(data),
+                    HTTP_UNPROCESSABLE_ENTITY)
+
+        if entity_id not in self.buttons:
+            _LOGGER.info("New myStrom button/action detected: %s/%s",
+                         button_id, button_action)
+            self.buttons[entity_id] = MyStromBinarySensor(
+                '{}_{}'.format(button_id, button_action))
+            hass.async_add_job(self.add_devices, [self.buttons[entity_id]])
+        else:
+            new_state = True if self.buttons[entity_id].state == 'off' \
+                else False
+            self.buttons[entity_id].async_on_update(new_state)
+
+
+class MyStromBinarySensor(BinarySensorDevice):
+    """Representation of a myStrom button."""
+
+    def __init__(self, button_id):
+        """Initialize the myStrom Binary sensor."""
+        self._button_id = button_id
+        self._state = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._button_id
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self._state
+
+    def async_on_update(self, value):
+        """Receive an update."""
+        self._state = value
+        self.hass.async_add_job(self.async_update_ha_state())

homeassistant/components/binary_sensor/nest.py

@@ -16,15 +16,18 @@ DEPENDENCIES = ['nest']
 
 BINARY_TYPES = ['online']
 
-CLIMATE_BINARY_TYPES = ['fan',
-                        'is_using_emergency_heat',
-                        'is_locked',
-                        'has_leaf']
+CLIMATE_BINARY_TYPES = [
+    'fan',
+    'is_using_emergency_heat',
+    'is_locked',
+    'has_leaf',
+]
 
 CAMERA_BINARY_TYPES = [
     'motion_detected',
     'sound_detected',
-    'person_detected']
+    'person_detected',
+]
 
 _BINARY_TYPES_DEPRECATED = [
     'hvac_ac_state',
@@ -34,7 +37,8 @@ _BINARY_TYPES_DEPRECATED = [
     'hvac_heat_x3_state',
     'hvac_alt_heat_state',
     'hvac_alt_heat_x2_state',
-    'hvac_emer_heat_state']
+    'hvac_emer_heat_state',
+]
 
 _VALID_BINARY_SENSOR_TYPES = BINARY_TYPES + CLIMATE_BINARY_TYPES \
     + CAMERA_BINARY_TYPES
@@ -43,7 +47,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup Nest binary sensors."""
+    """Set up the Nest binary sensors."""
     if discovery_info is None:
         return
 
@@ -93,7 +97,7 @@ class NestBinarySensor(NestSensor, BinarySensorDevice):
 
     @property
     def is_on(self):
-        """True if the binary sensor is on."""
+        """Return true if the binary sensor is on."""
         return self._state
 
     def update(self):

homeassistant/components/binary_sensor/netatmo.py

@@ -7,6 +7,7 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.netatmo/.
 """
 import logging
+
 import voluptuous as vol
 
 from homeassistant.components.binary_sensor import (
@@ -16,10 +17,9 @@ from homeassistant.loader import get_component
 from homeassistant.const import CONF_TIMEOUT, CONF_OFFSET
 from homeassistant.helpers import config_validation as cv
 
-DEPENDENCIES = ["netatmo"]
-
 _LOGGER = logging.getLogger(__name__)
 
+DEPENDENCIES = ['netatmo']
 
 # These are the available sensors mapped to binary_sensor class
 WELCOME_SENSOR_TYPES = {
@@ -34,8 +34,8 @@ PRESENCE_SENSOR_TYPES = {
     "Outdoor vehicle": "motion"
 }
 TAG_SENSOR_TYPES = {
-    "Tag Vibration": 'vibration',
-    "Tag Open": 'opening'
+    "Tag Vibration": "vibration",
+    "Tag Open": "opening"
 }
 
 CONF_HOME = 'home'
@@ -61,7 +61,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup access to Netatmo binary sensor."""
+    """Set up the access to Netatmo binary sensor."""
     netatmo = get_component('netatmo')
     home = config.get(CONF_HOME, None)
     timeout = config.get(CONF_TIMEOUT, 15)
@@ -85,35 +85,31 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     for camera_name in data.get_camera_names():
         camera_type = data.get_camera_type(camera=camera_name, home=home)
-        if camera_type == "NACamera":
+        if camera_type == 'NACamera':
             if CONF_CAMERAS in config:
                 if config[CONF_CAMERAS] != [] and \
                    camera_name not in config[CONF_CAMERAS]:
                     continue
             for variable in welcome_sensors:
-                add_devices([NetatmoBinarySensor(data, camera_name,
-                                                 module_name, home, timeout,
-                                                 offset, camera_type,
-                                                 variable)])
-        if camera_type == "NOC":
+                add_devices([NetatmoBinarySensor(
+                    data, camera_name, module_name, home, timeout,
+                    offset, camera_type, variable)])
+        if camera_type == 'NOC':
             if CONF_CAMERAS in config:
                 if config[CONF_CAMERAS] != [] and \
                    camera_name not in config[CONF_CAMERAS]:
                     continue
             for variable in presence_sensors:
-                add_devices([NetatmoBinarySensor(data, camera_name,
-                                                 module_name, home, timeout,
-                                                 offset, camera_type,
-                                                 variable)])
+                add_devices([NetatmoBinarySensor(
+                    data, camera_name, module_name, home, timeout, offset,
+                    camera_type, variable)])
 
         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)])
+                add_devices([NetatmoBinarySensor(
+                    data, camera_name, module_name, home, timeout, offset,
+                    camera_type, variable)])
 
 
 class NetatmoBinarySensor(BinarySensorDevice):
@@ -121,7 +117,7 @@ class NetatmoBinarySensor(BinarySensorDevice):
 
     def __init__(self, data, camera_name, module_name, home,
                  timeout, offset, camera_type, sensor):
-        """Setup for access to the Netatmo camera events."""
+        """Set up for access to the Netatmo camera events."""
         self._data = data
         self._camera_name = camera_name
         self._module_name = module_name
@@ -129,23 +125,23 @@ class NetatmoBinarySensor(BinarySensorDevice):
         self._timeout = timeout
         self._offset = offset
         if home:
-            self._name = home + ' / ' + camera_name
+            self._name = '{} / {}'.format(home, camera_name)
         else:
             self._name = camera_name
         if module_name:
             self._name += ' / ' + module_name
         self._sensor_name = sensor
         self._name += ' ' + sensor
-        camera_id = data.camera_data.cameraByName(camera=camera_name,
-                                                  home=home)['id']
-        self._unique_id = "Netatmo_binary_sensor {0} - {1}".format(self._name,
-                                                                   camera_id)
+        camera_id = data.camera_data.cameraByName(
+            camera=camera_name, home=home)['id']
+        self._unique_id = "Netatmo_binary_sensor {0} - {1}".format(
+            self._name, camera_id)
         self._cameratype = camera_type
         self.update()
 
     @property
     def name(self):
-        """The name of the Netatmo device and this sensor."""
+        """Return the name of the Netatmo device and this sensor."""
         return self._name
 
     @property
@@ -156,9 +152,9 @@ class NetatmoBinarySensor(BinarySensorDevice):
     @property
     def device_class(self):
         """Return the class of this sensor, from DEVICE_CLASSES."""
-        if self._cameratype == "NACamera":
+        if self._cameratype == 'NACamera':
             return WELCOME_SENSOR_TYPES.get(self._sensor_name)
-        elif self._cameratype == "NOC":
+        elif self._cameratype == 'NOC':
             return PRESENCE_SENSOR_TYPES.get(self._sensor_name)
         else:
             return TAG_SENSOR_TYPES.get(self._sensor_name)
@@ -173,51 +169,44 @@ class NetatmoBinarySensor(BinarySensorDevice):
         self._data.update()
         self._data.update_event()
 
-        if self._cameratype == "NACamera":
+        if self._cameratype == 'NACamera':
             if self._sensor_name == "Someone known":
                 self._state =\
-                    self._data.camera_data.someoneKnownSeen(self._home,
-                                                            self._camera_name,
-                                                            self._timeout*60)
+                    self._data.camera_data.someoneKnownSeen(
+                        self._home, self._camera_name, self._timeout*60)
             elif self._sensor_name == "Someone unknown":
                 self._state =\
                     self._data.camera_data.someoneUnknownSeen(
                         self._home, self._camera_name, self._timeout*60)
             elif self._sensor_name == "Motion":
                 self._state =\
-                    self._data.camera_data.motionDetected(self._home,
-                                                          self._camera_name,
-                                                          self._timeout*60)
-        elif self._cameratype == "NOC":
+                    self._data.camera_data.motionDetected(
+                        self._home, self._camera_name, self._timeout*60)
+        elif self._cameratype == 'NOC':
             if self._sensor_name == "Outdoor motion":
                 self._state =\
                     self._data.camera_data.outdoormotionDetected(
                         self._home, self._camera_name, self._offset)
             elif self._sensor_name == "Outdoor human":
                 self._state =\
-                    self._data.camera_data.humanDetected(self._home,
-                                                         self._camera_name,
-                                                         self._offset)
+                    self._data.camera_data.humanDetected(
+                        self._home, self._camera_name, self._offset)
             elif self._sensor_name == "Outdoor animal":
                 self._state =\
-                    self._data.camera_data.animalDetected(self._home,
-                                                          self._camera_name,
-                                                          self._offset)
+                    self._data.camera_data.animalDetected(
+                        self._home, self._camera_name, self._offset)
             elif self._sensor_name == "Outdoor vehicle":
                 self._state =\
-                    self._data.camera_data.carDetected(self._home,
-                                                       self._camera_name,
-                                                       self._offset)
+                    self._data.camera_data.carDetected(
+                        self._home, self._camera_name, self._offset)
         if self._sensor_name == "Tag Vibration":
             self._state =\
-                self._data.camera_data.moduleMotionDetected(self._home,
-                                                            self._module_name,
-                                                            self._camera_name,
-                                                            self._timeout*60)
+                self._data.camera_data.moduleMotionDetected(
+                    self._home, self._module_name, self._camera_name,
+                    self._timeout*60)
         elif self._sensor_name == "Tag Open":
             self._state =\
-                self._data.camera_data.moduleOpened(self._home,
-                                                    self._module_name,
-                                                    self._camera_name)
+                self._data.camera_data.moduleOpened(
+                    self._home, self._module_name, self._camera_name)
         else:
             return None

homeassistant/components/binary_sensor/nx584.py

@@ -41,7 +41,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the NX584 binary sensor platform."""
+    """Set up the NX584 binary sensor platform."""
     from nx584 import client as nx584_client
 
     host = config.get(CONF_HOST)
@@ -53,7 +53,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         client = nx584_client.Client('http://{}:{}'.format(host, port))
         zones = client.list_zones()
     except requests.exceptions.ConnectionError as ex:
-        _LOGGER.error('Unable to connect to NX584: %s', str(ex))
+        _LOGGER.error("Unable to connect to NX584: %s", str(ex))
         return False
 
     version = [int(v) for v in client.get_version().split('.')]

homeassistant/components/binary_sensor/octoprint.py

@@ -9,14 +9,12 @@ import logging
 import requests
 import voluptuous as vol
 
-from homeassistant.const import (
-    CONF_NAME, STATE_ON, STATE_OFF, CONF_MONITORED_CONDITIONS)
+from homeassistant.const import CONF_NAME, CONF_MONITORED_CONDITIONS
 from homeassistant.components.binary_sensor import (
     BinarySensorDevice, PLATFORM_SCHEMA)
 from homeassistant.loader import get_component
 import homeassistant.helpers.config_validation as cv
 
-
 _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['octoprint']
@@ -38,22 +36,18 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the available OctoPrint binary sensors."""
+    """Set up the available OctoPrint binary sensors."""
     octoprint = get_component('octoprint')
     name = config.get(CONF_NAME)
-    monitored_conditions = config.get(CONF_MONITORED_CONDITIONS,
-                                      SENSOR_TYPES.keys())
+    monitored_conditions = config.get(
+        CONF_MONITORED_CONDITIONS, SENSOR_TYPES.keys())
 
     devices = []
     for octo_type in monitored_conditions:
-        new_sensor = OctoPrintBinarySensor(octoprint.OCTOPRINT,
-                                           octo_type,
-                                           SENSOR_TYPES[octo_type][2],
-                                           name,
-                                           SENSOR_TYPES[octo_type][3],
-                                           SENSOR_TYPES[octo_type][0],
-                                           SENSOR_TYPES[octo_type][1],
-                                           'flags')
+        new_sensor = OctoPrintBinarySensor(
+            octoprint.OCTOPRINT, octo_type, SENSOR_TYPES[octo_type][2],
+            name, SENSOR_TYPES[octo_type][3], SENSOR_TYPES[octo_type][0],
+            SENSOR_TYPES[octo_type][1], 'flags')
         devices.append(new_sensor)
     add_devices(devices)
 
@@ -85,18 +79,10 @@ class OctoPrintBinarySensor(BinarySensorDevice):
         """Return the name of the sensor."""
         return self._name
 
-    @property
-    def state(self):
-        """Return the state of the sensor."""
-        return self.is_on
-
     @property
     def is_on(self):
         """Return true if binary sensor is on."""
-        if self._state:
-            return STATE_ON
-        else:
-            return STATE_OFF
+        return bool(self._state)
 
     @property
     def device_class(self):
@@ -106,10 +92,9 @@ class OctoPrintBinarySensor(BinarySensorDevice):
     def update(self):
         """Update state of sensor."""
         try:
-            self._state = self.api.update(self.sensor_type,
-                                          self.api_endpoint,
-                                          self.api_group,
-                                          self.api_tool)
+            self._state = self.api.update(
+                self.sensor_type, self.api_endpoint, self.api_group,
+                self.api_tool)
         except requests.exceptions.ConnectionError:
             # Error calling the api, already logged in api.update()
             return

homeassistant/components/binary_sensor/pilight.py

@@ -0,0 +1,186 @@
+"""
+Support for Pilight binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.pilight/
+"""
+import datetime
+import logging
+
+import voluptuous as vol
+from homeassistant.components import pilight
+from homeassistant.components.binary_sensor import (
+    PLATFORM_SCHEMA,
+    BinarySensorDevice,
+)
+from homeassistant.const import (
+    CONF_DISARM_AFTER_TRIGGER,
+    CONF_NAME,
+    CONF_PAYLOAD,
+    CONF_PAYLOAD_OFF,
+    CONF_PAYLOAD_ON
+)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.event import track_point_in_time
+from homeassistant.util import dt as dt_util
+
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_VARIABLE = 'variable'
+
+DEFAULT_NAME = 'Pilight Binary Sensor'
+DEPENDENCIES = ['pilight']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_VARIABLE): cv.string,
+    vol.Required(CONF_PAYLOAD): vol.Schema(dict),
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_PAYLOAD_ON, default='on'): cv.string,
+    vol.Optional(CONF_PAYLOAD_OFF, default='off'): cv.string,
+    vol.Optional(CONF_DISARM_AFTER_TRIGGER, default=False): cv.boolean
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Pilight Binary Sensor."""
+    disarm = config.get(CONF_DISARM_AFTER_TRIGGER)
+    if disarm:
+        add_devices([PilightTriggerSensor(
+            hass=hass,
+            name=config.get(CONF_NAME),
+            variable=config.get(CONF_VARIABLE),
+            payload=config.get(CONF_PAYLOAD),
+            on_value=config.get(CONF_PAYLOAD_ON),
+            off_value=config.get(CONF_PAYLOAD_OFF),
+        )])
+    else:
+        add_devices([PilightBinarySensor(
+            hass=hass,
+            name=config.get(CONF_NAME),
+            variable=config.get(CONF_VARIABLE),
+            payload=config.get(CONF_PAYLOAD),
+            on_value=config.get(CONF_PAYLOAD_ON),
+            off_value=config.get(CONF_PAYLOAD_OFF),
+        )])
+
+
+class PilightBinarySensor(BinarySensorDevice):
+    """Representation of a binary sensor that can be updated using Pilight."""
+
+    def __init__(self, hass, name, variable, payload, on_value, off_value):
+        """Initialize the sensor."""
+        self._state = False
+        self._hass = hass
+        self._name = name
+        self._variable = variable
+        self._payload = payload
+        self._on_value = on_value
+        self._off_value = off_value
+
+        hass.bus.listen(pilight.EVENT, self._handle_code)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._state
+
+    def _handle_code(self, call):
+        """Handle received code by the pilight-daemon.
+
+        If the code matches the defined playload
+        of this sensor the sensor state is changed accordingly.
+        """
+        # Check if received code matches defined playoad
+        # True if payload is contained in received code dict
+        payload_ok = True
+        for key in self._payload:
+            if key not in call.data:
+                payload_ok = False
+                continue
+            if self._payload[key] != call.data[key]:
+                payload_ok = False
+        # Read out variable if payload ok
+        if payload_ok:
+            if self._variable not in call.data:
+                return
+            value = call.data[self._variable]
+            self._state = (value == self._on_value)
+            self.schedule_update_ha_state()
+
+
+class PilightTriggerSensor(BinarySensorDevice):
+    """Representation of a binary sensor that can be updated using Pilight."""
+
+    def __init__(
+            self,
+            hass,
+            name,
+            variable,
+            payload,
+            on_value,
+            off_value,
+            rst_dly_sec=30):
+        """Initialize the sensor."""
+        self._state = False
+        self._hass = hass
+        self._name = name
+        self._variable = variable
+        self._payload = payload
+        self._on_value = on_value
+        self._off_value = off_value
+        self._reset_delay_sec = rst_dly_sec
+        self._delay_after = None
+        self._hass = hass
+
+        hass.bus.listen(pilight.EVENT, self._handle_code)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._state
+
+    def _reset_state(self, call):
+        self._state = False
+        self._delay_after = None
+        self.schedule_update_ha_state()
+
+    def _handle_code(self, call):
+        """Handle received code by the pilight-daemon.
+
+        If the code matches the defined playload
+        of this sensor the sensor state is changed accordingly.
+        """
+        # Check if received code matches defined playoad
+        # True if payload is contained in received code dict
+        payload_ok = True
+        for key in self._payload:
+            if key not in call.data:
+                payload_ok = False
+                continue
+            if self._payload[key] != call.data[key]:
+                payload_ok = False
+        # Read out variable if payload ok
+        if payload_ok:
+            if self._variable not in call.data:
+                return
+            value = call.data[self._variable]
+            self._state = (value == self._on_value)
+            if self._delay_after is None:
+                self._delay_after = dt_util.utcnow() + datetime.timedelta(
+                    seconds=self._reset_delay_sec)
+                track_point_in_time(
+                    self._hass, self._reset_state,
+                    self._delay_after)
+            self.schedule_update_ha_state()

homeassistant/components/binary_sensor/ping.py

@@ -35,6 +35,9 @@ SCAN_INTERVAL = timedelta(minutes=5)
 PING_MATCHER = re.compile(
     r'(?P<min>\d+.\d+)\/(?P<avg>\d+.\d+)\/(?P<max>\d+.\d+)\/(?P<mdev>\d+.\d+)')
 
+WIN32_PING_MATCHER = re.compile(
+    r'(?P<min>\d+)ms.+(?P<max>\d+)ms.+(?P<avg>\d+)ms')
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
@@ -102,7 +105,7 @@ class PingData(object):
 
         if sys.platform == 'win32':
             self._ping_cmd = [
-                'ping', '-n', str(self._count), '-w 1000', self._ip_address]
+                'ping', '-n', str(self._count), '-w', '1000', self._ip_address]
         else:
             self._ping_cmd = [
                 'ping', '-n', '-q', '-c', str(self._count), '-W1',
@@ -114,13 +117,23 @@ class PingData(object):
             self._ping_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         try:
             out = pinger.communicate()
-            match = PING_MATCHER.search(str(out).split('\n')[-1])
-            rtt_min, rtt_avg, rtt_max, rtt_mdev = match.groups()
-            return {
-                'min': rtt_min,
-                'avg': rtt_avg,
-                'max': rtt_max,
-                'mdev': rtt_mdev}
+            _LOGGER.debug("Output is %s", str(out))
+            if sys.platform == 'win32':
+                match = WIN32_PING_MATCHER.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': ''}
+            else:
+                match = PING_MATCHER.search(str(out).split('\n')[-1])
+                rtt_min, rtt_avg, rtt_max, rtt_mdev = match.groups()
+                return {
+                    'min': rtt_min,
+                    'avg': rtt_avg,
+                    'max': rtt_max,
+                    'mdev': rtt_mdev}
         except (subprocess.CalledProcessError, AttributeError):
             return False
 

homeassistant/components/binary_sensor/raspihats.py

@@ -0,0 +1,131 @@
+"""
+Configure a binary_sensor using a digital input from a raspihats board.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.raspihats/
+"""
+import logging
+import voluptuous as vol
+from homeassistant.const import (
+    CONF_NAME, CONF_DEVICE_CLASS, DEVICE_DEFAULT_NAME
+)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    PLATFORM_SCHEMA, BinarySensorDevice
+)
+from homeassistant.components.raspihats import (
+    CONF_I2C_HATS, CONF_BOARD, CONF_ADDRESS, CONF_CHANNELS, CONF_INDEX,
+    CONF_INVERT_LOGIC, I2C_HAT_NAMES, I2C_HATS_MANAGER, I2CHatsException
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['raspihats']
+
+DEFAULT_INVERT_LOGIC = False
+DEFAULT_DEVICE_CLASS = None
+
+_CHANNELS_SCHEMA = vol.Schema([{
+    vol.Required(CONF_INDEX): cv.positive_int,
+    vol.Required(CONF_NAME): cv.string,
+    vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean,
+    vol.Optional(CONF_DEVICE_CLASS, default=DEFAULT_DEVICE_CLASS): cv.string,
+}])
+
+_I2C_HATS_SCHEMA = vol.Schema([{
+    vol.Required(CONF_BOARD): vol.In(I2C_HAT_NAMES),
+    vol.Required(CONF_ADDRESS): vol.Coerce(int),
+    vol.Required(CONF_CHANNELS): _CHANNELS_SCHEMA
+}])
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_I2C_HATS): _I2C_HATS_SCHEMA,
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the raspihats binary_sensor devices."""
+    I2CHatBinarySensor.I2C_HATS_MANAGER = hass.data[I2C_HATS_MANAGER]
+    binary_sensors = []
+    i2c_hat_configs = config.get(CONF_I2C_HATS)
+    for i2c_hat_config in i2c_hat_configs:
+        address = i2c_hat_config[CONF_ADDRESS]
+        board = i2c_hat_config[CONF_BOARD]
+        try:
+            I2CHatBinarySensor.I2C_HATS_MANAGER.register_board(board, address)
+            for channel_config in i2c_hat_config[CONF_CHANNELS]:
+                binary_sensors.append(
+                    I2CHatBinarySensor(
+                        address,
+                        channel_config[CONF_INDEX],
+                        channel_config[CONF_NAME],
+                        channel_config[CONF_INVERT_LOGIC],
+                        channel_config[CONF_DEVICE_CLASS]
+                    )
+                )
+        except I2CHatsException as ex:
+            _LOGGER.error(
+                "Failed to register " + board + "I2CHat@" + hex(address) + " "
+                + str(ex)
+            )
+    add_devices(binary_sensors)
+
+
+class I2CHatBinarySensor(BinarySensorDevice):
+    """Represents a binary sensor that uses a I2C-HAT digital input."""
+
+    I2C_HATS_MANAGER = None
+
+    def __init__(self, address, channel, name, invert_logic, device_class):
+        """Initialize sensor."""
+        self._address = address
+        self._channel = channel
+        self._name = name or DEVICE_DEFAULT_NAME
+        self._invert_logic = invert_logic
+        self._device_class = device_class
+        self._state = self.I2C_HATS_MANAGER.read_di(
+            self._address,
+            self._channel
+        )
+
+        def online_callback():
+            """Callback fired when board is online."""
+            self.schedule_update_ha_state()
+
+        self.I2C_HATS_MANAGER.register_online_callback(
+            self._address,
+            self._channel,
+            online_callback
+        )
+
+        def edge_callback(state):
+            """Read digital input state."""
+            self._state = state
+            self.schedule_update_ha_state()
+
+        self.I2C_HATS_MANAGER.register_di_callback(
+            self._address,
+            self._channel,
+            edge_callback
+        )
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return self._device_class
+
+    @property
+    def name(self):
+        """Return the name of this sensor."""
+        return self._name
+
+    @property
+    def should_poll(self):
+        """Polling not needed for this sensor."""
+        return False
+
+    @property
+    def is_on(self):
+        """Return the state of this sensor."""
+        return self._state != self._invert_logic

homeassistant/components/binary_sensor/rest.py

@@ -44,7 +44,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the REST binary sensor."""
+    """Set up the REST binary sensor."""
     name = config.get(CONF_NAME)
     resource = config.get(CONF_RESOURCE)
     method = config.get(CONF_METHOD)
@@ -114,8 +114,8 @@ class RestBinarySensor(BinarySensorDevice):
         try:
             return bool(int(response))
         except ValueError:
-            return {"true": True, "on": True, "open": True,
-                    "yes": True}.get(response.lower(), False)
+            return {'true': True, 'on': True, 'open': True,
+                    'yes': True}.get(response.lower(), False)
 
     def update(self):
         """Get the latest data from REST API and updates the state."""

homeassistant/components/binary_sensor/rpi_gpio.py

@@ -41,10 +41,10 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Raspberry PI GPIO devices."""
-    pull_mode = config.get('pull_mode', DEFAULT_PULL_MODE)
-    bouncetime = config.get('bouncetime', DEFAULT_BOUNCETIME)
-    invert_logic = config.get('invert_logic', DEFAULT_INVERT_LOGIC)
+    """Set up the Raspberry PI GPIO devices."""
+    pull_mode = config.get(CONF_PULL_MODE)
+    bouncetime = config.get(CONF_BOUNCETIME)
+    invert_logic = config.get(CONF_INVERT_LOGIC)
 
     binary_sensors = []
     ports = config.get('ports')

homeassistant/components/binary_sensor/rpi_pfio.py

@@ -0,0 +1,93 @@
+"""
+Support for binary sensor using the PiFace Digital I/O module on a RPi.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.rpi_pfio/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.components.rpi_pfio as rpi_pfio
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import DEVICE_DEFAULT_NAME
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_NAME = 'name'
+ATTR_INVERT_LOGIC = 'invert_logic'
+ATTR_SETTLE_TIME = 'settle_time'
+CONF_PORTS = 'ports'
+
+DEFAULT_INVERT_LOGIC = False
+DEFAULT_SETTLE_TIME = 20
+
+DEPENDENCIES = ['rpi_pfio']
+
+PORT_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_NAME, default=None): cv.string,
+    vol.Optional(ATTR_SETTLE_TIME, default=DEFAULT_SETTLE_TIME):
+        cv.positive_int,
+    vol.Optional(ATTR_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_PORTS, default={}): vol.Schema({
+        cv.positive_int: PORT_SCHEMA
+    })
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the PiFace Digital Input devices."""
+    binary_sensors = []
+    ports = config.get('ports')
+    for port, port_entity in ports.items():
+        name = port_entity[ATTR_NAME]
+        settle_time = port_entity[ATTR_SETTLE_TIME] / 1000
+        invert_logic = port_entity[ATTR_INVERT_LOGIC]
+
+        binary_sensors.append(RPiPFIOBinarySensor(
+            hass, port, name, settle_time, invert_logic))
+    add_devices(binary_sensors, True)
+
+    rpi_pfio.activate_listener(hass)
+
+
+class RPiPFIOBinarySensor(BinarySensorDevice):
+    """Represent a binary sensor that a PiFace Digital Input."""
+
+    def __init__(self, hass, port, name, settle_time, invert_logic):
+        """Initialize the RPi binary sensor."""
+        self._port = port
+        self._name = name or DEVICE_DEFAULT_NAME
+        self._invert_logic = invert_logic
+        self._state = None
+
+        def read_pfio(port):
+            """Read state from PFIO."""
+            self._state = rpi_pfio.read_input(self._port)
+            self.schedule_update_ha_state()
+
+        rpi_pfio.edge_detect(hass, self._port, read_pfio, settle_time)
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the entity."""
+        return self._state != self._invert_logic
+
+    def update(self):
+        """Update the PFIO state."""
+        self._state = rpi_pfio.read_input(self._port)

homeassistant/components/binary_sensor/sleepiq.py

@@ -11,7 +11,7 @@ DEPENDENCIES = ['sleepiq']
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the SleepIQ sensors."""
+    """Set up the SleepIQ sensors."""
     if discovery_info is None:
         return
 

homeassistant/components/binary_sensor/tcp.py

@@ -27,5 +27,5 @@ class TcpBinarySensor(BinarySensorDevice, TcpSensor):
 
     @property
     def is_on(self):
-        """True if the binary sensor is on."""
+        """Return true if the binary sensor is on."""
         return self._state == self._config[CONF_VALUE_ON]

homeassistant/components/binary_sensor/template.py

@@ -41,7 +41,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Setup template binary sensors."""
+    """Set up template binary sensors."""
     sensors = []
 
     for device, device_config in config[CONF_SENSORS].items():
@@ -57,15 +57,11 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 
         sensors.append(
             BinarySensorTemplate(
-                hass,
-                device,
-                friendly_name,
-                device_class,
-                value_template,
+                hass, device, friendly_name, device_class, value_template,
                 entity_ids)
             )
     if not sensors:
-        _LOGGER.error('No sensors added')
+        _LOGGER.error("No sensors added")
         return False
 
     async_add_devices(sensors, True)
@@ -79,8 +75,8 @@ class BinarySensorTemplate(BinarySensorDevice):
                  value_template, entity_ids):
         """Initialize the Template binary sensor."""
         self.hass = hass
-        self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device,
-                                                  hass=hass)
+        self.entity_id = async_generate_entity_id(
+            ENTITY_ID_FORMAT, device, hass=hass)
         self._name = friendly_name
         self._device_class = device_class
         self._template = value_template
@@ -96,7 +92,7 @@ class BinarySensorTemplate(BinarySensorDevice):
 
         @callback
         def template_bsensor_state_listener(entity, old_state, new_state):
-            """Called when the target device changes state."""
+            """Handle the target device state changes."""
             self.hass.async_add_job(self.async_update_ha_state(True))
 
         @callback
@@ -139,8 +135,8 @@ class BinarySensorTemplate(BinarySensorDevice):
             if ex.args and ex.args[0].startswith(
                     "UndefinedError: 'None' has no attribute"):
                 # Common during HA startup - so just a warning
-                _LOGGER.warning('Could not render template %s,'
-                                ' the state is unknown.', self._name)
+                _LOGGER.warning("Could not render template %s, "
+                                "the state is unknown", self._name)
                 return
-            _LOGGER.error('Could not render template %s: %s', self._name, ex)
+            _LOGGER.error("Could not render template %s: %s", self._name, ex)
             self._state = False

homeassistant/components/binary_sensor/threshold.py

@@ -77,7 +77,7 @@ class ThresholdSensor(BinarySensorDevice):
         # pylint: disable=invalid-name
         def async_threshold_sensor_state_listener(
                 entity, old_state, new_state):
-            """Called when the sensor changes state."""
+            """Handle sensor state changes."""
             if new_state.state == STATE_UNKNOWN:
                 return
 

homeassistant/components/binary_sensor/trend.py

@@ -6,22 +6,18 @@ https://home-assistant.io/components/sensor.trend/
 """
 import asyncio
 import logging
+
 import voluptuous as vol
 
 from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
 from homeassistant.components.binary_sensor import (
-    BinarySensorDevice,
-    ENTITY_ID_FORMAT,
-    PLATFORM_SCHEMA,
+    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,)
+    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_SENSOR_CLASS,
+    CONF_DEVICE_CLASS, STATE_UNKNOWN,)
 from homeassistant.helpers.deprecation import get_deprecated
 from homeassistant.helpers.entity import generate_entity_id
 from homeassistant.helpers.event import track_state_change
@@ -47,7 +43,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the trend sensors."""
+    """Set up the trend sensors."""
     sensors = []
 
     for device, device_config in config[CONF_SENSORS].items():
@@ -60,13 +56,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
         sensors.append(
             SensorTrend(
-                hass,
-                device,
-                friendly_name,
-                entity_id,
-                attribute,
-                device_class,
-                invert)
+                hass, device, friendly_name, entity_id, attribute,
+                device_class, invert)
             )
     if not sensors:
         _LOGGER.error("No sensors added")
@@ -82,8 +73,8 @@ class SensorTrend(BinarySensorDevice):
                  target_entity, attribute, device_class, invert):
         """Initialize the sensor."""
         self._hass = hass
-        self.entity_id = generate_entity_id(ENTITY_ID_FORMAT, device_id,
-                                            hass=hass)
+        self.entity_id = generate_entity_id(
+            ENTITY_ID_FORMAT, device_id, hass=hass)
         self._name = friendly_name
         self._target_entity = target_entity
         self._attribute = attribute
@@ -95,7 +86,7 @@ class SensorTrend(BinarySensorDevice):
 
         @callback
         def trend_sensor_state_listener(entity, old_state, new_state):
-            """Called when the target device changes state."""
+            """Handle the target device state changes."""
             self.from_state = old_state
             self.to_state = new_state
             hass.async_add_job(self.async_update_ha_state(True))

homeassistant/components/binary_sensor/volvooncall.py

@@ -3,7 +3,6 @@ Support for VOC.
 
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.volvooncall/
-
 """
 import logging
 
@@ -14,7 +13,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup Volvo sensors."""
+    """Set up the Volvo sensors."""
     if discovery_info is None:
         return
     add_devices([VolvoSensor(hass, *discovery_info)])
@@ -28,7 +27,7 @@ class VolvoSensor(VolvoEntity, BinarySensorDevice):
         """Return True if the binary sensor is on."""
         val = getattr(self.vehicle, self._attribute)
         if self._attribute == 'bulb_failures':
-            return len(val) > 0
+            return bool(val)
         elif self._attribute in ['doors', 'windows']:
             return any([val[key] for key in val if 'Open' in key])
         else:

homeassistant/components/binary_sensor/wemo.py

@@ -29,7 +29,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
 
 
 class WemoBinarySensor(BinarySensorDevice):
-    """Represents a WeMo binary sensor."""
+    """Representation a WeMo binary sensor."""
 
     def __init__(self, device):
         """Initialize the WeMo sensor."""
@@ -41,10 +41,8 @@ class WemoBinarySensor(BinarySensorDevice):
         wemo.SUBSCRIPTION_REGISTRY.on(self.wemo, None, self._update_callback)
 
     def _update_callback(self, _device, _type, _params):
-        """Called by the Wemo device callback to update state."""
-        _LOGGER.info(
-            'Subscription update for  %s',
-            _device)
+        """Handle state changes."""
+        _LOGGER.info("Subscription update for %s", _device)
         updated = self.wemo.subscription_update(_type, _params)
         self._update(force_update=(not updated))
 
@@ -60,7 +58,7 @@ class WemoBinarySensor(BinarySensorDevice):
     @property
     def unique_id(self):
         """Return the id of this WeMo device."""
-        return "{}.{}".format(self.__class__, self.wemo.serialnumber)
+        return '{}.{}'.format(self.__class__, self.wemo.serialnumber)
 
     @property
     def name(self):
@@ -69,7 +67,7 @@ class WemoBinarySensor(BinarySensorDevice):
 
     @property
     def is_on(self):
-        """True if sensor is on."""
+        """Return true if sensor is on."""
         return self._state
 
     def update(self):
@@ -80,5 +78,5 @@ class WemoBinarySensor(BinarySensorDevice):
         try:
             self._state = self.wemo.get_state(force_update)
         except AttributeError as err:
-            _LOGGER.warning('Could not update status for %s (%s)',
-                            self.name, err)
+            _LOGGER.warning(
+                "Could not update status for %s (%s)", self.name, err)

homeassistant/components/binary_sensor/wink.py

@@ -4,6 +4,7 @@ Support for Wink binary sensors.
 For more details about this platform, please refer to the documentation at
 at https://home-assistant.io/components/binary_sensor.wink/
 """
+import asyncio
 import logging
 
 from homeassistant.components.binary_sensor import BinarySensorDevice
@@ -16,23 +17,23 @@ DEPENDENCIES = ['wink']
 
 # These are the available sensors mapped to binary_sensor class
 SENSOR_TYPES = {
-    "opened": "opening",
-    "brightness": "light",
-    "vibration": "vibration",
-    "loudness": "sound",
-    "noise": "sound",
-    "capturing_audio": "sound",
-    "liquid_detected": "moisture",
-    "motion": "motion",
-    "presence": "occupancy",
-    "co_detected": "gas",
-    "smoke_detected": "smoke",
-    "capturing_video": None
+    'opened': 'opening',
+    'brightness': 'light',
+    'vibration': 'vibration',
+    'loudness': 'sound',
+    'noise': 'sound',
+    'capturing_audio': 'sound',
+    'liquid_detected': 'moisture',
+    'motion': 'motion',
+    'presence': 'occupancy',
+    'co_detected': 'gas',
+    'smoke_detected': 'smoke',
+    'capturing_video': None
 }
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Wink binary sensor platform."""
+    """Set up the Wink binary sensor platform."""
     import pywink
 
     for sensor in pywink.get_sensors():
@@ -83,7 +84,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 if camera_sensor.capability() in SENSOR_TYPES:
                     add_devices([WinkBinarySensorDevice(camera_sensor, hass)])
             except AttributeError:
-                _LOGGER.info("Device isn't a sensor, skipping.")
+                _LOGGER.info("Device isn't a sensor, skipping")
 
 
 class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
@@ -101,6 +102,11 @@ class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
         else:
             self.capability = None
 
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Callback when entity is added to hass."""
+        self.hass.data[DOMAIN]['entities']['binary_sensor'].append(self)
+
     @property
     def is_on(self):
         """Return true if the binary sensor is on."""

homeassistant/components/binary_sensor/workday.py

@@ -11,10 +11,9 @@ import datetime
 import voluptuous as vol
 
 from homeassistant.components.sensor import PLATFORM_SCHEMA
-from homeassistant.const import (
-    STATE_ON, STATE_OFF, STATE_UNKNOWN, CONF_NAME, WEEKDAYS)
+from homeassistant.const import CONF_NAME, WEEKDAYS
 import homeassistant.util.dt as dt_util
-from homeassistant.helpers.entity import Entity
+from homeassistant.components.binary_sensor import BinarySensorDevice
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
@@ -66,15 +65,20 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     obj_holidays = getattr(holidays, country)(years=year)
 
     if province:
-        if province not in obj_holidays.PROVINCES and \
-                        province not in obj_holidays.STATES:
+        # 'state' and 'prov' are not interchangeable, so need to make
+        # sure we use the right one
+        if (hasattr(obj_holidays, "PROVINCES") and
+                province in obj_holidays.PROVINCES):
+            obj_holidays = getattr(holidays, country)(prov=province,
+                                                      years=year)
+        elif (hasattr(obj_holidays, "STATES") and
+              province in obj_holidays.STATES):
+            obj_holidays = getattr(holidays, country)(state=province,
+                                                      years=year)
+        else:
             _LOGGER.error("There is no province/state %s in country %s",
                           province, country)
             return False
-        else:
-            year = datetime.datetime.now().year
-            obj_holidays = getattr(holidays, country)(prov=province,
-                                                      years=year)
 
     _LOGGER.debug("Found the following holidays for your configuration:")
     for date, name in sorted(obj_holidays.items()):
@@ -92,7 +96,7 @@ def day_to_string(day):
         return None
 
 
-class IsWorkdaySensor(Entity):
+class IsWorkdaySensor(BinarySensorDevice):
     """Implementation of a Workday sensor."""
 
     def __init__(self, obj_holidays, workdays, excludes, name):
@@ -101,7 +105,7 @@ class IsWorkdaySensor(Entity):
         self._obj_holidays = obj_holidays
         self._workdays = workdays
         self._excludes = excludes
-        self._state = STATE_UNKNOWN
+        self._state = None
 
     @property
     def name(self):
@@ -109,7 +113,7 @@ class IsWorkdaySensor(Entity):
         return self._name
 
     @property
-    def state(self):
+    def is_on(self):
         """Return the state of the device."""
         return self._state
 
@@ -135,14 +139,14 @@ class IsWorkdaySensor(Entity):
     def async_update(self):
         """Get date and look whether it is a holiday."""
         # Default is no workday
-        self._state = STATE_OFF
+        self._state = False
 
         # Get iso day of the week (1 = Monday, 7 = Sunday)
         day = datetime.datetime.today().isoweekday() - 1
         day_of_week = day_to_string(day)
 
         if self.is_include(day_of_week, dt_util.now()):
-            self._state = STATE_ON
+            self._state = True
 
         if self.is_exclude(day_of_week, dt_util.now()):
-            self._state = STATE_OFF
+            self._state = False

homeassistant/components/binary_sensor/zha.py

@@ -0,0 +1,89 @@
+"""
+Binary sensors on Zigbee Home Automation networks.
+
+For more details on this platform, please refer to the documentation
+at https://home-assistant.io/components/binary_sensor.zha/
+"""
+import asyncio
+import logging
+
+from homeassistant.components.binary_sensor import DOMAIN, BinarySensorDevice
+from homeassistant.components import zha
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['zha']
+
+# ZigBee Cluster Library Zone Type to Home Assistant device class
+CLASS_MAPPING = {
+    0x000d: 'motion',
+    0x0015: 'opening',
+    0x0028: 'smoke',
+    0x002a: 'moisture',
+    0x002b: 'gas',
+    0x002d: 'vibration',
+}
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Zigbee Home Automation binary sensors."""
+    discovery_info = zha.get_discovery_info(hass, discovery_info)
+    if discovery_info is None:
+        return
+
+    from bellows.zigbee.zcl.clusters.security import IasZone
+
+    clusters = discovery_info['clusters']
+
+    device_class = None
+    cluster = [c for c in clusters if isinstance(c, IasZone)][0]
+    if discovery_info['new_join']:
+        yield from cluster.bind()
+        ieee = cluster.endpoint.device.application.ieee
+        yield from cluster.write_attributes({'cie_addr': ieee})
+
+    try:
+        zone_type = yield from cluster['zone_type']
+        device_class = CLASS_MAPPING.get(zone_type, None)
+    except Exception:  # pylint: disable=broad-except
+        # If we fail to read from the device, use a non-specific class
+        pass
+
+    sensor = BinarySensor(device_class, **discovery_info)
+    async_add_devices([sensor])
+
+
+class BinarySensor(zha.Entity, BinarySensorDevice):
+    """THe ZHA Binary Sensor."""
+
+    _domain = DOMAIN
+
+    def __init__(self, device_class, **kwargs):
+        """Initialize the ZHA binary sensor."""
+        super().__init__(**kwargs)
+        self._device_class = device_class
+        from bellows.zigbee.zcl.clusters.security import IasZone
+        self._ias_zone_cluster = self._clusters[IasZone.cluster_id]
+
+    @property
+    def is_on(self) -> bool:
+        """Return True if entity is on."""
+        if self._state == 'unknown':
+            return False
+        return bool(self._state)
+
+    @property
+    def device_class(self):
+        """Return the class of this device, from component DEVICE_CLASSES."""
+        return self._device_class
+
+    def cluster_command(self, aps_frame, tsn, command_id, args):
+        """Handle commands received to this cluster."""
+        if command_id == 0:
+            self._state = args[0] & 3
+            _LOGGER.debug("Updated alarm state: %s", self._state)
+            self.schedule_update_ha_state()
+        elif command_id == 1:
+            _LOGGER.debug("Enroll requested")
+            self.hass.add_job(self._ias_zone_cluster.enroll_response(0, 0))

homeassistant/components/binary_sensor/zigbee.py

@@ -23,7 +23,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the ZigBee binary sensor platform."""
+    """Set up the ZigBee binary sensor platform."""
     add_devices(
         [ZigBeeBinarySensor(hass, ZigBeeDigitalInConfig(config))], True)
 

homeassistant/components/binary_sensor/zwave.py

@@ -20,7 +20,7 @@ DEPENDENCIES = []
 
 
 def get_device(values, **kwargs):
-    """Create zwave entity device."""
+    """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
@@ -45,12 +45,12 @@ class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity):
         self._state = self.values.primary.data
 
     def update_properties(self):
-        """Callback on data changes for node values."""
+        """Handle data changes for node values."""
         self._state = self.values.primary.data
 
     @property
     def is_on(self):
-        """Return True if the binary sensor is on."""
+        """Return true if the binary sensor is on."""
         return self._state
 
     @property
@@ -69,7 +69,7 @@ class ZWaveTriggerSensor(ZWaveBinarySensor):
         self.invalidate_after = None
 
     def update_properties(self):
-        """Called when a value for this entity's node has changed."""
+        """Handle value changes for this entity's node."""
         self._state = self.values.primary.data
         # only allow this value to be true for re_arm secs
         if not self.hass:
@@ -83,7 +83,7 @@ class ZWaveTriggerSensor(ZWaveBinarySensor):
 
     @property
     def is_on(self):
-        """Return True if movement has happened within the rearm time."""
+        """Return true if movement has happened within the rearm time."""
         return self._state and \
             (self.invalidate_after is None or
              self.invalidate_after > dt_util.utcnow())

homeassistant/components/blink.py

@@ -13,7 +13,7 @@ from homeassistant.const import (
     CONF_USERNAME, CONF_PASSWORD, ATTR_FRIENDLY_NAME, ATTR_ARMED)
 from homeassistant.helpers import discovery
 
-REQUIREMENTS = ['blinkpy==0.5.2']
+REQUIREMENTS = ['blinkpy==0.6.0']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/bloomsky.py

@@ -35,7 +35,7 @@ CONFIG_SCHEMA = vol.Schema({
 
 # pylint: disable=unused-argument
 def setup(hass, config):
-    """Setup BloomSky component."""
+    """Set up the BloomSky component."""
     api_key = config[DOMAIN][CONF_API_KEY]
 
     global BLOOMSKY
@@ -67,9 +67,8 @@ class BloomSky(object):
     def refresh_devices(self):
         """Use the API to retrieve a list of devices."""
         _LOGGER.debug("Fetching BloomSky update")
-        response = requests.get(self.API_URL,
-                                headers={"Authorization": self._api_key},
-                                timeout=10)
+        response = requests.get(
+            self.API_URL, headers={"Authorization": self._api_key}, timeout=10)
         if response.status_code == 401:
             raise RuntimeError("Invalid API_KEY")
         elif response.status_code != 200:

homeassistant/components/calendar/__init__.py

@@ -7,12 +7,10 @@ https://home-assistant.io/components/calendar/
 import asyncio
 import logging
 from datetime import timedelta
-
 import re
 
-from homeassistant.components.google import (CONF_OFFSET,
-                                             CONF_DEVICE_ID,
-                                             CONF_NAME)
+from homeassistant.components.google import (
+    CONF_OFFSET, CONF_DEVICE_ID, CONF_NAME)
 from homeassistant.const import STATE_OFF, STATE_ON
 from homeassistant.helpers.config_validation import time_period_str
 from homeassistant.helpers.entity import Entity, generate_entity_id
@@ -22,16 +20,18 @@ from homeassistant.util import dt
 
 _LOGGER = logging.getLogger(__name__)
 
-SCAN_INTERVAL = timedelta(seconds=60)
 DOMAIN = 'calendar'
+
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 
+SCAN_INTERVAL = timedelta(seconds=60)
+
 
 @asyncio.coroutine
 def async_setup(hass, config):
     """Track states and offer events for calendars."""
     component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL, DOMAIN)
+        _LOGGER, DOMAIN, hass, SCAN_INTERVAL, DOMAIN)
 
     yield from component.async_setup(config)
     return True
@@ -55,9 +55,8 @@ class CalendarEventDevice(Entity):
         self._name = data.get(CONF_NAME)
         self.dev_id = data.get(CONF_DEVICE_ID)
         self._offset = data.get(CONF_OFFSET, DEFAULT_CONF_OFFSET)
-        self.entity_id = generate_entity_id(ENTITY_ID_FORMAT,
-                                            self.dev_id,
-                                            hass=hass)
+        self.entity_id = generate_entity_id(
+            ENTITY_ID_FORMAT, self.dev_id, hass=hass)
 
         self._cal_data = {
             'all_day': False,
@@ -87,7 +86,7 @@ class CalendarEventDevice(Entity):
 
     @property
     def device_state_attributes(self):
-        """State Attributes for HA."""
+        """Return the device state attributes."""
         start = self._cal_data.get('start', None)
         end = self._cal_data.get('end', None)
         start = start.strftime(DATE_STR_FORMAT) if start is not None else None

homeassistant/components/calendar/demo.py

@@ -1,82 +1,82 @@
-"""
-Demo platform that has two fake binary sensors.
-
-For more details about this platform, please refer to the documentation
-https://home-assistant.io/components/demo/
-"""
-import homeassistant.util.dt as dt_util
-from homeassistant.components.calendar import CalendarEventDevice
-from homeassistant.components.google import CONF_DEVICE_ID, CONF_NAME
-
-
-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Demo binary sensor platform."""
-    calendar_data_future = DemoGoogleCalendarDataFuture()
-    calendar_data_current = DemoGoogleCalendarDataCurrent()
-    add_devices([
-        DemoGoogleCalendar(hass, calendar_data_future, {
-            CONF_NAME: 'Future Event',
-            CONF_DEVICE_ID: 'future_event',
-        }),
-
-        DemoGoogleCalendar(hass, calendar_data_current, {
-            CONF_NAME: 'Current Event',
-            CONF_DEVICE_ID: 'current_event',
-        }),
-    ])
-
-
-class DemoGoogleCalendarData(object):
-    """Setup base class for data."""
+"""
+Demo platform that has two fake binary sensors.
 
-    # pylint: disable=no-self-use
-    def update(self):
-        """Return true so entity knows we have new data."""
-        return True
-
-
-class DemoGoogleCalendarDataFuture(DemoGoogleCalendarData):
-    """Setup future data event."""
-
-    def __init__(self):
-        """Set the event to a future event."""
-        one_hour_from_now = dt_util.now() \
-            + dt_util.dt.timedelta(minutes=30)
-        self.event = {
-            'start': {
-                'dateTime': one_hour_from_now.isoformat()
-            },
-            'end': {
-                'dateTime': (one_hour_from_now + dt_util.dt.
-                             timedelta(minutes=60)).isoformat()
-            },
-            'summary': 'Future Event',
-        }
-
-
-class DemoGoogleCalendarDataCurrent(DemoGoogleCalendarData):
-    """Create a current event we're in the middle of."""
-
-    def __init__(self):
-        """Set the event data."""
-        middle_of_event = dt_util.now() \
-            - dt_util.dt.timedelta(minutes=30)
-        self.event = {
-            'start': {
-                'dateTime': middle_of_event.isoformat()
-            },
-            'end': {
-                'dateTime': (middle_of_event + dt_util.dt.
-                             timedelta(minutes=60)).isoformat()
-            },
-            'summary': 'Current Event',
-        }
-
-
-class DemoGoogleCalendar(CalendarEventDevice):
-    """A Demo binary sensor."""
-
-    def __init__(self, hass, calendar_data, data):
-        """The same as a google calendar but without the api calls."""
-        self.data = calendar_data
-        super().__init__(hass, data)
+For more details about this platform, please refer to the documentation
+https://home-assistant.io/components/demo/
+"""
+import homeassistant.util.dt as dt_util
+from homeassistant.components.calendar import CalendarEventDevice
+from homeassistant.components.google import CONF_DEVICE_ID, CONF_NAME
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Demo Calendar platform."""
+    calendar_data_future = DemoGoogleCalendarDataFuture()
+    calendar_data_current = DemoGoogleCalendarDataCurrent()
+    add_devices([
+        DemoGoogleCalendar(hass, calendar_data_future, {
+            CONF_NAME: 'Future Event',
+            CONF_DEVICE_ID: 'future_event',
+        }),
+
+        DemoGoogleCalendar(hass, calendar_data_current, {
+            CONF_NAME: 'Current Event',
+            CONF_DEVICE_ID: 'current_event',
+        }),
+    ])
+
+
+class DemoGoogleCalendarData(object):
+    """Representation of a Demo Calendar element."""
+
+    # pylint: disable=no-self-use
+    def update(self):
+        """Return true so entity knows we have new data."""
+        return True
+
+
+class DemoGoogleCalendarDataFuture(DemoGoogleCalendarData):
+    """Representation of a Demo Calendar for a future event."""
+
+    def __init__(self):
+        """Set the event to a future event."""
+        one_hour_from_now = dt_util.now() \
+            + dt_util.dt.timedelta(minutes=30)
+        self.event = {
+            'start': {
+                'dateTime': one_hour_from_now.isoformat()
+            },
+            'end': {
+                'dateTime': (one_hour_from_now + dt_util.dt.
+                             timedelta(minutes=60)).isoformat()
+            },
+            'summary': 'Future Event',
+        }
+
+
+class DemoGoogleCalendarDataCurrent(DemoGoogleCalendarData):
+    """Representation of a Demo Calendar for a current event."""
+
+    def __init__(self):
+        """Set the event data."""
+        middle_of_event = dt_util.now() \
+            - dt_util.dt.timedelta(minutes=30)
+        self.event = {
+            'start': {
+                'dateTime': middle_of_event.isoformat()
+            },
+            'end': {
+                'dateTime': (middle_of_event + dt_util.dt.
+                             timedelta(minutes=60)).isoformat()
+            },
+            'summary': 'Current Event',
+        }
+
+
+class DemoGoogleCalendar(CalendarEventDevice):
+    """Representation of a Demo Calendar element."""
+
+    def __init__(self, hass, calendar_data, data):
+        """Initialize Google Calendar but without the API calls."""
+        self.data = calendar_data
+        super().__init__(hass, data)

homeassistant/components/calendar/google.py

@@ -1,79 +1,78 @@
-"""
-Support for Google Calendar Search binary sensors.
-
-For more details about this platform, please refer to the documentation at
-https://home-assistant.io/components/binary_sensor.google_calendar/
-"""
-# pylint: disable=import-error
-import logging
-from datetime import timedelta
-
-from homeassistant.components.calendar import CalendarEventDevice
-from homeassistant.components.google import (CONF_CAL_ID, CONF_ENTITIES,
-                                             CONF_TRACK, TOKEN_FILE,
-                                             GoogleCalendarService)
-from homeassistant.util import Throttle, dt
-
-DEFAULT_GOOGLE_SEARCH_PARAMS = {
-    'orderBy': 'startTime',
-    'maxResults': 1,
-    'singleEvents': True,
-}
-
-# Return cached results if last scan was less then this time ago
-MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=15)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def setup_platform(hass, config, add_devices, disc_info=None):
-    """Setup the calendar platform for event devices."""
-    if disc_info is None:
-        return
-
-    if not any([data[CONF_TRACK] for data in disc_info[CONF_ENTITIES]]):
-        return
-
-    calendar_service = GoogleCalendarService(hass.config.path(TOKEN_FILE))
-    add_devices([GoogleCalendarEventDevice(hass, calendar_service,
-                                           disc_info[CONF_CAL_ID], data)
-                 for data in disc_info[CONF_ENTITIES] if data[CONF_TRACK]])
-
-
-# pylint: disable=too-many-instance-attributes
-class GoogleCalendarEventDevice(CalendarEventDevice):
-    """A calendar event device."""
-
-    def __init__(self, hass, calendar_service, calendar, data):
-        """Create the Calendar event device."""
-        self.data = GoogleCalendarData(calendar_service, calendar,
-                                       data.get('search', None))
-        super().__init__(hass, data)
-
-
-class GoogleCalendarData(object):
-    """Class to utilize calendar service object to get next event."""
-
-    def __init__(self, calendar_service, calendar_id, search=None):
-        """Setup how we are going to search the google calendar."""
-        self.calendar_service = calendar_service
-        self.calendar_id = calendar_id
-        self.search = search
-        self.event = None
-
-    @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    def update(self):
-        """Get the latest data."""
-        service = self.calendar_service.get()
-        params = dict(DEFAULT_GOOGLE_SEARCH_PARAMS)
-        params['timeMin'] = dt.now().isoformat('T')
-        params['calendarId'] = self.calendar_id
-        if self.search:
-            params['q'] = self.search
-
-        events = service.events()  # pylint: disable=no-member
-        result = events.list(**params).execute()
-
-        items = result.get('items', [])
-        self.event = items[0] if len(items) == 1 else None
-        return True
+"""
+Support for Google Calendar Search binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.google_calendar/
+"""
+# pylint: disable=import-error
+import logging
+from datetime import timedelta
+
+from homeassistant.components.calendar import CalendarEventDevice
+from homeassistant.components.google import (
+    CONF_CAL_ID, CONF_ENTITIES, CONF_TRACK, TOKEN_FILE,
+    GoogleCalendarService)
+from homeassistant.util import Throttle, dt
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_GOOGLE_SEARCH_PARAMS = {
+    'orderBy': 'startTime',
+    'maxResults': 1,
+    'singleEvents': True,
+}
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=15)
+
+
+def setup_platform(hass, config, add_devices, disc_info=None):
+    """Set up the calendar platform for event devices."""
+    if disc_info is None:
+        return
+
+    if not any([data[CONF_TRACK] for data in disc_info[CONF_ENTITIES]]):
+        return
+
+    calendar_service = GoogleCalendarService(hass.config.path(TOKEN_FILE))
+    add_devices([GoogleCalendarEventDevice(hass, calendar_service,
+                                           disc_info[CONF_CAL_ID], data)
+                 for data in disc_info[CONF_ENTITIES] if data[CONF_TRACK]])
+
+
+# pylint: disable=too-many-instance-attributes
+class GoogleCalendarEventDevice(CalendarEventDevice):
+    """A calendar event device."""
+
+    def __init__(self, hass, calendar_service, calendar, data):
+        """Create the Calendar event device."""
+        self.data = GoogleCalendarData(calendar_service, calendar,
+                                       data.get('search', None))
+        super().__init__(hass, data)
+
+
+class GoogleCalendarData(object):
+    """Class to utilize calendar service object to get next event."""
+
+    def __init__(self, calendar_service, calendar_id, search=None):
+        """Set up how we are going to search the google calendar."""
+        self.calendar_service = calendar_service
+        self.calendar_id = calendar_id
+        self.search = search
+        self.event = None
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Get the latest data."""
+        service = self.calendar_service.get()
+        params = dict(DEFAULT_GOOGLE_SEARCH_PARAMS)
+        params['timeMin'] = dt.now().isoformat('T')
+        params['calendarId'] = self.calendar_id
+        if self.search:
+            params['q'] = self.search
+
+        events = service.events()  # pylint: disable=no-member
+        result = events.list(**params).execute()
+
+        items = result.get('items', [])
+        self.event = items[0] if len(items) == 1 else None
+        return True

homeassistant/components/camera/__init__.py

@@ -76,7 +76,7 @@ def async_get_image(hass, entity_id, timeout=10):
 
 @asyncio.coroutine
 def async_setup(hass, config):
-    """Setup the camera component."""
+    """Set up the camera component."""
     component = EntityComponent(_LOGGER, DOMAIN, hass, SCAN_INTERVAL)
 
     hass.http.register_view(CameraImageView(component.entities))
@@ -121,12 +121,12 @@ class Camera(Entity):
 
     @property
     def brand(self):
-        """Camera brand."""
+        """Return the camera brand."""
         return None
 
     @property
     def model(self):
-        """Camera model."""
+        """Return the camera model."""
         return None
 
     def camera_image(self):
@@ -138,7 +138,7 @@ class Camera(Entity):
 
         This method must be run in the event loop and returns a coroutine.
         """
-        return self.hass.loop.run_in_executor(None, self.camera_image)
+        return self.hass.async_add_job(self.camera_image)
 
     @asyncio.coroutine
     def handle_async_mjpeg_stream(self, request):
@@ -191,7 +191,7 @@ class Camera(Entity):
 
     @property
     def state(self):
-        """Camera state."""
+        """Return the camera state."""
         if self.is_recording:
             return STATE_RECORDING
         elif self.is_streaming:
@@ -201,7 +201,7 @@ class Camera(Entity):
 
     @property
     def state_attributes(self):
-        """Camera state attributes."""
+        """Return the camera state attributes."""
         attr = {
             'access_token': self.access_tokens[-1],
         }
@@ -233,7 +233,7 @@ class CameraView(HomeAssistantView):
 
     @asyncio.coroutine
     def get(self, request, entity_id):
-        """Start a get request."""
+        """Start a GET request."""
         camera = self.entities.get(entity_id)
 
         if camera is None:
@@ -241,7 +241,7 @@ class CameraView(HomeAssistantView):
             return web.Response(status=status)
 
         authenticated = (request[KEY_AUTHENTICATED] or
-                         request.GET.get('token') in camera.access_tokens)
+                         request.query.get('token') in camera.access_tokens)
 
         if not authenticated:
             return web.Response(status=401)
@@ -251,15 +251,15 @@ class CameraView(HomeAssistantView):
 
     @asyncio.coroutine
     def handle(self, request, camera):
-        """Hanlde the camera request."""
+        """Handle the camera request."""
         raise NotImplementedError()
 
 
 class CameraImageView(CameraView):
     """Camera view to serve an image."""
 
-    url = "/api/camera_proxy/{entity_id}"
-    name = "api:camera:image"
+    url = '/api/camera_proxy/{entity_id}'
+    name = 'api:camera:image'
 
     @asyncio.coroutine
     def handle(self, request, camera):
@@ -269,7 +269,7 @@ class CameraImageView(CameraView):
                 image = yield from camera.async_camera_image()
 
             if image:
-                return web.Response(body=image)
+                return web.Response(body=image, content_type='image/jpeg')
 
         return web.Response(status=500)
 
@@ -277,8 +277,8 @@ class CameraImageView(CameraView):
 class CameraMjpegStream(CameraView):
     """Camera View to serve an MJPEG stream."""
 
-    url = "/api/camera_proxy_stream/{entity_id}"
-    name = "api:camera:stream"
+    url = '/api/camera_proxy_stream/{entity_id}'
+    name = 'api:camera:stream'
 
     @asyncio.coroutine
     def handle(self, request, camera):

homeassistant/components/camera/amcrest.py

@@ -12,18 +12,22 @@ import voluptuous as vol
 
 import homeassistant.loader as loader
 from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
+from homeassistant.components.ffmpeg import DATA_FFMPEG
 from homeassistant.const import (
     CONF_HOST, CONF_NAME, CONF_USERNAME, CONF_PASSWORD, CONF_PORT)
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import (
-    async_get_clientsession, async_aiohttp_proxy_web)
+    async_get_clientsession, async_aiohttp_proxy_web,
+    async_aiohttp_proxy_stream)
 
-REQUIREMENTS = ['amcrest==1.1.9']
+REQUIREMENTS = ['amcrest==1.2.0']
+DEPENDENCIES = ['ffmpeg']
 
 _LOGGER = logging.getLogger(__name__)
 
 CONF_RESOLUTION = 'resolution'
 CONF_STREAM_SOURCE = 'stream_source'
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
 
 DEFAULT_NAME = 'Amcrest Camera'
 DEFAULT_PORT = 80
@@ -40,7 +44,8 @@ RESOLUTION_LIST = {
 
 STREAM_SOURCE_LIST = {
     'mjpeg': 0,
-    'snapshot': 1
+    'snapshot': 1,
+    'rtsp': 2,
 }
 
 CONTENT_TYPE_HEADER = 'Content-Type'
@@ -56,6 +61,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
     vol.Optional(CONF_STREAM_SOURCE, default=DEFAULT_STREAM_SOURCE):
         vol.All(vol.In(STREAM_SOURCE_LIST)),
+    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string,
 })
 
 
@@ -92,8 +98,9 @@ class AmcrestCam(Camera):
         super(AmcrestCam, self).__init__()
         self._camera = camera
         self._base_url = self._camera.get_base_url()
-        self._hass = hass
         self._name = device_info.get(CONF_NAME)
+        self._ffmpeg = hass.data[DATA_FFMPEG]
+        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
         self._resolution = RESOLUTION_LIST[device_info.get(CONF_RESOLUTION)]
         self._stream_source = STREAM_SOURCE_LIST[
             device_info.get(CONF_STREAM_SOURCE)
@@ -117,15 +124,28 @@ class AmcrestCam(Camera):
             yield from super().handle_async_mjpeg_stream(request)
             return
 
-        # Otherwise, stream an MJPEG image stream directly from the camera
-        websession = async_get_clientsession(self.hass)
-        streaming_url = '{0}mjpg/video.cgi?channel=0&subtype={1}'.format(
-            self._base_url, self._resolution)
+        elif self._stream_source == STREAM_SOURCE_LIST['mjpeg']:
+            # stream an MJPEG image stream directly from the camera
+            websession = async_get_clientsession(self.hass)
+            streaming_url = self._camera.mjpeg_url(typeno=self._resolution)
+            stream_coro = websession.get(
+                streaming_url, auth=self._token, timeout=TIMEOUT)
 
-        stream_coro = websession.get(
-            streaming_url, auth=self._token, timeout=TIMEOUT)
+            yield from async_aiohttp_proxy_web(self.hass, request, stream_coro)
 
-        yield from async_aiohttp_proxy_web(self.hass, request, stream_coro)
+        else:
+            # streaming via fmpeg
+            from haffmpeg import CameraMjpeg
+
+            streaming_url = self._camera.rtsp_url(typeno=self._resolution)
+            stream = CameraMjpeg(self._ffmpeg.binary, loop=self.hass.loop)
+            yield from stream.open_camera(
+                streaming_url, extra_cmd=self._ffmpeg_arguments)
+
+            yield from async_aiohttp_proxy_stream(
+                self.hass, request, stream,
+                'multipart/x-mixed-replace;boundary=ffserver')
+            yield from stream.close()
 
     @property
     def name(self):

homeassistant/components/camera/arlo.py

@@ -0,0 +1,92 @@
+"""
+This component provides basic support for Netgear Arlo IP cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.arlo/
+"""
+import asyncio
+import logging
+import voluptuous as vol
+
+from homeassistant.helpers import config_validation as cv
+from homeassistant.components.arlo import DEFAULT_BRAND
+
+from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
+from homeassistant.components.ffmpeg import DATA_FFMPEG
+from homeassistant.helpers.aiohttp_client import (
+    async_aiohttp_proxy_stream)
+
+DEPENDENCIES = ['arlo', 'ffmpeg']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_FFMPEG_ARGUMENTS):
+        cv.string,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up an Arlo IP Camera."""
+    arlo = hass.data.get('arlo')
+    if not arlo:
+        return False
+
+    cameras = []
+    for camera in arlo.cameras:
+        cameras.append(ArloCam(hass, camera, config))
+
+    async_add_devices(cameras, True)
+    return True
+
+
+class ArloCam(Camera):
+    """An implementation of a Netgear Arlo IP camera."""
+
+    def __init__(self, hass, camera, device_info):
+        """Initialize an Arlo camera."""
+        super().__init__()
+
+        self._camera = camera
+        self._name = self._camera.name
+        self._ffmpeg = hass.data[DATA_FFMPEG]
+        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
+
+    def camera_image(self):
+        """Return a still image reponse from the camera."""
+        return self._camera.last_image
+
+    @asyncio.coroutine
+    def handle_async_mjpeg_stream(self, request):
+        """Generate an HTTP MJPEG stream from the camera."""
+        from haffmpeg import CameraMjpeg
+        video = self._camera.last_video
+        if not video:
+            return
+
+        stream = CameraMjpeg(self._ffmpeg.binary, loop=self.hass.loop)
+        yield from stream.open_camera(
+            video.video_url, extra_cmd=self._ffmpeg_arguments)
+
+        yield from async_aiohttp_proxy_stream(
+            self.hass, request, stream,
+            'multipart/x-mixed-replace;boundary=ffserver')
+        yield from stream.close()
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name
+
+    @property
+    def model(self):
+        """Camera model."""
+        return self._camera.model_id
+
+    @property
+    def brand(self):
+        """Camera brand."""
+        return DEFAULT_BRAND

homeassistant/components/camera/axis.py

@@ -0,0 +1,38 @@
+"""
+Support for Axis camera streaming.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.axis/
+"""
+import logging
+
+from homeassistant.const import (
+    CONF_NAME, CONF_USERNAME, CONF_PASSWORD,
+    CONF_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION)
+from homeassistant.components.camera.mjpeg import (
+    CONF_MJPEG_URL, CONF_STILL_IMAGE_URL, MjpegCamera)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['axis']
+DOMAIN = 'axis'
+
+
+def _get_image_url(host, mode):
+    if mode == 'mjpeg':
+        return 'http://{}/axis-cgi/mjpg/video.cgi'.format(host)
+    elif mode == 'single':
+        return 'http://{}/axis-cgi/jpg/image.cgi'.format(host)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup Axis camera."""
+    device_info = {
+        CONF_NAME: discovery_info['name'],
+        CONF_USERNAME: discovery_info['username'],
+        CONF_PASSWORD: discovery_info['password'],
+        CONF_MJPEG_URL: _get_image_url(discovery_info['host'], 'mjpeg'),
+        CONF_STILL_IMAGE_URL: _get_image_url(discovery_info['host'], 'single'),
+        CONF_AUTHENTICATION: HTTP_DIGEST_AUTHENTICATION,
+    }
+    add_devices([MjpegCamera(hass, device_info)])

homeassistant/components/camera/blink.py

@@ -21,7 +21,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup a Blink Camera."""
+    """Set up a Blink Camera."""
     if discovery_info is None:
         return
 
@@ -49,19 +49,19 @@ class BlinkCamera(Camera):
 
     @property
     def name(self):
-        """A camera name."""
+        """Return the camera name."""
         return self._name
 
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
     def request_image(self):
-        """An image request from Blink servers."""
+        """Request a new image from Blink servers."""
         _LOGGER.info("Requesting new image from blink servers")
         image_url = self.check_for_motion()
         header = self.data.cameras[self._name].header
         self.response = requests.get(image_url, headers=header, stream=True)
 
     def check_for_motion(self):
-        """A method to check if motion has been detected since last update."""
+        """Check if motion has been detected since last update."""
         self.data.refresh()
         notifs = self.data.cameras[self._name].notifications
         if notifs > self.notifications:

homeassistant/components/camera/bloomsky.py

@@ -16,7 +16,7 @@ DEPENDENCIES = ['bloomsky']
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup access to BloomSky cameras."""
+    """Set up access to BloomSky cameras."""
     bloomsky = get_component('bloomsky')
     for device in bloomsky.BLOOMSKY.devices.values():
         add_devices([BloomSkyCamera(bloomsky.BLOOMSKY, device)])
@@ -26,14 +26,14 @@ class BloomSkyCamera(Camera):
     """Representation of the images published from the BloomSky's camera."""
 
     def __init__(self, bs, device):
-        """Setup for access to the BloomSky camera images."""
+        """Initialize access to the BloomSky camera images."""
         super(BloomSkyCamera, self).__init__()
         self._name = device['DeviceName']
         self._id = device['DeviceID']
         self._bloomsky = bs
         self._url = ""
         self._last_url = ""
-        # _last_image will store images as they are downloaded so that the
+        # last_image will store images as they are downloaded so that the
         # frequent updates in home-assistant don't keep poking the server
         # to download the same image over and over.
         self._last_image = ""

homeassistant/components/camera/demo.py

@@ -11,7 +11,7 @@ from homeassistant.components.camera import Camera
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Demo camera platform."""
+    """Set up the Demo camera platform."""
     add_devices([
         DemoCamera('Demo camera')
     ])
@@ -29,8 +29,8 @@ class DemoCamera(Camera):
         """Return a faked still image response."""
         now = dt_util.utcnow()
 
-        image_path = os.path.join(os.path.dirname(__file__),
-                                  'demo_{}.jpg'.format(now.second % 4))
+        image_path = os.path.join(
+            os.path.dirname(__file__), 'demo_{}.jpg'.format(now.second % 4))
         with open(image_path, 'rb') as file:
             return file.read()
 

homeassistant/components/camera/ffmpeg.py

@@ -16,10 +16,10 @@ from homeassistant.components.ffmpeg import (
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.aiohttp_client import (
     async_aiohttp_proxy_stream)
-DEPENDENCIES = ['ffmpeg']
 
 _LOGGER = logging.getLogger(__name__)
 
+DEPENDENCIES = ['ffmpeg']
 DEFAULT_NAME = 'FFmpeg'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -31,7 +31,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Setup a FFmpeg Camera."""
+    """Set up a FFmpeg camera."""
     if not hass.data[DATA_FFMPEG].async_run_test(config.get(CONF_INPUT)):
         return
     async_add_devices([FFmpegCamera(hass, config)])

homeassistant/components/camera/foscam.py

@@ -32,7 +32,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup a Foscam IP Camera."""
+    """Set up a Foscam IP Camera."""
     add_devices([FoscamCamera(config)])
 
 
@@ -60,7 +60,7 @@ class FoscamCamera(Camera):
         )
         self._name = device_info.get(CONF_NAME)
 
-        _LOGGER.info('Using the following URL for %s: %s',
+        _LOGGER.info("Using the following URL for %s: %s",
                      self._name, uri_template.format('***', '***'))
 
     def camera_image(self):

homeassistant/components/camera/generic.py

@@ -43,7 +43,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 @asyncio.coroutine
 # pylint: disable=unused-argument
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Setup a generic IP Camera."""
+    """Set up a generic IP Camera."""
     async_add_devices([GenericCamera(hass, config)])
 
 
@@ -85,8 +85,8 @@ class GenericCamera(Camera):
         try:
             url = self._still_image_url.async_render()
         except TemplateError as err:
-            _LOGGER.error('Error parsing template %s: %s',
-                          self._still_image_url, err)
+            _LOGGER.error(
+                "Error parsing template %s: %s", self._still_image_url, err)
             return self._last_image
 
         if url == self._last_url and self._limit_refetch:
@@ -100,11 +100,11 @@ class GenericCamera(Camera):
                     response = requests.get(url, timeout=10, auth=self._auth)
                     return response.content
                 except requests.exceptions.RequestException as error:
-                    _LOGGER.error('Error getting camera image: %s', error)
+                    _LOGGER.error("Error getting camera image: %s", error)
                     return self._last_image
 
-            self._last_image = yield from self.hass.loop.run_in_executor(
-                None, fetch)
+            self._last_image = yield from self.hass.async_add_job(
+                fetch)
         # async
         else:
             try:
@@ -114,10 +114,10 @@ class GenericCamera(Camera):
                         url, auth=self._auth)
                 self._last_image = yield from response.read()
             except asyncio.TimeoutError:
-                _LOGGER.error('Timeout getting camera image')
+                _LOGGER.error("Timeout getting camera image")
                 return self._last_image
             except aiohttp.ClientError as err:
-                _LOGGER.error('Error getting new camera image: %s', err)
+                _LOGGER.error("Error getting new camera image: %s", err)
                 return self._last_image
 
         self._last_url = url