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

0.59.1

.coveragerc

@@ -53,6 +53,11 @@ omit =
     homeassistant/components/digital_ocean.py
     homeassistant/components/*/digital_ocean.py
 
+    homeassistant/components/dominos.py
+
+	homeassistant/components/doorbird.py
+	homeassistant/components/*/doorbird.py
+
     homeassistant/components/dweet.py
     homeassistant/components/*/dweet.py
 
@@ -68,12 +73,18 @@ omit =
     homeassistant/components/envisalink.py
     homeassistant/components/*/envisalink.py
 
+    homeassistant/components/gc100.py
+    homeassistant/components/*/gc100.py
+
     homeassistant/components/google.py
     homeassistant/components/*/google.py
 
     homeassistant/components/hdmi_cec.py
     homeassistant/components/*/hdmi_cec.py
 
+    homeassistant/components/hive.py
+    homeassistant/components/*/hive.py
+
     homeassistant/components/homematic.py
     homeassistant/components/*/homematic.py
 
@@ -104,6 +115,9 @@ omit =
     homeassistant/components/lametric.py
     homeassistant/components/*/lametric.py
 
+    homeassistant/components/linode.py
+    homeassistant/components/*/linode.py
+
     homeassistant/components/lutron.py
     homeassistant/components/*/lutron.py
 
@@ -146,6 +160,9 @@ omit =
     homeassistant/components/rachio.py
     homeassistant/components/*/rachio.py
 
+    homeassistant/components/raincloud.py
+    homeassistant/components/*/raincloud.py
+
     homeassistant/components/raspihats.py
     homeassistant/components/*/raspihats.py
 
@@ -158,12 +175,21 @@ omit =
     homeassistant/components/rpi_pfio.py
     homeassistant/components/*/rpi_pfio.py
 
+    homeassistant/components/satel_integra.py
+    homeassistant/components/*/satel_integra.py
+
     homeassistant/components/scsgate.py
     homeassistant/components/*/scsgate.py
 
+    homeassistant/components/skybell.py
+    homeassistant/components/*/skybell.py
+
     homeassistant/components/tado.py
     homeassistant/components/*/tado.py
 
+    homeassistant/components/tahoma.py
+    homeassistant/components/*/tahoma.py
+
     homeassistant/components/tellduslive.py
     homeassistant/components/*/tellduslive.py
 
@@ -173,8 +199,14 @@ omit =
     homeassistant/components/tesla.py
     homeassistant/components/*/tesla.py
 
+    homeassistant/components/thethingsnetwork.py
+    homeassistant/components/*/thethingsnetwork.py
+
     homeassistant/components/*/thinkingcleaner.py
 
+    homeassistant/components/toon.py
+    homeassistant/components/*/toon.py
+
     homeassistant/components/tradfri.py
     homeassistant/components/*/tradfri.py
 
@@ -205,15 +237,15 @@ omit =
     homeassistant/components/wemo.py
     homeassistant/components/*/wemo.py
 
-    homeassistant/components/wink.py
+    homeassistant/components/wink/*
     homeassistant/components/*/wink.py
 
-    homeassistant/components/xiaomi.py
-    homeassistant/components/binary_sensor/xiaomi.py
-    homeassistant/components/cover/xiaomi.py
-    homeassistant/components/light/xiaomi.py
-    homeassistant/components/sensor/xiaomi.py
-    homeassistant/components/switch/xiaomi.py
+    homeassistant/components/xiaomi_aqara.py
+    homeassistant/components/binary_sensor/xiaomi_aqara.py
+    homeassistant/components/cover/xiaomi_aqara.py
+    homeassistant/components/light/xiaomi_aqara.py
+    homeassistant/components/sensor/xiaomi_aqara.py
+    homeassistant/components/switch/xiaomi_aqara.py
 
     homeassistant/components/zabbix.py
     homeassistant/components/*/zabbix.py
@@ -247,13 +279,17 @@ omit =
     homeassistant/components/binary_sensor/rest.py
     homeassistant/components/binary_sensor/tapsaff.py
     homeassistant/components/browser.py
+    homeassistant/components/calendar/todoist.py
     homeassistant/components/camera/bloomsky.py
     homeassistant/components/camera/ffmpeg.py
     homeassistant/components/camera/foscam.py
     homeassistant/components/camera/mjpeg.py
     homeassistant/components/camera/rpi_camera.py
     homeassistant/components/camera/onvif.py
+    homeassistant/components/camera/ring.py
     homeassistant/components/camera/synology.py
+    homeassistant/components/camera/yi.py
+    homeassistant/components/climate/ephember.py
     homeassistant/components/climate/eq3btsmart.py
     homeassistant/components/climate/flexit.py
     homeassistant/components/climate/heatmiser.py
@@ -281,8 +317,10 @@ omit =
     homeassistant/components/device_tracker/cisco_ios.py
     homeassistant/components/device_tracker/fritz.py
     homeassistant/components/device_tracker/gpslogger.py
+    homeassistant/components/device_tracker/hitron_coda.py
     homeassistant/components/device_tracker/huawei_router.py
     homeassistant/components/device_tracker/icloud.py
+    homeassistant/components/device_tracker/keenetic_ndms2.py
     homeassistant/components/device_tracker/linksys_ap.py
     homeassistant/components/device_tracker/linksys_smart.py
     homeassistant/components/device_tracker/luci.py
@@ -296,6 +334,7 @@ omit =
     homeassistant/components/device_tracker/thomson.py
     homeassistant/components/device_tracker/tomato.py
     homeassistant/components/device_tracker/tado.py
+    homeassistant/components/device_tracker/tile.py
     homeassistant/components/device_tracker/tplink.py
     homeassistant/components/device_tracker/trackr.py
     homeassistant/components/device_tracker/ubus.py
@@ -303,6 +342,7 @@ omit =
     homeassistant/components/emoncms_history.py
     homeassistant/components/emulated_hue/upnp.py
     homeassistant/components/fan/mqtt.py
+    homeassistant/components/fan/xiaomi_miio.py
     homeassistant/components/feedreader.py
     homeassistant/components/foursquare.py
     homeassistant/components/ifttt.py
@@ -331,7 +371,7 @@ omit =
     homeassistant/components/light/tplink.py
     homeassistant/components/light/tradfri.py
     homeassistant/components/light/x10.py
-    homeassistant/components/light/xiaomi_philipslight.py
+    homeassistant/components/light/xiaomi_miio.py
     homeassistant/components/light/yeelight.py
     homeassistant/components/light/yeelightsunflower.py
     homeassistant/components/light/zengge.py
@@ -390,9 +430,10 @@ omit =
     homeassistant/components/notify/aws_sns.py
     homeassistant/components/notify/aws_sqs.py
     homeassistant/components/notify/ciscospark.py
+    homeassistant/components/notify/clickatell.py
     homeassistant/components/notify/clicksend.py
+    homeassistant/components/notify/clicksend_tts.py
     homeassistant/components/notify/discord.py
-    homeassistant/components/notify/facebook.py
     homeassistant/components/notify/free_mobile.py
     homeassistant/components/notify/gntp.py
     homeassistant/components/notify/group.py
@@ -412,6 +453,7 @@ omit =
     homeassistant/components/notify/pushover.py
     homeassistant/components/notify/pushsafer.py
     homeassistant/components/notify/rest.py
+    homeassistant/components/notify/rocketchat.py
     homeassistant/components/notify/sendgrid.py
     homeassistant/components/notify/simplepush.py
     homeassistant/components/notify/slack.py
@@ -421,8 +463,10 @@ omit =
     homeassistant/components/notify/telstra.py
     homeassistant/components/notify/twitter.py
     homeassistant/components/notify/xmpp.py
+    homeassistant/components/notify/yessssms.py
     homeassistant/components/nuimo_controller.py
     homeassistant/components/prometheus.py
+    homeassistant/components/remember_the_milk/__init__.py
     homeassistant/components/remote/harmony.py
     homeassistant/components/remote/itach.py
     homeassistant/components/scene/hunterdouglas_powerview.py
@@ -439,7 +483,6 @@ omit =
     homeassistant/components/sensor/broadlink.py
     homeassistant/components/sensor/buienradar.py
     homeassistant/components/sensor/citybikes.py
-    homeassistant/components/sensor/coinmarketcap.py
     homeassistant/components/sensor/cert_expiry.py
     homeassistant/components/sensor/comed_hourly_pricing.py
     homeassistant/components/sensor/cpuspeed.py
@@ -447,6 +490,7 @@ omit =
     homeassistant/components/sensor/cups.py
     homeassistant/components/sensor/currencylayer.py
     homeassistant/components/sensor/darksky.py
+    homeassistant/components/sensor/deluge.py
     homeassistant/components/sensor/deutsche_bahn.py
     homeassistant/components/sensor/dht.py
     homeassistant/components/sensor/dnsip.py
@@ -474,17 +518,19 @@ omit =
     homeassistant/components/sensor/gpsd.py
     homeassistant/components/sensor/gtfs.py
     homeassistant/components/sensor/haveibeenpwned.py
-    homeassistant/components/sensor/hddtemp.py
     homeassistant/components/sensor/hp_ilo.py
     homeassistant/components/sensor/htu21d.py
     homeassistant/components/sensor/hydroquebec.py
     homeassistant/components/sensor/imap.py
     homeassistant/components/sensor/imap_email_content.py
     homeassistant/components/sensor/influxdb.py
+    homeassistant/components/sensor/irish_rail_transport.py
     homeassistant/components/sensor/kwb.py
+    homeassistant/components/sensor/lacrosse.py
     homeassistant/components/sensor/lastfm.py
     homeassistant/components/sensor/linux_battery.py
     homeassistant/components/sensor/loopenergy.py
+    homeassistant/components/sensor/luftdaten.py
     homeassistant/components/sensor/lyft.py
     homeassistant/components/sensor/metoffice.py
     homeassistant/components/sensor/miflora.py
@@ -492,6 +538,7 @@ omit =
     homeassistant/components/sensor/mopar.py
     homeassistant/components/sensor/mqtt_room.py
     homeassistant/components/sensor/mvglive.py
+    homeassistant/components/sensor/nederlandse_spoorwegen.py
     homeassistant/components/sensor/netdata.py
     homeassistant/components/sensor/neurio_energy.py
     homeassistant/components/sensor/nut.py
@@ -508,12 +555,14 @@ omit =
     homeassistant/components/sensor/pocketcasts.py
     homeassistant/components/sensor/pushbullet.py
     homeassistant/components/sensor/pvoutput.py
+    homeassistant/components/sensor/pyload.py
     homeassistant/components/sensor/qnap.py
     homeassistant/components/sensor/radarr.py
     homeassistant/components/sensor/ripple.py
     homeassistant/components/sensor/sabnzbd.py
     homeassistant/components/sensor/scrape.py
     homeassistant/components/sensor/sensehat.py
+    homeassistant/components/sensor/serial.py
     homeassistant/components/sensor/serial_pm.py
     homeassistant/components/sensor/shodan.py
     homeassistant/components/sensor/skybeacon.py
@@ -527,21 +576,26 @@ omit =
     homeassistant/components/sensor/swiss_public_transport.py
     homeassistant/components/sensor/synologydsm.py
     homeassistant/components/sensor/systemmonitor.py
+    homeassistant/components/sensor/sytadin.py
     homeassistant/components/sensor/tank_utility.py
     homeassistant/components/sensor/ted5000.py
     homeassistant/components/sensor/temper.py
+    homeassistant/components/sensor/tibber.py
     homeassistant/components/sensor/time_date.py
     homeassistant/components/sensor/torque.py
     homeassistant/components/sensor/transmission.py
+    homeassistant/components/sensor/travisci.py
     homeassistant/components/sensor/twitch.py
     homeassistant/components/sensor/uber.py
     homeassistant/components/sensor/upnp.py
     homeassistant/components/sensor/ups.py
     homeassistant/components/sensor/vasttrafik.py
+    homeassistant/components/sensor/viaggiatreno.py
     homeassistant/components/sensor/waqi.py
+    homeassistant/components/sensor/whois.py
     homeassistant/components/sensor/worldtidesinfo.py
+    homeassistant/components/sensor/worxlandroid.py
     homeassistant/components/sensor/xbox_live.py
-    homeassistant/components/sensor/yweather.py
     homeassistant/components/sensor/zamg.py
     homeassistant/components/shiftr.py
     homeassistant/components/spc.py
@@ -549,6 +603,7 @@ omit =
     homeassistant/components/switch/anel_pwrctrl.py
     homeassistant/components/switch/arest.py
     homeassistant/components/switch/broadlink.py
+    homeassistant/components/switch/deluge.py
     homeassistant/components/switch/digitalloggers.py
     homeassistant/components/switch/dlink.py
     homeassistant/components/switch/edimax.py
@@ -561,17 +616,21 @@ omit =
     homeassistant/components/switch/orvibo.py
     homeassistant/components/switch/pilight.py
     homeassistant/components/switch/pulseaudio_loopback.py
+    homeassistant/components/switch/rainbird.py
     homeassistant/components/switch/rainmachine.py
     homeassistant/components/switch/rest.py
     homeassistant/components/switch/rpi_rf.py
+    homeassistant/components/switch/snmp.py
     homeassistant/components/switch/tplink.py
+    homeassistant/components/switch/telnet.py
     homeassistant/components/switch/transmission.py
-    homeassistant/components/switch/wake_on_lan.py
+    homeassistant/components/switch/xiaomi_miio.py
     homeassistant/components/telegram_bot/*
     homeassistant/components/thingspeak.py
     homeassistant/components/tts/amazon_polly.py
+    homeassistant/components/tts/baidu.py
+    homeassistant/components/tts/microsoft.py
     homeassistant/components/tts/picotts.py
-    homeassistant/components/upnp.py
     homeassistant/components/vacuum/roomba.py
     homeassistant/components/weather/bom.py
     homeassistant/components/weather/buienradar.py
@@ -581,7 +640,7 @@ omit =
     homeassistant/components/weather/zamg.py
     homeassistant/components/zeroconf.py
     homeassistant/components/zwave/util.py
-
+    homeassistant/components/vacuum/mqtt.py
 
 [report]
 # Regexes for lines to exclude from consideration

.gitignore

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

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "homeassistant/components/frontend/www_static/home-assistant-polymer"]
-	path = homeassistant/components/frontend/www_static/home-assistant-polymer
-	url = https://github.com/home-assistant/home-assistant-polymer.git

.travis.yml

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

CODEOWNERS

@@ -29,6 +29,9 @@ homeassistant/components/weblink.py @home-assistant/core
 homeassistant/components/websocket_api.py @home-assistant/core
 homeassistant/components/zone.py @home-assistant/core
 
+# To monitor non-pypi additions
+requirements_all.txt @andrey-git
+
 Dockerfile @home-assistant/docker
 virtualization/Docker/* @home-assistant/docker
 
@@ -36,6 +39,44 @@ homeassistant/components/zwave/* @home-assistant/z-wave
 homeassistant/components/*/zwave.py @home-assistant/z-wave
 
 # Indiviudal components
+homeassistant/components/alarm_control_panel/egardia.py @jeroenterheerdt
+homeassistant/components/camera/yi.py @bachya
+homeassistant/components/climate/ephember.py @ttroy50
+homeassistant/components/climate/eq3btsmart.py @rytilahti
+homeassistant/components/climate/sensibo.py @andrey-git
 homeassistant/components/cover/template.py @PhracturedBlue
 homeassistant/components/device_tracker/automatic.py @armills
+homeassistant/components/device_tracker/tile.py @bachya
+homeassistant/components/history_graph.py @andrey-git
+homeassistant/components/light/tplink.py @rytilahti
+homeassistant/components/light/yeelight.py @rytilahti
 homeassistant/components/media_player/kodi.py @armills
+homeassistant/components/media_player/monoprice.py @etsinko
+homeassistant/components/media_player/yamaha_musiccast.py @jalmeroth
+homeassistant/components/sensor/airvisual.py @bachya
+homeassistant/components/sensor/irish_rail_transport.py @ttroy50
+homeassistant/components/sensor/miflora.py @danielhiversen
+homeassistant/components/sensor/sytadin.py @gautric
+homeassistant/components/sensor/tibber.py @danielhiversen
+homeassistant/components/sensor/waqi.py @andrey-git
+homeassistant/components/switch/rainmachine.py @bachya
+homeassistant/components/switch/tplink.py @rytilahti
+homeassistant/components/xiaomi_aqara.py @danielhiversen @syssi
+
+homeassistant/components/*/broadlink.py @danielhiversen
+homeassistant/components/hive.py @Rendili @KJonline
+homeassistant/components/*/hive.py @Rendili @KJonline
+homeassistant/components/*/rfxtrx.py @danielhiversen
+homeassistant/components/velux.py @Julius2342
+homeassistant/components/*/velux.py @Julius2342
+homeassistant/components/knx.py @Julius2342
+homeassistant/components/*/knx.py @Julius2342
+homeassistant/components/tahoma.py @philklei
+homeassistant/components/*/tahoma.py @philklei
+homeassistant/components/tesla.py @zabuldon
+homeassistant/components/*/tesla.py @zabuldon
+homeassistant/components/tellduslive.py @molobrakos @fredrike
+homeassistant/components/*/tellduslive.py @molobrakos @fredrike
+homeassistant/components/*/tradfri.py @ggravlingen
+homeassistant/components/*/xiaomi_aqara.py @danielhiversen @syssi
+homeassistant/components/*/xiaomi_miio.py @rytilahti @syssi

Dockerfile

@@ -3,7 +3,7 @@
 # This way, the development image and the production image are kept in sync.
 
 FROM python:3.6
-MAINTAINER Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>
+LABEL maintainer="Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>"
 
 # Uncomment any of the following lines to disable the installation.
 #ENV INSTALL_TELLSTICK no
@@ -11,7 +11,6 @@ MAINTAINER Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>
 #ENV INSTALL_FFMPEG no
 #ENV INSTALL_LIBCEC no
 #ENV INSTALL_PHANTOMJS no
-#ENV INSTALL_COAP_CLIENT no
 #ENV INSTALL_SSOCR no
 
 VOLUME /config
@@ -25,11 +24,10 @@ RUN virtualization/Docker/setup_docker_prereqs
 
 # Install hass component dependencies
 COPY requirements_all.txt requirements_all.txt
-
-# Uninstall enum34 because some depenndecies install it but breaks Python 3.4+.
+# Uninstall enum34 because some dependencies install it but breaks Python 3.4+.
 # See PR #8103 for more info.
 RUN pip3 install --no-cache-dir -r requirements_all.txt && \
-    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop cchardet
+    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop cchardet cython
 
 # Copy source
 COPY . .

MANIFEST.in

@@ -1,5 +1,4 @@
 include README.rst
 include LICENSE.md
 graft homeassistant
-prune homeassistant/components/frontend/www_static/home-assistant-polymer
 recursive-exclude * *.py[co]

docs/source/conf.py

@@ -19,15 +19,13 @@
 #
 import sys
 import os
-from os.path import relpath
 import inspect
-from homeassistant.const import (__version__, __short_version__, PROJECT_NAME,
-                                 PROJECT_LONG_DESCRIPTION,
-                                 PROJECT_COPYRIGHT, PROJECT_AUTHOR,
-                                 PROJECT_GITHUB_USERNAME,
-                                 PROJECT_GITHUB_REPOSITORY,
-                                 GITHUB_PATH, GITHUB_URL)
 
+from homeassistant.const import __version__, __short_version__
+from setup import (
+    PROJECT_NAME, PROJECT_LONG_DESCRIPTION, PROJECT_COPYRIGHT, PROJECT_AUTHOR,
+    PROJECT_GITHUB_USERNAME, PROJECT_GITHUB_REPOSITORY, GITHUB_PATH,
+    GITHUB_URL)
 
 sys.path.insert(0, os.path.abspath('_ext'))
 sys.path.insert(0, os.path.abspath('../homeassistant'))
@@ -87,9 +85,7 @@ edit_on_github_src_path = 'docs/source/'
 
 
 def linkcode_resolve(domain, info):
-    """
-    Determine the URL corresponding to Python object
-    """
+    """Determine the URL corresponding to Python object."""
     if domain != 'py':
         return None
     modname = info['module']
@@ -117,7 +113,11 @@ def linkcode_resolve(domain, info):
         linespec = "#L%d" % (lineno + 1)
     else:
         linespec = ""
-    fn = relpath(fn, start='../')
+    index = fn.find("/homeassistant/")
+    if index == -1:
+        index = 0
+
+    fn = fn[index:]
 
     return '{}/blob/{}/{}{}'.format(GITHUB_URL, code_branch, fn, linespec)
 

homeassistant/__main__.py

@@ -126,6 +126,12 @@ def get_arguments() -> argparse.Namespace:
         type=int,
         default=None,
         help='Enables daily log rotation and keeps up to the specified days')
+    parser.add_argument(
+        '--log-file',
+        type=str,
+        default=None,
+        help='Log file to write to.  If not set, CONFIG/home-assistant.log '
+             'is used')
     parser.add_argument(
         '--runner',
         action='store_true',
@@ -256,13 +262,14 @@ def setup_and_run_hass(config_dir: str,
         }
         hass = bootstrap.from_config_dict(
             config, config_dir=config_dir, verbose=args.verbose,
-            skip_pip=args.skip_pip, log_rotate_days=args.log_rotate_days)
+            skip_pip=args.skip_pip, log_rotate_days=args.log_rotate_days,
+            log_file=args.log_file)
     else:
         config_file = ensure_config_file(config_dir)
         print('Config directory:', config_dir)
         hass = bootstrap.from_config_file(
             config_file, verbose=args.verbose, skip_pip=args.skip_pip,
-            log_rotate_days=args.log_rotate_days)
+            log_rotate_days=args.log_rotate_days, log_file=args.log_file)
 
     if hass is None:
         return None

homeassistant/bootstrap.py

@@ -11,13 +11,11 @@ from typing import Any, Optional, Dict
 
 import voluptuous as vol
 
-import homeassistant.components as core_components
+from homeassistant import (
+    core, config as conf_util, loader, components as core_components)
 from homeassistant.components import persistent_notification
-import homeassistant.config as conf_util
-import homeassistant.core as core
 from homeassistant.const import EVENT_HOMEASSISTANT_CLOSE
 from homeassistant.setup import async_setup_component
-import homeassistant.loader as loader
 from homeassistant.util.logging import AsyncHandler
 from homeassistant.util.package import async_get_user_site, get_user_site
 from homeassistant.util.yaml import clear_secret_cache
@@ -27,9 +25,13 @@ from homeassistant.helpers.signal import async_register_signal_handling
 _LOGGER = logging.getLogger(__name__)
 
 ERROR_LOG_FILENAME = 'home-assistant.log'
+
+# hass.data key for logging information.
+DATA_LOGGING = 'logging'
+
 FIRST_INIT_COMPONENT = set((
-    'recorder', 'mqtt', 'mqtt_eventstream', 'logger', 'introduction',
-    'frontend', 'history'))
+    'system_log', 'recorder', 'mqtt', 'mqtt_eventstream', 'logger',
+    'introduction', 'frontend', 'history'))
 
 
 def from_config_dict(config: Dict[str, Any],
@@ -38,7 +40,8 @@ def from_config_dict(config: Dict[str, Any],
                      enable_log: bool=True,
                      verbose: bool=False,
                      skip_pip: bool=False,
-                     log_rotate_days: Any=None) \
+                     log_rotate_days: Any=None,
+                     log_file: Any=None) \
                      -> Optional[core.HomeAssistant]:
     """Try to configure Home Assistant from a configuration dictionary.
 
@@ -56,7 +59,7 @@ def from_config_dict(config: Dict[str, Any],
     hass = hass.loop.run_until_complete(
         async_from_config_dict(
             config, hass, config_dir, enable_log, verbose, skip_pip,
-            log_rotate_days)
+            log_rotate_days, log_file)
     )
 
     return hass
@@ -69,7 +72,8 @@ def async_from_config_dict(config: Dict[str, Any],
                            enable_log: bool=True,
                            verbose: bool=False,
                            skip_pip: bool=False,
-                           log_rotate_days: Any=None) \
+                           log_rotate_days: Any=None,
+                           log_file: Any=None) \
                            -> Optional[core.HomeAssistant]:
     """Try to configure Home Assistant from a configuration dictionary.
 
@@ -77,6 +81,18 @@ def async_from_config_dict(config: Dict[str, Any],
     This method is a coroutine.
     """
     start = time()
+
+    if enable_log:
+        async_enable_logging(hass, verbose, log_rotate_days, log_file)
+
+    if sys.version_info[:2] < (3, 5):
+        _LOGGER.warning(
+            'Python 3.4 support has been deprecated and will be removed in '
+            'the beginning of 2018. Please upgrade Python or your operating '
+            'system. More info: https://home-assistant.io/blog/2017/10/06/'
+            'deprecating-python-3.4-support/'
+        )
+
     core_config = config.get(core.DOMAIN, {})
 
     try:
@@ -87,9 +103,6 @@ def async_from_config_dict(config: Dict[str, Any],
 
     yield from hass.async_add_job(conf_util.process_ha_config_upgrade, hass)
 
-    if enable_log:
-        async_enable_logging(hass, verbose, log_rotate_days)
-
     hass.config.skip_pip = skip_pip
     if skip_pip:
         _LOGGER.warning("Skipping pip installation of required modules. "
@@ -153,7 +166,8 @@ def from_config_file(config_path: str,
                      hass: Optional[core.HomeAssistant]=None,
                      verbose: bool=False,
                      skip_pip: bool=True,
-                     log_rotate_days: Any=None):
+                     log_rotate_days: Any=None,
+                     log_file: Any=None):
     """Read the configuration file and try to start all the functionality.
 
     Will add functionality to 'hass' parameter if given,
@@ -165,7 +179,7 @@ def from_config_file(config_path: str,
     # run task
     hass = hass.loop.run_until_complete(
         async_from_config_file(
-            config_path, hass, verbose, skip_pip, log_rotate_days)
+            config_path, hass, verbose, skip_pip, log_rotate_days, log_file)
     )
 
     return hass
@@ -176,7 +190,8 @@ def async_from_config_file(config_path: str,
                            hass: core.HomeAssistant,
                            verbose: bool=False,
                            skip_pip: bool=True,
-                           log_rotate_days: Any=None):
+                           log_rotate_days: Any=None,
+                           log_file: Any=None):
     """Read the configuration file and try to start all the functionality.
 
     Will add functionality to 'hass' parameter.
@@ -187,7 +202,7 @@ def async_from_config_file(config_path: str,
     hass.config.config_dir = config_dir
     yield from async_mount_local_lib_path(config_dir, hass.loop)
 
-    async_enable_logging(hass, verbose, log_rotate_days)
+    async_enable_logging(hass, verbose, log_rotate_days, log_file)
 
     try:
         config_dict = yield from hass.async_add_job(
@@ -205,7 +220,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:
+                         log_rotate_days=None, log_file=None) -> None:
     """Set up the logging.
 
     This method must be run in the event loop.
@@ -239,13 +254,18 @@ def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
         pass
 
     # Log errors to a file if we have write access to file or config dir
-    err_log_path = hass.config.path(ERROR_LOG_FILENAME)
+    if log_file is None:
+        err_log_path = hass.config.path(ERROR_LOG_FILENAME)
+    else:
+        err_log_path = os.path.abspath(log_file)
+
     err_path_exists = os.path.isfile(err_log_path)
+    err_dir = os.path.dirname(err_log_path)
 
     # Check if we can write to the error log if it exists or that
     # we can create files in the containing directory if not.
     if (err_path_exists and os.access(err_log_path, os.W_OK)) or \
-       (not err_path_exists and os.access(hass.config.config_dir, os.W_OK)):
+       (not err_path_exists and os.access(err_dir, os.W_OK)):
 
         if log_rotate_days:
             err_handler = logging.handlers.TimedRotatingFileHandler(
@@ -272,6 +292,8 @@ def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
         logger.addHandler(async_handler)
         logger.setLevel(logging.INFO)
 
+        # Save the log file location for access by other components.
+        hass.data[DATA_LOGGING] = err_log_path
     else:
         _LOGGER.error(
             "Unable to setup error log %s (access denied)", err_log_path)

homeassistant/components/__init__.py

@@ -10,6 +10,7 @@ Component design guidelines:
 import asyncio
 import itertools as it
 import logging
+import os
 
 import homeassistant.core as ha
 import homeassistant.config as conf_util
@@ -110,6 +111,11 @@ def async_reload_core_config(hass):
 @asyncio.coroutine
 def async_setup(hass, config):
     """Set up general services related to Home Assistant."""
+    descriptions = yield from hass.async_add_job(
+        conf_util.load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml')
+    )
+
     @asyncio.coroutine
     def async_handle_turn_service(service):
         """Handle calls to homeassistant.turn_on/off."""
@@ -149,11 +155,14 @@ def async_setup(hass, config):
         yield from asyncio.wait(tasks, loop=hass.loop)
 
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_TURN_OFF, async_handle_turn_service)
+        ha.DOMAIN, SERVICE_TURN_OFF, async_handle_turn_service,
+        descriptions[ha.DOMAIN][SERVICE_TURN_OFF])
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_TURN_ON, async_handle_turn_service)
+        ha.DOMAIN, SERVICE_TURN_ON, async_handle_turn_service,
+        descriptions[ha.DOMAIN][SERVICE_TURN_ON])
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_TOGGLE, async_handle_turn_service)
+        ha.DOMAIN, SERVICE_TOGGLE, async_handle_turn_service,
+        descriptions[ha.DOMAIN][SERVICE_TOGGLE])
 
     @asyncio.coroutine
     def async_handle_core_service(call):
@@ -178,11 +187,14 @@ def async_setup(hass, config):
             hass.async_add_job(hass.async_stop(RESTART_EXIT_CODE))
 
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_HOMEASSISTANT_STOP, async_handle_core_service)
+        ha.DOMAIN, SERVICE_HOMEASSISTANT_STOP, async_handle_core_service,
+        descriptions[ha.DOMAIN][SERVICE_HOMEASSISTANT_STOP])
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_HOMEASSISTANT_RESTART, async_handle_core_service)
+        ha.DOMAIN, SERVICE_HOMEASSISTANT_RESTART, async_handle_core_service,
+        descriptions[ha.DOMAIN][SERVICE_HOMEASSISTANT_RESTART])
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_CHECK_CONFIG, async_handle_core_service)
+        ha.DOMAIN, SERVICE_CHECK_CONFIG, async_handle_core_service,
+        descriptions[ha.DOMAIN][SERVICE_CHECK_CONFIG])
 
     @asyncio.coroutine
     def async_handle_reload_config(call):
@@ -197,6 +209,7 @@ def async_setup(hass, config):
             hass, conf.get(ha.DOMAIN) or {})
 
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG, async_handle_reload_config)
+        ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG, async_handle_reload_config,
+        descriptions[ha.DOMAIN][SERVICE_RELOAD_CORE_CONFIG])
 
     return True

homeassistant/components/abode.py

@@ -6,57 +6,136 @@ https://home-assistant.io/components/abode/
 """
 import asyncio
 import logging
+from functools import partial
+from os import path
 
 import voluptuous as vol
-from requests.exceptions import HTTPError, ConnectTimeout
-from homeassistant.helpers import discovery
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity import Entity
-from homeassistant.const import (ATTR_ATTRIBUTION,
-                                 CONF_USERNAME, CONF_PASSWORD,
-                                 CONF_NAME, EVENT_HOMEASSISTANT_STOP,
-                                 EVENT_HOMEASSISTANT_START)
 
-REQUIREMENTS = ['abodepy==0.9.0']
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (
+    ATTR_ATTRIBUTION, ATTR_DATE, ATTR_TIME, ATTR_ENTITY_ID, CONF_USERNAME,
+    CONF_PASSWORD, CONF_EXCLUDE, CONF_NAME, CONF_LIGHTS,
+    EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_START)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import discovery
+from homeassistant.helpers.entity import Entity
+from requests.exceptions import HTTPError, ConnectTimeout
+
+REQUIREMENTS = ['abodepy==0.12.2']
 
 _LOGGER = logging.getLogger(__name__)
 
 CONF_ATTRIBUTION = "Data provided by goabode.com"
+CONF_POLLING = 'polling'
 
 DOMAIN = 'abode'
-DEFAULT_NAME = 'Abode'
-DATA_ABODE = 'abode'
 
 NOTIFICATION_ID = 'abode_notification'
 NOTIFICATION_TITLE = 'Abode Security Setup'
 
+EVENT_ABODE_ALARM = 'abode_alarm'
+EVENT_ABODE_ALARM_END = 'abode_alarm_end'
+EVENT_ABODE_AUTOMATION = 'abode_automation'
+EVENT_ABODE_FAULT = 'abode_panel_fault'
+EVENT_ABODE_RESTORE = 'abode_panel_restore'
+
+SERVICE_SETTINGS = 'change_setting'
+SERVICE_CAPTURE_IMAGE = 'capture_image'
+SERVICE_TRIGGER = 'trigger_quick_action'
+
+ATTR_DEVICE_ID = 'device_id'
+ATTR_DEVICE_NAME = 'device_name'
+ATTR_DEVICE_TYPE = 'device_type'
+ATTR_EVENT_CODE = 'event_code'
+ATTR_EVENT_NAME = 'event_name'
+ATTR_EVENT_TYPE = 'event_type'
+ATTR_EVENT_UTC = 'event_utc'
+ATTR_SETTING = 'setting'
+ATTR_USER_NAME = 'user_name'
+ATTR_VALUE = 'value'
+
+ABODE_DEVICE_ID_LIST_SCHEMA = vol.Schema([str])
+
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: vol.Schema({
         vol.Required(CONF_USERNAME): cv.string,
         vol.Required(CONF_PASSWORD): cv.string,
-        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+        vol.Optional(CONF_NAME): cv.string,
+        vol.Optional(CONF_POLLING, default=False): cv.boolean,
+        vol.Optional(CONF_EXCLUDE, default=[]): ABODE_DEVICE_ID_LIST_SCHEMA,
+        vol.Optional(CONF_LIGHTS, default=[]): ABODE_DEVICE_ID_LIST_SCHEMA
     }),
 }, extra=vol.ALLOW_EXTRA)
 
+CHANGE_SETTING_SCHEMA = vol.Schema({
+    vol.Required(ATTR_SETTING): cv.string,
+    vol.Required(ATTR_VALUE): cv.string
+})
+
+CAPTURE_IMAGE_SCHEMA = vol.Schema({
+    ATTR_ENTITY_ID: cv.entity_ids,
+})
+
+TRIGGER_SCHEMA = vol.Schema({
+    ATTR_ENTITY_ID: cv.entity_ids,
+})
+
 ABODE_PLATFORMS = [
-    'alarm_control_panel', 'binary_sensor', 'lock', 'switch', 'cover'
+    'alarm_control_panel', 'binary_sensor', 'lock', 'switch', 'cover',
+    'camera', 'light'
 ]
 
 
+class AbodeSystem(object):
+    """Abode System class."""
+
+    def __init__(self, username, password, name, polling, exclude, lights):
+        """Initialize the system."""
+        import abodepy
+        self.abode = abodepy.Abode(
+            username, password, auto_login=True, get_devices=True,
+            get_automations=True)
+        self.name = name
+        self.polling = polling
+        self.exclude = exclude
+        self.lights = lights
+        self.devices = []
+
+    def is_excluded(self, device):
+        """Check if a device is configured to be excluded."""
+        return device.device_id in self.exclude
+
+    def is_automation_excluded(self, automation):
+        """Check if an automation is configured to be excluded."""
+        return automation.automation_id in self.exclude
+
+    def is_light(self, device):
+        """Check if a switch device is configured as a light."""
+        import abodepy.helpers.constants as CONST
+
+        return (device.generic_type == CONST.TYPE_LIGHT or
+                (device.generic_type == CONST.TYPE_SWITCH and
+                 device.device_id in self.lights))
+
+
 def setup(hass, config):
     """Set up Abode component."""
-    import abodepy
+    from abodepy.exceptions import AbodeException
 
     conf = config[DOMAIN]
     username = conf.get(CONF_USERNAME)
     password = conf.get(CONF_PASSWORD)
+    name = conf.get(CONF_NAME)
+    polling = conf.get(CONF_POLLING)
+    exclude = conf.get(CONF_EXCLUDE)
+    lights = conf.get(CONF_LIGHTS)
 
     try:
-        hass.data[DATA_ABODE] = abode = abodepy.Abode(
-            username, password, auto_login=True, get_devices=True)
-
-    except (ConnectTimeout, HTTPError) as ex:
+        hass.data[DOMAIN] = AbodeSystem(
+            username, password, name, polling, exclude, lights)
+    except (AbodeException, ConnectTimeout, HTTPError) as ex:
         _LOGGER.error("Unable to connect to Abode: %s", str(ex))
+
         hass.components.persistent_notification.create(
             'Error: {}<br />'
             'You will need to restart hass after fixing.'
@@ -65,46 +144,144 @@ def setup(hass, config):
             notification_id=NOTIFICATION_ID)
         return False
 
+    setup_hass_services(hass)
+    setup_hass_events(hass)
+    setup_abode_events(hass)
+
     for platform in ABODE_PLATFORMS:
         discovery.load_platform(hass, platform, DOMAIN, {}, config)
 
+    return True
+
+
+def setup_hass_services(hass):
+    """Home assistant services."""
+    from abodepy.exceptions import AbodeException
+
+    def change_setting(call):
+        """Change an Abode system setting."""
+        setting = call.data.get(ATTR_SETTING)
+        value = call.data.get(ATTR_VALUE)
+
+        try:
+            hass.data[DOMAIN].abode.set_setting(setting, value)
+        except AbodeException as ex:
+            _LOGGER.warning(ex)
+
+    def capture_image(call):
+        """Capture a new image."""
+        entity_ids = call.data.get(ATTR_ENTITY_ID)
+
+        target_devices = [device for device in hass.data[DOMAIN].devices
+                          if device.entity_id in entity_ids]
+
+        for device in target_devices:
+            device.capture()
+
+    def trigger_quick_action(call):
+        """Trigger a quick action."""
+        entity_ids = call.data.get(ATTR_ENTITY_ID, None)
+
+        target_devices = [device for device in hass.data[DOMAIN].devices
+                          if device.entity_id in entity_ids]
+
+        for device in target_devices:
+            device.trigger()
+
+    descriptions = load_yaml_config_file(
+        path.join(path.dirname(__file__), 'services.yaml'))[DOMAIN]
+
+    hass.services.register(
+        DOMAIN, SERVICE_SETTINGS, change_setting,
+        descriptions.get(SERVICE_SETTINGS),
+        schema=CHANGE_SETTING_SCHEMA)
+
+    hass.services.register(
+        DOMAIN, SERVICE_CAPTURE_IMAGE, capture_image,
+        descriptions.get(SERVICE_CAPTURE_IMAGE),
+        schema=CAPTURE_IMAGE_SCHEMA)
+
+    hass.services.register(
+        DOMAIN, SERVICE_TRIGGER, trigger_quick_action,
+        descriptions.get(SERVICE_TRIGGER),
+        schema=TRIGGER_SCHEMA)
+
+
+def setup_hass_events(hass):
+    """Home Assistant start and stop callbacks."""
+    def startup(event):
+        """Listen for push events."""
+        hass.data[DOMAIN].abode.events.start()
+
     def logout(event):
         """Logout of Abode."""
-        abode.stop_listener()
-        abode.logout()
+        if not hass.data[DOMAIN].polling:
+            hass.data[DOMAIN].abode.events.stop()
+
+        hass.data[DOMAIN].abode.logout()
         _LOGGER.info("Logged out of Abode")
 
+    if not hass.data[DOMAIN].polling:
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_START, startup)
+
     hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, logout)
 
-    def startup(event):
-        """Listen for push events."""
-        abode.start_listener()
 
-    hass.bus.listen_once(EVENT_HOMEASSISTANT_START, startup)
+def setup_abode_events(hass):
+    """Event callbacks."""
+    import abodepy.helpers.timeline as TIMELINE
 
-    return True
+    def event_callback(event, event_json):
+        """Handle an event callback from Abode."""
+        data = {
+            ATTR_DEVICE_ID: event_json.get(ATTR_DEVICE_ID, ''),
+            ATTR_DEVICE_NAME: event_json.get(ATTR_DEVICE_NAME, ''),
+            ATTR_DEVICE_TYPE: event_json.get(ATTR_DEVICE_TYPE, ''),
+            ATTR_EVENT_CODE: event_json.get(ATTR_EVENT_CODE, ''),
+            ATTR_EVENT_NAME: event_json.get(ATTR_EVENT_NAME, ''),
+            ATTR_EVENT_TYPE: event_json.get(ATTR_EVENT_TYPE, ''),
+            ATTR_EVENT_UTC: event_json.get(ATTR_EVENT_UTC, ''),
+            ATTR_USER_NAME: event_json.get(ATTR_USER_NAME, ''),
+            ATTR_DATE: event_json.get(ATTR_DATE, ''),
+            ATTR_TIME: event_json.get(ATTR_TIME, ''),
+        }
+
+        hass.bus.fire(event, data)
+
+    events = [TIMELINE.ALARM_GROUP, TIMELINE.ALARM_END_GROUP,
+              TIMELINE.PANEL_FAULT_GROUP, TIMELINE.PANEL_RESTORE_GROUP,
+              TIMELINE.AUTOMATION_GROUP]
+
+    for event in events:
+        hass.data[DOMAIN].abode.events.add_event_callback(
+            event,
+            partial(event_callback, event))
 
 
 class AbodeDevice(Entity):
     """Representation of an Abode device."""
 
-    def __init__(self, controller, device):
+    def __init__(self, data, device):
         """Initialize a sensor for Abode device."""
-        self._controller = controller
+        self._data = data
         self._device = device
 
     @asyncio.coroutine
     def async_added_to_hass(self):
         """Subscribe Abode events."""
         self.hass.async_add_job(
-            self._controller.register, self._device,
-            self._update_callback
+            self._data.abode.events.add_device_callback,
+            self._device.device_id, self._update_callback
         )
 
     @property
     def should_poll(self):
         """Return the polling state."""
-        return False
+        return self._data.polling
+
+    def update(self):
+        """Update automation state."""
+        self._device.refresh()
 
     @property
     def name(self):
@@ -118,9 +295,58 @@ class AbodeDevice(Entity):
             ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
             'device_id': self._device.device_id,
             'battery_low': self._device.battery_low,
-            'no_response': self._device.no_response
+            'no_response': self._device.no_response,
+            'device_type': self._device.type
         }
 
     def _update_callback(self, device):
         """Update the device state."""
         self.schedule_update_ha_state()
+
+
+class AbodeAutomation(Entity):
+    """Representation of an Abode automation."""
+
+    def __init__(self, data, automation, event=None):
+        """Initialize for Abode automation."""
+        self._data = data
+        self._automation = automation
+        self._event = event
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Subscribe Abode events."""
+        if self._event:
+            self.hass.async_add_job(
+                self._data.abode.events.add_event_callback,
+                self._event, self._update_callback
+            )
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return self._data.polling
+
+    def update(self):
+        """Update automation state."""
+        self._automation.refresh()
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._automation.name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'automation_id': self._automation.automation_id,
+            'type': self._automation.type,
+            'sub_type': self._automation.sub_type
+        }
+
+    def _update_callback(self, device):
+        """Update the device state."""
+        self._automation.refresh()
+        self.schedule_update_ha_state()

homeassistant/components/alarm_control_panel/__init__.py

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

homeassistant/components/alarm_control_panel/abode.py

@@ -7,7 +7,7 @@ https://home-assistant.io/components/alarm_control_panel.abode/
 import logging
 
 from homeassistant.components.abode import (
-    AbodeDevice, DATA_ABODE, DEFAULT_NAME, CONF_ATTRIBUTION)
+    AbodeDevice, DOMAIN as ABODE_DOMAIN, CONF_ATTRIBUTION)
 from homeassistant.components.alarm_control_panel import (AlarmControlPanel)
 from homeassistant.const import (ATTR_ATTRIBUTION, STATE_ALARM_ARMED_AWAY,
                                  STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED)
@@ -22,18 +22,22 @@ ICON = 'mdi:security'
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up a sensor for an Abode device."""
-    abode = hass.data[DATA_ABODE]
+    data = hass.data[ABODE_DOMAIN]
 
-    add_devices([AbodeAlarm(abode, abode.get_alarm())])
+    alarm_devices = [AbodeAlarm(data, data.abode.get_alarm(), data.name)]
+
+    data.devices.extend(alarm_devices)
+
+    add_devices(alarm_devices)
 
 
 class AbodeAlarm(AbodeDevice, AlarmControlPanel):
     """An alarm_control_panel implementation for Abode."""
 
-    def __init__(self, controller, device):
+    def __init__(self, data, device, name):
         """Initialize the alarm control panel."""
-        AbodeDevice.__init__(self, controller, device)
-        self._name = "{0}".format(DEFAULT_NAME)
+        super().__init__(data, device)
+        self._name = name
 
     @property
     def icon(self):
@@ -65,6 +69,11 @@ class AbodeAlarm(AbodeDevice, AlarmControlPanel):
         """Send arm away command."""
         self._device.set_away()
 
+    @property
+    def name(self):
+        """Return the name of the alarm."""
+        return self._name or super().name
+
     @property
     def device_state_attributes(self):
         """Return the state attributes."""

homeassistant/components/alarm_control_panel/alarmdecoder.py

@@ -57,19 +57,19 @@ class AlarmDecoderAlarmPanel(alarm.AlarmControlPanel):
         if message.alarm_sounding or message.fire_alarm:
             if self._state != STATE_ALARM_TRIGGERED:
                 self._state = STATE_ALARM_TRIGGERED
-                self.hass.async_add_job(self.async_update_ha_state())
+                self.async_schedule_update_ha_state()
         elif message.armed_away:
             if self._state != STATE_ALARM_ARMED_AWAY:
                 self._state = STATE_ALARM_ARMED_AWAY
-                self.hass.async_add_job(self.async_update_ha_state())
+                self.async_schedule_update_ha_state()
         elif message.armed_home:
             if self._state != STATE_ALARM_ARMED_HOME:
                 self._state = STATE_ALARM_ARMED_HOME
-                self.hass.async_add_job(self.async_update_ha_state())
+                self.async_schedule_update_ha_state()
         else:
             if self._state != STATE_ALARM_DISARMED:
                 self._state = STATE_ALARM_DISARMED
-                self.hass.async_add_job(self.async_update_ha_state())
+                self.async_schedule_update_ha_state()
 
     @property
     def name(self):

homeassistant/components/alarm_control_panel/arlo.py

@@ -0,0 +1,128 @@
+"""
+Support for Arlo Alarm Control Panels.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.arlo/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.alarm_control_panel import (
+    AlarmControlPanel, PLATFORM_SCHEMA)
+from homeassistant.components.arlo import (DATA_ARLO, CONF_ATTRIBUTION)
+from homeassistant.const import (
+    ATTR_ATTRIBUTION, STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
+    STATE_ALARM_DISARMED)
+
+_LOGGER = logging.getLogger(__name__)
+
+ARMED = 'armed'
+
+CONF_HOME_MODE_NAME = 'home_mode_name'
+CONF_AWAY_MODE_NAME = 'away_mode_name'
+
+DEPENDENCIES = ['arlo']
+
+DISARMED = 'disarmed'
+
+ICON = 'mdi:security'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_HOME_MODE_NAME, default=ARMED): cv.string,
+    vol.Optional(CONF_AWAY_MODE_NAME, default=ARMED): cv.string,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Arlo Alarm Control Panels."""
+    data = hass.data[DATA_ARLO]
+
+    if not data.base_stations:
+        return
+
+    home_mode_name = config.get(CONF_HOME_MODE_NAME)
+    away_mode_name = config.get(CONF_AWAY_MODE_NAME)
+    base_stations = []
+    for base_station in data.base_stations:
+        base_stations.append(ArloBaseStation(base_station, home_mode_name,
+                                             away_mode_name))
+    async_add_devices(base_stations, True)
+
+
+class ArloBaseStation(AlarmControlPanel):
+    """Representation of an Arlo Alarm Control Panel."""
+
+    def __init__(self, data, home_mode_name, away_mode_name):
+        """Initialize the alarm control panel."""
+        self._base_station = data
+        self._home_mode_name = home_mode_name
+        self._away_mode_name = away_mode_name
+        self._state = None
+
+    @property
+    def icon(self):
+        """Return icon."""
+        return ICON
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._state
+
+    def update(self):
+        """Update the state of the device."""
+        # PyArlo sometimes returns None for mode. So retry 3 times before
+        # returning None.
+        num_retries = 3
+        i = 0
+        while i < num_retries:
+            mode = self._base_station.mode
+            if mode:
+                self._state = self._get_state_from_mode(mode)
+                return
+            i += 1
+        self._state = None
+
+    @asyncio.coroutine
+    def async_alarm_disarm(self, code=None):
+        """Send disarm command."""
+        self._base_station.mode = DISARMED
+
+    @asyncio.coroutine
+    def async_alarm_arm_away(self, code=None):
+        """Send arm away command. Uses custom mode."""
+        self._base_station.mode = self._away_mode_name
+
+    @asyncio.coroutine
+    def async_alarm_arm_home(self, code=None):
+        """Send arm home command. Uses custom mode."""
+        self._base_station.mode = self._home_mode_name
+
+    @property
+    def name(self):
+        """Return the name of the base station."""
+        return self._base_station.name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._base_station.device_id
+        }
+
+    def _get_state_from_mode(self, mode):
+        """Convert Arlo mode to Home Assistant state."""
+        if mode == ARMED:
+            return STATE_ALARM_ARMED_AWAY
+        elif mode == DISARMED:
+            return STATE_ALARM_DISARMED
+        elif mode == self._home_mode_name:
+            return STATE_ALARM_ARMED_HOME
+        elif mode == self._away_mode_name:
+            return STATE_ALARM_ARMED_AWAY
+        return None

homeassistant/components/alarm_control_panel/concord232.py

@@ -107,7 +107,7 @@ class Concord232Alarm(alarm.AlarmControlPanel):
             newstate = STATE_ALARM_ARMED_AWAY
 
         if not newstate == self._state:
-            _LOGGER.info("State Chnage from %s to %s", self._state, newstate)
+            _LOGGER.info("State Change from %s to %s", self._state, newstate)
             self._state = newstate
         return self._state
 

homeassistant/components/alarm_control_panel/demo.py

@@ -5,10 +5,29 @@ For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/demo/
 """
 import homeassistant.components.alarm_control_panel.manual as manual
+from homeassistant.const import (
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
+    STATE_ALARM_ARMED_CUSTOM_BYPASS, STATE_ALARM_TRIGGERED, CONF_PENDING_TIME)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Demo alarm control panel platform."""
     add_devices([
-        manual.ManualAlarm(hass, 'Alarm', '1234', 5, 10, False),
+        manual.ManualAlarm(hass, 'Alarm', '1234', 5, 10, False, {
+            STATE_ALARM_ARMED_AWAY: {
+                CONF_PENDING_TIME: 5
+            },
+            STATE_ALARM_ARMED_HOME: {
+                CONF_PENDING_TIME: 5
+            },
+            STATE_ALARM_ARMED_NIGHT: {
+                CONF_PENDING_TIME: 5
+            },
+            STATE_ALARM_ARMED_CUSTOM_BYPASS: {
+                CONF_PENDING_TIME: 5
+            },
+            STATE_ALARM_TRIGGERED: {
+                CONF_PENDING_TIME: 5
+            },
+        }),
     ])

homeassistant/components/alarm_control_panel/egardia.py

@@ -18,13 +18,14 @@ from homeassistant.const import (
     CONF_NAME, STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME,
     STATE_ALARM_ARMED_AWAY, STATE_ALARM_TRIGGERED)
 
-REQUIREMENTS = ['pythonegardia==1.0.20']
+REQUIREMENTS = ['pythonegardia==1.0.22']
 
 _LOGGER = logging.getLogger(__name__)
 
 CONF_REPORT_SERVER_CODES = 'report_server_codes'
 CONF_REPORT_SERVER_ENABLED = 'report_server_enabled'
 CONF_REPORT_SERVER_PORT = 'report_server_port'
+CONF_REPORT_SERVER_CODES_IGNORE = 'ignore'
 
 DEFAULT_NAME = 'Egardia'
 DEFAULT_PORT = 80
@@ -148,9 +149,15 @@ class EgardiaAlarm(alarm.AlarmControlPanel):
 
     def parsestatus(self, status):
         """Parse the status."""
-        newstatus = ([v for k, v in STATES.items()
-                      if status.upper() == k][0])
-        self._status = newstatus
+        _LOGGER.debug("Parsing status %s", status)
+        # Ignore the statuscode if it is IGNORE
+        if status.lower().strip() != CONF_REPORT_SERVER_CODES_IGNORE:
+            _LOGGER.debug("Not ignoring status")
+            newstatus = ([v for k, v in STATES.items()
+                          if status.upper() == k][0])
+            self._status = newstatus
+        else:
+            _LOGGER.error("Ignoring status")
 
     def update(self):
         """Update the alarm status."""

homeassistant/components/alarm_control_panel/envisalink.py

@@ -106,7 +106,7 @@ class EnvisalinkAlarm(EnvisalinkDevice, alarm.AlarmControlPanel):
     def _update_callback(self, partition):
         """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())
+            self.async_schedule_update_ha_state()
 
     @property
     def code_format(self):

homeassistant/components/alarm_control_panel/manual.py

@@ -4,6 +4,7 @@ Support for manual alarms.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel.manual/
 """
+import copy
 import datetime
 import logging
 
@@ -13,9 +14,9 @@ import homeassistant.components.alarm_control_panel as alarm
 import homeassistant.util.dt as dt_util
 from homeassistant.const import (
     STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
-    STATE_ALARM_DISARMED, STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED,
-    CONF_PLATFORM, CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
-    CONF_DISARM_AFTER_TRIGGER)
+    STATE_ALARM_ARMED_CUSTOM_BYPASS, STATE_ALARM_DISARMED, STATE_ALARM_PENDING,
+    STATE_ALARM_TRIGGERED, CONF_PLATFORM, CONF_NAME, CONF_CODE,
+    CONF_PENDING_TIME, CONF_TRIGGER_TIME, CONF_DISARM_AFTER_TRIGGER)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import track_point_in_time
 
@@ -24,9 +25,29 @@ DEFAULT_PENDING_TIME = 60
 DEFAULT_TRIGGER_TIME = 120
 DEFAULT_DISARM_AFTER_TRIGGER = False
 
+SUPPORTED_PENDING_STATES = [STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
+                            STATE_ALARM_ARMED_NIGHT, STATE_ALARM_TRIGGERED,
+                            STATE_ALARM_ARMED_CUSTOM_BYPASS]
+
 ATTR_POST_PENDING_STATE = 'post_pending_state'
 
-PLATFORM_SCHEMA = vol.Schema({
+
+def _state_validator(config):
+    config = copy.deepcopy(config)
+    for state in SUPPORTED_PENDING_STATES:
+        if CONF_PENDING_TIME not in config[state]:
+            config[state][CONF_PENDING_TIME] = config[CONF_PENDING_TIME]
+
+    return config
+
+
+STATE_SETTING_SCHEMA = vol.Schema({
+    vol.Optional(CONF_PENDING_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=0))
+})
+
+
+PLATFORM_SCHEMA = vol.Schema(vol.All({
     vol.Required(CONF_PLATFORM): 'manual',
     vol.Optional(CONF_NAME, default=DEFAULT_ALARM_NAME): cv.string,
     vol.Optional(CONF_CODE): cv.string,
@@ -36,7 +57,13 @@ PLATFORM_SCHEMA = vol.Schema({
         vol.All(vol.Coerce(int), vol.Range(min=1)),
     vol.Optional(CONF_DISARM_AFTER_TRIGGER,
                  default=DEFAULT_DISARM_AFTER_TRIGGER): cv.boolean,
-})
+    vol.Optional(STATE_ALARM_ARMED_AWAY, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_HOME, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_NIGHT, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_CUSTOM_BYPASS,
+                 default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_TRIGGERED, default={}): STATE_SETTING_SCHEMA,
+}, _state_validator))
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -49,7 +76,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         config.get(CONF_CODE),
         config.get(CONF_PENDING_TIME, DEFAULT_PENDING_TIME),
         config.get(CONF_TRIGGER_TIME, DEFAULT_TRIGGER_TIME),
-        config.get(CONF_DISARM_AFTER_TRIGGER, DEFAULT_DISARM_AFTER_TRIGGER)
+        config.get(CONF_DISARM_AFTER_TRIGGER, DEFAULT_DISARM_AFTER_TRIGGER),
+        config
         )])
 
 
@@ -63,19 +91,23 @@ class ManualAlarm(alarm.AlarmControlPanel):
     or disarm if `disarm_after_trigger` is true.
     """
 
-    def __init__(self, hass, name, code, pending_time,
-                 trigger_time, disarm_after_trigger):
+    def __init__(self, hass, name, code, pending_time, trigger_time,
+                 disarm_after_trigger, config):
         """Init the manual alarm panel."""
         self._state = STATE_ALARM_DISARMED
         self._hass = hass
         self._name = name
         self._code = str(code) if code else None
-        self._pending_time = datetime.timedelta(seconds=pending_time)
         self._trigger_time = datetime.timedelta(seconds=trigger_time)
         self._disarm_after_trigger = disarm_after_trigger
         self._pre_trigger_state = self._state
         self._state_ts = None
 
+        self._pending_time_by_state = {}
+        for state in SUPPORTED_PENDING_STATES:
+            self._pending_time_by_state[state] = datetime.timedelta(
+                seconds=config[state][CONF_PENDING_TIME])
+
     @property
     def should_poll(self):
         """Return the plling state."""
@@ -89,17 +121,10 @@ class ManualAlarm(alarm.AlarmControlPanel):
     @property
     def state(self):
         """Return the state of the device."""
-        if self._state in (STATE_ALARM_ARMED_HOME,
-                           STATE_ALARM_ARMED_AWAY,
-                           STATE_ALARM_ARMED_NIGHT) and \
-           self._pending_time and self._state_ts + self._pending_time > \
-           dt_util.utcnow():
-            return STATE_ALARM_PENDING
-
         if self._state == STATE_ALARM_TRIGGERED and self._trigger_time:
-            if self._state_ts + self._pending_time > dt_util.utcnow():
+            if self._within_pending_time(self._state):
                 return STATE_ALARM_PENDING
-            elif (self._state_ts + self._pending_time +
+            elif (self._state_ts + self._pending_time_by_state[self._state] +
                   self._trigger_time) < dt_util.utcnow():
                 if self._disarm_after_trigger:
                     return STATE_ALARM_DISARMED
@@ -107,8 +132,16 @@ class ManualAlarm(alarm.AlarmControlPanel):
                     self._state = self._pre_trigger_state
                     return self._state
 
+        if self._state in SUPPORTED_PENDING_STATES and \
+                self._within_pending_time(self._state):
+            return STATE_ALARM_PENDING
+
         return self._state
 
+    def _within_pending_time(self, state):
+        pending_time = self._pending_time_by_state[state]
+        return self._state_ts + pending_time > dt_util.utcnow()
+
     @property
     def code_format(self):
         """One or more characters."""
@@ -128,58 +161,54 @@ class ManualAlarm(alarm.AlarmControlPanel):
         if not self._validate_code(code, STATE_ALARM_ARMED_HOME):
             return
 
-        self._state = STATE_ALARM_ARMED_HOME
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
-
-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+        self._update_state(STATE_ALARM_ARMED_HOME)
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         if not self._validate_code(code, STATE_ALARM_ARMED_AWAY):
             return
 
-        self._state = STATE_ALARM_ARMED_AWAY
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
-
-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+        self._update_state(STATE_ALARM_ARMED_AWAY)
 
     def alarm_arm_night(self, code=None):
         """Send arm night command."""
         if not self._validate_code(code, STATE_ALARM_ARMED_NIGHT):
             return
 
-        self._state = STATE_ALARM_ARMED_NIGHT
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
+        self._update_state(STATE_ALARM_ARMED_NIGHT)
 
-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+    def alarm_arm_custom_bypass(self, code=None):
+        """Send arm custom bypass command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_CUSTOM_BYPASS):
+            return
+
+        self._update_state(STATE_ALARM_ARMED_CUSTOM_BYPASS)
 
     def alarm_trigger(self, code=None):
         """Send alarm trigger command. No code needed."""
         self._pre_trigger_state = self._state
-        self._state = STATE_ALARM_TRIGGERED
+
+        self._update_state(STATE_ALARM_TRIGGERED)
+
+    def _update_state(self, state):
+        self._state = state
         self._state_ts = dt_util.utcnow()
         self.schedule_update_ha_state()
 
-        if self._trigger_time:
+        pending_time = self._pending_time_by_state[state]
+
+        if state == STATE_ALARM_TRIGGERED and self._trigger_time:
             track_point_in_time(
                 self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+                self._state_ts + pending_time)
 
             track_point_in_time(
                 self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time + self._trigger_time)
+                self._state_ts + self._trigger_time + pending_time)
+        elif state in SUPPORTED_PENDING_STATES and pending_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + pending_time)
 
     def _validate_code(self, code, state):
         """Validate given code."""

homeassistant/components/alarm_control_panel/manual_mqtt.py

@@ -5,6 +5,7 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel.manual_mqtt/
 """
 import asyncio
+import copy
 import datetime
 import logging
 
@@ -13,9 +14,9 @@ import voluptuous as vol
 import homeassistant.components.alarm_control_panel as alarm
 import homeassistant.util.dt as dt_util
 from homeassistant.const import (
-    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED,
-    STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED, CONF_PLATFORM,
-    CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
+    STATE_ALARM_DISARMED, STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED,
+    CONF_PLATFORM, CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
     CONF_DISARM_AFTER_TRIGGER)
 import homeassistant.components.mqtt as mqtt
 
@@ -28,6 +29,7 @@ from homeassistant.helpers.event import track_point_in_time
 CONF_PAYLOAD_DISARM = 'payload_disarm'
 CONF_PAYLOAD_ARM_HOME = 'payload_arm_home'
 CONF_PAYLOAD_ARM_AWAY = 'payload_arm_away'
+CONF_PAYLOAD_ARM_NIGHT = 'payload_arm_night'
 
 DEFAULT_ALARM_NAME = 'HA Alarm'
 DEFAULT_PENDING_TIME = 60
@@ -35,11 +37,32 @@ DEFAULT_TRIGGER_TIME = 120
 DEFAULT_DISARM_AFTER_TRIGGER = False
 DEFAULT_ARM_AWAY = 'ARM_AWAY'
 DEFAULT_ARM_HOME = 'ARM_HOME'
+DEFAULT_ARM_NIGHT = 'ARM_NIGHT'
 DEFAULT_DISARM = 'DISARM'
 
+SUPPORTED_PENDING_STATES = [STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
+                            STATE_ALARM_ARMED_NIGHT, STATE_ALARM_TRIGGERED]
+
+ATTR_POST_PENDING_STATE = 'post_pending_state'
+
+
+def _state_validator(config):
+    config = copy.deepcopy(config)
+    for state in SUPPORTED_PENDING_STATES:
+        if CONF_PENDING_TIME not in config[state]:
+            config[state][CONF_PENDING_TIME] = config[CONF_PENDING_TIME]
+
+    return config
+
+
+STATE_SETTING_SCHEMA = vol.Schema({
+    vol.Optional(CONF_PENDING_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=0))
+})
+
 DEPENDENCIES = ['mqtt']
 
-PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
+PLATFORM_SCHEMA = vol.Schema(vol.All(mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
     vol.Required(CONF_PLATFORM): 'manual_mqtt',
     vol.Optional(CONF_NAME, default=DEFAULT_ALARM_NAME): cv.string,
     vol.Optional(CONF_CODE): cv.string,
@@ -49,12 +72,17 @@ PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
         vol.All(vol.Coerce(int), vol.Range(min=1)),
     vol.Optional(CONF_DISARM_AFTER_TRIGGER,
                  default=DEFAULT_DISARM_AFTER_TRIGGER): cv.boolean,
+    vol.Optional(STATE_ALARM_ARMED_AWAY, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_HOME, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_NIGHT, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_TRIGGERED, default={}): STATE_SETTING_SCHEMA,
     vol.Required(mqtt.CONF_COMMAND_TOPIC): mqtt.valid_publish_topic,
     vol.Required(mqtt.CONF_STATE_TOPIC): mqtt.valid_subscribe_topic,
     vol.Optional(CONF_PAYLOAD_ARM_AWAY, default=DEFAULT_ARM_AWAY): cv.string,
     vol.Optional(CONF_PAYLOAD_ARM_HOME, default=DEFAULT_ARM_HOME): cv.string,
+    vol.Optional(CONF_PAYLOAD_ARM_NIGHT, default=DEFAULT_ARM_NIGHT): cv.string,
     vol.Optional(CONF_PAYLOAD_DISARM, default=DEFAULT_DISARM): cv.string,
-})
+}), _state_validator))
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -73,7 +101,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         config.get(mqtt.CONF_QOS),
         config.get(CONF_PAYLOAD_DISARM),
         config.get(CONF_PAYLOAD_ARM_HOME),
-        config.get(CONF_PAYLOAD_ARM_AWAY))])
+        config.get(CONF_PAYLOAD_ARM_AWAY),
+        config.get(CONF_PAYLOAD_ARM_NIGHT),
+        config)])
 
 
 class ManualMQTTAlarm(alarm.AlarmControlPanel):
@@ -89,7 +119,8 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
     def __init__(self, hass, name, code, pending_time,
                  trigger_time, disarm_after_trigger,
                  state_topic, command_topic, qos,
-                 payload_disarm, payload_arm_home, payload_arm_away):
+                 payload_disarm, payload_arm_home, payload_arm_away,
+                 payload_arm_night, config):
         """Init the manual MQTT alarm panel."""
         self._state = STATE_ALARM_DISARMED
         self._hass = hass
@@ -101,12 +132,18 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
         self._pre_trigger_state = self._state
         self._state_ts = None
 
+        self._pending_time_by_state = {}
+        for state in SUPPORTED_PENDING_STATES:
+            self._pending_time_by_state[state] = datetime.timedelta(
+                seconds=config[state][CONF_PENDING_TIME])
+
         self._state_topic = state_topic
         self._command_topic = command_topic
         self._qos = qos
         self._payload_disarm = payload_disarm
         self._payload_arm_home = payload_arm_home
         self._payload_arm_away = payload_arm_away
+        self._payload_arm_night = payload_arm_night
 
     @property
     def should_poll(self):
@@ -121,23 +158,27 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
     @property
     def state(self):
         """Return the state of the device."""
-        if self._state in (STATE_ALARM_ARMED_HOME,
-                           STATE_ALARM_ARMED_AWAY) and \
-           self._pending_time and self._state_ts + self._pending_time > \
-           dt_util.utcnow():
-            return STATE_ALARM_PENDING
-
         if self._state == STATE_ALARM_TRIGGERED and self._trigger_time:
-            if self._state_ts + self._pending_time > dt_util.utcnow():
+            if self._within_pending_time(self._state):
                 return STATE_ALARM_PENDING
-            elif (self._state_ts + self._pending_time +
+            elif (self._state_ts + self._pending_time_by_state[self._state] +
                   self._trigger_time) < dt_util.utcnow():
                 if self._disarm_after_trigger:
                     return STATE_ALARM_DISARMED
-                return self._pre_trigger_state
+                else:
+                    self._state = self._pre_trigger_state
+                    return self._state
+
+        if self._state in SUPPORTED_PENDING_STATES and \
+                self._within_pending_time(self._state):
+            return STATE_ALARM_PENDING
 
         return self._state
 
+    def _within_pending_time(self, state):
+        pending_time = self._pending_time_by_state[state]
+        return self._state_ts + pending_time > dt_util.utcnow()
+
     @property
     def code_format(self):
         """One or more characters."""
@@ -157,44 +198,47 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
         if not self._validate_code(code, STATE_ALARM_ARMED_HOME):
             return
 
-        self._state = STATE_ALARM_ARMED_HOME
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
-
-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+        self._update_state(STATE_ALARM_ARMED_HOME)
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         if not self._validate_code(code, STATE_ALARM_ARMED_AWAY):
             return
 
-        self._state = STATE_ALARM_ARMED_AWAY
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
+        self._update_state(STATE_ALARM_ARMED_AWAY)
 
-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_NIGHT):
+            return
+
+        self._update_state(STATE_ALARM_ARMED_NIGHT)
 
     def alarm_trigger(self, code=None):
         """Send alarm trigger command. No code needed."""
         self._pre_trigger_state = self._state
-        self._state = STATE_ALARM_TRIGGERED
+
+        self._update_state(STATE_ALARM_TRIGGERED)
+
+    def _update_state(self, state):
+        self._state = state
         self._state_ts = dt_util.utcnow()
         self.schedule_update_ha_state()
 
-        if self._trigger_time:
+        pending_time = self._pending_time_by_state[state]
+
+        if state == STATE_ALARM_TRIGGERED and self._trigger_time:
             track_point_in_time(
                 self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+                self._state_ts + pending_time)
 
             track_point_in_time(
                 self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time + self._trigger_time)
+                self._state_ts + self._trigger_time + pending_time)
+        elif state in SUPPORTED_PENDING_STATES and pending_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + pending_time)
 
     def _validate_code(self, code, state):
         """Validate given code."""
@@ -203,6 +247,16 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
             _LOGGER.warning("Invalid code given for %s", state)
         return check
 
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        state_attr = {}
+
+        if self.state == STATE_ALARM_PENDING:
+            state_attr[ATTR_POST_PENDING_STATE] = self._state
+
+        return state_attr
+
     def async_added_to_hass(self):
         """Subscribe mqtt events.
 
@@ -221,6 +275,8 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
                 self.async_alarm_arm_home(self._code)
             elif payload == self._payload_arm_away:
                 self.async_alarm_arm_away(self._code)
+            elif payload == self._payload_arm_night:
+                self.async_alarm_arm_night(self._code)
             else:
                 _LOGGER.warning("Received unexpected payload: %s", payload)
                 return

homeassistant/components/alarm_control_panel/mqtt.py

@@ -87,7 +87,7 @@ class MqttAlarm(alarm.AlarmControlPanel):
                 _LOGGER.warning("Received unexpected payload: %s", payload)
                 return
             self._state = payload
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()
 
         return mqtt.async_subscribe(
             self.hass, self._state_topic, message_received, self._qos)

homeassistant/components/alarm_control_panel/satel_integra.py

@@ -0,0 +1,94 @@
+"""
+Support for Satel Integra alarm, using ETHM module: https://www.satel.pl/en/ .
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.satel_integra/
+"""
+import asyncio
+import logging
+
+import homeassistant.components.alarm_control_panel as alarm
+from homeassistant.components.satel_integra import (CONF_ARM_HOME_MODE,
+                                                    DATA_SATEL,
+                                                    SIGNAL_PANEL_MESSAGE)
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['satel_integra']
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up for AlarmDecoder alarm panels."""
+    if not discovery_info:
+        return
+
+    device = SatelIntegraAlarmPanel("Alarm Panel",
+                                    discovery_info.get(CONF_ARM_HOME_MODE))
+    async_add_devices([device])
+
+
+class SatelIntegraAlarmPanel(alarm.AlarmControlPanel):
+    """Representation of an AlarmDecoder-based alarm panel."""
+
+    def __init__(self, name, arm_home_mode):
+        """Initialize the alarm panel."""
+        self._name = name
+        self._state = None
+        self._arm_home_mode = arm_home_mode
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Register callbacks."""
+        async_dispatcher_connect(
+            self.hass, SIGNAL_PANEL_MESSAGE, self._message_callback)
+
+    @callback
+    def _message_callback(self, message):
+
+        if message != self._state:
+            self._state = message
+            self.async_schedule_update_ha_state()
+        else:
+            _LOGGER.warning("Ignoring alarm status message, same state")
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return False
+
+    @property
+    def code_format(self):
+        """Return the regex for code format or None if no code is required."""
+        return '^\\d{4,6}$'
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._state
+
+    @asyncio.coroutine
+    def async_alarm_disarm(self, code=None):
+        """Send disarm command."""
+        if code:
+            yield from self.hass.data[DATA_SATEL].disarm(code)
+
+    @asyncio.coroutine
+    def async_alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        if code:
+            yield from self.hass.data[DATA_SATEL].arm(code)
+
+    @asyncio.coroutine
+    def async_alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        if code:
+            yield from self.hass.data[DATA_SATEL].arm(code,
+                                                      self._arm_home_mode)

homeassistant/components/alarm_control_panel/services.yaml

@@ -1,65 +1,61 @@
-alarm_disarm:
-  description: Send the alarm the command for disarm
+# Describes the format for available alarm control panel services
 
+alarm_disarm:
+  description: Send the alarm the command for disarm.
   fields:
     entity_id:
-      description: Name of alarm control panel to disarm
+      description: Name of alarm control panel to disarm.
       example: 'alarm_control_panel.downstairs'
     code:
-      description: An optional code to disarm the alarm control panel with
+      description: An optional code to disarm the alarm control panel with.
       example: 1234
 
 alarm_arm_home:
-  description: Send the alarm the command for arm home
-
+  description: Send the alarm the command for arm home.
   fields:
     entity_id:
-      description: Name of alarm control panel to arm home
+      description: Name of alarm control panel to arm home.
       example: 'alarm_control_panel.downstairs'
     code:
-      description: An optional code to arm home the alarm control panel with
+      description: An optional code to arm home the alarm control panel with.
       example: 1234
 
 alarm_arm_away:
-  description: Send the alarm the command for arm away
-
+  description: Send the alarm the command for arm away.
   fields:
     entity_id:
-      description: Name of alarm control panel to arm away
+      description: Name of alarm control panel to arm away.
       example: 'alarm_control_panel.downstairs'
     code:
-      description: An optional code to arm away the alarm control panel with
+      description: An optional code to arm away the alarm control panel with.
       example: 1234
 
 alarm_arm_night:
-  description: Send the alarm the command for arm night
-
+  description: Send the alarm the command for arm night.
   fields:
     entity_id:
-      description: Name of alarm control panel to arm night
+      description: Name of alarm control panel to arm night.
       example: 'alarm_control_panel.downstairs'
     code:
-      description: An optional code to arm night the alarm control panel with
+      description: An optional code to arm night the alarm control panel with.
       example: 1234
 
 alarm_trigger:
-  description: Send the alarm the command for trigger
-
+  description: Send the alarm the command for trigger.
   fields:
     entity_id:
-      description: Name of alarm control panel to trigger
+      description: Name of alarm control panel to trigger.
       example: 'alarm_control_panel.downstairs'
     code:
-      description: An optional code to trigger the alarm control panel with
+      description: An optional code to trigger the alarm control panel with.
       example: 1234
 
 envisalink_alarm_keypress:
-  description: Send custom keypresses to the alarm
-
+  description: Send custom keypresses to the alarm.
   fields:
     entity_id:
-      description: Name of the alarm control panel to trigger
+      description: Name of the alarm control panel to trigger.
       example: 'alarm_control_panel.downstairs'
     keypress:
-      description: 'String to send to the alarm panel (1-6 characters)'
+      description: 'String to send to the alarm panel (1-6 characters).'
       example: '*71'

homeassistant/components/alarm_control_panel/spc.py

@@ -27,40 +27,46 @@ def _get_alarm_state(spc_mode):
 
 
 @asyncio.coroutine
-def async_setup_platform(hass, config, async_add_entities,
+def async_setup_platform(hass, config, async_add_devices,
                          discovery_info=None):
     """Set up the SPC alarm control panel platform."""
     if (discovery_info is None or
             discovery_info[ATTR_DISCOVER_AREAS] is None):
         return
 
-    entities = [SpcAlarm(hass=hass,
-                         area_id=area['id'],
-                         name=area['name'],
-                         state=_get_alarm_state(area['mode']))
-                for area in discovery_info[ATTR_DISCOVER_AREAS]]
+    api = hass.data[DATA_API]
+    devices = [SpcAlarm(api, area)
+               for area in discovery_info[ATTR_DISCOVER_AREAS]]
 
-    async_add_entities(entities)
+    async_add_devices(devices)
 
 
 class SpcAlarm(alarm.AlarmControlPanel):
     """Represents the SPC alarm panel."""
 
-    def __init__(self, hass, area_id, name, state):
+    def __init__(self, api, area):
         """Initialize the SPC alarm panel."""
-        self._hass = hass
-        self._area_id = area_id
-        self._name = name
-        self._state = state
-        self._api = hass.data[DATA_API]
-
-        hass.data[DATA_REGISTRY].register_alarm_device(area_id, self)
+        self._area_id = area['id']
+        self._name = area['name']
+        self._state = _get_alarm_state(area['mode'])
+        if self._state == STATE_ALARM_DISARMED:
+            self._changed_by = area.get('last_unset_user_name', 'unknown')
+        else:
+            self._changed_by = area.get('last_set_user_name', 'unknown')
+        self._api = api
 
     @asyncio.coroutine
-    def async_update_from_spc(self, state):
+    def async_added_to_hass(self):
+        """Calbback for init handlers."""
+        self.hass.data[DATA_REGISTRY].register_alarm_device(
+            self._area_id, self)
+
+    @asyncio.coroutine
+    def async_update_from_spc(self, state, extra):
         """Update the alarm panel with a new state."""
         self._state = state
-        yield from self.async_update_ha_state()
+        self._changed_by = extra.get('changed_by', 'unknown')
+        self.async_schedule_update_ha_state()
 
     @property
     def should_poll(self):
@@ -72,6 +78,11 @@ class SpcAlarm(alarm.AlarmControlPanel):
         """Return the name of the device."""
         return self._name
 
+    @property
+    def changed_by(self):
+        """Return the user the last change was triggered by."""
+        return self._changed_by
+
     @property
     def state(self):
         """Return the state of the device."""

homeassistant/components/alarm_control_panel/totalconnect.py

@@ -16,7 +16,7 @@ from homeassistant.const import (
     STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT, STATE_ALARM_DISARMED,
     STATE_ALARM_ARMING, STATE_ALARM_DISARMING, STATE_UNKNOWN, CONF_NAME)
 
-REQUIREMENTS = ['total_connect_client==0.11']
+REQUIREMENTS = ['total_connect_client==0.16']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/alexa/__init__.py

@@ -0,0 +1,52 @@
+"""
+Support for Alexa skill service end point.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/alexa/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from homeassistant.helpers import config_validation as cv
+
+from .const import (
+    DOMAIN, CONF_UID, CONF_TITLE, CONF_AUDIO, CONF_TEXT, CONF_DISPLAY_URL)
+from . import flash_briefings, intent
+
+_LOGGER = logging.getLogger(__name__)
+
+
+DEPENDENCIES = ['http']
+
+CONF_FLASH_BRIEFINGS = 'flash_briefings'
+
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: {
+        CONF_FLASH_BRIEFINGS: {
+            cv.string: vol.All(cv.ensure_list, [{
+                vol.Optional(CONF_UID): cv.string,
+                vol.Required(CONF_TITLE): cv.template,
+                vol.Optional(CONF_AUDIO): cv.template,
+                vol.Required(CONF_TEXT, default=""): cv.template,
+                vol.Optional(CONF_DISPLAY_URL): cv.template,
+            }]),
+        }
+    }
+}, extra=vol.ALLOW_EXTRA)
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Activate Alexa component."""
+    config = config.get(DOMAIN, {})
+    flash_briefings_config = config.get(CONF_FLASH_BRIEFINGS)
+
+    intent.async_setup(hass)
+
+    if flash_briefings_config:
+        flash_briefings.async_setup(hass, flash_briefings_config)
+
+    return True

homeassistant/components/alexa/const.py

@@ -0,0 +1,20 @@
+"""Constants for the Alexa integration."""
+DOMAIN = 'alexa'
+
+# Flash briefing constants
+CONF_UID = 'uid'
+CONF_TITLE = 'title'
+CONF_AUDIO = 'audio'
+CONF_TEXT = 'text'
+CONF_DISPLAY_URL = 'display_url'
+
+ATTR_UID = 'uid'
+ATTR_UPDATE_DATE = 'updateDate'
+ATTR_TITLE_TEXT = 'titleText'
+ATTR_STREAM_URL = 'streamUrl'
+ATTR_MAIN_TEXT = 'mainText'
+ATTR_REDIRECTION_URL = 'redirectionURL'
+
+SYN_RESOLUTION_MATCH = 'ER_SUCCESS_MATCH'
+
+DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.0Z'

homeassistant/components/alexa/flash_briefings.py

@@ -0,0 +1,96 @@
+"""
+Support for Alexa skill service end point.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/alexa/
+"""
+import copy
+import logging
+from datetime import datetime
+import uuid
+
+from homeassistant.core import callback
+from homeassistant.helpers import template
+from homeassistant.components import http
+
+from .const import (
+    CONF_UID, CONF_TITLE, CONF_AUDIO, CONF_TEXT, CONF_DISPLAY_URL, ATTR_UID,
+    ATTR_UPDATE_DATE, ATTR_TITLE_TEXT, ATTR_STREAM_URL, ATTR_MAIN_TEXT,
+    ATTR_REDIRECTION_URL, DATE_FORMAT)
+
+
+_LOGGER = logging.getLogger(__name__)
+
+FLASH_BRIEFINGS_API_ENDPOINT = '/api/alexa/flash_briefings/{briefing_id}'
+
+
+@callback
+def async_setup(hass, flash_briefing_config):
+    """Activate Alexa component."""
+    hass.http.register_view(
+        AlexaFlashBriefingView(hass, flash_briefing_config))
+
+
+class AlexaFlashBriefingView(http.HomeAssistantView):
+    """Handle Alexa Flash Briefing skill requests."""
+
+    url = FLASH_BRIEFINGS_API_ENDPOINT
+    name = 'api:alexa:flash_briefings'
+
+    def __init__(self, hass, flash_briefings):
+        """Initialize Alexa view."""
+        super().__init__()
+        self.flash_briefings = copy.deepcopy(flash_briefings)
+        template.attach(hass, self.flash_briefings)
+
+    @callback
+    def get(self, request, briefing_id):
+        """Handle Alexa Flash Briefing request."""
+        _LOGGER.debug('Received Alexa flash briefing request for: %s',
+                      briefing_id)
+
+        if self.flash_briefings.get(briefing_id) is None:
+            err = 'No configured Alexa flash briefing was found for: %s'
+            _LOGGER.error(err, briefing_id)
+            return b'', 404
+
+        briefing = []
+
+        for item in self.flash_briefings.get(briefing_id, []):
+            output = {}
+            if item.get(CONF_TITLE) is not None:
+                if isinstance(item.get(CONF_TITLE), template.Template):
+                    output[ATTR_TITLE_TEXT] = item[CONF_TITLE].async_render()
+                else:
+                    output[ATTR_TITLE_TEXT] = item.get(CONF_TITLE)
+
+            if item.get(CONF_TEXT) is not None:
+                if isinstance(item.get(CONF_TEXT), template.Template):
+                    output[ATTR_MAIN_TEXT] = item[CONF_TEXT].async_render()
+                else:
+                    output[ATTR_MAIN_TEXT] = item.get(CONF_TEXT)
+
+            uid = item.get(CONF_UID)
+            if uid is None:
+                uid = str(uuid.uuid4())
+            output[ATTR_UID] = uid
+
+            if item.get(CONF_AUDIO) is not None:
+                if isinstance(item.get(CONF_AUDIO), template.Template):
+                    output[ATTR_STREAM_URL] = item[CONF_AUDIO].async_render()
+                else:
+                    output[ATTR_STREAM_URL] = item.get(CONF_AUDIO)
+
+            if item.get(CONF_DISPLAY_URL) is not None:
+                if isinstance(item.get(CONF_DISPLAY_URL),
+                              template.Template):
+                    output[ATTR_REDIRECTION_URL] = \
+                        item[CONF_DISPLAY_URL].async_render()
+                else:
+                    output[ATTR_REDIRECTION_URL] = item.get(CONF_DISPLAY_URL)
+
+            output[ATTR_UPDATE_DATE] = datetime.now().strftime(DATE_FORMAT)
+
+            briefing.append(output)
+
+        return self.json(briefing)

homeassistant/components/alexa/intent.py

@@ -3,54 +3,22 @@ Support for Alexa skill service end point.
 
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/alexa/
+
 """
 import asyncio
-import copy
 import enum
 import logging
-import uuid
-from datetime import datetime
-
-import voluptuous as vol
 
 from homeassistant.core import callback
 from homeassistant.const import HTTP_BAD_REQUEST
-from homeassistant.helpers import intent, template, config_validation as cv
+from homeassistant.helpers import intent
 from homeassistant.components import http
 
-_LOGGER = logging.getLogger(__name__)
+from .const import DOMAIN, SYN_RESOLUTION_MATCH
 
 INTENTS_API_ENDPOINT = '/api/alexa'
-FLASH_BRIEFINGS_API_ENDPOINT = '/api/alexa/flash_briefings/{briefing_id}'
 
-CONF_ACTION = 'action'
-CONF_CARD = 'card'
-CONF_INTENTS = 'intents'
-CONF_SPEECH = 'speech'
-
-CONF_TYPE = 'type'
-CONF_TITLE = 'title'
-CONF_CONTENT = 'content'
-CONF_TEXT = 'text'
-
-CONF_FLASH_BRIEFINGS = 'flash_briefings'
-CONF_UID = 'uid'
-CONF_TITLE = 'title'
-CONF_AUDIO = 'audio'
-CONF_TEXT = 'text'
-CONF_DISPLAY_URL = 'display_url'
-
-ATTR_UID = 'uid'
-ATTR_UPDATE_DATE = 'updateDate'
-ATTR_TITLE_TEXT = 'titleText'
-ATTR_STREAM_URL = 'streamUrl'
-ATTR_MAIN_TEXT = 'mainText'
-ATTR_REDIRECTION_URL = 'redirectionURL'
-
-DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.0Z'
-
-DOMAIN = 'alexa'
-DEPENDENCIES = ['http']
+_LOGGER = logging.getLogger(__name__)
 
 
 class SpeechType(enum.Enum):
@@ -73,30 +41,10 @@ class CardType(enum.Enum):
     link_account = "LinkAccount"
 
 
-CONFIG_SCHEMA = vol.Schema({
-    DOMAIN: {
-        CONF_FLASH_BRIEFINGS: {
-            cv.string: vol.All(cv.ensure_list, [{
-                vol.Required(CONF_UID, default=str(uuid.uuid4())): cv.string,
-                vol.Required(CONF_TITLE): cv.template,
-                vol.Optional(CONF_AUDIO): cv.template,
-                vol.Required(CONF_TEXT, default=""): cv.template,
-                vol.Optional(CONF_DISPLAY_URL): cv.template,
-            }]),
-        }
-    }
-}, extra=vol.ALLOW_EXTRA)
-
-
-@asyncio.coroutine
-def async_setup(hass, config):
+@callback
+def async_setup(hass):
     """Activate Alexa component."""
-    flash_briefings = config[DOMAIN].get(CONF_FLASH_BRIEFINGS, {})
-
     hass.http.register_view(AlexaIntentsView)
-    hass.http.register_view(AlexaFlashBriefingView(hass, flash_briefings))
-
-    return True
 
 
 class AlexaIntentsView(http.HomeAssistantView):
@@ -176,6 +124,43 @@ class AlexaIntentsView(http.HomeAssistantView):
         return self.json(alexa_response)
 
 
+def resolve_slot_synonyms(key, request):
+    """Check slot request for synonym resolutions."""
+    # Default to the spoken slot value if more than one or none are found. For
+    # reference to the request object structure, see the Alexa docs:
+    # https://tinyurl.com/ybvm7jhs
+    resolved_value = request['value']
+
+    if ('resolutions' in request and
+            'resolutionsPerAuthority' in request['resolutions'] and
+            len(request['resolutions']['resolutionsPerAuthority']) >= 1):
+
+        # Extract all of the possible values from each authority with a
+        # successful match
+        possible_values = []
+
+        for entry in request['resolutions']['resolutionsPerAuthority']:
+            if entry['status']['code'] != SYN_RESOLUTION_MATCH:
+                continue
+
+            possible_values.extend([item['value']['name']
+                                    for item
+                                    in entry['values']])
+
+        # If there is only one match use the resolved value, otherwise the
+        # resolution cannot be determined, so use the spoken slot value
+        if len(possible_values) == 1:
+            resolved_value = possible_values[0]
+        else:
+            _LOGGER.debug(
+                'Found multiple synonym resolutions for slot value: {%s: %s}',
+                key,
+                request['value']
+            )
+
+    return resolved_value
+
+
 class AlexaResponse(object):
     """Help generating the response for Alexa."""
 
@@ -188,12 +173,17 @@ class AlexaResponse(object):
         self.session_attributes = {}
         self.should_end_session = True
         self.variables = {}
+
         # Intent is None if request was a LaunchRequest or SessionEndedRequest
         if intent_info is not None:
             for key, value in intent_info.get('slots', {}).items():
-                if 'value' in value:
-                    underscored_key = key.replace('.', '_')
-                    self.variables[underscored_key] = value['value']
+                # Only include slots with values
+                if 'value' not in value:
+                    continue
+
+                _key = key.replace('.', '_')
+
+                self.variables[_key] = resolve_slot_synonyms(key, value)
 
     def add_card(self, card_type, title, content):
         """Add a card to the response."""
@@ -255,66 +245,3 @@ class AlexaResponse(object):
             'sessionAttributes': self.session_attributes,
             'response': response,
         }
-
-
-class AlexaFlashBriefingView(http.HomeAssistantView):
-    """Handle Alexa Flash Briefing skill requests."""
-
-    url = FLASH_BRIEFINGS_API_ENDPOINT
-    name = 'api:alexa:flash_briefings'
-
-    def __init__(self, hass, flash_briefings):
-        """Initialize Alexa view."""
-        super().__init__()
-        self.flash_briefings = copy.deepcopy(flash_briefings)
-        template.attach(hass, self.flash_briefings)
-
-    @callback
-    def get(self, request, briefing_id):
-        """Handle Alexa Flash Briefing request."""
-        _LOGGER.debug('Received Alexa flash briefing request for: %s',
-                      briefing_id)
-
-        if self.flash_briefings.get(briefing_id) is None:
-            err = 'No configured Alexa flash briefing was found for: %s'
-            _LOGGER.error(err, briefing_id)
-            return b'', 404
-
-        briefing = []
-
-        for item in self.flash_briefings.get(briefing_id, []):
-            output = {}
-            if item.get(CONF_TITLE) is not None:
-                if isinstance(item.get(CONF_TITLE), template.Template):
-                    output[ATTR_TITLE_TEXT] = item[CONF_TITLE].async_render()
-                else:
-                    output[ATTR_TITLE_TEXT] = item.get(CONF_TITLE)
-
-            if item.get(CONF_TEXT) is not None:
-                if isinstance(item.get(CONF_TEXT), template.Template):
-                    output[ATTR_MAIN_TEXT] = item[CONF_TEXT].async_render()
-                else:
-                    output[ATTR_MAIN_TEXT] = item.get(CONF_TEXT)
-
-            if item.get(CONF_UID) is not None:
-                output[ATTR_UID] = item.get(CONF_UID)
-
-            if item.get(CONF_AUDIO) is not None:
-                if isinstance(item.get(CONF_AUDIO), template.Template):
-                    output[ATTR_STREAM_URL] = item[CONF_AUDIO].async_render()
-                else:
-                    output[ATTR_STREAM_URL] = item.get(CONF_AUDIO)
-
-            if item.get(CONF_DISPLAY_URL) is not None:
-                if isinstance(item.get(CONF_DISPLAY_URL),
-                              template.Template):
-                    output[ATTR_REDIRECTION_URL] = \
-                        item[CONF_DISPLAY_URL].async_render()
-                else:
-                    output[ATTR_REDIRECTION_URL] = item.get(CONF_DISPLAY_URL)
-
-            output[ATTR_UPDATE_DATE] = datetime.now().strftime(DATE_FORMAT)
-
-            briefing.append(output)
-
-        return self.json(briefing)

homeassistant/components/alexa/smart_home.py

@@ -0,0 +1,643 @@
+"""Support for alexa Smart Home Skill API."""
+import asyncio
+from collections import namedtuple
+import logging
+import math
+from uuid import uuid4
+
+import homeassistant.core as ha
+from homeassistant.const import (
+    ATTR_ENTITY_ID, ATTR_SUPPORTED_FEATURES, SERVICE_LOCK,
+    SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_PAUSE, SERVICE_MEDIA_PLAY,
+    SERVICE_MEDIA_PREVIOUS_TRACK, SERVICE_MEDIA_STOP,
+    SERVICE_SET_COVER_POSITION, SERVICE_TURN_OFF, SERVICE_TURN_ON,
+    SERVICE_UNLOCK, SERVICE_VOLUME_SET)
+from homeassistant.components import (
+    alert, automation, cover, fan, group, input_boolean, light, lock,
+    media_player, scene, script, switch)
+import homeassistant.util.color as color_util
+from homeassistant.util.decorator import Registry
+
+HANDLERS = Registry()
+_LOGGER = logging.getLogger(__name__)
+
+API_DIRECTIVE = 'directive'
+API_ENDPOINT = 'endpoint'
+API_EVENT = 'event'
+API_HEADER = 'header'
+API_PAYLOAD = 'payload'
+
+ATTR_ALEXA_DESCRIPTION = 'alexa_description'
+ATTR_ALEXA_DISPLAY_CATEGORIES = 'alexa_display_categories'
+ATTR_ALEXA_HIDDEN = 'alexa_hidden'
+ATTR_ALEXA_NAME = 'alexa_name'
+
+
+MAPPING_COMPONENT = {
+    alert.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    automation.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    cover.DOMAIN: [
+        'DOOR', ('Alexa.PowerController',), {
+            cover.SUPPORT_SET_POSITION: 'Alexa.PercentageController',
+        }
+    ],
+    fan.DOMAIN: [
+        'OTHER', ('Alexa.PowerController',), {
+            fan.SUPPORT_SET_SPEED: 'Alexa.PercentageController',
+        }
+    ],
+    group.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    input_boolean.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    light.DOMAIN: [
+        'LIGHT', ('Alexa.PowerController',), {
+            light.SUPPORT_BRIGHTNESS: 'Alexa.BrightnessController',
+            light.SUPPORT_RGB_COLOR: 'Alexa.ColorController',
+            light.SUPPORT_XY_COLOR: 'Alexa.ColorController',
+            light.SUPPORT_COLOR_TEMP: 'Alexa.ColorTemperatureController',
+        }
+    ],
+    lock.DOMAIN: ['SMARTLOCK', ('Alexa.LockController',), None],
+    media_player.DOMAIN: [
+        'TV', ('Alexa.PowerController',), {
+            media_player.SUPPORT_VOLUME_SET: 'Alexa.Speaker',
+            media_player.SUPPORT_PLAY: 'Alexa.PlaybackController',
+            media_player.SUPPORT_PAUSE: 'Alexa.PlaybackController',
+            media_player.SUPPORT_STOP: 'Alexa.PlaybackController',
+            media_player.SUPPORT_NEXT_TRACK: 'Alexa.PlaybackController',
+            media_player.SUPPORT_PREVIOUS_TRACK: 'Alexa.PlaybackController',
+        }
+    ],
+    scene.DOMAIN: ['ACTIVITY_TRIGGER', ('Alexa.SceneController',), None],
+    script.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    switch.DOMAIN: ['SWITCH', ('Alexa.PowerController',), None],
+}
+
+
+Config = namedtuple('AlexaConfig', 'filter')
+
+
+@asyncio.coroutine
+def async_handle_message(hass, config, message):
+    """Handle incoming API messages."""
+    assert message[API_DIRECTIVE][API_HEADER]['payloadVersion'] == '3'
+
+    # Read head data
+    message = message[API_DIRECTIVE]
+    namespace = message[API_HEADER]['namespace']
+    name = message[API_HEADER]['name']
+
+    # Do we support this API request?
+    funct_ref = HANDLERS.get((namespace, name))
+    if not funct_ref:
+        _LOGGER.warning(
+            "Unsupported API request %s/%s", namespace, name)
+        return api_error(message)
+
+    return (yield from funct_ref(hass, config, message))
+
+
+def api_message(request, name='Response', namespace='Alexa', payload=None):
+    """Create a API formatted response message.
+
+    Async friendly.
+    """
+    payload = payload or {}
+
+    response = {
+        API_EVENT: {
+            API_HEADER: {
+                'namespace': namespace,
+                'name': name,
+                'messageId': str(uuid4()),
+                'payloadVersion': '3',
+            },
+            API_PAYLOAD: payload,
+        }
+    }
+
+    # If a correlation token exsits, add it to header / Need by Async requests
+    token = request[API_HEADER].get('correlationToken')
+    if token:
+        response[API_EVENT][API_HEADER]['correlationToken'] = token
+
+    # Extend event with endpoint object / Need by Async requests
+    if API_ENDPOINT in request:
+        response[API_EVENT][API_ENDPOINT] = request[API_ENDPOINT].copy()
+
+    return response
+
+
+def api_error(request, error_type='INTERNAL_ERROR', error_message=""):
+    """Create a API formatted error response.
+
+    Async friendly.
+    """
+    payload = {
+        'type': error_type,
+        'message': error_message,
+    }
+
+    return api_message(request, name='ErrorResponse', payload=payload)
+
+
+@HANDLERS.register(('Alexa.Discovery', 'Discover'))
+@asyncio.coroutine
+def async_api_discovery(hass, config, request):
+    """Create a API formatted discovery response.
+
+    Async friendly.
+    """
+    discovery_endpoints = []
+
+    for entity in hass.states.async_all():
+        if not config.filter(entity.entity_id):
+            _LOGGER.debug("Not exposing %s because filtered by config",
+                          entity.entity_id)
+            continue
+
+        if entity.attributes.get(ATTR_ALEXA_HIDDEN, False):
+            _LOGGER.debug("Not exposing %s because alexa_hidden is true",
+                          entity.entity_id)
+            continue
+
+        class_data = MAPPING_COMPONENT.get(entity.domain)
+
+        if not class_data:
+            continue
+
+        friendly_name = entity.attributes.get(ATTR_ALEXA_NAME, entity.name)
+        description = entity.attributes.get(ATTR_ALEXA_DESCRIPTION,
+                                            entity.entity_id)
+
+        # Required description as per Amazon Scene docs
+        if entity.domain == scene.DOMAIN:
+            scene_fmt = '{} (Scene connected via Home Assistant)'
+            description = scene_fmt.format(description)
+
+        cat_key = ATTR_ALEXA_DISPLAY_CATEGORIES
+        display_categories = entity.attributes.get(cat_key, class_data[0])
+
+        endpoint = {
+            'displayCategories': [display_categories],
+            'additionalApplianceDetails': {},
+            'endpointId': entity.entity_id.replace('.', '#'),
+            'friendlyName': friendly_name,
+            'description': description,
+            'manufacturerName': 'Home Assistant',
+        }
+        actions = set()
+
+        # static actions
+        if class_data[1]:
+            actions |= set(class_data[1])
+
+        # dynamic actions
+        if class_data[2]:
+            supported = entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
+            for feature, action_name in class_data[2].items():
+                if feature & supported > 0:
+                    actions.add(action_name)
+
+        # Write action into capabilities
+        capabilities = []
+        for action in actions:
+            capabilities.append({
+                'type': 'AlexaInterface',
+                'interface': action,
+                'version': 3,
+            })
+
+        endpoint['capabilities'] = capabilities
+        discovery_endpoints.append(endpoint)
+
+    return api_message(
+        request, name='Discover.Response', namespace='Alexa.Discovery',
+        payload={'endpoints': discovery_endpoints})
+
+
+def extract_entity(funct):
+    """Decorator for extract entity object from request."""
+    @asyncio.coroutine
+    def async_api_entity_wrapper(hass, config, request):
+        """Process a turn on request."""
+        entity_id = request[API_ENDPOINT]['endpointId'].replace('#', '.')
+
+        # extract state object
+        entity = hass.states.get(entity_id)
+        if not entity:
+            _LOGGER.error("Can't process %s for %s",
+                          request[API_HEADER]['name'], entity_id)
+            return api_error(request, error_type='NO_SUCH_ENDPOINT')
+
+        return (yield from funct(hass, config, request, entity))
+
+    return async_api_entity_wrapper
+
+
+@HANDLERS.register(('Alexa.PowerController', 'TurnOn'))
+@extract_entity
+@asyncio.coroutine
+def async_api_turn_on(hass, config, request, entity):
+    """Process a turn on request."""
+    domain = entity.domain
+    if entity.domain == group.DOMAIN:
+        domain = ha.DOMAIN
+
+    yield from hass.services.async_call(domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PowerController', 'TurnOff'))
+@extract_entity
+@asyncio.coroutine
+def async_api_turn_off(hass, config, request, entity):
+    """Process a turn off request."""
+    domain = entity.domain
+    if entity.domain == group.DOMAIN:
+        domain = ha.DOMAIN
+
+    yield from hass.services.async_call(domain, SERVICE_TURN_OFF, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.BrightnessController', 'SetBrightness'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_brightness(hass, config, request, entity):
+    """Process a set brightness request."""
+    brightness = int(request[API_PAYLOAD]['brightness'])
+
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_BRIGHTNESS_PCT: brightness,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.BrightnessController', 'AdjustBrightness'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_brightness(hass, config, request, entity):
+    """Process a adjust brightness request."""
+    brightness_delta = int(request[API_PAYLOAD]['brightnessDelta'])
+
+    # read current state
+    try:
+        current = math.floor(
+            int(entity.attributes.get(light.ATTR_BRIGHTNESS)) / 255 * 100)
+    except ZeroDivisionError:
+        current = 0
+
+    # set brightness
+    brightness = max(0, brightness_delta + current)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_BRIGHTNESS_PCT: brightness,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.ColorController', 'SetColor'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_color(hass, config, request, entity):
+    """Process a set color request."""
+    supported = entity.attributes.get(ATTR_SUPPORTED_FEATURES)
+    rgb = color_util.color_hsb_to_RGB(
+        float(request[API_PAYLOAD]['color']['hue']),
+        float(request[API_PAYLOAD]['color']['saturation']),
+        float(request[API_PAYLOAD]['color']['brightness'])
+    )
+
+    if supported & light.SUPPORT_RGB_COLOR > 0:
+        yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+            ATTR_ENTITY_ID: entity.entity_id,
+            light.ATTR_RGB_COLOR: rgb,
+        }, blocking=True)
+    else:
+        xyz = color_util.color_RGB_to_xy(*rgb)
+        yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+            ATTR_ENTITY_ID: entity.entity_id,
+            light.ATTR_XY_COLOR: (xyz[0], xyz[1]),
+            light.ATTR_BRIGHTNESS: xyz[2],
+        }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.ColorTemperatureController', 'SetColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_color_temperature(hass, config, request, entity):
+    """Process a set color temperature request."""
+    kelvin = int(request[API_PAYLOAD]['colorTemperatureInKelvin'])
+
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_KELVIN: kelvin,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(
+    ('Alexa.ColorTemperatureController', 'DecreaseColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_decrease_color_temp(hass, config, request, entity):
+    """Process a decrease color temperature request."""
+    current = int(entity.attributes.get(light.ATTR_COLOR_TEMP))
+    max_mireds = int(entity.attributes.get(light.ATTR_MAX_MIREDS))
+
+    value = min(max_mireds, current + 50)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_COLOR_TEMP: value,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(
+    ('Alexa.ColorTemperatureController', 'IncreaseColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_increase_color_temp(hass, config, request, entity):
+    """Process a increase color temperature request."""
+    current = int(entity.attributes.get(light.ATTR_COLOR_TEMP))
+    min_mireds = int(entity.attributes.get(light.ATTR_MIN_MIREDS))
+
+    value = max(min_mireds, current - 50)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_COLOR_TEMP: value,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.SceneController', 'Activate'))
+@extract_entity
+@asyncio.coroutine
+def async_api_activate(hass, config, request, entity):
+    """Process a activate request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PercentageController', 'SetPercentage'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_percentage(hass, config, request, entity):
+    """Process a set percentage request."""
+    percentage = int(request[API_PAYLOAD]['percentage'])
+    service = None
+    data = {ATTR_ENTITY_ID: entity.entity_id}
+
+    if entity.domain == fan.DOMAIN:
+        service = fan.SERVICE_SET_SPEED
+        speed = "off"
+
+        if percentage <= 33:
+            speed = "low"
+        elif percentage <= 66:
+            speed = "medium"
+        elif percentage <= 100:
+            speed = "high"
+        data[fan.ATTR_SPEED] = speed
+
+    elif entity.domain == cover.DOMAIN:
+        service = SERVICE_SET_COVER_POSITION
+        data[cover.ATTR_POSITION] = percentage
+
+    yield from hass.services.async_call(entity.domain, service,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PercentageController', 'AdjustPercentage'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_percentage(hass, config, request, entity):
+    """Process a adjust percentage request."""
+    percentage_delta = int(request[API_PAYLOAD]['percentageDelta'])
+    service = None
+    data = {ATTR_ENTITY_ID: entity.entity_id}
+
+    if entity.domain == fan.DOMAIN:
+        service = fan.SERVICE_SET_SPEED
+        speed = entity.attributes.get(fan.ATTR_SPEED)
+
+        if speed == "off":
+            current = 0
+        elif speed == "low":
+            current = 33
+        elif speed == "medium":
+            current = 66
+        elif speed == "high":
+            current = 100
+
+        # set percentage
+        percentage = max(0, percentage_delta + current)
+        speed = "off"
+
+        if percentage <= 33:
+            speed = "low"
+        elif percentage <= 66:
+            speed = "medium"
+        elif percentage <= 100:
+            speed = "high"
+
+        data[fan.ATTR_SPEED] = speed
+
+    elif entity.domain == cover.DOMAIN:
+        service = SERVICE_SET_COVER_POSITION
+
+        current = entity.attributes.get(cover.ATTR_POSITION)
+
+        data[cover.ATTR_POSITION] = max(0, percentage_delta + current)
+
+    yield from hass.services.async_call(entity.domain, service,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.LockController', 'Lock'))
+@extract_entity
+@asyncio.coroutine
+def async_api_lock(hass, config, request, entity):
+    """Process a lock request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_LOCK, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+# Not supported by Alexa yet
+@HANDLERS.register(('Alexa.LockController', 'Unlock'))
+@extract_entity
+@asyncio.coroutine
+def async_api_unlock(hass, config, request, entity):
+    """Process a unlock request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_UNLOCK, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'SetVolume'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_volume(hass, config, request, entity):
+    """Process a set volume request."""
+    volume = round(float(request[API_PAYLOAD]['volume'] / 100), 2)
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_LEVEL: volume,
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_VOLUME_SET,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'AdjustVolume'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_volume(hass, config, request, entity):
+    """Process a adjust volume request."""
+    volume_delta = int(request[API_PAYLOAD]['volume'])
+
+    current_level = entity.attributes.get(media_player.ATTR_MEDIA_VOLUME_LEVEL)
+
+    # read current state
+    try:
+        current = math.floor(int(current_level * 100))
+    except ZeroDivisionError:
+        current = 0
+
+    volume = float(max(0, volume_delta + current) / 100)
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_LEVEL: volume,
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        media_player.SERVICE_VOLUME_SET,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'SetMute'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_mute(hass, config, request, entity):
+    """Process a set mute request."""
+    mute = bool(request[API_PAYLOAD]['mute'])
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_MUTED: mute,
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        media_player.SERVICE_VOLUME_MUTE,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Play'))
+@extract_entity
+@asyncio.coroutine
+def async_api_play(hass, config, request, entity):
+    """Process a play request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_PLAY,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Pause'))
+@extract_entity
+@asyncio.coroutine
+def async_api_pause(hass, config, request, entity):
+    """Process a pause request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_PAUSE,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Stop'))
+@extract_entity
+@asyncio.coroutine
+def async_api_stop(hass, config, request, entity):
+    """Process a stop request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_STOP,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Next'))
+@extract_entity
+@asyncio.coroutine
+def async_api_next(hass, config, request, entity):
+    """Process a next request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        SERVICE_MEDIA_NEXT_TRACK,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Previous'))
+@extract_entity
+@asyncio.coroutine
+def async_api_previous(hass, config, request, entity):
+    """Process a previous request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        SERVICE_MEDIA_PREVIOUS_TRACK,
+                                        data, blocking=True)
+
+    return api_message(request)

homeassistant/components/amcrest.py

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

homeassistant/components/android_ip_webcam.py

@@ -263,7 +263,7 @@ class AndroidIPCamEntity(Entity):
             """Update callback."""
             if self._host != host:
                 return
-            self.hass.async_add_job(self.async_update_ha_state(True))
+            self.async_schedule_update_ha_state(True)
 
         async_dispatcher_connect(
             self.hass, SIGNAL_UPDATE_DATA, async_ipcam_update)

homeassistant/components/api.py

@@ -13,7 +13,7 @@ import async_timeout
 
 import homeassistant.core as ha
 import homeassistant.remote as rem
-from homeassistant.bootstrap import ERROR_LOG_FILENAME
+from homeassistant.bootstrap import DATA_LOGGING
 from homeassistant.const import (
     EVENT_HOMEASSISTANT_STOP, EVENT_TIME_CHANGED,
     HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND,
@@ -51,8 +51,9 @@ def setup(hass, config):
     hass.http.register_view(APIComponentsView)
     hass.http.register_view(APITemplateView)
 
-    hass.http.register_static_path(
-        URL_API_ERROR_LOG, hass.config.path(ERROR_LOG_FILENAME), False)
+    log_path = hass.data.get(DATA_LOGGING, None)
+    if log_path:
+        hass.http.register_static_path(URL_API_ERROR_LOG, log_path, False)
 
     return True
 
@@ -261,7 +262,11 @@ class APIEventView(HomeAssistantView):
     def post(self, request, event_type):
         """Fire events."""
         body = yield from request.text()
-        event_data = json.loads(body) if body else None
+        try:
+            event_data = json.loads(body) if body else None
+        except ValueError:
+            return self.json_message('Event data should be valid JSON',
+                                     HTTP_BAD_REQUEST)
 
         if event_data is not None and not isinstance(event_data, dict):
             return self.json_message('Event data should be a JSON object',
@@ -308,7 +313,11 @@ class APIDomainServicesView(HomeAssistantView):
         """
         hass = request.app['hass']
         body = yield from request.text()
-        data = json.loads(body) if body else None
+        try:
+            data = json.loads(body) if body else None
+        except ValueError:
+            return self.json_message('Data should be valid JSON',
+                                     HTTP_BAD_REQUEST)
 
         with AsyncTrackStates(hass) as changed_states:
             yield from hass.services.async_call(domain, service, data, True)

homeassistant/components/apple_tv.py

@@ -10,6 +10,7 @@ import logging
 
 import voluptuous as vol
 
+from typing import Union, TypeVar, Sequence
 from homeassistant.const import (CONF_HOST, CONF_NAME, ATTR_ENTITY_ID)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -17,7 +18,7 @@ from homeassistant.helpers import discovery
 from homeassistant.components.discovery import SERVICE_APPLE_TV
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['pyatv==0.3.4']
+REQUIREMENTS = ['pyatv==0.3.8']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -45,8 +46,19 @@ NOTIFICATION_AUTH_TITLE = 'Apple TV Authentication'
 NOTIFICATION_SCAN_ID = 'apple_tv_scan_notification'
 NOTIFICATION_SCAN_TITLE = 'Apple TV Scan'
 
+T = TypeVar('T')
+
+
+# This version of ensure_list interprets an empty dict as no value
+def ensure_list(value: Union[T, Sequence[T]]) -> Sequence[T]:
+    """Wrap value in list if it is not one."""
+    if value is None or (isinstance(value, dict) and not value):
+        return []
+    return value if isinstance(value, list) else [value]
+
+
 CONFIG_SCHEMA = vol.Schema({
-    DOMAIN: vol.All(cv.ensure_list, [vol.Schema({
+    DOMAIN: vol.All(ensure_list, [vol.Schema({
         vol.Required(CONF_HOST): cv.string,
         vol.Required(CONF_LOGIN_ID): cv.string,
         vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
@@ -133,6 +145,10 @@ def async_setup(hass, config):
         """Handler for service calls."""
         entity_ids = service.data.get(ATTR_ENTITY_ID)
 
+        if service.service == SERVICE_SCAN:
+            hass.async_add_job(scan_for_apple_tvs, hass)
+            return
+
         if entity_ids:
             devices = [device for device in hass.data[DATA_ENTITIES]
                        if device.entity_id in entity_ids]
@@ -140,16 +156,16 @@ def async_setup(hass, config):
             devices = hass.data[DATA_ENTITIES]
 
         for device in devices:
+            if service.service != SERVICE_AUTHENTICATE:
+                continue
+
             atv = device.atv
-            if service.service == SERVICE_AUTHENTICATE:
-                credentials = yield from atv.airplay.generate_credentials()
-                yield from atv.airplay.load_credentials(credentials)
-                _LOGGER.debug('Generated new credentials: %s', credentials)
-                yield from atv.airplay.start_authentication()
-                hass.async_add_job(request_configuration,
-                                   hass, config, atv, credentials)
-            elif service.service == SERVICE_SCAN:
-                hass.async_add_job(scan_for_apple_tvs, hass)
+            credentials = yield from atv.airplay.generate_credentials()
+            yield from atv.airplay.load_credentials(credentials)
+            _LOGGER.debug('Generated new credentials: %s', credentials)
+            yield from atv.airplay.start_authentication()
+            hass.async_add_job(request_configuration,
+                               hass, config, atv, credentials)
 
     @asyncio.coroutine
     def atv_discovered(service, info):

homeassistant/components/arlo.py

@@ -1,5 +1,5 @@
 """
-This component provides basic support for Netgear Arlo IP cameras.
+This component provides support for Netgear Arlo IP cameras.
 
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/arlo/
@@ -12,7 +12,7 @@ from requests.exceptions import HTTPError, ConnectTimeout
 from homeassistant.helpers import config_validation as cv
 from homeassistant.const import CONF_USERNAME, CONF_PASSWORD
 
-REQUIREMENTS = ['pyarlo==0.0.4']
+REQUIREMENTS = ['pyarlo==0.1.0']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -23,7 +23,7 @@ DEFAULT_BRAND = 'Netgear Arlo'
 DOMAIN = 'arlo'
 
 NOTIFICATION_ID = 'arlo_notification'
-NOTIFICATION_TITLE = 'Arlo Camera Setup'
+NOTIFICATION_TITLE = 'Arlo Component Setup'
 
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: vol.Schema({

homeassistant/components/automation/event.py

@@ -29,18 +29,27 @@ TRIGGER_SCHEMA = vol.Schema({
 def async_trigger(hass, config, action):
     """Listen for events based on configuration."""
     event_type = config.get(CONF_EVENT_TYPE)
-    event_data = config.get(CONF_EVENT_DATA)
+    event_data_schema = vol.Schema(
+        config.get(CONF_EVENT_DATA),
+        extra=vol.ALLOW_EXTRA) if config.get(CONF_EVENT_DATA) else None
 
     @callback
     def handle_event(event):
         """Listen for events and calls the action when data matches."""
-        if not event_data or all(val == event.data.get(key) for key, val
-                                 in event_data.items()):
-            hass.async_run_job(action, {
-                'trigger': {
-                    'platform': 'event',
-                    'event': event,
-                },
-            })
+        if event_data_schema:
+            # Check that the event data matches the configured
+            # schema if one was provided
+            try:
+                event_data_schema(event.data)
+            except vol.Invalid:
+                # If event data doesn't match requested schema, skip event
+                return
+
+        hass.async_run_job(action, {
+            'trigger': {
+                'platform': 'event',
+                'event': event,
+            },
+        })
 
     return hass.bus.async_listen(event_type, handle_event)

homeassistant/components/automation/numeric_state.py

@@ -37,14 +37,15 @@ def async_trigger(hass, config, action):
     above = config.get(CONF_ABOVE)
     time_delta = config.get(CONF_FOR)
     value_template = config.get(CONF_VALUE_TEMPLATE)
-    async_remove_track_same = None
+    unsub_track_same = {}
+    entities_triggered = set()
 
     if value_template is not None:
         value_template.hass = hass
 
     @callback
     def check_numeric_state(entity, from_s, to_s):
-        """Return True if they should trigger."""
+        """Return True if criteria are now met."""
         if to_s is None:
             return False
 
@@ -56,51 +57,39 @@ def async_trigger(hass, config, action):
                 'above': above,
             }
         }
-
-        # If new one doesn't match, nothing to do
-        if not condition.async_numeric_state(
-                hass, to_s, below, above, value_template, variables):
-            return False
-
-        return True
+        return condition.async_numeric_state(
+            hass, to_s, below, above, value_template, variables)
 
     @callback
     def state_automation_listener(entity, from_s, to_s):
         """Listen for state changes and calls action."""
-        nonlocal async_remove_track_same
-
-        if not check_numeric_state(entity, from_s, to_s):
-            return
-
-        variables = {
-            'trigger': {
-                'platform': 'numeric_state',
-                'entity_id': entity,
-                'below': below,
-                'above': above,
-                'from_state': from_s,
-                'to_state': to_s,
-            }
-        }
-
-        # Only match if old didn't exist or existed but didn't match
-        # Written as: skip if old one did exist and matched
-        if from_s is not None and condition.async_numeric_state(
-                hass, from_s, below, above, value_template, variables):
-            return
-
         @callback
         def call_action():
             """Call action with right context."""
-            hass.async_run_job(action, variables)
+            hass.async_run_job(action, {
+                'trigger': {
+                    'platform': 'numeric_state',
+                    'entity_id': entity,
+                    'below': below,
+                    'above': above,
+                    'from_state': from_s,
+                    'to_state': to_s,
+                }
+            })
 
-        if not time_delta:
-            call_action()
-            return
+        matching = check_numeric_state(entity, from_s, to_s)
 
-        async_remove_track_same = async_track_same_state(
-            hass, True, time_delta, call_action, entity_ids=entity_id,
-            async_check_func=check_numeric_state)
+        if not matching:
+            entities_triggered.discard(entity)
+        elif entity not in entities_triggered:
+            entities_triggered.add(entity)
+
+            if time_delta:
+                unsub_track_same[entity] = async_track_same_state(
+                    hass, time_delta, call_action, entity_ids=entity_id,
+                    async_check_same_func=check_numeric_state)
+            else:
+                call_action()
 
     unsub = async_track_state_change(
         hass, entity_id, state_automation_listener)
@@ -109,7 +98,8 @@ def async_trigger(hass, config, action):
     def async_remove():
         """Remove state listeners async."""
         unsub()
-        if async_remove_track_same:
-            async_remove_track_same()  # pylint: disable=not-callable
+        for async_remove in unsub_track_same.values():
+            async_remove()
+        unsub_track_same.clear()
 
     return async_remove

homeassistant/components/automation/services.yaml

@@ -1,6 +1,7 @@
+# Describes the format for available automation services
+
 turn_on:
   description: Enable an automation.
-
   fields:
     entity_id:
       description: Name of the automation to turn on.
@@ -8,7 +9,6 @@ turn_on:
 
 turn_off:
   description: Disable an automation.
-
   fields:
     entity_id:
       description: Name of the automation to turn off.
@@ -16,7 +16,6 @@ turn_off:
 
 toggle:
   description: Toggle an automation.
-
   fields:
     entity_id:
       description: Name of the automation to toggle on/off.
@@ -24,7 +23,6 @@ toggle:
 
 trigger:
   description: Trigger the action of an automation.
-
   fields:
     entity_id:
       description: Name of the automation to trigger.

homeassistant/components/automation/state.py

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

homeassistant/components/axis.py

@@ -5,25 +5,26 @@ 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.components.discovery import SERVICE_AXIS
 from homeassistant.config import load_yaml_config_file
 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
+                                 CONF_EVENT, CONF_HOST, CONF_INCLUDE,
+                                 CONF_NAME, CONF_PASSWORD, CONF_PORT,
+                                 CONF_TRIGGER_TIME, CONF_USERNAME,
+                                 EVENT_HOMEASSISTANT_STOP)
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers import discovery
-from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.dispatcher import dispatcher_send
 from homeassistant.helpers.entity import Entity
+from homeassistant.util.json import load_json, save_json
 
 
-REQUIREMENTS = ['axis==8']
+REQUIREMENTS = ['axis==14']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -51,6 +52,7 @@ DEVICE_SCHEMA = vol.Schema({
     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(CONF_PORT, default=80): cv.positive_int,
     vol.Optional(ATTR_LOCATION, default=''): cv.string,
 })
 
@@ -76,7 +78,7 @@ SERVICE_SCHEMA = vol.Schema({
 })
 
 
-def request_configuration(hass, name, host, serialnumber):
+def request_configuration(hass, config, name, host, serialnumber):
     """Request configuration steps from the user."""
     configurator = hass.components.configurator
 
@@ -86,22 +88,24 @@ def request_configuration(hass, name, host, serialnumber):
             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)
+            device_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)
+        if setup_device(hass, config, device_config):
+            config_file = load_json(hass.config.path(CONFIG_FILE))
+            config_file[serialnumber] = dict(device_config)
+            save_json(hass.config.path(CONFIG_FILE), config_file)
             configurator.request_done(request_id)
         else:
             configurator.notify_errors(request_id,
@@ -132,6 +136,9 @@ def request_configuration(hass, name, host, serialnumber):
             {'id': ATTR_LOCATION,
              'name': "Physical location of device (optional)",
              'type': 'text'},
+            {'id': CONF_PORT,
+             'name': "HTTP port (default=80)",
+             'type': 'number'},
             {'id': CONF_TRIGGER_TIME,
              'name': "Sensor update interval (optional)",
              'type': 'number'},
@@ -139,13 +146,13 @@ def request_configuration(hass, name, host, serialnumber):
     )
 
 
-def setup(hass, base_config):
+def setup(hass, config):
     """Common setup for Axis devices."""
     def _shutdown(call):  # pylint: disable=unused-argument
-        """Stop the metadatastream on shutdown."""
+        """Stop the event stream on shutdown."""
         for serialnumber, device in AXIS_DEVICES.items():
-            _LOGGER.info("Stopping metadatastream for %s.", serialnumber)
-            device.stop_metadatastream()
+            _LOGGER.info("Stopping event stream for %s.", serialnumber)
+            device.stop()
 
     hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)
 
@@ -156,38 +163,37 @@ def setup(hass, base_config):
         serialnumber = discovery_info['properties']['macaddress']
 
         if serialnumber not in AXIS_DEVICES:
-            config_file = _read_config(hass)
+            config_file = load_json(hass.config.path(CONFIG_FILE))
             if serialnumber in config_file:
-                # Device config saved to file
+                # Device config previously saved to file
                 try:
-                    config = DEVICE_SCHEMA(config_file[serialnumber])
-                    config[CONF_HOST] = host
+                    device_config = DEVICE_SCHEMA(config_file[serialnumber])
+                    device_config[CONF_HOST] = host
                 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[CONF_NAME])
+                if not setup_device(hass, config, device_config):
+                    _LOGGER.error("Couldn\'t set up %s",
+                                  device_config[CONF_NAME])
             else:
                 # New device, create configuration request for UI
-                request_configuration(hass, name, host, serialnumber)
+                request_configuration(hass, config, name, host, serialnumber)
         else:
             # Device already registered, but on a different IP
             device = AXIS_DEVICES[serialnumber]
-            device.url = host
-            async_dispatcher_send(hass,
-                                  DOMAIN + '_' + device.name + '_new_ip',
-                                  host)
+            device.config.host = host
+            dispatcher_send(hass, DOMAIN + '_' + device.name + '_new_ip', host)
 
     # Register discovery service
     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[CONF_NAME])
+    if DOMAIN in config:
+        for device in config[DOMAIN]:
+            device_config = config[DOMAIN][device]
+            if CONF_NAME not in device_config:
+                device_config[CONF_NAME] = device
+            if not setup_device(hass, config, device_config):
+                _LOGGER.error("Couldn\'t set up %s", device_config[CONF_NAME])
 
     # Services to communicate with device.
     descriptions = load_yaml_config_file(
@@ -197,10 +203,11 @@ def setup(hass, base_config):
         """Service to send a message."""
         for _, device in AXIS_DEVICES.items():
             if device.name == call.data[CONF_NAME]:
-                response = device.do_request(call.data[SERVICE_CGI],
-                                             call.data[SERVICE_ACTION],
-                                             call.data[SERVICE_PARAM])
-                hass.bus.async_fire(SERVICE_VAPIX_CALL_RESPONSE, response)
+                response = device.vapix.do_request(
+                    call.data[SERVICE_CGI],
+                    call.data[SERVICE_ACTION],
+                    call.data[SERVICE_PARAM])
+                hass.bus.fire(SERVICE_VAPIX_CALL_RESPONSE, response)
                 return True
         _LOGGER.info("Couldn\'t find device %s", call.data[CONF_NAME])
         return False
@@ -211,85 +218,72 @@ def setup(hass, base_config):
                            vapix_service,
                            descriptions[DOMAIN][SERVICE_VAPIX_CALL],
                            schema=SERVICE_SCHEMA)
-
     return True
 
 
-def setup_device(hass, config):
+def setup_device(hass, config, device_config):
     """Set up device."""
     from axis import AxisDevice
 
-    config['hass'] = hass
-    device = AxisDevice(config)  # Initialize device
-    enable_metadatastream = False
+    def signal_callback(action, event):
+        """Callback to configure events when initialized on event stream."""
+        if action == 'add':
+            event_config = {
+                CONF_EVENT: event,
+                CONF_NAME: device_config[CONF_NAME],
+                ATTR_LOCATION: device_config[ATTR_LOCATION],
+                CONF_TRIGGER_TIME: device_config[CONF_TRIGGER_TIME]
+            }
+            component = event.event_platform
+            discovery.load_platform(hass,
+                                    component,
+                                    DOMAIN,
+                                    event_config,
+                                    config)
+
+    event_types = list(filter(lambda x: x in device_config[CONF_INCLUDE],
+                              EVENT_TYPES))
+    device_config['events'] = event_types
+    device_config['signal'] = signal_callback
+    device = AxisDevice(hass.loop, **device_config)
+    device.name = device_config[CONF_NAME]
 
     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])
+        _LOGGER.error("Couldn\'t connect to %s", device_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
-        if not device.initiate_metadatastream():
-            hass.components.persistent_notification.create(
-                'Dependency missing for sensors, '
-                'please check documentation',
-                title=DOMAIN,
-                notification_id='axis_notification')
+    for component in device_config[CONF_INCLUDE]:
+        if component == 'camera':
+            camera_config = {
+                CONF_NAME: device_config[CONF_NAME],
+                CONF_HOST: device_config[CONF_HOST],
+                CONF_PORT: device_config[CONF_PORT],
+                CONF_USERNAME: device_config[CONF_USERNAME],
+                CONF_PASSWORD: device_config[CONF_PASSWORD]
+            }
+            discovery.load_platform(hass,
+                                    component,
+                                    DOMAIN,
+                                    camera_config,
+                                    config)
 
     AXIS_DEVICES[device.serial_number] = device
-
+    if event_types:
+        hass.add_job(device.start)
     return True
 
 
-def _read_config(hass):
-    """Read Axis config."""
-    path = hass.config.path(CONFIG_FILE)
-
-    if not os.path.isfile(path):
-        return {}
-
-    with open(path) as f_handle:
-        # Guard against empty file
-        return json.loads(f_handle.read() or '{}')
-
-
-def _write_config(hass, config):
-    """Write Axis config."""
-    data = json.dumps(config)
-    with open(hass.config.path(CONFIG_FILE), 'w', encoding='utf-8') as outfile:
-        outfile.write(data)
-
-
-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):
+    def __init__(self, event_config):
         """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 = event_config[CONF_EVENT]
+        self._name = '{}_{}_{}'.format(event_config[CONF_NAME],
+                                       self.axis_event.event_type,
                                        self.axis_event.id)
+        self.location = event_config[ATTR_LOCATION]
         self.axis_event.callback = self._update_callback
 
     def _update_callback(self):
@@ -305,7 +299,7 @@ class AxisDeviceEvent(Entity):
     @property
     def device_class(self):
         """Return the class of the event."""
-        return self._event_class
+        return self.axis_event.event_class
 
     @property
     def should_poll(self):
@@ -320,52 +314,6 @@ class AxisDeviceEvent(Entity):
         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
+        attr[ATTR_LOCATION] = self.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': 'binary_sensor'}, ]

homeassistant/components/binary_sensor/__init__.py

@@ -20,6 +20,7 @@ SCAN_INTERVAL = timedelta(seconds=30)
 
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 DEVICE_CLASSES = [
+    'battery',       # On means low, Off means normal
     'cold',          # On means cold (or too cold)
     'connectivity',  # On means connection present, Off = no connection
     'gas',           # CO, CO2, etc.
@@ -30,7 +31,9 @@ DEVICE_CLASSES = [
     'moving',        # On means moving, Off means stopped
     'occupancy',     # On means occupied, Off means not occupied
     'opening',       # Door, window, etc.
+    'plug',          # On means plugged in, Off means unplugged
     'power',         # Power, over-current, etc
+    'presence',      # On means home, Off means away
     'safety',        # Generic on=unsafe, off=safe
     'smoke',         # Smoke detector
     'sound',         # On means sound detected, Off means no sound

homeassistant/components/binary_sensor/abode.py

@@ -6,7 +6,8 @@ https://home-assistant.io/components/binary_sensor.abode/
 """
 import logging
 
-from homeassistant.components.abode import AbodeDevice, DATA_ABODE
+from homeassistant.components.abode import (AbodeDevice, AbodeAutomation,
+                                            DOMAIN as ABODE_DOMAIN)
 from homeassistant.components.binary_sensor import BinarySensorDevice
 
 
@@ -17,39 +18,38 @@ _LOGGER = logging.getLogger(__name__)
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up a sensor for an Abode device."""
-    abode = hass.data[DATA_ABODE]
-
-    device_types = map_abode_device_class().keys()
-
-    sensors = []
-    for sensor in abode.get_devices(type_filter=device_types):
-        sensors.append(AbodeBinarySensor(abode, sensor))
-
-    add_devices(sensors)
-
-
-def map_abode_device_class():
-    """Map Abode device types to Home Assistant binary sensor class."""
     import abodepy.helpers.constants as CONST
+    import abodepy.helpers.timeline as TIMELINE
 
-    return {
-        CONST.DEVICE_GLASS_BREAK: 'connectivity',
-        CONST.DEVICE_KEYPAD: 'connectivity',
-        CONST.DEVICE_DOOR_CONTACT: 'opening',
-        CONST.DEVICE_STATUS_DISPLAY: 'connectivity',
-        CONST.DEVICE_MOTION_CAMERA: 'connectivity',
-        CONST.DEVICE_WATER_SENSOR: 'moisture'
-    }
+    data = hass.data[ABODE_DOMAIN]
+
+    device_types = [CONST.TYPE_CONNECTIVITY, CONST.TYPE_MOISTURE,
+                    CONST.TYPE_MOTION, CONST.TYPE_OCCUPANCY,
+                    CONST.TYPE_OPENING]
+
+    devices = []
+    for device in data.abode.get_devices(generic_type=device_types):
+        if data.is_excluded(device):
+            continue
+
+        devices.append(AbodeBinarySensor(data, device))
+
+    for automation in data.abode.get_automations(
+            generic_type=CONST.TYPE_QUICK_ACTION):
+        if data.is_automation_excluded(automation):
+            continue
+
+        devices.append(AbodeQuickActionBinarySensor(
+            data, automation, TIMELINE.AUTOMATION_EDIT_GROUP))
+
+    data.devices.extend(devices)
+
+    add_devices(devices)
 
 
 class AbodeBinarySensor(AbodeDevice, BinarySensorDevice):
     """A binary sensor implementation for Abode device."""
 
-    def __init__(self, controller, device):
-        """Initialize a sensor for Abode device."""
-        AbodeDevice.__init__(self, controller, device)
-        self._device_class = map_abode_device_class().get(self._device.type)
-
     @property
     def is_on(self):
         """Return True if the binary sensor is on."""
@@ -58,4 +58,17 @@ class AbodeBinarySensor(AbodeDevice, BinarySensorDevice):
     @property
     def device_class(self):
         """Return the class of the binary sensor."""
-        return self._device_class
+        return self._device.generic_type
+
+
+class AbodeQuickActionBinarySensor(AbodeAutomation, BinarySensorDevice):
+    """A binary sensor implementation for Abode quick action automations."""
+
+    def trigger(self):
+        """Trigger a quick automation."""
+        self._automation.trigger()
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._automation.is_active

homeassistant/components/binary_sensor/alarmdecoder.py

@@ -102,11 +102,11 @@ class AlarmDecoderBinarySensor(BinarySensorDevice):
         """Update the zone's state, if needed."""
         if zone is None or int(zone) == self._zone_number:
             self._state = 1
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()
 
     @callback
     def _restore_callback(self, zone):
         """Update the zone's state, if needed."""
         if zone is None or int(zone) == self._zone_number:
             self._state = 0
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()

homeassistant/components/binary_sensor/aurora.py

@@ -7,25 +7,32 @@ https://home-assistant.io/components/binary_sensor.aurora/
 from datetime import timedelta
 import logging
 
+from aiohttp.hdrs import USER_AGENT
 import requests
 import voluptuous as vol
 
-from homeassistant.components.binary_sensor \
-    import (BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.const import (CONF_NAME)
+from homeassistant.components.binary_sensor import (
+    PLATFORM_SCHEMA, BinarySensorDevice)
+from homeassistant.const import CONF_NAME, ATTR_ATTRIBUTION
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util import Throttle
 
-CONF_THRESHOLD = "forecast_threshold"
-
 _LOGGER = logging.getLogger(__name__)
 
+CONF_ATTRIBUTION = "Data provided by the National Oceanic and Atmospheric" \
+                   "Administration"
+CONF_THRESHOLD = 'forecast_threshold'
+
+DEFAULT_DEVICE_CLASS = 'visible'
 DEFAULT_NAME = 'Aurora Visibility'
-DEFAULT_DEVICE_CLASS = "visible"
 DEFAULT_THRESHOLD = 75
 
+HA_USER_AGENT = "Home Assistant Aurora Tracker v.0.1.0"
+
 MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=5)
 
+URL = "http://services.swpc.noaa.gov/text/aurora-nowcast-map.txt"
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_THRESHOLD, default=DEFAULT_THRESHOLD): cv.positive_int,
@@ -43,10 +50,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     try:
         aurora_data = AuroraData(
-            hass.config.latitude,
-            hass.config.longitude,
-            threshold
-        )
+            hass.config.latitude, hass.config.longitude, threshold)
         aurora_data.update()
     except requests.exceptions.HTTPError as error:
         _LOGGER.error(
@@ -85,9 +89,9 @@ class AuroraSensor(BinarySensorDevice):
         attrs = {}
 
         if self.aurora_data:
-            attrs["visibility_level"] = self.aurora_data.visibility_level
-            attrs["message"] = self.aurora_data.is_visible_text
-
+            attrs['visibility_level'] = self.aurora_data.visibility_level
+            attrs['message'] = self.aurora_data.is_visible_text
+            attrs[ATTR_ATTRIBUTION] = CONF_ATTRIBUTION
         return attrs
 
     def update(self):
@@ -104,10 +108,7 @@ class AuroraData(object):
         self.longitude = longitude
         self.number_of_latitude_intervals = 513
         self.number_of_longitude_intervals = 1024
-        self.api_url = \
-            "http://services.swpc.noaa.gov/text/aurora-nowcast-map.txt"
-        self.headers = {"User-Agent": "Home Assistant Aurora Tracker v.0.1.0"}
-
+        self.headers = {USER_AGENT: HA_USER_AGENT}
         self.threshold = int(threshold)
         self.is_visible = None
         self.is_visible_text = None
@@ -132,14 +133,14 @@ class AuroraData(object):
 
     def get_aurora_forecast(self):
         """Get forecast data and parse for given long/lat."""
-        raw_data = requests.get(self.api_url, headers=self.headers).text
+        raw_data = requests.get(URL, headers=self.headers, timeout=5).text
         forecast_table = [
             row.strip(" ").split("   ")
             for row in raw_data.split("\n")
             if not row.startswith("#")
         ]
 
-        # convert lat and long for data points in table
+        # Convert lat and long for data points in table
         converted_latitude = round((self.latitude / 180)
                                    * self.number_of_latitude_intervals)
         converted_longitude = round((self.longitude / 360)

homeassistant/components/binary_sensor/axis.py

@@ -21,19 +21,19 @@ _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)
+    add_devices([AxisBinarySensor(hass, discovery_info)], True)
 
 
 class AxisBinarySensor(AxisDeviceEvent, BinarySensorDevice):
     """Representation of a binary Axis event."""
 
-    def __init__(self, axis_event, hass):
+    def __init__(self, hass, event_config):
         """Initialize the binary sensor."""
         self.hass = hass
         self._state = False
-        self._delay = axis_event.device_config(CONF_TRIGGER_TIME)
+        self._delay = event_config[CONF_TRIGGER_TIME]
         self._timer = None
-        AxisDeviceEvent.__init__(self, axis_event)
+        AxisDeviceEvent.__init__(self, event_config)
 
     @property
     def is_on(self):

homeassistant/components/binary_sensor/bayesian.py

@@ -22,6 +22,10 @@ from homeassistant.helpers.event import async_track_state_change
 
 _LOGGER = logging.getLogger(__name__)
 
+ATTR_OBSERVATIONS = 'observations'
+ATTR_PROBABILITY = 'probability'
+ATTR_PROBABILITY_THRESHOLD = 'probability_threshold'
+
 CONF_OBSERVATIONS = 'observations'
 CONF_PRIOR = 'prior'
 CONF_PROBABILITY_THRESHOLD = 'probability_threshold'
@@ -29,7 +33,8 @@ CONF_P_GIVEN_F = 'prob_given_false'
 CONF_P_GIVEN_T = 'prob_given_true'
 CONF_TO_STATE = 'to_state'
 
-DEFAULT_NAME = 'BayesianBinary'
+DEFAULT_NAME = "Bayesian Binary Sensor"
+DEFAULT_PROBABILITY_THRESHOLD = 0.5
 
 NUMERIC_STATE_SCHEMA = vol.Schema({
     CONF_PLATFORM: 'numeric_state',
@@ -49,16 +54,14 @@ STATE_SCHEMA = vol.Schema({
 }, required=True)
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME):
-        cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_DEVICE_CLASS): cv.string,
-    vol.Required(CONF_OBSERVATIONS): vol.Schema(
-        vol.All(cv.ensure_list, [vol.Any(NUMERIC_STATE_SCHEMA,
-                                         STATE_SCHEMA)])
-    ),
+    vol.Required(CONF_OBSERVATIONS):
+        vol.Schema(vol.All(cv.ensure_list,
+                           [vol.Any(NUMERIC_STATE_SCHEMA, STATE_SCHEMA)])),
     vol.Required(CONF_PRIOR): vol.Coerce(float),
-    vol.Optional(CONF_PROBABILITY_THRESHOLD):
-        vol.Coerce(float),
+    vol.Optional(CONF_PROBABILITY_THRESHOLD,
+                 default=DEFAULT_PROBABILITY_THRESHOLD): vol.Coerce(float),
 })
 
 
@@ -73,16 +76,16 @@ def update_probability(prior, prob_true, prob_false):
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Set up the Threshold sensor."""
+    """Set up the Bayesian Binary sensor."""
     name = config.get(CONF_NAME)
     observations = config.get(CONF_OBSERVATIONS)
     prior = config.get(CONF_PRIOR)
-    probability_threshold = config.get(CONF_PROBABILITY_THRESHOLD, 0.5)
+    probability_threshold = config.get(CONF_PROBABILITY_THRESHOLD)
     device_class = config.get(CONF_DEVICE_CLASS)
 
     async_add_devices([
-        BayesianBinarySensor(name, prior, observations, probability_threshold,
-                             device_class)
+        BayesianBinarySensor(
+            name, prior, observations, probability_threshold, device_class)
     ], True)
 
 
@@ -102,7 +105,13 @@ class BayesianBinarySensor(BinarySensorDevice):
 
         self.current_obs = OrderedDict({})
 
-        self.entity_obs = {obs['entity_id']: obs for obs in self._observations}
+        to_observe = set(obs['entity_id'] for obs in self._observations)
+
+        self.entity_obs = dict.fromkeys(to_observe, [])
+
+        for ind, obs in enumerate(self._observations):
+            obs['id'] = ind
+            self.entity_obs[obs['entity_id']].append(obs)
 
         self.watchers = {
             'numeric_state': self._process_numeric_state,
@@ -111,7 +120,7 @@ class BayesianBinarySensor(BinarySensorDevice):
 
     @asyncio.coroutine
     def async_added_to_hass(self):
-        """Call when entity about to be added to hass."""
+        """Call when entity about to be added."""
         @callback
         # pylint: disable=invalid-name
         def async_threshold_sensor_state_listener(entity, old_state,
@@ -120,17 +129,17 @@ class BayesianBinarySensor(BinarySensorDevice):
             if new_state.state == STATE_UNKNOWN:
                 return
 
-            entity_obs = self.entity_obs[entity]
-            platform = entity_obs['platform']
+            entity_obs_list = self.entity_obs[entity]
 
-            self.watchers[platform](entity_obs)
+            for entity_obs in entity_obs_list:
+                platform = entity_obs['platform']
+
+                self.watchers[platform](entity_obs)
 
             prior = self.prior
-            print(self.current_obs.values())
             for obs in self.current_obs.values():
-                prior = update_probability(prior, obs['prob_true'],
-                                           obs['prob_false'])
-
+                prior = update_probability(
+                    prior, obs['prob_true'], obs['prob_false'])
             self.probability = prior
 
             self.hass.async_add_job(self.async_update_ha_state, True)
@@ -141,20 +150,20 @@ class BayesianBinarySensor(BinarySensorDevice):
 
     def _update_current_obs(self, entity_observation, should_trigger):
         """Update current observation."""
-        entity = entity_observation['entity_id']
+        obs_id = entity_observation['id']
 
         if should_trigger:
             prob_true = entity_observation['prob_given_true']
             prob_false = entity_observation.get(
                 'prob_given_false', 1 - prob_true)
 
-            self.current_obs[entity] = {
+            self.current_obs[obs_id] = {
                 'prob_true': prob_true,
                 'prob_false': prob_false
             }
 
         else:
-            self.current_obs.pop(entity, None)
+            self.current_obs.pop(obs_id, None)
 
     def _process_numeric_state(self, entity_observation):
         """Add entity to current_obs if numeric state conditions are met."""
@@ -200,9 +209,9 @@ class BayesianBinarySensor(BinarySensorDevice):
     def device_state_attributes(self):
         """Return the state attributes of the sensor."""
         return {
-            'observations': [val for val in self.current_obs.values()],
-            'probability': self.probability,
-            'probability_threshold': self._probability_threshold
+            ATTR_OBSERVATIONS: [val for val in self.current_obs.values()],
+            ATTR_PROBABILITY: round(self.probability, 2),
+            ATTR_PROBABILITY_THRESHOLD: self._probability_threshold,
         }
 
     @asyncio.coroutine

homeassistant/components/binary_sensor/doorbird.py

@@ -0,0 +1,60 @@
+"""Support for reading binary states from a DoorBird video doorbell."""
+from datetime import timedelta
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.doorbird import DOMAIN as DOORBIRD_DOMAIN
+from homeassistant.util import Throttle
+
+DEPENDENCIES = ['doorbird']
+
+_LOGGER = logging.getLogger(__name__)
+_MIN_UPDATE_INTERVAL = timedelta(milliseconds=250)
+
+SENSOR_TYPES = {
+    "doorbell": {
+        "name": "Doorbell Ringing",
+        "icon": {
+            True: "bell-ring",
+            False: "bell",
+            None: "bell-outline"
+        }
+    }
+}
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the DoorBird binary sensor component."""
+    device = hass.data.get(DOORBIRD_DOMAIN)
+    add_devices([DoorBirdBinarySensor(device, "doorbell")], True)
+
+
+class DoorBirdBinarySensor(BinarySensorDevice):
+    """A binary sensor of a DoorBird device."""
+
+    def __init__(self, device, sensor_type):
+        """Initialize a binary sensor on a DoorBird device."""
+        self._device = device
+        self._sensor_type = sensor_type
+        self._state = None
+
+    @property
+    def name(self):
+        """Get the name of the sensor."""
+        return SENSOR_TYPES[self._sensor_type]["name"]
+
+    @property
+    def icon(self):
+        """Get an icon to display."""
+        state_icon = SENSOR_TYPES[self._sensor_type]["icon"][self._state]
+        return "mdi:{}".format(state_icon)
+
+    @property
+    def is_on(self):
+        """Get the state of the binary sensor."""
+        return self._state
+
+    @Throttle(_MIN_UPDATE_INTERVAL)
+    def update(self):
+        """Pull the latest value from the device."""
+        self._state = self._device.doorbell_state()

homeassistant/components/binary_sensor/envisalink.py

@@ -80,4 +80,4 @@ class EnvisalinkBinarySensor(EnvisalinkDevice, BinarySensorDevice):
     def _update_callback(self, zone):
         """Update the zone's state, if needed."""
         if zone is None or int(zone) == self._zone_number:
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()

homeassistant/components/binary_sensor/ffmpeg_motion.py

@@ -73,7 +73,7 @@ class FFmpegBinarySensor(FFmpegBase, BinarySensorDevice):
     def _async_callback(self, state):
         """HA-FFmpeg callback for noise detection."""
         self._state = state
-        self.hass.async_add_job(self.async_update_ha_state())
+        self.async_schedule_update_ha_state()
 
     @property
     def is_on(self):

homeassistant/components/binary_sensor/gc100.py

@@ -0,0 +1,69 @@
+"""
+Support for binary sensor using GC100.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.gc100/
+"""
+import voluptuous as vol
+
+from homeassistant.components.gc100 import DATA_GC100, CONF_PORTS
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import DEVICE_DEFAULT_NAME
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['gc100']
+
+_SENSORS_SCHEMA = vol.Schema({
+    cv.string: cv.string,
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PORTS): vol.All(cv.ensure_list, [_SENSORS_SCHEMA])
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the GC100 devices."""
+    binary_sensors = []
+    ports = config.get(CONF_PORTS)
+    for port in ports:
+        for port_addr, port_name in port.items():
+            binary_sensors.append(GC100BinarySensor(
+                port_name, port_addr, hass.data[DATA_GC100]))
+    add_devices(binary_sensors, True)
+
+
+class GC100BinarySensor(BinarySensorDevice):
+    """Representation of a binary sensor from GC100."""
+
+    def __init__(self, name, port_addr, gc100):
+        """Initialize the GC100 binary sensor."""
+        # pylint: disable=no-member
+        self._name = name or DEVICE_DEFAULT_NAME
+        self._port_addr = port_addr
+        self._gc100 = gc100
+        self._state = None
+
+        # Subscribe to be notified about state changes (PUSH)
+        self._gc100.subscribe(self._port_addr, self.set_state)
+
+    @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
+
+    def update(self):
+        """Update the sensor state."""
+        self._gc100.read_sensor(self._port_addr, self.set_state)
+
+    def set_state(self, state):
+        """Set the current state."""
+        self._state = state == 1
+        self.schedule_update_ha_state()

homeassistant/components/binary_sensor/hive.py

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

homeassistant/components/binary_sensor/homematic.py

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

homeassistant/components/binary_sensor/insteon_plm.py

@@ -55,12 +55,12 @@ class InsteonPLMBinarySensorDevice(BinarySensorDevice):
 
     @property
     def address(self):
-        """Return the the address of the node."""
+        """Return the address of the node."""
         return self._address
 
     @property
     def name(self):
-        """Return the the name of the node."""
+        """Return the name of the node."""
         return self._name
 
     @property

homeassistant/components/binary_sensor/iss.py

@@ -13,7 +13,8 @@ import voluptuous as vol
 import homeassistant.helpers.config_validation as cv
 from homeassistant.components.binary_sensor import (
     BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.const import (CONF_NAME, ATTR_LONGITUDE, ATTR_LATITUDE)
+from homeassistant.const import (
+    CONF_NAME, ATTR_LONGITUDE, ATTR_LATITUDE, CONF_SHOW_ON_MAP)
 from homeassistant.util import Throttle
 
 REQUIREMENTS = ['pyiss==1.0.1']
@@ -23,8 +24,6 @@ _LOGGER = logging.getLogger(__name__)
 ATTR_ISS_NEXT_RISE = 'next_rise'
 ATTR_ISS_NUMBER_PEOPLE_SPACE = 'number_of_people_in_space'
 
-CONF_SHOW_ON_MAP = 'show_on_map'
-
 DEFAULT_NAME = 'ISS'
 DEFAULT_DEVICE_CLASS = 'visible'
 

homeassistant/components/binary_sensor/knx.py

@@ -53,7 +53,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 @asyncio.coroutine
-def async_setup_platform(hass, config, add_devices,
+def async_setup_platform(hass, config, async_add_devices,
                          discovery_info=None):
     """Set up binary sensor(s) for KNX platform."""
     if DATA_KNX not in hass.data \
@@ -61,25 +61,25 @@ def async_setup_platform(hass, config, add_devices,
         return False
 
     if discovery_info is not None:
-        async_add_devices_discovery(hass, discovery_info, add_devices)
+        async_add_devices_discovery(hass, discovery_info, async_add_devices)
     else:
-        async_add_devices_config(hass, config, add_devices)
+        async_add_devices_config(hass, config, async_add_devices)
 
     return True
 
 
 @callback
-def async_add_devices_discovery(hass, discovery_info, add_devices):
+def async_add_devices_discovery(hass, discovery_info, async_add_devices):
     """Set up binary sensors for KNX platform configured via xknx.yaml."""
     entities = []
     for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
         device = hass.data[DATA_KNX].xknx.devices[device_name]
         entities.append(KNXBinarySensor(hass, device))
-    add_devices(entities)
+    async_add_devices(entities)
 
 
 @callback
-def async_add_devices_config(hass, config, add_devices):
+def async_add_devices_config(hass, config, async_add_devices):
     """Set up binary senor for KNX platform configured within plattform."""
     name = config.get(CONF_NAME)
     import xknx
@@ -101,7 +101,7 @@ def async_add_devices_config(hass, config, add_devices):
             entity.automations.append(KNXAutomation(
                 hass=hass, device=binary_sensor, hook=hook,
                 action=action, counter=counter))
-    add_devices([entity])
+    async_add_devices([entity])
 
 
 class KNXBinarySensor(BinarySensorDevice):

homeassistant/components/binary_sensor/linode.py

@@ -0,0 +1,96 @@
+"""
+Support for monitoring the state of Linode Nodes.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.linode/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.linode import (
+    CONF_NODES, ATTR_CREATED, ATTR_NODE_ID, ATTR_NODE_NAME,
+    ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY,
+    ATTR_REGION, ATTR_VCPUS, DATA_LINODE)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Node'
+DEFAULT_DEVICE_CLASS = 'moving'
+DEPENDENCIES = ['linode']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_NODES): vol.All(cv.ensure_list, [cv.string]),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Linode droplet sensor."""
+    linode = hass.data.get(DATA_LINODE)
+    nodes = config.get(CONF_NODES)
+
+    dev = []
+    for node in nodes:
+        node_id = linode.get_node_id(node)
+        if node_id is None:
+            _LOGGER.error("Node %s is not available", node)
+            return
+        dev.append(LinodeBinarySensor(linode, node_id))
+
+    add_devices(dev, True)
+
+
+class LinodeBinarySensor(BinarySensorDevice):
+    """Representation of a Linode droplet sensor."""
+
+    def __init__(self, li, node_id):
+        """Initialize a new Linode sensor."""
+        self._linode = li
+        self._node_id = node_id
+        self._state = None
+        self.data = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        if self.data is not None:
+            return self.data.label
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        if self.data is not None:
+            return self.data.status == 'running'
+        return False
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_DEVICE_CLASS
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the Linode Node."""
+        if self.data:
+            return {
+                ATTR_CREATED: self.data.created,
+                ATTR_NODE_ID: self.data.id,
+                ATTR_NODE_NAME: self.data.label,
+                ATTR_IPV4_ADDRESS: self.data.ipv4,
+                ATTR_IPV6_ADDRESS: self.data.ipv6,
+                ATTR_MEMORY: self.data.specs.memory,
+                ATTR_REGION: self.data.region.country,
+                ATTR_VCPUS: self.data.specs.vcpus,
+            }
+        return {}
+
+    def update(self):
+        """Update state of sensor."""
+        self._linode.update()
+        if self._linode.data is not None:
+            for node in self._linode.data:
+                if node.id == self._node_id:
+                    self.data = node

homeassistant/components/binary_sensor/mqtt.py

@@ -16,14 +16,21 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.const import (
     CONF_NAME, CONF_VALUE_TEMPLATE, CONF_PAYLOAD_ON, CONF_PAYLOAD_OFF,
     CONF_DEVICE_CLASS)
-from homeassistant.components.mqtt import (CONF_STATE_TOPIC, CONF_QOS)
+from homeassistant.components.mqtt import (
+    CONF_STATE_TOPIC, CONF_AVAILABILITY_TOPIC, CONF_QOS, valid_subscribe_topic)
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
+CONF_PAYLOAD_AVAILABLE = 'payload_available'
+CONF_PAYLOAD_NOT_AVAILABLE = 'payload_not_available'
+
 DEFAULT_NAME = 'MQTT Binary sensor'
 DEFAULT_PAYLOAD_OFF = 'OFF'
 DEFAULT_PAYLOAD_ON = 'ON'
+DEFAULT_PAYLOAD_AVAILABLE = 'online'
+DEFAULT_PAYLOAD_NOT_AVAILABLE = 'offline'
+
 DEPENDENCIES = ['mqtt']
 
 PLATFORM_SCHEMA = mqtt.MQTT_RO_PLATFORM_SCHEMA.extend({
@@ -31,6 +38,11 @@ PLATFORM_SCHEMA = mqtt.MQTT_RO_PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string,
     vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_AVAILABILITY_TOPIC): valid_subscribe_topic,
+    vol.Optional(CONF_PAYLOAD_AVAILABLE,
+                 default=DEFAULT_PAYLOAD_AVAILABLE): cv.string,
+    vol.Optional(CONF_PAYLOAD_NOT_AVAILABLE,
+                 default=DEFAULT_PAYLOAD_NOT_AVAILABLE): cv.string,
 })
 
 
@@ -47,10 +59,13 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     async_add_devices([MqttBinarySensor(
         config.get(CONF_NAME),
         config.get(CONF_STATE_TOPIC),
+        config.get(CONF_AVAILABILITY_TOPIC),
         config.get(CONF_DEVICE_CLASS),
         config.get(CONF_QOS),
         config.get(CONF_PAYLOAD_ON),
         config.get(CONF_PAYLOAD_OFF),
+        config.get(CONF_PAYLOAD_AVAILABLE),
+        config.get(CONF_PAYLOAD_NOT_AVAILABLE),
         value_template
     )])
 
@@ -58,15 +73,20 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 class MqttBinarySensor(BinarySensorDevice):
     """Representation a binary sensor that is updated by MQTT."""
 
-    def __init__(self, name, state_topic, device_class, qos, payload_on,
-                 payload_off, value_template):
+    def __init__(self, name, state_topic, availability_topic, device_class,
+                 qos, payload_on, payload_off, payload_available,
+                 payload_not_available, value_template):
         """Initialize the MQTT binary sensor."""
         self._name = name
-        self._state = False
+        self._state = None
         self._state_topic = state_topic
+        self._availability_topic = availability_topic
+        self._available = True if availability_topic is None else False
         self._device_class = device_class
         self._payload_on = payload_on
         self._payload_off = payload_off
+        self._payload_available = payload_available
+        self._payload_not_available = payload_not_available
         self._qos = qos
         self._template = value_template
 
@@ -76,8 +96,8 @@ class MqttBinarySensor(BinarySensorDevice):
         This method must be run in the event loop and returns a coroutine.
         """
         @callback
-        def message_received(topic, payload, qos):
-            """Handle a new received MQTT message."""
+        def state_message_received(topic, payload, qos):
+            """Handle a new received MQTT state message."""
             if self._template is not None:
                 payload = self._template.async_render_with_possible_json_value(
                     payload)
@@ -86,10 +106,25 @@ class MqttBinarySensor(BinarySensorDevice):
             elif payload == self._payload_off:
                 self._state = False
 
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()
 
-        return mqtt.async_subscribe(
-            self.hass, self._state_topic, message_received, self._qos)
+        yield from mqtt.async_subscribe(
+            self.hass, self._state_topic, state_message_received, self._qos)
+
+        @callback
+        def availability_message_received(topic, payload, qos):
+            """Handle a new received MQTT availability message."""
+            if payload == self._payload_available:
+                self._available = True
+            elif payload == self._payload_not_available:
+                self._available = False
+
+            self.async_schedule_update_ha_state()
+
+        if self._availability_topic is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._availability_topic,
+                availability_message_received, self._qos)
 
     @property
     def should_poll(self):
@@ -101,6 +136,11 @@ class MqttBinarySensor(BinarySensorDevice):
         """Return the name of the binary sensor."""
         return self._name
 
+    @property
+    def available(self) -> bool:
+        """Return if the binary sensor is available."""
+        return self._available
+
     @property
     def is_on(self):
         """Return true if the binary sensor is on."""

homeassistant/components/binary_sensor/mystrom.py

@@ -92,4 +92,4 @@ class MyStromBinarySensor(BinarySensorDevice):
     def async_on_update(self, value):
         """Receive an update."""
         self._state = value
-        self.hass.async_add_job(self.async_update_ha_state())
+        self.async_schedule_update_ha_state()

homeassistant/components/binary_sensor/netatmo.py

@@ -14,7 +14,7 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDevice, PLATFORM_SCHEMA)
 from homeassistant.components.netatmo import CameraData
 from homeassistant.loader import get_component
-from homeassistant.const import CONF_TIMEOUT, CONF_OFFSET
+from homeassistant.const import CONF_TIMEOUT
 from homeassistant.helpers import config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
@@ -44,14 +44,12 @@ CONF_WELCOME_SENSORS = 'welcome_sensors'
 CONF_PRESENCE_SENSORS = 'presence_sensors'
 CONF_TAG_SENSORS = 'tag_sensors'
 
-DEFAULT_TIMEOUT = 15
-DEFAULT_OFFSET = 90
+DEFAULT_TIMEOUT = 90
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_CAMERAS, default=[]):
         vol.All(cv.ensure_list, [cv.string]),
     vol.Optional(CONF_HOME): cv.string,
-    vol.Optional(CONF_OFFSET, default=DEFAULT_OFFSET): cv.positive_int,
     vol.Optional(CONF_PRESENCE_SENSORS, default=PRESENCE_SENSOR_TYPES):
         vol.All(cv.ensure_list, [vol.In(PRESENCE_SENSOR_TYPES)]),
     vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
@@ -66,7 +64,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     netatmo = get_component('netatmo')
     home = config.get(CONF_HOME)
     timeout = config.get(CONF_TIMEOUT)
-    offset = config.get(CONF_OFFSET)
+    if timeout is None:
+        timeout = DEFAULT_TIMEOUT
 
     module_name = None
 
@@ -94,7 +93,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             for variable in welcome_sensors:
                 add_devices([NetatmoBinarySensor(
                     data, camera_name, module_name, home, timeout,
-                    offset, camera_type, variable)], True)
+                    camera_type, variable)], True)
         if camera_type == 'NOC':
             if CONF_CAMERAS in config:
                 if config[CONF_CAMERAS] != [] and \
@@ -102,14 +101,14 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                     continue
             for variable in presence_sensors:
                 add_devices([NetatmoBinarySensor(
-                    data, camera_name, module_name, home, timeout, offset,
+                    data, camera_name, module_name, home, timeout,
                     camera_type, variable)], True)
 
         for module_name in data.get_module_names(camera_name):
             for variable in tag_sensors:
                 camera_type = None
                 add_devices([NetatmoBinarySensor(
-                    data, camera_name, module_name, home, timeout, offset,
+                    data, camera_name, module_name, home, timeout,
                     camera_type, variable)], True)
 
 
@@ -117,14 +116,13 @@ class NetatmoBinarySensor(BinarySensorDevice):
     """Represent a single binary sensor in a Netatmo Camera device."""
 
     def __init__(self, data, camera_name, module_name, home,
-                 timeout, offset, camera_type, sensor):
+                 timeout, camera_type, sensor):
         """Set up for access to the Netatmo camera events."""
         self._data = data
         self._camera_name = camera_name
         self._module_name = module_name
         self._home = home
         self._timeout = timeout
-        self._offset = offset
         if home:
             self._name = '{} / {}'.format(home, camera_name)
         else:
@@ -173,40 +171,39 @@ class NetatmoBinarySensor(BinarySensorDevice):
             if self._sensor_name == "Someone known":
                 self._state =\
                     self._data.camera_data.someoneKnownSeen(
-                        self._home, self._camera_name, self._timeout*60)
+                        self._home, self._camera_name, self._timeout)
             elif self._sensor_name == "Someone unknown":
                 self._state =\
                     self._data.camera_data.someoneUnknownSeen(
-                        self._home, self._camera_name, self._timeout*60)
+                        self._home, self._camera_name, self._timeout)
             elif self._sensor_name == "Motion":
                 self._state =\
                     self._data.camera_data.motionDetected(
-                        self._home, self._camera_name, self._timeout*60)
+                        self._home, self._camera_name, self._timeout)
         elif self._cameratype == 'NOC':
             if self._sensor_name == "Outdoor motion":
                 self._state =\
                     self._data.camera_data.outdoormotionDetected(
-                        self._home, self._camera_name, self._offset)
+                        self._home, self._camera_name, self._timeout)
             elif self._sensor_name == "Outdoor human":
                 self._state =\
                     self._data.camera_data.humanDetected(
-                        self._home, self._camera_name, self._offset)
+                        self._home, self._camera_name, self._timeout)
             elif self._sensor_name == "Outdoor animal":
                 self._state =\
                     self._data.camera_data.animalDetected(
-                        self._home, self._camera_name, self._offset)
+                        self._home, self._camera_name, self._timeout)
             elif self._sensor_name == "Outdoor vehicle":
                 self._state =\
                     self._data.camera_data.carDetected(
-                        self._home, self._camera_name, self._offset)
+                        self._home, self._camera_name, self._timeout)
         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._timeout)
         elif self._sensor_name == "Tag Open":
             self._state =\
                 self._data.camera_data.moduleOpened(
-                    self._home, self._module_name, self._camera_name)
-        else:
-            return None
+                    self._home, self._module_name, self._camera_name,
+                    self._timeout)

homeassistant/components/binary_sensor/raincloud.py

@@ -0,0 +1,72 @@
+"""
+Support for Melnor RainCloud sprinkler water timer.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.raincloud/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.raincloud import (
+    BINARY_SENSORS, DATA_RAINCLOUD, ICON_MAP, RainCloudEntity)
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import CONF_MONITORED_CONDITIONS
+
+DEPENDENCIES = ['raincloud']
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_MONITORED_CONDITIONS, default=list(BINARY_SENSORS)):
+        vol.All(cv.ensure_list, [vol.In(BINARY_SENSORS)]),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a sensor for a raincloud device."""
+    raincloud = hass.data[DATA_RAINCLOUD].data
+
+    sensors = []
+    for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
+        if sensor_type == 'status':
+            sensors.append(
+                RainCloudBinarySensor(raincloud.controller, sensor_type))
+            sensors.append(
+                RainCloudBinarySensor(raincloud.controller.faucet,
+                                      sensor_type))
+
+        else:
+            # create an sensor for each zone managed by faucet
+            for zone in raincloud.controller.faucet.zones:
+                sensors.append(RainCloudBinarySensor(zone, sensor_type))
+
+    add_devices(sensors, True)
+    return True
+
+
+class RainCloudBinarySensor(RainCloudEntity, BinarySensorDevice):
+    """A sensor implementation for raincloud device."""
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self._state
+
+    def update(self):
+        """Get the latest data and updates the state."""
+        _LOGGER.debug("Updating RainCloud sensor: %s", self._name)
+        self._state = getattr(self.data, self._sensor_type)
+        if self._sensor_type == 'status':
+            self._state = self._state == 'Online'
+
+    @property
+    def icon(self):
+        """Return the icon of this device."""
+        if self._sensor_type == 'is_watering':
+            return 'mdi:water' if self.is_on else 'mdi:water-off'
+        elif self._sensor_type == 'status':
+            return 'mdi:pipe' if self.is_on else 'mdi:pipe-disconnected'
+        return ICON_MAP.get(self._sensor_type)

homeassistant/components/binary_sensor/random.py

@@ -0,0 +1,64 @@
+"""
+Support for showing random states.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.random/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
+from homeassistant.const import CONF_NAME, CONF_DEVICE_CLASS
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Random Binary Sensor'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Random binary sensor."""
+    name = config.get(CONF_NAME)
+    device_class = config.get(CONF_DEVICE_CLASS)
+
+    async_add_devices([RandomSensor(name, device_class)], True)
+
+
+class RandomSensor(BinarySensorDevice):
+    """Representation of a Random binary sensor."""
+
+    def __init__(self, name, device_class):
+        """Initialize the Random binary sensor."""
+        self._name = name
+        self._device_class = device_class
+        self._state = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._state
+
+    @property
+    def device_class(self):
+        """Return the sensor class of the sensor."""
+        return self._device_class
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Get new state and update the sensor's state."""
+        from random import getrandbits
+        self._state = bool(getrandbits(1))

homeassistant/components/binary_sensor/rfxtrx.py

@@ -62,7 +62,6 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                                     entity[CONF_COMMAND_ON],
                                     entity[CONF_COMMAND_OFF])
         device.hass = hass
-        device.is_lighting4 = (packet_id[2:4] == '13')
         sensors.append(device)
         rfxtrx.RFX_DEVICES[device_id] = device
 
@@ -86,17 +85,16 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
             if not config[ATTR_AUTOMATIC_ADD]:
                 return
 
-            poss_dev = rfxtrx.find_possible_pt2262_device(device_id)
-
-            if poss_dev is not None:
-                poss_id = slugify(poss_dev.event.device.id_string.lower())
-                _LOGGER.info("Found possible matching deviceid %s.",
-                             poss_id)
+            if event.device.packettype == 0x13:
+                poss_dev = rfxtrx.find_possible_pt2262_device(device_id)
+                if poss_dev is not None:
+                    poss_id = slugify(poss_dev.event.device.id_string.lower())
+                    _LOGGER.info("Found possible matching deviceid %s.",
+                                 poss_id)
 
             pkt_id = "".join("{0:02x}".format(x) for x in event.data)
             sensor = RfxtrxBinarySensor(event, pkt_id)
             sensor.hass = hass
-            sensor.is_lighting4 = (pkt_id[2:4] == '13')
             rfxtrx.RFX_DEVICES[device_id] = sensor
             add_devices_callback([sensor])
             _LOGGER.info("Added binary sensor %s "
@@ -114,6 +112,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                          slugify(event.device.id_string.lower()),
                          event.device.__class__.__name__,
                          event.device.subtype)
+
         if sensor.is_lighting4:
             if sensor.data_bits is not None:
                 cmd = rfxtrx.get_pt2262_cmd(device_id, sensor.data_bits)
@@ -154,7 +153,7 @@ class RfxtrxBinarySensor(BinarySensorDevice):
         self._device_class = device_class
         self._off_delay = off_delay
         self._state = False
-        self.is_lighting4 = False
+        self.is_lighting4 = (event.device.packettype == 0x13)
         self.delay_listener = None
         self._data_bits = data_bits
         self._cmd_on = cmd_on

homeassistant/components/binary_sensor/ring.py

@@ -11,7 +11,7 @@ import voluptuous as vol
 import homeassistant.helpers.config_validation as cv
 
 from homeassistant.components.ring import (
-    CONF_ATTRIBUTION, DEFAULT_ENTITY_NAMESPACE)
+    CONF_ATTRIBUTION, DEFAULT_ENTITY_NAMESPACE, DATA_RING)
 
 from homeassistant.const import (
     ATTR_ATTRIBUTION, CONF_ENTITY_NAMESPACE, CONF_MONITORED_CONDITIONS)
@@ -28,20 +28,20 @@ SCAN_INTERVAL = timedelta(seconds=5)
 # Sensor types: Name, category, device_class
 SENSOR_TYPES = {
     'ding': ['Ding', ['doorbell'], 'occupancy'],
-    'motion': ['Motion', ['doorbell'], 'motion'],
+    'motion': ['Motion', ['doorbell', 'stickup_cams'], 'motion'],
 }
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_ENTITY_NAMESPACE, default=DEFAULT_ENTITY_NAMESPACE):
         cv.string,
-    vol.Required(CONF_MONITORED_CONDITIONS, default=[]):
+    vol.Required(CONF_MONITORED_CONDITIONS, default=list(SENSOR_TYPES)):
         vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
 })
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up a sensor for a Ring device."""
-    ring = hass.data.get('ring')
+    ring = hass.data[DATA_RING]
 
     sensors = []
     for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
@@ -50,6 +50,12 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 sensors.append(RingBinarySensor(hass,
                                                 device,
                                                 sensor_type))
+
+        for device in ring.stickup_cams:
+            if 'stickup_cams' in SENSOR_TYPES[sensor_type][1]:
+                sensors.append(RingBinarySensor(hass,
+                                                device,
+                                                sensor_type))
     add_devices(sensors, True)
     return True
 

homeassistant/components/binary_sensor/satel_integra.py

@@ -0,0 +1,90 @@
+"""
+Support for Satel Integra zone states- represented as binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.satel_integra/
+"""
+import asyncio
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.satel_integra import (CONF_ZONES,
+                                                    CONF_ZONE_NAME,
+                                                    CONF_ZONE_TYPE,
+                                                    SIGNAL_ZONES_UPDATED)
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+
+DEPENDENCIES = ['satel_integra']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Satel Integra binary sensor devices."""
+    if not discovery_info:
+        return
+
+    configured_zones = discovery_info[CONF_ZONES]
+
+    devices = []
+
+    for zone_num, device_config_data in configured_zones.items():
+        zone_type = device_config_data[CONF_ZONE_TYPE]
+        zone_name = device_config_data[CONF_ZONE_NAME]
+        device = SatelIntegraBinarySensor(zone_num, zone_name, zone_type)
+        devices.append(device)
+
+    async_add_devices(devices)
+
+
+class SatelIntegraBinarySensor(BinarySensorDevice):
+    """Representation of an Satel Integra binary sensor."""
+
+    def __init__(self, zone_number, zone_name, zone_type):
+        """Initialize the binary_sensor."""
+        self._zone_number = zone_number
+        self._name = zone_name
+        self._zone_type = zone_type
+        self._state = 0
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Register callbacks."""
+        async_dispatcher_connect(
+            self.hass, SIGNAL_ZONES_UPDATED, self._zones_updated)
+
+    @property
+    def name(self):
+        """Return the name of the entity."""
+        return self._name
+
+    @property
+    def icon(self):
+        """Icon for device by its type."""
+        if self._zone_type == 'smoke':
+            return "mdi:fire"
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._state == 1
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor, from DEVICE_CLASSES."""
+        return self._zone_type
+
+    @callback
+    def _zones_updated(self, zones):
+        """Update the zone's state, if needed."""
+        if self._zone_number in zones \
+                and self._state != zones[self._zone_number]:
+            self._state = zones[self._zone_number]
+            self.async_schedule_update_ha_state()

homeassistant/components/binary_sensor/skybell.py

@@ -0,0 +1,97 @@
+"""
+Binary sensor support for the Skybell HD Doorbell.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.skybell/
+"""
+from datetime import timedelta
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.skybell import (
+    DEFAULT_ENTITY_NAMESPACE, DOMAIN as SKYBELL_DOMAIN, SkybellDevice)
+from homeassistant.const import (
+    CONF_ENTITY_NAMESPACE, CONF_MONITORED_CONDITIONS)
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['skybell']
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(seconds=5)
+
+# Sensor types: Name, device_class, event
+SENSOR_TYPES = {
+    'button': ['Button', 'occupancy', 'device:sensor:button'],
+    'motion': ['Motion', 'motion', 'device:sensor:motion'],
+}
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_ENTITY_NAMESPACE, default=DEFAULT_ENTITY_NAMESPACE):
+        cv.string,
+    vol.Required(CONF_MONITORED_CONDITIONS, default=[]):
+        vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the platform for a Skybell device."""
+    skybell = hass.data.get(SKYBELL_DOMAIN)
+
+    sensors = []
+    for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
+        for device in skybell.get_devices():
+            sensors.append(SkybellBinarySensor(device, sensor_type))
+
+    add_devices(sensors, True)
+
+
+class SkybellBinarySensor(SkybellDevice, BinarySensorDevice):
+    """A binary sensor implementation for Skybell devices."""
+
+    def __init__(self, device, sensor_type):
+        """Initialize a binary sensor for a Skybell device."""
+        super().__init__(device)
+        self._sensor_type = sensor_type
+        self._name = "{0} {1}".format(self._device.name,
+                                      SENSOR_TYPES[self._sensor_type][0])
+        self._device_class = SENSOR_TYPES[self._sensor_type][1]
+        self._event = {}
+        self._state = None
+
+    @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
+
+    @property
+    def device_class(self):
+        """Return the class of the binary sensor."""
+        return self._device_class
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = super().device_state_attributes
+
+        attrs['event_date'] = self._event.get('createdAt')
+
+        return attrs
+
+    def update(self):
+        """Get the latest data and updates the state."""
+        super().update()
+
+        event = self._device.latest(SENSOR_TYPES[self._sensor_type][2])
+
+        self._state = bool(event and event.get('id') != self._event.get('id'))
+
+        self._event = event

homeassistant/components/binary_sensor/spc.py

@@ -41,14 +41,14 @@ def _create_sensor(hass, zone):
 
 
 @asyncio.coroutine
-def async_setup_platform(hass, config, async_add_entities,
+def async_setup_platform(hass, config, async_add_devices,
                          discovery_info=None):
     """Initialize the platform."""
     if (discovery_info is None or
             discovery_info[ATTR_DISCOVER_DEVICES] is None):
         return
 
-    async_add_entities(
+    async_add_devices(
         _create_sensor(hass, zone)
         for zone in discovery_info[ATTR_DISCOVER_DEVICES]
         if _get_device_class(zone['type']))
@@ -67,7 +67,7 @@ class SpcBinarySensor(BinarySensorDevice):
         spc_registry.register_sensor_device(zone_id, self)
 
     @asyncio.coroutine
-    def async_update_from_spc(self, state):
+    def async_update_from_spc(self, state, extra):
         """Update the state of the device."""
         self._state = state
         yield from self.async_update_ha_state()

homeassistant/components/binary_sensor/tellduslive.py

@@ -0,0 +1,34 @@
+"""
+Support for binary sensors using Tellstick Net.
+
+This platform uses the Telldus Live online service.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.tellduslive/
+
+"""
+import logging
+
+from homeassistant.components.tellduslive import TelldusLiveEntity
+from homeassistant.components.binary_sensor import BinarySensorDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Tellstick sensors."""
+    if discovery_info is None:
+        return
+    add_devices(
+        TelldusLiveSensor(hass, binary_sensor)
+        for binary_sensor in discovery_info
+    )
+
+
+class TelldusLiveSensor(TelldusLiveEntity, BinarySensorDevice):
+    """Representation of a Tellstick sensor."""
+
+    @property
+    def is_on(self):
+        """Return true if switch is on."""
+        return self.device.is_on

homeassistant/components/binary_sensor/template.py

@@ -15,13 +15,12 @@ from homeassistant.components.binary_sensor import (
     DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
     ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_VALUE_TEMPLATE,
-    CONF_SENSORS, CONF_DEVICE_CLASS, EVENT_HOMEASSISTANT_START, STATE_ON)
+    CONF_SENSORS, CONF_DEVICE_CLASS, EVENT_HOMEASSISTANT_START)
 from homeassistant.exceptions import TemplateError
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.event import (
     async_track_state_change, async_track_same_state)
-from homeassistant.helpers.restore_state import async_get_last_state
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -94,10 +93,6 @@ class BinarySensorTemplate(BinarySensorDevice):
     @asyncio.coroutine
     def async_added_to_hass(self):
         """Register callbacks."""
-        state = yield from async_get_last_state(self.hass, self.entity_id)
-        if state:
-            self._state = state.state == STATE_ON
-
         @callback
         def template_bsensor_state_listener(entity, old_state, new_state):
             """Handle the target device state changes."""
@@ -135,7 +130,7 @@ class BinarySensorTemplate(BinarySensorDevice):
         return False
 
     @callback
-    def _async_render(self, *args):
+    def _async_render(self):
         """Get the state of template."""
         try:
             return self._template.async_render().lower() == 'true'
@@ -161,7 +156,7 @@ class BinarySensorTemplate(BinarySensorDevice):
         def set_state():
             """Set state of template binary sensor."""
             self._state = state
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()
 
         # state without delay
         if (state and not self._delay_on) or \
@@ -171,5 +166,5 @@ class BinarySensorTemplate(BinarySensorDevice):
 
         period = self._delay_on if state else self._delay_off
         async_track_same_state(
-            self.hass, state, period, set_state, entity_ids=self._entities,
-            async_check_func=self._async_render)
+            self.hass, period, set_state, entity_ids=self._entities,
+            async_check_same_func=lambda *args: self._async_render() == state)

homeassistant/components/binary_sensor/tesla.py

@@ -30,7 +30,6 @@ class TeslaBinarySensor(TeslaDevice, BinarySensorDevice):
     def __init__(self, tesla_device, controller, sensor_type):
         """Initialisation of binary sensor."""
         super().__init__(tesla_device, controller)
-        self._name = self.tesla_device.name
         self._state = False
         self.entity_id = ENTITY_ID_FORMAT.format(self.tesla_id)
         self._sensor_type = sensor_type

homeassistant/components/binary_sensor/threshold.py

@@ -20,15 +20,18 @@ from homeassistant.helpers.event import async_track_state_change
 
 _LOGGER = logging.getLogger(__name__)
 
+ATTR_HYSTERESIS = 'hysteresis'
 ATTR_SENSOR_VALUE = 'sensor_value'
 ATTR_THRESHOLD = 'threshold'
 ATTR_TYPE = 'type'
 
+CONF_HYSTERESIS = 'hysteresis'
 CONF_LOWER = 'lower'
 CONF_THRESHOLD = 'threshold'
 CONF_UPPER = 'upper'
 
 DEFAULT_NAME = 'Threshold'
+DEFAULT_HYSTERESIS = 0.0
 
 SENSOR_TYPES = [CONF_LOWER, CONF_UPPER]
 
@@ -36,6 +39,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_ENTITY_ID): cv.entity_id,
     vol.Required(CONF_THRESHOLD): vol.Coerce(float),
     vol.Required(CONF_TYPE): vol.In(SENSOR_TYPES),
+    vol.Optional(
+        CONF_HYSTERESIS, default=DEFAULT_HYSTERESIS): vol.Coerce(float),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })
@@ -47,28 +52,32 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     entity_id = config.get(CONF_ENTITY_ID)
     name = config.get(CONF_NAME)
     threshold = config.get(CONF_THRESHOLD)
+    hysteresis = config.get(CONF_HYSTERESIS)
     limit_type = config.get(CONF_TYPE)
     device_class = config.get(CONF_DEVICE_CLASS)
 
-    async_add_devices(
-        [ThresholdSensor(hass, entity_id, name, threshold, limit_type,
-                         device_class)], True)
+    async_add_devices([ThresholdSensor(
+        hass, entity_id, name, threshold,
+        hysteresis, limit_type, device_class)
+                      ], True)
+
     return True
 
 
 class ThresholdSensor(BinarySensorDevice):
     """Representation of a Threshold sensor."""
 
-    def __init__(self, hass, entity_id, name, threshold, limit_type,
-                 device_class):
+    def __init__(self, hass, entity_id, name, threshold,
+                 hysteresis, limit_type, device_class):
         """Initialize the Threshold sensor."""
         self._hass = hass
         self._entity_id = entity_id
         self.is_upper = limit_type == 'upper'
         self._name = name
         self._threshold = threshold
+        self._hysteresis = hysteresis
         self._device_class = device_class
-        self._deviation = False
+        self._state = False
         self.sensor_value = 0
 
         @callback
@@ -97,7 +106,7 @@ class ThresholdSensor(BinarySensorDevice):
     @property
     def is_on(self):
         """Return true if sensor is on."""
-        return self._deviation
+        return self._state
 
     @property
     def should_poll(self):
@@ -116,13 +125,16 @@ class ThresholdSensor(BinarySensorDevice):
             ATTR_ENTITY_ID: self._entity_id,
             ATTR_SENSOR_VALUE: self.sensor_value,
             ATTR_THRESHOLD: self._threshold,
+            ATTR_HYSTERESIS: self._hysteresis,
             ATTR_TYPE: CONF_UPPER if self.is_upper else CONF_LOWER,
         }
 
     @asyncio.coroutine
     def async_update(self):
         """Get the latest data and updates the states."""
-        if self.is_upper:
-            self._deviation = bool(self.sensor_value > self._threshold)
-        else:
-            self._deviation = bool(self.sensor_value < self._threshold)
+        if self._hysteresis == 0 and self.sensor_value == self._threshold:
+            self._state = False
+        elif self.sensor_value > (self._threshold + self._hysteresis):
+            self._state = self.is_upper
+        elif self.sensor_value < (self._threshold - self._hysteresis):
+            self._state = not self.is_upper

homeassistant/components/binary_sensor/trend.py

@@ -1,11 +1,13 @@
 """
-A sensor that monitors trands in other components.
+A sensor that monitors trends in other components.
 
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/sensor.trend/
 """
 import asyncio
+from collections import deque
 import logging
+import math
 
 import voluptuous as vol
 
@@ -16,21 +18,40 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDevice, ENTITY_ID_FORMAT, PLATFORM_SCHEMA,
     DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_DEVICE_CLASS, STATE_UNKNOWN)
+    ATTR_ENTITY_ID, ATTR_FRIENDLY_NAME,
+    CONF_DEVICE_CLASS, CONF_ENTITY_ID, CONF_FRIENDLY_NAME,
+    STATE_UNKNOWN)
 from homeassistant.helpers.entity import generate_entity_id
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.event import async_track_state_change
+from homeassistant.util import utcnow
+
+REQUIREMENTS = ['numpy==1.13.3']
 
 _LOGGER = logging.getLogger(__name__)
+
+ATTR_ATTRIBUTE = 'attribute'
+ATTR_GRADIENT = 'gradient'
+ATTR_MIN_GRADIENT = 'min_gradient'
+ATTR_INVERT = 'invert'
+ATTR_SAMPLE_DURATION = 'sample_duration'
+ATTR_SAMPLE_COUNT = 'sample_count'
+
 CONF_SENSORS = 'sensors'
 CONF_ATTRIBUTE = 'attribute'
+CONF_MAX_SAMPLES = 'max_samples'
+CONF_MIN_GRADIENT = 'min_gradient'
 CONF_INVERT = 'invert'
+CONF_SAMPLE_DURATION = 'sample_duration'
 
 SENSOR_SCHEMA = vol.Schema({
-    vol.Required(ATTR_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
     vol.Optional(CONF_ATTRIBUTE): cv.string,
-    vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
-    vol.Optional(CONF_INVERT, default=False): cv.boolean,
     vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_FRIENDLY_NAME): cv.string,
+    vol.Optional(CONF_MAX_SAMPLES, default=2): cv.positive_int,
+    vol.Optional(CONF_MIN_GRADIENT, default=0.0): vol.Coerce(float),
+    vol.Optional(CONF_INVERT, default=False): cv.boolean,
+    vol.Optional(CONF_SAMPLE_DURATION, default=0): cv.positive_int,
 })
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -43,17 +64,21 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the trend sensors."""
     sensors = []
 
-    for device, device_config in config[CONF_SENSORS].items():
+    for device_id, device_config in config[CONF_SENSORS].items():
         entity_id = device_config[ATTR_ENTITY_ID]
         attribute = device_config.get(CONF_ATTRIBUTE)
-        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
         device_class = device_config.get(CONF_DEVICE_CLASS)
+        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device_id)
         invert = device_config[CONF_INVERT]
+        max_samples = device_config[CONF_MAX_SAMPLES]
+        min_gradient = device_config[CONF_MIN_GRADIENT]
+        sample_duration = device_config[CONF_SAMPLE_DURATION]
 
         sensors.append(
             SensorTrend(
-                hass, device, friendly_name, entity_id, attribute,
-                device_class, invert)
+                hass, device_id, friendly_name, entity_id, attribute,
+                device_class, invert, max_samples, min_gradient,
+                sample_duration)
             )
     if not sensors:
         _LOGGER.error("No sensors added")
@@ -65,30 +90,23 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class SensorTrend(BinarySensorDevice):
     """Representation of a trend Sensor."""
 
-    def __init__(self, hass, device_id, friendly_name,
-                 target_entity, attribute, device_class, invert):
+    def __init__(self, hass, device_id, friendly_name, entity_id,
+                 attribute, device_class, invert, max_samples,
+                 min_gradient, sample_duration):
         """Initialize the sensor."""
         self._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._entity_id = entity_id
         self._attribute = attribute
         self._device_class = device_class
         self._invert = invert
+        self._sample_duration = sample_duration
+        self._min_gradient = min_gradient
+        self._gradient = None
         self._state = None
-        self.from_state = None
-        self.to_state = None
-
-        @callback
-        def trend_sensor_state_listener(entity, old_state, new_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))
-
-        track_state_change(hass, target_entity,
-                           trend_sensor_state_listener)
+        self.samples = deque(maxlen=max_samples)
 
     @property
     def name(self):
@@ -105,33 +123,77 @@ class SensorTrend(BinarySensorDevice):
         """Return the sensor class of the sensor."""
         return self._device_class
 
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        return {
+            ATTR_ENTITY_ID: self._entity_id,
+            ATTR_FRIENDLY_NAME: self._name,
+            ATTR_INVERT: self._invert,
+            ATTR_GRADIENT: self._gradient,
+            ATTR_MIN_GRADIENT: self._min_gradient,
+            ATTR_SAMPLE_DURATION: self._sample_duration,
+            ATTR_SAMPLE_COUNT: len(self.samples),
+        }
+
     @property
     def should_poll(self):
         """No polling needed."""
         return False
 
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Complete device setup after being added to hass."""
+        @callback
+        def trend_sensor_state_listener(entity, old_state, new_state):
+            """Handle state changes on the observed device."""
+            try:
+                if self._attribute:
+                    state = new_state.attributes.get(self._attribute)
+                else:
+                    state = new_state.state
+                if state != STATE_UNKNOWN:
+                    sample = (utcnow().timestamp(), float(state))
+                    self.samples.append(sample)
+                    self.async_schedule_update_ha_state(True)
+            except (ValueError, TypeError) as ex:
+                _LOGGER.error(ex)
+
+        async_track_state_change(
+            self.hass, self._entity_id,
+            trend_sensor_state_listener)
+
     @asyncio.coroutine
     def async_update(self):
         """Get the latest data and update the states."""
-        if self.from_state is None or self.to_state is None:
-            return
-        if (self.from_state.state == STATE_UNKNOWN or
-                self.to_state.state == STATE_UNKNOWN):
-            return
-        try:
-            if self._attribute:
-                from_value = float(
-                    self.from_state.attributes.get(self._attribute))
-                to_value = float(
-                    self.to_state.attributes.get(self._attribute))
-            else:
-                from_value = float(self.from_state.state)
-                to_value = float(self.to_state.state)
+        # Remove outdated samples
+        if self._sample_duration > 0:
+            cutoff = utcnow().timestamp() - self._sample_duration
+            while self.samples and self.samples[0][0] < cutoff:
+                self.samples.popleft()
 
-            self._state = to_value > from_value
-            if self._invert:
-                self._state = not self._state
+        if len(self.samples) < 2:
+            return
 
-        except (ValueError, TypeError) as ex:
-            self._state = None
-            _LOGGER.error(ex)
+        # Calculate gradient of linear trend
+        yield from self.hass.async_add_job(self._calculate_gradient)
+
+        # Update state
+        self._state = (
+            abs(self._gradient) > abs(self._min_gradient) and
+            math.copysign(self._gradient, self._min_gradient) == self._gradient
+        )
+
+        if self._invert:
+            self._state = not self._state
+
+    def _calculate_gradient(self):
+        """Compute the linear trend gradient of the current samples.
+
+        This need run inside executor.
+        """
+        import numpy as np
+        timestamps = np.array([t for t, _ in self.samples])
+        values = np.array([s for _, s in self.samples])
+        coeffs = np.polyfit(timestamps, values, 1)
+        self._gradient = coeffs[0]

homeassistant/components/binary_sensor/vultr.py

@@ -0,0 +1,103 @@
+"""
+Support for monitoring the state of Vultr subscriptions (VPS).
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.vultr/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import CONF_NAME
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.vultr import (
+    CONF_SUBSCRIPTION, ATTR_AUTO_BACKUPS, ATTR_ALLOWED_BANDWIDTH,
+    ATTR_CREATED_AT, ATTR_SUBSCRIPTION_ID, ATTR_SUBSCRIPTION_NAME,
+    ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY, ATTR_DISK,
+    ATTR_COST_PER_MONTH, ATTR_OS, ATTR_REGION, ATTR_VCPUS, DATA_VULTR)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_DEVICE_CLASS = 'power'
+DEFAULT_NAME = 'Vultr {}'
+DEPENDENCIES = ['vultr']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_SUBSCRIPTION): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Vultr subscription (server) sensor."""
+    vultr = hass.data[DATA_VULTR]
+
+    subscription = config.get(CONF_SUBSCRIPTION)
+    name = config.get(CONF_NAME)
+
+    if subscription not in vultr.data:
+        _LOGGER.error("Subscription %s not found", subscription)
+        return False
+
+    add_devices([VultrBinarySensor(vultr, subscription, name)], True)
+
+
+class VultrBinarySensor(BinarySensorDevice):
+    """Representation of a Vultr subscription sensor."""
+
+    def __init__(self, vultr, subscription, name):
+        """Initialize a new Vultr sensor."""
+        self._vultr = vultr
+        self._name = name
+
+        self.subscription = subscription
+        self.data = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        try:
+            return self._name.format(self.data['label'])
+        except (KeyError, TypeError):
+            return self._name
+
+    @property
+    def icon(self):
+        """Return the icon of this server."""
+        return 'mdi:server' if self.is_on else 'mdi:server-off'
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.data['power_status'] == 'running'
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_DEVICE_CLASS
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the Vultr subscription."""
+        return {
+            ATTR_ALLOWED_BANDWIDTH: self.data.get('allowed_bandwidth_gb'),
+            ATTR_AUTO_BACKUPS: self.data.get('auto_backups'),
+            ATTR_COST_PER_MONTH: self.data.get('cost_per_month'),
+            ATTR_CREATED_AT: self.data.get('date_created'),
+            ATTR_DISK: self.data.get('disk'),
+            ATTR_IPV4_ADDRESS: self.data.get('main_ip'),
+            ATTR_IPV6_ADDRESS: self.data.get('v6_main_ip'),
+            ATTR_MEMORY: self.data.get('ram'),
+            ATTR_OS: self.data.get('os'),
+            ATTR_REGION: self.data.get('location'),
+            ATTR_SUBSCRIPTION_ID: self.data.get('SUBID'),
+            ATTR_SUBSCRIPTION_NAME: self.data.get('label'),
+            ATTR_VCPUS: self.data.get('vcpu_count')
+        }
+
+    def update(self):
+        """Update state of sensor."""
+        self._vultr.update()
+        self.data = self._vultr.data[self.subscription]

homeassistant/components/binary_sensor/wink.py

@@ -9,7 +9,6 @@ import logging
 
 from homeassistant.components.binary_sensor import BinarySensorDevice
 from homeassistant.components.wink import WinkDevice, DOMAIN
-from homeassistant.helpers.entity import Entity
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -87,7 +86,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 _LOGGER.info("Device isn't a sensor, skipping")
 
 
-class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
+class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice):
     """Representation of a Wink binary sensor."""
 
     def __init__(self, wink, hass):
@@ -117,6 +116,11 @@ class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
         """Return the class of this sensor, from DEVICE_CLASSES."""
         return SENSOR_TYPES.get(self.capability)
 
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return super().device_state_attributes
+
 
 class WinkSmokeDetector(WinkBinarySensorDevice):
     """Representation of a Wink Smoke detector."""
@@ -124,9 +128,9 @@ class WinkSmokeDetector(WinkBinarySensorDevice):
     @property
     def device_state_attributes(self):
         """Return the state attributes."""
-        return {
-            'test_activated': self.wink.test_activated()
-        }
+        _attributes = super().device_state_attributes
+        _attributes['test_activated'] = self.wink.test_activated()
+        return _attributes
 
 
 class WinkHub(WinkBinarySensorDevice):
@@ -135,10 +139,11 @@ class WinkHub(WinkBinarySensorDevice):
     @property
     def device_state_attributes(self):
         """Return the state attributes."""
-        return {
-            'update needed': self.wink.update_needed(),
-            'firmware version': self.wink.firmware_version()
-        }
+        _attributes = super().device_state_attributes
+        _attributes['update_needed'] = self.wink.update_needed()
+        _attributes['firmware_version'] = self.wink.firmware_version()
+        _attributes['pairing_mode'] = self.wink.pairing_mode()
+        return _attributes
 
 
 class WinkRemote(WinkBinarySensorDevice):
@@ -147,12 +152,12 @@ class WinkRemote(WinkBinarySensorDevice):
     @property
     def device_state_attributes(self):
         """Return the state attributes."""
-        return {
-            'button_on_pressed': self.wink.button_on_pressed(),
-            'button_off_pressed': self.wink.button_off_pressed(),
-            'button_up_pressed': self.wink.button_up_pressed(),
-            'button_down_pressed': self.wink.button_down_pressed()
-        }
+        _attributes = super().device_state_attributes
+        _attributes['button_on_pressed'] = self.wink.button_on_pressed()
+        _attributes['button_off_pressed'] = self.wink.button_off_pressed()
+        _attributes['button_up_pressed'] = self.wink.button_up_pressed()
+        _attributes['button_down_pressed'] = self.wink.button_down_pressed()
+        return _attributes
 
     @property
     def device_class(self):
@@ -166,10 +171,10 @@ class WinkButton(WinkBinarySensorDevice):
     @property
     def device_state_attributes(self):
         """Return the state attributes."""
-        return {
-            'pressed': self.wink.pressed(),
-            'long_pressed': self.wink.long_pressed()
-        }
+        _attributes = super().device_state_attributes
+        _attributes['pressed'] = self.wink.pressed()
+        _attributes['long_pressed'] = self.wink.long_pressed()
+        return _attributes
 
 
 class WinkGang(WinkBinarySensorDevice):

homeassistant/components/binary_sensor/xiaomi_aqara.py

@@ -1,8 +1,9 @@
-"""Support for Xiaomi binary sensors."""
+"""Support for Xiaomi aqara binary sensors."""
 import logging
 
 from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.xiaomi import (PY_XIAOMI_GATEWAY, XiaomiDevice)
+from homeassistant.components.xiaomi_aqara import (PY_XIAOMI_GATEWAY,
+                                                   XiaomiDevice)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -11,6 +12,7 @@ ATTR_OPEN_SINCE = 'Open since'
 
 MOTION = 'motion'
 NO_MOTION = 'no_motion'
+ATTR_LAST_ACTION = 'last_action'
 ATTR_NO_MOTION_SINCE = 'No motion since'
 
 DENSITY = 'density'
@@ -23,13 +25,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     for (_, gateway) in hass.data[PY_XIAOMI_GATEWAY].gateways.items():
         for device in gateway.devices['binary_sensor']:
             model = device['model']
-            if model == 'motion':
+            if model in ['motion', 'sensor_motion.aq2']:
                 devices.append(XiaomiMotionSensor(device, hass, gateway))
-            elif model == 'sensor_motion.aq2':
-                devices.append(XiaomiMotionSensor(device, hass, gateway))
-            elif model == 'magnet':
-                devices.append(XiaomiDoorSensor(device, gateway))
-            elif model == 'sensor_magnet.aq2':
+            elif model in ['magnet', 'sensor_magnet.aq2']:
                 devices.append(XiaomiDoorSensor(device, gateway))
             elif model == 'sensor_wleak.aq1':
                 devices.append(XiaomiWaterLeakSensor(device, gateway))
@@ -37,10 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 devices.append(XiaomiSmokeSensor(device, gateway))
             elif model == 'natgas':
                 devices.append(XiaomiNatgasSensor(device, gateway))
-            elif model == 'switch':
-                devices.append(XiaomiButton(device, 'Switch', 'status',
-                                            hass, gateway))
-            elif model == 'sensor_switch.aq2':
+            elif model in ['switch', 'sensor_switch.aq2', 'sensor_switch.aq3']:
                 devices.append(XiaomiButton(device, 'Switch', 'status',
                                             hass, gateway))
             elif model == '86sw1':
@@ -287,9 +282,17 @@ class XiaomiButton(XiaomiBinarySensor):
     def __init__(self, device, name, data_key, hass, xiaomi_hub):
         """Initialize the XiaomiButton."""
         self._hass = hass
+        self._last_action = None
         XiaomiBinarySensor.__init__(self, device, name, xiaomi_hub,
                                     data_key, None)
 
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_LAST_ACTION: self._last_action}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
     def parse_data(self, data):
         """Parse data sent by gateway."""
         value = data.get(self._data_key)
@@ -315,6 +318,8 @@ class XiaomiButton(XiaomiBinarySensor):
             'entity_id': self.entity_id,
             'click_type': click_type
         })
+        self._last_action = click_type
+
         if value in ['long_click_press', 'long_click_release']:
             return True
         return False
@@ -326,10 +331,18 @@ class XiaomiCube(XiaomiBinarySensor):
     def __init__(self, device, hass, xiaomi_hub):
         """Initialize the Xiaomi Cube."""
         self._hass = hass
+        self._last_action = None
         self._state = False
         XiaomiBinarySensor.__init__(self, device, 'Cube', xiaomi_hub,
                                     None, None)
 
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_LAST_ACTION: self._last_action}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
     def parse_data(self, data):
         """Parse data sent by gateway."""
         if 'status' in data:
@@ -337,6 +350,7 @@ class XiaomiCube(XiaomiBinarySensor):
                 'entity_id': self.entity_id,
                 'action_type': data['status']
             })
+            self._last_action = data['status']
 
         if 'rotate' in data:
             self._hass.bus.fire('cube_action', {
@@ -344,4 +358,6 @@ class XiaomiCube(XiaomiBinarySensor):
                 'action_type': 'rotate',
                 'action_value': float(data['rotate'].replace(",", "."))
             })
-        return False
+            self._last_action = 'rotate'
+
+        return True

homeassistant/components/bloomsky.py

@@ -4,16 +4,17 @@ Support for BloomSky weather station.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/bloomsky/
 """
-import logging
 from datetime import timedelta
+import logging
 
+from aiohttp.hdrs import AUTHORIZATION
 import requests
 import voluptuous as vol
 
 from homeassistant.const import CONF_API_KEY
 from homeassistant.helpers import discovery
-from homeassistant.util import Throttle
 import homeassistant.helpers.config_validation as cv
+from homeassistant.util import Throttle
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -68,7 +69,7 @@ class BloomSky(object):
         """Use the API to retrieve a list of devices."""
         _LOGGER.debug("Fetching BloomSky update")
         response = requests.get(
-            self.API_URL, headers={"Authorization": self._api_key}, timeout=10)
+            self.API_URL, headers={AUTHORIZATION: self._api_key}, timeout=10)
         if response.status_code == 401:
             raise RuntimeError("Invalid API_KEY")
         elif response.status_code != 200:

homeassistant/components/calendar/__init__.py

@@ -12,6 +12,7 @@ import re
 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 PLATFORM_SCHEMA  # noqa
 from homeassistant.helpers.config_validation import time_period_str
 from homeassistant.helpers.entity import Entity, generate_entity_id
 from homeassistant.helpers.entity_component import EntityComponent

homeassistant/components/calendar/services.yaml

@@ -0,0 +1,21 @@
+# Describes the format for available calendar services
+
+todoist:
+  new_task:
+    description: Create a new task and add it to a project.
+    fields:
+      content: 
+        description: The name of the task (Required).
+        example: Pick up the mail
+      project:
+        description: The name of the project this task should belong to. Defaults to Inbox (Optional).
+        example: Errands
+      labels:
+        description: Any labels that you want to apply to this task, separated by a comma (Optional).
+        example: Chores,Deliveries
+      priority:
+        description: The priority of this task, from 1 (normal) to 4 (urgent) (Optional).
+        example: 2
+      due_date:
+        description: The day this task is due, in format YYYY-MM-DD (Optional).
+        example: "2018-04-01"

homeassistant/components/calendar/todoist.py

@@ -0,0 +1,544 @@
+"""
+Support for Todoist task management (https://todoist.com).
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/calendar.todoist/
+"""
+
+
+from datetime import datetime
+from datetime import timedelta
+import logging
+import os
+
+import voluptuous as vol
+
+from homeassistant.components.calendar import (
+    CalendarEventDevice, PLATFORM_SCHEMA)
+from homeassistant.components.google import (
+    CONF_DEVICE_ID)
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (
+    CONF_ID, CONF_NAME, CONF_TOKEN)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.template import DATE_STR_FORMAT
+from homeassistant.util import dt
+from homeassistant.util import Throttle
+
+REQUIREMENTS = ['todoist-python==7.0.17']
+
+_LOGGER = logging.getLogger(__name__)
+DOMAIN = 'todoist'
+
+# Calendar Platform: Does this calendar event last all day?
+ALL_DAY = 'all_day'
+# Attribute: All tasks in this project
+ALL_TASKS = 'all_tasks'
+# Todoist API: "Completed" flag -- 1 if complete, else 0
+CHECKED = 'checked'
+# Attribute: Is this task complete?
+COMPLETED = 'completed'
+# Todoist API: What is this task about?
+# Service Call: What is this task about?
+CONTENT = 'content'
+# Calendar Platform: Get a calendar event's description
+DESCRIPTION = 'description'
+# Calendar Platform: Used in the '_get_date()' method
+DATETIME = 'dateTime'
+# Attribute: When is this task due?
+# Service Call: When is this task due?
+DUE_DATE = 'due_date'
+# Todoist API: Look up a task's due date
+DUE_DATE_UTC = 'due_date_utc'
+# Attribute: Is this task due today?
+DUE_TODAY = 'due_today'
+# Calendar Platform: When a calendar event ends
+END = 'end'
+# Todoist API: Look up a Project/Label/Task ID
+ID = 'id'
+# Todoist API: Fetch all labels
+# Service Call: What are the labels attached to this task?
+LABELS = 'labels'
+# Todoist API: "Name" value
+NAME = 'name'
+# Attribute: Is this task overdue?
+OVERDUE = 'overdue'
+# Attribute: What is this task's priority?
+# Todoist API: Get a task's priority
+# Service Call: What is this task's priority?
+PRIORITY = 'priority'
+# Todoist API: Look up the Project ID a Task belongs to
+PROJECT_ID = 'project_id'
+# Service Call: What Project do you want a Task added to?
+PROJECT_NAME = 'project'
+# Todoist API: Fetch all Projects
+PROJECTS = 'projects'
+# Calendar Platform: When does a calendar event start?
+START = 'start'
+# Calendar Platform: What is the next calendar event about?
+SUMMARY = 'summary'
+# Todoist API: Fetch all Tasks
+TASKS = 'items'
+
+SERVICE_NEW_TASK = 'new_task'
+NEW_TASK_SERVICE_SCHEMA = vol.Schema({
+    vol.Required(CONTENT): cv.string,
+    vol.Optional(PROJECT_NAME, default='inbox'): vol.All(cv.string, vol.Lower),
+    vol.Optional(LABELS): cv.ensure_list_csv,
+    vol.Optional(PRIORITY): vol.All(vol.Coerce(int),
+                                    vol.Range(min=1, max=4)),
+    vol.Optional(DUE_DATE): cv.string
+})
+
+CONF_EXTRA_PROJECTS = 'custom_projects'
+CONF_PROJECT_DUE_DATE = 'due_date_days'
+CONF_PROJECT_WHITELIST = 'include_projects'
+CONF_PROJECT_LABEL_WHITELIST = 'labels'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_TOKEN): cv.string,
+    vol.Optional(CONF_EXTRA_PROJECTS, default=[]):
+        vol.All(cv.ensure_list, vol.Schema([
+            vol.Schema({
+                vol.Required(CONF_NAME): cv.string,
+                vol.Optional(CONF_PROJECT_DUE_DATE): vol.Coerce(int),
+                vol.Optional(CONF_PROJECT_WHITELIST, default=[]):
+                    vol.All(cv.ensure_list, [vol.All(cv.string, vol.Lower)]),
+                vol.Optional(CONF_PROJECT_LABEL_WHITELIST, default=[]):
+                    vol.All(cv.ensure_list, [vol.All(cv.string, vol.Lower)])
+            })
+        ]))
+})
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=15)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Todoist platform."""
+    # Check token:
+    token = config.get(CONF_TOKEN)
+
+    # Look up IDs based on (lowercase) names.
+    project_id_lookup = {}
+    label_id_lookup = {}
+
+    from todoist.api import TodoistAPI
+    api = TodoistAPI(token)
+    api.sync()
+
+    # Setup devices:
+    # Grab all projects.
+    projects = api.state[PROJECTS]
+
+    # Grab all labels
+    labels = api.state[LABELS]
+
+    # Add all Todoist-defined projects.
+    project_devices = []
+    for project in projects:
+        # Project is an object, not a dict!
+        # Because of that, we convert what we need to a dict.
+        project_data = {
+            CONF_NAME: project[NAME],
+            CONF_ID: project[ID]
+        }
+        project_devices.append(
+            TodoistProjectDevice(hass, project_data, labels, api)
+        )
+        # Cache the names so we can easily look up name->ID.
+        project_id_lookup[project[NAME].lower()] = project[ID]
+
+    # Cache all label names
+    for label in labels:
+        label_id_lookup[label[NAME].lower()] = label[ID]
+
+    # Check config for more projects.
+    extra_projects = config.get(CONF_EXTRA_PROJECTS)
+    for project in extra_projects:
+        # Special filter: By date
+        project_due_date = project.get(CONF_PROJECT_DUE_DATE)
+
+        # Special filter: By label
+        project_label_filter = project.get(CONF_PROJECT_LABEL_WHITELIST)
+
+        # Special filter: By name
+        # Names must be converted into IDs.
+        project_name_filter = project.get(CONF_PROJECT_WHITELIST)
+        project_id_filter = [
+            project_id_lookup[project_name.lower()]
+            for project_name in project_name_filter]
+
+        # Create the custom project and add it to the devices array.
+        project_devices.append(
+            TodoistProjectDevice(
+                hass, project, labels, api, project_due_date,
+                project_label_filter, project_id_filter
+            )
+        )
+
+    add_devices(project_devices)
+
+    # Services:
+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+
+    def handle_new_task(call):
+        """Called when a user creates a new Todoist Task from HASS."""
+        project_name = call.data[PROJECT_NAME]
+        project_id = project_id_lookup[project_name]
+
+        # Create the task
+        item = api.items.add(call.data[CONTENT], project_id)
+
+        if LABELS in call.data:
+            task_labels = call.data[LABELS]
+            label_ids = [
+                label_id_lookup[label.lower()]
+                for label in task_labels]
+            item.update(labels=label_ids)
+
+        if PRIORITY in call.data:
+            item.update(priority=call.data[PRIORITY])
+
+        if DUE_DATE in call.data:
+            due_date = dt.parse_datetime(call.data[DUE_DATE])
+            if due_date is None:
+                due = dt.parse_date(call.data[DUE_DATE])
+                due_date = datetime(due.year, due.month, due.day)
+            # Format it in the manner Todoist expects
+            due_date = dt.as_utc(due_date)
+            date_format = '%Y-%m-%dT%H:%M'
+            due_date = datetime.strftime(due_date, date_format)
+            item.update(due_date_utc=due_date)
+        # Commit changes
+        api.commit()
+        _LOGGER.debug("Created Todoist task: %s", call.data[CONTENT])
+
+    hass.services.register(DOMAIN, SERVICE_NEW_TASK, handle_new_task,
+                           descriptions[DOMAIN][SERVICE_NEW_TASK],
+                           schema=NEW_TASK_SERVICE_SCHEMA)
+
+
+class TodoistProjectDevice(CalendarEventDevice):
+    """A device for getting the next Task from a Todoist Project."""
+
+    def __init__(self, hass, data, labels, token,
+                 latest_task_due_date=None, whitelisted_labels=None,
+                 whitelisted_projects=None):
+        """Create the Todoist Calendar Event Device."""
+        self.data = TodoistProjectData(
+            data, labels, token, latest_task_due_date,
+            whitelisted_labels, whitelisted_projects
+        )
+
+        # Set up the calendar side of things
+        calendar_format = {
+            CONF_NAME: data[CONF_NAME],
+            # Set Entity ID to use the name so we can identify calendars
+            CONF_DEVICE_ID: data[CONF_NAME]
+        }
+
+        super().__init__(hass, calendar_format)
+
+    def update(self):
+        """Update all Todoist Calendars."""
+        # Set basic calendar data
+        super().update()
+
+        # Set Todoist-specific data that can't easily be grabbed
+        self._cal_data[ALL_TASKS] = [
+            task[SUMMARY] for task in self.data.all_project_tasks]
+
+    def cleanup(self):
+        """Clean up all calendar data."""
+        super().cleanup()
+        self._cal_data[ALL_TASKS] = []
+
+    @property
+    def device_state_attributes(self):
+        """Return the device state attributes."""
+        if self.data.event is None:
+            # No tasks, we don't REALLY need to show anything.
+            return {}
+
+        attributes = super().device_state_attributes
+
+        # Add additional attributes.
+        attributes[DUE_TODAY] = self.data.event[DUE_TODAY]
+        attributes[OVERDUE] = self.data.event[OVERDUE]
+        attributes[ALL_TASKS] = self._cal_data[ALL_TASKS]
+        attributes[PRIORITY] = self.data.event[PRIORITY]
+        attributes[LABELS] = self.data.event[LABELS]
+
+        return attributes
+
+
+class TodoistProjectData(object):
+    """
+    Class used by the Task Device service object to hold all Todoist Tasks.
+
+    This is analogous to the GoogleCalendarData found in the Google Calendar
+    component.
+
+    Takes an object with a 'name' field and optionally an 'id' field (either
+    user-defined or from the Todoist API), a Todoist API token, and an optional
+    integer specifying the latest number of days from now a task can be due (7
+    means everything due in the next week, 0 means today, etc.).
+
+    This object has an exposed 'event' property (used by the Calendar platform
+    to determine the next calendar event) and an exposed 'update' method (used
+    by the Calendar platform to poll for new calendar events).
+
+    The 'event' is a representation of a Todoist Task, with defined parameters
+    of 'due_today' (is the task due today?), 'all_day' (does the task have a
+    due date?), 'task_labels' (all labels assigned to the task), 'message'
+    (the content of the task, e.g. 'Fetch Mail'), 'description' (a URL pointing
+    to the task on the Todoist website), 'end_time' (what time the event is
+    due), 'start_time' (what time this event was last updated), 'overdue' (is
+    the task past its due date?), 'priority' (1-4, how important the task is,
+    with 4 being the most important), and 'all_tasks' (all tasks in this
+    project, sorted by how important they are).
+
+    'offset_reached', 'location', and 'friendly_name' are defined by the
+    platform itself, but are not used by this component at all.
+
+    The 'update' method polls the Todoist API for new projects/tasks, as well
+    as any updates to current projects/tasks. This is throttled to every
+    MIN_TIME_BETWEEN_UPDATES minutes.
+    """
+
+    def __init__(self, project_data, labels, api,
+                 latest_task_due_date=None, whitelisted_labels=None,
+                 whitelisted_projects=None):
+        """Initialize a Todoist Project."""
+        self.event = None
+
+        self._api = api
+        self._name = project_data.get(CONF_NAME)
+        # If no ID is defined, fetch all tasks.
+        self._id = project_data.get(CONF_ID)
+
+        # All labels the user has defined, for easy lookup.
+        self._labels = labels
+        # Not tracked: order, indent, comment_count.
+
+        self.all_project_tasks = []
+
+        # The latest date a task can be due (for making lists of everything
+        # due today, or everything due in the next week, for example).
+        if latest_task_due_date is not None:
+            self._latest_due_date = dt.utcnow() + timedelta(
+                days=latest_task_due_date)
+        else:
+            self._latest_due_date = None
+
+        # Only tasks with one of these labels will be included.
+        if whitelisted_labels is not None:
+            self._label_whitelist = whitelisted_labels
+        else:
+            self._label_whitelist = []
+
+        # This project includes only projects with these names.
+        if whitelisted_projects is not None:
+            self._project_id_whitelist = whitelisted_projects
+        else:
+            self._project_id_whitelist = []
+
+    def create_todoist_task(self, data):
+        """
+        Create a dictionary based on a Task passed from the Todoist API.
+
+        Will return 'None' if the task is to be filtered out.
+        """
+        task = {}
+        # Fields are required to be in all returned task objects.
+        task[SUMMARY] = data[CONTENT]
+        task[COMPLETED] = data[CHECKED] == 1
+        task[PRIORITY] = data[PRIORITY]
+        task[DESCRIPTION] = 'https://todoist.com/showTask?id={}'.format(
+            data[ID])
+
+        # All task Labels (optional parameter).
+        task[LABELS] = [
+            label[NAME].lower() for label in self._labels
+            if label[ID] in data[LABELS]]
+
+        if self._label_whitelist and (
+                not any(label in task[LABELS]
+                        for label in self._label_whitelist)):
+            # We're not on the whitelist, return invalid task.
+            return None
+
+        # Due dates (optional parameter).
+        # The due date is the END date -- the task cannot be completed
+        # past this time.
+        # That means that the START date is the earliest time one can
+        # complete the task.
+        # Generally speaking, that means right now.
+        task[START] = dt.utcnow()
+        if data[DUE_DATE_UTC] is not None:
+            due_date = data[DUE_DATE_UTC]
+
+            # Due dates are represented in RFC3339 format, in UTC.
+            # Home Assistant exclusively uses UTC, so it'll
+            # handle the conversion.
+            time_format = '%a %d %b %Y %H:%M:%S %z'
+            # HASS' built-in parse time function doesn't like
+            # Todoist's time format; strptime has to be used.
+            task[END] = datetime.strptime(due_date, time_format)
+
+            if self._latest_due_date is not None and (
+                    task[END] > self._latest_due_date):
+                # This task is out of range of our due date;
+                # it shouldn't be counted.
+                return None
+
+            task[DUE_TODAY] = task[END].date() == datetime.today().date()
+
+            # Special case: Task is overdue.
+            if task[END] <= task[START]:
+                task[OVERDUE] = True
+                # Set end time to the current time plus 1 hour.
+                # We're pretty much guaranteed to update within that 1 hour,
+                # so it should be fine.
+                task[END] = task[START] + timedelta(hours=1)
+            else:
+                task[OVERDUE] = False
+        else:
+            # If we ask for everything due before a certain date, don't count
+            # things which have no due dates.
+            if self._latest_due_date is not None:
+                return None
+
+            # Define values for tasks without due dates
+            task[END] = None
+            task[ALL_DAY] = True
+            task[DUE_TODAY] = False
+            task[OVERDUE] = False
+
+        # Not tracked: id, comments, project_id order, indent, recurring.
+        return task
+
+    @staticmethod
+    def select_best_task(project_tasks):
+        """
+        Search through a list of events for the "best" event to select.
+
+        The "best" event is determined by the following criteria:
+          * A proposed event must not be completed
+          * A proposed event must have a end date (otherwise we go with
+            the event at index 0, selected above)
+          * A proposed event must be on the same day or earlier as our
+            current event
+          * If a proposed event is an earlier day than what we have so
+            far, select it
+          * If a proposed event is on the same day as our current event
+            and the proposed event has a higher priority than our current
+            event, select it
+          * If a proposed event is on the same day as our current event,
+            has the same priority as our current event, but is due earlier
+            in the day, select it
+        """
+        # Start at the end of the list, so if tasks don't have a due date
+        # the newest ones are the most important.
+
+        event = project_tasks[-1]
+
+        for proposed_event in project_tasks:
+            if event == proposed_event:
+                continue
+            if proposed_event[COMPLETED]:
+                # Event is complete!
+                continue
+            if proposed_event[END] is None:
+                # No end time:
+                if event[END] is None and (
+                        proposed_event[PRIORITY] < event[PRIORITY]):
+                    # They also have no end time,
+                    # but we have a higher priority.
+                    event = proposed_event
+                    continue
+                else:
+                    continue
+            elif event[END] is None:
+                # We have an end time, they do not.
+                event = proposed_event
+                continue
+            if proposed_event[END].date() > event[END].date():
+                # Event is too late.
+                continue
+            elif proposed_event[END].date() < event[END].date():
+                # Event is earlier than current, select it.
+                event = proposed_event
+                continue
+            else:
+                if proposed_event[PRIORITY] > event[PRIORITY]:
+                    # Proposed event has a higher priority.
+                    event = proposed_event
+                    continue
+                elif proposed_event[PRIORITY] == event[PRIORITY] and (
+                        proposed_event[END] < event[END]):
+                    event = proposed_event
+                    continue
+        return event
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Get the latest data."""
+        if self._id is None:
+            project_task_data = [
+                task for task in self._api.state[TASKS]
+                if not self._project_id_whitelist or
+                task[PROJECT_ID] in self._project_id_whitelist]
+        else:
+            project_task_data = self._api.projects.get_data(self._id)[TASKS]
+
+        # If we have no data, we can just return right away.
+        if not project_task_data:
+            self.event = None
+            return True
+
+        # Keep an updated list of all tasks in this project.
+        project_tasks = []
+
+        for task in project_task_data:
+            todoist_task = self.create_todoist_task(task)
+            if todoist_task is not None:
+                # A None task means it is invalid for this project
+                project_tasks.append(todoist_task)
+
+        if not project_tasks:
+            # We had no valid tasks
+            return True
+
+        # Organize the best tasks (so users can see all the tasks
+        # they have, organized)
+        while len(project_tasks) > 0:
+            best_task = self.select_best_task(project_tasks)
+            _LOGGER.debug("Found Todoist Task: %s", best_task[SUMMARY])
+            project_tasks.remove(best_task)
+            self.all_project_tasks.append(best_task)
+
+        self.event = self.all_project_tasks[0]
+
+        # Convert datetime to a string again
+        if self.event is not None:
+            if self.event[START] is not None:
+                self.event[START] = {
+                    DATETIME: self.event[START].strftime(DATE_STR_FORMAT)
+                }
+            if self.event[END] is not None:
+                self.event[END] = {
+                    DATETIME: self.event[END].strftime(DATE_STR_FORMAT)
+                }
+            else:
+                # HASS gets cranky if a calendar event never ends
+                # Let's set our "due date" to tomorrow
+                self.event[END] = {
+                    DATETIME: (
+                        datetime.utcnow() +
+                        timedelta(days=1)
+                    ).strftime(DATE_STR_FORMAT)
+                }
+        _LOGGER.debug("Updated %s", self._name)
+        return True

homeassistant/components/camera/__init__.py

@@ -29,18 +29,22 @@ from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 from homeassistant.components.http import HomeAssistantView, KEY_AUTHENTICATED
-from homeassistant.helpers.event import async_track_time_interval
 import homeassistant.helpers.config_validation as cv
 
+DOMAIN = 'camera'
+DEPENDENCIES = ['http']
+
 _LOGGER = logging.getLogger(__name__)
 
-SERVICE_EN_MOTION = 'enable_motion_detection'
-SERVICE_DISEN_MOTION = 'disable_motion_detection'
-DOMAIN = 'camera'
-DEPENDENCIES = ['http']
+SERVICE_ENABLE_MOTION = 'enable_motion_detection'
+SERVICE_DISABLE_MOTION = 'disable_motion_detection'
+SERVICE_SNAPSHOT = 'snapshot'
+
 SCAN_INTERVAL = timedelta(seconds=30)
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 
+ATTR_FILENAME = 'filename'
+
 STATE_RECORDING = 'recording'
 STATE_STREAMING = 'streaming'
 STATE_IDLE = 'idle'
@@ -55,13 +59,17 @@ CAMERA_SERVICE_SCHEMA = vol.Schema({
     vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
 })
 
+CAMERA_SERVICE_SNAPSHOT = CAMERA_SERVICE_SCHEMA.extend({
+    vol.Required(ATTR_FILENAME): cv.template
+})
+
 
 @bind_hass
 def enable_motion_detection(hass, entity_id=None):
     """Enable Motion Detection."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
     hass.async_add_job(hass.services.async_call(
-        DOMAIN, SERVICE_EN_MOTION, data))
+        DOMAIN, SERVICE_ENABLE_MOTION, data))
 
 
 @bind_hass
@@ -69,9 +77,20 @@ def disable_motion_detection(hass, entity_id=None):
     """Disable Motion Detection."""
     data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
     hass.async_add_job(hass.services.async_call(
-        DOMAIN, SERVICE_DISEN_MOTION, data))
+        DOMAIN, SERVICE_DISABLE_MOTION, data))
 
 
+@bind_hass
+def async_snapshot(hass, filename, entity_id=None):
+    """Make a snapshot from a camera."""
+    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
+    data[ATTR_FILENAME] = filename
+
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_SNAPSHOT, data))
+
+
+@bind_hass
 @asyncio.coroutine
 def async_get_image(hass, entity_id, timeout=10):
     """Fetch a image from a camera entity."""
@@ -119,44 +138,72 @@ def async_setup(hass, config):
             entity.async_update_token()
             hass.async_add_job(entity.async_update_ha_state())
 
-    async_track_time_interval(hass, update_tokens, TOKEN_CHANGE_INTERVAL)
+    hass.helpers.event.async_track_time_interval(
+        update_tokens, TOKEN_CHANGE_INTERVAL)
 
     @asyncio.coroutine
     def async_handle_camera_service(service):
         """Handle calls to the camera services."""
         target_cameras = component.async_extract_from_service(service)
 
-        for camera in target_cameras:
-            if service.service == SERVICE_EN_MOTION:
-                yield from camera.async_enable_motion_detection()
-            elif service.service == SERVICE_DISEN_MOTION:
-                yield from camera.async_disable_motion_detection()
-
         update_tasks = []
         for camera in target_cameras:
+            if service.service == SERVICE_ENABLE_MOTION:
+                yield from camera.async_enable_motion_detection()
+            elif service.service == SERVICE_DISABLE_MOTION:
+                yield from camera.async_disable_motion_detection()
+
             if not camera.should_poll:
                 continue
-
-            update_coro = hass.async_add_job(
-                camera.async_update_ha_state(True))
-            if hasattr(camera, 'async_update'):
-                update_tasks.append(update_coro)
-            else:
-                yield from update_coro
+            update_tasks.append(camera.async_update_ha_state(True))
 
         if update_tasks:
             yield from asyncio.wait(update_tasks, loop=hass.loop)
 
+    @asyncio.coroutine
+    def async_handle_snapshot_service(service):
+        """Handle snapshot services calls."""
+        target_cameras = component.async_extract_from_service(service)
+        filename = service.data[ATTR_FILENAME]
+        filename.hass = hass
+
+        for camera in target_cameras:
+            snapshot_file = filename.async_render(
+                variables={ATTR_ENTITY_ID: camera})
+
+            # check if we allow to access to that file
+            if not hass.config.is_allowed_path(snapshot_file):
+                _LOGGER.error(
+                    "Can't write %s, no access to path!", snapshot_file)
+                continue
+
+            image = yield from camera.async_camera_image()
+
+            def _write_image(to_file, image_data):
+                """Executor helper to write image."""
+                with open(to_file, 'wb') as img_file:
+                    img_file.write(image_data)
+
+            try:
+                yield from hass.async_add_job(
+                    _write_image, snapshot_file, image)
+            except OSError as err:
+                _LOGGER.error("Can't write image to file: %s", err)
+
     descriptions = yield from hass.async_add_job(
         load_yaml_config_file, os.path.join(
             os.path.dirname(__file__), 'services.yaml'))
 
     hass.services.async_register(
-        DOMAIN, SERVICE_EN_MOTION, async_handle_camera_service,
-        descriptions.get(SERVICE_EN_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+        DOMAIN, SERVICE_ENABLE_MOTION, async_handle_camera_service,
+        descriptions.get(SERVICE_ENABLE_MOTION), schema=CAMERA_SERVICE_SCHEMA)
     hass.services.async_register(
-        DOMAIN, SERVICE_DISEN_MOTION, async_handle_camera_service,
-        descriptions.get(SERVICE_DISEN_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+        DOMAIN, SERVICE_DISABLE_MOTION, async_handle_camera_service,
+        descriptions.get(SERVICE_DISABLE_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_SNAPSHOT, async_handle_snapshot_service,
+        descriptions.get(SERVICE_SNAPSHOT),
+        schema=CAMERA_SERVICE_SNAPSHOT)
 
     return True
 

homeassistant/components/camera/abode.py

@@ -0,0 +1,101 @@
+"""
+This component provides HA camera support for Abode Security System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.abode/
+"""
+import asyncio
+import logging
+
+from datetime import timedelta
+import requests
+
+from homeassistant.components.abode import AbodeDevice, DOMAIN as ABODE_DOMAIN
+from homeassistant.components.camera import Camera
+from homeassistant.util import Throttle
+
+
+DEPENDENCIES = ['abode']
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=90)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discoveryy_info=None):
+    """Set up Abode camera devices."""
+    import abodepy.helpers.constants as CONST
+    import abodepy.helpers.timeline as TIMELINE
+
+    data = hass.data[ABODE_DOMAIN]
+
+    devices = []
+    for device in data.abode.get_devices(generic_type=CONST.TYPE_CAMERA):
+        if data.is_excluded(device):
+            continue
+
+        devices.append(AbodeCamera(data, device, TIMELINE.CAPTURE_IMAGE))
+
+    data.devices.extend(devices)
+
+    add_devices(devices)
+
+
+class AbodeCamera(AbodeDevice, Camera):
+    """Representation of an Abode camera."""
+
+    def __init__(self, data, device, event):
+        """Initialize the Abode device."""
+        AbodeDevice.__init__(self, data, device)
+        Camera.__init__(self)
+        self._event = event
+        self._response = None
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Subscribe Abode events."""
+        yield from super().async_added_to_hass()
+
+        self.hass.async_add_job(
+            self._data.abode.events.add_timeline_callback,
+            self._event, self._capture_callback
+        )
+
+    def capture(self):
+        """Request a new image capture."""
+        return self._device.capture()
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def refresh_image(self):
+        """Find a new image on the timeline."""
+        if self._device.refresh_image():
+            self.get_image()
+
+    def get_image(self):
+        """Attempt to download the most recent capture."""
+        if self._device.image_url:
+            try:
+                self._response = requests.get(
+                    self._device.image_url, stream=True)
+
+                self._response.raise_for_status()
+            except requests.HTTPError as err:
+                _LOGGER.warning("Failed to get camera image: %s", err)
+                self._response = None
+        else:
+            self._response = None
+
+    def camera_image(self):
+        """Get a camera image."""
+        self.refresh_image()
+
+        if self._response:
+            return self._response.content
+
+        return None
+
+    def _capture_callback(self, capture):
+        """Update the image with the device then refresh device."""
+        self._device.update_image_location(capture)
+        self.get_image()
+        self.schedule_update_ha_state()

homeassistant/components/camera/amcrest.py

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

homeassistant/components/camera/arlo.py

@@ -1,30 +1,51 @@
 """
-This component provides basic support for Netgear Arlo IP cameras.
+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
+from datetime import timedelta
 
 import voluptuous as vol
 
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+import homeassistant.helpers.config_validation as cv
 from homeassistant.components.arlo import DEFAULT_BRAND, DATA_ARLO
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 from homeassistant.components.ffmpeg import DATA_FFMPEG
-
-DEPENDENCIES = ['arlo', 'ffmpeg']
+from homeassistant.const import ATTR_BATTERY_LEVEL
+from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
 
 _LOGGER = logging.getLogger(__name__)
 
-CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+SCAN_INTERVAL = timedelta(seconds=90)
+
 ARLO_MODE_ARMED = 'armed'
 ARLO_MODE_DISARMED = 'disarmed'
 
+ATTR_BRIGHTNESS = 'brightness'
+ATTR_FLIPPED = 'flipped'
+ATTR_MIRRORED = 'mirrored'
+ATTR_MOTION = 'motion_detection_sensitivity'
+ATTR_POWERSAVE = 'power_save_mode'
+ATTR_SIGNAL_STRENGTH = 'signal_strength'
+ATTR_UNSEEN_VIDEOS = 'unseen_videos'
+ATTR_LAST_REFRESH = 'last_refresh'
+
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+
+DEPENDENCIES = ['arlo', 'ffmpeg']
+
+POWERSAVE_MODE_MAPPING = {
+    1: 'best_battery_life',
+    2: 'optimized',
+    3: 'best_video'
+}
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string,
+    vol.Optional(CONF_FFMPEG_ARGUMENTS):
+    cv.string,
 })
 
 
@@ -53,6 +74,9 @@ class ArloCam(Camera):
         self._motion_status = False
         self._ffmpeg = hass.data[DATA_FFMPEG]
         self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
+        self._last_refresh = None
+        self._camera.base_station.refresh_rate = SCAN_INTERVAL.total_seconds()
+        self.attrs = {}
 
     def camera_image(self):
         """Return a still image response from the camera."""
@@ -80,14 +104,31 @@ class ArloCam(Camera):
         """Return the name of this camera."""
         return self._name
 
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            name: value for name, value in (
+                (ATTR_BATTERY_LEVEL, self._camera.battery_level),
+                (ATTR_BRIGHTNESS, self._camera.brightness),
+                (ATTR_FLIPPED, self._camera.flip_state),
+                (ATTR_MIRRORED, self._camera.mirror_state),
+                (ATTR_MOTION, self._camera.motion_detection_sensitivity),
+                (ATTR_POWERSAVE, POWERSAVE_MODE_MAPPING.get(
+                    self._camera.powersave_mode)),
+                (ATTR_SIGNAL_STRENGTH, self._camera.signal_strength),
+                (ATTR_UNSEEN_VIDEOS, self._camera.unseen_videos),
+            ) if value is not None
+        }
+
     @property
     def model(self):
-        """Camera model."""
+        """Return the camera model."""
         return self._camera.model_id
 
     @property
     def brand(self):
-        """Camera brand."""
+        """Return the camera brand."""
         return DEFAULT_BRAND
 
     @property
@@ -97,7 +138,7 @@ class ArloCam(Camera):
 
     @property
     def motion_detection_enabled(self):
-        """Camera Motion Detection Status."""
+        """Return the camera motion detection status."""
         return self._motion_status
 
     def set_base_station_mode(self, mode):
@@ -105,7 +146,7 @@ class ArloCam(Camera):
         # Get the list of base stations identified by library
         base_stations = self.hass.data[DATA_ARLO].base_stations
 
-        # Some Arlo cameras does not have basestation
+        # Some Arlo cameras does not have base station
         # So check if there is base station detected first
         # if yes, then choose the primary base station
         # Set the mode on the chosen base station
@@ -122,3 +163,7 @@ class ArloCam(Camera):
         """Disable the motion detection in base station (Disarm)."""
         self._motion_status = False
         self.set_base_station_mode(ARLO_MODE_DISARMED)
+
+    def update(self):
+        """Add an attribute-update task to the executor pool."""
+        self._camera.update()

homeassistant/components/camera/axis.py

@@ -7,11 +7,11 @@ https://home-assistant.io/components/camera.axis/
 import logging
 
 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, CONF_USERNAME, CONF_PASSWORD,
+    CONF_HOST, CONF_NAME, CONF_USERNAME, CONF_PASSWORD, CONF_PORT,
     CONF_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION)
 from homeassistant.components.camera.mjpeg import (
     CONF_MJPEG_URL, CONF_STILL_IMAGE_URL, MjpegCamera)
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.dispatcher import dispatcher_connect
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -19,38 +19,44 @@ DOMAIN = 'axis'
 DEPENDENCIES = [DOMAIN]
 
 
-def _get_image_url(host, mode):
+def _get_image_url(host, port, mode):
     if mode == 'mjpeg':
-        return 'http://{}/axis-cgi/mjpg/video.cgi'.format(host)
+        return 'http://{}:{}/axis-cgi/mjpg/video.cgi'.format(host, port)
     elif mode == 'single':
-        return 'http://{}/axis-cgi/jpg/image.cgi'.format(host)
+        return 'http://{}:{}/axis-cgi/jpg/image.cgi'.format(host, port)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup Axis camera."""
-    config = {
+    camera_config = {
         CONF_NAME: discovery_info[CONF_NAME],
         CONF_USERNAME: discovery_info[CONF_USERNAME],
         CONF_PASSWORD: discovery_info[CONF_PASSWORD],
-        CONF_MJPEG_URL: _get_image_url(discovery_info[CONF_HOST], 'mjpeg'),
+        CONF_MJPEG_URL: _get_image_url(discovery_info[CONF_HOST],
+                                       str(discovery_info[CONF_PORT]),
+                                       'mjpeg'),
         CONF_STILL_IMAGE_URL: _get_image_url(discovery_info[CONF_HOST],
+                                             str(discovery_info[CONF_PORT]),
                                              'single'),
         CONF_AUTHENTICATION: HTTP_DIGEST_AUTHENTICATION,
     }
-    add_devices([AxisCamera(hass, config)])
+    add_devices([AxisCamera(hass,
+                            camera_config,
+                            str(discovery_info[CONF_PORT]))])
 
 
 class AxisCamera(MjpegCamera):
     """AxisCamera class."""
 
-    def __init__(self, hass, config):
+    def __init__(self, hass, config, port):
         """Initialize Axis Communications camera component."""
         super().__init__(hass, config)
-        async_dispatcher_connect(hass,
-                                 DOMAIN + '_' + config[CONF_NAME] + '_new_ip',
-                                 self._new_ip)
+        self.port = port
+        dispatcher_connect(hass,
+                           DOMAIN + '_' + config[CONF_NAME] + '_new_ip',
+                           self._new_ip)
 
     def _new_ip(self, host):
         """Set new IP for video stream."""
-        self._mjpeg_url = _get_image_url(host, 'mjpeg')
-        self._still_image_url = _get_image_url(host, 'mjpeg')
+        self._mjpeg_url = _get_image_url(host, self.port, 'mjpeg')
+        self._still_image_url = _get_image_url(host, self.port, 'single')

homeassistant/components/camera/blink.py

@@ -76,6 +76,6 @@ class BlinkCamera(Camera):
         return self.data.camera_thumbs[self._name]
 
     def camera_image(self):
-        """Return a still image reponse from the camera."""
+        """Return a still image response from the camera."""
         self.request_image()
         return self.response.content

homeassistant/components/camera/doorbird.py

@@ -0,0 +1,90 @@
+"""Support for viewing the camera feed from a DoorBird video doorbell."""
+
+import asyncio
+import datetime
+import logging
+import voluptuous as vol
+
+import aiohttp
+import async_timeout
+
+from homeassistant.components.camera import PLATFORM_SCHEMA, Camera
+from homeassistant.components.doorbird import DOMAIN as DOORBIRD_DOMAIN
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+DEPENDENCIES = ['doorbird']
+
+_CAMERA_LIVE = "DoorBird Live"
+_CAMERA_LAST_VISITOR = "DoorBird Last Ring"
+_LIVE_INTERVAL = datetime.timedelta(seconds=1)
+_LAST_VISITOR_INTERVAL = datetime.timedelta(minutes=1)
+_LOGGER = logging.getLogger(__name__)
+_TIMEOUT = 10  # seconds
+
+CONF_SHOW_LAST_VISITOR = 'last_visitor'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_SHOW_LAST_VISITOR, default=False): cv.boolean
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the DoorBird camera platform."""
+    device = hass.data.get(DOORBIRD_DOMAIN)
+
+    _LOGGER.debug("Adding DoorBird camera %s", _CAMERA_LIVE)
+    entities = [DoorBirdCamera(device.live_image_url, _CAMERA_LIVE,
+                               _LIVE_INTERVAL)]
+
+    if config.get(CONF_SHOW_LAST_VISITOR):
+        _LOGGER.debug("Adding DoorBird camera %s", _CAMERA_LAST_VISITOR)
+        entities.append(DoorBirdCamera(device.history_image_url(1),
+                                       _CAMERA_LAST_VISITOR,
+                                       _LAST_VISITOR_INTERVAL))
+
+    async_add_devices(entities)
+    _LOGGER.info("Added DoorBird camera(s)")
+
+
+class DoorBirdCamera(Camera):
+    """The camera on a DoorBird device."""
+
+    def __init__(self, url, name, interval=None):
+        """Initialize the camera on a DoorBird device."""
+        self._url = url
+        self._name = name
+        self._last_image = None
+        self._interval = interval or datetime.timedelta
+        self._last_update = datetime.datetime.min
+        super().__init__()
+
+    @property
+    def name(self):
+        """Get the name of the camera."""
+        return self._name
+
+    @asyncio.coroutine
+    def async_camera_image(self):
+        """Pull a still image from the camera."""
+        now = datetime.datetime.now()
+
+        if self._last_image and now - self._last_update < self._interval:
+            return self._last_image
+
+        try:
+            websession = async_get_clientsession(self.hass)
+
+            with async_timeout.timeout(_TIMEOUT, loop=self.hass.loop):
+                response = yield from websession.get(self._url)
+
+            self._last_image = yield from response.read()
+            self._last_update = now
+            return self._last_image
+        except asyncio.TimeoutError:
+            _LOGGER.error("Camera image timed out")
+            return self._last_image
+        except aiohttp.ClientError as error:
+            _LOGGER.error("Error getting camera image: %s", error)
+            return self._last_image

homeassistant/components/camera/ffmpeg.py

@@ -55,9 +55,9 @@ class FFmpegCamera(Camera):
         from haffmpeg import ImageFrame, IMAGE_JPEG
         ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop)
 
-        image = yield from ffmpeg.get_image(
+        image = yield from asyncio.shield(ffmpeg.get_image(
             self._input, output_format=IMAGE_JPEG,
-            extra_cmd=self._extra_arguments)
+            extra_cmd=self._extra_arguments), loop=self.hass.loop)
         return image
 
     @asyncio.coroutine

homeassistant/components/camera/foscam.py

@@ -15,7 +15,7 @@ from homeassistant.helpers import config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
-REQUIREMENTS = ['pyfoscam==1.2']
+REQUIREMENTS = ['libpyfoscam==1.0']
 
 CONF_IP = 'ip'
 
@@ -53,13 +53,13 @@ class FoscamCam(Camera):
         self._name = device_info.get(CONF_NAME)
         self._motion_status = False
 
-        from foscam.foscam import FoscamCamera
+        from libpyfoscam import FoscamCamera
 
         self._foscam_session = FoscamCamera(ip_address, port, self._username,
                                             self._password, verbose=False)
 
     def camera_image(self):
-        """Return a still image reponse from the camera."""
+        """Return a still image response from the camera."""
         # Send the request to snap a picture and return raw jpg data
         # Handle exception if host is not reachable or url failed
         result, response = self._foscam_session.snap_picture_2()

homeassistant/components/camera/onvif.py

@@ -78,9 +78,9 @@ class ONVIFCamera(Camera):
         ffmpeg = ImageFrame(
             self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop)
 
-        image = yield from ffmpeg.get_image(
+        image = yield from asyncio.shield(ffmpeg.get_image(
             self._input, output_format=IMAGE_JPEG,
-            extra_cmd=self._ffmpeg_arguments)
+            extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop)
         return image
 
     @asyncio.coroutine

homeassistant/components/camera/ring.py

@@ -0,0 +1,167 @@
+"""
+This component provides support to the Ring Door Bell camera.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.ring/
+"""
+import asyncio
+import logging
+
+from datetime import timedelta
+
+import voluptuous as vol
+
+from homeassistant.helpers import config_validation as cv
+from homeassistant.components.ring import (
+    DATA_RING, CONF_ATTRIBUTION, NOTIFICATION_ID)
+from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
+from homeassistant.components.ffmpeg import DATA_FFMPEG
+from homeassistant.const import ATTR_ATTRIBUTION, CONF_SCAN_INTERVAL
+from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+from homeassistant.util import dt as dt_util
+
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+
+DEPENDENCIES = ['ring', 'ffmpeg']
+
+FORCE_REFRESH_INTERVAL = timedelta(minutes=45)
+
+_LOGGER = logging.getLogger(__name__)
+
+NOTIFICATION_TITLE = 'Ring Camera Setup'
+
+SCAN_INTERVAL = timedelta(seconds=90)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string,
+    vol.Optional(CONF_SCAN_INTERVAL, default=SCAN_INTERVAL):
+        cv.time_period,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up a Ring Door Bell and StickUp Camera."""
+    ring = hass.data[DATA_RING]
+
+    cams = []
+    cams_no_plan = []
+    for camera in ring.doorbells:
+        if camera.has_subscription:
+            cams.append(RingCam(hass, camera, config))
+        else:
+            cams_no_plan.append(camera)
+
+    for camera in ring.stickup_cams:
+        if camera.has_subscription:
+            cams.append(RingCam(hass, camera, config))
+        else:
+            cams_no_plan.append(camera)
+
+    # show notification for all cameras without an active subscription
+    if cams_no_plan:
+        cameras = str(', '.join([camera.name for camera in cams_no_plan]))
+
+        err_msg = '''A Ring Protect Plan is required for the''' \
+                  ''' following cameras: {}.'''.format(cameras)
+
+        _LOGGER.error(err_msg)
+        hass.components.persistent_notification.async_create(
+            'Error: {}<br />'
+            'You will need to restart hass after fixing.'
+            ''.format(err_msg),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
+
+    async_add_devices(cams, True)
+    return True
+
+
+class RingCam(Camera):
+    """An implementation of a Ring Door Bell camera."""
+
+    def __init__(self, hass, camera, device_info):
+        """Initialize a Ring Door Bell camera."""
+        super(RingCam, self).__init__()
+        self._camera = camera
+        self._hass = hass
+        self._name = self._camera.name
+        self._ffmpeg = hass.data[DATA_FFMPEG]
+        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
+        self._last_video_id = self._camera.last_recording_id
+        self._video_url = self._camera.recording_url(self._last_video_id)
+        self._utcnow = dt_util.utcnow()
+        self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._camera.id,
+            'firmware': self._camera.firmware,
+            'kind': self._camera.kind,
+            'timezone': self._camera.timezone,
+            'type': self._camera.family,
+            'video_url': self._video_url,
+        }
+
+    @asyncio.coroutine
+    def async_camera_image(self):
+        """Return a still image response from the camera."""
+        from haffmpeg import ImageFrame, IMAGE_JPEG
+        ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop)
+
+        if self._video_url is None:
+            return
+
+        image = yield from asyncio.shield(ffmpeg.get_image(
+            self._video_url, output_format=IMAGE_JPEG,
+            extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop)
+        return image
+
+    @asyncio.coroutine
+    def handle_async_mjpeg_stream(self, request):
+        """Generate an HTTP MJPEG stream from the camera."""
+        from haffmpeg import CameraMjpeg
+
+        if self._video_url is None:
+            return
+
+        stream = CameraMjpeg(self._ffmpeg.binary, loop=self.hass.loop)
+        yield from stream.open_camera(
+            self._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 should_poll(self):
+        """Update the image periodically."""
+        return True
+
+    def update(self):
+        """Update camera entity and refresh attributes."""
+        _LOGGER.debug("Checking if Ring DoorBell needs to refresh video_url")
+
+        self._camera.update()
+        self._utcnow = dt_util.utcnow()
+
+        last_recording_id = self._camera.last_recording_id
+
+        if self._last_video_id != last_recording_id or \
+           self._utcnow >= self._expires_at:
+
+            _LOGGER.info("Ring DoorBell properties refreshed")
+
+            # update attributes if new video or if URL has expired
+            self._last_video_id = self._camera.last_recording_id
+            self._video_url = self._camera.recording_url(self._last_video_id)
+            self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow

homeassistant/components/camera/services.yaml

@@ -1,17 +1,25 @@
 # Describes the format for available camera services
 
 enable_motion_detection:
-  description: Enable the motion detection in a camera
-
+  description: Enable the motion detection in a camera.
   fields:
     entity_id:
-      description: Name(s) of entities to enable motion detection
+      description: Name(s) of entities to enable motion detection.
       example: 'camera.living_room_camera'
 
 disable_motion_detection:
-  description: Disable the motion detection in a camera
-  
+  description: Disable the motion detection in a camera.
   fields:
     entity_id:
-      description: Name(s) of entities to disable motion detection
+      description: Name(s) of entities to disable motion detection.
       example: 'camera.living_room_camera'
+
+snapshot:
+  description: Take a snapshot from a camera.
+  fields:
+    entity_id:
+      description: Name(s) of entities to create snapshots from.
+      example: 'camera.living_room_camera'
+    filename:
+      description: Template of a Filename. Variable is entity_id.
+      example: '/tmp/snapshot_{{ entity_id }}'