Merge pull request #15330 from home-assistant/rc

0.73
Bumped version to 0.73.0
2025-09-25 12:59:29 +00:00 · 2018-07-06 16:41:09 -04:00 · 2018-07-06 22:31:09 +02:00 · 2018-07-04 12:11:52 -04:00 · 2018-07-04 12:11:39 -04:00 · 2018-07-03 14:58:31 -04:00
773 changed files with 18351 additions and 6102 deletions
--- a/.coveragerc
+++ b/.coveragerc
@@ -61,6 +61,9 @@ omit =
    homeassistant/components/coinbase.py
    homeassistant/components/sensor/coinbase.py

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

@@ -97,7 +100,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 +126,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 +192,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 +225,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 +255,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 +320,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

@@ -345,6 +360,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 +376,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 +392,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 +400,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 +412,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 +463,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 +478,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 +489,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 +497,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 +524,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 +540,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 +556,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 +564,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
@@ -619,6 +642,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 +661,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 +766,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/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/auth.py
+++ b/homeassistant/auth.py
@@ -1,26 +1,27 @@
 """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 os
 import uuid
+from collections import OrderedDict
+from datetime import datetime, timedelta

 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.core import callback
 from homeassistant.util import dt as dt_util
-
+from homeassistant.util.decorator import Registry

 _LOGGER = logging.getLogger(__name__)

+STORAGE_VERSION = 1
+STORAGE_KEY = 'auth'

 AUTH_PROVIDERS = Registry()

@@ -121,23 +122,12 @@ class User:
    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))
+    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))
-
-    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,
-        }
+    refresh_tokens = attr.ib(type=dict, default=attr.Factory(dict), cmp=False)


@attr.s(slots=True)
@@ -152,7 +142,7 @@ class RefreshToken:
                                      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))
+    access_tokens = attr.ib(type=list, default=attr.Factory(list), cmp=False)


@attr.s(slots=True)
@@ -168,9 +158,10 @@ class AccessToken:
                    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
+    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)
@@ -281,7 +272,24 @@ class AuthManager:
        self.login_flow = data_entry_flow.FlowManager(
            hass, self._async_create_login_flow,
            self._async_finish_login_flow)
-        self.access_tokens = {}
+        self._access_tokens = {}
+
+    @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 async_auth_providers(self):
@@ -317,13 +325,22 @@ class AuthManager:
    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
+        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)
+        tkn = self._access_tokens.get(token)
+
+        if tkn is None:
+            return None
+
+        if tkn.expired:
+            self._access_tokens.pop(token)
+            return None
+
+        return tkn

    async def async_create_client(self, name, *, redirect_uris=None,
                                  no_secret=False):
@@ -331,6 +348,16 @@ class AuthManager:
        return await self._store.async_create_client(
            name, redirect_uris, no_secret)

+    async def async_get_or_create_client(self, name, *, redirect_uris=None,
+                                         no_secret=False):
+        """Find a client, if not exists, create a new one."""
+        for client in await self._store.async_get_clients():
+            if client.name == name:
+                return 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)
@@ -374,29 +401,36 @@ class AuthStore:
    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)
+        self._users = None
+        self._clients = None
+        self._store = hass.helpers.storage.Store(STORAGE_VERSION, STORAGE_KEY)

    async def credentials_for_provider(self, provider_type, provider_id):
        """Return credentials for specific auth provider type and id."""
-        if self.users is None:
+        if self._users is None:
            await self.async_load()

        return [
            credentials
-            for user in self.users.values()
+            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:
+    async def async_get_users(self):
+        """Retrieve all users."""
+        if self._users is None:
            await self.async_load()

-        return self.users.get(user_id)
+        return list(self._users.values())
+
+    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.
@@ -404,7 +438,7 @@ class AuthStore:
        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:
+        if self._users is None:
            await self.async_load()

        # New credentials, store in user
@@ -412,7 +446,7 @@ class AuthStore:
            info = await auth_provider.async_user_meta_for_credentials(
                credentials)
            # Make owner and activate user if it's the first user.
-            if self.users:
+            if self._users:
                is_owner = False
                is_active = False
            else:
@@ -424,11 +458,11 @@ class AuthStore:
                is_active=is_active,
                name=info.get('name'),
            )
-            self.users[new_user.id] = new_user
+            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 user in self._users.values():
            for creds in user.credentials:
                if (creds.auth_provider_type == credentials.auth_provider_type
                        and creds.auth_provider_id ==
@@ -445,11 +479,19 @@ class AuthStore:

    async def async_remove_user(self, user):
        """Remove a user."""
-        self.users.pop(user.id)
+        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."""
+        local_user = await self.async_get_user(user.id)
+        if local_user is None:
+            raise ValueError('Invalid user')
+
+        local_client = await self.async_get_client(client_id)
+        if local_client is None:
+            raise ValueError('Invalid client_id')
+
        refresh_token = RefreshToken(user, client_id)
        user.refresh_tokens[refresh_token.token] = refresh_token
        await self.async_save()
@@ -457,10 +499,10 @@ class AuthStore:

    async def async_get_refresh_token(self, token):
        """Get refresh token by token."""
-        if self.users is None:
+        if self._users is None:
            await self.async_load()

-        for user in self.users.values():
+        for user in self._users.values():
            refresh_token = user.refresh_tokens.get(token)
            if refresh_token is not None:
                return refresh_token
@@ -469,7 +511,7 @@ class AuthStore:

    async def async_create_client(self, name, redirect_uris, no_secret):
        """Create a new client."""
-        if self.clients is None:
+        if self._clients is None:
            await self.async_load()

        kwargs = {
@@ -481,23 +523,148 @@ class AuthStore:
            kwargs['secret'] = None

        client = Client(**kwargs)
-        self.clients[client.id] = client
+        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:
+    async def async_get_clients(self):
+        """Return all clients."""
+        if self._clients is None:
            await self.async_load()

-        return self.clients.get(client_id)
+        return list(self._clients.values())
+
+    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 = {}
+        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
+
+        if data is None:
+            self._users = {}
+            self._clients = {}
+            return
+
+        users = {
+            user_dict['id']: User(**user_dict) for user_dict in data['users']
+        }
+
+        for cred_dict in data['credentials']:
+            users[cred_dict['user_id']].credentials.append(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 = {}
+
+        for rt_dict in data['refresh_tokens']:
+            token = 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 = 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)
+
+        clients = {
+            cl_dict['id']: Client(**cl_dict) for cl_dict in data['clients']
+        }
+
+        self._users = users
+        self._clients = clients

    async def async_save(self):
        """Save users."""
-        pass
+        users = [
+            {
+                'id': user.id,
+                'is_owner': user.is_owner,
+                'is_active': user.is_active,
+                'name': user.name,
+            }
+            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
+        ]
+
+        clients = [
+            {
+                'id': client.id,
+                'name': client.name,
+                'secret': client.secret,
+                'redirect_uris': client.redirect_uris,
+            }
+            for client in self._clients.values()
+        ]
+
+        data = {
+            'users': users,
+            'clients': clients,
+            'credentials': credentials,
+            'access_tokens': access_tokens,
+            'refresh_tokens': refresh_tokens,
+        }
+
+        await self._store.async_save(data, delay=1)
--- a/homeassistant/auth_providers/homeassistant.py
+++ b/homeassistant/auth_providers/homeassistant.py
@@ -8,10 +8,10 @@ import voluptuous as vol

 from homeassistant import auth, data_entry_flow
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.util import json


-PATH_DATA = '.users.json'
+STORAGE_VERSION = 1
+STORAGE_KEY = 'auth_provider.homeassistant'

 CONFIG_SCHEMA = auth.AUTH_PROVIDER_SCHEMA.extend({
 }, extra=vol.PREVENT_EXTRA)
@@ -31,14 +31,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(),
                'users': []
            }
+
        self._data = data

    @property
@@ -99,14 +107,9 @@ class Data:
        else:
            raise InvalidUser

-    def save(self):
+    async def async_save(self):
        """Save data."""
-        json.save_json(self.path, self._data)
-
-
-def load_data(path):
-    """Load auth data."""
-    return Data(path, json.load_json(path, None))
+        await self._store.async_save(self._data)


@auth.AUTH_PROVIDERS.register('homeassistant')
@@ -121,12 +124,10 @@ class HassAuthProvider(auth.AuthProvider):

    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)
-
-        await self.hass.async_add_job(validate)
+        data = Data(self.hass)
+        await data.async_load()
+        await self.hass.async_add_executor_job(
+            data.validate_login, username, password)

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

-    def _auth_data(self):
-        """Return the auth provider data."""
-        return load_data(self.hass.config.path(PATH_DATA))
-

 class LoginFlow(data_entry_flow.FlowHandler):
    """Handler for the login flow."""
--- a/homeassistant/auth_providers/legacy_api_password.py
+++ b/homeassistant/auth_providers/legacy_api_password.py
@@ -0,0 +1,104 @@
+"""
+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 auth, data_entry_flow
+from homeassistant.core import callback
+
+USER_SCHEMA = vol.Schema({
+    vol.Required('username'): str,
+})
+
+
+CONFIG_SCHEMA = auth.AUTH_PROVIDER_SCHEMA.extend({
+}, extra=vol.PREVENT_EXTRA)
+
+LEGACY_USER = 'homeassistant'
+
+
+class InvalidAuthError(HomeAssistantError):
+    """Raised when submitting invalid authentication."""
+
+
+@auth.AUTH_PROVIDERS.register('legacy_api_password')
+class LegacyApiPasswordAuthProvider(auth.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}
+
+
+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/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
@@ -53,8 +52,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(
@@ -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. "
@@ -197,7 +196,9 @@ 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)
@@ -211,9 +212,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 +308,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
@@ -154,7 +154,6 @@ def async_setup(hass, config):
    return True


-# 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/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"


@@ -1474,9 +1473,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.8']

 _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/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
@@ -6,7 +6,8 @@ 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)
+    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))

@@ -103,6 +107,6 @@ 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:
+        if self._sensor.type in PRESENCE and self._sensor.dark is not None:
            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/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/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,32 @@ 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))
+
+    await hass.components.frontend.async_register_built_in_panel(
+        'calendar', 'calendar', 'hass:calendar')
+
+    await component.async_setup(config)
    return True


@@ -42,7 +52,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 +67,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 +160,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 +185,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
@@ -51,6 +51,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 +68,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 +76,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.

@@ -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/homeassistant/components/camera/netatmo.py
+++ b/homeassistant/components/camera/netatmo.py
@@ -29,13 +29,12 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up access to Netatmo cameras."""
    netatmo = hass.components.netatmo
    home = config.get(CONF_HOME)
    verify_ssl = config.get(CONF_VERIFY_SSL, True)
-    import lnetatmo
+    import pyatmo
    try:
        data = CameraData(netatmo.NETATMO_AUTH, home)
        for camera_name in data.get_camera_names():
@@ -46,7 +45,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                    continue
            add_devices([NetatmoCamera(data, camera_name, home,
                                       camera_type, verify_ssl)])
-    except lnetatmo.NoDevice:
+    except pyatmo.NoDevice:
        return None


--- a/homeassistant/components/camera/proxy.py
+++ b/homeassistant/components/camera/proxy.py
@@ -233,6 +233,7 @@ class ProxyCamera(Camera):
            _LOGGER.debug("Stream closed by frontend.")
            req.close()
            response = None
+            raise

        finally:
            if response is not None:
--- a/homeassistant/components/camera/uvc.py
+++ b/homeassistant/components/camera/uvc.py
@@ -13,6 +13,7 @@ import voluptuous as vol
 from homeassistant.const import CONF_PORT
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 import homeassistant.helpers.config_validation as cv
+from homeassistant.exceptions import PlatformNotReady

 REQUIREMENTS = ['uvcclient==0.10.1']

@@ -41,25 +42,26 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    port = config[CONF_PORT]

    from uvcclient import nvr
-    nvrconn = nvr.UVCRemote(addr, port, key)
    try:
+        # Exceptions may be raised in all method calls to the nvr library.
+        nvrconn = nvr.UVCRemote(addr, port, key)
        cameras = nvrconn.index()
+
+        identifier = 'id' if nvrconn.server_version >= (3, 2, 0) else 'uuid'
+        # Filter out airCam models, which are not supported in the latest
+        # version of UnifiVideo and which are EOL by Ubiquiti
+        cameras = [
+            camera for camera in cameras
+            if 'airCam' not in nvrconn.get_camera(camera[identifier])['model']]
    except nvr.NotAuthorized:
        _LOGGER.error("Authorization failure while connecting to NVR")
        return False
-    except nvr.NvrError:
-        _LOGGER.error("NVR refuses to talk to me")
-        return False
+    except nvr.NvrError as ex:
+        _LOGGER.error("NVR refuses to talk to me: %s", str(ex))
+        raise PlatformNotReady
    except requests.exceptions.ConnectionError as ex:
        _LOGGER.error("Unable to connect to NVR: %s", str(ex))
-        return False
-
-    identifier = 'id' if nvrconn.server_version >= (3, 2, 0) else 'uuid'
-    # Filter out airCam models, which are not supported in the latest
-    # version of UnifiVideo and which are EOL by Ubiquiti
-    cameras = [
-        camera for camera in cameras
-        if 'airCam' not in nvrconn.get_camera(camera[identifier])['model']]
+        raise PlatformNotReady

    add_devices([UnifiVideoCamera(nvrconn,
                                  camera[identifier],
--- a/homeassistant/components/camera/xeoma.py
+++ b/homeassistant/components/camera/xeoma.py
@@ -67,8 +67,6 @@ async def async_setup_platform(hass, config, async_add_devices,
        ]

        for cam in config.get(CONF_CAMERAS, []):
-            # https://github.com/PyCQA/pylint/issues/1830
-            # pylint: disable=stop-iteration-return
            camera = next(
                (dc for dc in discovered_cameras
                 if dc[CONF_IMAGE_NAME] == cam[CONF_IMAGE_NAME]), None)
--- a/homeassistant/components/camera/xiaomi.py
+++ b/homeassistant/components/camera/xiaomi.py
@@ -0,0 +1,164 @@
+"""
+This component provides support for Xiaomi Cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.xiaomi/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
+from homeassistant.components.ffmpeg import DATA_FFMPEG
+from homeassistant.const import (CONF_HOST, CONF_NAME, CONF_PATH,
+                                 CONF_PASSWORD, CONF_PORT, CONF_USERNAME)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+
+DEPENDENCIES = ['ffmpeg']
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_BRAND = 'Xiaomi Home Camera'
+DEFAULT_PATH = '/media/mmcblk0p1/record'
+DEFAULT_PORT = 21
+DEFAULT_USERNAME = 'root'
+
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+CONF_MODEL = 'model'
+
+MODEL_YI = 'yi'
+MODEL_XIAOFANG = 'xiaofang'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_NAME): cv.string,
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_MODEL): vol.Any(MODEL_YI,
+                                      MODEL_XIAOFANG),
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.string,
+    vol.Optional(CONF_PATH, default=DEFAULT_PATH): cv.string,
+    vol.Optional(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string
+})
+
+
+async def async_setup_platform(hass,
+                               config,
+                               async_add_devices,
+                               discovery_info=None):
+    """Set up a Xiaomi Camera."""
+    _LOGGER.debug('Received configuration for model %s', config[CONF_MODEL])
+    async_add_devices([XiaomiCamera(hass, config)])
+
+
+class XiaomiCamera(Camera):
+    """Define an implementation of a Xiaomi Camera."""
+
+    def __init__(self, hass, config):
+        """Initialize."""
+        super().__init__()
+        self._extra_arguments = config.get(CONF_FFMPEG_ARGUMENTS)
+        self._last_image = None
+        self._last_url = None
+        self._manager = hass.data[DATA_FFMPEG]
+        self._name = config[CONF_NAME]
+        self.host = config[CONF_HOST]
+        self._model = config[CONF_MODEL]
+        self.port = config[CONF_PORT]
+        self.path = config[CONF_PATH]
+        self.user = config[CONF_USERNAME]
+        self.passwd = config[CONF_PASSWORD]
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name
+
+    @property
+    def brand(self):
+        """Return the camera brand."""
+        return DEFAULT_BRAND
+
+    @property
+    def model(self):
+        """Return the camera model."""
+        return self._model
+
+    def get_latest_video_url(self):
+        """Retrieve the latest video file from the Xiaomi Camera FTP server."""
+        from ftplib import FTP, error_perm
+
+        ftp = FTP(self.host)
+        try:
+            ftp.login(self.user, self.passwd)
+        except error_perm as exc:
+            _LOGGER.error('Camera login failed: %s', exc)
+            return False
+
+        try:
+            ftp.cwd(self.path)
+        except error_perm as exc:
+            _LOGGER.error('Unable to find path: %s - %s', self.path, exc)
+            return False
+
+        dirs = [d for d in ftp.nlst() if '.' not in d]
+        if not dirs:
+            _LOGGER.warning("There don't appear to be any folders")
+            return False
+
+        first_dir = dirs[-1]
+        try:
+            ftp.cwd(first_dir)
+        except error_perm as exc:
+            _LOGGER.error('Unable to find path: %s - %s', first_dir, exc)
+            return False
+
+        if self._model == MODEL_XIAOFANG:
+            dirs = [d for d in ftp.nlst() if '.' not in d]
+            if not dirs:
+                _LOGGER.warning("There don't appear to be any uploaded videos")
+                return False
+
+            latest_dir = dirs[-1]
+            ftp.cwd(latest_dir)
+
+        videos = [v for v in ftp.nlst() if '.tmp' not in v]
+        if not videos:
+            _LOGGER.info('Video folder "%s" is empty; delaying', latest_dir)
+            return False
+
+        if self._model == MODEL_XIAOFANG:
+            video = videos[-2]
+        else:
+            video = videos[-1]
+
+        return 'ftp://{0}:{1}@{2}:{3}{4}/{5}'.format(
+            self.user, self.passwd, self.host, self.port, ftp.pwd(), video)
+
+    async def async_camera_image(self):
+        """Return a still image response from the camera."""
+        from haffmpeg import ImageFrame, IMAGE_JPEG
+
+        url = await self.hass.async_add_job(self.get_latest_video_url)
+        if url != self._last_url:
+            ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop)
+            self._last_image = await asyncio.shield(ffmpeg.get_image(
+                url, output_format=IMAGE_JPEG,
+                extra_cmd=self._extra_arguments), loop=self.hass.loop)
+            self._last_url = url
+
+        return self._last_image
+
+    async def handle_async_mjpeg_stream(self, request):
+        """Generate an HTTP MJPEG stream from the camera."""
+        from haffmpeg import CameraMjpeg
+
+        stream = CameraMjpeg(self._manager.binary, loop=self.hass.loop)
+        await stream.open_camera(
+            self._last_url, extra_cmd=self._extra_arguments)
+
+        await async_aiohttp_proxy_stream(
+            self.hass, request, stream,
+            'multipart/x-mixed-replace;boundary=ffserver')
+        await stream.close()
--- a/homeassistant/components/camera/yi.py
+++ b/homeassistant/components/camera/yi.py
@@ -11,11 +11,13 @@ import voluptuous as vol

 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 from homeassistant.components.ffmpeg import DATA_FFMPEG
-from homeassistant.const import (CONF_HOST, CONF_NAME, CONF_PATH,
-                                 CONF_PASSWORD, CONF_PORT, CONF_USERNAME)
+from homeassistant.const import (
+    CONF_HOST, CONF_NAME, CONF_PATH, CONF_PASSWORD, CONF_PORT, CONF_USERNAME)
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+from homeassistant.exceptions import PlatformNotReady

+REQUIREMENTS = ['aioftp==0.10.1']
 DEPENDENCIES = ['ffmpeg']
 _LOGGER = logging.getLogger(__name__)

@@ -38,12 +40,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-async 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 a Yi Camera."""
-    _LOGGER.debug('Received configuration: %s', config)
    async_add_devices([YiCamera(hass, config)], True)


@@ -57,68 +56,72 @@ class YiCamera(Camera):
        self._last_image = None
        self._last_url = None
        self._manager = hass.data[DATA_FFMPEG]
-        self._name = config.get(CONF_NAME)
-        self.host = config.get(CONF_HOST)
-        self.port = config.get(CONF_PORT)
-        self.path = config.get(CONF_PATH)
-        self.user = config.get(CONF_USERNAME)
-        self.passwd = config.get(CONF_PASSWORD)
-
-    @property
-    def name(self):
-        """Return the name of this camera."""
-        return self._name
+        self._name = config[CONF_NAME]
+        self.host = config[CONF_HOST]
+        self.port = config[CONF_PORT]
+        self.path = config[CONF_PATH]
+        self.user = config[CONF_USERNAME]
+        self.passwd = config[CONF_PASSWORD]

    @property
    def brand(self):
        """Camera brand."""
        return DEFAULT_BRAND

-    def get_latest_video_url(self):
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name
+
+    async def _get_latest_video_url(self):
        """Retrieve the latest video file from the customized Yi FTP server."""
-        from ftplib import FTP, error_perm
+        from aioftp import Client, StatusCodeError

-        ftp = FTP(self.host)
+        ftp = Client(loop=self.hass.loop)
        try:
-            ftp.login(self.user, self.passwd)
-        except error_perm as exc:
-            _LOGGER.error('There was an error while logging into the camera')
-            _LOGGER.debug(exc)
-            return False
+            await ftp.connect(self.host)
+            await ftp.login(self.user, self.passwd)
+        except StatusCodeError as err:
+            raise PlatformNotReady(err)

        try:
-            ftp.cwd(self.path)
-        except error_perm as exc:
-            _LOGGER.error('Unable to find path: %s', self.path)
-            _LOGGER.debug(exc)
-            return False
+            await ftp.change_directory(self.path)
+            dirs = []
+            for path, attrs in await ftp.list():
+                if attrs['type'] == 'dir' and '.' not in str(path):
+                    dirs.append(path)
+            latest_dir = dirs[-1]
+            await ftp.change_directory(latest_dir)

-        dirs = [d for d in ftp.nlst() if '.' not in d]
-        if not dirs:
-            _LOGGER.warning("There don't appear to be any uploaded videos")
-            return False
+            videos = []
+            for path, _ in await ftp.list():
+                videos.append(path)
+            if not videos:
+                _LOGGER.info('Video folder "%s" empty; delaying', latest_dir)
+                return None

-        latest_dir = dirs[-1]
-        ftp.cwd(latest_dir)
-        videos = ftp.nlst()
-        if not videos:
-            _LOGGER.info('Video folder "%s" is empty; delaying', latest_dir)
-            return False
+            await ftp.quit()

-        return 'ftp://{0}:{1}@{2}:{3}{4}/{5}/{6}'.format(
-            self.user, self.passwd, self.host, self.port, self.path,
-            latest_dir, videos[-1])
+            return 'ftp://{0}:{1}@{2}:{3}{4}/{5}/{6}'.format(
+                self.user, self.passwd, self.host, self.port, self.path,
+                latest_dir, videos[-1])
+        except (ConnectionRefusedError, StatusCodeError) as err:
+            _LOGGER.error('Error while fetching video: %s', err)
+            return None

    async def async_camera_image(self):
        """Return a still image response from the camera."""
        from haffmpeg import ImageFrame, IMAGE_JPEG

-        url = await self.hass.async_add_job(self.get_latest_video_url)
+        url = await self._get_latest_video_url()
        if url != self._last_url:
            ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop)
-            self._last_image = await asyncio.shield(ffmpeg.get_image(
-                url, output_format=IMAGE_JPEG,
-                extra_cmd=self._extra_arguments), loop=self.hass.loop)
+            self._last_image = await asyncio.shield(
+                ffmpeg.get_image(
+                    url,
+                    output_format=IMAGE_JPEG,
+                    extra_cmd=self._extra_arguments),
+                loop=self.hass.loop)
            self._last_url = url

        return self._last_image
--- a/homeassistant/components/camera/zoneminder.py
+++ b/homeassistant/components/camera/zoneminder.py
@@ -49,7 +49,6 @@ def _get_image_url(hass, monitor, mode):


@asyncio.coroutine
-# pylint: disable=unused-argument
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Set up the ZoneMinder cameras."""
    cameras = []
--- a/homeassistant/components/cast/.translations/ca.json
+++ b/homeassistant/components/cast/.translations/ca.json
@@ -0,0 +1,15 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "No s'han trobat dispositius de Google Cast a la xarxa.",
+            "single_instance_allowed": "Nom\u00e9s cal una \u00fanica configuraci\u00f3 de Google Cast."
+        },
+        "step": {
+            "confirm": {
+                "description": "Voleu configurar Google Cast?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/homeassistant/components/cast/.translations/cs.json
+++ b/homeassistant/components/cast/.translations/cs.json
@@ -0,0 +1,15 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "V s\u00edti nebyly nalezena \u017e\u00e1dn\u00e1 za\u0159\u00edzen\u00ed Google Cast.",
+            "single_instance_allowed": "Pouze jedin\u00e1 konfigurace Google Cast je nezbytn\u00e1."
+        },
+        "step": {
+            "confirm": {
+                "description": "Chcete nastavit Google Cast?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/homeassistant/components/cast/.translations/de.json
+++ b/homeassistant/components/cast/.translations/de.json
@@ -0,0 +1,14 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "Keine Google Cast Ger\u00e4te im Netzwerk gefunden."
+        },
+        "step": {
+            "confirm": {
+                "description": "M\u00f6chten Sie Google Cast einrichten?",
+                "title": ""
+            }
+        },
+        "title": ""
+    }
+}
--- a/homeassistant/components/cast/.translations/en.json
+++ b/homeassistant/components/cast/.translations/en.json
@@ -0,0 +1,15 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "No Google Cast devices found on the network.",
+            "single_instance_allowed": "Only a single configuration of Google Cast is necessary."
+        },
+        "step": {
+            "confirm": {
+                "description": "Do you want to setup Google Cast?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/homeassistant/components/cast/.translations/hu.json
+++ b/homeassistant/components/cast/.translations/hu.json
@@ -0,0 +1,14 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "Nem tal\u00e1lhat\u00f3k Google Cast eszk\u00f6z\u00f6k a h\u00e1l\u00f3zaton."
+        },
+        "step": {
+            "confirm": {
+                "description": "Be szeretn\u00e9d \u00e1ll\u00edtani a Google Cast szolg\u00e1ltat\u00e1st?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/homeassistant/components/cast/.translations/it.json
+++ b/homeassistant/components/cast/.translations/it.json
@@ -0,0 +1,15 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "Nessun dispositivo Google Cast trovato in rete.",
+            "single_instance_allowed": "\u00c8 necessaria una sola configurazione di Google Cast."
+        },
+        "step": {
+            "confirm": {
+                "description": "Vuoi configurare Google Cast?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/homeassistant/components/cast/.translations/ko.json
+++ b/homeassistant/components/cast/.translations/ko.json
@@ -0,0 +1,15 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "Googgle Cast \uc7a5\uce58\uac00 \ub124\ud2b8\uc6cc\ud06c\uc5d0\uc11c \ubc1c\uacac\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4.",
+            "single_instance_allowed": "Google Cast\uc758 \ub2e8\uc77c \uad6c\uc131 \ub9cc \ud544\uc694\ud569\ub2c8\ub2e4."
+        },
+        "step": {
+            "confirm": {
+                "description": "Google Cast\ub97c \uc124\uc815 \ud558\uc2dc\uaca0\uc2b5\ub2c8\uae4c?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/homeassistant/components/cast/.translations/lb.json
+++ b/homeassistant/components/cast/.translations/lb.json
@@ -0,0 +1,15 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "Keng Google Cast Apparater am Netzwierk fonnt.",
+            "single_instance_allowed": "N\u00ebmmen eng eenzeg Konfiguratioun vun Google Cast ass n\u00e9ideg."
+        },
+        "step": {
+            "confirm": {
+                "description": "Soll Google Cast konfigur\u00e9iert ginn?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/homeassistant/components/cast/.translations/nl.json
+++ b/homeassistant/components/cast/.translations/nl.json
@@ -0,0 +1,15 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "Geen Google Cast-apparaten gevonden op het netwerk.",
+            "single_instance_allowed": "Er is slechts \u00e9\u00e9n configuratie van Google Cast nodig."
+        },
+        "step": {
+            "confirm": {
+                "description": "Wilt u Google Cast instellen?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/homeassistant/components/cast/.translations/no.json
+++ b/homeassistant/components/cast/.translations/no.json
@@ -0,0 +1,15 @@
+{
+    "config": {
+        "abort": {
+            "no_devices_found": "Ingen Google Cast enheter funnet p\u00e5 nettverket.",
+            "single_instance_allowed": "Kun en enkelt konfigurasjon av Google Cast er n\u00f8dvendig."
+        },
+        "step": {
+            "confirm": {
+                "description": "\u00d8nsker du \u00e5 sette opp Google Cast?",
+                "title": "Google Cast"
+            }
+        },
+        "title": "Google Cast"
+    }
+}
--- a/Show More
+++ b/Show More