Merge pull request #15570 from home-assistant/rc

0.74
light.tplink: initialize min & max mireds only once, avoid i/o outside update (#15571 )
2026-01-04 06:45:24 +01:00 · 2018-07-20 15:11:18 +02:00 · 2018-07-20 14:40:38 +02:00 · 2018-07-20 12:44:15 +02:00 · 2018-07-20 12:33:21 +02:00 · 2018-07-20 12:32:45 +02:00
904 changed files with 24564 additions and 8047 deletions
--- a/.coveragerc
+++ b/.coveragerc
@@ -61,6 +61,11 @@ omit =
    homeassistant/components/coinbase.py
    homeassistant/components/sensor/coinbase.py

+    homeassistant/components/cast/*
+    homeassistant/components/*/cast.py
+
+    homeassistant/components/cloudflare.py
+
    homeassistant/components/comfoconnect.py
    homeassistant/components/*/comfoconnect.py

@@ -97,7 +102,7 @@ omit =
    homeassistant/components/*/envisalink.py

    homeassistant/components/fritzbox.py
-    homeassistant/components/*/fritzbox.py
+    homeassistant/components/switch/fritzbox.py

    homeassistant/components/eufy.py
    homeassistant/components/*/eufy.py
@@ -123,6 +128,9 @@ omit =
    homeassistant/components/homematicip_cloud.py
    homeassistant/components/*/homematicip_cloud.py

+    homeassistant/components/hydrawise.py
+    homeassistant/components/*/hydrawise.py
+
    homeassistant/components/ihc/*
    homeassistant/components/*/ihc.py

@@ -186,18 +194,21 @@ omit =
    homeassistant/components/mychevy.py
    homeassistant/components/*/mychevy.py

-    homeassistant/components/mysensors.py
+    homeassistant/components/mysensors/*
    homeassistant/components/*/mysensors.py

    homeassistant/components/neato.py
    homeassistant/components/*/neato.py

-    homeassistant/components/nest.py
+    homeassistant/components/nest/__init__.py
    homeassistant/components/*/nest.py

    homeassistant/components/netatmo.py
    homeassistant/components/*/netatmo.py

+    homeassistant/components/netgear_lte.py
+    homeassistant/components/*/netgear_lte.py
+
    homeassistant/components/octoprint.py
    homeassistant/components/*/octoprint.py

@@ -216,7 +227,7 @@ omit =
    homeassistant/components/raincloud.py
    homeassistant/components/*/raincloud.py

-    homeassistant/components/rainmachine.py
+    homeassistant/components/rainmachine/*
    homeassistant/components/*/rainmachine.py

    homeassistant/components/raspihats.py
@@ -246,6 +257,9 @@ omit =
    homeassistant/components/smappee.py
    homeassistant/components/*/smappee.py

+    homeassistant/components/sonos/__init__.py
+    homeassistant/components/*/sonos.py
+
    homeassistant/components/tado.py
    homeassistant/components/*/tado.py

@@ -308,6 +322,9 @@ omit =
    homeassistant/components/wink/*
    homeassistant/components/*/wink.py

+    homeassistant/components/wirelesstag.py
+    homeassistant/components/*/wirelesstag.py
+
    homeassistant/components/xiaomi_aqara.py
    homeassistant/components/*/xiaomi_aqara.py

@@ -326,6 +343,9 @@ omit =
    homeassistant/components/zoneminder.py
    homeassistant/components/*/zoneminder.py

+    homeassistant/components/tuya.py
+    homeassistant/components/*/tuya.py
+
    homeassistant/components/alarm_control_panel/alarmdotcom.py
    homeassistant/components/alarm_control_panel/canary.py
    homeassistant/components/alarm_control_panel/concord232.py
@@ -345,6 +365,7 @@ omit =
    homeassistant/components/binary_sensor/ping.py
    homeassistant/components/binary_sensor/rest.py
    homeassistant/components/binary_sensor/tapsaff.py
+    homeassistant/components/binary_sensor/uptimerobot.py
    homeassistant/components/browser.py
    homeassistant/components/calendar/caldav.py
    homeassistant/components/calendar/todoist.py
@@ -360,6 +381,7 @@ omit =
    homeassistant/components/camera/rpi_camera.py
    homeassistant/components/camera/synology.py
    homeassistant/components/camera/xeoma.py
+    homeassistant/components/camera/xiaomi.py
    homeassistant/components/camera/yi.py
    homeassistant/components/climate/econet.py
    homeassistant/components/climate/ephember.py
@@ -375,6 +397,7 @@ omit =
    homeassistant/components/climate/sensibo.py
    homeassistant/components/climate/touchline.py
    homeassistant/components/climate/venstar.py
+    homeassistant/components/climate/zhong_hong.py
    homeassistant/components/cover/garadget.py
    homeassistant/components/cover/gogogate2.py
    homeassistant/components/cover/homematic.py
@@ -382,6 +405,7 @@ omit =
    homeassistant/components/cover/myq.py
    homeassistant/components/cover/opengarage.py
    homeassistant/components/cover/rpi_gpio.py
+    homeassistant/components/cover/ryobi_gdo.py
    homeassistant/components/cover/scsgate.py
    homeassistant/components/device_tracker/actiontec.py
    homeassistant/components/device_tracker/aruba.py
@@ -393,6 +417,7 @@ omit =
    homeassistant/components/device_tracker/bt_home_hub_5.py
    homeassistant/components/device_tracker/cisco_ios.py
    homeassistant/components/device_tracker/ddwrt.py
+    homeassistant/components/device_tracker/freebox.py
    homeassistant/components/device_tracker/fritz.py
    homeassistant/components/device_tracker/google_maps.py
    homeassistant/components/device_tracker/gpslogger.py
@@ -443,6 +468,7 @@ omit =
    homeassistant/components/light/lifx_legacy.py
    homeassistant/components/light/lifx.py
    homeassistant/components/light/limitlessled.py
+    homeassistant/components/light/lw12wifi.py
    homeassistant/components/light/mystrom.py
    homeassistant/components/light/nanoleaf_aurora.py
    homeassistant/components/light/osramlightify.py
@@ -457,6 +483,7 @@ omit =
    homeassistant/components/light/yeelightsunflower.py
    homeassistant/components/light/zengge.py
    homeassistant/components/lirc.py
+    homeassistant/components/lock/kiwi.py
    homeassistant/components/lock/lockitron.py
    homeassistant/components/lock/nello.py
    homeassistant/components/lock/nuki.py
@@ -467,7 +494,6 @@ omit =
    homeassistant/components/media_player/aquostv.py
    homeassistant/components/media_player/bluesound.py
    homeassistant/components/media_player/braviatv.py
-    homeassistant/components/media_player/cast.py
    homeassistant/components/media_player/channels.py
    homeassistant/components/media_player/clementine.py
    homeassistant/components/media_player/cmus.py
@@ -476,10 +502,12 @@ omit =
    homeassistant/components/media_player/directv.py
    homeassistant/components/media_player/dunehd.py
    homeassistant/components/media_player/emby.py
+    homeassistant/components/media_player/epson.py
    homeassistant/components/media_player/firetv.py
    homeassistant/components/media_player/frontier_silicon.py
    homeassistant/components/media_player/gpmdp.py
    homeassistant/components/media_player/gstreamer.py
+    homeassistant/components/media_player/horizon.py
    homeassistant/components/media_player/itunes.py
    homeassistant/components/media_player/kodi.py
    homeassistant/components/media_player/lg_netcast.py
@@ -501,7 +529,6 @@ omit =
    homeassistant/components/media_player/russound_rnet.py
    homeassistant/components/media_player/snapcast.py
    homeassistant/components/media_player/songpal.py
-    homeassistant/components/media_player/sonos.py
    homeassistant/components/media_player/spotify.py
    homeassistant/components/media_player/squeezebox.py
    homeassistant/components/media_player/ue_smart_radio.py
@@ -518,9 +545,10 @@ omit =
    homeassistant/components/notify/aws_sqs.py
    homeassistant/components/notify/ciscospark.py
    homeassistant/components/notify/clickatell.py
-    homeassistant/components/notify/clicksend_tts.py
    homeassistant/components/notify/clicksend.py
+    homeassistant/components/notify/clicksend_tts.py
    homeassistant/components/notify/discord.py
+    homeassistant/components/notify/flock.py
    homeassistant/components/notify/free_mobile.py
    homeassistant/components/notify/gntp.py
    homeassistant/components/notify/group.py
@@ -533,7 +561,6 @@ omit =
    homeassistant/components/notify/message_bird.py
    homeassistant/components/notify/mycroft.py
    homeassistant/components/notify/nfandroidtv.py
-    homeassistant/components/notify/nma.py
    homeassistant/components/notify/prowl.py
    homeassistant/components/notify/pushbullet.py
    homeassistant/components/notify/pushetta.py
@@ -542,6 +569,7 @@ omit =
    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
    homeassistant/components/notify/smtp.py
    homeassistant/components/notify/stride.py
@@ -589,6 +617,7 @@ omit =
    homeassistant/components/sensor/domain_expiry.py
    homeassistant/components/sensor/dte_energy_bridge.py
    homeassistant/components/sensor/dublin_bus_transport.py
+    homeassistant/components/sensor/duke_energy.py
    homeassistant/components/sensor/dwd_weather_warnings.py
    homeassistant/components/sensor/ebox.py
    homeassistant/components/sensor/eddystone_temperature.py
@@ -619,6 +648,7 @@ omit =
    homeassistant/components/sensor/imap_email_content.py
    homeassistant/components/sensor/imap.py
    homeassistant/components/sensor/influxdb.py
+    homeassistant/components/sensor/iperf3.py
    homeassistant/components/sensor/irish_rail_transport.py
    homeassistant/components/sensor/kwb.py
    homeassistant/components/sensor/lacrosse.py
@@ -637,6 +667,7 @@ omit =
    homeassistant/components/sensor/nederlandse_spoorwegen.py
    homeassistant/components/sensor/netdata.py
    homeassistant/components/sensor/neurio_energy.py
+    homeassistant/components/sensor/nsw_fuel_station.py
    homeassistant/components/sensor/nut.py
    homeassistant/components/sensor/nzbget.py
    homeassistant/components/sensor/ohmconnect.py
@@ -741,6 +772,7 @@ omit =
    homeassistant/components/tts/picotts.py
    homeassistant/components/vacuum/mqtt.py
    homeassistant/components/vacuum/roomba.py
+    homeassistant/components/watson_iot.py
    homeassistant/components/weather/bom.py
    homeassistant/components/weather/buienradar.py
    homeassistant/components/weather/darksky.py
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -20,7 +20,7 @@ If user exposed functionality or configuration variables are added/changed:
 If the code communicates with devices, web services, or third-party tools:
  - [ ] New dependencies have been added to the `REQUIREMENTS` variable ([example][ex-requir]).
  - [ ] New dependencies are only imported inside functions that use them ([example][ex-import]).
-  - [ ] New dependencies have been added to `requirements_all.txt` by running `script/gen_requirements_all.py`.
+  - [ ] New or updated dependencies have been added to `requirements_all.txt` by running `script/gen_requirements_all.py`.
  - [ ] New files were added to `.coveragerc`.

 If the code does not interact with devices:
--- a/.gitignore
+++ b/.gitignore
@@ -107,3 +107,6 @@ desktop.ini

 # Secrets
 .lokalise_token
+
+# monkeytype
+monkeytype.sqlite3
--- a/.isort.cfg
+++ b/.isort.cfg
@@ -0,0 +1,2 @@
+[settings]
+multi_line_output=4
--- a/.travis.yml
+++ b/.travis.yml
@@ -16,11 +16,17 @@ matrix:
      env: TOXENV=py35
    - python: "3.6"
      env: TOXENV=py36
-    # - python: "3.6-dev"
-    #   env: TOXENV=py36
-  # allow_failures:
-  #   - python: "3.5"
-  #     env: TOXENV=typing
+    - python: "3.7"
+      env: TOXENV=py37
+      dist: xenial
+    - python: "3.8-dev"
+      env: TOXENV=py38
+      dist: xenial
+      if: branch = dev AND type = push
+  allow_failures:
+    - python: "3.8-dev"
+      env: TOXENV=py38
+      dist: xenial

 cache:
  directories:
--- a/4
+++ b/4
@@ -70,6 +70,7 @@ homeassistant/components/sensor/filter.py @dgomes
 homeassistant/components/sensor/gearbest.py @HerrHofrat
 homeassistant/components/sensor/irish_rail_transport.py @ttroy50
 homeassistant/components/sensor/miflora.py @danielhiversen @ChristianKuehnel
+homeassistant/components/sensor/nsw_fuel_station.py @nickw444
 homeassistant/components/sensor/pollen.py @bachya
 homeassistant/components/sensor/qnap.py @colinodell
 homeassistant/components/sensor/sma.py @kellerza
@@ -78,7 +79,6 @@ homeassistant/components/sensor/sytadin.py @gautric
 homeassistant/components/sensor/tibber.py @danielhiversen
 homeassistant/components/sensor/upnp.py @dgomes
 homeassistant/components/sensor/waqi.py @andrey-git
-homeassistant/components/switch/rainmachine.py @bachya
 homeassistant/components/switch/tplink.py @rytilahti
 homeassistant/components/vacuum/roomba.py @pschmitt
 homeassistant/components/xiaomi_aqara.py @danielhiversen @syssi
@@ -100,6 +100,8 @@ homeassistant/components/matrix.py @tinloaf
 homeassistant/components/*/matrix.py @tinloaf
 homeassistant/components/qwikswitch.py @kellerza
 homeassistant/components/*/qwikswitch.py @kellerza
+homeassistant/components/rainmachine/* @bachya
+homeassistant/components/*/rainmachine.py @bachya
 homeassistant/components/*/rfxtrx.py @danielhiversen
 homeassistant/components/tahoma.py @philklei
 homeassistant/components/*/tahoma.py @philklei
--- a/1
+++ b/1
@@ -12,6 +12,7 @@ LABEL maintainer="Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>"
 #ENV INSTALL_LIBCEC no
 #ENV INSTALL_PHANTOMJS no
 #ENV INSTALL_SSOCR no
+#ENV INSTALL_IPERF3 no

 VOLUME /config

--- a/docs/swagger.yaml
+++ b/docs/swagger.yaml
@@ -1,606 +0,0 @@
-swagger: '2.0'
-info:
-  title: Home Assistant
-  description: Home Assistant REST API
-  version: "1.0.1"
-# the domain of the service
-host: localhost:8123
-
-# array of all schemes that your API supports
-schemes:
-  - http
-  - https
-
-securityDefinitions:
-  #api_key:
-  #  type: apiKey
-  #  description: API password
-  #  name: api_password
-  #  in: query
-  
-   api_key:
-    type: apiKey
-    description: API password
-    name: x-ha-access
-    in: header
-
-# will be prefixed to all paths
-basePath: /api
-
-consumes:
-  - application/json
-produces:
-  - application/json
-paths:
-  /:
-    get:
-      summary: API alive message
-      description: Returns message if API is up and running.
-      tags:
-        - Core
-      security:
-        - api_key: []
-      responses:
-        200:
-          description: API is up and running
-          schema:
-            $ref: '#/definitions/Message'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /config:
-    get:
-      summary: API alive message
-      description: Returns the current configuration as JSON.
-      tags:
-        - Core
-      security:
-        - api_key: []
-      responses:
-        200:
-          description: Current configuration
-          schema:
-            $ref: '#/definitions/ApiConfig'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /discovery_info:
-    get:
-      summary: Basic information about Home Assistant instance
-      tags:
-        - Core
-      responses:
-        200:
-          description: Basic information
-          schema:
-            $ref: '#/definitions/DiscoveryInfo'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /bootstrap:
-    get:
-      summary: Returns all data needed to bootstrap Home Assistant.
-      tags:
-        - Core
-      security:
-        - api_key: []
-      responses:
-        200:
-          description: Bootstrap information
-          schema:
-            $ref: '#/definitions/BootstrapInfo'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /events:
-    get:
-      summary: Array of event objects.
-      description: Returns an array of event objects. Each event object contain event name and listener count.
-      tags:
-        - Events
-      security:
-        - api_key: []
-      responses:
-        200:
-          description: Events
-          schema:
-            type: array
-            items:
-              $ref: '#/definitions/Event'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /services:
-    get:
-      summary: Array of service objects.
-      description: Returns an array of service objects. Each object contains the domain and which services it contains.
-      tags:
-        - Services
-      security:
-        - api_key: []
-      responses:
-        200:
-          description: Services
-          schema:
-            type: array
-            items:
-              $ref: '#/definitions/Service'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /history:
-    get:
-      summary: Array of state changes in the past.
-      description: Returns an array of state changes in the past. Each object contains further detail for the entities.
-      tags:
-        - State
-      security:
-        - api_key: []
-      responses:
-        200:
-          description: State changes
-          schema:
-            type: array
-            items:
-              $ref: '#/definitions/History'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /states:
-    get:
-      summary: Array of state objects.
-      description: |
-        Returns an array of state objects. Each state has the following attributes: entity_id, state, last_changed and attributes.
-      tags:
-        - State
-      security:
-        - api_key: []
-      responses:
-        200:
-          description: States
-          schema:
-            type: array
-            items:
-              $ref: '#/definitions/State'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /states/{entity_id}:
-    get:
-      summary: Specific state object.
-      description: |
-        Returns a state object for specified entity_id.
-      tags:
-        - State
-      security:
-        - api_key: []
-      parameters:
-      - name: entity_id
-        in: path
-        description: entity_id of the entity to query
-        required: true
-        type: string
-      responses:
-        200:
-          description: State
-          schema:
-            $ref: '#/definitions/State'
-        404:
-          description: Not found
-          schema:
-            $ref: '#/definitions/Message'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-    post:
-      description: |
-        Updates or creates the current state of an entity.
-      tags:
-        - State
-      consumes:
-        - application/json
-      parameters:
-      - name: entity_id
-        in: path
-        description: entity_id to set the state of
-        required: true
-        type: string
-      - $ref: '#/parameters/State'
-      responses:
-        200:
-          description: State of existing entity was set
-          schema:
-            $ref: '#/definitions/State'
-        201:
-          description: State of new entity was set
-          schema:
-            $ref: '#/definitions/State'
-          headers:
-            location:
-              type: string
-              description: location of the new entity
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /error_log:
-    get:
-      summary: Error log
-      description: |
-        Retrieve all errors logged during the current session of Home Assistant as a plaintext response.
-      tags:
-        - Core
-      security:
-        - api_key: []
-      produces:
-        - text/plain
-      responses:
-        200:
-          description: Plain text error log
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /camera_proxy/camera.{entity_id}:
-    get:
-      summary: Camera image.
-      description: |
-        Returns the data (image) from the specified camera entity_id.
-      tags:
-        - Camera
-      security:
-        - api_key: []
-      produces:
-        - image/jpeg
-      parameters:
-      - name: entity_id
-        in: path
-        description: entity_id of the camera to query
-        required: true
-        type: string
-      responses:
-        200:
-          description: Camera image
-          schema:
-            type: file
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /events/{event_type}:
-    post:
-      description: |
-        Fires an event with event_type
-      tags:
-        - Events
-      security:
-        - api_key: []
-      consumes:
-        - application/json
-      parameters:
-      - name: event_type
-        in: path
-        description: event_type to fire event with
-        required: true
-        type: string
-      - $ref: '#/parameters/EventData'
-      responses:
-        200:
-          description: Response message
-          schema:
-            $ref: '#/definitions/Message'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /services/{domain}/{service}:
-    post:
-      description: |
-        Calls a service within a specific domain. Will return when the service has been executed or 10 seconds has past, whichever comes first.
-      tags:
-        - Services
-      security:
-        - api_key: []
-      consumes:
-        - application/json
-      parameters:
-      - name: domain
-        in: path
-        description: domain of the service
-        required: true
-        type: string
-      - name: service
-        in: path
-        description: service to call
-        required: true
-        type: string
-      - $ref: '#/parameters/ServiceData'
-      responses:
-        200:
-          description: List of states that have changed while the service was being executed. The result will include any changed states that changed while the service was being executed, even if their change was the result of something else happening in the system.
-          schema:
-            type: array
-            items:
-              $ref: '#/definitions/State'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /template:
-    post:
-      description: |
-        Render a Home Assistant template.
-      tags:
-        - Template
-      security:
-        - api_key: []
-      consumes:
-        - application/json
-      produces:
-        - text/plain
-      parameters:
-      - $ref: '#/parameters/Template'
-      responses:
-        200:
-          description: Returns the rendered template in plain text.
-          schema:
-            type: string
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /event_forwarding:
-    post:
-      description: |
-        Setup event forwarding to another Home Assistant instance.
-      tags:
-        - Core
-      security:
-        - api_key: []
-      consumes:
-        - application/json
-      parameters:
-      - $ref: '#/parameters/EventForwarding'
-      responses:
-        200:
-          description: It will return a message if event forwarding was setup successful.
-          schema:
-            $ref: '#/definitions/Message'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-    delete:
-      description: |
-        Cancel event forwarding to another Home Assistant instance.
-      tags:
-        - Core
-      consumes:
-        - application/json
-      parameters:
-      - $ref: '#/parameters/EventForwarding'
-      responses:
-        200:
-          description: It will return a message if event forwarding was cancelled successful.
-          schema:
-            $ref: '#/definitions/Message'
-        default:
-          description: Error
-          schema:
-            $ref: '#/definitions/Message'
-  /stream:
-    get:
-      summary: Server-sent events
-      description: The server-sent events feature is a one-way channel from your Home Assistant server to a client which is acting as a consumer.
-      tags:
-        - Core
-        - Events
-      security:
-        - api_key: []
-      produces:
-        - text/event-stream
-      parameters:
-        - name: restrict
-          in: query
-          description: comma-separated list of event_types to filter
-          required: false
-          type: string
-      responses:
-        default:
-          description: Stream of events
-          schema:
-            type: object
-            x-events:
-              state_changed:
-                type: object
-                properties:
-                  entity_id:
-                    type: string
-                  old_state:
-                    $ref: '#/definitions/State'
-                  new_state:
-                    $ref: '#/definitions/State'
-definitions:
-  ApiConfig:
-    type: object
-    properties:
-      components:
-        type: array
-        description: List of component types
-        items:
-          type: string
-          description: Component type
-      latitude:
-        type: number
-        format: float
-        description: Latitude of Home Assistant server
-      longitude:
-        type: number
-        format: float
-        description: Longitude of Home Assistant server
-      location_name:
-        type: string
-      unit_system:
-        type: object
-        properties:
-          length:
-            type: string
-          mass:
-            type: string
-          temperature: 
-            type: string
-          volume:
-            type: string
-      time_zone:
-        type: string
-      version:
-        type: string
-  DiscoveryInfo:
-    type: object
-    properties:
-      base_url:
-        type: string
-      location_name:
-        type: string
-      requires_api_password:
-        type: boolean
-      version:
-        type: string
-  BootstrapInfo:
-    type: object
-    properties:
-      config:
-        $ref: '#/definitions/ApiConfig'
-      events:
-        type: array
-        items:
-          $ref: '#/definitions/Event'
-      services:
-        type: array
-        items:
-          $ref: '#/definitions/Service'
-      states:
-        type: array
-        items:
-          $ref: '#/definitions/State'
-  Event:
-    type: object
-    properties:
-      event:
-        type: string
-      listener_count:
-        type: integer
-  Service:
-    type: object
-    properties:
-      domain:
-        type: string
-      services:
-        type: object
-        additionalProperties:
-          $ref: '#/definitions/DomainService'
-  DomainService:
-    type: object
-    properties:
-      description:
-        type: string
-      fields:
-        type: object
-        description: Object with service fields that can be called
-  State:
-    type: object
-    properties:
-      attributes:
-        $ref: '#/definitions/StateAttributes'
-      state:
-        type: string
-      entity_id:
-        type: string
-      last_changed:
-        type: string
-        format: date-time
-  StateAttributes:
-    type: object
-    additionalProperties:
-      type: string
-  History:
-    allOf:
-    - $ref: '#/definitions/State'
-    - type: object
-      properties:
-        last_updated:
-            type: string
-            format: date-time
-  Message:
-    type: object
-    properties:
-      message:
-        type: string
-parameters:
-  State:
-    name: body
-    in: body
-    description: State parameter
-    required: false
-    schema:
-      type: object
-      required:
-      - state
-      properties:
-        attributes:
-          $ref: '#/definitions/StateAttributes'
-        state:
-          type: string
-  EventData:
-    name: body
-    in: body
-    description: event_data
-    required: false
-    schema:
-      type: object
-  ServiceData:
-    name: body
-    in: body
-    description: service_data
-    required: false
-    schema:
-      type: object
-  Template:
-    name: body
-    in: body
-    description: Template to render
-    required: true
-    schema:
-      type: object
-      required:
-      - template
-      properties:
-        template:
-          description: Jinja2 template string
-          type: string
-  EventForwarding:
-    name: body
-    in: body
-    description: Event Forwarding parameter
-    required: true
-    schema:
-      type: object
-      required:
-      - host
-      - api_password
-      properties:
-        host:
-          type: string
-        api_password:
-          type: string
-        port:
-          type: integer
--- a/homeassistant/main.py
+++ b/homeassistant/main.py
@@ -241,7 +241,7 @@ def cmdline() -> List[str]:


 def setup_and_run_hass(config_dir: str,
-                       args: argparse.Namespace) -> Optional[int]:
+                       args: argparse.Namespace) -> int:
    """Set up HASS and run."""
    from homeassistant import bootstrap

@@ -274,7 +274,7 @@ def setup_and_run_hass(config_dir: str,
            log_no_color=args.log_no_color)

    if hass is None:
-        return None
+        return -1

    if args.open_ui:
        # Imported here to avoid importing asyncio before monkey patch
--- a/homeassistant/auth.py
+++ b/homeassistant/auth.py
@@ -1,503 +0,0 @@
-"""Provide an authentication layer for Home Assistant."""
-import asyncio
-import binascii
-from collections import OrderedDict
-from datetime import datetime, timedelta
-import os
-import importlib
-import logging
-import uuid
-
-import attr
-import voluptuous as vol
-from voluptuous.humanize import humanize_error
-
-from homeassistant import data_entry_flow, requirements
-from homeassistant.core import callback
-from homeassistant.const import CONF_TYPE, CONF_NAME, CONF_ID
-from homeassistant.util.decorator import Registry
-from homeassistant.util import dt as dt_util
-
-
-_LOGGER = logging.getLogger(__name__)
-
-
-AUTH_PROVIDERS = Registry()
-
-AUTH_PROVIDER_SCHEMA = vol.Schema({
-    vol.Required(CONF_TYPE): str,
-    vol.Optional(CONF_NAME): str,
-    # Specify ID if you have two auth providers for same type.
-    vol.Optional(CONF_ID): str,
-}, extra=vol.ALLOW_EXTRA)
-
-ACCESS_TOKEN_EXPIRATION = timedelta(minutes=30)
-DATA_REQS = 'auth_reqs_processed'
-
-
-def generate_secret(entropy: int = 32) -> str:
-    """Generate a secret.
-
-    Backport of secrets.token_hex from Python 3.6
-
-    Event loop friendly.
-    """
-    return binascii.hexlify(os.urandom(entropy)).decode('ascii')
-
-
-class AuthProvider:
-    """Provider of user authentication."""
-
-    DEFAULT_TITLE = 'Unnamed auth provider'
-
-    initialized = False
-
-    def __init__(self, hass, store, config):
-        """Initialize an auth provider."""
-        self.hass = hass
-        self.store = store
-        self.config = config
-
-    @property
-    def id(self):  # pylint: disable=invalid-name
-        """Return id of the auth provider.
-
-        Optional, can be None.
-        """
-        return self.config.get(CONF_ID)
-
-    @property
-    def type(self):
-        """Return type of the provider."""
-        return self.config[CONF_TYPE]
-
-    @property
-    def name(self):
-        """Return the name of the auth provider."""
-        return self.config.get(CONF_NAME, self.DEFAULT_TITLE)
-
-    async def async_credentials(self):
-        """Return all credentials of this provider."""
-        return await self.store.credentials_for_provider(self.type, self.id)
-
-    @callback
-    def async_create_credentials(self, data):
-        """Create credentials."""
-        return Credentials(
-            auth_provider_type=self.type,
-            auth_provider_id=self.id,
-            data=data,
-        )
-
-    # Implement by extending class
-
-    async def async_initialize(self):
-        """Initialize the auth provider.
-
-        Optional.
-        """
-
-    async def async_credential_flow(self):
-        """Return the data flow for logging in with auth provider."""
-        raise NotImplementedError
-
-    async def async_get_or_create_credentials(self, flow_result):
-        """Get credentials based on the flow result."""
-        raise NotImplementedError
-
-    async def async_user_meta_for_credentials(self, credentials):
-        """Return extra user metadata for credentials.
-
-        Will be used to populate info when creating a new user.
-        """
-        return {}
-
-
-@attr.s(slots=True)
-class User:
-    """A user."""
-
-    id = attr.ib(type=str, default=attr.Factory(lambda: uuid.uuid4().hex))
-    is_owner = attr.ib(type=bool, default=False)
-    is_active = attr.ib(type=bool, default=False)
-    name = attr.ib(type=str, default=None)
-    # For persisting and see if saved?
-    # store = attr.ib(type=AuthStore, default=None)
-
-    # List of credentials of a user.
-    credentials = attr.ib(type=list, default=attr.Factory(list))
-
-    # Tokens associated with a user.
-    refresh_tokens = attr.ib(type=dict, default=attr.Factory(dict))
-
-    def as_dict(self):
-        """Convert user object to a dictionary."""
-        return {
-            'id': self.id,
-            'is_owner': self.is_owner,
-            'is_active': self.is_active,
-            'name': self.name,
-        }
-
-
-@attr.s(slots=True)
-class RefreshToken:
-    """RefreshToken for a user to grant new access tokens."""
-
-    user = attr.ib(type=User)
-    client_id = attr.ib(type=str)
-    id = attr.ib(type=str, default=attr.Factory(lambda: uuid.uuid4().hex))
-    created_at = attr.ib(type=datetime, default=attr.Factory(dt_util.utcnow))
-    access_token_expiration = attr.ib(type=timedelta,
-                                      default=ACCESS_TOKEN_EXPIRATION)
-    token = attr.ib(type=str,
-                    default=attr.Factory(lambda: generate_secret(64)))
-    access_tokens = attr.ib(type=list, default=attr.Factory(list))
-
-
-@attr.s(slots=True)
-class AccessToken:
-    """Access token to access the API.
-
-    These will only ever be stored in memory and not be persisted.
-    """
-
-    refresh_token = attr.ib(type=RefreshToken)
-    created_at = attr.ib(type=datetime, default=attr.Factory(dt_util.utcnow))
-    token = attr.ib(type=str,
-                    default=attr.Factory(generate_secret))
-
-    @property
-    def expires(self):
-        """Return datetime when this token expires."""
-        return self.created_at + self.refresh_token.access_token_expiration
-
-
-@attr.s(slots=True)
-class Credentials:
-    """Credentials for a user on an auth provider."""
-
-    auth_provider_type = attr.ib(type=str)
-    auth_provider_id = attr.ib(type=str)
-
-    # Allow the auth provider to store data to represent their auth.
-    data = attr.ib(type=dict)
-
-    id = attr.ib(type=str, default=attr.Factory(lambda: uuid.uuid4().hex))
-    is_new = attr.ib(type=bool, default=True)
-
-
-@attr.s(slots=True)
-class Client:
-    """Client that interacts with Home Assistant on behalf of a user."""
-
-    name = attr.ib(type=str)
-    id = attr.ib(type=str, default=attr.Factory(lambda: uuid.uuid4().hex))
-    secret = attr.ib(type=str, default=attr.Factory(generate_secret))
-    redirect_uris = attr.ib(type=list, default=attr.Factory(list))
-
-
-async def load_auth_provider_module(hass, provider):
-    """Load an auth provider."""
-    try:
-        module = importlib.import_module(
-            'homeassistant.auth_providers.{}'.format(provider))
-    except ImportError:
-        _LOGGER.warning('Unable to find auth provider %s', provider)
-        return None
-
-    if hass.config.skip_pip or not hasattr(module, 'REQUIREMENTS'):
-        return module
-
-    processed = hass.data.get(DATA_REQS)
-
-    if processed is None:
-        processed = hass.data[DATA_REQS] = set()
-    elif provider in processed:
-        return module
-
-    req_success = await requirements.async_process_requirements(
-        hass, 'auth provider {}'.format(provider), module.REQUIREMENTS)
-
-    if not req_success:
-        return None
-
-    return module
-
-
-async def auth_manager_from_config(hass, provider_configs):
-    """Initialize an auth manager from config."""
-    store = AuthStore(hass)
-    if provider_configs:
-        providers = await asyncio.gather(
-            *[_auth_provider_from_config(hass, store, config)
-              for config in provider_configs])
-    else:
-        providers = []
-    # So returned auth providers are in same order as config
-    provider_hash = OrderedDict()
-    for provider in providers:
-        if provider is None:
-            continue
-
-        key = (provider.type, provider.id)
-
-        if key in provider_hash:
-            _LOGGER.error(
-                'Found duplicate provider: %s. Please add unique IDs if you '
-                'want to have the same provider twice.', key)
-            continue
-
-        provider_hash[key] = provider
-    manager = AuthManager(hass, store, provider_hash)
-    return manager
-
-
-async def _auth_provider_from_config(hass, store, config):
-    """Initialize an auth provider from a config."""
-    provider_name = config[CONF_TYPE]
-    module = await load_auth_provider_module(hass, provider_name)
-
-    if module is None:
-        return None
-
-    try:
-        config = module.CONFIG_SCHEMA(config)
-    except vol.Invalid as err:
-        _LOGGER.error('Invalid configuration for auth provider %s: %s',
-                      provider_name, humanize_error(config, err))
-        return None
-
-    return AUTH_PROVIDERS[provider_name](hass, store, config)
-
-
-class AuthManager:
-    """Manage the authentication for Home Assistant."""
-
-    def __init__(self, hass, store, providers):
-        """Initialize the auth manager."""
-        self._store = store
-        self._providers = providers
-        self.login_flow = data_entry_flow.FlowManager(
-            hass, self._async_create_login_flow,
-            self._async_finish_login_flow)
-        self.access_tokens = {}
-
-    @property
-    def async_auth_providers(self):
-        """Return a list of available auth providers."""
-        return self._providers.values()
-
-    async def async_get_user(self, user_id):
-        """Retrieve a user."""
-        return await self._store.async_get_user(user_id)
-
-    async def async_get_or_create_user(self, credentials):
-        """Get or create a user."""
-        return await self._store.async_get_or_create_user(
-            credentials, self._async_get_auth_provider(credentials))
-
-    async def async_link_user(self, user, credentials):
-        """Link credentials to an existing user."""
-        await self._store.async_link_user(user, credentials)
-
-    async def async_remove_user(self, user):
-        """Remove a user."""
-        await self._store.async_remove_user(user)
-
-    async def async_create_refresh_token(self, user, client_id):
-        """Create a new refresh token for a user."""
-        return await self._store.async_create_refresh_token(user, client_id)
-
-    async def async_get_refresh_token(self, token):
-        """Get refresh token by token."""
-        return await self._store.async_get_refresh_token(token)
-
-    @callback
-    def async_create_access_token(self, refresh_token):
-        """Create a new access token."""
-        access_token = AccessToken(refresh_token)
-        self.access_tokens[access_token.token] = access_token
-        return access_token
-
-    @callback
-    def async_get_access_token(self, token):
-        """Get an access token."""
-        return self.access_tokens.get(token)
-
-    async def async_create_client(self, name, *, redirect_uris=None,
-                                  no_secret=False):
-        """Create a new client."""
-        return await self._store.async_create_client(
-            name, redirect_uris, no_secret)
-
-    async def async_get_client(self, client_id):
-        """Get a client."""
-        return await self._store.async_get_client(client_id)
-
-    async def _async_create_login_flow(self, handler, *, source, data):
-        """Create a login flow."""
-        auth_provider = self._providers[handler]
-
-        if not auth_provider.initialized:
-            auth_provider.initialized = True
-            await auth_provider.async_initialize()
-
-        return await auth_provider.async_credential_flow()
-
-    async def _async_finish_login_flow(self, result):
-        """Result of a credential login flow."""
-        if result['type'] != data_entry_flow.RESULT_TYPE_CREATE_ENTRY:
-            return None
-
-        auth_provider = self._providers[result['handler']]
-        return await auth_provider.async_get_or_create_credentials(
-            result['data'])
-
-    @callback
-    def _async_get_auth_provider(self, credentials):
-        """Helper to get auth provider from a set of credentials."""
-        auth_provider_key = (credentials.auth_provider_type,
-                             credentials.auth_provider_id)
-        return self._providers[auth_provider_key]
-
-
-class AuthStore:
-    """Stores authentication info.
-
-    Any mutation to an object should happen inside the auth store.
-
-    The auth store is lazy. It won't load the data from disk until a method is
-    called that needs it.
-    """
-
-    def __init__(self, hass):
-        """Initialize the auth store."""
-        self.hass = hass
-        self.users = None
-        self.clients = None
-        self._load_lock = asyncio.Lock(loop=hass.loop)
-
-    async def credentials_for_provider(self, provider_type, provider_id):
-        """Return credentials for specific auth provider type and id."""
-        if self.users is None:
-            await self.async_load()
-
-        return [
-            credentials
-            for user in self.users.values()
-            for credentials in user.credentials
-            if (credentials.auth_provider_type == provider_type and
-                credentials.auth_provider_id == provider_id)
-        ]
-
-    async def async_get_user(self, user_id):
-        """Retrieve a user."""
-        if self.users is None:
-            await self.async_load()
-
-        return self.users.get(user_id)
-
-    async def async_get_or_create_user(self, credentials, auth_provider):
-        """Get or create a new user for given credentials.
-
-        If link_user is passed in, the credentials will be linked to the passed
-        in user if the credentials are new.
-        """
-        if self.users is None:
-            await self.async_load()
-
-        # New credentials, store in user
-        if credentials.is_new:
-            info = await auth_provider.async_user_meta_for_credentials(
-                credentials)
-            # Make owner and activate user if it's the first user.
-            if self.users:
-                is_owner = False
-                is_active = False
-            else:
-                is_owner = True
-                is_active = True
-
-            new_user = User(
-                is_owner=is_owner,
-                is_active=is_active,
-                name=info.get('name'),
-            )
-            self.users[new_user.id] = new_user
-            await self.async_link_user(new_user, credentials)
-            return new_user
-
-        for user in self.users.values():
-            for creds in user.credentials:
-                if (creds.auth_provider_type == credentials.auth_provider_type
-                        and creds.auth_provider_id ==
-                        credentials.auth_provider_id):
-                    return user
-
-        raise ValueError('We got credentials with ID but found no user')
-
-    async def async_link_user(self, user, credentials):
-        """Add credentials to an existing user."""
-        user.credentials.append(credentials)
-        await self.async_save()
-        credentials.is_new = False
-
-    async def async_remove_user(self, user):
-        """Remove a user."""
-        self.users.pop(user.id)
-        await self.async_save()
-
-    async def async_create_refresh_token(self, user, client_id):
-        """Create a new token for a user."""
-        refresh_token = RefreshToken(user, client_id)
-        user.refresh_tokens[refresh_token.token] = refresh_token
-        await self.async_save()
-        return refresh_token
-
-    async def async_get_refresh_token(self, token):
-        """Get refresh token by token."""
-        if self.users is None:
-            await self.async_load()
-
-        for user in self.users.values():
-            refresh_token = user.refresh_tokens.get(token)
-            if refresh_token is not None:
-                return refresh_token
-
-        return None
-
-    async def async_create_client(self, name, redirect_uris, no_secret):
-        """Create a new client."""
-        if self.clients is None:
-            await self.async_load()
-
-        kwargs = {
-            'name': name,
-            'redirect_uris': redirect_uris
-        }
-
-        if no_secret:
-            kwargs['secret'] = None
-
-        client = Client(**kwargs)
-        self.clients[client.id] = client
-        await self.async_save()
-        return client
-
-    async def async_get_client(self, client_id):
-        """Get a client."""
-        if self.clients is None:
-            await self.async_load()
-
-        return self.clients.get(client_id)
-
-    async def async_load(self):
-        """Load the users."""
-        async with self._load_lock:
-            self.users = {}
-            self.clients = {}
-
-    async def async_save(self):
-        """Save users."""
-        pass
--- a/homeassistant/auth/init.py
+++ b/homeassistant/auth/init.py
@@ -0,0 +1,243 @@
+"""Provide an authentication layer for Home Assistant."""
+import asyncio
+import logging
+from collections import OrderedDict
+
+from homeassistant import data_entry_flow
+from homeassistant.core import callback
+
+from . import models
+from . import auth_store
+from .providers import auth_provider_from_config
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def auth_manager_from_config(hass, provider_configs):
+    """Initialize an auth manager from config."""
+    store = auth_store.AuthStore(hass)
+    if provider_configs:
+        providers = await asyncio.gather(
+            *[auth_provider_from_config(hass, store, config)
+              for config in provider_configs])
+    else:
+        providers = []
+    # So returned auth providers are in same order as config
+    provider_hash = OrderedDict()
+    for provider in providers:
+        if provider is None:
+            continue
+
+        key = (provider.type, provider.id)
+
+        if key in provider_hash:
+            _LOGGER.error(
+                'Found duplicate provider: %s. Please add unique IDs if you '
+                'want to have the same provider twice.', key)
+            continue
+
+        provider_hash[key] = provider
+    manager = AuthManager(hass, store, provider_hash)
+    return manager
+
+
+class AuthManager:
+    """Manage the authentication for Home Assistant."""
+
+    def __init__(self, hass, store, providers):
+        """Initialize the auth manager."""
+        self._store = store
+        self._providers = providers
+        self.login_flow = data_entry_flow.FlowManager(
+            hass, self._async_create_login_flow,
+            self._async_finish_login_flow)
+        self._access_tokens = OrderedDict()
+
+    @property
+    def active(self):
+        """Return if any auth providers are registered."""
+        return bool(self._providers)
+
+    @property
+    def support_legacy(self):
+        """
+        Return if legacy_api_password auth providers are registered.
+
+        Should be removed when we removed legacy_api_password auth providers.
+        """
+        for provider_type, _ in self._providers:
+            if provider_type == 'legacy_api_password':
+                return True
+        return False
+
+    @property
+    def auth_providers(self):
+        """Return a list of available auth providers."""
+        return list(self._providers.values())
+
+    async def async_get_users(self):
+        """Retrieve all users."""
+        return await self._store.async_get_users()
+
+    async def async_get_user(self, user_id):
+        """Retrieve a user."""
+        return await self._store.async_get_user(user_id)
+
+    async def async_create_system_user(self, name):
+        """Create a system user."""
+        return await self._store.async_create_user(
+            name=name,
+            system_generated=True,
+            is_active=True,
+        )
+
+    async def async_create_user(self, name):
+        """Create a user."""
+        kwargs = {
+            'name': name,
+            'is_active': True,
+        }
+
+        if await self._user_should_be_owner():
+            kwargs['is_owner'] = True
+
+        return await self._store.async_create_user(**kwargs)
+
+    async def async_get_or_create_user(self, credentials):
+        """Get or create a user."""
+        if not credentials.is_new:
+            for user in await self._store.async_get_users():
+                for creds in user.credentials:
+                    if creds.id == credentials.id:
+                        return user
+
+            raise ValueError('Unable to find the user.')
+
+        auth_provider = self._async_get_auth_provider(credentials)
+
+        if auth_provider is None:
+            raise RuntimeError('Credential with unknown provider encountered')
+
+        info = await auth_provider.async_user_meta_for_credentials(
+            credentials)
+
+        return await self._store.async_create_user(
+            credentials=credentials,
+            name=info.get('name'),
+            is_active=info.get('is_active', False)
+        )
+
+    async def async_link_user(self, user, credentials):
+        """Link credentials to an existing user."""
+        await self._store.async_link_user(user, credentials)
+
+    async def async_remove_user(self, user):
+        """Remove a user."""
+        tasks = [
+            self.async_remove_credentials(credentials)
+            for credentials in user.credentials
+        ]
+
+        if tasks:
+            await asyncio.wait(tasks)
+
+        await self._store.async_remove_user(user)
+
+    async def async_activate_user(self, user):
+        """Activate a user."""
+        await self._store.async_activate_user(user)
+
+    async def async_deactivate_user(self, user):
+        """Deactivate a user."""
+        if user.is_owner:
+            raise ValueError('Unable to deactive the owner')
+        await self._store.async_deactivate_user(user)
+
+    async def async_remove_credentials(self, credentials):
+        """Remove credentials."""
+        provider = self._async_get_auth_provider(credentials)
+
+        if (provider is not None and
+                hasattr(provider, 'async_will_remove_credentials')):
+            await provider.async_will_remove_credentials(credentials)
+
+        await self._store.async_remove_credentials(credentials)
+
+    async def async_create_refresh_token(self, user, client_id=None):
+        """Create a new refresh token for a user."""
+        if not user.is_active:
+            raise ValueError('User is not active')
+
+        if user.system_generated and client_id is not None:
+            raise ValueError(
+                'System generated users cannot have refresh tokens connected '
+                'to a client.')
+
+        if not user.system_generated and client_id is None:
+            raise ValueError('Client is required to generate a refresh token.')
+
+        return await self._store.async_create_refresh_token(user, client_id)
+
+    async def async_get_refresh_token(self, token):
+        """Get refresh token by token."""
+        return await self._store.async_get_refresh_token(token)
+
+    @callback
+    def async_create_access_token(self, refresh_token):
+        """Create a new access token."""
+        access_token = models.AccessToken(refresh_token=refresh_token)
+        self._access_tokens[access_token.token] = access_token
+        return access_token
+
+    @callback
+    def async_get_access_token(self, token):
+        """Get an access token."""
+        tkn = self._access_tokens.get(token)
+
+        if tkn is None:
+            _LOGGER.debug('Attempt to get non-existing access token')
+            return None
+
+        if tkn.expired or not tkn.refresh_token.user.is_active:
+            if tkn.expired:
+                _LOGGER.debug('Attempt to get expired access token')
+            else:
+                _LOGGER.debug('Attempt to get access token for inactive user')
+            self._access_tokens.pop(token)
+            return None
+
+        return tkn
+
+    async def _async_create_login_flow(self, handler, *, source, data):
+        """Create a login flow."""
+        auth_provider = self._providers[handler]
+
+        return await auth_provider.async_credential_flow()
+
+    async def _async_finish_login_flow(self, result):
+        """Result of a credential login flow."""
+        if result['type'] != data_entry_flow.RESULT_TYPE_CREATE_ENTRY:
+            return None
+
+        auth_provider = self._providers[result['handler']]
+        return await auth_provider.async_get_or_create_credentials(
+            result['data'])
+
+    @callback
+    def _async_get_auth_provider(self, credentials):
+        """Helper to get auth provider from a set of credentials."""
+        auth_provider_key = (credentials.auth_provider_type,
+                             credentials.auth_provider_id)
+        return self._providers.get(auth_provider_key)
+
+    async def _user_should_be_owner(self):
+        """Determine if user should be owner.
+
+        A user should be an owner if it is the first non-system user that is
+        being created.
+        """
+        for user in await self._store.async_get_users():
+            if not user.system_generated:
+                return False
+
+        return True
--- a/homeassistant/auth/auth_store.py
+++ b/homeassistant/auth/auth_store.py
@@ -0,0 +1,240 @@
+"""Storage for auth models."""
+from collections import OrderedDict
+from datetime import timedelta
+
+from homeassistant.util import dt as dt_util
+
+from . import models
+
+STORAGE_VERSION = 1
+STORAGE_KEY = 'auth'
+
+
+class AuthStore:
+    """Stores authentication info.
+
+    Any mutation to an object should happen inside the auth store.
+
+    The auth store is lazy. It won't load the data from disk until a method is
+    called that needs it.
+    """
+
+    def __init__(self, hass):
+        """Initialize the auth store."""
+        self.hass = hass
+        self._users = None
+        self._store = hass.helpers.storage.Store(STORAGE_VERSION, STORAGE_KEY)
+
+    async def async_get_users(self):
+        """Retrieve all users."""
+        if self._users is None:
+            await self.async_load()
+
+        return list(self._users.values())
+
+    async def async_get_user(self, user_id):
+        """Retrieve a user by id."""
+        if self._users is None:
+            await self.async_load()
+
+        return self._users.get(user_id)
+
+    async def async_create_user(self, name, is_owner=None, is_active=None,
+                                system_generated=None, credentials=None):
+        """Create a new user."""
+        if self._users is None:
+            await self.async_load()
+
+        kwargs = {
+            'name': name
+        }
+
+        if is_owner is not None:
+            kwargs['is_owner'] = is_owner
+
+        if is_active is not None:
+            kwargs['is_active'] = is_active
+
+        if system_generated is not None:
+            kwargs['system_generated'] = system_generated
+
+        new_user = models.User(**kwargs)
+
+        self._users[new_user.id] = new_user
+
+        if credentials is None:
+            await self.async_save()
+            return new_user
+
+        # Saving is done inside the link.
+        await self.async_link_user(new_user, credentials)
+        return new_user
+
+    async def async_link_user(self, user, credentials):
+        """Add credentials to an existing user."""
+        user.credentials.append(credentials)
+        await self.async_save()
+        credentials.is_new = False
+
+    async def async_remove_user(self, user):
+        """Remove a user."""
+        self._users.pop(user.id)
+        await self.async_save()
+
+    async def async_activate_user(self, user):
+        """Activate a user."""
+        user.is_active = True
+        await self.async_save()
+
+    async def async_deactivate_user(self, user):
+        """Activate a user."""
+        user.is_active = False
+        await self.async_save()
+
+    async def async_remove_credentials(self, credentials):
+        """Remove credentials."""
+        for user in self._users.values():
+            found = None
+
+            for index, cred in enumerate(user.credentials):
+                if cred is credentials:
+                    found = index
+                    break
+
+            if found is not None:
+                user.credentials.pop(found)
+                break
+
+        await self.async_save()
+
+    async def async_create_refresh_token(self, user, client_id=None):
+        """Create a new token for a user."""
+        refresh_token = models.RefreshToken(user=user, client_id=client_id)
+        user.refresh_tokens[refresh_token.token] = refresh_token
+        await self.async_save()
+        return refresh_token
+
+    async def async_get_refresh_token(self, token):
+        """Get refresh token by token."""
+        if self._users is None:
+            await self.async_load()
+
+        for user in self._users.values():
+            refresh_token = user.refresh_tokens.get(token)
+            if refresh_token is not None:
+                return refresh_token
+
+        return None
+
+    async def async_load(self):
+        """Load the users."""
+        data = await self._store.async_load()
+
+        # Make sure that we're not overriding data if 2 loads happened at the
+        # same time
+        if self._users is not None:
+            return
+
+        users = OrderedDict()
+
+        if data is None:
+            self._users = users
+            return
+
+        for user_dict in data['users']:
+            users[user_dict['id']] = models.User(**user_dict)
+
+        for cred_dict in data['credentials']:
+            users[cred_dict['user_id']].credentials.append(models.Credentials(
+                id=cred_dict['id'],
+                is_new=False,
+                auth_provider_type=cred_dict['auth_provider_type'],
+                auth_provider_id=cred_dict['auth_provider_id'],
+                data=cred_dict['data'],
+            ))
+
+        refresh_tokens = OrderedDict()
+
+        for rt_dict in data['refresh_tokens']:
+            token = models.RefreshToken(
+                id=rt_dict['id'],
+                user=users[rt_dict['user_id']],
+                client_id=rt_dict['client_id'],
+                created_at=dt_util.parse_datetime(rt_dict['created_at']),
+                access_token_expiration=timedelta(
+                    seconds=rt_dict['access_token_expiration']),
+                token=rt_dict['token'],
+            )
+            refresh_tokens[token.id] = token
+            users[rt_dict['user_id']].refresh_tokens[token.token] = token
+
+        for ac_dict in data['access_tokens']:
+            refresh_token = refresh_tokens[ac_dict['refresh_token_id']]
+            token = models.AccessToken(
+                refresh_token=refresh_token,
+                created_at=dt_util.parse_datetime(ac_dict['created_at']),
+                token=ac_dict['token'],
+            )
+            refresh_token.access_tokens.append(token)
+
+        self._users = users
+
+    async def async_save(self):
+        """Save users."""
+        users = [
+            {
+                'id': user.id,
+                'is_owner': user.is_owner,
+                'is_active': user.is_active,
+                'name': user.name,
+                'system_generated': user.system_generated,
+            }
+            for user in self._users.values()
+        ]
+
+        credentials = [
+            {
+                'id': credential.id,
+                'user_id': user.id,
+                'auth_provider_type': credential.auth_provider_type,
+                'auth_provider_id': credential.auth_provider_id,
+                'data': credential.data,
+            }
+            for user in self._users.values()
+            for credential in user.credentials
+        ]
+
+        refresh_tokens = [
+            {
+                'id': refresh_token.id,
+                'user_id': user.id,
+                'client_id': refresh_token.client_id,
+                'created_at': refresh_token.created_at.isoformat(),
+                'access_token_expiration':
+                    refresh_token.access_token_expiration.total_seconds(),
+                'token': refresh_token.token,
+            }
+            for user in self._users.values()
+            for refresh_token in user.refresh_tokens.values()
+        ]
+
+        access_tokens = [
+            {
+                'id': user.id,
+                'refresh_token_id': refresh_token.id,
+                'created_at': access_token.created_at.isoformat(),
+                'token': access_token.token,
+            }
+            for user in self._users.values()
+            for refresh_token in user.refresh_tokens.values()
+            for access_token in refresh_token.access_tokens
+        ]
+
+        data = {
+            'users': users,
+            'credentials': credentials,
+            'access_tokens': access_tokens,
+            'refresh_tokens': refresh_tokens,
+        }
+
+        await self._store.async_save(data, delay=1)
--- a/homeassistant/auth/const.py
+++ b/homeassistant/auth/const.py
@@ -0,0 +1,4 @@
+"""Constants for the auth module."""
+from datetime import timedelta
+
+ACCESS_TOKEN_EXPIRATION = timedelta(minutes=30)
--- a/homeassistant/auth/models.py
+++ b/homeassistant/auth/models.py
@@ -0,0 +1,75 @@
+"""Auth models."""
+from datetime import datetime, timedelta
+import uuid
+
+import attr
+
+from homeassistant.util import dt as dt_util
+
+from .const import ACCESS_TOKEN_EXPIRATION
+from .util import generate_secret
+
+
+@attr.s(slots=True)
+class User:
+    """A user."""
+
+    name = attr.ib(type=str)
+    id = attr.ib(type=str, default=attr.Factory(lambda: uuid.uuid4().hex))
+    is_owner = attr.ib(type=bool, default=False)
+    is_active = attr.ib(type=bool, default=False)
+    system_generated = attr.ib(type=bool, default=False)
+
+    # List of credentials of a user.
+    credentials = attr.ib(type=list, default=attr.Factory(list), cmp=False)
+
+    # Tokens associated with a user.
+    refresh_tokens = attr.ib(type=dict, default=attr.Factory(dict), cmp=False)
+
+
+@attr.s(slots=True)
+class RefreshToken:
+    """RefreshToken for a user to grant new access tokens."""
+
+    user = attr.ib(type=User)
+    client_id = attr.ib(type=str)
+    id = attr.ib(type=str, default=attr.Factory(lambda: uuid.uuid4().hex))
+    created_at = attr.ib(type=datetime, default=attr.Factory(dt_util.utcnow))
+    access_token_expiration = attr.ib(type=timedelta,
+                                      default=ACCESS_TOKEN_EXPIRATION)
+    token = attr.ib(type=str,
+                    default=attr.Factory(lambda: generate_secret(64)))
+    access_tokens = attr.ib(type=list, default=attr.Factory(list), cmp=False)
+
+
+@attr.s(slots=True)
+class AccessToken:
+    """Access token to access the API.
+
+    These will only ever be stored in memory and not be persisted.
+    """
+
+    refresh_token = attr.ib(type=RefreshToken)
+    created_at = attr.ib(type=datetime, default=attr.Factory(dt_util.utcnow))
+    token = attr.ib(type=str,
+                    default=attr.Factory(generate_secret))
+
+    @property
+    def expired(self):
+        """Return if this token has expired."""
+        expires = self.created_at + self.refresh_token.access_token_expiration
+        return dt_util.utcnow() > expires
+
+
+@attr.s(slots=True)
+class Credentials:
+    """Credentials for a user on an auth provider."""
+
+    auth_provider_type = attr.ib(type=str)
+    auth_provider_id = attr.ib(type=str)
+
+    # Allow the auth provider to store data to represent their auth.
+    data = attr.ib(type=dict)
+
+    id = attr.ib(type=str, default=attr.Factory(lambda: uuid.uuid4().hex))
+    is_new = attr.ib(type=bool, default=True)
--- a/homeassistant/auth/providers/init.py
+++ b/homeassistant/auth/providers/init.py
@@ -0,0 +1,143 @@
+"""Auth providers for Home Assistant."""
+import importlib
+import logging
+
+import voluptuous as vol
+from voluptuous.humanize import humanize_error
+
+from homeassistant import requirements
+from homeassistant.core import callback
+from homeassistant.const import CONF_TYPE, CONF_NAME, CONF_ID
+from homeassistant.util.decorator import Registry
+
+from homeassistant.auth.models import Credentials
+
+_LOGGER = logging.getLogger(__name__)
+DATA_REQS = 'auth_prov_reqs_processed'
+
+AUTH_PROVIDERS = Registry()
+
+AUTH_PROVIDER_SCHEMA = vol.Schema({
+    vol.Required(CONF_TYPE): str,
+    vol.Optional(CONF_NAME): str,
+    # Specify ID if you have two auth providers for same type.
+    vol.Optional(CONF_ID): str,
+}, extra=vol.ALLOW_EXTRA)
+
+
+async def auth_provider_from_config(hass, store, config):
+    """Initialize an auth provider from a config."""
+    provider_name = config[CONF_TYPE]
+    module = await load_auth_provider_module(hass, provider_name)
+
+    if module is None:
+        return None
+
+    try:
+        config = module.CONFIG_SCHEMA(config)
+    except vol.Invalid as err:
+        _LOGGER.error('Invalid configuration for auth provider %s: %s',
+                      provider_name, humanize_error(config, err))
+        return None
+
+    return AUTH_PROVIDERS[provider_name](hass, store, config)
+
+
+async def load_auth_provider_module(hass, provider):
+    """Load an auth provider."""
+    try:
+        module = importlib.import_module(
+            'homeassistant.auth.providers.{}'.format(provider))
+    except ImportError:
+        _LOGGER.warning('Unable to find auth provider %s', provider)
+        return None
+
+    if hass.config.skip_pip or not hasattr(module, 'REQUIREMENTS'):
+        return module
+
+    processed = hass.data.get(DATA_REQS)
+
+    if processed is None:
+        processed = hass.data[DATA_REQS] = set()
+    elif provider in processed:
+        return module
+
+    req_success = await requirements.async_process_requirements(
+        hass, 'auth provider {}'.format(provider), module.REQUIREMENTS)
+
+    if not req_success:
+        return None
+
+    processed.add(provider)
+    return module
+
+
+class AuthProvider:
+    """Provider of user authentication."""
+
+    DEFAULT_TITLE = 'Unnamed auth provider'
+
+    def __init__(self, hass, store, config):
+        """Initialize an auth provider."""
+        self.hass = hass
+        self.store = store
+        self.config = config
+
+    @property
+    def id(self):  # pylint: disable=invalid-name
+        """Return id of the auth provider.
+
+        Optional, can be None.
+        """
+        return self.config.get(CONF_ID)
+
+    @property
+    def type(self):
+        """Return type of the provider."""
+        return self.config[CONF_TYPE]
+
+    @property
+    def name(self):
+        """Return the name of the auth provider."""
+        return self.config.get(CONF_NAME, self.DEFAULT_TITLE)
+
+    async def async_credentials(self):
+        """Return all credentials of this provider."""
+        users = await self.store.async_get_users()
+        return [
+            credentials
+            for user in users
+            for credentials in user.credentials
+            if (credentials.auth_provider_type == self.type and
+                credentials.auth_provider_id == self.id)
+        ]
+
+    @callback
+    def async_create_credentials(self, data):
+        """Create credentials."""
+        return Credentials(
+            auth_provider_type=self.type,
+            auth_provider_id=self.id,
+            data=data,
+        )
+
+    # Implement by extending class
+
+    async def async_credential_flow(self):
+        """Return the data flow for logging in with auth provider."""
+        raise NotImplementedError
+
+    async def async_get_or_create_credentials(self, flow_result):
+        """Get credentials based on the flow result."""
+        raise NotImplementedError
+
+    async def async_user_meta_for_credentials(self, credentials):
+        """Return extra user metadata for credentials.
+
+        Will be used to populate info when creating a new user.
+
+        Values to populate:
+         - name: string
+         - is_active: boolean
+        """
+        return {}
--- a/homeassistant/auth/providers/homeassistant.py
+++ b/homeassistant/auth/providers/homeassistant.py
@@ -6,15 +6,29 @@ import hmac

 import voluptuous as vol

-from homeassistant import auth, data_entry_flow
+from homeassistant import data_entry_flow
+from homeassistant.const import CONF_ID
+from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.util import json
+
+from homeassistant.auth.util import generate_secret
+
+from . import AuthProvider, AUTH_PROVIDER_SCHEMA, AUTH_PROVIDERS
+
+STORAGE_VERSION = 1
+STORAGE_KEY = 'auth_provider.homeassistant'


-PATH_DATA = '.users.json'
+def _disallow_id(conf):
+    """Disallow ID in config."""
+    if CONF_ID in conf:
+        raise vol.Invalid(
+            'ID is not allowed for the homeassistant auth provider.')

-CONFIG_SCHEMA = auth.AUTH_PROVIDER_SCHEMA.extend({
-}, extra=vol.PREVENT_EXTRA)
+    return conf
+
+
+CONFIG_SCHEMA = vol.All(AUTH_PROVIDER_SCHEMA, _disallow_id)


 class InvalidAuth(HomeAssistantError):
@@ -31,14 +45,22 @@ class InvalidUser(HomeAssistantError):
 class Data:
    """Hold the user data."""

-    def __init__(self, path, data):
+    def __init__(self, hass):
        """Initialize the user data store."""
-        self.path = path
+        self.hass = hass
+        self._store = hass.helpers.storage.Store(STORAGE_VERSION, STORAGE_KEY)
+        self._data = None
+
+    async def async_load(self):
+        """Load stored data."""
+        data = await self._store.async_load()
+
        if data is None:
            data = {
-                'salt': auth.generate_secret(),
+                'salt': generate_secret(),
                'users': []
            }
+
        self._data = data

    @property
@@ -77,8 +99,8 @@ class Data:
            hashed = base64.b64encode(hashed).decode()
        return hashed

-    def add_user(self, username, password):
-        """Add a user."""
+    def add_auth(self, username, password):
+        """Add a new authenticated user/pass."""
        if any(user['username'] == username for user in self.users):
            raise InvalidUser

@@ -87,8 +109,22 @@ class Data:
            'password': self.hash_password(password, True),
        })

+    @callback
+    def async_remove_auth(self, username):
+        """Remove authentication."""
+        index = None
+        for i, user in enumerate(self.users):
+            if user['username'] == username:
+                index = i
+                break
+
+        if index is None:
+            raise InvalidUser
+
+        self.users.pop(index)
+
    def change_password(self, username, new_password):
-        """Update the password of a user.
+        """Update the password.

        Raises InvalidUser if user cannot be found.
        """
@@ -99,34 +135,38 @@ class Data:
        else:
            raise InvalidUser

-    def save(self):
+    async def async_save(self):
        """Save data."""
-        json.save_json(self.path, self._data)
+        await self._store.async_save(self._data)


-def load_data(path):
-    """Load auth data."""
-    return Data(path, json.load_json(path, None))
-
-
-@auth.AUTH_PROVIDERS.register('homeassistant')
-class HassAuthProvider(auth.AuthProvider):
+@AUTH_PROVIDERS.register('homeassistant')
+class HassAuthProvider(AuthProvider):
    """Auth provider based on a local storage of users in HASS config dir."""

    DEFAULT_TITLE = 'Home Assistant Local'

+    data = None
+
+    async def async_initialize(self):
+        """Initialize the auth provider."""
+        if self.data is not None:
+            return
+
+        self.data = Data(self.hass)
+        await self.data.async_load()
+
    async def async_credential_flow(self):
        """Return a flow to login."""
        return LoginFlow(self)

    async def async_validate_login(self, username, password):
        """Helper to validate a username and password."""
-        def validate():
-            """Validate creds."""
-            data = self._auth_data()
-            data.validate_login(username, password)
+        if self.data is None:
+            await self.async_initialize()

-        await self.hass.async_add_job(validate)
+        await self.hass.async_add_executor_job(
+            self.data.validate_login, username, password)

    async def async_get_or_create_credentials(self, flow_result):
        """Get credentials based on the flow result."""
@@ -141,9 +181,24 @@ class HassAuthProvider(auth.AuthProvider):
            'username': username
        })

-    def _auth_data(self):
-        """Return the auth provider data."""
-        return load_data(self.hass.config.path(PATH_DATA))
+    async def async_user_meta_for_credentials(self, credentials):
+        """Get extra info for this credential."""
+        return {
+            'name': credentials.data['username'],
+            'is_active': True,
+        }
+
+    async def async_will_remove_credentials(self, credentials):
+        """When credentials get removed, also remove the auth."""
+        if self.data is None:
+            await self.async_initialize()
+
+        try:
+            self.data.async_remove_auth(credentials.data['username'])
+            await self.data.async_save()
+        except InvalidUser:
+            # Can happen if somehow we didn't clean up a credential
+            pass


 class LoginFlow(data_entry_flow.FlowHandler):
--- a/homeassistant/auth/providers/insecure_example.py
+++ b/homeassistant/auth/providers/insecure_example.py
@@ -5,9 +5,11 @@ import hmac
 import voluptuous as vol

 from homeassistant.exceptions import HomeAssistantError
-from homeassistant import auth, data_entry_flow
+from homeassistant import data_entry_flow
 from homeassistant.core import callback

+from . import AuthProvider, AUTH_PROVIDER_SCHEMA, AUTH_PROVIDERS
+

 USER_SCHEMA = vol.Schema({
    vol.Required('username'): str,
@@ -16,7 +18,7 @@ USER_SCHEMA = vol.Schema({
 })


-CONFIG_SCHEMA = auth.AUTH_PROVIDER_SCHEMA.extend({
+CONFIG_SCHEMA = AUTH_PROVIDER_SCHEMA.extend({
    vol.Required('users'): [USER_SCHEMA]
 }, extra=vol.PREVENT_EXTRA)

@@ -25,8 +27,8 @@ class InvalidAuthError(HomeAssistantError):
    """Raised when submitting invalid authentication."""


-@auth.AUTH_PROVIDERS.register('insecure_example')
-class ExampleAuthProvider(auth.AuthProvider):
+@AUTH_PROVIDERS.register('insecure_example')
+class ExampleAuthProvider(AuthProvider):
    """Example auth provider based on hardcoded usernames and passwords."""

    async def async_credential_flow(self):
@@ -73,14 +75,16 @@ class ExampleAuthProvider(auth.AuthProvider):
        Will be used to populate info when creating a new user.
        """
        username = credentials.data['username']
+        info = {
+            'is_active': True,
+        }

        for user in self.config['users']:
            if user['username'] == username:
-                return {
-                    'name': user.get('name')
-                }
+                info['name'] = user.get('name')
+                break

-        return {}
+        return info


 class LoginFlow(data_entry_flow.FlowHandler):
--- a/homeassistant/auth/providers/legacy_api_password.py
+++ b/homeassistant/auth/providers/legacy_api_password.py
@@ -0,0 +1,110 @@
+"""
+Support Legacy API password auth provider.
+
+It will be removed when auth system production ready
+"""
+from collections import OrderedDict
+import hmac
+
+import voluptuous as vol
+
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant import data_entry_flow
+from homeassistant.core import callback
+
+from . import AuthProvider, AUTH_PROVIDER_SCHEMA, AUTH_PROVIDERS
+
+
+USER_SCHEMA = vol.Schema({
+    vol.Required('username'): str,
+})
+
+
+CONFIG_SCHEMA = AUTH_PROVIDER_SCHEMA.extend({
+}, extra=vol.PREVENT_EXTRA)
+
+LEGACY_USER = 'homeassistant'
+
+
+class InvalidAuthError(HomeAssistantError):
+    """Raised when submitting invalid authentication."""
+
+
+@AUTH_PROVIDERS.register('legacy_api_password')
+class LegacyApiPasswordAuthProvider(AuthProvider):
+    """Example auth provider based on hardcoded usernames and passwords."""
+
+    DEFAULT_TITLE = 'Legacy API Password'
+
+    async def async_credential_flow(self):
+        """Return a flow to login."""
+        return LoginFlow(self)
+
+    @callback
+    def async_validate_login(self, password):
+        """Helper to validate a username and password."""
+        if not hasattr(self.hass, 'http'):
+            raise ValueError('http component is not loaded')
+
+        if self.hass.http.api_password is None:
+            raise ValueError('http component is not configured using'
+                             ' api_password')
+
+        if not hmac.compare_digest(self.hass.http.api_password.encode('utf-8'),
+                                   password.encode('utf-8')):
+            raise InvalidAuthError
+
+    async def async_get_or_create_credentials(self, flow_result):
+        """Return LEGACY_USER always."""
+        for credential in await self.async_credentials():
+            if credential.data['username'] == LEGACY_USER:
+                return credential
+
+        return self.async_create_credentials({
+            'username': LEGACY_USER
+        })
+
+    async def async_user_meta_for_credentials(self, credentials):
+        """
+        Set name as LEGACY_USER always.
+
+        Will be used to populate info when creating a new user.
+        """
+        return {
+            'name': LEGACY_USER,
+            'is_active': True,
+        }
+
+
+class LoginFlow(data_entry_flow.FlowHandler):
+    """Handler for the login flow."""
+
+    def __init__(self, auth_provider):
+        """Initialize the login flow."""
+        self._auth_provider = auth_provider
+
+    async def async_step_init(self, user_input=None):
+        """Handle the step of the form."""
+        errors = {}
+
+        if user_input is not None:
+            try:
+                self._auth_provider.async_validate_login(
+                    user_input['password'])
+            except InvalidAuthError:
+                errors['base'] = 'invalid_auth'
+
+            if not errors:
+                return self.async_create_entry(
+                    title=self._auth_provider.name,
+                    data={}
+                )
+
+        schema = OrderedDict()
+        schema['password'] = str
+
+        return self.async_show_form(
+            step_id='init',
+            data_schema=vol.Schema(schema),
+            errors=errors,
+        )
--- a/homeassistant/auth/util.py
+++ b/homeassistant/auth/util.py
@@ -0,0 +1,13 @@
+"""Auth utils."""
+import binascii
+import os
+
+
+def generate_secret(entropy: int = 32) -> str:
+    """Generate a secret.
+
+    Backport of secrets.token_hex from Python 3.6
+
+    Event loop friendly.
+    """
+    return binascii.hexlify(os.urandom(entropy)).decode('ascii')
--- a/homeassistant/auth_providers/init.py
+++ b/homeassistant/auth_providers/init.py
@@ -1 +0,0 @@
-"""Auth providers for Home Assistant."""
--- a/homeassistant/bootstrap.py
+++ b/homeassistant/bootstrap.py
@@ -1,5 +1,4 @@
 """Provide methods to bootstrap a Home Assistant instance."""
-import asyncio
 import logging
 import logging.handlers
 import os
@@ -17,7 +16,7 @@ from homeassistant.components import persistent_notification
 from homeassistant.const import EVENT_HOMEASSISTANT_CLOSE
 from homeassistant.setup import async_setup_component
 from homeassistant.util.logging import AsyncHandler
-from homeassistant.util.package import async_get_user_site, get_user_site
+from homeassistant.util.package import async_get_user_site, is_virtual_env
 from homeassistant.util.yaml import clear_secret_cache
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.signal import async_register_signal_handling
@@ -29,9 +28,8 @@ ERROR_LOG_FILENAME = 'home-assistant.log'
 # hass.data key for logging information.
 DATA_LOGGING = 'logging'

-FIRST_INIT_COMPONENT = set((
-    'system_log', 'recorder', 'mqtt', 'mqtt_eventstream', 'logger',
-    'introduction', 'frontend', 'history'))
+FIRST_INIT_COMPONENT = {'system_log', 'recorder', 'mqtt', 'mqtt_eventstream',
+                        'logger', 'introduction', 'frontend', 'history'}


 def from_config_dict(config: Dict[str, Any],
@@ -53,8 +51,9 @@ def from_config_dict(config: Dict[str, Any],
        if config_dir is not None:
            config_dir = os.path.abspath(config_dir)
            hass.config.config_dir = config_dir
-            hass.loop.run_until_complete(
-                async_mount_local_lib_path(config_dir, hass.loop))
+            if not is_virtual_env():
+                hass.loop.run_until_complete(
+                    async_mount_local_lib_path(config_dir))

    # run task
    hass = hass.loop.run_until_complete(
@@ -95,7 +94,8 @@ async def async_from_config_dict(config: Dict[str, Any],
        conf_util.async_log_exception(ex, 'homeassistant', core_config, hass)
        return None

-    await hass.async_add_job(conf_util.process_ha_config_upgrade, hass)
+    await hass.async_add_executor_job(
+        conf_util.process_ha_config_upgrade, hass)

    hass.config.skip_pip = skip_pip
    if skip_pip:
@@ -123,7 +123,6 @@ async def async_from_config_dict(config: Dict[str, Any],
    components.update(hass.config_entries.async_domains())

    # setup components
-    # pylint: disable=not-an-iterable
    res = await core_components.async_setup(hass, config)
    if not res:
        _LOGGER.error("Home Assistant core failed to initialize. "
@@ -138,7 +137,7 @@ async def async_from_config_dict(config: Dict[str, Any],
    for component in components:
        if component not in FIRST_INIT_COMPONENT:
            continue
-        hass.async_add_job(async_setup_component(hass, component, config))
+        hass.async_create_task(async_setup_component(hass, component, config))

    await hass.async_block_till_done()

@@ -146,7 +145,7 @@ async def async_from_config_dict(config: Dict[str, Any],
    for component in components:
        if component in FIRST_INIT_COMPONENT:
            continue
-        hass.async_add_job(async_setup_component(hass, component, config))
+        hass.async_create_task(async_setup_component(hass, component, config))

    await hass.async_block_till_done()

@@ -163,7 +162,8 @@ def from_config_file(config_path: str,
                     skip_pip: bool = True,
                     log_rotate_days: Any = None,
                     log_file: Any = None,
-                     log_no_color: bool = False):
+                     log_no_color: bool = False)\
+        -> Optional[core.HomeAssistant]:
    """Read the configuration file and try to start all the functionality.

    Will add functionality to 'hass' parameter if given,
@@ -188,7 +188,8 @@ async def async_from_config_file(config_path: str,
                                 skip_pip: bool = True,
                                 log_rotate_days: Any = None,
                                 log_file: Any = None,
-                                 log_no_color: bool = False):
+                                 log_no_color: bool = False)\
+        -> Optional[core.HomeAssistant]:
    """Read the configuration file and try to start all the functionality.

    Will add functionality to 'hass' parameter.
@@ -197,13 +198,15 @@ async def async_from_config_file(config_path: str,
    # Set config dir to directory holding config file
    config_dir = os.path.abspath(os.path.dirname(config_path))
    hass.config.config_dir = config_dir
-    await async_mount_local_lib_path(config_dir, hass.loop)
+
+    if not is_virtual_env():
+        await async_mount_local_lib_path(config_dir)

    async_enable_logging(hass, verbose, log_rotate_days, log_file,
                         log_no_color)

    try:
-        config_dict = await hass.async_add_job(
+        config_dict = await hass.async_add_executor_job(
            conf_util.load_yaml_config_file, config_path)
    except HomeAssistantError as err:
        _LOGGER.error("Error loading %s: %s", config_path, err)
@@ -211,9 +214,8 @@ async def async_from_config_file(config_path: str,
    finally:
        clear_secret_cache()

-    hass = await async_from_config_dict(
+    return await async_from_config_dict(
        config_dict, hass, enable_log=False, skip_pip=skip_pip)
-    return hass


@core.callback
@@ -308,23 +310,13 @@ def async_enable_logging(hass: core.HomeAssistant,
            "Unable to setup error log %s (access denied)", err_log_path)


-def mount_local_lib_path(config_dir: str) -> str:
-    """Add local library to Python Path."""
-    deps_dir = os.path.join(config_dir, 'deps')
-    lib_dir = get_user_site(deps_dir)
-    if lib_dir not in sys.path:
-        sys.path.insert(0, lib_dir)
-    return deps_dir
-
-
-async def async_mount_local_lib_path(config_dir: str,
-                                     loop: asyncio.AbstractEventLoop) -> str:
+async def async_mount_local_lib_path(config_dir: str) -> str:
    """Add local library to Python Path.

    This function is a coroutine.
    """
    deps_dir = os.path.join(config_dir, 'deps')
-    lib_dir = await async_get_user_site(deps_dir, loop=loop)
+    lib_dir = await async_get_user_site(deps_dir)
    if lib_dir not in sys.path:
        sys.path.insert(0, lib_dir)
    return deps_dir
--- a/homeassistant/components/alarm_control_panel/init.py
+++ b/homeassistant/components/alarm_control_panel/init.py
@@ -121,7 +121,7 @@ def alarm_arm_custom_bypass(hass, code=None, entity_id=None):
@asyncio.coroutine
 def async_setup(hass, config):
    """Track states and offer events for sensors."""
-    component = EntityComponent(
+    component = hass.data[DOMAIN] = EntityComponent(
        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)

    yield from component.async_setup(config)
@@ -154,6 +154,16 @@ def async_setup(hass, config):
    return True


+async def async_setup_entry(hass, entry):
+    """Setup a config entry."""
+    return await hass.data[DOMAIN].async_setup_entry(entry)
+
+
+async def async_unload_entry(hass, entry):
+    """Unload a config entry."""
+    return await hass.data[DOMAIN].async_unload_entry(entry)
+
+
 # pylint: disable=no-self-use
 class AlarmControlPanel(Entity):
    """An abstract class for alarm control devices."""
--- a/homeassistant/components/alarm_control_panel/alarmdecoder.py
+++ b/homeassistant/components/alarm_control_panel/alarmdecoder.py
@@ -100,8 +100,8 @@ class AlarmDecoderAlarmPanel(alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """Return the regex for code format or None if no code is required."""
-        return '^\\d{4,6}$'
+        """Return one or more digits/characters."""
+        return 'Number'

    @property
    def state(self):
--- a/homeassistant/components/alarm_control_panel/alarmdotcom.py
+++ b/homeassistant/components/alarm_control_panel/alarmdotcom.py
@@ -6,6 +6,7 @@ https://home-assistant.io/components/alarm_control_panel.alarmdotcom/
 """
 import asyncio
 import logging
+import re

 import voluptuous as vol

@@ -79,8 +80,12 @@ class AlarmDotCom(alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """Return one or more characters if code is defined."""
-        return None if self._code is None else '.+'
+        """Return one or more digits/characters."""
+        if self._code is None:
+            return None
+        elif isinstance(self._code, str) and re.search('^\\d+$', self._code):
+            return 'Number'
+        return 'Any'

    @property
    def state(self):
--- a/homeassistant/components/alarm_control_panel/arlo.py
+++ b/homeassistant/components/alarm_control_panel/arlo.py
@@ -4,15 +4,17 @@ 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.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.components.alarm_control_panel import (
    AlarmControlPanel, PLATFORM_SCHEMA)
-from homeassistant.components.arlo import (DATA_ARLO, CONF_ATTRIBUTION)
+from homeassistant.components.arlo import (
+    DATA_ARLO, CONF_ATTRIBUTION, SIGNAL_UPDATE_ARLO)
 from homeassistant.const import (
    ATTR_ATTRIBUTION, STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
    STATE_ALARM_DISARMED)
@@ -36,21 +38,20 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-@asyncio.coroutine
-def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Arlo Alarm Control Panels."""
-    data = hass.data[DATA_ARLO]
+    arlo = hass.data[DATA_ARLO]

-    if not data.base_stations:
+    if not arlo.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:
+    for base_station in arlo.base_stations:
        base_stations.append(ArloBaseStation(base_station, home_mode_name,
                                             away_mode_name))
-    async_add_devices(base_stations, True)
+    add_devices(base_stations, True)


 class ArloBaseStation(AlarmControlPanel):
@@ -68,6 +69,16 @@ class ArloBaseStation(AlarmControlPanel):
        """Return icon."""
        return ICON

+    async def async_added_to_hass(self):
+        """Register callbacks."""
+        async_dispatcher_connect(
+            self.hass, SIGNAL_UPDATE_ARLO, self._update_callback)
+
+    @callback
+    def _update_callback(self):
+        """Call update method."""
+        self.async_schedule_update_ha_state(True)
+
    @property
    def state(self):
        """Return the state of the device."""
@@ -75,30 +86,22 @@ class ArloBaseStation(AlarmControlPanel):

    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
+        _LOGGER.debug("Updating Arlo Alarm Control Panel %s", self.name)
+        mode = self._base_station.mode
+        if mode:
+            self._state = self._get_state_from_mode(mode)
+        else:
+            self._state = None

-    @asyncio.coroutine
-    def async_alarm_disarm(self, code=None):
+    async 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):
+    async 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):
+    async def async_alarm_arm_home(self, code=None):
        """Send arm home command. Uses custom mode."""
        self._base_station.mode = self._home_mode_name

@@ -125,4 +128,4 @@ class ArloBaseStation(AlarmControlPanel):
            return STATE_ALARM_ARMED_HOME
        elif mode == self._away_mode_name:
            return STATE_ALARM_ARMED_AWAY
-        return None
+        return mode
--- a/homeassistant/components/alarm_control_panel/concord232.py
+++ b/homeassistant/components/alarm_control_panel/concord232.py
@@ -80,7 +80,7 @@ class Concord232Alarm(alarm.AlarmControlPanel):
    @property
    def code_format(self):
        """Return the characters if code is defined."""
-        return '[0-9]{4}([0-9]{2})?'
+        return 'Number'

    @property
    def state(self):
--- a/homeassistant/components/alarm_control_panel/envisalink.py
+++ b/homeassistant/components/alarm_control_panel/envisalink.py
@@ -106,7 +106,7 @@ class EnvisalinkAlarm(EnvisalinkDevice, alarm.AlarmControlPanel):
        """Regex for code format or None if no code is required."""
        if self._code:
            return None
-        return '^\\d{4,6}$'
+        return 'Number'

    @property
    def state(self):
--- a/homeassistant/components/alarm_control_panel/homematicip_cloud.py
+++ b/homeassistant/components/alarm_control_panel/homematicip_cloud.py
@@ -0,0 +1,88 @@
+"""
+Support for HomematicIP alarm control panel.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.homematicip_cloud/
+"""
+
+import logging
+
+from homeassistant.const import (
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED,
+    STATE_ALARM_TRIGGERED)
+from homeassistant.components.alarm_control_panel import AlarmControlPanel
+from homeassistant.components.homematicip_cloud import (
+    HomematicipGenericDevice, DOMAIN as HMIPC_DOMAIN,
+    HMIPC_HAPID)
+
+
+DEPENDENCIES = ['homematicip_cloud']
+
+_LOGGER = logging.getLogger(__name__)
+
+HMIP_OPEN = 'OPEN'
+HMIP_ZONE_AWAY = 'EXTERNAL'
+HMIP_ZONE_HOME = 'INTERNAL'
+
+
+async def async_setup_platform(hass, config, async_add_devices,
+                               discovery_info=None):
+    """Set up the HomematicIP alarm control devices."""
+    pass
+
+
+async def async_setup_entry(hass, config_entry, async_add_devices):
+    """Set up the HomematicIP alarm control panel from a config entry."""
+    from homematicip.aio.group import AsyncSecurityZoneGroup
+
+    home = hass.data[HMIPC_DOMAIN][config_entry.data[HMIPC_HAPID]].home
+    devices = []
+    for group in home.groups:
+        if isinstance(group, AsyncSecurityZoneGroup):
+            devices.append(HomematicipSecurityZone(home, group))
+
+    if devices:
+        async_add_devices(devices)
+
+
+class HomematicipSecurityZone(HomematicipGenericDevice, AlarmControlPanel):
+    """Representation of an HomematicIP security zone group."""
+
+    def __init__(self, home, device):
+        """Initialize the security zone group."""
+        device.modelType = 'Group-SecurityZone'
+        device.windowState = ''
+        super().__init__(home, device)
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        if self._device.active:
+            if (self._device.sabotage or self._device.motionDetected or
+                    self._device.windowState == HMIP_OPEN):
+                return STATE_ALARM_TRIGGERED
+
+            if self._device.label == HMIP_ZONE_HOME:
+                return STATE_ALARM_ARMED_HOME
+            return STATE_ALARM_ARMED_AWAY
+
+        return STATE_ALARM_DISARMED
+
+    async def async_alarm_disarm(self, code=None):
+        """Send disarm command."""
+        await self._home.set_security_zones_activation(False, False)
+
+    async def async_alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        await self._home.set_security_zones_activation(True, False)
+
+    async def async_alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        await self._home.set_security_zones_activation(True, True)
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the alarm control device."""
+        # The base class is loading the battery property, but device doesn't
+        # have this property - base class needs clean-up.
+        return None
--- a/homeassistant/components/alarm_control_panel/ifttt.py
+++ b/homeassistant/components/alarm_control_panel/ifttt.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.ifttt/
 """
 import logging
+import re

 import voluptuous as vol

@@ -124,8 +125,12 @@ class IFTTTAlarmPanel(alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """Return one or more characters."""
-        return None if self._code is None else '.+'
+        """Return one or more digits/characters."""
+        if self._code is None:
+            return None
+        elif isinstance(self._code, str) and re.search('^\\d+$', self._code):
+            return 'Number'
+        return 'Any'

    def alarm_disarm(self, code=None):
        """Send disarm command."""
--- a/homeassistant/components/alarm_control_panel/manual.py
+++ b/homeassistant/components/alarm_control_panel/manual.py
@@ -7,6 +7,7 @@ https://home-assistant.io/components/alarm_control_panel.manual/
 import copy
 import datetime
 import logging
+import re

 import voluptuous as vol

@@ -201,8 +202,12 @@ class ManualAlarm(alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """Return one or more characters."""
-        return None if self._code is None else '.+'
+        """Return one or more digits/characters."""
+        if self._code is None:
+            return None
+        elif isinstance(self._code, str) and re.search('^\\d+$', self._code):
+            return 'Number'
+        return 'Any'

    def alarm_disarm(self, code=None):
        """Send disarm command."""
--- a/homeassistant/components/alarm_control_panel/manual_mqtt.py
+++ b/homeassistant/components/alarm_control_panel/manual_mqtt.py
@@ -8,6 +8,7 @@ import asyncio
 import copy
 import datetime
 import logging
+import re

 import voluptuous as vol

@@ -237,8 +238,12 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """Return one or more characters."""
-        return None if self._code is None else '.+'
+        """Return one or more digits/characters."""
+        if self._code is None:
+            return None
+        elif isinstance(self._code, str) and re.search('^\\d+$', self._code):
+            return 'Number'
+        return 'Any'

    def alarm_disarm(self, code=None):
        """Send disarm command."""
--- a/homeassistant/components/alarm_control_panel/mqtt.py
+++ b/homeassistant/components/alarm_control_panel/mqtt.py
@@ -6,6 +6,7 @@ https://home-assistant.io/components/alarm_control_panel.mqtt/
 """
 import asyncio
 import logging
+import re

 import voluptuous as vol

@@ -19,7 +20,7 @@ from homeassistant.const import (
 from homeassistant.components.mqtt import (
    CONF_AVAILABILITY_TOPIC, CONF_STATE_TOPIC, CONF_COMMAND_TOPIC,
    CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_QOS,
-    MqttAvailability)
+    CONF_RETAIN, MqttAvailability)
 import homeassistant.helpers.config_validation as cv

 _LOGGER = logging.getLogger(__name__)
@@ -53,6 +54,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
        config.get(CONF_STATE_TOPIC),
        config.get(CONF_COMMAND_TOPIC),
        config.get(CONF_QOS),
+        config.get(CONF_RETAIN),
        config.get(CONF_PAYLOAD_DISARM),
        config.get(CONF_PAYLOAD_ARM_HOME),
        config.get(CONF_PAYLOAD_ARM_AWAY),
@@ -65,9 +67,9 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 class MqttAlarm(MqttAvailability, alarm.AlarmControlPanel):
    """Representation of a MQTT alarm status."""

-    def __init__(self, name, state_topic, command_topic, qos, payload_disarm,
-                 payload_arm_home, payload_arm_away, code, availability_topic,
-                 payload_available, payload_not_available):
+    def __init__(self, name, state_topic, command_topic, qos, retain,
+                 payload_disarm, payload_arm_home, payload_arm_away, code,
+                 availability_topic, payload_available, payload_not_available):
        """Init the MQTT Alarm Control Panel."""
        super().__init__(availability_topic, qos, payload_available,
                         payload_not_available)
@@ -76,6 +78,7 @@ class MqttAlarm(MqttAvailability, alarm.AlarmControlPanel):
        self._state_topic = state_topic
        self._command_topic = command_topic
        self._qos = qos
+        self._retain = retain
        self._payload_disarm = payload_disarm
        self._payload_arm_home = payload_arm_home
        self._payload_arm_away = payload_arm_away
@@ -117,8 +120,12 @@ class MqttAlarm(MqttAvailability, alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """One or more characters if code is defined."""
-        return None if self._code is None else '.+'
+        """Return one or more digits/characters."""
+        if self._code is None:
+            return None
+        elif isinstance(self._code, str) and re.search('^\\d+$', self._code):
+            return 'Number'
+        return 'Any'

    @asyncio.coroutine
    def async_alarm_disarm(self, code=None):
@@ -129,7 +136,8 @@ class MqttAlarm(MqttAvailability, alarm.AlarmControlPanel):
        if not self._validate_code(code, 'disarming'):
            return
        mqtt.async_publish(
-            self.hass, self._command_topic, self._payload_disarm, self._qos)
+            self.hass, self._command_topic, self._payload_disarm, self._qos,
+            self._retain)

    @asyncio.coroutine
    def async_alarm_arm_home(self, code=None):
@@ -140,7 +148,8 @@ class MqttAlarm(MqttAvailability, alarm.AlarmControlPanel):
        if not self._validate_code(code, 'arming home'):
            return
        mqtt.async_publish(
-            self.hass, self._command_topic, self._payload_arm_home, self._qos)
+            self.hass, self._command_topic, self._payload_arm_home, self._qos,
+            self._retain)

    @asyncio.coroutine
    def async_alarm_arm_away(self, code=None):
@@ -151,7 +160,8 @@ class MqttAlarm(MqttAvailability, alarm.AlarmControlPanel):
        if not self._validate_code(code, 'arming away'):
            return
        mqtt.async_publish(
-            self.hass, self._command_topic, self._payload_arm_away, self._qos)
+            self.hass, self._command_topic, self._payload_arm_away, self._qos,
+            self._retain)

    def _validate_code(self, code, state):
        """Validate given code."""
--- a/homeassistant/components/alarm_control_panel/nx584.py
+++ b/homeassistant/components/alarm_control_panel/nx584.py
@@ -69,8 +69,8 @@ class NX584Alarm(alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """Return che characters if code is defined."""
-        return '[0-9]{4}([0-9]{2})?'
+        """Return one or more digits/characters."""
+        return 'Number'

    @property
    def state(self):
--- a/homeassistant/components/alarm_control_panel/satel_integra.py
+++ b/homeassistant/components/alarm_control_panel/satel_integra.py
@@ -66,7 +66,7 @@ class SatelIntegraAlarmPanel(alarm.AlarmControlPanel):
    @property
    def code_format(self):
        """Return the regex for code format or None if no code is required."""
-        return '^\\d{4,6}$'
+        return 'Number'

    @property
    def state(self):
--- a/homeassistant/components/alarm_control_panel/simplisafe.py
+++ b/homeassistant/components/alarm_control_panel/simplisafe.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.simplisafe/
 """
 import logging
+import re

 import voluptuous as vol

@@ -83,8 +84,12 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """Return one or more characters if code is defined."""
-        return None if self._code is None else '.+'
+        """Return one or more digits/characters."""
+        if self._code is None:
+            return None
+        elif isinstance(self._code, str) and re.search('^\\d+$', self._code):
+            return 'Number'
+        return 'Any'

    @property
    def state(self):
--- a/homeassistant/components/alarm_control_panel/totalconnect.py
+++ b/homeassistant/components/alarm_control_panel/totalconnect.py
@@ -18,7 +18,7 @@ from homeassistant.const import (
    STATE_ALARM_ARMED_CUSTOM_BYPASS)


-REQUIREMENTS = ['total_connect_client==0.17']
+REQUIREMENTS = ['total_connect_client==0.18']

 _LOGGER = logging.getLogger(__name__)

--- a/homeassistant/components/alarm_control_panel/verisure.py
+++ b/homeassistant/components/alarm_control_panel/verisure.py
@@ -60,8 +60,8 @@ class VerisureAlarm(alarm.AlarmControlPanel):

    @property
    def code_format(self):
-        """Return the code format as regex."""
-        return '^\\d{%s}$' % self._digits
+        """Return one or more digits/characters."""
+        return 'Number'

    @property
    def changed_by(self):
--- a/homeassistant/components/alexa/smart_home.py
+++ b/homeassistant/components/alexa/smart_home.py
@@ -107,7 +107,6 @@ class _DisplayCategory(object):
    THERMOSTAT = "THERMOSTAT"

    # Indicates the endpoint is a television.
-    # pylint: disable=invalid-name
    TV = "TV"


@@ -271,11 +270,14 @@ class _AlexaInterface(object):
        """Return properties serialized for an API response."""
        for prop in self.properties_supported():
            prop_name = prop['name']
-            yield {
-                'name': prop_name,
-                'namespace': self.name(),
-                'value': self.get_property(prop_name),
-            }
+            # pylint: disable=assignment-from-no-return
+            prop_value = self.get_property(prop_name)
+            if prop_value is not None:
+                yield {
+                    'name': prop_name,
+                    'namespace': self.name(),
+                    'value': prop_value,
+                }


 class _AlexaPowerController(_AlexaInterface):
@@ -439,14 +441,17 @@ class _AlexaThermostatController(_AlexaInterface):
        unit = self.entity.attributes[CONF_UNIT_OF_MEASUREMENT]
        temp = None
        if name == 'targetSetpoint':
-            temp = self.entity.attributes.get(ATTR_TEMPERATURE)
+            temp = self.entity.attributes.get(climate.ATTR_TEMPERATURE)
        elif name == 'lowerSetpoint':
            temp = self.entity.attributes.get(climate.ATTR_TARGET_TEMP_LOW)
        elif name == 'upperSetpoint':
            temp = self.entity.attributes.get(climate.ATTR_TARGET_TEMP_HIGH)
-        if temp is None:
+        else:
            raise _UnsupportedProperty(name)

+        if temp is None:
+            return None
+
        return {
            'value': float(temp),
            'scale': API_TEMP_UNITS[unit],
@@ -1474,9 +1479,6 @@ async def async_api_set_thermostat_mode(hass, config, request, entity):
    mode = mode if isinstance(mode, str) else mode['value']

    operation_list = entity.attributes.get(climate.ATTR_OPERATION_LIST)
-    # Work around a pylint false positive due to
-    #  https://github.com/PyCQA/pylint/issues/1830
-    # pylint: disable=stop-iteration-return
    ha_mode = next(
        (k for k, v in API_THERMOSTAT_MODES.items() if v == mode),
        None
--- a/homeassistant/components/amcrest.py
+++ b/homeassistant/components/amcrest.py
@@ -18,7 +18,7 @@ from homeassistant.const import (
 from homeassistant.helpers import discovery
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['amcrest==1.2.2']
+REQUIREMENTS = ['amcrest==1.2.3']
 DEPENDENCIES = ['ffmpeg']

 _LOGGER = logging.getLogger(__name__)
--- a/homeassistant/components/api.py
+++ b/homeassistant/components/api.py
@@ -2,7 +2,7 @@
 Rest API for Home Assistant.

 For more details about the RESTful API, please refer to the documentation at
-https://home-assistant.io/developers/api/
+https://developers.home-assistant.io/docs/en/external_api_rest.html
 """
 import asyncio
 import json
@@ -11,31 +11,34 @@ import logging
 from aiohttp import web
 import async_timeout

-import homeassistant.core as ha
-import homeassistant.remote as rem
 from homeassistant.bootstrap import DATA_LOGGING
-from homeassistant.const import (
-    EVENT_HOMEASSISTANT_STOP, EVENT_TIME_CHANGED,
-    HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND,
-    MATCH_ALL, URL_API, URL_API_COMPONENTS,
-    URL_API_CONFIG, URL_API_DISCOVERY_INFO, URL_API_ERROR_LOG,
-    URL_API_EVENTS, URL_API_SERVICES,
-    URL_API_STATES, URL_API_STATES_ENTITY, URL_API_STREAM, URL_API_TEMPLATE,
-    __version__)
-from homeassistant.exceptions import TemplateError
-from homeassistant.helpers.state import AsyncTrackStates
-from homeassistant.helpers.service import async_get_all_descriptions
-from homeassistant.helpers import template
 from homeassistant.components.http import HomeAssistantView
+from homeassistant.const import (
+    EVENT_HOMEASSISTANT_STOP, EVENT_TIME_CHANGED, HTTP_BAD_REQUEST,
+    HTTP_CREATED, HTTP_NOT_FOUND, MATCH_ALL, URL_API, URL_API_COMPONENTS,
+    URL_API_CONFIG, URL_API_DISCOVERY_INFO, URL_API_ERROR_LOG, URL_API_EVENTS,
+    URL_API_SERVICES, URL_API_STATES, URL_API_STATES_ENTITY, URL_API_STREAM,
+    URL_API_TEMPLATE, __version__)
+import homeassistant.core as ha
+from homeassistant.exceptions import TemplateError
+from homeassistant.helpers import template
+from homeassistant.helpers.service import async_get_all_descriptions
+from homeassistant.helpers.state import AsyncTrackStates
+import homeassistant.remote as rem
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_BASE_URL = 'base_url'
+ATTR_LOCATION_NAME = 'location_name'
+ATTR_REQUIRES_API_PASSWORD = 'requires_api_password'
+ATTR_VERSION = 'version'

 DOMAIN = 'api'
 DEPENDENCIES = ['http']

-STREAM_PING_PAYLOAD = "ping"
+STREAM_PING_PAYLOAD = 'ping'
 STREAM_PING_INTERVAL = 50  # seconds

-_LOGGER = logging.getLogger(__name__)
-

 def setup(hass, config):
    """Register the API with the HTTP interface."""
@@ -62,23 +65,22 @@ class APIStatusView(HomeAssistantView):
    """View to handle Status requests."""

    url = URL_API
-    name = "api:status"
+    name = 'api:status'

    @ha.callback
    def get(self, request):
        """Retrieve if API is running."""
-        return self.json_message('API running.')
+        return self.json_message("API running.")


 class APIEventStream(HomeAssistantView):
    """View to handle EventStream requests."""

    url = URL_API_STREAM
-    name = "api:stream"
+    name = 'api:stream'

    async def get(self, request):
        """Provide a streaming interface for the event bus."""
-        # pylint: disable=no-self-use
        hass = request.app['hass']
        stop_obj = object()
        to_write = asyncio.Queue(loop=hass.loop)
@@ -95,7 +97,7 @@ class APIEventStream(HomeAssistantView):
            if restrict and event.event_type not in restrict:
                return

-            _LOGGER.debug('STREAM %s FORWARDING %s', id(stop_obj), event)
+            _LOGGER.debug("STREAM %s FORWARDING %s", id(stop_obj), event)

            if event.event_type == EVENT_HOMEASSISTANT_STOP:
                data = stop_obj
@@ -111,7 +113,7 @@ class APIEventStream(HomeAssistantView):
        unsub_stream = hass.bus.async_listen(MATCH_ALL, forward_events)

        try:
-            _LOGGER.debug('STREAM %s ATTACHED', id(stop_obj))
+            _LOGGER.debug("STREAM %s ATTACHED", id(stop_obj))

            # Fire off one message so browsers fire open event right away
            await to_write.put(STREAM_PING_PAYLOAD)
@@ -126,25 +128,25 @@ class APIEventStream(HomeAssistantView):
                        break

                    msg = "data: {}\n\n".format(payload)
-                    _LOGGER.debug('STREAM %s WRITING %s', id(stop_obj),
-                                  msg.strip())
-                    await response.write(msg.encode("UTF-8"))
+                    _LOGGER.debug(
+                        "STREAM %s WRITING %s", id(stop_obj), msg.strip())
+                    await response.write(msg.encode('UTF-8'))
                except asyncio.TimeoutError:
                    await to_write.put(STREAM_PING_PAYLOAD)

        except asyncio.CancelledError:
-            _LOGGER.debug('STREAM %s ABORT', id(stop_obj))
+            _LOGGER.debug("STREAM %s ABORT", id(stop_obj))

        finally:
-            _LOGGER.debug('STREAM %s RESPONSE CLOSED', id(stop_obj))
+            _LOGGER.debug("STREAM %s RESPONSE CLOSED", id(stop_obj))
            unsub_stream()


 class APIConfigView(HomeAssistantView):
-    """View to handle Config requests."""
+    """View to handle Configuration requests."""

    url = URL_API_CONFIG
-    name = "api:config"
+    name = 'api:config'

    @ha.callback
    def get(self, request):
@@ -153,22 +155,22 @@ class APIConfigView(HomeAssistantView):


 class APIDiscoveryView(HomeAssistantView):
-    """View to provide discovery info."""
+    """View to provide Discovery information."""

    requires_auth = False
    url = URL_API_DISCOVERY_INFO
-    name = "api:discovery"
+    name = 'api:discovery'

    @ha.callback
    def get(self, request):
-        """Get discovery info."""
+        """Get discovery information."""
        hass = request.app['hass']
        needs_auth = hass.config.api.api_password is not None
        return self.json({
-            'base_url': hass.config.api.base_url,
-            'location_name': hass.config.location_name,
-            'requires_api_password': needs_auth,
-            'version': __version__
+            ATTR_BASE_URL: hass.config.api.base_url,
+            ATTR_LOCATION_NAME: hass.config.location_name,
+            ATTR_REQUIRES_API_PASSWORD: needs_auth,
+            ATTR_VERSION: __version__,
        })


@@ -187,8 +189,8 @@ class APIStatesView(HomeAssistantView):
 class APIEntityStateView(HomeAssistantView):
    """View to handle EntityState requests."""

-    url = "/api/states/{entity_id}"
-    name = "api:entity-state"
+    url = '/api/states/{entity_id}'
+    name = 'api:entity-state'

    @ha.callback
    def get(self, request, entity_id):
@@ -196,7 +198,7 @@ class APIEntityStateView(HomeAssistantView):
        state = request.app['hass'].states.get(entity_id)
        if state:
            return self.json(state)
-        return self.json_message('Entity not found', HTTP_NOT_FOUND)
+        return self.json_message("Entity not found.", HTTP_NOT_FOUND)

    async def post(self, request, entity_id):
        """Update state of entity."""
@@ -204,13 +206,13 @@ class APIEntityStateView(HomeAssistantView):
        try:
            data = await request.json()
        except ValueError:
-            return self.json_message('Invalid JSON specified',
-                                     HTTP_BAD_REQUEST)
+            return self.json_message(
+                "Invalid JSON specified.", HTTP_BAD_REQUEST)

        new_state = data.get('state')

        if new_state is None:
-            return self.json_message('No state specified', HTTP_BAD_REQUEST)
+            return self.json_message("No state specified.", HTTP_BAD_REQUEST)

        attributes = data.get('attributes')
        force_update = data.get('force_update', False)
@@ -232,15 +234,15 @@ class APIEntityStateView(HomeAssistantView):
    def delete(self, request, entity_id):
        """Remove entity."""
        if request.app['hass'].states.async_remove(entity_id):
-            return self.json_message('Entity removed')
-        return self.json_message('Entity not found', HTTP_NOT_FOUND)
+            return self.json_message("Entity removed.")
+        return self.json_message("Entity not found.", HTTP_NOT_FOUND)


 class APIEventListenersView(HomeAssistantView):
    """View to handle EventListeners requests."""

    url = URL_API_EVENTS
-    name = "api:event-listeners"
+    name = 'api:event-listeners'

    @ha.callback
    def get(self, request):
@@ -252,7 +254,7 @@ class APIEventView(HomeAssistantView):
    """View to handle Event requests."""

    url = '/api/events/{event_type}'
-    name = "api:event"
+    name = 'api:event'

    async def post(self, request, event_type):
        """Fire events."""
@@ -260,12 +262,12 @@ class APIEventView(HomeAssistantView):
        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)
+            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',
-                                     HTTP_BAD_REQUEST)
+            return self.json_message(
+                "Event data should be a JSON object", HTTP_BAD_REQUEST)

        # Special case handling for event STATE_CHANGED
        # We will try to convert state dicts back to State objects
@@ -276,8 +278,8 @@ class APIEventView(HomeAssistantView):
                if state:
                    event_data[key] = state

-        request.app['hass'].bus.async_fire(event_type, event_data,
-                                           ha.EventOrigin.remote)
+        request.app['hass'].bus.async_fire(
+            event_type, event_data, ha.EventOrigin.remote)

        return self.json_message("Event {} fired.".format(event_type))

@@ -286,7 +288,7 @@ class APIServicesView(HomeAssistantView):
    """View to handle Services requests."""

    url = URL_API_SERVICES
-    name = "api:services"
+    name = 'api:services'

    async def get(self, request):
        """Get registered services."""
@@ -297,8 +299,8 @@ class APIServicesView(HomeAssistantView):
 class APIDomainServicesView(HomeAssistantView):
    """View to handle DomainServices requests."""

-    url = "/api/services/{domain}/{service}"
-    name = "api:domain-services"
+    url = '/api/services/{domain}/{service}'
+    name = 'api:domain-services'

    async def post(self, request, domain, service):
        """Call a service.
@@ -310,8 +312,8 @@ class APIDomainServicesView(HomeAssistantView):
        try:
            data = json.loads(body) if body else None
        except ValueError:
-            return self.json_message('Data should be valid JSON',
-                                     HTTP_BAD_REQUEST)
+            return self.json_message(
+                "Data should be valid JSON.", HTTP_BAD_REQUEST)

        with AsyncTrackStates(hass) as changed_states:
            await hass.services.async_call(domain, service, data, True)
@@ -323,7 +325,7 @@ class APIComponentsView(HomeAssistantView):
    """View to handle Components requests."""

    url = URL_API_COMPONENTS
-    name = "api:components"
+    name = 'api:components'

    @ha.callback
    def get(self, request):
@@ -332,10 +334,10 @@ class APIComponentsView(HomeAssistantView):


 class APITemplateView(HomeAssistantView):
-    """View to handle requests."""
+    """View to handle Template requests."""

    url = URL_API_TEMPLATE
-    name = "api:template"
+    name = 'api:template'

    async def post(self, request):
        """Render a template."""
@@ -344,30 +346,29 @@ class APITemplateView(HomeAssistantView):
            tpl = template.Template(data['template'], request.app['hass'])
            return tpl.async_render(data.get('variables'))
        except (ValueError, TemplateError) as ex:
-            return self.json_message('Error rendering template: {}'.format(ex),
-                                     HTTP_BAD_REQUEST)
+            return self.json_message(
+                "Error rendering template: {}".format(ex), HTTP_BAD_REQUEST)


 class APIErrorLog(HomeAssistantView):
-    """View to fetch the error log."""
+    """View to fetch the API error log."""

    url = URL_API_ERROR_LOG
-    name = "api:error_log"
+    name = 'api:error_log'

    async def get(self, request):
        """Retrieve API error log."""
-        return web.FileResponse(
-            request.app['hass'].data[DATA_LOGGING])
+        return web.FileResponse(request.app['hass'].data[DATA_LOGGING])


 async def async_services_json(hass):
    """Generate services data to JSONify."""
    descriptions = await async_get_all_descriptions(hass)
-    return [{"domain": key, "services": value}
+    return [{'domain': key, 'services': value}
            for key, value in descriptions.items()]


 def async_events_json(hass):
    """Generate event data to JSONify."""
-    return [{"event": key, "listener_count": value}
+    return [{'event': key, 'listener_count': value}
            for key, value in hass.bus.async_listeners().items()]
--- a/homeassistant/components/apple_tv.py
+++ b/homeassistant/components/apple_tv.py
@@ -17,7 +17,7 @@ from homeassistant.helpers import discovery
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['pyatv==0.3.9']
+REQUIREMENTS = ['pyatv==0.3.10']

 _LOGGER = logging.getLogger(__name__)

--- a/homeassistant/components/arlo.py
+++ b/homeassistant/components/arlo.py
@@ -5,14 +5,18 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/arlo/
 """
 import logging
+from datetime import timedelta

 import voluptuous as vol
 from requests.exceptions import HTTPError, ConnectTimeout

 from homeassistant.helpers import config_validation as cv
-from homeassistant.const import CONF_USERNAME, CONF_PASSWORD
+from homeassistant.const import (
+    CONF_USERNAME, CONF_PASSWORD, CONF_SCAN_INTERVAL)
+from homeassistant.helpers.event import track_time_interval
+from homeassistant.helpers.dispatcher import dispatcher_send

-REQUIREMENTS = ['pyarlo==0.1.2']
+REQUIREMENTS = ['pyarlo==0.1.9']

 _LOGGER = logging.getLogger(__name__)

@@ -25,10 +29,16 @@ DOMAIN = 'arlo'
 NOTIFICATION_ID = 'arlo_notification'
 NOTIFICATION_TITLE = 'Arlo Component Setup'

+SCAN_INTERVAL = timedelta(seconds=60)
+
+SIGNAL_UPDATE_ARLO = "arlo_update"
+
 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
        vol.Required(CONF_USERNAME): cv.string,
        vol.Required(CONF_PASSWORD): cv.string,
+        vol.Optional(CONF_SCAN_INTERVAL, default=SCAN_INTERVAL):
+            cv.time_period,
    }),
 }, extra=vol.ALLOW_EXTRA)

@@ -38,6 +48,7 @@ def setup(hass, config):
    conf = config[DOMAIN]
    username = conf.get(CONF_USERNAME)
    password = conf.get(CONF_PASSWORD)
+    scan_interval = conf.get(CONF_SCAN_INTERVAL)

    try:
        from pyarlo import PyArlo
@@ -45,7 +56,17 @@ def setup(hass, config):
        arlo = PyArlo(username, password, preload=False)
        if not arlo.is_connected:
            return False
+
+        # assign refresh period to base station thread
+        arlo_base_station = next((
+            station for station in arlo.base_stations), None)
+
+        if arlo_base_station is None:
+            return False
+
+        arlo_base_station.refresh_rate = scan_interval.total_seconds()
        hass.data[DATA_ARLO] = arlo
+
    except (ConnectTimeout, HTTPError) as ex:
        _LOGGER.error("Unable to connect to Netgear Arlo: %s", str(ex))
        hass.components.persistent_notification.create(
@@ -55,4 +76,17 @@ def setup(hass, config):
            title=NOTIFICATION_TITLE,
            notification_id=NOTIFICATION_ID)
        return False
+
+    def hub_refresh(event_time):
+        """Call ArloHub to refresh information."""
+        _LOGGER.info("Updating Arlo Hub component")
+        hass.data[DATA_ARLO].update(update_cameras=True,
+                                    update_base_station=True)
+        dispatcher_send(hass, SIGNAL_UPDATE_ARLO)
+
+    # register service
+    hass.services.register(DOMAIN, 'update', hub_refresh)
+
+    # register scan interval for ArloHub
+    track_time_interval(hass, hub_refresh, scan_interval)
    return True
--- a/homeassistant/components/auth/init.py
+++ b/homeassistant/components/auth/init.py
@@ -102,6 +102,7 @@ a limited expiration.
    "token_type": "Bearer"
 }
 """
+from datetime import timedelta
 import logging
 import uuid

@@ -112,13 +113,22 @@ from homeassistant import data_entry_flow
 from homeassistant.core import callback
 from homeassistant.helpers.data_entry_flow import (
    FlowManagerIndexView, FlowManagerResourceView)
+from homeassistant.components import websocket_api
 from homeassistant.components.http.view import HomeAssistantView
 from homeassistant.components.http.data_validator import RequestDataValidator
+from homeassistant.util import dt as dt_util
+
+from . import indieauth

-from .client import verify_client

 DOMAIN = 'auth'
 DEPENDENCIES = ['http']
+
+WS_TYPE_CURRENT_USER = 'auth/current_user'
+SCHEMA_WS_CURRENT_USER = websocket_api.BASE_COMMAND_MESSAGE_SCHEMA.extend({
+    vol.Required('type'): WS_TYPE_CURRENT_USER,
+})
+
 _LOGGER = logging.getLogger(__name__)


@@ -133,6 +143,11 @@ async def async_setup(hass, config):
    hass.http.register_view(GrantTokenView(retrieve_credentials))
    hass.http.register_view(LinkUserView(retrieve_credentials))

+    hass.components.websocket_api.async_register_command(
+        WS_TYPE_CURRENT_USER, websocket_current_user,
+        SCHEMA_WS_CURRENT_USER
+    )
+
    return True


@@ -143,14 +158,13 @@ class AuthProvidersView(HomeAssistantView):
    name = 'api:auth:providers'
    requires_auth = False

-    @verify_client
-    async def get(self, request, client):
+    async def get(self, request):
        """Get available auth providers."""
        return self.json([{
            'name': provider.name,
            'id': provider.id,
            'type': provider.type,
-        } for provider in request.app['hass'].auth.async_auth_providers])
+        } for provider in request.app['hass'].auth.auth_providers])


 class LoginFlowIndexView(FlowManagerIndexView):
@@ -164,16 +178,16 @@ class LoginFlowIndexView(FlowManagerIndexView):
        """Do not allow index of flows in progress."""
        return aiohttp.web.Response(status=405)

-    # pylint: disable=arguments-differ
-    @verify_client
    @RequestDataValidator(vol.Schema({
+        vol.Required('client_id'): str,
        vol.Required('handler'): vol.Any(str, list),
        vol.Required('redirect_uri'): str,
    }))
-    async def post(self, request, client, data):
+    async def post(self, request, data):
        """Create a new login flow."""
-        if data['redirect_uri'] not in client.redirect_uris:
-            return self.json_message('invalid redirect uri', )
+        if not indieauth.verify_redirect_uri(data['client_id'],
+                                             data['redirect_uri']):
+            return self.json_message('invalid client id or redirect uri', 400)

        # pylint: disable=no-value-for-parameter
        return await super().post(request)
@@ -191,16 +205,20 @@ class LoginFlowResourceView(FlowManagerResourceView):
        super().__init__(flow_mgr)
        self._store_credentials = store_credentials

-    # pylint: disable=arguments-differ
-    async def get(self, request):
+    async def get(self, request, flow_id):
        """Do not allow getting status of a flow in progress."""
        return self.json_message('Invalid flow specified', 404)

-    # pylint: disable=arguments-differ
-    @verify_client
-    @RequestDataValidator(vol.Schema(dict), allow_empty=True)
-    async def post(self, request, client, flow_id, data):
+    @RequestDataValidator(vol.Schema({
+        'client_id': str
+    }, extra=vol.ALLOW_EXTRA))
+    async def post(self, request, flow_id, data):
        """Handle progressing a login flow request."""
+        client_id = data.pop('client_id')
+
+        if not indieauth.verify_client_id(client_id):
+            return self.json_message('Invalid client id', 400)
+
        try:
            result = await self._flow_mgr.async_configure(flow_id, data)
        except data_entry_flow.UnknownFlow:
@@ -212,7 +230,7 @@ class LoginFlowResourceView(FlowManagerResourceView):
            return self.json(self._prepare_result_json(result))

        result.pop('data')
-        result['result'] = self._store_credentials(client.id, result['result'])
+        result['result'] = self._store_credentials(client_id, result['result'])

        return self.json(result)

@@ -223,25 +241,32 @@ class GrantTokenView(HomeAssistantView):
    url = '/auth/token'
    name = 'api:auth:token'
    requires_auth = False
+    cors_allowed = True

    def __init__(self, retrieve_credentials):
        """Initialize the grant token view."""
        self._retrieve_credentials = retrieve_credentials

-    @verify_client
-    async def post(self, request, client):
+    async def post(self, request):
        """Grant a token."""
        hass = request.app['hass']
        data = await request.post()
+
+        client_id = data.get('client_id')
+        if client_id is None or not indieauth.verify_client_id(client_id):
+            return self.json({
+                'error': 'invalid_request',
+                'error_description': 'Invalid client id',
+            }, status_code=400)
+
        grant_type = data.get('grant_type')

        if grant_type == 'authorization_code':
-            return await self._async_handle_auth_code(
-                hass, client.id, data)
+            return await self._async_handle_auth_code(hass, client_id, data)

        elif grant_type == 'refresh_token':
            return await self._async_handle_refresh_token(
-                hass, client.id, data)
+                hass, client_id, data)

        return self.json({
            'error': 'unsupported_grant_type',
@@ -261,9 +286,17 @@ class GrantTokenView(HomeAssistantView):
        if credentials is None:
            return self.json({
                'error': 'invalid_request',
+                'error_description': 'Invalid code',
            }, status_code=400)

        user = await hass.auth.async_get_or_create_user(credentials)
+
+        if not user.is_active:
+            return self.json({
+                'error': 'access_denied',
+                'error_description': 'User is not active',
+            }, status_code=403)
+
        refresh_token = await hass.auth.async_create_refresh_token(user,
                                                                   client_id)
        access_token = hass.auth.async_create_access_token(refresh_token)
@@ -340,12 +373,43 @@ def _create_cred_store():
    def store_credentials(client_id, credentials):
        """Store credentials and return a code to retrieve it."""
        code = uuid.uuid4().hex
-        temp_credentials[(client_id, code)] = credentials
+        temp_credentials[(client_id, code)] = (dt_util.utcnow(), credentials)
        return code

    @callback
    def retrieve_credentials(client_id, code):
        """Retrieve credentials."""
-        return temp_credentials.pop((client_id, code), None)
+        key = (client_id, code)
+
+        if key not in temp_credentials:
+            return None
+
+        created, credentials = temp_credentials.pop(key)
+
+        # OAuth 4.2.1
+        # The authorization code MUST expire shortly after it is issued to
+        # mitigate the risk of leaks.  A maximum authorization code lifetime of
+        # 10 minutes is RECOMMENDED.
+        if dt_util.utcnow() - created < timedelta(minutes=10):
+            return credentials
+
+        return None

    return store_credentials, retrieve_credentials
+
+
+@callback
+def websocket_current_user(hass, connection, msg):
+    """Return the current user."""
+    user = connection.request.get('hass_user')
+
+    if user is None:
+        connection.to_write.put_nowait(websocket_api.error_message(
+            msg['id'], 'no_user', 'Not authenticated as a user'))
+        return
+
+    connection.to_write.put_nowait(websocket_api.result_message(msg['id'], {
+        'id': user.id,
+        'name': user.name,
+        'is_owner': user.is_owner,
+    }))
--- a/homeassistant/components/auth/client.py
+++ b/homeassistant/components/auth/client.py
@@ -1,79 +0,0 @@
-"""Helpers to resolve client ID/secret."""
-import base64
-from functools import wraps
-import hmac
-
-import aiohttp.hdrs
-
-
-def verify_client(method):
-    """Decorator to verify client id/secret on requests."""
-    @wraps(method)
-    async def wrapper(view, request, *args, **kwargs):
-        """Verify client id/secret before doing request."""
-        client = await _verify_client(request)
-
-        if client is None:
-            return view.json({
-                'error': 'invalid_client',
-            }, status_code=401)
-
-        return await method(
-            view, request, *args, **kwargs, client=client)
-
-    return wrapper
-
-
-async def _verify_client(request):
-    """Method to verify the client id/secret in consistent time.
-
-    By using a consistent time for looking up client id and comparing the
-    secret, we prevent attacks by malicious actors trying different client ids
-    and are able to derive from the time it takes to process the request if
-    they guessed the client id correctly.
-    """
-    if aiohttp.hdrs.AUTHORIZATION not in request.headers:
-        return None
-
-    auth_type, auth_value = \
-        request.headers.get(aiohttp.hdrs.AUTHORIZATION).split(' ', 1)
-
-    if auth_type != 'Basic':
-        return None
-
-    decoded = base64.b64decode(auth_value).decode('utf-8')
-    try:
-        client_id, client_secret = decoded.split(':', 1)
-    except ValueError:
-        # If no ':' in decoded
-        client_id, client_secret = decoded, None
-
-    return await async_secure_get_client(
-        request.app['hass'], client_id, client_secret)
-
-
-async def async_secure_get_client(hass, client_id, client_secret):
-    """Get a client id/secret in consistent time."""
-    client = await hass.auth.async_get_client(client_id)
-
-    if client is None:
-        if client_secret is not None:
-            # Still do a compare so we run same time as if a client was found.
-            hmac.compare_digest(client_secret.encode('utf-8'),
-                                client_secret.encode('utf-8'))
-        return None
-
-    if client.secret is None:
-        return client
-
-    elif client_secret is None:
-        # Still do a compare so we run same time as if a secret was passed.
-        hmac.compare_digest(client.secret.encode('utf-8'),
-                            client.secret.encode('utf-8'))
-        return None
-
-    elif hmac.compare_digest(client_secret.encode('utf-8'),
-                             client.secret.encode('utf-8')):
-        return client
-
-    return None
--- a/homeassistant/components/auth/indieauth.py
+++ b/homeassistant/components/auth/indieauth.py
@@ -0,0 +1,130 @@
+"""Helpers to resolve client ID/secret."""
+from ipaddress import ip_address, ip_network
+from urllib.parse import urlparse
+
+# IP addresses of loopback interfaces
+ALLOWED_IPS = (
+    ip_address('127.0.0.1'),
+    ip_address('::1'),
+)
+
+# RFC1918 - Address allocation for Private Internets
+ALLOWED_NETWORKS = (
+    ip_network('10.0.0.0/8'),
+    ip_network('172.16.0.0/12'),
+    ip_network('192.168.0.0/16'),
+)
+
+
+def verify_redirect_uri(client_id, redirect_uri):
+    """Verify that the client and redirect uri match."""
+    try:
+        client_id_parts = _parse_client_id(client_id)
+    except ValueError:
+        return False
+
+    redirect_parts = _parse_url(redirect_uri)
+
+    # IndieAuth 4.2.2 allows for redirect_uri to be on different domain
+    # but needs to be specified in link tag when fetching `client_id`.
+    # This is not implemented.
+
+    # Verify redirect url and client url have same scheme and domain.
+    return (
+        client_id_parts.scheme == redirect_parts.scheme and
+        client_id_parts.netloc == redirect_parts.netloc
+    )
+
+
+def verify_client_id(client_id):
+    """Verify that the client id is valid."""
+    try:
+        _parse_client_id(client_id)
+        return True
+    except ValueError:
+        return False
+
+
+def _parse_url(url):
+    """Parse a url in parts and canonicalize according to IndieAuth."""
+    parts = urlparse(url)
+
+    # Canonicalize a url according to IndieAuth 3.2.
+
+    # SHOULD convert the hostname to lowercase
+    parts = parts._replace(netloc=parts.netloc.lower())
+
+    # If a URL with no path component is ever encountered,
+    # it MUST be treated as if it had the path /.
+    if parts.path == '':
+        parts = parts._replace(path='/')
+
+    return parts
+
+
+def _parse_client_id(client_id):
+    """Test if client id is a valid URL according to IndieAuth section 3.2.
+
+    https://indieauth.spec.indieweb.org/#client-identifier
+    """
+    parts = _parse_url(client_id)
+
+    # Client identifier URLs
+    # MUST have either an https or http scheme
+    if parts.scheme not in ('http', 'https'):
+        raise ValueError()
+
+    # MUST contain a path component
+    # Handled by url canonicalization.
+
+    # MUST NOT contain single-dot or double-dot path segments
+    if any(segment in ('.', '..') for segment in parts.path.split('/')):
+        raise ValueError(
+            'Client ID cannot contain single-dot or double-dot path segments')
+
+    # MUST NOT contain a fragment component
+    if parts.fragment != '':
+        raise ValueError('Client ID cannot contain a fragment')
+
+    # MUST NOT contain a username or password component
+    if parts.username is not None:
+        raise ValueError('Client ID cannot contain username')
+
+    if parts.password is not None:
+        raise ValueError('Client ID cannot contain password')
+
+    # MAY contain a port
+    try:
+        # parts raises ValueError when port cannot be parsed as int
+        parts.port
+    except ValueError:
+        raise ValueError('Client ID contains invalid port')
+
+    # Additionally, hostnames
+    # MUST be domain names or a loopback interface and
+    # MUST NOT be IPv4 or IPv6 addresses except for IPv4 127.0.0.1
+    # or IPv6 [::1]
+
+    # We are not goint to follow the spec here. We are going to allow
+    # any internal network IP to be used inside a client id.
+
+    address = None
+
+    try:
+        netloc = parts.netloc
+
+        # Strip the [, ] from ipv6 addresses before parsing
+        if netloc[0] == '[' and netloc[-1] == ']':
+            netloc = netloc[1:-1]
+
+        address = ip_address(netloc)
+    except ValueError:
+        # Not an ip address
+        pass
+
+    if (address is None or
+            address in ALLOWED_IPS or
+            any(address in network for network in ALLOWED_NETWORKS)):
+        return parts
+
+    raise ValueError('Hostname should be a domain name or local IP address')
--- a/homeassistant/components/automation/init.py
+++ b/homeassistant/components/automation/init.py
@@ -98,7 +98,7 @@ SERVICE_SCHEMA = vol.Schema({
 })

 TRIGGER_SERVICE_SCHEMA = vol.Schema({
-    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Required(ATTR_ENTITY_ID): cv.entity_ids,
    vol.Optional(ATTR_VARIABLES, default={}): dict,
 })

--- a/homeassistant/components/axis.py
+++ b/homeassistant/components/axis.py
@@ -145,7 +145,7 @@ def request_configuration(hass, config, name, host, serialnumber):

 def setup(hass, config):
    """Set up for Axis devices."""
-    def _shutdown(call):  # pylint: disable=unused-argument
+    def _shutdown(call):
        """Stop the event stream on shutdown."""
        for serialnumber, device in AXIS_DEVICES.items():
            _LOGGER.info("Stopping event stream for %s.", serialnumber)
@@ -272,8 +272,7 @@ class AxisDeviceEvent(Entity):

    def _update_callback(self):
        """Update the sensor's state, if needed."""
-        self.update()
-        self.schedule_update_ha_state()
+        self.schedule_update_ha_state(True)

    @property
    def name(self):
--- a/homeassistant/components/bbb_gpio.py
+++ b/homeassistant/components/bbb_gpio.py
@@ -16,7 +16,6 @@ _LOGGER = logging.getLogger(__name__)
 DOMAIN = 'bbb_gpio'


-# pylint: disable=no-member
 def setup(hass, config):
    """Set up the BeagleBone Black GPIO component."""
    # pylint: disable=import-error
@@ -34,41 +33,39 @@ def setup(hass, config):
    return True


-# noqa: F821
-
 def setup_output(pin):
    """Set up a GPIO as output."""
-    # pylint: disable=import-error,undefined-variable
+    # pylint: disable=import-error
    import Adafruit_BBIO.GPIO as GPIO
    GPIO.setup(pin, GPIO.OUT)


 def setup_input(pin, pull_mode):
    """Set up a GPIO as input."""
-    # pylint: disable=import-error,undefined-variable
+    # pylint: disable=import-error
    import Adafruit_BBIO.GPIO as GPIO
-    GPIO.setup(pin, GPIO.IN,                            # noqa: F821
-               GPIO.PUD_DOWN if pull_mode == 'DOWN'     # noqa: F821
-               else GPIO.PUD_UP)                        # noqa: F821
+    GPIO.setup(pin, GPIO.IN,
+               GPIO.PUD_DOWN if pull_mode == 'DOWN'
+               else GPIO.PUD_UP)


 def write_output(pin, value):
    """Write a value to a GPIO."""
-    # pylint: disable=import-error,undefined-variable
+    # pylint: disable=import-error
    import Adafruit_BBIO.GPIO as GPIO
    GPIO.output(pin, value)


 def read_input(pin):
    """Read a value from a GPIO."""
-    # pylint: disable=import-error,undefined-variable
+    # pylint: disable=import-error
    import Adafruit_BBIO.GPIO as GPIO
    return GPIO.input(pin) is GPIO.HIGH


 def edge_detect(pin, event_callback, bounce):
    """Add detection for RISING and FALLING events."""
-    # pylint: disable=import-error,undefined-variable
+    # pylint: disable=import-error
    import Adafruit_BBIO.GPIO as GPIO
    GPIO.add_event_detect(
        pin, GPIO.BOTH, callback=event_callback, bouncetime=bounce)
--- a/homeassistant/components/binary_sensor/init.py
+++ b/homeassistant/components/binary_sensor/init.py
@@ -67,7 +67,6 @@ async def async_unload_entry(hass, entry):
    return await hass.data[DOMAIN].async_unload_entry(entry)


-# pylint: disable=no-self-use
 class BinarySensorDevice(Entity):
    """Represent a binary sensor."""

--- a/homeassistant/components/binary_sensor/bmw_connected_drive.py
+++ b/homeassistant/components/binary_sensor/bmw_connected_drive.py
@@ -124,11 +124,11 @@ class BMWConnectedDriveSensor(BinarySensorDevice):
                result['check_control_messages'] = check_control_messages
        elif self._attribute == 'charging_status':
            result['charging_status'] = vehicle_state.charging_status.value
-            # pylint: disable=W0212
+            # pylint: disable=protected-access
            result['last_charging_end_result'] = \
                vehicle_state._attributes['lastChargingEndResult']
        if self._attribute == 'connection_status':
-            # pylint: disable=W0212
+            # pylint: disable=protected-access
            result['connection_status'] = \
                vehicle_state._attributes['connectionStatus']

@@ -166,7 +166,7 @@ class BMWConnectedDriveSensor(BinarySensorDevice):
        # device class plug: On means device is plugged in,
        #                    Off means device is unplugged
        if self._attribute == 'connection_status':
-            # pylint: disable=W0212
+            # pylint: disable=protected-access
            self._state = (vehicle_state._attributes['connectionStatus'] ==
                           'CONNECTED')

--- a/homeassistant/components/binary_sensor/command_line.py
+++ b/homeassistant/components/binary_sensor/command_line.py
@@ -35,7 +35,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Command line Binary Sensor."""
    name = config.get(CONF_NAME)
--- a/homeassistant/components/binary_sensor/deconz.py
+++ b/homeassistant/components/binary_sensor/deconz.py
@@ -5,8 +5,9 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.deconz/
 """
 from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.deconz import (
-    DOMAIN as DATA_DECONZ, DATA_DECONZ_ID, DATA_DECONZ_UNSUB)
+from homeassistant.components.deconz.const import (
+    ATTR_DARK, ATTR_ON, CONF_ALLOW_CLIP_SENSOR, DOMAIN as DATA_DECONZ,
+    DATA_DECONZ_ID, DATA_DECONZ_UNSUB)
 from homeassistant.const import ATTR_BATTERY_LEVEL
 from homeassistant.core import callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -27,10 +28,13 @@ async def async_setup_entry(hass, config_entry, async_add_devices):
        """Add binary sensor from deCONZ."""
        from pydeconz.sensor import DECONZ_BINARY_SENSOR
        entities = []
+        allow_clip_sensor = config_entry.data.get(CONF_ALLOW_CLIP_SENSOR, True)
        for sensor in sensors:
-            if sensor.type in DECONZ_BINARY_SENSOR:
+            if sensor.type in DECONZ_BINARY_SENSOR and \
+               not (not allow_clip_sensor and sensor.type.startswith('CLIP')):
                entities.append(DeconzBinarySensor(sensor))
        async_add_devices(entities, True)
+
    hass.data[DATA_DECONZ_UNSUB].append(
        async_dispatcher_connect(hass, 'deconz_new_sensor', async_add_sensor))

@@ -58,7 +62,8 @@ class DeconzBinarySensor(BinarySensorDevice):
        """
        if reason['state'] or \
           'reachable' in reason['attr'] or \
-           'battery' in reason['attr']:
+           'battery' in reason['attr'] or \
+           'on' in reason['attr']:
            self.async_schedule_update_ha_state()

    @property
@@ -103,6 +108,8 @@ class DeconzBinarySensor(BinarySensorDevice):
        attr = {}
        if self._sensor.battery:
            attr[ATTR_BATTERY_LEVEL] = self._sensor.battery
-        if self._sensor.type in PRESENCE and self._sensor.dark:
-            attr['dark'] = self._sensor.dark
+        if self._sensor.on is not None:
+            attr[ATTR_ON] = self._sensor.on
+        if self._sensor.type in PRESENCE and self._sensor.dark is not None:
+            attr[ATTR_DARK] = self._sensor.dark
        return attr
--- a/homeassistant/components/binary_sensor/digital_ocean.py
+++ b/homeassistant/components/binary_sensor/digital_ocean.py
@@ -14,7 +14,8 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.components.digital_ocean import (
    CONF_DROPLETS, ATTR_CREATED_AT, ATTR_DROPLET_ID, ATTR_DROPLET_NAME,
    ATTR_FEATURES, ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY,
-    ATTR_REGION, ATTR_VCPUS, DATA_DIGITAL_OCEAN)
+    ATTR_REGION, ATTR_VCPUS, CONF_ATTRIBUTION, DATA_DIGITAL_OCEAN)
+from homeassistant.const import ATTR_ATTRIBUTION

 _LOGGER = logging.getLogger(__name__)

@@ -75,6 +76,7 @@ class DigitalOceanBinarySensor(BinarySensorDevice):
    def device_state_attributes(self):
        """Return the state attributes of the Digital Ocean droplet."""
        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
            ATTR_CREATED_AT: self.data.created_at,
            ATTR_DROPLET_ID: self.data.id,
            ATTR_DROPLET_NAME: self.data.name,
--- a/homeassistant/components/binary_sensor/eight_sleep.py
+++ b/homeassistant/components/binary_sensor/eight_sleep.py
@@ -5,7 +5,6 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.eight_sleep/
 """
 import logging
-import asyncio

 from homeassistant.components.binary_sensor import BinarySensorDevice
 from homeassistant.components.eight_sleep import (
@@ -16,8 +15,8 @@ _LOGGER = logging.getLogger(__name__)
 DEPENDENCIES = ['eight_sleep']


-@asyncio.coroutine
-def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+async def async_setup_platform(hass, config, async_add_devices,
+                               discovery_info=None):
    """Set up the eight sleep binary sensor."""
    if discovery_info is None:
        return
@@ -63,7 +62,6 @@ class EightHeatSensor(EightSleepHeatEntity, BinarySensorDevice):
        """Return true if the binary sensor is on."""
        return self._state

-    @asyncio.coroutine
-    def async_update(self):
+    async def async_update(self):
        """Retrieve latest state."""
        self._state = self._usrobj.bed_presence
--- a/homeassistant/components/binary_sensor/envisalink.py
+++ b/homeassistant/components/binary_sensor/envisalink.py
@@ -6,6 +6,7 @@ https://home-assistant.io/components/binary_sensor.envisalink/
 """
 import asyncio
 import logging
+import datetime

 from homeassistant.core import callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -14,6 +15,7 @@ from homeassistant.components.envisalink import (
    DATA_EVL, ZONE_SCHEMA, CONF_ZONENAME, CONF_ZONETYPE, EnvisalinkDevice,
    SIGNAL_ZONE_UPDATE)
 from homeassistant.const import ATTR_LAST_TRIP_TIME
+from homeassistant.util import dt as dt_util

 _LOGGER = logging.getLogger(__name__)

@@ -63,7 +65,25 @@ class EnvisalinkBinarySensor(EnvisalinkDevice, BinarySensorDevice):
    def device_state_attributes(self):
        """Return the state attributes."""
        attr = {}
-        attr[ATTR_LAST_TRIP_TIME] = self._info['last_fault']
+
+        # The Envisalink library returns a "last_fault" value that's the
+        # number of seconds since the last fault, up to a maximum of 327680
+        # seconds (65536 5-second ticks).
+        #
+        # We don't want the HA event log to fill up with a bunch of no-op
+        # "state changes" that are just that number ticking up once per poll
+        # interval, so we subtract it from the current second-accurate time
+        # unless it is already at the maximum value, in which case we set it
+        # to None since we can't determine the actual value.
+        seconds_ago = self._info['last_fault']
+        if seconds_ago < 65536 * 5:
+            now = dt_util.now().replace(microsecond=0)
+            delta = datetime.timedelta(seconds=seconds_ago)
+            last_trip_time = (now - delta).isoformat()
+        else:
+            last_trip_time = None
+
+        attr[ATTR_LAST_TRIP_TIME] = last_trip_time
        return attr

    @property
--- a/homeassistant/components/binary_sensor/flic.py
+++ b/homeassistant/components/binary_sensor/flic.py
@@ -16,7 +16,7 @@ from homeassistant.const import (
 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA)

-REQUIREMENTS = ['https://github.com/soldag/pyflic/archive/0.4.zip#pyflic==0.4']
+REQUIREMENTS = ['pyflic-homeassistant==0.4.dev0']

 _LOGGER = logging.getLogger(__name__)

--- a/homeassistant/components/binary_sensor/gc100.py
+++ b/homeassistant/components/binary_sensor/gc100.py
@@ -23,7 +23,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the GC100 devices."""
    binary_sensors = []
@@ -40,7 +39,6 @@ class GC100BinarySensor(BinarySensorDevice):

    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
--- a/homeassistant/components/binary_sensor/homematicip_cloud.py
+++ b/homeassistant/components/binary_sensor/homematicip_cloud.py
@@ -9,8 +9,8 @@ import logging

 from homeassistant.components.binary_sensor import BinarySensorDevice
 from homeassistant.components.homematicip_cloud import (
-    HomematicipGenericDevice, DOMAIN as HOMEMATICIP_CLOUD_DOMAIN,
-    ATTR_HOME_ID)
+    HomematicipGenericDevice, DOMAIN as HMIPC_DOMAIN,
+    HMIPC_HAPID)

 DEPENDENCIES = ['homematicip_cloud']

@@ -21,17 +21,18 @@ ATTR_EVENT_DELAY = 'event_delay'
 ATTR_MOTION_DETECTED = 'motion_detected'
 ATTR_ILLUMINATION = 'illumination'

-HMIP_OPEN = 'open'
-

 async def async_setup_platform(hass, config, async_add_devices,
                               discovery_info=None):
-    """Set up the HomematicIP binary sensor devices."""
+    """Set up the binary sensor devices."""
+    pass
+
+
+async def async_setup_entry(hass, config_entry, async_add_devices):
+    """Set up the HomematicIP binary sensor from a config entry."""
    from homematicip.device import (ShutterContact, MotionDetectorIndoor)

-    if discovery_info is None:
-        return
-    home = hass.data[HOMEMATICIP_CLOUD_DOMAIN][discovery_info[ATTR_HOME_ID]]
+    home = hass.data[HMIPC_DOMAIN][config_entry.data[HMIPC_HAPID]].home
    devices = []
    for device in home.devices:
        if isinstance(device, ShutterContact):
@@ -58,11 +59,13 @@ class HomematicipShutterContact(HomematicipGenericDevice, BinarySensorDevice):
    @property
    def is_on(self):
        """Return true if the shutter contact is on/open."""
+        from homematicip.base.enums import WindowState
+
        if self._device.sabotage:
            return True
        if self._device.windowState is None:
            return None
-        return self._device.windowState.lower() == HMIP_OPEN
+        return self._device.windowState == WindowState.OPEN


 class HomematicipMotionDetector(HomematicipGenericDevice, BinarySensorDevice):
--- a/homeassistant/components/binary_sensor/hydrawise.py
+++ b/homeassistant/components/binary_sensor/hydrawise.py
@@ -0,0 +1,81 @@
+"""
+Support for Hydrawise sprinkler.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.hydrawise/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.hydrawise import (
+    BINARY_SENSORS, DATA_HYDRAWISE, HydrawiseEntity, DEVICE_MAP,
+    DEVICE_MAP_INDEX)
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import CONF_MONITORED_CONDITIONS
+
+DEPENDENCIES = ['hydrawise']
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_MONITORED_CONDITIONS, default=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 Hydrawise device."""
+    hydrawise = hass.data[DATA_HYDRAWISE].data
+
+    sensors = []
+    for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
+        if sensor_type in ['status', 'rain_sensor']:
+            sensors.append(
+                HydrawiseBinarySensor(
+                    hydrawise.controller_status, sensor_type))
+
+        else:
+            # create a sensor for each zone
+            for zone in hydrawise.relays:
+                zone_data = zone
+                zone_data['running'] = \
+                    hydrawise.controller_status.get('running', False)
+                sensors.append(HydrawiseBinarySensor(zone_data, sensor_type))
+
+    add_devices(sensors, True)
+
+
+class HydrawiseBinarySensor(HydrawiseEntity, BinarySensorDevice):
+    """A sensor implementation for Hydrawise 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 Hydrawise binary sensor: %s", self._name)
+        mydata = self.hass.data[DATA_HYDRAWISE].data
+        if self._sensor_type == 'status':
+            self._state = mydata.status == 'All good!'
+        elif self._sensor_type == 'rain_sensor':
+            for sensor in mydata.sensors:
+                if sensor['name'] == 'Rain':
+                    self._state = sensor['active'] == 1
+        elif self._sensor_type == 'is_watering':
+            if not mydata.running:
+                self._state = False
+            elif int(mydata.running[0]['relay']) == self.data['relay']:
+                self._state = True
+            else:
+                self._state = False
+
+    @property
+    def device_class(self):
+        """Return the device class of the sensor type."""
+        return DEVICE_MAP[self._sensor_type][
+            DEVICE_MAP_INDEX.index('DEVICE_CLASS_INDEX')]
--- a/homeassistant/components/binary_sensor/isy994.py
+++ b/homeassistant/components/binary_sensor/isy994.py
@@ -8,7 +8,7 @@ https://home-assistant.io/components/binary_sensor.isy994/
 import asyncio
 import logging
 from datetime import timedelta
-from typing import Callable  # noqa
+from typing import Callable

 from homeassistant.core import callback
 from homeassistant.components.binary_sensor import BinarySensorDevice, DOMAIN
@@ -28,7 +28,6 @@ ISY_DEVICE_TYPES = {
 }


-# pylint: disable=unused-argument
 def setup_platform(hass, config: ConfigType,
                   add_devices: Callable[[list], None], discovery_info=None):
    """Set up the ISY994 binary sensor platform."""
@@ -299,7 +298,6 @@ class ISYBinarySensorHeartbeat(ISYDevice, BinarySensorDevice):
            # No heartbeat timer is active
            pass

-        # pylint: disable=unused-argument
        @callback
        def timer_elapsed(now) -> None:
            """Heartbeat missed; set state to indicate dead battery."""
@@ -314,7 +312,6 @@ class ISYBinarySensorHeartbeat(ISYDevice, BinarySensorDevice):
        self._heartbeat_timer = async_track_point_in_utc_time(
            self.hass, timer_elapsed, point_in_time)

-    # pylint: disable=unused-argument
    def on_update(self, event: object) -> None:
        """Ignore node status updates.

--- a/homeassistant/components/binary_sensor/knx.py
+++ b/homeassistant/components/binary_sensor/knx.py
@@ -115,7 +115,6 @@ class KNXBinarySensor(BinarySensorDevice):
        """Register callbacks to update hass after device was changed."""
        async def after_update_callback(device):
            """Call after device was updated."""
-            # pylint: disable=unused-argument
            await self.async_update_ha_state()
        self.device.register_device_updated_cb(after_update_callback)

--- a/homeassistant/components/binary_sensor/linode.py
+++ b/homeassistant/components/binary_sensor/linode.py
@@ -52,19 +52,18 @@ class LinodeBinarySensor(BinarySensorDevice):
        self._node_id = node_id
        self._state = None
        self.data = None
+        self._attrs = {}
+        self._name = None

    @property
    def name(self):
        """Return the name of the sensor."""
-        if self.data is not None:
-            return self.data.label
+        return self._name

    @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
+        return self._state

    @property
    def device_class(self):
@@ -74,8 +73,18 @@ class LinodeBinarySensor(BinarySensorDevice):
    @property
    def device_state_attributes(self):
        """Return the state attributes of the Linode Node."""
-        if self.data:
-            return {
+        return self._attrs
+
+    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
+        if self.data is not None:
+            self._state = self.data.status == 'running'
+            self._attrs = {
                ATTR_CREATED: self.data.created,
                ATTR_NODE_ID: self.data.id,
                ATTR_NODE_NAME: self.data.label,
@@ -85,12 +94,4 @@ class LinodeBinarySensor(BinarySensorDevice):
                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
+            self._name = self.data.label
--- a/homeassistant/components/binary_sensor/mqtt.py
+++ b/homeassistant/components/binary_sensor/mqtt.py
@@ -6,6 +6,7 @@ https://home-assistant.io/components/binary_sensor.mqtt/
 """
 import asyncio
 import logging
+from typing import Optional

 import voluptuous as vol

@@ -24,7 +25,7 @@ import homeassistant.helpers.config_validation as cv
 _LOGGER = logging.getLogger(__name__)

 DEFAULT_NAME = 'MQTT Binary sensor'
-
+CONF_UNIQUE_ID = 'unique_id'
 DEFAULT_PAYLOAD_OFF = 'OFF'
 DEFAULT_PAYLOAD_ON = 'ON'
 DEFAULT_FORCE_UPDATE = False
@@ -37,6 +38,9 @@ PLATFORM_SCHEMA = mqtt.MQTT_RO_PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
    vol.Optional(CONF_FORCE_UPDATE, default=DEFAULT_FORCE_UPDATE): cv.boolean,
+    # Integrations shouldn't never expose unique_id through configuration
+    # this here is an exception because MQTT is a msg transport, not a protocol
+    vol.Optional(CONF_UNIQUE_ID): cv.string,
 }).extend(mqtt.MQTT_AVAILABILITY_SCHEMA.schema)


@@ -61,7 +65,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
        config.get(CONF_PAYLOAD_OFF),
        config.get(CONF_PAYLOAD_AVAILABLE),
        config.get(CONF_PAYLOAD_NOT_AVAILABLE),
-        value_template
+        value_template,
+        config.get(CONF_UNIQUE_ID),
    )])


@@ -70,7 +75,8 @@ class MqttBinarySensor(MqttAvailability, BinarySensorDevice):

    def __init__(self, name, state_topic, availability_topic, device_class,
                 qos, force_update, payload_on, payload_off, payload_available,
-                 payload_not_available, value_template):
+                 payload_not_available, value_template,
+                 unique_id: Optional[str]):
        """Initialize the MQTT binary sensor."""
        super().__init__(availability_topic, qos, payload_available,
                         payload_not_available)
@@ -83,6 +89,7 @@ class MqttBinarySensor(MqttAvailability, BinarySensorDevice):
        self._qos = qos
        self._force_update = force_update
        self._template = value_template
+        self._unique_id = unique_id

    @asyncio.coroutine
    def async_added_to_hass(self):
@@ -134,3 +141,8 @@ class MqttBinarySensor(MqttAvailability, BinarySensorDevice):
    def force_update(self):
        """Force update."""
        return self._force_update
+
+    @property
+    def unique_id(self):
+        """Return a unique ID."""
+        return self._unique_id
--- a/homeassistant/components/binary_sensor/mysensors.py
+++ b/homeassistant/components/binary_sensor/mysensors.py
@@ -29,7 +29,8 @@ async def async_setup_platform(
        async_add_devices=async_add_devices)


-class MySensorsBinarySensor(mysensors.MySensorsEntity, BinarySensorDevice):
+class MySensorsBinarySensor(
+        mysensors.device.MySensorsEntity, BinarySensorDevice):
    """Representation of a MySensors Binary Sensor child node."""

    @property
--- a/homeassistant/components/binary_sensor/mystrom.py
+++ b/homeassistant/components/binary_sensor/mystrom.py
@@ -29,6 +29,7 @@ class MyStromView(HomeAssistantView):

    url = '/api/mystrom'
    name = 'api:mystrom'
+    supported_actions = ['single', 'double', 'long', 'touch']

    def __init__(self, add_devices):
        """Initialize the myStrom URL endpoint."""
@@ -44,16 +45,18 @@ class MyStromView(HomeAssistantView):
    @asyncio.coroutine
    def _handle(self, hass, data):
        """Handle requests to the myStrom endpoint."""
-        button_action = list(data.keys())[0]
-        button_id = data[button_action]
-        entity_id = '{}.{}_{}'.format(DOMAIN, button_id, button_action)
+        button_action = next((
+            parameter for parameter in data
+            if parameter in self.supported_actions), None)

-        if button_action not in ['single', 'double', 'long', 'touch']:
+        if button_action is None:
            _LOGGER.error(
                "Received unidentified message from myStrom button: %s", data)
            return ("Received unidentified message: {}".format(data),
                    HTTP_UNPROCESSABLE_ENTITY)

+        button_id = data[button_action]
+        entity_id = '{}.{}_{}'.format(DOMAIN, button_id, button_action)
        if entity_id not in self.buttons:
            _LOGGER.info("New myStrom button/action detected: %s/%s",
                         button_id, button_action)
--- a/homeassistant/components/binary_sensor/nest.py
+++ b/homeassistant/components/binary_sensor/nest.py
@@ -7,27 +7,35 @@ https://home-assistant.io/components/binary_sensor.nest/
 from itertools import chain
 import logging

-from homeassistant.components.binary_sensor import (BinarySensorDevice)
-from homeassistant.components.sensor.nest import NestSensor
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.nest import (
+    DATA_NEST, DATA_NEST_CONFIG, CONF_BINARY_SENSORS, NestSensorDevice)
 from homeassistant.const import CONF_MONITORED_CONDITIONS
-from homeassistant.components.nest import DATA_NEST

 DEPENDENCIES = ['nest']

-BINARY_TYPES = ['online']
+BINARY_TYPES = {'online': 'connectivity'}

-CLIMATE_BINARY_TYPES = [
-    'fan',
-    'is_using_emergency_heat',
-    'is_locked',
-    'has_leaf',
-]
+CLIMATE_BINARY_TYPES = {
+    'fan': None,
+    'is_using_emergency_heat': 'heat',
+    'is_locked': None,
+    'has_leaf': None,
+}

-CAMERA_BINARY_TYPES = [
-    'motion_detected',
-    'sound_detected',
-    'person_detected',
-]
+CAMERA_BINARY_TYPES = {
+    'motion_detected': 'motion',
+    'sound_detected': 'sound',
+    'person_detected': 'occupancy',
+}
+
+STRUCTURE_BINARY_TYPES = {
+    'away': None,
+}
+
+STRUCTURE_BINARY_STATE_MAP = {
+    'away': {'away': True, 'home': False},
+}

 _BINARY_TYPES_DEPRECATED = [
    'hvac_ac_state',
@@ -40,19 +48,26 @@ _BINARY_TYPES_DEPRECATED = [
    'hvac_emer_heat_state',
 ]

-_VALID_BINARY_SENSOR_TYPES = BINARY_TYPES + CLIMATE_BINARY_TYPES \
-    + CAMERA_BINARY_TYPES
+_VALID_BINARY_SENSOR_TYPES = {**BINARY_TYPES, **CLIMATE_BINARY_TYPES,
+                              **CAMERA_BINARY_TYPES, **STRUCTURE_BINARY_TYPES}

 _LOGGER = logging.getLogger(__name__)


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the Nest binary sensors."""
-    if discovery_info is None:
-        return
+    """Set up the Nest binary sensors.

+    No longer used.
+    """
+
+
+async def async_setup_entry(hass, entry, async_add_devices):
+    """Set up a Nest binary sensor based on a config entry."""
    nest = hass.data[DATA_NEST]

+    discovery_info = \
+        hass.data.get(DATA_NEST_CONFIG, {}).get(CONF_BINARY_SENSORS, {})
+
    # Add all available binary sensors if no Nest binary sensor config is set
    if discovery_info == {}:
        conditions = _VALID_BINARY_SENSOR_TYPES
@@ -67,32 +82,40 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                    "for valid options.")
            _LOGGER.error(wstr)

-    sensors = []
-    device_chain = chain(nest.thermostats(),
-                         nest.smoke_co_alarms(),
-                         nest.cameras())
-    for structure, device in device_chain:
-        sensors += [NestBinarySensor(structure, device, variable)
-                    for variable in conditions
-                    if variable in BINARY_TYPES]
-        sensors += [NestBinarySensor(structure, device, variable)
-                    for variable in conditions
-                    if variable in CLIMATE_BINARY_TYPES
-                    and device.is_thermostat]
-
-        if device.is_camera:
+    def get_binary_sensors():
+        """Get the Nest binary sensors."""
+        sensors = []
+        for structure in nest.structures():
+            sensors += [NestBinarySensor(structure, None, variable)
+                        for variable in conditions
+                        if variable in STRUCTURE_BINARY_TYPES]
+        device_chain = chain(nest.thermostats(),
+                             nest.smoke_co_alarms(),
+                             nest.cameras())
+        for structure, device in device_chain:
            sensors += [NestBinarySensor(structure, device, variable)
                        for variable in conditions
-                        if variable in CAMERA_BINARY_TYPES]
-            for activity_zone in device.activity_zones:
-                sensors += [NestActivityZoneSensor(structure,
-                                                   device,
-                                                   activity_zone)]
+                        if variable in BINARY_TYPES]
+            sensors += [NestBinarySensor(structure, device, variable)
+                        for variable in conditions
+                        if variable in CLIMATE_BINARY_TYPES
+                        and device.is_thermostat]

-    add_devices(sensors, True)
+            if device.is_camera:
+                sensors += [NestBinarySensor(structure, device, variable)
+                            for variable in conditions
+                            if variable in CAMERA_BINARY_TYPES]
+                for activity_zone in device.activity_zones:
+                    sensors += [NestActivityZoneSensor(structure,
+                                                       device,
+                                                       activity_zone)]
+
+        return sensors
+
+    async_add_devices(await hass.async_add_job(get_binary_sensors), True)


-class NestBinarySensor(NestSensor, BinarySensorDevice):
+class NestBinarySensor(NestSensorDevice, BinarySensorDevice):
    """Represents a Nest binary sensor."""

    @property
@@ -100,9 +123,19 @@ class NestBinarySensor(NestSensor, BinarySensorDevice):
        """Return true if the binary sensor is on."""
        return self._state

+    @property
+    def device_class(self):
+        """Return the device class of the binary sensor."""
+        return _VALID_BINARY_SENSOR_TYPES.get(self.variable)
+
    def update(self):
        """Retrieve latest state."""
-        self._state = bool(getattr(self.device, self.variable))
+        value = getattr(self.device, self.variable)
+        if self.variable in STRUCTURE_BINARY_TYPES:
+            self._state = bool(STRUCTURE_BINARY_STATE_MAP
+                               [self.variable].get(value))
+        else:
+            self._state = bool(value)


 class NestActivityZoneSensor(NestBinarySensor):
@@ -115,9 +148,9 @@ class NestActivityZoneSensor(NestBinarySensor):
        self._name = "{} {} activity".format(self._name, self.zone.name)

    @property
-    def name(self):
-        """Return the name of the nest, if any."""
-        return self._name
+    def device_class(self):
+        """Return the device class of the binary sensor."""
+        return 'motion'

    def update(self):
        """Retrieve latest state."""
--- a/homeassistant/components/binary_sensor/netatmo.py
+++ b/homeassistant/components/binary_sensor/netatmo.py
@@ -57,7 +57,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the access to Netatmo binary sensor."""
    netatmo = hass.components.netatmo
@@ -68,12 +67,12 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    module_name = None

-    import lnetatmo
+    import pyatmo
    try:
        data = CameraData(netatmo.NETATMO_AUTH, home)
        if not data.get_camera_names():
            return None
-    except lnetatmo.NoDevice:
+    except pyatmo.NoDevice:
        return None

    welcome_sensors = config.get(
--- a/homeassistant/components/binary_sensor/octoprint.py
+++ b/homeassistant/components/binary_sensor/octoprint.py
@@ -33,7 +33,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the available OctoPrint binary sensors."""
    octoprint_api = hass.data[DOMAIN]["api"]
--- a/homeassistant/components/binary_sensor/pilight.py
+++ b/homeassistant/components/binary_sensor/pilight.py
@@ -44,7 +44,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up Pilight Binary Sensor."""
    disarm = config.get(CONF_DISARM_AFTER_TRIGGER)
--- a/homeassistant/components/binary_sensor/rachio.py
+++ b/homeassistant/components/binary_sensor/rachio.py
@@ -0,0 +1,127 @@
+"""
+Integration with the Rachio Iro sprinkler system controller.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.rachio/
+"""
+from abc import abstractmethod
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.rachio import (DOMAIN as DOMAIN_RACHIO,
+                                             KEY_DEVICE_ID,
+                                             KEY_STATUS,
+                                             KEY_SUBTYPE,
+                                             SIGNAL_RACHIO_CONTROLLER_UPDATE,
+                                             STATUS_OFFLINE,
+                                             STATUS_ONLINE,
+                                             SUBTYPE_OFFLINE,
+                                             SUBTYPE_ONLINE,)
+from homeassistant.helpers.dispatcher import dispatcher_connect
+
+DEPENDENCIES = ['rachio']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Rachio binary sensors."""
+    devices = []
+    for controller in hass.data[DOMAIN_RACHIO].controllers:
+        devices.append(RachioControllerOnlineBinarySensor(hass, controller))
+
+    add_devices(devices)
+    _LOGGER.info("%d Rachio binary sensor(s) added", len(devices))
+
+
+class RachioControllerBinarySensor(BinarySensorDevice):
+    """Represent a binary sensor that reflects a Rachio state."""
+
+    def __init__(self, hass, controller, poll=True):
+        """Set up a new Rachio controller binary sensor."""
+        self._controller = controller
+
+        if poll:
+            self._state = self._poll_update()
+        else:
+            self._state = None
+
+        dispatcher_connect(hass, SIGNAL_RACHIO_CONTROLLER_UPDATE,
+                           self._handle_any_update)
+
+    @property
+    def should_poll(self) -> bool:
+        """Declare that this entity pushes its state to HA."""
+        return False
+
+    @property
+    def is_on(self) -> bool:
+        """Return whether the sensor has a 'true' value."""
+        return self._state
+
+    def _handle_any_update(self, *args, **kwargs) -> None:
+        """Determine whether an update event applies to this device."""
+        if args[0][KEY_DEVICE_ID] != self._controller.controller_id:
+            # For another device
+            return
+
+        # For this device
+        self._handle_update()
+
+    @abstractmethod
+    def _poll_update(self, data=None) -> bool:
+        """Request the state from the API."""
+        pass
+
+    @abstractmethod
+    def _handle_update(self, *args, **kwargs) -> None:
+        """Handle an update to the state of this sensor."""
+        pass
+
+
+class RachioControllerOnlineBinarySensor(RachioControllerBinarySensor):
+    """Represent a binary sensor that reflects if the controller is online."""
+
+    def __init__(self, hass, controller):
+        """Set up a new Rachio controller online binary sensor."""
+        super().__init__(hass, controller, poll=False)
+        self._state = self._poll_update(controller.init_data)
+
+    @property
+    def name(self) -> str:
+        """Return the name of this sensor including the controller name."""
+        return "{} online".format(self._controller.name)
+
+    @property
+    def device_class(self) -> str:
+        """Return the class of this device, from component DEVICE_CLASSES."""
+        return 'connectivity'
+
+    @property
+    def icon(self) -> str:
+        """Return the name of an icon for this sensor."""
+        return 'mdi:wifi-strength-4' if self.is_on\
+            else 'mdi:wifi-strength-off-outline'
+
+    def _poll_update(self, data=None) -> bool:
+        """Request the state from the API."""
+        if data is None:
+            data = self._controller.rachio.device.get(
+                self._controller.controller_id)[1]
+
+        if data[KEY_STATUS] == STATUS_ONLINE:
+            return True
+        elif data[KEY_STATUS] == STATUS_OFFLINE:
+            return False
+        else:
+            _LOGGER.warning('"%s" reported in unknown state "%s"', self.name,
+                            data[KEY_STATUS])
+
+    def _handle_update(self, *args, **kwargs) -> None:
+        """Handle an update to the state of this sensor."""
+        if args[0][KEY_SUBTYPE] == SUBTYPE_ONLINE:
+            self._state = True
+        elif args[0][KEY_SUBTYPE] == SUBTYPE_OFFLINE:
+            self._state = False
+
+        self.schedule_update_ha_state()
--- a/homeassistant/components/binary_sensor/rainmachine.py
+++ b/homeassistant/components/binary_sensor/rainmachine.py
@@ -0,0 +1,103 @@
+"""
+This platform provides binary sensors for key RainMachine data.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.rainmachine/
+"""
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.rainmachine import (
+    BINARY_SENSORS, DATA_RAINMACHINE, SENSOR_UPDATE_TOPIC, TYPE_FREEZE,
+    TYPE_FREEZE_PROTECTION, TYPE_HOT_DAYS, TYPE_HOURLY, TYPE_MONTH,
+    TYPE_RAINDELAY, TYPE_RAINSENSOR, TYPE_WEEKDAY, RainMachineEntity)
+from homeassistant.const import CONF_MONITORED_CONDITIONS
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+
+DEPENDENCIES = ['rainmachine']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_platform(
+        hass, config, async_add_devices, discovery_info=None):
+    """Set up the RainMachine Switch platform."""
+    if discovery_info is None:
+        return
+
+    rainmachine = hass.data[DATA_RAINMACHINE]
+
+    binary_sensors = []
+    for sensor_type in discovery_info[CONF_MONITORED_CONDITIONS]:
+        name, icon = BINARY_SENSORS[sensor_type]
+        binary_sensors.append(
+            RainMachineBinarySensor(rainmachine, sensor_type, name, icon))
+
+    async_add_devices(binary_sensors, True)
+
+
+class RainMachineBinarySensor(RainMachineEntity, BinarySensorDevice):
+    """A sensor implementation for raincloud device."""
+
+    def __init__(self, rainmachine, sensor_type, name, icon):
+        """Initialize the sensor."""
+        super().__init__(rainmachine)
+
+        self._icon = icon
+        self._name = name
+        self._sensor_type = sensor_type
+        self._state = None
+
+    @property
+    def icon(self) -> str:
+        """Return the icon."""
+        return self._icon
+
+    @property
+    def is_on(self):
+        """Return the status of the sensor."""
+        return self._state
+
+    @property
+    def should_poll(self):
+        """Disable polling."""
+        return False
+
+    @property
+    def unique_id(self) -> str:
+        """Return a unique, HASS-friendly identifier for this entity."""
+        return '{0}_{1}'.format(
+            self.rainmachine.device_mac.replace(':', ''), self._sensor_type)
+
+    @callback
+    def _update_data(self):
+        """Update the state."""
+        self.async_schedule_update_ha_state(True)
+
+    async def async_added_to_hass(self):
+        """Register callbacks."""
+        async_dispatcher_connect(
+            self.hass, SENSOR_UPDATE_TOPIC, self._update_data)
+
+    async def async_update(self):
+        """Update the state."""
+        if self._sensor_type == TYPE_FREEZE:
+            self._state = self.rainmachine.restrictions['current']['freeze']
+        elif self._sensor_type == TYPE_FREEZE_PROTECTION:
+            self._state = self.rainmachine.restrictions['global'][
+                'freezeProtectEnabled']
+        elif self._sensor_type == TYPE_HOT_DAYS:
+            self._state = self.rainmachine.restrictions['global'][
+                'hotDaysExtraWatering']
+        elif self._sensor_type == TYPE_HOURLY:
+            self._state = self.rainmachine.restrictions['current']['hourly']
+        elif self._sensor_type == TYPE_MONTH:
+            self._state = self.rainmachine.restrictions['current']['month']
+        elif self._sensor_type == TYPE_RAINDELAY:
+            self._state = self.rainmachine.restrictions['current']['rainDelay']
+        elif self._sensor_type == TYPE_RAINSENSOR:
+            self._state = self.rainmachine.restrictions['current'][
+                'rainSensor']
+        elif self._sensor_type == TYPE_WEEKDAY:
+            self._state = self.rainmachine.restrictions['current']['weekDay']
--- a/homeassistant/components/binary_sensor/random.py
+++ b/homeassistant/components/binary_sensor/random.py
@@ -4,7 +4,6 @@ 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
@@ -24,8 +23,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-@asyncio.coroutine
-def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+async 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)
@@ -57,8 +56,7 @@ class RandomSensor(BinarySensorDevice):
        """Return the sensor class of the sensor."""
        return self._device_class

-    @asyncio.coroutine
-    def async_update(self):
+    async def async_update(self):
        """Get new state and update the sensor's state."""
        from random import getrandbits
        self._state = bool(getrandbits(1))
--- a/homeassistant/components/binary_sensor/raspihats.py
+++ b/homeassistant/components/binary_sensor/raspihats.py
@@ -42,7 +42,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the raspihats binary_sensor devices."""
    I2CHatBinarySensor.I2C_HATS_MANAGER = hass.data[I2C_HATS_MANAGER]
--- a/homeassistant/components/binary_sensor/ring.py
+++ b/homeassistant/components/binary_sensor/ring.py
@@ -23,7 +23,7 @@ DEPENDENCIES = ['ring']

 _LOGGER = logging.getLogger(__name__)

-SCAN_INTERVAL = timedelta(seconds=5)
+SCAN_INTERVAL = timedelta(seconds=10)

 # Sensor types: Name, category, device_class
 SENSOR_TYPES = {
--- a/homeassistant/components/binary_sensor/rpi_gpio.py
+++ b/homeassistant/components/binary_sensor/rpi_gpio.py
@@ -39,7 +39,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Raspberry PI GPIO devices."""
    pull_mode = config.get(CONF_PULL_MODE)
@@ -59,7 +58,6 @@ class RPiGPIOBinarySensor(BinarySensorDevice):

    def __init__(self, name, port, pull_mode, bouncetime, invert_logic):
        """Initialize the RPi binary sensor."""
-        # pylint: disable=no-member
        self._name = name or DEVICE_DEFAULT_NAME
        self._port = port
        self._pull_mode = pull_mode
--- a/homeassistant/components/binary_sensor/skybell.py
+++ b/homeassistant/components/binary_sensor/skybell.py
@@ -94,4 +94,4 @@ class SkybellBinarySensor(SkybellDevice, BinarySensorDevice):

        self._state = bool(event and event.get('id') != self._event.get('id'))

-        self._event = event
+        self._event = event or {}
--- a/homeassistant/components/binary_sensor/trend.py
+++ b/homeassistant/components/binary_sensor/trend.py
@@ -23,7 +23,7 @@ from homeassistant.helpers.entity import generate_entity_id
 from homeassistant.helpers.event import async_track_state_change
 from homeassistant.util import utcnow

-REQUIREMENTS = ['numpy==1.14.3']
+REQUIREMENTS = ['numpy==1.14.5']

 _LOGGER = logging.getLogger(__name__)

@@ -57,7 +57,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the trend sensors."""
    sensors = []
--- a/homeassistant/components/binary_sensor/uptimerobot.py
+++ b/homeassistant/components/binary_sensor/uptimerobot.py
@@ -0,0 +1,92 @@
+"""
+A platform that to monitor Uptime Robot monitors.
+
+For more details about this platform, please refer to the documentation at
+https://www.home-assistant.io/components/binary_sensor.uptimerobot/
+"""
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.binary_sensor import (
+    PLATFORM_SCHEMA, BinarySensorDevice)
+from homeassistant.const import ATTR_ATTRIBUTION, CONF_API_KEY
+import homeassistant.helpers.config_validation as cv
+
+REQUIREMENTS = ['pyuptimerobot==0.0.5']
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_TARGET = 'target'
+
+CONF_ATTRIBUTION = "Data provided by Uptime Robot"
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_API_KEY): cv.string,
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Uptime Robot binary_sensors."""
+    from pyuptimerobot import UptimeRobot
+
+    up_robot = UptimeRobot()
+    api_key = config.get(CONF_API_KEY)
+    monitors = up_robot.getMonitors(api_key)
+
+    devices = []
+    if not monitors or monitors.get('stat') != 'ok':
+        _LOGGER.error("Error connecting to Uptime Robot")
+        return
+
+    for monitor in monitors['monitors']:
+        devices.append(UptimeRobotBinarySensor(
+            api_key, up_robot, monitor['id'], monitor['friendly_name'],
+            monitor['url']))
+
+    add_devices(devices, True)
+
+
+class UptimeRobotBinarySensor(BinarySensorDevice):
+    """Representation of a Uptime Robot binary sensor."""
+
+    def __init__(self, api_key, up_robot, monitor_id, name, target):
+        """Initialize Uptime Robot the binary sensor."""
+        self._api_key = api_key
+        self._monitor_id = str(monitor_id)
+        self._name = name
+        self._target = target
+        self._up_robot = up_robot
+        self._state = None
+
+    @property
+    def name(self):
+        """Return the name of the binary sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the binary sensor."""
+        return self._state
+
+    @property
+    def device_class(self):
+        """Return the class of this device, from component DEVICE_CLASSES."""
+        return 'connectivity'
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the binary sensor."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            ATTR_TARGET: self._target,
+        }
+
+    def update(self):
+        """Get the latest state of the binary sensor."""
+        monitor = self._up_robot.getMonitors(self._api_key, self._monitor_id)
+        if not monitor or monitor.get('stat') != 'ok':
+            _LOGGER.warning("Failed to get new state")
+            return
+        status = monitor['monitors'][0]['status']
+        self._state = 1 if status == 2 else 0
--- a/homeassistant/components/binary_sensor/vera.py
+++ b/homeassistant/components/binary_sensor/vera.py
@@ -19,8 +19,8 @@ _LOGGER = logging.getLogger(__name__)
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Perform the setup for Vera controller devices."""
    add_devices(
-        VeraBinarySensor(device, hass.data[VERA_CONTROLLER])
-        for device in hass.data[VERA_DEVICES]['binary_sensor'])
+        [VeraBinarySensor(device, hass.data[VERA_CONTROLLER])
+         for device in hass.data[VERA_DEVICES]['binary_sensor']], True)


 class VeraBinarySensor(VeraDevice, BinarySensorDevice):
--- a/homeassistant/components/binary_sensor/verisure.py
+++ b/homeassistant/components/binary_sensor/verisure.py
@@ -54,6 +54,7 @@ class VerisureDoorWindowSensor(BinarySensorDevice):
            "$.doorWindow.doorWindowDevice[?(@.deviceLabel=='%s')]",
            self._device_label) is not None

+    # pylint: disable=no-self-use
    def update(self):
        """Update the state of the sensor."""
        hub.update_overview()
--- a/homeassistant/components/binary_sensor/wemo.py
+++ b/homeassistant/components/binary_sensor/wemo.py
@@ -13,7 +13,6 @@ DEPENDENCIES = ['wemo']
 _LOGGER = logging.getLogger(__name__)


-# pylint: disable=unused-argument, too-many-function-args
 def setup_platform(hass, config, add_devices_callback, discovery_info=None):
    """Register discovered WeMo binary sensors."""
    import pywemo.discovery as discovery
--- a/homeassistant/components/binary_sensor/wirelesstag.py
+++ b/homeassistant/components/binary_sensor/wirelesstag.py
@@ -0,0 +1,214 @@
+"""
+Binary sensor support for Wireless Sensor Tags.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.wirelesstag/
+"""
+import logging
+
+import voluptuous as vol
+
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.wirelesstag import (
+    DOMAIN as WIRELESSTAG_DOMAIN,
+    WIRELESSTAG_TYPE_13BIT, WIRELESSTAG_TYPE_WATER,
+    WIRELESSTAG_TYPE_ALSPRO,
+    WIRELESSTAG_TYPE_WEMO_DEVICE,
+    SIGNAL_BINARY_EVENT_UPDATE,
+    WirelessTagBaseSensor)
+from homeassistant.const import (
+    CONF_MONITORED_CONDITIONS, STATE_ON, STATE_OFF)
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['wirelesstag']
+
+_LOGGER = logging.getLogger(__name__)
+
+# On means in range, Off means out of range
+SENSOR_PRESENCE = 'presence'
+
+# On means motion detected, Off means cear
+SENSOR_MOTION = 'motion'
+
+# On means open, Off means closed
+SENSOR_DOOR = 'door'
+
+# On means temperature become too cold, Off means normal
+SENSOR_COLD = 'cold'
+
+# On means hot, Off means normal
+SENSOR_HEAT = 'heat'
+
+# On means too dry (humidity), Off means normal
+SENSOR_DRY = 'dry'
+
+# On means too wet (humidity), Off means normal
+SENSOR_WET = 'wet'
+
+# On means light detected, Off means no light
+SENSOR_LIGHT = 'light'
+
+# On means moisture detected (wet), Off means no moisture (dry)
+SENSOR_MOISTURE = 'moisture'
+
+# On means tag battery is low, Off means normal
+SENSOR_BATTERY = 'low_battery'
+
+# Sensor types: Name, device_class, push notification type representing 'on',
+# attr to check
+SENSOR_TYPES = {
+    SENSOR_PRESENCE: ['Presence', 'presence', 'is_in_range', {
+        "on": "oor",
+        "off": "back_in_range"
+        }, 2],
+    SENSOR_MOTION: ['Motion', 'motion', 'is_moved', {
+        "on": "motion_detected",
+        }, 5],
+    SENSOR_DOOR: ['Door', 'door', 'is_door_open', {
+        "on": "door_opened",
+        "off": "door_closed"
+        }, 5],
+    SENSOR_COLD: ['Cold', 'cold', 'is_cold', {
+        "on": "temp_toolow",
+        "off": "temp_normal"
+        }, 4],
+    SENSOR_HEAT: ['Heat', 'heat', 'is_heat', {
+        "on": "temp_toohigh",
+        "off": "temp_normal"
+        }, 4],
+    SENSOR_DRY: ['Too dry', 'dry', 'is_too_dry', {
+        "on": "too_dry",
+        "off": "cap_normal"
+        }, 2],
+    SENSOR_WET: ['Too wet', 'wet', 'is_too_humid', {
+        "on": "too_humid",
+        "off": "cap_normal"
+        }, 2],
+    SENSOR_LIGHT: ['Light', 'light', 'is_light_on', {
+        "on": "too_bright",
+        "off": "light_normal"
+        }, 1],
+    SENSOR_MOISTURE: ['Leak', 'moisture', 'is_leaking', {
+        "on": "water_detected",
+        "off": "water_dried",
+        }, 1],
+    SENSOR_BATTERY: ['Low Battery', 'battery', 'is_battery_low', {
+        "on": "low_battery"
+        }, 3]
+}
+
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    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 WirelessTags."""
+    platform = hass.data.get(WIRELESSTAG_DOMAIN)
+
+    sensors = []
+    tags = platform.tags
+    for tag in tags.values():
+        allowed_sensor_types = WirelessTagBinarySensor.allowed_sensors(tag)
+        for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
+            if sensor_type in allowed_sensor_types:
+                sensors.append(WirelessTagBinarySensor(platform, tag,
+                                                       sensor_type))
+
+    add_devices(sensors, True)
+    hass.add_job(platform.install_push_notifications, sensors)
+
+
+class WirelessTagBinarySensor(WirelessTagBaseSensor, BinarySensorDevice):
+    """A binary sensor implementation for WirelessTags."""
+
+    @classmethod
+    def allowed_sensors(cls, tag):
+        """Return list of allowed sensor types for specific tag type."""
+        sensors_map = {
+            # 13-bit tag - allows everything but not light and moisture
+            WIRELESSTAG_TYPE_13BIT: [
+                SENSOR_PRESENCE, SENSOR_BATTERY,
+                SENSOR_MOTION, SENSOR_DOOR,
+                SENSOR_COLD, SENSOR_HEAT,
+                SENSOR_DRY, SENSOR_WET],
+
+            # Moister/water sensor - temperature and moisture only
+            WIRELESSTAG_TYPE_WATER: [
+                SENSOR_PRESENCE, SENSOR_BATTERY,
+                SENSOR_COLD, SENSOR_HEAT,
+                SENSOR_MOISTURE],
+
+            # ALS Pro: allows everything, but not moisture
+            WIRELESSTAG_TYPE_ALSPRO: [
+                SENSOR_PRESENCE, SENSOR_BATTERY,
+                SENSOR_MOTION, SENSOR_DOOR,
+                SENSOR_COLD, SENSOR_HEAT,
+                SENSOR_DRY, SENSOR_WET,
+                SENSOR_LIGHT],
+
+            # Wemo are power switches.
+            WIRELESSTAG_TYPE_WEMO_DEVICE: [SENSOR_PRESENCE]
+        }
+
+        # allow everything if tag type is unknown
+        # (i just dont have full catalog of them :))
+        tag_type = tag.tag_type
+        fullset = SENSOR_TYPES.keys()
+        return sensors_map[tag_type] if tag_type in sensors_map else fullset
+
+    def __init__(self, api, tag, sensor_type):
+        """Initialize a binary sensor for a Wireless Sensor Tags."""
+        super().__init__(api, tag)
+        self._sensor_type = sensor_type
+        self._name = '{0} {1}'.format(self._tag.name,
+                                      SENSOR_TYPES[self._sensor_type][0])
+        self._device_class = SENSOR_TYPES[self._sensor_type][1]
+        self._tag_attr = SENSOR_TYPES[self._sensor_type][2]
+        self.binary_spec = SENSOR_TYPES[self._sensor_type][3]
+        self.tag_id_index_template = SENSOR_TYPES[self._sensor_type][4]
+
+    async def async_added_to_hass(self):
+        """Register callbacks."""
+        tag_id = self.tag_id
+        event_type = self.device_class
+        async_dispatcher_connect(
+            self.hass,
+            SIGNAL_BINARY_EVENT_UPDATE.format(tag_id, event_type),
+            self._on_binary_event_callback)
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._state == STATE_ON
+
+    @property
+    def device_class(self):
+        """Return the class of the binary sensor."""
+        return self._device_class
+
+    @property
+    def principal_value(self):
+        """Return value of tag.
+
+        Subclasses need override based on type of sensor.
+        """
+        return (
+            STATE_ON if getattr(self._tag, self._tag_attr, False)
+            else STATE_OFF)
+
+    def updated_state_value(self):
+        """Use raw princial value."""
+        return self.principal_value
+
+    @callback
+    def _on_binary_event_callback(self, event):
+        """Update state from arrive push notification."""
+        # state should be 'on' or 'off'
+        self._state = event.data.get('state')
+        self.async_schedule_update_ha_state()
--- a/homeassistant/components/binary_sensor/xiaomi_aqara.py
+++ b/homeassistant/components/binary_sensor/xiaomi_aqara.py
@@ -28,7 +28,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            if model in ['motion', 'sensor_motion', 'sensor_motion.aq2']:
                devices.append(XiaomiMotionSensor(device, hass, gateway))
            elif model in ['magnet', 'sensor_magnet', 'sensor_magnet.aq2']:
-                devices.append(XiaomiDoorSensor(device, gateway))
+                if 'proto' not in device or int(device['proto'][0:1]) == 1:
+                    data_key = 'status'
+                else:
+                    data_key = 'window_status'
+                devices.append(XiaomiDoorSensor(device, data_key, gateway))
            elif model == 'sensor_wleak.aq1':
                devices.append(XiaomiWaterLeakSensor(device, gateway))
            elif model in ['smoke', 'sensor_smoke']:
@@ -43,10 +47,10 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                    data_key = 'channel_0'
                devices.append(XiaomiButton(device, 'Switch', data_key,
                                            hass, gateway))
-            elif model in ['86sw1', 'sensor_86sw1.aq1']:
+            elif model in ['86sw1', 'sensor_86sw1', 'sensor_86sw1.aq1']:
                devices.append(XiaomiButton(device, 'Wall Switch', 'channel_0',
                                            hass, gateway))
-            elif model in ['86sw2', 'sensor_86sw2.aq1']:
+            elif model in ['86sw2', 'sensor_86sw2', 'sensor_86sw2.aq1']:
                devices.append(XiaomiButton(device, 'Wall Switch (Left)',
                                            'channel_0', hass, gateway))
                devices.append(XiaomiButton(device, 'Wall Switch (Right)',
@@ -190,11 +194,11 @@ class XiaomiMotionSensor(XiaomiBinarySensor):
 class XiaomiDoorSensor(XiaomiBinarySensor):
    """Representation of a XiaomiDoorSensor."""

-    def __init__(self, device, xiaomi_hub):
+    def __init__(self, device, data_key, xiaomi_hub):
        """Initialize the XiaomiDoorSensor."""
        self._open_since = 0
        XiaomiBinarySensor.__init__(self, device, 'Door Window Sensor',
-                                    xiaomi_hub, 'status', 'opening')
+                                    xiaomi_hub, data_key, 'opening')

    @property
    def device_state_attributes(self):
@@ -330,6 +334,8 @@ class XiaomiButton(XiaomiBinarySensor):
            click_type = 'both'
        elif value == 'shake':
            click_type = 'shake'
+        elif value in ['long_click', 'long_both_click']:
+            return False
        else:
            _LOGGER.warning("Unsupported click_type detected: %s", value)
            return False
--- a/homeassistant/components/binary_sensor/zha.py
+++ b/homeassistant/components/binary_sensor/zha.py
@@ -187,8 +187,8 @@ class Switch(zha.Entity, BinarySensorDevice):
                if args[0] == 0xff:
                    rate = 10  # Should read default move rate
                self._entity.move_level(-rate if args[0] else rate)
-            elif command_id == 0x0002:  # step
-                # Step (technically shouldn't change on/off)
+            elif command_id in (0x0002, 0x0006):  # step, -with_on_off
+                # Step (technically may change on/off)
                self._entity.move_level(-args[1] if args[0] else args[1])

        def attribute_update(self, attrid, value):
@@ -203,14 +203,19 @@ class Switch(zha.Entity, BinarySensorDevice):
    def __init__(self, **kwargs):
        """Initialize Switch."""
        super().__init__(**kwargs)
-        self._state = True
-        self._level = 255
+        self._state = False
+        self._level = 0
        from zigpy.zcl.clusters import general
        self._out_listeners = {
            general.OnOff.cluster_id: self.OnOffListener(self),
            general.LevelControl.cluster_id: self.LevelListener(self),
        }

+    @property
+    def should_poll(self) -> bool:
+        """Let zha handle polling."""
+        return False
+
    @property
    def is_on(self) -> bool:
        """Return true if the binary sensor is on."""
--- a/homeassistant/components/bloomsky.py
+++ b/homeassistant/components/bloomsky.py
@@ -34,7 +34,6 @@ CONFIG_SCHEMA = vol.Schema({
 }, extra=vol.ALLOW_EXTRA)


-# pylint: disable=unused-argument
 def setup(hass, config):
    """Set up the BloomSky component."""
    api_key = config[DOMAIN][CONF_API_KEY]
--- a/homeassistant/components/calendar/init.py
+++ b/homeassistant/components/calendar/init.py
@@ -4,11 +4,12 @@ Support for Google Calendar event device sensors.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/calendar/
 """
-import asyncio
 import logging
 from datetime import timedelta
 import re

+from aiohttp import web
+
 from homeassistant.components.google import (
    CONF_OFFSET, CONF_DEVICE_ID, CONF_NAME)
 from homeassistant.const import STATE_OFF, STATE_ON
@@ -18,23 +19,33 @@ from homeassistant.helpers.entity import Entity, generate_entity_id
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.template import DATE_STR_FORMAT
 from homeassistant.util import dt
+from homeassistant.components import http
+

 _LOGGER = logging.getLogger(__name__)

 DOMAIN = 'calendar'

+DEPENDENCIES = ['http']
+
 ENTITY_ID_FORMAT = DOMAIN + '.{}'

 SCAN_INTERVAL = timedelta(seconds=60)


-@asyncio.coroutine
-def async_setup(hass, config):
+async def async_setup(hass, config):
    """Track states and offer events for calendars."""
    component = EntityComponent(
        _LOGGER, DOMAIN, hass, SCAN_INTERVAL, DOMAIN)

-    yield from component.async_setup(config)
+    hass.http.register_view(CalendarListView(component))
+    hass.http.register_view(CalendarEventView(component))
+
+    # Doesn't work in prod builds of the frontend: home-assistant-polymer#1289
+    # await hass.components.frontend.async_register_built_in_panel(
+    #     'calendar', 'calendar', 'hass:calendar')
+
+    await component.async_setup(config)
    return True


@@ -42,7 +53,14 @@ DEFAULT_CONF_TRACK_NEW = True
 DEFAULT_CONF_OFFSET = '!!'


-# pylint: disable=too-many-instance-attributes
+def get_date(date):
+    """Get the dateTime from date or dateTime as a local."""
+    if 'date' in date:
+        return dt.start_of_local_day(dt.dt.datetime.combine(
+            dt.parse_date(date['date']), dt.dt.time.min))
+    return dt.as_local(dt.parse_datetime(date['dateTime']))
+
+
 class CalendarEventDevice(Entity):
    """A calendar event device."""

@@ -50,7 +68,6 @@ class CalendarEventDevice(Entity):
    # with an update() method
    data = None

-    # pylint: disable=too-many-arguments
    def __init__(self, hass, data):
        """Create the Calendar Event Device."""
        self._name = data.get(CONF_NAME)
@@ -144,15 +161,8 @@ class CalendarEventDevice(Entity):
            self.cleanup()
            return

-        def _get_date(date):
-            """Get the dateTime from date or dateTime as a local."""
-            if 'date' in date:
-                return dt.start_of_local_day(dt.dt.datetime.combine(
-                    dt.parse_date(date['date']), dt.dt.time.min))
-            return dt.as_local(dt.parse_datetime(date['dateTime']))
-
-        start = _get_date(self.data.event['start'])
-        end = _get_date(self.data.event['end'])
+        start = get_date(self.data.event['start'])
+        end = get_date(self.data.event['end'])

        summary = self.data.event.get('summary', '')

@@ -176,10 +186,61 @@ class CalendarEventDevice(Entity):

        # cleanup the string so we don't have a bunch of double+ spaces
        self._cal_data['message'] = re.sub('  +', '', summary).strip()
-
        self._cal_data['offset_time'] = offset_time
        self._cal_data['location'] = self.data.event.get('location', '')
        self._cal_data['description'] = self.data.event.get('description', '')
        self._cal_data['start'] = start
        self._cal_data['end'] = end
        self._cal_data['all_day'] = 'date' in self.data.event['start']
+
+
+class CalendarEventView(http.HomeAssistantView):
+    """View to retrieve calendar content."""
+
+    url = '/api/calendars/{entity_id}'
+    name = 'api:calendars:calendar'
+
+    def __init__(self, component):
+        """Initialize calendar view."""
+        self.component = component
+
+    async def get(self, request, entity_id):
+        """Return calendar events."""
+        entity = self.component.get_entity(entity_id)
+        start = request.query.get('start')
+        end = request.query.get('end')
+        if None in (start, end, entity):
+            return web.Response(status=400)
+        try:
+            start_date = dt.parse_datetime(start)
+            end_date = dt.parse_datetime(end)
+        except (ValueError, AttributeError):
+            return web.Response(status=400)
+        event_list = await entity.async_get_events(
+            request.app['hass'], start_date, end_date)
+        return self.json(event_list)
+
+
+class CalendarListView(http.HomeAssistantView):
+    """View to retrieve calendar list."""
+
+    url = '/api/calendars'
+    name = "api:calendars"
+
+    def __init__(self, component):
+        """Initialize calendar view."""
+        self.component = component
+
+    async def get(self, request):
+        """Retrieve calendar list."""
+        get_state = request.app['hass'].states.get
+        calendar_list = []
+
+        for entity in self.component.entities:
+            state = get_state(entity.entity_id)
+            calendar_list.append({
+                "name": state.name,
+                "entity_id": entity.entity_id,
+            })
+
+        return self.json(sorted(calendar_list, key=lambda x: x['name']))
--- a/homeassistant/components/calendar/caldav.py
+++ b/homeassistant/components/calendar/caldav.py
@@ -11,7 +11,7 @@ import re
 import voluptuous as vol

 from homeassistant.components.calendar import (
-    PLATFORM_SCHEMA, CalendarEventDevice)
+    PLATFORM_SCHEMA, CalendarEventDevice, get_date)
 from homeassistant.const import (
    CONF_NAME, CONF_PASSWORD, CONF_URL, CONF_USERNAME)
 import homeassistant.helpers.config_validation as cv
@@ -92,7 +92,7 @@ def setup_platform(hass, config, add_devices, disc_info=None):
        if not config.get(CONF_CUSTOM_CALENDARS):
            device_data = {
                CONF_NAME: calendar.name,
-                CONF_DEVICE_ID: calendar.name
+                CONF_DEVICE_ID: calendar.name,
            }
            calendar_devices.append(
                WebDavCalendarEventDevice(hass, device_data, calendar)
@@ -120,6 +120,10 @@ class WebDavCalendarEventDevice(CalendarEventDevice):
        attributes = super().device_state_attributes
        return attributes

+    async def async_get_events(self, hass, start_date, end_date):
+        """Get all events in a specific time frame."""
+        return await self.data.async_get_events(hass, start_date, end_date)
+

 class WebDavCalendarData(object):
    """Class to utilize the calendar dav client object to get next event."""
@@ -131,6 +135,33 @@ class WebDavCalendarData(object):
        self.search = search
        self.event = None

+    async def async_get_events(self, hass, start_date, end_date):
+        """Get all events in a specific time frame."""
+        # Get event list from the current calendar
+        vevent_list = await hass.async_add_job(self.calendar.date_search,
+                                               start_date, end_date)
+        event_list = []
+        for event in vevent_list:
+            vevent = event.instance.vevent
+            uid = None
+            if hasattr(vevent, 'uid'):
+                uid = vevent.uid.value
+            data = {
+                "uid": uid,
+                "title": vevent.summary.value,
+                "start": self.get_hass_date(vevent.dtstart.value),
+                "end": self.get_hass_date(self.get_end_date(vevent)),
+                "location": self.get_attr_value(vevent, "location"),
+                "description": self.get_attr_value(vevent, "description"),
+            }
+
+            data['start'] = get_date(data['start']).isoformat()
+            data['end'] = get_date(data['end']).isoformat()
+
+            event_list.append(data)
+
+        return event_list
+
    @Throttle(MIN_TIME_BETWEEN_UPDATES)
    def update(self):
        """Get the latest data."""
--- a/homeassistant/components/calendar/demo.py
+++ b/homeassistant/components/calendar/demo.py
@@ -4,8 +4,10 @@ Demo platform that has two fake binary sensors.
 For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/demo/
 """
+import copy
+
 import homeassistant.util.dt as dt_util
-from homeassistant.components.calendar import CalendarEventDevice
+from homeassistant.components.calendar import CalendarEventDevice, get_date
 from homeassistant.components.google import CONF_DEVICE_ID, CONF_NAME


@@ -15,13 +17,13 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    calendar_data_current = DemoGoogleCalendarDataCurrent()
    add_devices([
        DemoGoogleCalendar(hass, calendar_data_future, {
-            CONF_NAME: 'Future Event',
-            CONF_DEVICE_ID: 'future_event',
+            CONF_NAME: 'Calendar 1',
+            CONF_DEVICE_ID: 'calendar_1',
        }),

        DemoGoogleCalendar(hass, calendar_data_current, {
-            CONF_NAME: 'Current Event',
-            CONF_DEVICE_ID: 'current_event',
+            CONF_NAME: 'Calendar 2',
+            CONF_DEVICE_ID: 'calendar_2',
        }),
    ])

@@ -29,11 +31,21 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class DemoGoogleCalendarData(object):
    """Representation of a Demo Calendar element."""

+    event = {}
+
    # pylint: disable=no-self-use
    def update(self):
        """Return true so entity knows we have new data."""
        return True

+    async def async_get_events(self, hass, start_date, end_date):
+        """Get all events in a specific time frame."""
+        event = copy.copy(self.event)
+        event['title'] = event['summary']
+        event['start'] = get_date(event['start']).isoformat()
+        event['end'] = get_date(event['end']).isoformat()
+        return [event]
+

 class DemoGoogleCalendarDataFuture(DemoGoogleCalendarData):
    """Representation of a Demo Calendar for a future event."""
@@ -80,3 +92,7 @@ class DemoGoogleCalendar(CalendarEventDevice):
        """Initialize Google Calendar but without the API calls."""
        self.data = calendar_data
        super().__init__(hass, data)
+
+    async def async_get_events(self, hass, start_date, end_date):
+        """Get all events in a specific time frame."""
+        return await self.data.async_get_events(hass, start_date, end_date)
--- a/homeassistant/components/calendar/google.py
+++ b/homeassistant/components/calendar/google.py
@@ -4,7 +4,6 @@ Support for Google Calendar Search binary sensors.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.google_calendar/
 """
-# pylint: disable=import-error
 import logging
 from datetime import timedelta

@@ -51,6 +50,10 @@ class GoogleCalendarEventDevice(CalendarEventDevice):

        super().__init__(hass, data)

+    async def async_get_events(self, hass, start_date, end_date):
+        """Get all events in a specific time frame."""
+        return await self.data.async_get_events(hass, start_date, end_date)
+

 class GoogleCalendarData(object):
    """Class to utilize calendar service object to get next event."""
@@ -64,9 +67,7 @@ class GoogleCalendarData(object):
        self.ignore_availability = ignore_availability
        self.event = None

-    @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    def update(self):
-        """Get the latest data."""
+    def _prepare_query(self):
        from httplib2 import ServerNotFoundError

        try:
@@ -74,14 +75,40 @@ class GoogleCalendarData(object):
        except ServerNotFoundError:
            _LOGGER.warning("Unable to connect to Google, using cached data")
            return False
-
        params = dict(DEFAULT_GOOGLE_SEARCH_PARAMS)
-        params['timeMin'] = dt.now().isoformat('T')
        params['calendarId'] = self.calendar_id
        if self.search:
            params['q'] = self.search

-        events = service.events()  # pylint: disable=no-member
+        return service, params
+
+    async def async_get_events(self, hass, start_date, end_date):
+        """Get all events in a specific time frame."""
+        service, params = await hass.async_add_job(self._prepare_query)
+        params['timeMin'] = start_date.isoformat('T')
+        params['timeMax'] = end_date.isoformat('T')
+
+        events = await hass.async_add_job(service.events)
+        result = await hass.async_add_job(events.list(**params).execute)
+
+        items = result.get('items', [])
+        event_list = []
+        for item in items:
+            if (not self.ignore_availability
+                    and 'transparency' in item.keys()):
+                if item['transparency'] == 'opaque':
+                    event_list.append(item)
+            else:
+                event_list.append(item)
+        return event_list
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Get the latest data."""
+        service, params = self._prepare_query()
+        params['timeMin'] = dt.now().isoformat('T')
+
+        events = service.events()
        result = events.list(**params).execute()

        items = result.get('items', [])
--- a/homeassistant/components/calendar/todoist.py
+++ b/homeassistant/components/calendar/todoist.py
@@ -257,6 +257,10 @@ class TodoistProjectDevice(CalendarEventDevice):
        super().cleanup()
        self._cal_data[ALL_TASKS] = []

+    async def async_get_events(self, hass, start_date, end_date):
+        """Get all events in a specific time frame."""
+        return await self.data.async_get_events(hass, start_date, end_date)
+
    @property
    def device_state_attributes(self):
        """Return the device state attributes."""
@@ -485,6 +489,31 @@ class TodoistProjectData(object):
                    continue
        return event

+    async def async_get_events(self, hass, start_date, end_date):
+        """Get all tasks in a specific time frame."""
+        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]
+
+        events = []
+        time_format = '%a %d %b %Y %H:%M:%S %z'
+        for task in project_task_data:
+            due_date = datetime.strptime(task['due_date_utc'], time_format)
+            if due_date > start_date and due_date < end_date:
+                event = {
+                    'uid': task['id'],
+                    'title': task['content'],
+                    'start': due_date.isoformat(),
+                    'end': due_date.isoformat(),
+                    'allDay': True,
+                }
+                events.append(event)
+        return events
+
    @Throttle(MIN_TIME_BETWEEN_UPDATES)
    def update(self):
        """Get the latest data."""
--- a/homeassistant/components/camera/init.py
+++ b/homeassistant/components/camera/init.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
 """
 Component to interface with cameras.

@@ -67,8 +66,8 @@ CAMERA_SERVICE_SNAPSHOT = CAMERA_SERVICE_SCHEMA.extend({

 WS_TYPE_CAMERA_THUMBNAIL = 'camera_thumbnail'
 SCHEMA_WS_CAMERA_THUMBNAIL = websocket_api.BASE_COMMAND_MESSAGE_SCHEMA.extend({
-    'type': WS_TYPE_CAMERA_THUMBNAIL,
-    'entity_id': cv.entity_id
+    vol.Required('type'): WS_TYPE_CAMERA_THUMBNAIL,
+    vol.Required('entity_id'): cv.entity_id
 })


@@ -97,6 +96,7 @@ def disable_motion_detection(hass, entity_id=None):


@bind_hass
+@callback
 def async_snapshot(hass, filename, entity_id=None):
    """Make a snapshot from a camera."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
@@ -129,8 +129,7 @@ async def async_get_image(hass, entity_id, timeout=10):
    raise HomeAssistantError('Unable to get image')


-@asyncio.coroutine
-def async_setup(hass, config):
+async def async_setup(hass, config):
    """Set up the camera component."""
    component = hass.data[DOMAIN] = \
        EntityComponent(_LOGGER, DOMAIN, hass, SCAN_INTERVAL)
@@ -142,7 +141,7 @@ def async_setup(hass, config):
        SCHEMA_WS_CAMERA_THUMBNAIL
    )

-    yield from component.async_setup(config)
+    await component.async_setup(config)

    @callback
    def update_tokens(time):
@@ -154,27 +153,25 @@ def async_setup(hass, config):
    hass.helpers.event.async_track_time_interval(
        update_tokens, TOKEN_CHANGE_INTERVAL)

-    @asyncio.coroutine
-    def async_handle_camera_service(service):
+    async def async_handle_camera_service(service):
        """Handle calls to the camera services."""
        target_cameras = component.async_extract_from_service(service)

        update_tasks = []
        for camera in target_cameras:
            if service.service == SERVICE_ENABLE_MOTION:
-                yield from camera.async_enable_motion_detection()
+                await camera.async_enable_motion_detection()
            elif service.service == SERVICE_DISABLE_MOTION:
-                yield from camera.async_disable_motion_detection()
+                await camera.async_disable_motion_detection()

            if not camera.should_poll:
                continue
            update_tasks.append(camera.async_update_ha_state(True))

        if update_tasks:
-            yield from asyncio.wait(update_tasks, loop=hass.loop)
+            await asyncio.wait(update_tasks, loop=hass.loop)

-    @asyncio.coroutine
-    def async_handle_snapshot_service(service):
+    async def async_handle_snapshot_service(service):
        """Handle snapshot services calls."""
        target_cameras = component.async_extract_from_service(service)
        filename = service.data[ATTR_FILENAME]
@@ -190,7 +187,7 @@ def async_setup(hass, config):
                    "Can't write %s, no access to path!", snapshot_file)
                continue

-            image = yield from camera.async_camera_image()
+            image = await camera.async_camera_image()

            def _write_image(to_file, image_data):
                """Executor helper to write image."""
@@ -198,7 +195,7 @@ def async_setup(hass, config):
                    img_file.write(image_data)

            try:
-                yield from hass.async_add_job(
+                await hass.async_add_job(
                    _write_image, snapshot_file, image)
            except OSError as err:
                _LOGGER.error("Can't write image to file: %s", err)
@@ -216,6 +213,16 @@ def async_setup(hass, config):
    return True


+async def async_setup_entry(hass, entry):
+    """Setup a config entry."""
+    return await hass.data[DOMAIN].async_setup_entry(entry)
+
+
+async def async_unload_entry(hass, entry):
+    """Unload a config entry."""
+    return await hass.data[DOMAIN].async_unload_entry(entry)
+
+
 class Camera(Entity):
    """The base class for camera entities."""

@@ -265,6 +272,7 @@ class Camera(Entity):
        """Return bytes of camera image."""
        raise NotImplementedError()

+    @callback
    def async_camera_image(self):
        """Return bytes of camera image.

@@ -314,6 +322,7 @@ class Camera(Entity):
        except asyncio.CancelledError:
            _LOGGER.debug("Stream closed by frontend.")
            response = None
+            raise

        finally:
            if response is not None:
@@ -388,8 +397,7 @@ class CameraView(HomeAssistantView):
        """Initialize a basic camera view."""
        self.component = component

-    @asyncio.coroutine
-    def get(self, request, entity_id):
+    async def get(self, request, entity_id):
        """Start a GET request."""
        camera = self.component.get_entity(entity_id)

@@ -403,11 +411,10 @@ class CameraView(HomeAssistantView):
        if not authenticated:
            return web.Response(status=401)

-        response = yield from self.handle(request, camera)
+        response = await self.handle(request, camera)
        return response

-    @asyncio.coroutine
-    def handle(self, request, camera):
+    async def handle(self, request, camera):
        """Handle the camera request."""
        raise NotImplementedError()

@@ -418,12 +425,11 @@ class CameraImageView(CameraView):
    url = '/api/camera_proxy/{entity_id}'
    name = 'api:camera:image'

-    @asyncio.coroutine
-    def handle(self, request, camera):
+    async def handle(self, request, camera):
        """Serve camera image."""
        with suppress(asyncio.CancelledError, asyncio.TimeoutError):
            with async_timeout.timeout(10, loop=request.app['hass'].loop):
-                image = yield from camera.async_camera_image()
+                image = await camera.async_camera_image()

            if image:
                return web.Response(body=image,
--- a/homeassistant/components/camera/arlo.py
+++ b/homeassistant/components/camera/arlo.py
@@ -4,23 +4,22 @@ 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.core import callback
 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.arlo import DEFAULT_BRAND, DATA_ARLO
+from homeassistant.components.arlo import (
+    DEFAULT_BRAND, DATA_ARLO, SIGNAL_UPDATE_ARLO)
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 from homeassistant.components.ffmpeg import DATA_FFMPEG
 from homeassistant.const import ATTR_BATTERY_LEVEL
 from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+from homeassistant.helpers.dispatcher import async_dispatcher_connect

 _LOGGER = logging.getLogger(__name__)

-SCAN_INTERVAL = timedelta(seconds=90)
-
 ARLO_MODE_ARMED = 'armed'
 ARLO_MODE_DISARMED = 'disarmed'

@@ -44,22 +43,19 @@ POWERSAVE_MODE_MAPPING = {
 }

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_FFMPEG_ARGUMENTS):
-    cv.string,
+    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string,
 })


 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up an Arlo IP Camera."""
-    arlo = hass.data.get(DATA_ARLO)
-    if not arlo:
-        return False
+    arlo = hass.data[DATA_ARLO]

    cameras = []
    for camera in arlo.cameras:
        cameras.append(ArloCam(hass, camera, config))

-    add_devices(cameras, True)
+    add_devices(cameras)


 class ArloCam(Camera):
@@ -74,31 +70,41 @@ class ArloCam(Camera):
        self._ffmpeg = hass.data[DATA_FFMPEG]
        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
        self._last_refresh = None
-        if self._camera.base_station:
-            self._camera.base_station.refresh_rate = \
-                SCAN_INTERVAL.total_seconds()
        self.attrs = {}

    def camera_image(self):
        """Return a still image response from the camera."""
-        return self._camera.last_image
+        return self._camera.last_image_from_cache

-    @asyncio.coroutine
-    def handle_async_mjpeg_stream(self, request):
+    async def async_added_to_hass(self):
+        """Register callbacks."""
+        async_dispatcher_connect(
+            self.hass, SIGNAL_UPDATE_ARLO, self._update_callback)
+
+    @callback
+    def _update_callback(self):
+        """Call update method."""
+        self.async_schedule_update_ha_state()
+
+    async def handle_async_mjpeg_stream(self, request):
        """Generate an HTTP MJPEG stream from the camera."""
        from haffmpeg import CameraMjpeg
        video = self._camera.last_video
        if not video:
+            error_msg = \
+                'Video not found for {0}. Is it older than {1} days?'.format(
+                    self.name, self._camera.min_days_vdo_cache)
+            _LOGGER.error(error_msg)
            return

        stream = CameraMjpeg(self._ffmpeg.binary, loop=self.hass.loop)
-        yield from stream.open_camera(
+        await stream.open_camera(
            video.video_url, extra_cmd=self._ffmpeg_arguments)

-        yield from async_aiohttp_proxy_stream(
+        await async_aiohttp_proxy_stream(
            self.hass, request, stream,
            'multipart/x-mixed-replace;boundary=ffserver')
-        yield from stream.close()
+        await stream.close()

    @property
    def name(self):
@@ -132,11 +138,6 @@ class ArloCam(Camera):
        """Return the camera brand."""
        return DEFAULT_BRAND

-    @property
-    def should_poll(self):
-        """Camera should poll periodically."""
-        return True
-
    @property
    def motion_detection_enabled(self):
        """Return the camera motion detection status."""
@@ -164,7 +165,3 @@ 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()
--- a/homeassistant/components/camera/bloomsky.py
+++ b/homeassistant/components/camera/bloomsky.py
@@ -13,7 +13,6 @@ from homeassistant.components.camera import Camera
 DEPENDENCIES = ['bloomsky']


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up access to BloomSky cameras."""
    bloomsky = hass.components.bloomsky
--- a/homeassistant/components/camera/demo.py
+++ b/homeassistant/components/camera/demo.py
@@ -12,9 +12,10 @@ from homeassistant.components.camera import Camera
 _LOGGER = logging.getLogger(__name__)


-def setup_platform(hass, config, add_devices, discovery_info=None):
+async def async_setup_platform(hass, config, async_add_devices,
+                               discovery_info=None):
    """Set up the Demo camera platform."""
-    add_devices([
+    async_add_devices([
        DemoCamera(hass, config, 'Demo camera')
    ])

--- a/homeassistant/components/camera/doorbird.py
+++ b/homeassistant/components/camera/doorbird.py
@@ -17,9 +17,9 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession

 DEPENDENCIES = ['doorbird']

-_CAMERA_LAST_VISITOR = "DoorBird Last Ring"
-_CAMERA_LAST_MOTION = "DoorBird Last Motion"
-_CAMERA_LIVE = "DoorBird Live"
+_CAMERA_LAST_VISITOR = "{} Last Ring"
+_CAMERA_LAST_MOTION = "{} Last Motion"
+_CAMERA_LIVE = "{} Live"
 _LAST_VISITOR_INTERVAL = datetime.timedelta(minutes=1)
 _LAST_MOTION_INTERVAL = datetime.timedelta(minutes=1)
 _LIVE_INTERVAL = datetime.timedelta(seconds=1)
@@ -30,16 +30,22 @@ _TIMEOUT = 10  # seconds
@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)
-    async_add_devices([
-        DoorBirdCamera(device.live_image_url, _CAMERA_LIVE, _LIVE_INTERVAL),
-        DoorBirdCamera(
-            device.history_image_url(1, 'doorbell'), _CAMERA_LAST_VISITOR,
-            _LAST_VISITOR_INTERVAL),
-        DoorBirdCamera(
-            device.history_image_url(1, 'motionsensor'), _CAMERA_LAST_MOTION,
-            _LAST_MOTION_INTERVAL),
-    ])
+    for doorstation in hass.data[DOORBIRD_DOMAIN]:
+        device = doorstation.device
+        async_add_devices([
+            DoorBirdCamera(
+                device.live_image_url,
+                _CAMERA_LIVE.format(doorstation.name),
+                _LIVE_INTERVAL),
+            DoorBirdCamera(
+                device.history_image_url(1, 'doorbell'),
+                _CAMERA_LAST_VISITOR.format(doorstation.name),
+                _LAST_VISITOR_INTERVAL),
+            DoorBirdCamera(
+                device.history_image_url(1, 'motionsensor'),
+                _CAMERA_LAST_MOTION.format(doorstation.name),
+                _LAST_MOTION_INTERVAL),
+        ])


 class DoorBirdCamera(Camera):
--- a/homeassistant/components/camera/foscam.py
+++ b/homeassistant/components/camera/foscam.py
@@ -33,7 +33,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up a Foscam IP Camera."""
    add_devices([FoscamCam(config)])
--- a/homeassistant/components/camera/generic.py
+++ b/homeassistant/components/camera/generic.py
@@ -46,7 +46,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({


@asyncio.coroutine
-# pylint: disable=unused-argument
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Set up a generic IP Camera."""
    async_add_devices([GenericCamera(hass, config)])
--- a/homeassistant/components/camera/mjpeg.py
+++ b/homeassistant/components/camera/mjpeg.py
@@ -42,7 +42,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({


@asyncio.coroutine
-# pylint: disable=unused-argument
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Set up a MJPEG IP Camera."""
    if discovery_info:
--- a/homeassistant/components/camera/neato.py
+++ b/homeassistant/components/camera/neato.py
@@ -10,12 +10,13 @@ from datetime import timedelta
 from homeassistant.components.camera import Camera
 from homeassistant.components.neato import (
    NEATO_MAP_DATA, NEATO_ROBOTS, NEATO_LOGIN)
-from homeassistant.util import Throttle

 _LOGGER = logging.getLogger(__name__)

 DEPENDENCIES = ['neato']

+SCAN_INTERVAL = timedelta(minutes=10)
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Neato Camera."""
@@ -45,7 +46,6 @@ class NeatoCleaningMap(Camera):
        self.update()
        return self._image

-    @Throttle(timedelta(seconds=10))
    def update(self):
        """Check the contents of the map list."""
        self.neato.update_robots()
--- a/homeassistant/components/camera/nest.py
+++ b/homeassistant/components/camera/nest.py
@@ -23,14 +23,19 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({})


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up a Nest Cam."""
-    if discovery_info is None:
-        return
+    """Set up a Nest Cam.

-    camera_devices = hass.data[nest.DATA_NEST].cameras()
+    No longer in use.
+    """
+
+
+async def async_setup_entry(hass, entry, async_add_devices):
+    """Set up a Nest sensor based on a config entry."""
+    camera_devices = \
+        await hass.async_add_job(hass.data[nest.DATA_NEST].cameras)
    cameras = [NestCamera(structure, device)
               for structure, device in camera_devices]
-    add_devices(cameras, True)
+    async_add_devices(cameras, True)


 class NestCamera(Camera):
--- a/Show More
+++ b/Show More