Merge pull request #2381 from home-assistant/dev

0.23

.coveragerc

@@ -14,9 +14,15 @@ omit =
     homeassistant/components/bloomsky.py
     homeassistant/components/*/bloomsky.py
 
+    homeassistant/components/dweet.py
+    homeassistant/components/*/dweet.py
+
     homeassistant/components/ecobee.py
     homeassistant/components/*/ecobee.py
 
+    homeassistant/components/envisalink.py
+    homeassistant/components/*/envisalink.py
+
     homeassistant/components/insteon_hub.py
     homeassistant/components/*/insteon_hub.py
 
@@ -32,6 +38,12 @@ omit =
     homeassistant/components/nest.py
     homeassistant/components/*/nest.py
 
+    homeassistant/components/octoprint.py
+    homeassistant/components/*/octoprint.py
+
+    homeassistant/components/qwikswitch.py
+    homeassistant/components/*/qwikswitch.py
+
     homeassistant/components/rpi_gpio.py
     homeassistant/components/*/rpi_gpio.py
 
@@ -66,6 +78,15 @@ omit =
     homeassistant/components/zwave.py
     homeassistant/components/*/zwave.py
 
+    homeassistant/components/enocean.py
+    homeassistant/components/*/enocean.py
+
+    homeassistant/components/netatmo.py
+    homeassistant/components/*/netatmo.py
+
+    homeassistant/components/homematic.py
+    homeassistant/components/*/homematic.py
+
     homeassistant/components/alarm_control_panel/alarmdotcom.py
     homeassistant/components/alarm_control_panel/nx584.py
     homeassistant/components/binary_sensor/arest.py
@@ -80,6 +101,7 @@ omit =
     homeassistant/components/device_tracker/aruba.py
     homeassistant/components/device_tracker/asuswrt.py
     homeassistant/components/device_tracker/bluetooth_tracker.py
+    homeassistant/components/device_tracker/bt_home_hub_5.py
     homeassistant/components/device_tracker/ddwrt.py
     homeassistant/components/device_tracker/fritz.py
     homeassistant/components/device_tracker/icloud.py
@@ -95,6 +117,8 @@ omit =
     homeassistant/components/downloader.py
     homeassistant/components/feedreader.py
     homeassistant/components/garage_door/wink.py
+    homeassistant/components/garage_door/rpi_gpio.py
+    homeassistant/components/hdmi_cec.py
     homeassistant/components/ifttt.py
     homeassistant/components/keyboard.py
     homeassistant/components/light/blinksticklight.py
@@ -102,20 +126,32 @@ omit =
     homeassistant/components/light/hyperion.py
     homeassistant/components/light/lifx.py
     homeassistant/components/light/limitlessled.py
+    homeassistant/components/light/osramlightify.py
+    homeassistant/components/lirc.py
+    homeassistant/components/media_player/braviatv.py
     homeassistant/components/media_player/cast.py
+    homeassistant/components/media_player/cmus.py
     homeassistant/components/media_player/denon.py
     homeassistant/components/media_player/firetv.py
+    homeassistant/components/media_player/gpmdp.py
     homeassistant/components/media_player/itunes.py
     homeassistant/components/media_player/kodi.py
+    homeassistant/components/media_player/lg_netcast.py
     homeassistant/components/media_player/mpd.py
     homeassistant/components/media_player/onkyo.py
     homeassistant/components/media_player/panasonic_viera.py
+    homeassistant/components/media_player/pandora.py
+    homeassistant/components/media_player/pioneer.py
     homeassistant/components/media_player/plex.py
+    homeassistant/components/media_player/roku.py
     homeassistant/components/media_player/samsungtv.py
     homeassistant/components/media_player/snapcast.py
     homeassistant/components/media_player/sonos.py
     homeassistant/components/media_player/squeezebox.py
     homeassistant/components/media_player/yamaha.py
+    homeassistant/components/notify/aws_lambda.py
+    homeassistant/components/notify/aws_sns.py
+    homeassistant/components/notify/aws_sqs.py
     homeassistant/components/notify/free_mobile.py
     homeassistant/components/notify/gntp.py
     homeassistant/components/notify/googlevoice.py
@@ -131,6 +167,7 @@ omit =
     homeassistant/components/notify/smtp.py
     homeassistant/components/notify/syslog.py
     homeassistant/components/notify/telegram.py
+    homeassistant/components/notify/twilio_sms.py
     homeassistant/components/notify/twitter.py
     homeassistant/components/notify/xmpp.py
     homeassistant/components/scene/hunterdouglas_powerview.py
@@ -139,22 +176,30 @@ omit =
     homeassistant/components/sensor/cpuspeed.py
     homeassistant/components/sensor/deutsche_bahn.py
     homeassistant/components/sensor/dht.py
-    homeassistant/components/sensor/dweet.py
+    homeassistant/components/sensor/dte_energy_bridge.py
     homeassistant/components/sensor/efergy.py
     homeassistant/components/sensor/eliqonline.py
+    homeassistant/components/sensor/fitbit.py
+    homeassistant/components/sensor/fixer.py
     homeassistant/components/sensor/forecast.py
     homeassistant/components/sensor/glances.py
+    homeassistant/components/sensor/google_travel_time.py
     homeassistant/components/sensor/gtfs.py
+    homeassistant/components/sensor/lastfm.py
     homeassistant/components/sensor/loopenergy.py
-    homeassistant/components/sensor/netatmo.py
     homeassistant/components/sensor/neurio_energy.py
     homeassistant/components/sensor/nzbget.py
     homeassistant/components/sensor/onewire.py
     homeassistant/components/sensor/openweathermap.py
+    homeassistant/components/sensor/openexchangerates.py
+    homeassistant/components/sensor/plex.py
     homeassistant/components/sensor/rest.py
     homeassistant/components/sensor/sabnzbd.py
+    homeassistant/components/sensor/snmp.py
     homeassistant/components/sensor/speedtest.py
     homeassistant/components/sensor/steam_online.py
+    homeassistant/components/sensor/supervisord.py
+    homeassistant/components/sensor/swiss_hydrological_data.py
     homeassistant/components/sensor/swiss_public_transport.py
     homeassistant/components/sensor/systemmonitor.py
     homeassistant/components/sensor/temper.py
@@ -164,14 +209,17 @@ omit =
     homeassistant/components/sensor/twitch.py
     homeassistant/components/sensor/uber.py
     homeassistant/components/sensor/worldclock.py
+    homeassistant/components/switch/acer_projector.py
     homeassistant/components/switch/arest.py
     homeassistant/components/switch/dlink.py
     homeassistant/components/switch/edimax.py
     homeassistant/components/switch/hikvisioncam.py
     homeassistant/components/switch/mystrom.py
+    homeassistant/components/switch/netio.py
     homeassistant/components/switch/orvibo.py
     homeassistant/components/switch/pulseaudio_loopback.py
     homeassistant/components/switch/rest.py
+    homeassistant/components/switch/rpi_rf.py
     homeassistant/components/switch/transmission.py
     homeassistant/components/switch/wake_on_lan.py
     homeassistant/components/thermostat/eq3btsmart.py

.github/ISSUE_TEMPLATE.md

@@ -1,4 +1,6 @@
-Feature requests should go in the forum: https://community.home-assistant.io/c/feature-requests
+Make sure you are running the latest version of Home Assistant before reporting an issue.
+
+You should only file an issue if you found a bug. Feature and enhancement requests should go in [the Feature Requests section](https://community.home-assistant.io/c/feature-requests) of our community forum:
 
 **Home Assistant release (`hass --version`):**
 

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,7 +1,9 @@
 **Description:**
 
 
-**Related issue (if applicable):** #
+**Related issue (if applicable):** fixes #
+
+**Pull request in [home-assistant.io](https://github.com/home-assistant/home-assistant.io) with documentation (if applicable):** home-assistant/home-assistant.io#
 
 **Example entry for `configuration.yaml` (if applicable):**
 ```yaml
@@ -10,6 +12,9 @@
 
 **Checklist:**
 
+If user exposed functionality or configuration variables are added/changed:
+  - [ ] Documentation added/updated in [home-assistant.io](https://github.com/home-assistant/home-assistant.io)
+
 If code communicates with devices:
   - [ ] Local tests with `tox` run successfully. **Your PR cannot be merged unless tests pass**
   - [ ] New dependencies have been added to the `REQUIREMENTS` variable ([example][ex-requir]).

.gitignore

@@ -78,7 +78,15 @@ nosetests.xml
 pyvenv.cfg
 pip-selfcheck.json
 venv
+.venv
 
 # vimmy stuff
 *.swp
 *.swo
+
+ctags.tmp
+
+# vagrant stuff
+virtualization/vagrant/setup_done
+virtualization/vagrant/.vagrant
+virtualization/vagrant/config

Dockerfile

@@ -19,7 +19,8 @@ RUN script/build_python_openzwave && \
   ln -sf /usr/src/app/build/python-openzwave/openzwave/config /usr/local/share/python-openzwave/config
 
 COPY requirements_all.txt requirements_all.txt
-RUN pip3 install --no-cache-dir -r requirements_all.txt
+# certifi breaks Debian based installs
+RUN pip3 install --no-cache-dir -r requirements_all.txt && pip3 uninstall -y certifi
 
 # Copy source
 COPY . .

README.rst

@@ -1,5 +1,5 @@
-Home Assistant |Build Status| |Coverage Status| |Join the chat at https://gitter.im/home-assistant/home-assistant|
-===========================================================================================================
+Home Assistant |Build Status| |Coverage Status| |Join the chat at https://gitter.im/home-assistant/home-assistant| |Join the dev chat at https://gitter.im/home-assistant/home-assistant/devs|
+==============================================================================================================================================================================================
 
 Home Assistant is a home automation platform running on Python 3. The
 goal of Home Assistant is to be able to track and control all devices at
@@ -80,9 +80,9 @@ Built home automation on top of your devices:
 
 The system is built modular so support for other devices or actions can
 be implemented easily. See also the `section on
-architecture <https://home-assistant.io/developers/architecture.html>`__
+architecture <https://home-assistant.io/developers/architecture/>`__
 and the `section on creating your own
-components <https://home-assistant.io/developers/creating_components.html>`__.
+components <https://home-assistant.io/developers/creating_components/>`__.
 
 If you run into issues while using Home Assistant or during development
 of a component, check the `Home Assistant help
@@ -92,7 +92,9 @@ section <https://home-assistant.io/help/>`__ how to reach us.
    :target: https://travis-ci.org/home-assistant/home-assistant
 .. |Coverage Status| image:: https://img.shields.io/coveralls/home-assistant/home-assistant.svg
    :target: https://coveralls.io/r/home-assistant/home-assistant?branch=master
-.. |Join the chat at https://gitter.im/home-assistant/home-assistant| image:: https://badges.gitter.im/Join%20Chat.svg
+.. |Join the chat at https://gitter.im/home-assistant/home-assistant| image:: https://img.shields.io/badge/gitter-general-blue.svg
    :target: https://gitter.im/home-assistant/home-assistant?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+.. |Join the dev chat at https://gitter.im/home-assistant/home-assistant/devs| image:: https://img.shields.io/badge/gitter-development-yellowgreen.svg
+   :target: https://gitter.im/home-assistant/home-assistant/devs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 .. |screenshot-states| image:: https://raw.github.com/home-assistant/home-assistant/master/docs/screenshots.png
    :target: https://home-assistant.io/demo/

config/configuration.yaml.example

@@ -22,6 +22,9 @@ http:
   # Set to 1 to enable development mode
   # development: 1
 
+frontend:
+# enable the frontend
+
 light:
 #  platform: hue
 

docs/swagger.yaml

@@ -0,0 +1,567 @@
+swagger: '2.0'
+info:
+  title: Home Assistant
+  description: Home Assistant REST API
+  version: "1.0.0"
+# 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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      temperature_unit:
+        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

homeassistant/__main__.py

@@ -3,11 +3,11 @@ from __future__ import print_function
 
 import argparse
 import os
-import signal
+import platform
+import subprocess
 import sys
 import threading
 import time
-from multiprocessing import Process
 
 from homeassistant.const import (
     __version__,
@@ -87,8 +87,7 @@ def get_arguments():
     parser.add_argument(
         '--debug',
         action='store_true',
-        help='Start Home Assistant in debug mode. Runs in single process to '
-        'enable use of interactive debuggers.')
+        help='Start Home Assistant in debug mode')
     parser.add_argument(
         '--open-ui',
         action='store_true',
@@ -123,15 +122,20 @@ def get_arguments():
         '--restart-osx',
         action='store_true',
         help='Restarts on OS X.')
-    if os.name != "nt":
+    parser.add_argument(
+        '--runner',
+        action='store_true',
+        help='On restart exit with code {}'.format(RESTART_EXIT_CODE))
+    if os.name == "posix":
         parser.add_argument(
             '--daemon',
             action='store_true',
             help='Run Home Assistant as daemon')
 
     arguments = parser.parse_args()
-    if os.name == "nt":
+    if os.name != "posix" or arguments.debug or arguments.runner:
         arguments.daemon = False
+
     return arguments
 
 
@@ -144,13 +148,21 @@ def daemonize():
 
     # Decouple fork
     os.setsid()
-    os.umask(0)
 
     # Create second fork
     pid = os.fork()
     if pid > 0:
         sys.exit(0)
 
+    # redirect standard file descriptors to devnull
+    infd = open(os.devnull, 'r')
+    outfd = open(os.devnull, 'a+')
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os.dup2(infd.fileno(), sys.stdin.fileno())
+    os.dup2(outfd.fileno(), sys.stdout.fileno())
+    os.dup2(outfd.fileno(), sys.stderr.fileno())
+
 
 def check_pid(pid_file):
     """Check that HA is not already running."""
@@ -161,6 +173,10 @@ def check_pid(pid_file):
         # PID File does not exist
         return
 
+    # If we just restarted, we just found our own pidfile.
+    if pid == os.getpid():
+        return
+
     try:
         os.kill(pid, 0)
     except OSError:
@@ -220,29 +236,61 @@ def uninstall_osx():
     print("Home Assistant has been uninstalled.")
 
 
-def setup_and_run_hass(config_dir, args, top_process=False):
-    """Setup HASS and run.
+def closefds_osx(min_fd, max_fd):
+    """Make sure file descriptors get closed when we restart.
 
-    Block until stopped. Will assume it is running in a subprocess unless
-    top_process is set to true.
+    We cannot call close on guarded fds, and we cannot easily test which fds
+    are guarded. But we can set the close-on-exec flag on everything we want to
+    get rid of.
     """
+    from fcntl import fcntl, F_GETFD, F_SETFD, FD_CLOEXEC
+
+    for _fd in range(min_fd, max_fd):
+        try:
+            val = fcntl(_fd, F_GETFD)
+            if not val & FD_CLOEXEC:
+                fcntl(_fd, F_SETFD, val | FD_CLOEXEC)
+        except IOError:
+            pass
+
+
+def cmdline():
+    """Collect path and arguments to re-execute the current hass instance."""
+    if sys.argv[0].endswith('/__main__.py'):
+        modulepath = os.path.dirname(sys.argv[0])
+        os.environ['PYTHONPATH'] = os.path.dirname(modulepath)
+    return [sys.executable] + [arg for arg in sys.argv if arg != '--daemon']
+
+
+def setup_and_run_hass(config_dir, args):
+    """Setup HASS and run."""
     from homeassistant import bootstrap
 
+    # Run a simple daemon runner process on Windows to handle restarts
+    if os.name == 'nt' and '--runner' not in sys.argv:
+        args = cmdline() + ['--runner']
+        while True:
+            try:
+                subprocess.check_call(args)
+                sys.exit(0)
+            except subprocess.CalledProcessError as exc:
+                if exc.returncode != RESTART_EXIT_CODE:
+                    sys.exit(exc.returncode)
+
     if args.demo_mode:
         config = {
             'frontend': {},
             'demo': {}
         }
         hass = bootstrap.from_config_dict(
-            config, config_dir=config_dir, daemon=args.daemon,
-            verbose=args.verbose, skip_pip=args.skip_pip,
-            log_rotate_days=args.log_rotate_days)
+            config, config_dir=config_dir, verbose=args.verbose,
+            skip_pip=args.skip_pip, log_rotate_days=args.log_rotate_days)
     else:
         config_file = ensure_config_file(config_dir)
         print('Config directory:', config_dir)
         hass = bootstrap.from_config_file(
-            config_file, daemon=args.daemon, verbose=args.verbose,
-            skip_pip=args.skip_pip, log_rotate_days=args.log_rotate_days)
+            config_file, verbose=args.verbose, skip_pip=args.skip_pip,
+            log_rotate_days=args.log_rotate_days)
 
     if hass is None:
         return
@@ -259,39 +307,49 @@ def setup_and_run_hass(config_dir, args, top_process=False):
     hass.start()
     exit_code = int(hass.block_till_stopped())
 
-    if not top_process:
-        sys.exit(exit_code)
     return exit_code
 
 
-def run_hass_process(hass_proc):
-    """Run a child hass process. Returns True if it should be restarted."""
-    requested_stop = threading.Event()
-    hass_proc.daemon = True
-
-    def request_stop(*args):
-        """Request hass stop, *args is for signal handler callback."""
-        requested_stop.set()
-        hass_proc.terminate()
+def try_to_restart():
+    """Attempt to clean up state and start a new homeassistant instance."""
+    # Things should be mostly shut down already at this point, now just try
+    # to clean up things that may have been left behind.
+    sys.stderr.write('Home Assistant attempting to restart.\n')
 
+    # Count remaining threads, ideally there should only be one non-daemonized
+    # thread left (which is us). Nothing we really do with it, but it might be
+    # useful when debugging shutdown/restart issues.
     try:
-        signal.signal(signal.SIGTERM, request_stop)
+        nthreads = sum(thread.isAlive() and not thread.isDaemon()
+                       for thread in threading.enumerate())
+        if nthreads > 1:
+            sys.stderr.write(
+                "Found {} non-daemonic threads.\n".format(nthreads))
+
+    # Somehow we sometimes seem to trigger an assertion in the python threading
+    # module. It seems we find threads that have no associated OS level thread
+    # which are not marked as stopped at the python level.
+    except AssertionError:
+        sys.stderr.write("Failed to count non-daemonic threads.\n")
+
+    # Try to not leave behind open filedescriptors with the emphasis on try.
+    try:
+        max_fd = os.sysconf("SC_OPEN_MAX")
     except ValueError:
-        print('Could not bind to SIGTERM. Are you running in a thread?')
+        max_fd = 256
 
-    hass_proc.start()
-    try:
-        hass_proc.join()
-    except KeyboardInterrupt:
-        request_stop()
-        try:
-            hass_proc.join()
-        except KeyboardInterrupt:
-            return False
+    if platform.system() == 'Darwin':
+        closefds_osx(3, max_fd)
+    else:
+        os.closerange(3, max_fd)
 
-    return (not requested_stop.isSet() and
-            hass_proc.exitcode == RESTART_EXIT_CODE,
-            hass_proc.exitcode)
+    # Now launch into a new instance of Home-Assistant. If this fails we
+    # fall through and exit with error 100 (RESTART_EXIT_CODE) in which case
+    # systemd will restart us when RestartForceExitStatus=100 is set in the
+    # systemd.service file.
+    sys.stderr.write("Restarting Home-Assistant\n")
+    args = cmdline()
+    os.execv(args[0], args)
 
 
 def main():
@@ -325,21 +383,10 @@ def main():
     if args.pid_file:
         write_pid(args.pid_file)
 
-    # Run hass in debug mode if requested
-    if args.debug:
-        sys.stderr.write('Running in debug mode. '
-                         'Home Assistant will not be able to restart.\n')
-        exit_code = setup_and_run_hass(config_dir, args, top_process=True)
-        if exit_code == RESTART_EXIT_CODE:
-            sys.stderr.write('Home Assistant requested a '
-                             'restart in debug mode.\n')
-        return exit_code
+    exit_code = setup_and_run_hass(config_dir, args)
+    if exit_code == RESTART_EXIT_CODE and not args.runner:
+        try_to_restart()
 
-    # Run hass as child process. Restart if necessary.
-    keep_running = True
-    while keep_running:
-        hass_proc = Process(target=setup_and_run_hass, args=(config_dir, args))
-        keep_running, exit_code = run_hass_process(hass_proc)
     return exit_code
 
 

homeassistant/bootstrap.py

@@ -3,7 +3,6 @@
 import logging
 import logging.handlers
 import os
-import shutil
 import sys
 from collections import defaultdict
 from threading import RLock
@@ -11,21 +10,16 @@ from threading import RLock
 import voluptuous as vol
 
 import homeassistant.components as core_components
-import homeassistant.components.group as group
-import homeassistant.config as config_util
+from homeassistant.components import group, persistent_notification
+import homeassistant.config as conf_util
 import homeassistant.core as core
+import homeassistant.helpers.config_validation as cv
 import homeassistant.loader as loader
-import homeassistant.util.dt as date_util
-import homeassistant.util.location as loc_util
 import homeassistant.util.package as pkg_util
-from homeassistant.const import (
-    CONF_CUSTOMIZE, CONF_LATITUDE, CONF_LONGITUDE, CONF_NAME,
-    CONF_TEMPERATURE_UNIT, CONF_TIME_ZONE, EVENT_COMPONENT_LOADED,
-    TEMP_CELSIUS, TEMP_FAHRENHEIT, PLATFORM_FORMAT, __version__)
+from homeassistant.const import EVENT_COMPONENT_LOADED, PLATFORM_FORMAT
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import (
     event_decorators, service, config_per_platform, extract_domain_configs)
-from homeassistant.helpers.entity import Entity
 
 _LOGGER = logging.getLogger(__name__)
 _SETUP_LOCK = RLock()
@@ -103,7 +97,7 @@ def _setup_component(hass, domain, config):
             try:
                 config = component.CONFIG_SCHEMA(config)
             except vol.MultipleInvalid as ex:
-                _LOGGER.error('Invalid config for [%s]: %s', domain, ex)
+                cv.log_exception(_LOGGER, ex, domain, config)
                 return False
 
         elif hasattr(component, 'PLATFORM_SCHEMA'):
@@ -113,12 +107,11 @@ def _setup_component(hass, domain, config):
                 try:
                     p_validated = component.PLATFORM_SCHEMA(p_config)
                 except vol.MultipleInvalid as ex:
-                    _LOGGER.error('Invalid platform config for [%s]: %s. %s',
-                                  domain, ex, p_config)
+                    cv.log_exception(_LOGGER, ex, domain, p_config)
                     return False
 
                 # Not all platform components follow same pattern for platforms
-                # Sof if p_name is None we are not going to validate platform
+                # So if p_name is None we are not going to validate platform
                 # (the automation component is one of them)
                 if p_name is None:
                     platforms.append(p_validated)
@@ -135,9 +128,8 @@ def _setup_component(hass, domain, config):
                     try:
                         p_validated = platform.PLATFORM_SCHEMA(p_validated)
                     except vol.MultipleInvalid as ex:
-                        _LOGGER.error(
-                            'Invalid platform config for [%s.%s]: %s. %s',
-                            domain, p_name, ex, p_config)
+                        cv.log_exception(_LOGGER, ex, '{}.{}'
+                                         .format(domain, p_name), p_validated)
                         return False
 
                 platforms.append(p_validated)
@@ -209,14 +201,9 @@ def prepare_setup_platform(hass, config, domain, platform_name):
     return platform
 
 
-def mount_local_lib_path(config_dir):
-    """Add local library to Python Path."""
-    sys.path.insert(0, os.path.join(config_dir, 'deps'))
-
-
 # pylint: disable=too-many-branches, too-many-statements, too-many-arguments
 def from_config_dict(config, hass=None, config_dir=None, enable_log=True,
-                     verbose=False, daemon=False, skip_pip=False,
+                     verbose=False, skip_pip=False,
                      log_rotate_days=None):
     """Try to configure Home Assistant from a config dict.
 
@@ -227,19 +214,20 @@ def from_config_dict(config, hass=None, config_dir=None, enable_log=True,
         if config_dir is not None:
             config_dir = os.path.abspath(config_dir)
             hass.config.config_dir = config_dir
-            mount_local_lib_path(config_dir)
+            _mount_local_lib_path(config_dir)
+
+    core_config = config.get(core.DOMAIN, {})
 
     try:
-        process_ha_core_config(hass, config_util.CORE_CONFIG_SCHEMA(
-            config.get(core.DOMAIN, {})))
-    except vol.MultipleInvalid as ex:
-        _LOGGER.error('Invalid config for [homeassistant]: %s', ex)
+        conf_util.process_ha_core_config(hass, core_config)
+    except vol.Invalid as ex:
+        cv.log_exception(_LOGGER, ex, 'homeassistant', core_config)
         return None
 
-    process_ha_config_upgrade(hass)
+    conf_util.process_ha_config_upgrade(hass)
 
     if enable_log:
-        enable_logging(hass, verbose, daemon, log_rotate_days)
+        enable_logging(hass, verbose, log_rotate_days)
 
     hass.config.skip_pip = skip_pip
     if skip_pip:
@@ -261,9 +249,10 @@ def from_config_dict(config, hass=None, config_dir=None, enable_log=True,
     if not core_components.setup(hass, config):
         _LOGGER.error('Home Assistant core failed to initialize. '
                       'Further initialization aborted.')
-
         return hass
 
+    persistent_notification.setup(hass, config)
+
     _LOGGER.info('Home Assistant core initialized')
 
     # Give event decorators access to HASS
@@ -277,8 +266,8 @@ def from_config_dict(config, hass=None, config_dir=None, enable_log=True,
     return hass
 
 
-def from_config_file(config_path, hass=None, verbose=False, daemon=False,
-                     skip_pip=True, log_rotate_days=None):
+def from_config_file(config_path, hass=None, verbose=False, skip_pip=True,
+                     log_rotate_days=None):
     """Read the configuration file and try to start all the functionality.
 
     Will add functionality to 'hass' parameter if given,
@@ -290,12 +279,12 @@ def from_config_file(config_path, hass=None, verbose=False, daemon=False,
     # Set config dir to directory holding config file
     config_dir = os.path.abspath(os.path.dirname(config_path))
     hass.config.config_dir = config_dir
-    mount_local_lib_path(config_dir)
+    _mount_local_lib_path(config_dir)
 
-    enable_logging(hass, verbose, daemon, log_rotate_days)
+    enable_logging(hass, verbose, log_rotate_days)
 
     try:
-        config_dict = config_util.load_yaml_config_file(config_path)
+        config_dict = conf_util.load_yaml_config_file(config_path)
     except HomeAssistantError:
         return None
 
@@ -303,28 +292,27 @@ def from_config_file(config_path, hass=None, verbose=False, daemon=False,
                             skip_pip=skip_pip)
 
 
-def enable_logging(hass, verbose=False, daemon=False, log_rotate_days=None):
+def enable_logging(hass, verbose=False, log_rotate_days=None):
     """Setup the logging."""
-    if not daemon:
-        logging.basicConfig(level=logging.INFO)
-        fmt = ("%(log_color)s%(asctime)s %(levelname)s (%(threadName)s) "
-               "[%(name)s] %(message)s%(reset)s")
-        try:
-            from colorlog import ColoredFormatter
-            logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
-                fmt,
-                datefmt='%y-%m-%d %H:%M:%S',
-                reset=True,
-                log_colors={
-                    'DEBUG': 'cyan',
-                    'INFO': 'green',
-                    'WARNING': 'yellow',
-                    'ERROR': 'red',
-                    'CRITICAL': 'red',
-                }
-            ))
-        except ImportError:
-            pass
+    logging.basicConfig(level=logging.INFO)
+    fmt = ("%(log_color)s%(asctime)s %(levelname)s (%(threadName)s) "
+           "[%(name)s] %(message)s%(reset)s")
+    try:
+        from colorlog import ColoredFormatter
+        logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
+            fmt,
+            datefmt='%y-%m-%d %H:%M:%S',
+            reset=True,
+            log_colors={
+                'DEBUG': 'cyan',
+                'INFO': 'green',
+                'WARNING': 'yellow',
+                'ERROR': 'red',
+                'CRITICAL': 'red',
+            }
+        ))
+    except ImportError:
+        pass
 
     # Log errors to a file if we have write access to file or config dir
     err_log_path = hass.config.path(ERROR_LOG_FILENAME)
@@ -355,101 +343,12 @@ def enable_logging(hass, verbose=False, daemon=False, log_rotate_days=None):
             'Unable to setup error log %s (access denied)', err_log_path)
 
 
-def process_ha_config_upgrade(hass):
-    """Upgrade config if necessary."""
-    version_path = hass.config.path('.HA_VERSION')
-
-    try:
-        with open(version_path, 'rt') as inp:
-            conf_version = inp.readline().strip()
-    except FileNotFoundError:
-        # Last version to not have this file
-        conf_version = '0.7.7'
-
-    if conf_version == __version__:
-        return
-
-    _LOGGER.info('Upgrading config directory from %s to %s', conf_version,
-                 __version__)
-
-    # This was where dependencies were installed before v0.18
-    # Probably should keep this around until ~v0.20.
-    lib_path = hass.config.path('lib')
-    if os.path.isdir(lib_path):
-        shutil.rmtree(lib_path)
-
-    lib_path = hass.config.path('deps')
-    if os.path.isdir(lib_path):
-        shutil.rmtree(lib_path)
-
-    with open(version_path, 'wt') as outp:
-        outp.write(__version__)
-
-
-def process_ha_core_config(hass, config):
-    """Process the [homeassistant] section from the config."""
-    hac = hass.config
-
-    def set_time_zone(time_zone_str):
-        """Helper method to set time zone."""
-        if time_zone_str is None:
-            return
-
-        time_zone = date_util.get_time_zone(time_zone_str)
-
-        if time_zone:
-            hac.time_zone = time_zone
-            date_util.set_default_time_zone(time_zone)
-        else:
-            _LOGGER.error('Received invalid time zone %s', time_zone_str)
-
-    for key, attr in ((CONF_LATITUDE, 'latitude'),
-                      (CONF_LONGITUDE, 'longitude'),
-                      (CONF_NAME, 'location_name')):
-        if key in config:
-            setattr(hac, attr, config[key])
-
-    if CONF_TIME_ZONE in config:
-        set_time_zone(config.get(CONF_TIME_ZONE))
-
-    for entity_id, attrs in config.get(CONF_CUSTOMIZE).items():
-        Entity.overwrite_attribute(entity_id, attrs.keys(), attrs.values())
-
-    if CONF_TEMPERATURE_UNIT in config:
-        hac.temperature_unit = config[CONF_TEMPERATURE_UNIT]
-
-    # If we miss some of the needed values, auto detect them
-    if None not in (
-            hac.latitude, hac.longitude, hac.temperature_unit, hac.time_zone):
-        return
-
-    _LOGGER.warning('Incomplete core config. Auto detecting location and '
-                    'temperature unit')
-
-    info = loc_util.detect_location_info()
-
-    if info is None:
-        _LOGGER.error('Could not detect location information')
-        return
-
-    if hac.latitude is None and hac.longitude is None:
-        hac.latitude = info.latitude
-        hac.longitude = info.longitude
-
-    if hac.temperature_unit is None:
-        if info.use_fahrenheit:
-            hac.temperature_unit = TEMP_FAHRENHEIT
-        else:
-            hac.temperature_unit = TEMP_CELSIUS
-
-    if hac.location_name is None:
-        hac.location_name = info.city
-
-    if hac.time_zone is None:
-        set_time_zone(info.time_zone)
-
-
 def _ensure_loader_prepared(hass):
     """Ensure Home Assistant loader is prepared."""
     if not loader.PREPARED:
         loader.prepare(hass)
+
+
+def _mount_local_lib_path(config_dir):
+    """Add local library to Python Path."""
+    sys.path.insert(0, os.path.join(config_dir, 'deps'))

homeassistant/components/__init__.py

@@ -19,6 +19,8 @@ from homeassistant.const import (
 
 _LOGGER = logging.getLogger(__name__)
 
+SERVICE_RELOAD_CORE_CONFIG = 'reload_core_config'
+
 
 def is_on(hass, entity_id=None):
     """Load up the module to call the is_on method.
@@ -73,6 +75,11 @@ def toggle(hass, entity_id=None, **service_data):
     hass.services.call(ha.DOMAIN, SERVICE_TOGGLE, service_data)
 
 
+def reload_core_config(hass):
+    """Reload the core config."""
+    hass.services.call(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG)
+
+
 def setup(hass, config):
     """Setup general services related to Home Assistant."""
     def handle_turn_service(service):
@@ -111,4 +118,21 @@ def setup(hass, config):
     hass.services.register(ha.DOMAIN, SERVICE_TURN_ON, handle_turn_service)
     hass.services.register(ha.DOMAIN, SERVICE_TOGGLE, handle_turn_service)
 
+    def handle_reload_config(call):
+        """Service handler for reloading core config."""
+        from homeassistant.exceptions import HomeAssistantError
+        from homeassistant import config as conf_util
+
+        try:
+            path = conf_util.find_config_file(hass.config.config_dir)
+            conf = conf_util.load_yaml_config_file(path)
+        except HomeAssistantError as err:
+            _LOGGER.error(err)
+            return
+
+        conf_util.process_ha_core_config(hass, conf.get(ha.DOMAIN) or {})
+
+    hass.services.register(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG,
+                           handle_reload_config)
+
     return True

homeassistant/components/alarm_control_panel/__init__.py

@@ -9,7 +9,6 @@ import os
 
 import voluptuous as vol
 
-from homeassistant.components import verisure
 from homeassistant.const import (
     ATTR_CODE, ATTR_CODE_FORMAT, ATTR_ENTITY_ID, SERVICE_ALARM_TRIGGER,
     SERVICE_ALARM_DISARM, SERVICE_ALARM_ARM_HOME, SERVICE_ALARM_ARM_AWAY)
@@ -24,11 +23,6 @@ SCAN_INTERVAL = 30
 
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 
-# Maps discovered services to their platforms
-DISCOVERY_PLATFORMS = {
-    verisure.DISCOVER_ALARMS: 'verisure'
-}
-
 SERVICE_TO_METHOD = {
     SERVICE_ALARM_DISARM: 'alarm_disarm',
     SERVICE_ALARM_ARM_HOME: 'alarm_arm_home',
@@ -50,8 +44,7 @@ ALARM_SERVICE_SCHEMA = vol.Schema({
 def setup(hass, config):
     """Track states and offer events for sensors."""
     component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL,
-        DISCOVERY_PLATFORMS)
+        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
 
     component.setup(config)
 

homeassistant/components/alarm_control_panel/envisalink.py

@@ -0,0 +1,105 @@
+"""
+Support for Envisalink-based alarm control panels (Honeywell/DSC).
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.envisalink/
+"""
+import logging
+import homeassistant.components.alarm_control_panel as alarm
+from homeassistant.components.envisalink import (EVL_CONTROLLER,
+                                                 EnvisalinkDevice,
+                                                 PARTITION_SCHEMA,
+                                                 CONF_CODE,
+                                                 CONF_PARTITIONNAME,
+                                                 SIGNAL_PARTITION_UPDATE,
+                                                 SIGNAL_KEYPAD_UPDATE)
+from homeassistant.const import (
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED,
+    STATE_UNKNOWN, STATE_ALARM_TRIGGERED)
+
+DEPENDENCIES = ['envisalink']
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """Perform the setup for Envisalink alarm panels."""
+    _configured_partitions = discovery_info['partitions']
+    _code = discovery_info[CONF_CODE]
+    for part_num in _configured_partitions:
+        _device_config_data = PARTITION_SCHEMA(
+            _configured_partitions[part_num])
+        _device = EnvisalinkAlarm(
+            part_num,
+            _device_config_data[CONF_PARTITIONNAME],
+            _code,
+            EVL_CONTROLLER.alarm_state['partition'][part_num],
+            EVL_CONTROLLER)
+        add_devices_callback([_device])
+
+    return True
+
+
+class EnvisalinkAlarm(EnvisalinkDevice, alarm.AlarmControlPanel):
+    """Represents the Envisalink-based alarm panel."""
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, partition_number, alarm_name, code, info, controller):
+        """Initialize the alarm panel."""
+        from pydispatch import dispatcher
+        self._partition_number = partition_number
+        self._code = code
+        _LOGGER.debug('Setting up alarm: ' + alarm_name)
+        EnvisalinkDevice.__init__(self, alarm_name, info, controller)
+        dispatcher.connect(self._update_callback,
+                           signal=SIGNAL_PARTITION_UPDATE,
+                           sender=dispatcher.Any)
+        dispatcher.connect(self._update_callback,
+                           signal=SIGNAL_KEYPAD_UPDATE,
+                           sender=dispatcher.Any)
+
+    def _update_callback(self, partition):
+        """Update HA state, if needed."""
+        if partition is None or int(partition) == self._partition_number:
+            self.update_ha_state()
+
+    @property
+    def code_format(self):
+        """The characters if code is defined."""
+        return self._code
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        if self._info['status']['alarm']:
+            return STATE_ALARM_TRIGGERED
+        elif self._info['status']['armed_away']:
+            return STATE_ALARM_ARMED_AWAY
+        elif self._info['status']['armed_stay']:
+            return STATE_ALARM_ARMED_HOME
+        elif self._info['status']['alpha']:
+            return STATE_ALARM_DISARMED
+        else:
+            return STATE_UNKNOWN
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        if self._code:
+            EVL_CONTROLLER.disarm_partition(str(code),
+                                            self._partition_number)
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        if self._code:
+            EVL_CONTROLLER.arm_stay_partition(str(code),
+                                              self._partition_number)
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        if self._code:
+            EVL_CONTROLLER.arm_away_partition(str(code),
+                                              self._partition_number)
+
+    def alarm_trigger(self, code=None):
+        """Alarm trigger command. Not possible for us."""
+        raise NotImplementedError()

homeassistant/components/alarm_control_panel/verisure.py

@@ -48,6 +48,11 @@ class VerisureAlarm(alarm.AlarmControlPanel):
         """Return the state of the device."""
         return self._state
 
+    @property
+    def available(self):
+        """Return True if entity is available."""
+        return hub.available
+
     @property
     def code_format(self):
         """The code format as regex."""

homeassistant/components/alexa.py

@@ -7,15 +7,14 @@ https://home-assistant.io/components/alexa/
 import enum
 import logging
 
-from homeassistant.const import HTTP_OK, HTTP_UNPROCESSABLE_ENTITY
-from homeassistant.helpers.service import call_from_config
-from homeassistant.helpers import template
+from homeassistant.const import HTTP_BAD_REQUEST
+from homeassistant.helpers import template, script
+from homeassistant.components.http import HomeAssistantView
 
 DOMAIN = 'alexa'
 DEPENDENCIES = ['http']
 
 _LOGGER = logging.getLogger(__name__)
-_CONFIG = {}
 
 API_ENDPOINT = '/api/alexa'
 
@@ -27,73 +26,88 @@ CONF_ACTION = 'action'
 
 def setup(hass, config):
     """Activate Alexa component."""
-    _CONFIG.update(config[DOMAIN].get(CONF_INTENTS, {}))
-
-    hass.http.register_path('POST', API_ENDPOINT, _handle_alexa, True)
+    hass.wsgi.register_view(AlexaView(hass,
+                                      config[DOMAIN].get(CONF_INTENTS, {})))
 
     return True
 
 
-def _handle_alexa(handler, path_match, data):
-    """Handle Alexa."""
-    _LOGGER.debug('Received Alexa request: %s', data)
+class AlexaView(HomeAssistantView):
+    """Handle Alexa requests."""
 
-    req = data.get('request')
+    url = API_ENDPOINT
+    name = 'api:alexa'
 
-    if req is None:
-        _LOGGER.error('Received invalid data from Alexa: %s', data)
-        handler.write_json_message(
-            "Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY)
-        return
+    def __init__(self, hass, intents):
+        """Initialize Alexa view."""
+        super().__init__(hass)
 
-    req_type = req['type']
+        for name, intent in intents.items():
+            if CONF_ACTION in intent:
+                intent[CONF_ACTION] = script.Script(
+                    hass, intent[CONF_ACTION], "Alexa intent {}".format(name))
 
-    if req_type == 'SessionEndedRequest':
-        handler.send_response(HTTP_OK)
-        handler.end_headers()
-        return
+        self.intents = intents
 
-    intent = req.get('intent')
-    response = AlexaResponse(handler.server.hass, intent)
+    def post(self, request):
+        """Handle Alexa."""
+        data = request.json
 
-    if req_type == 'LaunchRequest':
-        response.add_speech(
-            SpeechType.plaintext,
-            "Hello, and welcome to the future. How may I help?")
-        handler.write_json(response.as_dict())
-        return
+        _LOGGER.debug('Received Alexa request: %s', data)
 
-    if req_type != 'IntentRequest':
-        _LOGGER.warning('Received unsupported request: %s', req_type)
-        return
+        req = data.get('request')
 
-    intent_name = intent['name']
-    config = _CONFIG.get(intent_name)
+        if req is None:
+            _LOGGER.error('Received invalid data from Alexa: %s', data)
+            return self.json_message('Expected request value not received',
+                                     HTTP_BAD_REQUEST)
 
-    if config is None:
-        _LOGGER.warning('Received unknown intent %s', intent_name)
-        response.add_speech(
-            SpeechType.plaintext,
-            "This intent is not yet configured within Home Assistant.")
-        handler.write_json(response.as_dict())
-        return
+        req_type = req['type']
 
-    speech = config.get(CONF_SPEECH)
-    card = config.get(CONF_CARD)
-    action = config.get(CONF_ACTION)
+        if req_type == 'SessionEndedRequest':
+            return None
 
-    # pylint: disable=unsubscriptable-object
-    if speech is not None:
-        response.add_speech(SpeechType[speech['type']], speech['text'])
+        intent = req.get('intent')
+        response = AlexaResponse(self.hass, intent)
 
-    if card is not None:
-        response.add_card(CardType[card['type']], card['title'],
-                          card['content'])
+        if req_type == 'LaunchRequest':
+            response.add_speech(
+                SpeechType.plaintext,
+                "Hello, and welcome to the future. How may I help?")
+            return self.json(response)
 
-    if action is not None:
-        call_from_config(handler.server.hass, action, True)
+        if req_type != 'IntentRequest':
+            _LOGGER.warning('Received unsupported request: %s', req_type)
+            return self.json_message(
+                'Received unsupported request: {}'.format(req_type),
+                HTTP_BAD_REQUEST)
 
-    handler.write_json(response.as_dict())
+        intent_name = intent['name']
+        config = self.intents.get(intent_name)
+
+        if config is None:
+            _LOGGER.warning('Received unknown intent %s', intent_name)
+            response.add_speech(
+                SpeechType.plaintext,
+                "This intent is not yet configured within Home Assistant.")
+            return self.json(response)
+
+        speech = config.get(CONF_SPEECH)
+        card = config.get(CONF_CARD)
+        action = config.get(CONF_ACTION)
+
+        if action is not None:
+            action.run(response.variables)
+
+        # pylint: disable=unsubscriptable-object
+        if speech is not None:
+            response.add_speech(SpeechType[speech['type']], speech['text'])
+
+        if card is not None:
+            response.add_card(CardType[card['type']], card['title'],
+                              card['content'])
+
+        return self.json(response)
 
 
 class SpeechType(enum.Enum):

homeassistant/components/api.py

@@ -6,22 +6,23 @@ https://home-assistant.io/developers/api/
 """
 import json
 import logging
-import re
-import threading
+import queue
 
 import homeassistant.core as ha
 import homeassistant.remote as rem
 from homeassistant.bootstrap import ERROR_LOG_FILENAME
 from homeassistant.const import (
-    CONTENT_TYPE_TEXT_PLAIN, EVENT_HOMEASSISTANT_STOP, EVENT_TIME_CHANGED,
-    HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_HEADER_CONTENT_TYPE, HTTP_NOT_FOUND,
-    HTTP_OK, HTTP_UNPROCESSABLE_ENTITY, MATCH_ALL, URL_API, URL_API_COMPONENTS,
-    URL_API_CONFIG, URL_API_ERROR_LOG, URL_API_EVENT_FORWARD, URL_API_EVENTS,
-    URL_API_LOG_OUT, URL_API_SERVICES, URL_API_STATES, URL_API_STATES_ENTITY,
-    URL_API_STREAM, URL_API_TEMPLATE)
+    EVENT_HOMEASSISTANT_STOP, EVENT_TIME_CHANGED,
+    HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND,
+    HTTP_UNPROCESSABLE_ENTITY, MATCH_ALL, URL_API, URL_API_COMPONENTS,
+    URL_API_CONFIG, URL_API_DISCOVERY_INFO, URL_API_ERROR_LOG,
+    URL_API_EVENT_FORWARD, 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 TrackStates
 from homeassistant.helpers import template
+from homeassistant.components.http import HomeAssistantView
 
 DOMAIN = 'api'
 DEPENDENCIES = ['http']
@@ -34,356 +35,351 @@ _LOGGER = logging.getLogger(__name__)
 
 def setup(hass, config):
     """Register the API with the HTTP interface."""
-    # /api - for validation purposes
-    hass.http.register_path('GET', URL_API, _handle_get_api)
-
-    # /api/stream
-    hass.http.register_path('GET', URL_API_STREAM, _handle_get_api_stream)
-
-    # /api/config
-    hass.http.register_path('GET', URL_API_CONFIG, _handle_get_api_config)
-
-    # /states
-    hass.http.register_path('GET', URL_API_STATES, _handle_get_api_states)
-    hass.http.register_path(
-        'GET', re.compile(r'/api/states/(?P<entity_id>[a-zA-Z\._0-9]+)'),
-        _handle_get_api_states_entity)
-    hass.http.register_path(
-        'POST', re.compile(r'/api/states/(?P<entity_id>[a-zA-Z\._0-9]+)'),
-        _handle_post_state_entity)
-    hass.http.register_path(
-        'PUT', re.compile(r'/api/states/(?P<entity_id>[a-zA-Z\._0-9]+)'),
-        _handle_post_state_entity)
-    hass.http.register_path(
-        'DELETE', re.compile(r'/api/states/(?P<entity_id>[a-zA-Z\._0-9]+)'),
-        _handle_delete_state_entity)
-
-    # /events
-    hass.http.register_path('GET', URL_API_EVENTS, _handle_get_api_events)
-    hass.http.register_path(
-        'POST', re.compile(r'/api/events/(?P<event_type>[a-zA-Z\._0-9]+)'),
-        _handle_api_post_events_event)
-
-    # /services
-    hass.http.register_path('GET', URL_API_SERVICES, _handle_get_api_services)
-    hass.http.register_path(
-        'POST',
-        re.compile((r'/api/services/'
-                    r'(?P<domain>[a-zA-Z\._0-9]+)/'
-                    r'(?P<service>[a-zA-Z\._0-9]+)')),
-        _handle_post_api_services_domain_service)
-
-    # /event_forwarding
-    hass.http.register_path(
-        'POST', URL_API_EVENT_FORWARD, _handle_post_api_event_forward)
-    hass.http.register_path(
-        'DELETE', URL_API_EVENT_FORWARD, _handle_delete_api_event_forward)
-
-    # /components
-    hass.http.register_path(
-        'GET', URL_API_COMPONENTS, _handle_get_api_components)
-
-    # /error_log
-    hass.http.register_path('GET', URL_API_ERROR_LOG,
-                            _handle_get_api_error_log)
-
-    hass.http.register_path('POST', URL_API_LOG_OUT, _handle_post_api_log_out)
-
-    # /template
-    hass.http.register_path('POST', URL_API_TEMPLATE,
-                            _handle_post_api_template)
+    hass.wsgi.register_view(APIStatusView)
+    hass.wsgi.register_view(APIEventStream)
+    hass.wsgi.register_view(APIConfigView)
+    hass.wsgi.register_view(APIDiscoveryView)
+    hass.wsgi.register_view(APIStatesView)
+    hass.wsgi.register_view(APIEntityStateView)
+    hass.wsgi.register_view(APIEventListenersView)
+    hass.wsgi.register_view(APIEventView)
+    hass.wsgi.register_view(APIServicesView)
+    hass.wsgi.register_view(APIDomainServicesView)
+    hass.wsgi.register_view(APIEventForwardingView)
+    hass.wsgi.register_view(APIComponentsView)
+    hass.wsgi.register_view(APIErrorLogView)
+    hass.wsgi.register_view(APITemplateView)
 
     return True
 
 
-def _handle_get_api(handler, path_match, data):
-    """Render the debug interface."""
-    handler.write_json_message("API running.")
+class APIStatusView(HomeAssistantView):
+    """View to handle Status requests."""
 
+    url = URL_API
+    name = "api:status"
 
-def _handle_get_api_stream(handler, path_match, data):
-    """Provide a streaming interface for the event bus."""
-    gracefully_closed = False
-    hass = handler.server.hass
-    wfile = handler.wfile
-    write_lock = threading.Lock()
-    block = threading.Event()
-    session_id = None
+    def get(self, request):
+        """Retrieve if API is running."""
+        return self.json_message('API running.')
 
-    restrict = data.get('restrict')
-    if restrict:
-        restrict = restrict.split(',')
 
-    def write_message(payload):
-        """Write a message to the output."""
-        with write_lock:
-            msg = "data: {}\n\n".format(payload)
+class APIEventStream(HomeAssistantView):
+    """View to handle EventStream requests."""
 
-            try:
-                wfile.write(msg.encode("UTF-8"))
-                wfile.flush()
-            except (IOError, ValueError):
-                # IOError: socket errors
-                # ValueError: raised when 'I/O operation on closed file'
-                block.set()
+    url = URL_API_STREAM
+    name = "api:stream"
 
-    def forward_events(event):
-        """Forward events to the open request."""
-        nonlocal gracefully_closed
+    def get(self, request):
+        """Provide a streaming interface for the event bus."""
+        stop_obj = object()
+        to_write = queue.Queue()
 
-        if block.is_set() or event.event_type == EVENT_TIME_CHANGED:
-            return
-        elif event.event_type == EVENT_HOMEASSISTANT_STOP:
-            gracefully_closed = True
-            block.set()
-            return
+        restrict = request.args.get('restrict')
+        if restrict:
+            restrict = restrict.split(',') + [EVENT_HOMEASSISTANT_STOP]
 
-        handler.server.sessions.extend_validation(session_id)
-        write_message(json.dumps(event, cls=rem.JSONEncoder))
+        def forward_events(event):
+            """Forward events to the open request."""
+            if event.event_type == EVENT_TIME_CHANGED:
+                return
 
-    handler.send_response(HTTP_OK)
-    handler.send_header('Content-type', 'text/event-stream')
-    session_id = handler.set_session_cookie_header()
-    handler.end_headers()
+            if restrict and event.event_type not in restrict:
+                return
 
-    if restrict:
-        for event in restrict:
-            hass.bus.listen(event, forward_events)
-    else:
-        hass.bus.listen(MATCH_ALL, forward_events)
+            _LOGGER.debug('STREAM %s FORWARDING %s', id(stop_obj), event)
 
-    while True:
-        write_message(STREAM_PING_PAYLOAD)
+            if event.event_type == EVENT_HOMEASSISTANT_STOP:
+                data = stop_obj
+            else:
+                data = json.dumps(event, cls=rem.JSONEncoder)
 
-        block.wait(STREAM_PING_INTERVAL)
+            to_write.put(data)
 
-        if block.is_set():
-            break
+        def stream():
+            """Stream events to response."""
+            self.hass.bus.listen(MATCH_ALL, forward_events)
 
-    if not gracefully_closed:
-        _LOGGER.info("Found broken event stream to %s, cleaning up",
-                     handler.client_address[0])
+            _LOGGER.debug('STREAM %s ATTACHED', id(stop_obj))
 
-    if restrict:
-        for event in restrict:
-            hass.bus.remove_listener(event, forward_events)
-    else:
-        hass.bus.remove_listener(MATCH_ALL, forward_events)
+            # Fire off one message right away to have browsers fire open event
+            to_write.put(STREAM_PING_PAYLOAD)
 
+            while True:
+                try:
+                    payload = to_write.get(timeout=STREAM_PING_INTERVAL)
 
-def _handle_get_api_config(handler, path_match, data):
-    """Return the Home Assistant configuration."""
-    handler.write_json(handler.server.hass.config.as_dict())
+                    if payload is stop_obj:
+                        break
 
+                    msg = "data: {}\n\n".format(payload)
+                    _LOGGER.debug('STREAM %s WRITING %s', id(stop_obj),
+                                  msg.strip())
+                    yield msg.encode("UTF-8")
+                except queue.Empty:
+                    to_write.put(STREAM_PING_PAYLOAD)
+                except GeneratorExit:
+                    break
 
-def _handle_get_api_states(handler, path_match, data):
-    """Return a dict containing all entity ids and their state."""
-    handler.write_json(handler.server.hass.states.all())
+            _LOGGER.debug('STREAM %s RESPONSE CLOSED', id(stop_obj))
+            self.hass.bus.remove_listener(MATCH_ALL, forward_events)
 
+        return self.Response(stream(), mimetype='text/event-stream')
 
-def _handle_get_api_states_entity(handler, path_match, data):
-    """Return the state of a specific entity."""
-    entity_id = path_match.group('entity_id')
 
-    state = handler.server.hass.states.get(entity_id)
+class APIConfigView(HomeAssistantView):
+    """View to handle Config requests."""
 
-    if state:
-        handler.write_json(state)
-    else:
-        handler.write_json_message("State does not exist.", HTTP_NOT_FOUND)
+    url = URL_API_CONFIG
+    name = "api:config"
 
+    def get(self, request):
+        """Get current configuration."""
+        return self.json(self.hass.config.as_dict())
 
-def _handle_post_state_entity(handler, path_match, data):
-    """Handle updating the state of an entity.
 
-    This handles the following paths:
-    /api/states/<entity_id>
-    """
-    entity_id = path_match.group('entity_id')
+class APIDiscoveryView(HomeAssistantView):
+    """View to provide discovery info."""
 
-    try:
-        new_state = data['state']
-    except KeyError:
-        handler.write_json_message("state not specified", HTTP_BAD_REQUEST)
-        return
+    requires_auth = False
+    url = URL_API_DISCOVERY_INFO
+    name = "api:discovery"
 
-    attributes = data['attributes'] if 'attributes' in data else None
+    def get(self, request):
+        """Get discovery info."""
+        needs_auth = self.hass.config.api.api_password is not None
+        return self.json({
+            'base_url': self.hass.config.api.base_url,
+            'location_name': self.hass.config.location_name,
+            'requires_api_password': needs_auth,
+            'version': __version__
+        })
 
-    is_new_state = handler.server.hass.states.get(entity_id) is None
 
-    # Write state
-    handler.server.hass.states.set(entity_id, new_state, attributes)
+class APIStatesView(HomeAssistantView):
+    """View to handle States requests."""
 
-    state = handler.server.hass.states.get(entity_id)
+    url = URL_API_STATES
+    name = "api:states"
 
-    status_code = HTTP_CREATED if is_new_state else HTTP_OK
+    def get(self, request):
+        """Get current states."""
+        return self.json(self.hass.states.all())
 
-    handler.write_json(
-        state.as_dict(),
-        status_code=status_code,
-        location=URL_API_STATES_ENTITY.format(entity_id))
 
+class APIEntityStateView(HomeAssistantView):
+    """View to handle EntityState requests."""
 
-def _handle_delete_state_entity(handler, path_match, data):
-    """Handle request to delete an entity from state machine.
+    url = "/api/states/<entity(exist=False):entity_id>"
+    name = "api:entity-state"
 
-    This handles the following paths:
-    /api/states/<entity_id>
-    """
-    entity_id = path_match.group('entity_id')
+    def get(self, request, entity_id):
+        """Retrieve state of entity."""
+        state = self.hass.states.get(entity_id)
+        if state:
+            return self.json(state)
+        else:
+            return self.json_message('Entity not found', HTTP_NOT_FOUND)
 
-    if handler.server.hass.states.remove(entity_id):
-        handler.write_json_message(
-            "Entity not found", HTTP_NOT_FOUND)
-    else:
-        handler.write_json_message(
-            "Entity removed", HTTP_OK)
+    def post(self, request, entity_id):
+        """Update state of entity."""
+        try:
+            new_state = request.json['state']
+        except KeyError:
+            return self.json_message('No state specified', HTTP_BAD_REQUEST)
 
+        attributes = request.json.get('attributes')
+        force_update = request.json.get('force_update', False)
 
-def _handle_get_api_events(handler, path_match, data):
-    """Handle getting overview of event listeners."""
-    handler.write_json(events_json(handler.server.hass))
+        is_new_state = self.hass.states.get(entity_id) is None
 
+        # Write state
+        self.hass.states.set(entity_id, new_state, attributes, force_update)
 
-def _handle_api_post_events_event(handler, path_match, event_data):
-    """Handle firing of an event.
+        # Read the state back for our response
+        resp = self.json(self.hass.states.get(entity_id))
 
-    This handles the following paths: /api/events/<event_type>
+        if is_new_state:
+            resp.status_code = HTTP_CREATED
 
-    Events from /api are threated as remote events.
-    """
-    event_type = path_match.group('event_type')
+        resp.headers.add('Location', URL_API_STATES_ENTITY.format(entity_id))
 
-    if event_data is not None and not isinstance(event_data, dict):
-        handler.write_json_message(
-            "event_data should be an object", HTTP_UNPROCESSABLE_ENTITY)
-        return
+        return resp
 
-    event_origin = ha.EventOrigin.remote
+    def delete(self, request, entity_id):
+        """Remove entity."""
+        if self.hass.states.remove(entity_id):
+            return self.json_message('Entity removed')
+        else:
+            return self.json_message('Entity not found', HTTP_NOT_FOUND)
 
-    # Special case handling for event STATE_CHANGED
-    # We will try to convert state dicts back to State objects
-    if event_type == ha.EVENT_STATE_CHANGED and event_data:
-        for key in ('old_state', 'new_state'):
-            state = ha.State.from_dict(event_data.get(key))
 
-            if state:
-                event_data[key] = state
+class APIEventListenersView(HomeAssistantView):
+    """View to handle EventListeners requests."""
 
-    handler.server.hass.bus.fire(event_type, event_data, event_origin)
+    url = URL_API_EVENTS
+    name = "api:event-listeners"
 
-    handler.write_json_message("Event {} fired.".format(event_type))
+    def get(self, request):
+        """Get event listeners."""
+        return self.json(events_json(self.hass))
 
 
-def _handle_get_api_services(handler, path_match, data):
-    """Handle getting overview of services."""
-    handler.write_json(services_json(handler.server.hass))
+class APIEventView(HomeAssistantView):
+    """View to handle Event requests."""
 
+    url = '/api/events/<event_type>'
+    name = "api:event"
 
-# pylint: disable=invalid-name
-def _handle_post_api_services_domain_service(handler, path_match, data):
-    """Handle calling a service.
+    def post(self, request, event_type):
+        """Fire events."""
+        event_data = request.json
 
-    This handles the following paths: /api/services/<domain>/<service>
-    """
-    domain = path_match.group('domain')
-    service = path_match.group('service')
+        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)
 
-    with TrackStates(handler.server.hass) as changed_states:
-        handler.server.hass.services.call(domain, service, data, True)
+        # Special case handling for event STATE_CHANGED
+        # We will try to convert state dicts back to State objects
+        if event_type == ha.EVENT_STATE_CHANGED and event_data:
+            for key in ('old_state', 'new_state'):
+                state = ha.State.from_dict(event_data.get(key))
 
-    handler.write_json(changed_states)
+                if state:
+                    event_data[key] = state
 
+        self.hass.bus.fire(event_type, event_data, ha.EventOrigin.remote)
 
-# pylint: disable=invalid-name
-def _handle_post_api_event_forward(handler, path_match, data):
-    """Handle adding an event forwarding target."""
-    try:
-        host = data['host']
-        api_password = data['api_password']
-    except KeyError:
-        handler.write_json_message(
-            "No host or api_password received.", HTTP_BAD_REQUEST)
-        return
+        return self.json_message("Event {} fired.".format(event_type))
 
-    try:
-        port = int(data['port']) if 'port' in data else None
-    except ValueError:
-        handler.write_json_message(
-            "Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY)
-        return
 
-    api = rem.API(host, api_password, port)
+class APIServicesView(HomeAssistantView):
+    """View to handle Services requests."""
 
-    if not api.validate_api():
-        handler.write_json_message(
-            "Unable to validate API", HTTP_UNPROCESSABLE_ENTITY)
-        return
+    url = URL_API_SERVICES
+    name = "api:services"
 
-    if handler.server.event_forwarder is None:
-        handler.server.event_forwarder = \
-            rem.EventForwarder(handler.server.hass)
+    def get(self, request):
+        """Get registered services."""
+        return self.json(services_json(self.hass))
 
-    handler.server.event_forwarder.connect(api)
 
-    handler.write_json_message("Event forwarding setup.")
+class APIDomainServicesView(HomeAssistantView):
+    """View to handle DomainServices requests."""
 
+    url = "/api/services/<domain>/<service>"
+    name = "api:domain-services"
 
-def _handle_delete_api_event_forward(handler, path_match, data):
-    """Handle deleting an event forwarding target."""
-    try:
-        host = data['host']
-    except KeyError:
-        handler.write_json_message("No host received.", HTTP_BAD_REQUEST)
-        return
+    def post(self, request, domain, service):
+        """Call a service.
 
-    try:
-        port = int(data['port']) if 'port' in data else None
-    except ValueError:
-        handler.write_json_message(
-            "Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY)
-        return
+        Returns a list of changed states.
+        """
+        with TrackStates(self.hass) as changed_states:
+            self.hass.services.call(domain, service, request.json, True)
 
-    if handler.server.event_forwarder is not None:
-        api = rem.API(host, None, port)
+        return self.json(changed_states)
 
-        handler.server.event_forwarder.disconnect(api)
 
-    handler.write_json_message("Event forwarding cancelled.")
+class APIEventForwardingView(HomeAssistantView):
+    """View to handle EventForwarding requests."""
 
+    url = URL_API_EVENT_FORWARD
+    name = "api:event-forward"
+    event_forwarder = None
 
-def _handle_get_api_components(handler, path_match, data):
-    """Return all the loaded components."""
-    handler.write_json(handler.server.hass.config.components)
+    def post(self, request):
+        """Setup an event forwarder."""
+        data = request.json
+        if data is None:
+            return self.json_message("No data received.", HTTP_BAD_REQUEST)
+        try:
+            host = data['host']
+            api_password = data['api_password']
+        except KeyError:
+            return self.json_message("No host or api_password received.",
+                                     HTTP_BAD_REQUEST)
 
+        try:
+            port = int(data['port']) if 'port' in data else None
+        except ValueError:
+            return self.json_message("Invalid value received for port.",
+                                     HTTP_UNPROCESSABLE_ENTITY)
 
-def _handle_get_api_error_log(handler, path_match, data):
-    """Return the logged errors for this session."""
-    handler.write_file(handler.server.hass.config.path(ERROR_LOG_FILENAME),
-                       False)
+        api = rem.API(host, api_password, port)
 
+        if not api.validate_api():
+            return self.json_message("Unable to validate API.",
+                                     HTTP_UNPROCESSABLE_ENTITY)
 
-def _handle_post_api_log_out(handler, path_match, data):
-    """Log user out."""
-    handler.send_response(HTTP_OK)
-    handler.destroy_session()
-    handler.end_headers()
+        if self.event_forwarder is None:
+            self.event_forwarder = rem.EventForwarder(self.hass)
 
+        self.event_forwarder.connect(api)
 
-def _handle_post_api_template(handler, path_match, data):
-    """Log user out."""
-    template_string = data.get('template', '')
+        return self.json_message("Event forwarding setup.")
 
-    try:
-        rendered = template.render(handler.server.hass, template_string)
+    def delete(self, request):
+        """Remove event forwarer."""
+        data = request.json
+        if data is None:
+            return self.json_message("No data received.", HTTP_BAD_REQUEST)
 
-        handler.send_response(HTTP_OK)
-        handler.send_header(HTTP_HEADER_CONTENT_TYPE, CONTENT_TYPE_TEXT_PLAIN)
-        handler.end_headers()
-        handler.wfile.write(rendered.encode('utf-8'))
-    except TemplateError as e:
-        handler.write_json_message(str(e), HTTP_UNPROCESSABLE_ENTITY)
-        return
+        try:
+            host = data['host']
+        except KeyError:
+            return self.json_message("No host received.", HTTP_BAD_REQUEST)
+
+        try:
+            port = int(data['port']) if 'port' in data else None
+        except ValueError:
+            return self.json_message("Invalid value received for port.",
+                                     HTTP_UNPROCESSABLE_ENTITY)
+
+        if self.event_forwarder is not None:
+            api = rem.API(host, None, port)
+
+            self.event_forwarder.disconnect(api)
+
+        return self.json_message("Event forwarding cancelled.")
+
+
+class APIComponentsView(HomeAssistantView):
+    """View to handle Components requests."""
+
+    url = URL_API_COMPONENTS
+    name = "api:components"
+
+    def get(self, request):
+        """Get current loaded components."""
+        return self.json(self.hass.config.components)
+
+
+class APIErrorLogView(HomeAssistantView):
+    """View to handle ErrorLog requests."""
+
+    url = URL_API_ERROR_LOG
+    name = "api:error-log"
+
+    def get(self, request):
+        """Serve error log."""
+        return self.file(request, self.hass.config.path(ERROR_LOG_FILENAME))
+
+
+class APITemplateView(HomeAssistantView):
+    """View to handle requests."""
+
+    url = URL_API_TEMPLATE
+    name = "api:template"
+
+    def post(self, request):
+        """Render a template."""
+        try:
+            return template.render(self.hass, request.json['template'],
+                                   request.json.get('variables'))
+        except TemplateError as ex:
+            return self.json_message('Error rendering template: {}'.format(ex),
+                                     HTTP_BAD_REQUEST)
 
 
 def services_json(hass):

homeassistant/components/arduino.py

@@ -11,7 +11,7 @@ from homeassistant.const import (
 from homeassistant.helpers import validate_config
 
 DOMAIN = "arduino"
-REQUIREMENTS = ['PyMata==2.07a']
+REQUIREMENTS = ['PyMata==2.12']
 BOARD = None
 _LOGGER = logging.getLogger(__name__)
 
@@ -69,7 +69,7 @@ class ArduinoBoard(object):
                                      self._board.ANALOG)
         elif mode == 'digital' and direction == 'in':
             self._board.set_pin_mode(pin,
-                                     self._board.OUTPUT,
+                                     self._board.INPUT,
                                      self._board.DIGITAL)
         elif mode == 'digital' and direction == 'out':
             self._board.set_pin_mode(pin,

homeassistant/components/automation/__init__.py

@@ -9,10 +9,10 @@ import logging
 import voluptuous as vol
 
 from homeassistant.bootstrap import prepare_setup_platform
-from homeassistant.const import CONF_PLATFORM
+from homeassistant.const import ATTR_ENTITY_ID, CONF_PLATFORM
 from homeassistant.components import logbook
-from homeassistant.helpers import extract_domain_configs
-from homeassistant.helpers.service import call_from_config
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import extract_domain_configs, script, condition
 from homeassistant.loader import get_platform
 import homeassistant.helpers.config_validation as cv
 
@@ -74,10 +74,11 @@ _CONDITION_SCHEMA = vol.Any(
         [
             vol.All(
                 vol.Schema({
-                    vol.Required(CONF_PLATFORM): cv.platform_validator(DOMAIN),
+                    CONF_PLATFORM: str,
+                    CONF_CONDITION: str,
                 }, extra=vol.ALLOW_EXTRA),
-                _platform_validator(METHOD_IF_ACTION, 'IF_ACTION_SCHEMA'),
-            )
+                cv.has_at_least_one_key(CONF_PLATFORM, CONF_CONDITION),
+            ),
         ]
     )
 )
@@ -88,21 +89,23 @@ PLATFORM_SCHEMA = vol.Schema({
     vol.Required(CONF_CONDITION_TYPE, default=DEFAULT_CONDITION_TYPE):
         vol.All(vol.Lower, vol.Any(CONDITION_TYPE_AND, CONDITION_TYPE_OR)),
     CONF_CONDITION: _CONDITION_SCHEMA,
-    vol.Required(CONF_ACTION): cv.SERVICE_SCHEMA,
+    vol.Required(CONF_ACTION): cv.SCRIPT_SCHEMA,
 })
 
 
 def setup(hass, config):
     """Setup the automation."""
+    success = False
     for config_key in extract_domain_configs(config, DOMAIN):
         conf = config[config_key]
 
         for list_no, config_block in enumerate(conf):
             name = config_block.get(CONF_ALIAS, "{}, {}".format(config_key,
                                                                 list_no))
-            _setup_automation(hass, config_block, name, config)
+            success = (_setup_automation(hass, config_block, name, config) or
+                       success)
 
-    return True
+    return success
 
 
 def _setup_automation(hass, config_block, name, config):
@@ -122,12 +125,13 @@ def _setup_automation(hass, config_block, name, config):
 
 def _get_action(hass, config, name):
     """Return an action based on a configuration."""
-    def action():
+    script_obj = script.Script(hass, config, name)
+
+    def action(variables=None):
         """Action to be executed."""
         _LOGGER.info('Executing %s', name)
         logbook.log_entry(hass, name, 'has been triggered', DOMAIN)
-
-        call_from_config(hass, config)
+        script_obj.run(variables)
 
     return action
 
@@ -137,6 +141,11 @@ def _process_if(hass, config, p_config, action):
     cond_type = p_config.get(CONF_CONDITION_TYPE,
                              DEFAULT_CONDITION_TYPE).lower()
 
+    # Deprecated since 0.19 - 5/5/2016
+    if cond_type != DEFAULT_CONDITION_TYPE:
+        _LOGGER.warning('Using condition_type: "or" is deprecated. Please use '
+                        '"condition: or" instead.')
+
     if_configs = p_config.get(CONF_CONDITION)
     use_trigger = if_configs == CONDITION_USE_TRIGGER_VALUES
 
@@ -145,38 +154,47 @@ def _process_if(hass, config, p_config, action):
 
     checks = []
     for if_config in if_configs:
-        platform = _resolve_platform(METHOD_IF_ACTION, hass, config,
-                                     if_config.get(CONF_PLATFORM))
-        if platform is None:
-            continue
+        # Deprecated except for used by use_trigger_values
+        # since 0.19 - 5/5/2016
+        if CONF_PLATFORM in if_config:
+            if not use_trigger:
+                _LOGGER.warning("Please switch your condition configuration "
+                                "to use 'condition' instead of 'platform'.")
+            if_config = dict(if_config)
+            if_config[CONF_CONDITION] = if_config.pop(CONF_PLATFORM)
 
-        check = platform.if_action(hass, if_config)
+            # To support use_trigger_values with state trigger accepting
+            # multiple entity_ids to monitor.
+            if_entity_id = if_config.get(ATTR_ENTITY_ID)
+            if isinstance(if_entity_id, list) and len(if_entity_id) == 1:
+                if_config[ATTR_ENTITY_ID] = if_entity_id[0]
 
-        # Invalid conditions are allowed if we base it on trigger
-        if check is None and not use_trigger:
-            return None
-
-        checks.append(check)
+        try:
+            checks.append(condition.from_config(if_config))
+        except HomeAssistantError as ex:
+            # Invalid conditions are allowed if we base it on trigger
+            if use_trigger:
+                _LOGGER.warning('Ignoring invalid condition: %s', ex)
+            else:
+                _LOGGER.warning('Invalid condition: %s', ex)
+                return None
 
     if cond_type == CONDITION_TYPE_AND:
-        def if_action():
+        def if_action(variables=None):
             """AND all conditions."""
-            if all(check() for check in checks):
-                action()
+            if all(check(hass, variables) for check in checks):
+                action(variables)
     else:
-        def if_action():
+        def if_action(variables=None):
             """OR all conditions."""
-            if any(check() for check in checks):
-                action()
+            if any(check(hass, variables) for check in checks):
+                action(variables)
 
     return if_action
 
 
 def _process_trigger(hass, config, trigger_configs, name, action):
     """Setup the triggers."""
-    if isinstance(trigger_configs, dict):
-        trigger_configs = [trigger_configs]
-
     for conf in trigger_configs:
         platform = _resolve_platform(METHOD_TRIGGER, hass, config,
                                      conf.get(CONF_PLATFORM))

homeassistant/components/automation/event.py

@@ -6,27 +6,38 @@ at https://home-assistant.io/components/automation/#event-trigger
 """
 import logging
 
+import voluptuous as vol
+
+from homeassistant.const import CONF_PLATFORM
+from homeassistant.helpers import config_validation as cv
+
 CONF_EVENT_TYPE = "event_type"
 CONF_EVENT_DATA = "event_data"
 
 _LOGGER = logging.getLogger(__name__)
 
+TRIGGER_SCHEMA = vol.Schema({
+    vol.Required(CONF_PLATFORM): 'event',
+    vol.Required(CONF_EVENT_TYPE): cv.string,
+    vol.Optional(CONF_EVENT_DATA): dict,
+})
+
 
 def trigger(hass, config, action):
     """Listen for events based on configuration."""
     event_type = config.get(CONF_EVENT_TYPE)
-
-    if event_type is None:
-        _LOGGER.error("Missing configuration key %s", CONF_EVENT_TYPE)
-        return False
-
     event_data = config.get(CONF_EVENT_DATA)
 
     def handle_event(event):
         """Listen for events and calls the action when data matches."""
         if not event_data or all(val == event.data.get(key) for key, val
                                  in event_data.items()):
-            action()
+            action({
+                'trigger': {
+                    'platform': 'event',
+                    'event': event,
+                },
+            })
 
     hass.bus.listen(event_type, handle_event)
     return True

homeassistant/components/automation/mqtt.py

@@ -30,7 +30,14 @@ def trigger(hass, config, action):
     def mqtt_automation_listener(msg_topic, msg_payload, qos):
         """Listen for MQTT messages."""
         if payload is None or payload == msg_payload:
-            action()
+            action({
+                'trigger': {
+                    'platform': 'mqtt',
+                    'topic': msg_topic,
+                    'payload': msg_payload,
+                    'qos': qos,
+                }
+            })
 
     mqtt.subscribe(hass, topic, mqtt_automation_listener)
 

homeassistant/components/automation/numeric_state.py

@@ -5,101 +5,65 @@ For more details about this automation rule, please refer to the documentation
 at https://home-assistant.io/components/automation/#numeric-state-trigger
 """
 import logging
-from functools import partial
 
-from homeassistant.const import CONF_VALUE_TEMPLATE
+import voluptuous as vol
+
+from homeassistant.const import (
+    CONF_VALUE_TEMPLATE, CONF_PLATFORM, CONF_ENTITY_ID,
+    CONF_BELOW, CONF_ABOVE)
 from homeassistant.helpers.event import track_state_change
-from homeassistant.helpers import template
+from homeassistant.helpers import condition, config_validation as cv
 
-CONF_ENTITY_ID = "entity_id"
-CONF_BELOW = "below"
-CONF_ABOVE = "above"
+TRIGGER_SCHEMA = vol.All(vol.Schema({
+    vol.Required(CONF_PLATFORM): 'numeric_state',
+    vol.Required(CONF_ENTITY_ID): cv.entity_ids,
+    CONF_BELOW: vol.Coerce(float),
+    CONF_ABOVE: vol.Coerce(float),
+    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
+}), cv.has_at_least_one_key(CONF_BELOW, CONF_ABOVE))
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def _renderer(hass, value_template, state):
-    """Render the state value."""
-    if value_template is None:
-        return state.state
-
-    return template.render(hass, value_template, {'state': state})
-
-
 def trigger(hass, config, action):
     """Listen for state changes based on configuration."""
     entity_id = config.get(CONF_ENTITY_ID)
-
-    if entity_id is None:
-        _LOGGER.error("Missing configuration key %s", CONF_ENTITY_ID)
-        return False
-
     below = config.get(CONF_BELOW)
     above = config.get(CONF_ABOVE)
     value_template = config.get(CONF_VALUE_TEMPLATE)
 
-    if below is None and above is None:
-        _LOGGER.error("Missing configuration key."
-                      " One of %s or %s is required",
-                      CONF_BELOW, CONF_ABOVE)
-        return False
-
-    renderer = partial(_renderer, hass, value_template)
-
     # pylint: disable=unused-argument
     def state_automation_listener(entity, from_s, to_s):
         """Listen for state changes and calls action."""
-        # Fire action if we go from outside range into range
-        if _in_range(above, below, renderer(to_s)) and \
-           (from_s is None or not _in_range(above, below, renderer(from_s))):
-            action()
+        if to_s is None:
+            return
+
+        variables = {
+            'trigger': {
+                'platform': 'numeric_state',
+                'entity_id': entity,
+                'below': below,
+                'above': above,
+            }
+        }
+
+        # If new one doesn't match, nothing to do
+        if not condition.numeric_state(
+                hass, to_s, below, above, value_template, variables):
+            return
+
+        # Only match if old didn't exist or existed but didn't match
+        # Written as: skip if old one did exist and matched
+        if from_s is not None and condition.numeric_state(
+                hass, from_s, below, above, value_template, variables):
+            return
+
+        variables['trigger']['from_state'] = from_s
+        variables['trigger']['to_state'] = to_s
+
+        action(variables)
 
     track_state_change(
         hass, entity_id, state_automation_listener)
 
     return True
-
-
-def if_action(hass, config):
-    """Wrap action method with state based condition."""
-    entity_id = config.get(CONF_ENTITY_ID)
-
-    if entity_id is None:
-        _LOGGER.error("Missing configuration key %s", CONF_ENTITY_ID)
-        return None
-
-    below = config.get(CONF_BELOW)
-    above = config.get(CONF_ABOVE)
-    value_template = config.get(CONF_VALUE_TEMPLATE)
-
-    if below is None and above is None:
-        _LOGGER.error("Missing configuration key."
-                      " One of %s or %s is required",
-                      CONF_BELOW, CONF_ABOVE)
-        return None
-
-    renderer = partial(_renderer, hass, value_template)
-
-    def if_numeric_state():
-        """Test numeric state condition."""
-        state = hass.states.get(entity_id)
-        return state is not None and _in_range(above, below, renderer(state))
-
-    return if_numeric_state
-
-
-def _in_range(range_start, range_end, value):
-    """Check if value is inside the range."""
-    try:
-        value = float(value)
-    except ValueError:
-        _LOGGER.warning("Value returned from template is not a number: %s",
-                        value)
-        return False
-
-    if range_start is not None and range_end is not None:
-        return float(range_start) <= value < float(range_end)
-    elif range_end is not None:
-        return value < float(range_end)
-    else:
-        return float(range_start) <= value

homeassistant/components/automation/state.py

@@ -4,15 +4,11 @@ Offer state listening automation rules.
 For more details about this automation rule, please refer to the documentation
 at https://home-assistant.io/components/automation/#state-trigger
 """
-from datetime import timedelta
-
 import voluptuous as vol
 
 import homeassistant.util.dt as dt_util
 from homeassistant.const import (
     EVENT_STATE_CHANGED, EVENT_TIME_CHANGED, MATCH_ALL, CONF_PLATFORM)
-from homeassistant.components.automation.time import (
-    CONF_HOURS, CONF_MINUTES, CONF_SECONDS)
 from homeassistant.helpers.event import track_state_change, track_point_in_time
 import homeassistant.helpers.config_validation as cv
 
@@ -22,46 +18,19 @@ CONF_TO = "to"
 CONF_STATE = "state"
 CONF_FOR = "for"
 
-BASE_SCHEMA = vol.Schema({
-    vol.Required(CONF_PLATFORM): 'state',
-    vol.Required(CONF_ENTITY_ID): cv.entity_id,
-    # These are str on purpose. Want to catch YAML conversions
-    CONF_STATE: str,
-    CONF_FOR: vol.All(vol.Schema({
-        CONF_HOURS: vol.Coerce(int),
-        CONF_MINUTES: vol.Coerce(int),
-        CONF_SECONDS: vol.Coerce(int),
-    }), cv.has_at_least_one_key(CONF_HOURS, CONF_MINUTES, CONF_SECONDS)),
-})
-
-TRIGGER_SCHEMA = vol.Schema(vol.All(
-    BASE_SCHEMA.extend({
+TRIGGER_SCHEMA = vol.All(
+    vol.Schema({
+        vol.Required(CONF_PLATFORM): 'state',
+        vol.Required(CONF_ENTITY_ID): cv.entity_ids,
         # These are str on purpose. Want to catch YAML conversions
         CONF_FROM: str,
         CONF_TO: str,
+        CONF_STATE: str,
+        CONF_FOR: vol.All(cv.time_period, cv.positive_timedelta),
     }),
     vol.Any(cv.key_dependency(CONF_FOR, CONF_TO),
             cv.key_dependency(CONF_FOR, CONF_STATE))
-))
-
-IF_ACTION_SCHEMA = vol.Schema(vol.All(
-    BASE_SCHEMA,
-    cv.key_dependency(CONF_FOR, CONF_STATE)
-))
-
-
-def get_time_config(config):
-    """Helper function to extract the time specified in the configuration."""
-    if CONF_FOR not in config:
-        return None
-
-    hours = config[CONF_FOR].get(CONF_HOURS)
-    minutes = config[CONF_FOR].get(CONF_MINUTES)
-    seconds = config[CONF_FOR].get(CONF_SECONDS)
-
-    return timedelta(hours=(hours or 0.0),
-                     minutes=(minutes or 0.0),
-                     seconds=(seconds or 0.0))
+)
 
 
 def trigger(hass, config, action):
@@ -69,52 +38,48 @@ def trigger(hass, config, action):
     entity_id = config.get(CONF_ENTITY_ID)
     from_state = config.get(CONF_FROM, MATCH_ALL)
     to_state = config.get(CONF_TO) or config.get(CONF_STATE) or MATCH_ALL
-    time_delta = get_time_config(config)
+    time_delta = config.get(CONF_FOR)
 
     def state_automation_listener(entity, from_s, to_s):
         """Listen for state changes and calls action."""
+        def call_action():
+            """Call action with right context."""
+            action({
+                'trigger': {
+                    'platform': 'state',
+                    'entity_id': entity,
+                    'from_state': from_s,
+                    'to_state': to_s,
+                    'for': time_delta,
+                }
+            })
+
+        if time_delta is None:
+            call_action()
+            return
+
         def state_for_listener(now):
             """Fire on state changes after a delay and calls action."""
             hass.bus.remove_listener(
-                EVENT_STATE_CHANGED, for_state_listener)
-            action()
+                EVENT_STATE_CHANGED, attached_state_for_cancel)
+            call_action()
 
         def state_for_cancel_listener(entity, inner_from_s, inner_to_s):
             """Fire on changes and cancel for listener if changed."""
-            if inner_to_s == to_s:
+            if inner_to_s.state == to_s.state:
                 return
-            hass.bus.remove_listener(EVENT_TIME_CHANGED, for_time_listener)
-            hass.bus.remove_listener(
-                EVENT_STATE_CHANGED, for_state_listener)
+            hass.bus.remove_listener(EVENT_TIME_CHANGED,
+                                     attached_state_for_listener)
+            hass.bus.remove_listener(EVENT_STATE_CHANGED,
+                                     attached_state_for_cancel)
 
-        if time_delta is not None:
-            target_tm = dt_util.utcnow() + time_delta
-            for_time_listener = track_point_in_time(
-                hass, state_for_listener, target_tm)
-            for_state_listener = track_state_change(
-                hass, entity_id, state_for_cancel_listener,
-                MATCH_ALL, MATCH_ALL)
-        else:
-            action()
+        attached_state_for_listener = track_point_in_time(
+            hass, state_for_listener, dt_util.utcnow() + time_delta)
+
+        attached_state_for_cancel = track_state_change(
+            hass, entity, state_for_cancel_listener)
 
     track_state_change(
         hass, entity_id, state_automation_listener, from_state, to_state)
 
     return True
-
-
-def if_action(hass, config):
-    """Wrap action method with state based condition."""
-    entity_id = config.get(CONF_ENTITY_ID)
-    state = config.get(CONF_STATE)
-    time_delta = get_time_config(config)
-
-    def if_state():
-        """Test if condition."""
-        is_state = hass.states.is_state(entity_id, state)
-        return (time_delta is None and is_state or
-                time_delta is not None and
-                dt_util.utcnow() - time_delta >
-                hass.states.get(entity_id).last_changed)
-
-    return if_state

homeassistant/components/automation/sun.py

@@ -9,108 +9,41 @@ import logging
 
 import voluptuous as vol
 
-from homeassistant.const import CONF_PLATFORM
-import homeassistant.util.dt as dt_util
-from homeassistant.components import sun
+from homeassistant.const import (
+    CONF_EVENT, CONF_OFFSET, CONF_PLATFORM, SUN_EVENT_SUNRISE)
 from homeassistant.helpers.event import track_sunrise, track_sunset
 import homeassistant.helpers.config_validation as cv
 
 DEPENDENCIES = ['sun']
 
-CONF_OFFSET = 'offset'
-CONF_EVENT = 'event'
-CONF_BEFORE = "before"
-CONF_BEFORE_OFFSET = "before_offset"
-CONF_AFTER = "after"
-CONF_AFTER_OFFSET = "after_offset"
-
-EVENT_SUNSET = 'sunset'
-EVENT_SUNRISE = 'sunrise'
-
 _LOGGER = logging.getLogger(__name__)
 
-
-_SUN_EVENT = vol.All(vol.Lower, vol.Any(EVENT_SUNRISE, EVENT_SUNSET))
-
 TRIGGER_SCHEMA = vol.Schema({
     vol.Required(CONF_PLATFORM): 'sun',
-    vol.Required(CONF_EVENT): _SUN_EVENT,
-    vol.Required(CONF_OFFSET, default=timedelta(0)): cv.time_offset,
+    vol.Required(CONF_EVENT): cv.sun_event,
+    vol.Required(CONF_OFFSET, default=timedelta(0)): cv.time_period,
 })
 
-IF_ACTION_SCHEMA = vol.All(
-    vol.Schema({
-        vol.Required(CONF_PLATFORM): 'sun',
-        CONF_BEFORE: _SUN_EVENT,
-        CONF_AFTER: _SUN_EVENT,
-        vol.Required(CONF_BEFORE_OFFSET, default=timedelta(0)): cv.time_offset,
-        vol.Required(CONF_AFTER_OFFSET, default=timedelta(0)): cv.time_offset,
-    }),
-    cv.has_at_least_one_key(CONF_BEFORE, CONF_AFTER),
-)
-
 
 def trigger(hass, config, action):
     """Listen for events based on configuration."""
     event = config.get(CONF_EVENT)
     offset = config.get(CONF_OFFSET)
 
+    def call_action():
+        """Call action with right context."""
+        action({
+            'trigger': {
+                'platform': 'sun',
+                'event': event,
+                'offset': offset,
+            },
+        })
+
     # Do something to call action
-    if event == EVENT_SUNRISE:
-        track_sunrise(hass, action, offset)
+    if event == SUN_EVENT_SUNRISE:
+        track_sunrise(hass, call_action, offset)
     else:
-        track_sunset(hass, action, offset)
+        track_sunset(hass, call_action, offset)
 
     return True
-
-
-def if_action(hass, config):
-    """Wrap action method with sun based condition."""
-    before = config.get(CONF_BEFORE)
-    after = config.get(CONF_AFTER)
-    before_offset = config.get(CONF_BEFORE_OFFSET)
-    after_offset = config.get(CONF_AFTER_OFFSET)
-
-    if before is None:
-        def before_func():
-            """Return no point in time."""
-            return None
-    elif before == EVENT_SUNRISE:
-        def before_func():
-            """Return time before sunrise."""
-            return sun.next_rising(hass) + before_offset
-    else:
-        def before_func():
-            """Return time before sunset."""
-            return sun.next_setting(hass) + before_offset
-
-    if after is None:
-        def after_func():
-            """Return no point in time."""
-            return None
-    elif after == EVENT_SUNRISE:
-        def after_func():
-            """Return time after sunrise."""
-            return sun.next_rising(hass) + after_offset
-    else:
-        def after_func():
-            """Return time after sunset."""
-            return sun.next_setting(hass) + after_offset
-
-    def time_if():
-        """Validate time based if-condition."""
-        now = dt_util.now()
-        before = before_func()
-        after = after_func()
-
-        if before is not None and now > now.replace(hour=before.hour,
-                                                    minute=before.minute):
-            return False
-
-        if after is not None and now < now.replace(hour=after.hour,
-                                                   minute=after.minute):
-            return False
-
-        return True
-
-    return time_if

homeassistant/components/automation/template.py

@@ -9,9 +9,9 @@ import logging
 import voluptuous as vol
 
 from homeassistant.const import (
-    CONF_VALUE_TEMPLATE, EVENT_STATE_CHANGED, CONF_PLATFORM)
-from homeassistant.exceptions import TemplateError
-from homeassistant.helpers import template
+    CONF_VALUE_TEMPLATE, CONF_PLATFORM, MATCH_ALL)
+from homeassistant.helpers import condition
+from homeassistant.helpers.event import track_state_change
 import homeassistant.helpers.config_validation as cv
 
 
@@ -30,40 +30,24 @@ def trigger(hass, config, action):
     # Local variable to keep track of if the action has already been triggered
     already_triggered = False
 
-    def event_listener(event):
+    def state_changed_listener(entity_id, from_s, to_s):
         """Listen for state changes and calls action."""
         nonlocal already_triggered
-        template_result = _check_template(hass, value_template)
+        template_result = condition.template(hass, value_template)
 
         # Check to see if template returns true
         if template_result and not already_triggered:
             already_triggered = True
-            action()
+            action({
+                'trigger': {
+                    'platform': 'template',
+                    'entity_id': entity_id,
+                    'from_state': from_s,
+                    'to_state': to_s,
+                },
+            })
         elif not template_result:
             already_triggered = False
 
-    hass.bus.listen(EVENT_STATE_CHANGED, event_listener)
+    track_state_change(hass, MATCH_ALL, state_changed_listener)
     return True
-
-
-def if_action(hass, config):
-    """Wrap action method with state based condition."""
-    value_template = config.get(CONF_VALUE_TEMPLATE)
-
-    return lambda: _check_template(hass, value_template)
-
-
-def _check_template(hass, value_template):
-    """Check if result of template is true."""
-    try:
-        value = template.render(hass, value_template, {})
-    except TemplateError as ex:
-        if ex.args and ex.args[0].startswith(
-                "UndefinedError: 'None' has no attribute"):
-            # Common during HA startup - so just a warning
-            _LOGGER.warning(ex)
-        else:
-            _LOGGER.error(ex)
-        return False
-
-    return value.lower() == 'true'

homeassistant/components/automation/time.py

@@ -6,99 +6,48 @@ at https://home-assistant.io/components/automation/#time-trigger
 """
 import logging
 
-import homeassistant.util.dt as dt_util
+import voluptuous as vol
+
+from homeassistant.const import CONF_AFTER, CONF_PLATFORM
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.event import track_time_change
 
 CONF_HOURS = "hours"
 CONF_MINUTES = "minutes"
 CONF_SECONDS = "seconds"
-CONF_BEFORE = "before"
-CONF_AFTER = "after"
-CONF_WEEKDAY = "weekday"
-
-WEEKDAYS = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']
 
 _LOGGER = logging.getLogger(__name__)
 
+TRIGGER_SCHEMA = vol.All(vol.Schema({
+    vol.Required(CONF_PLATFORM): 'time',
+    CONF_AFTER: cv.time,
+    CONF_HOURS: vol.Any(vol.Coerce(int), vol.Coerce(str)),
+    CONF_MINUTES: vol.Any(vol.Coerce(int), vol.Coerce(str)),
+    CONF_SECONDS: vol.Any(vol.Coerce(int), vol.Coerce(str)),
+}), cv.has_at_least_one_key(CONF_HOURS, CONF_MINUTES,
+                            CONF_SECONDS, CONF_AFTER))
+
 
 def trigger(hass, config, action):
     """Listen for state changes based on configuration."""
     if CONF_AFTER in config:
-        after = dt_util.parse_time(config[CONF_AFTER])
-        if after is None:
-            _error_time(config[CONF_AFTER], CONF_AFTER)
-            return False
+        after = config.get(CONF_AFTER)
         hours, minutes, seconds = after.hour, after.minute, after.second
-    elif (CONF_HOURS in config or CONF_MINUTES in config or
-          CONF_SECONDS in config):
+    else:
         hours = config.get(CONF_HOURS)
         minutes = config.get(CONF_MINUTES)
         seconds = config.get(CONF_SECONDS)
-    else:
-        _LOGGER.error('One of %s, %s, %s OR %s needs to be specified',
-                      CONF_HOURS, CONF_MINUTES, CONF_SECONDS, CONF_AFTER)
-        return False
 
     def time_automation_listener(now):
         """Listen for time changes and calls action."""
-        action()
+        action({
+            'trigger': {
+                'platform': 'time',
+                'now': now,
+            },
+        })
 
     track_time_change(hass, time_automation_listener,
                       hour=hours, minute=minutes, second=seconds)
 
     return True
-
-
-def if_action(hass, config):
-    """Wrap action method with time based condition."""
-    before = config.get(CONF_BEFORE)
-    after = config.get(CONF_AFTER)
-    weekday = config.get(CONF_WEEKDAY)
-
-    if before is None and after is None and weekday is None:
-        _LOGGER.error(
-            "Missing if-condition configuration key %s, %s or %s",
-            CONF_BEFORE, CONF_AFTER, CONF_WEEKDAY)
-        return None
-
-    if before is not None:
-        before = dt_util.parse_time(before)
-        if before is None:
-            _error_time(before, CONF_BEFORE)
-            return None
-
-    if after is not None:
-        after = dt_util.parse_time(after)
-        if after is None:
-            _error_time(after, CONF_AFTER)
-            return None
-
-    def time_if():
-        """Validate time based if-condition."""
-        now = dt_util.now()
-        if before is not None and now > now.replace(hour=before.hour,
-                                                    minute=before.minute):
-            return False
-
-        if after is not None and now < now.replace(hour=after.hour,
-                                                   minute=after.minute):
-            return False
-
-        if weekday is not None:
-            now_weekday = WEEKDAYS[now.weekday()]
-
-            if isinstance(weekday, str) and weekday != now_weekday or \
-               now_weekday not in weekday:
-                return False
-
-        return True
-
-    return time_if
-
-
-def _error_time(value, key):
-    """Helper method to print error."""
-    _LOGGER.error(
-        "Received invalid value for '%s': %s", key, value)
-    if isinstance(value, int):
-        _LOGGER.error('Make sure you wrap time values in quotes')

homeassistant/components/automation/zone.py

@@ -6,33 +6,24 @@ at https://home-assistant.io/components/automation/#zone-trigger
 """
 import voluptuous as vol
 
-from homeassistant.components import zone
 from homeassistant.const import (
-    ATTR_GPS_ACCURACY, ATTR_LATITUDE, ATTR_LONGITUDE, MATCH_ALL, CONF_PLATFORM)
+    CONF_EVENT, CONF_ENTITY_ID, CONF_ZONE, MATCH_ALL, CONF_PLATFORM)
 from homeassistant.helpers.event import track_state_change
-import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import (
+    condition, config_validation as cv, location)
 
-CONF_ENTITY_ID = "entity_id"
-CONF_ZONE = "zone"
-CONF_EVENT = "event"
 EVENT_ENTER = "enter"
 EVENT_LEAVE = "leave"
 DEFAULT_EVENT = EVENT_ENTER
 
 TRIGGER_SCHEMA = vol.Schema({
     vol.Required(CONF_PLATFORM): 'zone',
-    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_ENTITY_ID): cv.entity_ids,
     vol.Required(CONF_ZONE): cv.entity_id,
     vol.Required(CONF_EVENT, default=DEFAULT_EVENT):
         vol.Any(EVENT_ENTER, EVENT_LEAVE),
 })
 
-IF_ACTION_SCHEMA = vol.Schema({
-    vol.Required(CONF_PLATFORM): 'zone',
-    vol.Required(CONF_ENTITY_ID): cv.entity_id,
-    vol.Required(CONF_ZONE): cv.entity_id,
-})
-
 
 def trigger(hass, config, action):
     """Listen for state changes based on configuration."""
@@ -42,46 +33,32 @@ def trigger(hass, config, action):
 
     def zone_automation_listener(entity, from_s, to_s):
         """Listen for state changes and calls action."""
-        if from_s and None in (from_s.attributes.get(ATTR_LATITUDE),
-                               from_s.attributes.get(ATTR_LONGITUDE)) or \
-            None in (to_s.attributes.get(ATTR_LATITUDE),
-                     to_s.attributes.get(ATTR_LONGITUDE)):
+        if from_s and not location.has_location(from_s) or \
+           not location.has_location(to_s):
             return
 
-        from_match = _in_zone(hass, zone_entity_id, from_s) if from_s else None
-        to_match = _in_zone(hass, zone_entity_id, to_s)
+        zone_state = hass.states.get(zone_entity_id)
+        if from_s:
+            from_match = condition.zone(hass, zone_state, from_s)
+        else:
+            from_match = False
+        to_match = condition.zone(hass, zone_state, to_s)
 
         # pylint: disable=too-many-boolean-expressions
         if event == EVENT_ENTER and not from_match and to_match or \
            event == EVENT_LEAVE and from_match and not to_match:
-            action()
+            action({
+                'trigger': {
+                    'platform': 'zone',
+                    'entity_id': entity,
+                    'from_state': from_s,
+                    'to_state': to_s,
+                    'zone': zone_state,
+                    'event': event,
+                },
+            })
 
     track_state_change(
         hass, entity_id, zone_automation_listener, MATCH_ALL, MATCH_ALL)
 
     return True
-
-
-def if_action(hass, config):
-    """Wrap action method with zone based condition."""
-    entity_id = config.get(CONF_ENTITY_ID)
-    zone_entity_id = config.get(CONF_ZONE)
-
-    def if_in_zone():
-        """Test if condition."""
-        return _in_zone(hass, zone_entity_id, hass.states.get(entity_id))
-
-    return if_in_zone
-
-
-def _in_zone(hass, zone_entity_id, state):
-    """Check if state is in zone."""
-    if not state or None in (state.attributes.get(ATTR_LATITUDE),
-                             state.attributes.get(ATTR_LONGITUDE)):
-        return False
-
-    zone_state = hass.states.get(zone_entity_id)
-    return zone_state and zone.in_zone(
-        zone_state, state.attributes.get(ATTR_LATITUDE),
-        state.attributes.get(ATTR_LONGITUDE),
-        state.attributes.get(ATTR_GPS_ACCURACY, 0))

homeassistant/components/binary_sensor/__init__.py

@@ -9,8 +9,6 @@ import logging
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
 from homeassistant.const import (STATE_ON, STATE_OFF)
-from homeassistant.components import (
-    bloomsky, mysensors, zwave, vera, wemo, wink)
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 
 DOMAIN = 'binary_sensor'
@@ -35,22 +33,11 @@ SENSOR_CLASSES = [
     'vibration',     # On means vibration detected, Off means no vibration
 ]
 
-# Maps discovered services to their platforms
-DISCOVERY_PLATFORMS = {
-    bloomsky.DISCOVER_BINARY_SENSORS: 'bloomsky',
-    mysensors.DISCOVER_BINARY_SENSORS: 'mysensors',
-    zwave.DISCOVER_BINARY_SENSORS: 'zwave',
-    vera.DISCOVER_BINARY_SENSORS: 'vera',
-    wemo.DISCOVER_BINARY_SENSORS: 'wemo',
-    wink.DISCOVER_BINARY_SENSORS: 'wink'
-}
-
 
 def setup(hass, config):
     """Track states and offer events for binary sensors."""
     component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL,
-        DISCOVERY_PLATFORMS)
+        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
 
     component.setup(config)
 

homeassistant/components/binary_sensor/command_line.py

@@ -1,13 +1,14 @@
 """
-Support for custom shell commands to to retrieve values.
+Support for custom shell commands to retrieve values.
 
 For more details about this platform, please refer to the documentation at
-https://home-assistant.io/components/binary_sensor.command/
+https://home-assistant.io/components/binary_sensor.command_line/
 """
 import logging
 from datetime import timedelta
 
-from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.binary_sensor import (BinarySensorDevice,
+                                                    SENSOR_CLASSES)
 from homeassistant.components.sensor.command_line import CommandSensorData
 from homeassistant.const import CONF_VALUE_TEMPLATE
 from homeassistant.helpers import template
@@ -15,6 +16,7 @@ from homeassistant.helpers import template
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME = "Binary Command Sensor"
+DEFAULT_SENSOR_CLASS = None
 DEFAULT_PAYLOAD_ON = 'ON'
 DEFAULT_PAYLOAD_OFF = 'OFF'
 
@@ -29,28 +31,35 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         _LOGGER.error('Missing required variable: "command"')
         return False
 
+    sensor_class = config.get('sensor_class')
+    if sensor_class not in SENSOR_CLASSES:
+        _LOGGER.warning('Unknown sensor class: %s', sensor_class)
+        sensor_class = DEFAULT_SENSOR_CLASS
+
     data = CommandSensorData(config.get('command'))
 
     add_devices([CommandBinarySensor(
         hass,
         data,
         config.get('name', DEFAULT_NAME),
+        sensor_class,
         config.get('payload_on', DEFAULT_PAYLOAD_ON),
         config.get('payload_off', DEFAULT_PAYLOAD_OFF),
         config.get(CONF_VALUE_TEMPLATE)
     )])
 
 
-# pylint: disable=too-many-arguments
+# pylint: disable=too-many-arguments, too-many-instance-attributes
 class CommandBinarySensor(BinarySensorDevice):
     """Represent a command line binary sensor."""
 
-    def __init__(self, hass, data, name, payload_on,
+    def __init__(self, hass, data, name, sensor_class, payload_on,
                  payload_off, value_template):
         """Initialize the Command line binary sensor."""
         self._hass = hass
         self.data = data
         self._name = name
+        self._sensor_class = sensor_class
         self._state = False
         self._payload_on = payload_on
         self._payload_off = payload_off
@@ -67,6 +76,11 @@ class CommandBinarySensor(BinarySensorDevice):
         """Return true if the binary sensor is on."""
         return self._state
 
+    @ property
+    def sensor_class(self):
+        """Return the class of the binary sensor."""
+        return self._sensor_class
+
     def update(self):
         """Get the latest data and updates the state."""
         self.data.update()

homeassistant/components/binary_sensor/enocean.py

@@ -0,0 +1,63 @@
+"""
+Support for EnOcean binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.enocean/
+"""
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components import enocean
+from homeassistant.const import CONF_NAME
+
+DEPENDENCIES = ["enocean"]
+
+CONF_ID = "id"
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Binary Sensor platform fo EnOcean."""
+    dev_id = config.get(CONF_ID, None)
+    devname = config.get(CONF_NAME, "EnOcean binary sensor")
+    add_devices([EnOceanBinarySensor(dev_id, devname)])
+
+
+class EnOceanBinarySensor(enocean.EnOceanDevice, BinarySensorDevice):
+    """Representation of EnOcean binary sensors such as wall switches."""
+
+    def __init__(self, dev_id, devname):
+        """Initialize the EnOcean binary sensor."""
+        enocean.EnOceanDevice.__init__(self)
+        self.stype = "listener"
+        self.dev_id = dev_id
+        self.which = -1
+        self.onoff = -1
+        self.devname = devname
+
+    @property
+    def name(self):
+        """The default name for the binary sensor."""
+        return self.devname
+
+    def value_changed(self, value, value2):
+        """Fire an event with the data that have changed.
+
+        This method is called when there is an incoming packet associated
+        with this platform.
+        """
+        self.update_ha_state()
+        if value2 == 0x70:
+            self.which = 0
+            self.onoff = 0
+        elif value2 == 0x50:
+            self.which = 0
+            self.onoff = 1
+        elif value2 == 0x30:
+            self.which = 1
+            self.onoff = 0
+        elif value2 == 0x10:
+            self.which = 1
+            self.onoff = 1
+        self.hass.bus.fire('button_pressed', {"id": self.dev_id,
+                                              'pushed': value,
+                                              'which': self.which,
+                                              'onoff': self.onoff})

homeassistant/components/binary_sensor/envisalink.py

@@ -0,0 +1,71 @@
+"""
+Support for Envisalink zone states- represented as binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.envisalink/
+"""
+import logging
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.envisalink import (EVL_CONTROLLER,
+                                                 ZONE_SCHEMA,
+                                                 CONF_ZONENAME,
+                                                 CONF_ZONETYPE,
+                                                 EnvisalinkDevice,
+                                                 SIGNAL_ZONE_UPDATE)
+from homeassistant.const import ATTR_LAST_TRIP_TIME
+
+DEPENDENCIES = ['envisalink']
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """Perform the setup for Envisalink sensor devices."""
+    _configured_zones = discovery_info['zones']
+    for zone_num in _configured_zones:
+        _device_config_data = ZONE_SCHEMA(_configured_zones[zone_num])
+        _device = EnvisalinkBinarySensor(
+            zone_num,
+            _device_config_data[CONF_ZONENAME],
+            _device_config_data[CONF_ZONETYPE],
+            EVL_CONTROLLER.alarm_state['zone'][zone_num],
+            EVL_CONTROLLER)
+        add_devices_callback([_device])
+
+
+class EnvisalinkBinarySensor(EnvisalinkDevice, BinarySensorDevice):
+    """Representation of an envisalink Binary Sensor."""
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, zone_number, zone_name, zone_type, info, controller):
+        """Initialize the binary_sensor."""
+        from pydispatch import dispatcher
+        self._zone_type = zone_type
+        self._zone_number = zone_number
+
+        _LOGGER.debug('Setting up zone: ' + zone_name)
+        EnvisalinkDevice.__init__(self, zone_name, info, controller)
+        dispatcher.connect(self._update_callback,
+                           signal=SIGNAL_ZONE_UPDATE,
+                           sender=dispatcher.Any)
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attr = {}
+        attr[ATTR_LAST_TRIP_TIME] = self._info['last_fault']
+        return attr
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._info['status']['open']
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        return self._zone_type
+
+    def _update_callback(self, zone):
+        """Update the zone's state, if needed."""
+        if zone is None or int(zone) == self._zone_number:
+            self.update_ha_state()

homeassistant/components/binary_sensor/homematic.py

@@ -0,0 +1,100 @@
+"""
+Support for Homematic binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.homematic/
+"""
+import logging
+from homeassistant.const import STATE_UNKNOWN
+from homeassistant.components.binary_sensor import BinarySensorDevice
+import homeassistant.components.homematic as homematic
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['homematic']
+
+SENSOR_TYPES_CLASS = {
+    "Remote": None,
+    "ShutterContact": "opening",
+    "Smoke": "smoke",
+    "SmokeV2": "smoke",
+    "Motion": "motion",
+    "MotionV2": "motion",
+    "RemoteMotion": None
+}
+
+
+def setup_platform(hass, config, add_callback_devices, discovery_info=None):
+    """Setup the Homematic binary sensor platform."""
+    if discovery_info is None:
+        return
+
+    return homematic.setup_hmdevice_discovery_helper(HMBinarySensor,
+                                                     discovery_info,
+                                                     add_callback_devices)
+
+
+class HMBinarySensor(homematic.HMDevice, BinarySensorDevice):
+    """Representation of a binary Homematic device."""
+
+    @property
+    def is_on(self):
+        """Return true if switch is on."""
+        if not self.available:
+            return False
+        return bool(self._hm_get_state())
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        if not self.available:
+            return None
+
+        # If state is MOTION (RemoteMotion works only)
+        if self._state == "MOTION":
+            return "motion"
+        return SENSOR_TYPES_CLASS.get(self._hmdevice.__class__.__name__, None)
+
+    def _check_hm_to_ha_object(self):
+        """Check if possible to use the HM Object as this HA type."""
+        from pyhomematic.devicetypes.sensors import HMBinarySensor\
+            as pyHMBinarySensor
+
+        # Check compatibility from HMDevice
+        if not super()._check_hm_to_ha_object():
+            return False
+
+        # check if the Homematic device correct for this HA device
+        if not isinstance(self._hmdevice, pyHMBinarySensor):
+            _LOGGER.critical("This %s can't be use as binary", self._name)
+            return False
+
+        # if exists user value?
+        if self._state and self._state not in self._hmdevice.BINARYNODE:
+            _LOGGER.critical("This %s have no binary with %s", self._name,
+                             self._state)
+            return False
+
+        # only check and give a warning to the user
+        if self._state is None and len(self._hmdevice.BINARYNODE) > 1:
+            _LOGGER.critical("%s have multiple binary params. It use all "
+                             "binary nodes as one. Possible param values: %s",
+                             self._name, str(self._hmdevice.BINARYNODE))
+            return False
+
+        return True
+
+    def _init_data_struct(self):
+        """Generate a data struct (self._data) from the Homematic metadata."""
+        super()._init_data_struct()
+
+        # object have 1 binary
+        if self._state is None and len(self._hmdevice.BINARYNODE) == 1:
+            for value in self._hmdevice.BINARYNODE:
+                self._state = value
+
+        # add state to data struct
+        if self._state:
+            _LOGGER.debug("%s init datastruct with main node '%s'", self._name,
+                          self._state)
+            self._data.update({self._state: STATE_UNKNOWN})

homeassistant/components/binary_sensor/mysensors.py

@@ -6,10 +6,10 @@ https://home-assistant.io/components/binary_sensor.mysensors/
 """
 import logging
 
+from homeassistant.components import mysensors
 from homeassistant.components.binary_sensor import (SENSOR_CLASSES,
                                                     BinarySensorDevice)
-from homeassistant.const import ATTR_BATTERY_LEVEL, STATE_OFF, STATE_ON
-from homeassistant.loader import get_component
+from homeassistant.const import STATE_ON
 
 _LOGGER = logging.getLogger(__name__)
 DEPENDENCIES = []
@@ -22,8 +22,6 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     if discovery_info is None:
         return
 
-    mysensors = get_component('mysensors')
-
     for gateway in mysensors.GATEWAYS.values():
         # Define the S_TYPES and V_TYPES that the platform should handle as
         # states. Map them in a dict of lists.
@@ -48,81 +46,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             map_sv_types, devices, add_devices, MySensorsBinarySensor))
 
 
-class MySensorsBinarySensor(BinarySensorDevice):
-    """Represent the value of a MySensors child node."""
-
-    # pylint: disable=too-many-arguments,too-many-instance-attributes
-
-    def __init__(
-            self, gateway, node_id, child_id, name, value_type, child_type):
-        """
-        Setup class attributes on instantiation.
-
-        Args:
-        gateway (GatewayWrapper): Gateway object.
-        node_id (str): Id of node.
-        child_id (str): Id of child.
-        name (str): Entity name.
-        value_type (str): Value type of child. Value is entity state.
-        child_type (str): Child type of child.
-
-        Attributes:
-        gateway (GatewayWrapper): Gateway object.
-        node_id (str): Id of node.
-        child_id (str): Id of child.
-        _name (str): Entity name.
-        value_type (str): Value type of child. Value is entity state.
-        child_type (str): Child type of child.
-        battery_level (int): Node battery level.
-        _values (dict): Child values. Non state values set as state attributes.
-        mysensors (module): Mysensors main component module.
-        """
-        self.gateway = gateway
-        self.node_id = node_id
-        self.child_id = child_id
-        self._name = name
-        self.value_type = value_type
-        self.child_type = child_type
-        self.battery_level = 0
-        self._values = {}
-        self.mysensors = get_component('mysensors')
-
-    @property
-    def should_poll(self):
-        """Mysensor gateway pushes its state to HA."""
-        return False
-
-    @property
-    def name(self):
-        """The name of this entity."""
-        return self._name
-
-    @property
-    def device_state_attributes(self):
-        """Return device specific state attributes."""
-        address = getattr(self.gateway, 'server_address', None)
-        if address:
-            device = '{}:{}'.format(address[0], address[1])
-        else:
-            device = self.gateway.port
-        attr = {
-            self.mysensors.ATTR_DEVICE: device,
-            self.mysensors.ATTR_NODE_ID: self.node_id,
-            self.mysensors.ATTR_CHILD_ID: self.child_id,
-            ATTR_BATTERY_LEVEL: self.battery_level,
-        }
-
-        set_req = self.gateway.const.SetReq
-
-        for value_type, value in self._values.items():
-            if value_type != self.value_type:
-                try:
-                    attr[set_req(value_type).name] = value
-                except ValueError:
-                    _LOGGER.error('value_type %s is not valid for mysensors '
-                                  'version %s', value_type,
-                                  self.gateway.version)
-        return attr
+class MySensorsBinarySensor(
+        mysensors.MySensorsDeviceEntity, BinarySensorDevice):
+    """Represent the value of a MySensors Binary Sensor child node."""
 
     @property
     def is_on(self):
@@ -150,23 +76,3 @@ class MySensorsBinarySensor(BinarySensorDevice):
             })
         if class_map.get(self.child_type) in SENSOR_CLASSES:
             return class_map.get(self.child_type)
-
-    @property
-    def available(self):
-        """Return True if entity is available."""
-        return self.value_type in self._values
-
-    def update(self):
-        """Update the controller with the latest values from a sensor."""
-        node = self.gateway.sensors[self.node_id]
-        child = node.children[self.child_id]
-        for value_type, value in child.values.items():
-            _LOGGER.debug(
-                "%s: value_type %s, value = %s", self._name, value_type, value)
-            if value_type == self.gateway.const.SetReq.V_TRIPPED:
-                self._values[value_type] = STATE_ON if int(
-                    value) == 1 else STATE_OFF
-            else:
-                self._values[value_type] = value
-
-        self.battery_level = node.battery_level

homeassistant/components/binary_sensor/octoprint.py

@@ -0,0 +1,109 @@
+"""
+Support for monitoring OctoPrint binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.octoprint/
+"""
+import logging
+import requests
+
+from homeassistant.const import CONF_NAME, STATE_ON, STATE_OFF
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.loader import get_component
+
+DEPENDENCIES = ["octoprint"]
+
+SENSOR_TYPES = {
+    # API Endpoint, Group, Key, unit
+    "Printing": ["printer", "state", "printing", None],
+    "Printing Error": ["printer", "state", "error", None]
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the available OctoPrint binary sensors."""
+    octoprint = get_component('octoprint')
+    name = config.get(CONF_NAME, "OctoPrint")
+    monitored_conditions = config.get("monitored_conditions",
+                                      SENSOR_TYPES.keys())
+
+    devices = []
+    for octo_type in monitored_conditions:
+        if octo_type in SENSOR_TYPES:
+            new_sensor = OctoPrintBinarySensor(octoprint.OCTOPRINT,
+                                               octo_type,
+                                               SENSOR_TYPES[octo_type][2],
+                                               name,
+                                               SENSOR_TYPES[octo_type][3],
+                                               SENSOR_TYPES[octo_type][0],
+                                               SENSOR_TYPES[octo_type][1],
+                                               "flags")
+            devices.append(new_sensor)
+        else:
+            _LOGGER.error("Unknown OctoPrint sensor type: %s", octo_type)
+    add_devices(devices)
+
+
+# pylint: disable=too-many-instance-attributes
+class OctoPrintBinarySensor(BinarySensorDevice):
+    """Representation an OctoPrint binary sensor."""
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, api, condition, sensor_type, sensor_name,
+                 unit, endpoint, group, tool=None):
+        """Initialize a new OctoPrint sensor."""
+        self.sensor_name = sensor_name
+        if tool is None:
+            self._name = sensor_name + ' ' + condition
+        else:
+            self._name = sensor_name + ' ' + condition
+        self.sensor_type = sensor_type
+        self.api = api
+        self._state = False
+        self._unit_of_measurement = unit
+        self.api_endpoint = endpoint
+        self.api_group = group
+        self.api_tool = tool
+        # Set initial state
+        self.update()
+        _LOGGER.debug("Created OctoPrint binary sensor %r", self)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        return self.is_on
+
+    @property
+    def is_on(self):
+        """Return true if binary sensor is on."""
+        if self._state:
+            return STATE_ON
+        else:
+            return STATE_OFF
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        return None
+
+    def update(self):
+        """Update state of sensor."""
+        try:
+            self._state = self.api.update(self.sensor_type,
+                                          self.api_endpoint,
+                                          self.api_group,
+                                          self.api_tool)
+        except requests.exceptions.ConnectionError:
+            # Error calling the api, already logged in api.update()
+            return
+
+        if self._state is None:
+            _LOGGER.warning("Unable to locate value for %s", self.sensor_type)

homeassistant/components/binary_sensor/rest.py

@@ -35,7 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     rest.update()
 
     if rest.data is None:
-        _LOGGER.error('Unable to fetch Rest data')
+        _LOGGER.error('Unable to fetch REST data')
         return False
 
     add_devices([RestBinarySensor(
@@ -57,6 +57,7 @@ class RestBinarySensor(BinarySensorDevice):
         self._name = name
         self._sensor_class = sensor_class
         self._state = False
+        self._previous_data = None
         self._value_template = value_template
         self.update()
 
@@ -77,9 +78,14 @@ class RestBinarySensor(BinarySensorDevice):
             return False
 
         if self._value_template is not None:
-            self.rest.data = template.render_with_possible_json_value(
+            response = template.render_with_possible_json_value(
                 self._hass, self._value_template, self.rest.data, False)
-        return bool(int(self.rest.data))
+
+        try:
+            return bool(int(response))
+        except ValueError:
+            return {"true": True, "on": True, "open": True,
+                    "yes": True}.get(response.lower(), False)
 
     def update(self):
         """Get the latest data from REST API and updates the state."""

homeassistant/components/binary_sensor/template.py

@@ -9,11 +9,12 @@ import logging
 from homeassistant.components.binary_sensor import (BinarySensorDevice,
                                                     ENTITY_ID_FORMAT,
                                                     SENSOR_CLASSES)
-from homeassistant.const import ATTR_FRIENDLY_NAME, CONF_VALUE_TEMPLATE
-from homeassistant.core import EVENT_STATE_CHANGED
+from homeassistant.const import (ATTR_FRIENDLY_NAME, CONF_VALUE_TEMPLATE,
+                                 ATTR_ENTITY_ID, MATCH_ALL)
 from homeassistant.exceptions import TemplateError
 from homeassistant.helpers.entity import generate_entity_id
 from homeassistant.helpers import template
+from homeassistant.helpers.event import track_state_change
 from homeassistant.util import slugify
 
 CONF_SENSORS = 'sensors'
@@ -52,13 +53,16 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 'Missing %s for sensor %s', CONF_VALUE_TEMPLATE, device)
             continue
 
+        entity_ids = device_config.get(ATTR_ENTITY_ID, MATCH_ALL)
+
         sensors.append(
             BinarySensorTemplate(
                 hass,
                 device,
                 friendly_name,
                 sensor_class,
-                value_template)
+                value_template,
+                entity_ids)
             )
     if not sensors:
         _LOGGER.error('No sensors added')
@@ -73,7 +77,7 @@ class BinarySensorTemplate(BinarySensorDevice):
 
     # pylint: disable=too-many-arguments
     def __init__(self, hass, device, friendly_name, sensor_class,
-                 value_template):
+                 value_template, entity_ids):
         """Initialize the Template binary sensor."""
         self.hass = hass
         self.entity_id = generate_entity_id(ENTITY_ID_FORMAT, device,
@@ -85,12 +89,12 @@ class BinarySensorTemplate(BinarySensorDevice):
 
         self.update()
 
-        def template_bsensor_event_listener(event):
+        def template_bsensor_state_listener(entity, old_state, new_state):
             """Called when the target device changes state."""
             self.update_ha_state(True)
 
-        hass.bus.listen(EVENT_STATE_CHANGED,
-                        template_bsensor_event_listener)
+        track_state_change(hass, entity_ids,
+                           template_bsensor_state_listener)
 
     @property
     def name(self):

homeassistant/components/binary_sensor/wink.py

@@ -7,10 +7,12 @@ at https://home-assistant.io/components/sensor.wink/
 import logging
 
 from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.sensor.wink import WinkDevice
 from homeassistant.const import CONF_ACCESS_TOKEN
 from homeassistant.helpers.entity import Entity
+from homeassistant.loader import get_component
 
-REQUIREMENTS = ['python-wink==0.7.4']
+REQUIREMENTS = ['python-wink==0.7.8', 'pubnub==3.7.8']
 
 # These are the available sensors mapped to binary_sensor class
 SENSOR_TYPES = {
@@ -41,12 +43,13 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             add_devices([WinkBinarySensorDevice(sensor)])
 
 
-class WinkBinarySensorDevice(BinarySensorDevice, Entity):
+class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
     """Representation of a Wink sensor."""
 
     def __init__(self, wink):
         """Initialize the Wink binary sensor."""
-        self.wink = wink
+        super().__init__(wink)
+        wink = get_component('wink')
         self._unit_of_measurement = self.wink.UNIT
         self.capability = self.wink.capability()
 
@@ -66,22 +69,3 @@ class WinkBinarySensorDevice(BinarySensorDevice, Entity):
     def sensor_class(self):
         """Return the class of this sensor, from SENSOR_CLASSES."""
         return SENSOR_TYPES.get(self.capability)
-
-    @property
-    def unique_id(self):
-        """Return the ID of this wink sensor."""
-        return "{}.{}".format(self.__class__, self.wink.device_id())
-
-    @property
-    def name(self):
-        """Return the name of the sensor if any."""
-        return self.wink.name()
-
-    @property
-    def available(self):
-        """True if connection == True."""
-        return self.wink.available
-
-    def update(self):
-        """Update state of the sensor."""
-        self.wink.update_state()

homeassistant/components/bloomsky.py

@@ -9,9 +9,8 @@ from datetime import timedelta
 
 import requests
 
-from homeassistant.components import discovery
 from homeassistant.const import CONF_API_KEY
-from homeassistant.helpers import validate_config
+from homeassistant.helpers import validate_config, discovery
 from homeassistant.util import Throttle
 
 DOMAIN = "bloomsky"
@@ -23,10 +22,6 @@ _LOGGER = logging.getLogger(__name__)
 # no point in polling the API more frequently
 MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=300)
 
-DISCOVER_SENSORS = 'bloomsky.sensors'
-DISCOVER_BINARY_SENSORS = 'bloomsky.binary_sensor'
-DISCOVER_CAMERAS = 'bloomsky.camera'
-
 
 # pylint: disable=unused-argument,too-few-public-methods
 def setup(hass, config):
@@ -45,11 +40,8 @@ def setup(hass, config):
     except RuntimeError:
         return False
 
-    for component, discovery_service in (
-            ('camera', DISCOVER_CAMERAS), ('sensor', DISCOVER_SENSORS),
-            ('binary_sensor', DISCOVER_BINARY_SENSORS)):
-        discovery.discover(hass, discovery_service, component=component,
-                           hass_config=config)
+    for component in 'camera', 'binary_sensor', 'sensor':
+        discovery.load_platform(hass, component, DOMAIN, {}, config)
 
     return True
 

homeassistant/components/camera/__init__.py

@@ -6,96 +6,36 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/camera/
 """
 import logging
-import re
 import time
 
-import requests
-
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.components import bloomsky
-from homeassistant.const import HTTP_OK, HTTP_NOT_FOUND, ATTR_ENTITY_ID
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
-
+from homeassistant.components.http import HomeAssistantView
 
 DOMAIN = 'camera'
 DEPENDENCIES = ['http']
 SCAN_INTERVAL = 30
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 
-# Maps discovered services to their platforms
-DISCOVERY_PLATFORMS = {
-    bloomsky.DISCOVER_CAMERAS: 'bloomsky',
-}
-
 STATE_RECORDING = 'recording'
 STATE_STREAMING = 'streaming'
 STATE_IDLE = 'idle'
 
-ENTITY_IMAGE_URL = '/api/camera_proxy/{0}'
-
-MULTIPART_BOUNDARY = '--jpgboundary'
-MJPEG_START_HEADER = 'Content-type: {0}\r\n\r\n'
+ENTITY_IMAGE_URL = '/api/camera_proxy/{0}?token={1}'
 
 
 # pylint: disable=too-many-branches
 def setup(hass, config):
     """Setup the camera component."""
     component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL,
-        DISCOVERY_PLATFORMS)
+        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
+
+    hass.wsgi.register_view(CameraImageView(hass, component.entities))
+    hass.wsgi.register_view(CameraMjpegStream(hass, component.entities))
 
     component.setup(config)
 
-    def _proxy_camera_image(handler, path_match, data):
-        """Serve the camera image via the HA server."""
-        entity_id = path_match.group(ATTR_ENTITY_ID)
-        camera = component.entities.get(entity_id)
-
-        if camera is None:
-            handler.send_response(HTTP_NOT_FOUND)
-            handler.end_headers()
-            return
-
-        response = camera.camera_image()
-
-        if response is None:
-            handler.send_response(HTTP_NOT_FOUND)
-            handler.end_headers()
-            return
-
-        handler.send_response(HTTP_OK)
-        handler.write_content(response)
-
-    hass.http.register_path(
-        'GET',
-        re.compile(r'/api/camera_proxy/(?P<entity_id>[a-zA-Z\._0-9]+)'),
-        _proxy_camera_image)
-
-    def _proxy_camera_mjpeg_stream(handler, path_match, data):
-        """Proxy the camera image as an mjpeg stream via the HA server."""
-        entity_id = path_match.group(ATTR_ENTITY_ID)
-        camera = component.entities.get(entity_id)
-
-        if camera is None:
-            handler.send_response(HTTP_NOT_FOUND)
-            handler.end_headers()
-            return
-
-        try:
-            camera.is_streaming = True
-            camera.update_ha_state()
-            camera.mjpeg_stream(handler)
-
-        except (requests.RequestException, IOError):
-            camera.is_streaming = False
-            camera.update_ha_state()
-
-    hass.http.register_path(
-        'GET',
-        re.compile(r'/api/camera_proxy_stream/(?P<entity_id>[a-zA-Z\._0-9]+)'),
-        _proxy_camera_mjpeg_stream)
-
     return True
 
 
@@ -106,6 +46,11 @@ class Camera(Entity):
         """Initialize a camera."""
         self.is_streaming = False
 
+    @property
+    def access_token(self):
+        """Access token for this camera."""
+        return str(id(self))
+
     @property
     def should_poll(self):
         """No need to poll cameras."""
@@ -114,7 +59,7 @@ class Camera(Entity):
     @property
     def entity_picture(self):
         """Return a link to the camera feed as entity picture."""
-        return ENTITY_IMAGE_URL.format(self.entity_id)
+        return ENTITY_IMAGE_URL.format(self.entity_id, self.access_token)
 
     @property
     def is_recording(self):
@@ -135,32 +80,33 @@ class Camera(Entity):
         """Return bytes of camera image."""
         raise NotImplementedError()
 
-    def mjpeg_stream(self, handler):
+    def mjpeg_stream(self, response):
         """Generate an HTTP MJPEG stream from camera images."""
-        def write_string(text):
-            """Helper method to write a string to the stream."""
-            handler.request.sendall(bytes(text + '\r\n', 'utf-8'))
+        def stream():
+            """Stream images as mjpeg stream."""
+            try:
+                last_image = None
+                while True:
+                    img_bytes = self.camera_image()
 
-        write_string('HTTP/1.1 200 OK')
-        write_string('Content-type: multipart/x-mixed-replace; '
-                     'boundary={}'.format(MULTIPART_BOUNDARY))
-        write_string('')
-        write_string(MULTIPART_BOUNDARY)
+                    if img_bytes is not None and img_bytes != last_image:
+                        yield bytes(
+                            '--jpegboundary\r\n'
+                            'Content-Type: image/jpeg\r\n'
+                            'Content-Length: {}\r\n\r\n'.format(
+                                len(img_bytes)), 'utf-8') + img_bytes + b'\r\n'
 
-        while True:
-            img_bytes = self.camera_image()
+                        last_image = img_bytes
 
-            if img_bytes is None:
-                continue
+                    time.sleep(0.5)
+            except GeneratorExit:
+                pass
 
-            write_string('Content-length: {}'.format(len(img_bytes)))
-            write_string('Content-type: image/jpeg')
-            write_string('')
-            handler.request.sendall(img_bytes)
-            write_string('')
-            write_string(MULTIPART_BOUNDARY)
-
-            time.sleep(0.5)
+        return response(
+            stream(),
+            content_type=('multipart/x-mixed-replace; '
+                          'boundary=--jpegboundary')
+        )
 
     @property
     def state(self):
@@ -175,7 +121,9 @@ class Camera(Entity):
     @property
     def state_attributes(self):
         """Camera state attributes."""
-        attr = {}
+        attr = {
+            'access_token': self.access_token,
+        }
 
         if self.model:
             attr['model_name'] = self.model
@@ -184,3 +132,60 @@ class Camera(Entity):
             attr['brand'] = self.brand
 
         return attr
+
+
+class CameraView(HomeAssistantView):
+    """Base CameraView."""
+
+    requires_auth = False
+
+    def __init__(self, hass, entities):
+        """Initialize a basic camera view."""
+        super().__init__(hass)
+        self.entities = entities
+
+    def get(self, request, entity_id):
+        """Start a get request."""
+        camera = self.entities.get(entity_id)
+
+        if camera is None:
+            return self.Response(status=404)
+
+        authenticated = (request.authenticated or
+                         request.args.get('token') == camera.access_token)
+
+        if not authenticated:
+            return self.Response(status=401)
+
+        return self.handle(camera)
+
+    def handle(self, camera):
+        """Hanlde the camera request."""
+        raise NotImplementedError()
+
+
+class CameraImageView(CameraView):
+    """Camera view to serve an image."""
+
+    url = "/api/camera_proxy/<entity(domain=camera):entity_id>"
+    name = "api:camera:image"
+
+    def handle(self, camera):
+        """Serve camera image."""
+        response = camera.camera_image()
+
+        if response is None:
+            return self.Response(status=500)
+
+        return self.Response(response)
+
+
+class CameraMjpegStream(CameraView):
+    """Camera View to serve an MJPEG stream."""
+
+    url = "/api/camera_proxy_stream/<entity(domain=camera):entity_id>"
+    name = "api:camera:stream"
+
+    def handle(self, camera):
+        """Serve camera image."""
+        return camera.mjpeg_stream(self.Response)

homeassistant/components/camera/foscam.py

@@ -49,7 +49,7 @@ class FoscamCamera(Camera):
     def camera_image(self):
         """Return a still image reponse from the camera."""
         # Send the request to snap a picture and return raw jpg data
-        response = requests.get(self._snap_picture_url)
+        response = requests.get(self._snap_picture_url, timeout=10)
 
         return response.content
 

homeassistant/components/camera/generic.py

@@ -43,13 +43,14 @@ class GenericCamera(Camera):
             try:
                 response = requests.get(
                     self._still_image_url,
-                    auth=HTTPBasicAuth(self._username, self._password))
+                    auth=HTTPBasicAuth(self._username, self._password),
+                    timeout=10)
             except requests.exceptions.RequestException as error:
                 _LOGGER.error('Error getting camera image: %s', error)
                 return None
         else:
             try:
-                response = requests.get(self._still_image_url)
+                response = requests.get(self._still_image_url, timeout=10)
             except requests.exceptions.RequestException as error:
                 _LOGGER.error('Error getting camera image: %s', error)
                 return None

homeassistant/components/camera/local_file.py

@@ -0,0 +1,53 @@
+"""Camera that loads a picture from a local file."""
+
+import logging
+import os
+
+from homeassistant.components.camera import Camera
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Camera."""
+    # check for missing required configuration variable
+    if config.get("file_path") is None:
+        _LOGGER.error("Missing required variable: file_path")
+        return False
+
+    setup_config = (
+        {
+            "name": config.get("name", "Local File"),
+            "file_path": config.get("file_path")
+        }
+    )
+
+    # check filepath given is readable
+    if not os.access(setup_config["file_path"], os.R_OK):
+        _LOGGER.error("file path is not readable")
+        return False
+
+    add_devices([
+        LocalFile(setup_config)
+    ])
+
+
+class LocalFile(Camera):
+    """Local camera."""
+
+    def __init__(self, device_info):
+        """Initialize Local File Camera component."""
+        super().__init__()
+
+        self._name = device_info["name"]
+        self._config = device_info
+
+    def camera_image(self):
+        """Return image response."""
+        with open(self._config["file_path"], 'rb') as file:
+            return file.read()
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name

homeassistant/components/camera/mjpeg.py

@@ -11,7 +11,6 @@ import requests
 from requests.auth import HTTPBasicAuth
 
 from homeassistant.components.camera import DOMAIN, Camera
-from homeassistant.const import HTTP_OK
 from homeassistant.helpers import validate_config
 
 CONTENT_TYPE_HEADER = 'Content-Type'
@@ -47,10 +46,9 @@ class MjpegCamera(Camera):
             return requests.get(self._mjpeg_url,
                                 auth=HTTPBasicAuth(self._username,
                                                    self._password),
-                                stream=True)
+                                stream=True, timeout=10)
         else:
-            return requests.get(self._mjpeg_url,
-                                stream=True)
+            return requests.get(self._mjpeg_url, stream=True, timeout=10)
 
     def camera_image(self):
         """Return a still image response from the camera."""
@@ -68,19 +66,14 @@ class MjpegCamera(Camera):
         with closing(self.camera_stream()) as response:
             return process_response(response)
 
-    def mjpeg_stream(self, handler):
+    def mjpeg_stream(self, response):
         """Generate an HTTP MJPEG stream from the camera."""
-        response = self.camera_stream()
-        content_type = response.headers[CONTENT_TYPE_HEADER]
-
-        handler.send_response(HTTP_OK)
-        handler.send_header(CONTENT_TYPE_HEADER, content_type)
-        handler.end_headers()
-
-        for chunk in response.iter_content(chunk_size=1024):
-            if not chunk:
-                break
-            handler.wfile.write(chunk)
+        stream = self.camera_stream()
+        return response(
+            stream.iter_content(chunk_size=1024),
+            mimetype=stream.headers[CONTENT_TYPE_HEADER],
+            direct_passthrough=True
+        )
 
     @property
     def name(self):

homeassistant/components/camera/netatmo.py

@@ -0,0 +1,104 @@
+"""
+Support for the Netatmo Welcome camera.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.netatmo/
+"""
+import logging
+from datetime import timedelta
+import requests
+from homeassistant.util import Throttle
+
+from homeassistant.components.camera import Camera
+from homeassistant.loader import get_component
+
+DEPENDENCIES = ["netatmo"]
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_HOME = 'home'
+ATTR_CAMERAS = 'cameras'
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=10)
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """Setup access to Netatmo Welcome cameras."""
+    netatmo = get_component('netatmo')
+    home = config.get(CONF_HOME, None)
+    data = WelcomeData(netatmo.NETATMO_AUTH, home)
+
+    for camera_name in data.get_camera_names():
+        if ATTR_CAMERAS in config:
+            if camera_name not in config[ATTR_CAMERAS]:
+                continue
+        add_devices_callback([WelcomeCamera(data, camera_name, home)])
+
+
+class WelcomeCamera(Camera):
+    """Representation of the images published from Welcome camera."""
+
+    def __init__(self, data, camera_name, home):
+        """Setup for access to the BloomSky camera images."""
+        super(WelcomeCamera, self).__init__()
+        self._data = data
+        self._camera_name = camera_name
+        if home:
+            self._name = home + ' / ' + camera_name
+        else:
+            self._name = camera_name
+        self._vpnurl, self._localurl = self._data.welcomedata.cameraUrls(
+            camera=camera_name
+            )
+
+    def camera_image(self):
+        """Return a still image response from the camera."""
+        try:
+            if self._localurl:
+                response = requests.get('{0}/live/snapshot_720.jpg'.format(
+                    self._localurl), timeout=10)
+            else:
+                response = requests.get('{0}/live/snapshot_720.jpg'.format(
+                    self._vpnurl), timeout=10)
+        except requests.exceptions.RequestException as error:
+            _LOGGER.error('Welcome VPN url changed: %s', error)
+            self._data.update()
+            (self._vpnurl, self._localurl) = \
+                self._data.welcomedata.cameraUrls(camera=self._camera_name)
+            return None
+        return response.content
+
+    @property
+    def name(self):
+        """Return the name of this Netatmo Welcome device."""
+        return self._name
+
+
+class WelcomeData(object):
+    """Get the latest data from NetAtmo."""
+
+    def __init__(self, auth, home=None):
+        """Initialize the data object."""
+        self.auth = auth
+        self.welcomedata = None
+        self.camera_names = []
+        self.home = home
+
+    def get_camera_names(self):
+        """Return all module available on the API as a list."""
+        self.update()
+        if not self.home:
+            for home in self.welcomedata.cameras.keys():
+                for camera in self.welcomedata.cameras[home].values():
+                    self.camera_names.append(camera['name'])
+        else:
+            for camera in self.welcomedata.cameras[self.home].values():
+                self.camera_names.append(camera['name'])
+        return self.camera_names
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Call the NetAtmo API to update the data."""
+        import lnetatmo
+        self.welcomedata = lnetatmo.WelcomeData(self.auth)

homeassistant/components/camera/rpi_camera.py

@@ -1,5 +1,9 @@
-"""Camera platform that has a Raspberry Pi camera."""
+"""
+Camera platform that has a Raspberry Pi camera.
 
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.rpi_camera/
+"""
 import os
 import subprocess
 import logging
@@ -43,7 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class RaspberryCamera(Camera):
-    """Raspberry Pi camera."""
+    """Representation of a Raspberry Pi camera."""
 
     def __init__(self, device_info):
         """Initialize Raspberry Pi camera component."""

homeassistant/components/camera/uvc.py

@@ -12,7 +12,7 @@ import requests
 from homeassistant.components.camera import DOMAIN, Camera
 from homeassistant.helpers import validate_config
 
-REQUIREMENTS = ['uvcclient==0.8']
+REQUIREMENTS = ['uvcclient==0.9.0']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -45,13 +45,15 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         _LOGGER.error('Unable to connect to NVR: %s', str(ex))
         return False
 
+    identifier = nvrconn.server_version >= (3, 2, 0) and 'id' or '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['uuid'])['model']]
+    cameras = [
+        camera for camera in cameras
+        if 'airCam' not in nvrconn.get_camera(camera[identifier])['model']]
 
     add_devices([UnifiVideoCamera(nvrconn,
-                                  camera['uuid'],
+                                  camera[identifier],
                                   camera['name'])
                  for camera in cameras])
     return True
@@ -110,12 +112,17 @@ class UnifiVideoCamera(Camera):
                           dict(name=self._name))
             password = 'ubnt'
 
+        if self._nvr.server_version >= (3, 2, 0):
+            client_cls = uvc_camera.UVCCameraClientV320
+        else:
+            client_cls = uvc_camera.UVCCameraClient
+
         camera = None
         for addr in addrs:
             try:
-                camera = uvc_camera.UVCCameraClient(addr,
-                                                    caminfo['username'],
-                                                    password)
+                camera = client_cls(addr,
+                                    caminfo['username'],
+                                    password)
                 camera.login()
                 _LOGGER.debug('Logged into UVC camera %(name)s via %(addr)s',
                               dict(name=self._name, addr=addr))

homeassistant/components/configurator.py

@@ -8,7 +8,7 @@ the user has submitted configuration information.
 """
 import logging
 
-from homeassistant.const import EVENT_TIME_CHANGED
+from homeassistant.const import EVENT_TIME_CHANGED, ATTR_FRIENDLY_NAME
 from homeassistant.helpers.entity import generate_entity_id
 
 DOMAIN = "configurator"
@@ -19,6 +19,8 @@ SERVICE_CONFIGURE = "configure"
 STATE_CONFIGURE = "configure"
 STATE_CONFIGURED = "configured"
 
+ATTR_LINK_NAME = "link_name"
+ATTR_LINK_URL = "link_url"
 ATTR_CONFIGURE_ID = "configure_id"
 ATTR_DESCRIPTION = "description"
 ATTR_DESCRIPTION_IMAGE = "description_image"
@@ -34,7 +36,7 @@ _LOGGER = logging.getLogger(__name__)
 # pylint: disable=too-many-arguments
 def request_config(
         hass, name, callback, description=None, description_image=None,
-        submit_caption=None, fields=None):
+        submit_caption=None, fields=None, link_name=None, link_url=None):
     """Create a new request for configuration.
 
     Will return an ID to be used for sequent calls.
@@ -43,7 +45,8 @@ def request_config(
 
     request_id = instance.request_config(
         name, callback,
-        description, description_image, submit_caption, fields)
+        description, description_image, submit_caption,
+        fields, link_name, link_url)
 
     _REQUESTS[request_id] = instance
 
@@ -100,7 +103,8 @@ class Configurator(object):
     # pylint: disable=too-many-arguments
     def request_config(
             self, name, callback,
-            description, description_image, submit_caption, fields):
+            description, description_image, submit_caption,
+            fields, link_name, link_url):
         """Setup a request for configuration."""
         entity_id = generate_entity_id(ENTITY_ID_FORMAT, name, hass=self.hass)
 
@@ -114,6 +118,7 @@ class Configurator(object):
         data = {
             ATTR_CONFIGURE_ID: request_id,
             ATTR_FIELDS: fields,
+            ATTR_FRIENDLY_NAME: name,
         }
 
         data.update({
@@ -121,6 +126,8 @@ class Configurator(object):
                 (ATTR_DESCRIPTION, description),
                 (ATTR_DESCRIPTION_IMAGE, description_image),
                 (ATTR_SUBMIT_CAPTION, submit_caption),
+                (ATTR_LINK_NAME, link_name),
+                (ATTR_LINK_URL, link_url),
             ] if value is not None
         })
 

homeassistant/components/conversation.py

@@ -27,7 +27,7 @@ SERVICE_PROCESS_SCHEMA = vol.Schema({
 
 REGEX_TURN_COMMAND = re.compile(r'turn (?P<name>(?: |\w)+) (?P<command>\w+)')
 
-REQUIREMENTS = ['fuzzywuzzy==0.8.0']
+REQUIREMENTS = ['fuzzywuzzy==0.10.0']
 
 
 def setup(hass, config):

homeassistant/components/demo.py

@@ -21,6 +21,7 @@ COMPONENTS_WITH_DEMO_PLATFORM = [
     'camera',
     'device_tracker',
     'garage_door',
+    'hvac',
     'light',
     'lock',
     'media_player',
@@ -36,6 +37,7 @@ def setup(hass, config):
     """Setup a demo environment."""
     group = loader.get_component('group')
     configurator = loader.get_component('configurator')
+    persistent_notification = loader.get_component('persistent_notification')
 
     config.setdefault(ha.DOMAIN, {})
     config.setdefault(DOMAIN, {})
@@ -58,6 +60,11 @@ def setup(hass, config):
         demo_config[component] = {CONF_PLATFORM: 'demo'}
         bootstrap.setup_component(hass, component, demo_config)
 
+    # Setup example persistent notification
+    persistent_notification.create(
+        hass, 'This is an example of a persistent notification.',
+        title='Example Notification')
+
     # Setup room groups
     lights = sorted(hass.states.entity_ids('light'))
     switches = sorted(hass.states.entity_ids('switch'))
@@ -66,7 +73,9 @@ def setup(hass, config):
         lights[1], switches[0], 'input_select.living_room_preset',
         'rollershutter.living_room_window', media_players[1],
         'scene.romantic_lights'])
-    group.Group(hass, 'bedroom', [lights[0], switches[1], media_players[0]])
+    group.Group(hass, 'bedroom', [
+        lights[0], switches[1], media_players[0],
+        'input_slider.noise_allowance'])
     group.Group(hass, 'kitchen', [
         lights[2], 'rollershutter.kitchen_window', 'lock.kitchen_door'])
     group.Group(hass, 'doors', [
@@ -144,6 +153,17 @@ def setup(hass, config):
         {'input_boolean': {'notify': {'icon': 'mdi:car',
                                       'initial': False,
                                       'name': 'Notify Anne Therese is home'}}})
+
+    # Set up input boolean
+    bootstrap.setup_component(
+        hass, 'input_slider',
+        {'input_slider': {
+            'noise_allowance': {'icon': 'mdi:bell-ring',
+                                'min': 0,
+                                'max': 10,
+                                'name': 'Allowed Noise',
+                                'unit_of_measurement': 'dB'}}})
+
     # Set up weblink
     bootstrap.setup_component(
         hass, 'weblink',

homeassistant/components/device_tracker/__init__.py

@@ -12,12 +12,13 @@ import os
 import threading
 
 from homeassistant.bootstrap import prepare_setup_platform
-from homeassistant.components import discovery, group, zone
+from homeassistant.components import group, zone
+from homeassistant.components.discovery import SERVICE_NETGEAR
 from homeassistant.config import load_yaml_config_file
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_per_platform
+from homeassistant.helpers import config_per_platform, discovery
 from homeassistant.helpers.entity import Entity
-from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
+import homeassistant.helpers.config_validation as cv
 import homeassistant.util as util
 import homeassistant.util.dt as dt_util
 
@@ -26,6 +27,7 @@ from homeassistant.const import (
     ATTR_GPS_ACCURACY, ATTR_LATITUDE, ATTR_LONGITUDE,
     DEVICE_DEFAULT_NAME, STATE_HOME, STATE_NOT_HOME)
 
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA
 DOMAIN = "device_tracker"
 DEPENDENCIES = ['zone']
 
@@ -61,7 +63,7 @@ ATTR_GPS = 'gps'
 ATTR_BATTERY = 'battery'
 
 DISCOVERY_PLATFORMS = {
-    discovery.SERVICE_NETGEAR: 'netgear',
+    SERVICE_NETGEAR: 'netgear',
 }
 _LOGGER = logging.getLogger(__name__)
 
@@ -94,8 +96,11 @@ def setup(hass, config):
     yaml_path = hass.config.path(YAML_DEVICES)
 
     conf = config.get(DOMAIN, {})
-    if isinstance(conf, list) and len(conf) > 0:
-        conf = conf[0]
+
+    # Config can be an empty list. In that case, substitute a dict
+    if isinstance(conf, list):
+        conf = conf[0] if len(conf) > 0 else {}
+
     consider_home = timedelta(
         seconds=util.convert(conf.get(CONF_CONSIDER_HOME), int,
                              DEFAULT_CONSIDER_HOME))
@@ -193,7 +198,7 @@ class DeviceTracker(object):
                 if not device:
                     dev_id = util.slugify(host_name or '') or util.slugify(mac)
             else:
-                dev_id = str(dev_id).lower()
+                dev_id = cv.slug(str(dev_id).lower())
                 device = self.devices.get(dev_id)
 
             if device:

homeassistant/components/device_tracker/asuswrt.py

@@ -6,8 +6,10 @@ https://home-assistant.io/components/device_tracker.asuswrt/
 """
 import logging
 import re
+import socket
 import telnetlib
 import threading
+from collections import namedtuple
 from datetime import timedelta
 
 from homeassistant.components.device_tracker import DOMAIN
@@ -19,13 +21,31 @@ from homeassistant.util import Throttle
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 _LOGGER = logging.getLogger(__name__)
+REQUIREMENTS = ['pexpect==4.0.1']
 
+_LEASES_CMD = 'cat /var/lib/misc/dnsmasq.leases'
 _LEASES_REGEX = re.compile(
     r'\w+\s' +
     r'(?P<mac>(([0-9a-f]{2}[:-]){5}([0-9a-f]{2})))\s' +
     r'(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\s' +
     r'(?P<host>([^\s]+))')
 
+# command to get both 5GHz and 2.4GHz clients
+_WL_CMD = '{ wl -i eth2 assoclist & wl -i eth1 assoclist ; }'
+_WL_REGEX = re.compile(
+    r'\w+\s' +
+    r'(?P<mac>(([0-9A-F]{2}[:-]){5}([0-9A-F]{2})))')
+
+_ARP_CMD = 'arp -n'
+_ARP_REGEX = re.compile(
+    r'.+\s' +
+    r'\((?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\)\s' +
+    r'.+\s' +
+    r'(?P<mac>(([0-9a-f]{2}[:-]){5}([0-9a-f]{2})))' +
+    r'\s' +
+    r'.*')
+
+_IP_NEIGH_CMD = 'ip neigh'
 _IP_NEIGH_REGEX = re.compile(
     r'(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\s' +
     r'\w+\s' +
@@ -38,23 +58,35 @@ _IP_NEIGH_REGEX = re.compile(
 def get_scanner(hass, config):
     """Validate the configuration and return an ASUS-WRT scanner."""
     if not validate_config(config,
-                           {DOMAIN: [CONF_HOST, CONF_USERNAME, CONF_PASSWORD]},
+                           {DOMAIN: [CONF_HOST, CONF_USERNAME]},
                            _LOGGER):
         return None
+    elif CONF_PASSWORD not in config[DOMAIN] and \
+            'pub_key' not in config[DOMAIN]:
+        _LOGGER.error("Either a public key or password must be provided")
+        return None
 
     scanner = AsusWrtDeviceScanner(config[DOMAIN])
 
     return scanner if scanner.success_init else None
 
+AsusWrtResult = namedtuple('AsusWrtResult', 'neighbors leases arp')
+
 
 class AsusWrtDeviceScanner(object):
     """This class queries a router running ASUSWRT firmware."""
 
+    # pylint: disable=too-many-instance-attributes, too-many-branches
+    # Eighth attribute needed for mode (AP mode vs router mode)
+
     def __init__(self, config):
         """Initialize the scanner."""
         self.host = config[CONF_HOST]
         self.username = str(config[CONF_USERNAME])
-        self.password = str(config[CONF_PASSWORD])
+        self.password = str(config.get(CONF_PASSWORD, ""))
+        self.pub_key = str(config.get('pub_key', ""))
+        self.protocol = config.get('protocol')
+        self.mode = config.get('mode')
 
         self.lock = threading.Lock()
 
@@ -100,8 +132,45 @@ class AsusWrtDeviceScanner(object):
             self.last_results = active_clients
             return True
 
-    def get_asuswrt_data(self):
-        """Retrieve data from ASUSWRT and return parsed result."""
+    def ssh_connection(self):
+        """Retrieve data from ASUSWRT via the ssh protocol."""
+        from pexpect import pxssh, exceptions
+
+        try:
+            ssh = pxssh.pxssh()
+            if self.pub_key:
+                ssh.login(self.host, self.username, ssh_key=self.pub_key)
+            elif self.password:
+                ssh.login(self.host, self.username, self.password)
+            else:
+                _LOGGER.error('No password or public key specified')
+                return None
+            ssh.sendline(_IP_NEIGH_CMD)
+            ssh.prompt()
+            neighbors = ssh.before.split(b'\n')[1:-1]
+            if self.mode == 'ap':
+                ssh.sendline(_ARP_CMD)
+                ssh.prompt()
+                arp_result = ssh.before.split(b'\n')[1:-1]
+                ssh.sendline(_WL_CMD)
+                ssh.prompt()
+                leases_result = ssh.before.split(b'\n')[1:-1]
+            else:
+                arp_result = ['']
+                ssh.sendline(_LEASES_CMD)
+                ssh.prompt()
+                leases_result = ssh.before.split(b'\n')[1:-1]
+            ssh.logout()
+            return AsusWrtResult(neighbors, leases_result, arp_result)
+        except pxssh.ExceptionPxssh as exc:
+            _LOGGER.error('Unexpected response from router: %s', exc)
+            return None
+        except exceptions.EOF:
+            _LOGGER.error('Connection refused or no route to host')
+            return None
+
+    def telnet_connection(self):
+        """Retrieve data from ASUSWRT via the telnet protocol."""
         try:
             telnet = telnetlib.Telnet(self.host)
             telnet.read_until(b'login: ')
@@ -109,41 +178,101 @@ class AsusWrtDeviceScanner(object):
             telnet.read_until(b'Password: ')
             telnet.write((self.password + '\n').encode('ascii'))
             prompt_string = telnet.read_until(b'#').split(b'\n')[-1]
-            telnet.write('ip neigh\n'.encode('ascii'))
+            telnet.write('{}\n'.format(_IP_NEIGH_CMD).encode('ascii'))
             neighbors = telnet.read_until(prompt_string).split(b'\n')[1:-1]
-            telnet.write('cat /var/lib/misc/dnsmasq.leases\n'.encode('ascii'))
-            leases_result = telnet.read_until(prompt_string).split(b'\n')[1:-1]
+            if self.mode == 'ap':
+                telnet.write('{}\n'.format(_ARP_CMD).encode('ascii'))
+                arp_result = (telnet.read_until(prompt_string).
+                              split(b'\n')[1:-1])
+                telnet.write('{}\n'.format(_WL_CMD).encode('ascii'))
+                leases_result = (telnet.read_until(prompt_string).
+                                 split(b'\n')[1:-1])
+            else:
+                arp_result = ['']
+                telnet.write('{}\n'.format(_LEASES_CMD).encode('ascii'))
+                leases_result = (telnet.read_until(prompt_string).
+                                 split(b'\n')[1:-1])
             telnet.write('exit\n'.encode('ascii'))
+            return AsusWrtResult(neighbors, leases_result, arp_result)
         except EOFError:
-            _LOGGER.exception("Unexpected response from router")
-            return
+            _LOGGER.error("Unexpected response from router")
+            return None
         except ConnectionRefusedError:
-            _LOGGER.exception("Connection refused by router," +
-                              " is telnet enabled?")
-            return
+            _LOGGER.error("Connection refused by router, is telnet enabled?")
+            return None
+        except socket.gaierror as exc:
+            _LOGGER.error("Socket exception: %s", exc)
+            return None
+        except OSError as exc:
+            _LOGGER.error("OSError: %s", exc)
+            return None
+
+    def get_asuswrt_data(self):
+        """Retrieve data from ASUSWRT and return parsed result."""
+        if self.protocol == 'ssh':
+            result = self.ssh_connection()
+        elif self.protocol == 'telnet':
+            result = self.telnet_connection()
+        else:
+            # autodetect protocol
+            result = self.ssh_connection()
+            if result:
+                self.protocol = 'ssh'
+            else:
+                result = self.telnet_connection()
+                if result:
+                    self.protocol = 'telnet'
+
+        if not result:
+            return {}
 
         devices = {}
-        for lease in leases_result:
-            match = _LEASES_REGEX.search(lease.decode('utf-8'))
+        if self.mode == 'ap':
+            for lease in result.leases:
+                match = _WL_REGEX.search(lease.decode('utf-8'))
 
-            if not match:
-                _LOGGER.warning("Could not parse lease row: %s", lease)
-                continue
+                if not match:
+                    _LOGGER.warning("Could not parse wl row: %s", lease)
+                    continue
 
-            # For leases where the client doesn't set a hostname, ensure it is
-            # blank and not '*', which breaks the entity_id down the line.
-            host = match.group('host')
-            if host == '*':
                 host = ''
 
-            devices[match.group('ip')] = {
-                'host': host,
-                'status': '',
-                'ip': match.group('ip'),
-                'mac': match.group('mac').upper(),
-                }
+                # match mac addresses to IP addresses in ARP table
+                for arp in result.arp:
+                    if match.group('mac').lower() in arp.decode('utf-8'):
+                        arp_match = _ARP_REGEX.search(arp.decode('utf-8'))
+                        if not arp_match:
+                            _LOGGER.warning("Could not parse arp row: %s", arp)
+                            continue
 
-        for neighbor in neighbors:
+                        devices[arp_match.group('ip')] = {
+                            'host': host,
+                            'status': '',
+                            'ip': arp_match.group('ip'),
+                            'mac': match.group('mac').upper(),
+                            }
+        else:
+            for lease in result.leases:
+                match = _LEASES_REGEX.search(lease.decode('utf-8'))
+
+                if not match:
+                    _LOGGER.warning("Could not parse lease row: %s", lease)
+                    continue
+
+                # For leases where the client doesn't set a hostname, ensure it
+                # is blank and not '*', which breaks entity_id down the line.
+                host = match.group('host')
+                if host == '*':
+                    host = ''
+
+                devices[match.group('ip')] = {
+                    'host': host,
+                    'status': '',
+                    'ip': match.group('ip'),
+                    'mac': match.group('mac').upper(),
+                    }
+
+        for neighbor in result.neighbors:
             match = _IP_NEIGH_REGEX.search(neighbor.decode('utf-8'))
             if not match:
                 _LOGGER.warning("Could not parse neighbor row: %s", neighbor)

homeassistant/components/device_tracker/bt_home_hub_5.py

@@ -0,0 +1,141 @@
+"""
+Support for BT Home Hub 5.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.bt_home_hub_5/
+"""
+import logging
+import re
+import threading
+from datetime import timedelta
+import xml.etree.ElementTree as ET
+import json
+from urllib.parse import unquote
+
+import requests
+
+from homeassistant.helpers import validate_config
+from homeassistant.components.device_tracker import DOMAIN
+from homeassistant.const import CONF_HOST
+from homeassistant.util import Throttle
+
+# Return cached results if last scan was less then this time ago.
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
+
+_LOGGER = logging.getLogger(__name__)
+
+_MAC_REGEX = re.compile(r'(([0-9A-Fa-f]{1,2}\:){5}[0-9A-Fa-f]{1,2})')
+
+
+# pylint: disable=unused-argument
+def get_scanner(hass, config):
+    """Return a BT Home Hub 5 scanner if successful."""
+    if not validate_config(config,
+                           {DOMAIN: [CONF_HOST]},
+                           _LOGGER):
+        return None
+    scanner = BTHomeHub5DeviceScanner(config[DOMAIN])
+
+    return scanner if scanner.success_init else None
+
+
+class BTHomeHub5DeviceScanner(object):
+    """This class queries a BT Home Hub 5."""
+
+    def __init__(self, config):
+        """Initialise the scanner."""
+        _LOGGER.info("Initialising BT Home Hub 5")
+        self.host = config.get(CONF_HOST, '192.168.1.254')
+
+        self.lock = threading.Lock()
+
+        self.last_results = {}
+
+        self.url = 'http://{}/nonAuth/home_status.xml'.format(self.host)
+
+        # Test the router is accessible
+        data = _get_homehub_data(self.url)
+        self.success_init = data is not None
+
+    def scan_devices(self):
+        """Scan for new devices and return a list with found device IDs."""
+        self._update_info()
+
+        return (device for device in self.last_results)
+
+    def get_device_name(self, device):
+        """Return the name of the given device or None if we don't know."""
+        with self.lock:
+            # If not initialised and not already scanned and not found.
+            if device not in self.last_results:
+                self._update_info()
+
+                if not self.last_results:
+                    return None
+
+            return self.last_results.get(device)
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """Ensure the information from the BT Home Hub 5 is up to date.
+
+        Return boolean if scanning successful.
+        """
+        if not self.success_init:
+            return False
+
+        with self.lock:
+            _LOGGER.info("Scanning")
+
+            data = _get_homehub_data(self.url)
+
+            if not data:
+                _LOGGER.warning('Error scanning devices')
+                return False
+
+            self.last_results = data
+
+            return True
+
+
+def _get_homehub_data(url):
+    """Retrieve data from BT Home Hub 5 and return parsed result."""
+    try:
+        response = requests.get(url, timeout=5)
+    except requests.exceptions.Timeout:
+        _LOGGER.exception("Connection to the router timed out")
+        return
+    if response.status_code == 200:
+        return _parse_homehub_response(response.text)
+    else:
+        _LOGGER.error("Invalid response from Home Hub: %s", response)
+
+
+def _parse_homehub_response(data_str):
+    """Parse the BT Home Hub 5 data format."""
+    root = ET.fromstring(data_str)
+
+    dirty_json = root.find('known_device_list').get('value')
+
+    # Normalise the JavaScript data to JSON.
+    clean_json = unquote(dirty_json.replace('\'', '\"')
+                         .replace('{', '{\"')
+                         .replace(':\"', '\":\"')
+                         .replace('\",', '\",\"'))
+
+    known_devices = [x for x in json.loads(clean_json) if x]
+
+    devices = {}
+
+    for device in known_devices:
+        name = device.get('name')
+        mac = device.get('mac')
+
+        if _MAC_REGEX.match(mac) or ',' in mac:
+            for mac_addr in mac.split(','):
+                if _MAC_REGEX.match(mac_addr):
+                    devices[mac_addr] = name
+        else:
+            devices[mac] = name
+
+    return devices

homeassistant/components/device_tracker/icloud.py

@@ -12,7 +12,7 @@ from homeassistant.helpers.event import track_utc_time_change
 
 _LOGGER = logging.getLogger(__name__)
 
-REQUIREMENTS = ['pyicloud==0.7.2']
+REQUIREMENTS = ['pyicloud==0.8.3']
 
 CONF_INTERVAL = 'interval'
 DEFAULT_INTERVAL = 8

homeassistant/components/device_tracker/locative.py

@@ -5,95 +5,92 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.locative/
 """
 import logging
-from functools import partial
 
 from homeassistant.components.device_tracker import DOMAIN
 from homeassistant.const import HTTP_UNPROCESSABLE_ENTITY, STATE_NOT_HOME
+from homeassistant.components.http import HomeAssistantView
 
 _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['http']
 
-URL_API_LOCATIVE_ENDPOINT = "/api/locative"
-
 
 def setup_scanner(hass, config, see):
     """Setup an endpoint for the Locative application."""
-    # POST would be semantically better, but that currently does not work
-    # since Locative sends the data as key1=value1&key2=value2
-    # in the request body, while Home Assistant expects json there.
-    hass.http.register_path(
-        'GET', URL_API_LOCATIVE_ENDPOINT,
-        partial(_handle_get_api_locative, hass, see))
+    hass.wsgi.register_view(LocativeView(hass, see))
 
     return True
 
 
-def _handle_get_api_locative(hass, see, handler, path_match, data):
-    """Locative message received."""
-    if not _check_data(handler, data):
-        return
+class LocativeView(HomeAssistantView):
+    """View to handle locative requests."""
 
-    device = data['device'].replace('-', '')
-    location_name = data['id'].lower()
-    direction = data['trigger']
+    url = "/api/locative"
+    name = "api:locative"
 
-    if direction == 'enter':
-        see(dev_id=device, location_name=location_name)
-        handler.write_text("Setting location to {}".format(location_name))
+    def __init__(self, hass, see):
+        """Initialize Locative url endpoints."""
+        super().__init__(hass)
+        self.see = see
 
-    elif direction == 'exit':
-        current_state = hass.states.get("{}.{}".format(DOMAIN, device))
+    def get(self, request):
+        """Locative message received as GET."""
+        return self.post(request)
+
+    def post(self, request):
+        """Locative message received."""
+        # pylint: disable=too-many-return-statements
+        data = request.values
+
+        if 'latitude' not in data or 'longitude' not in data:
+            return ("Latitude and longitude not specified.",
+                    HTTP_UNPROCESSABLE_ENTITY)
+
+        if 'device' not in data:
+            _LOGGER.error("Device id not specified.")
+            return ("Device id not specified.",
+                    HTTP_UNPROCESSABLE_ENTITY)
+
+        if 'id' not in data:
+            _LOGGER.error("Location id not specified.")
+            return ("Location id not specified.",
+                    HTTP_UNPROCESSABLE_ENTITY)
+
+        if 'trigger' not in data:
+            _LOGGER.error("Trigger is not specified.")
+            return ("Trigger is not specified.",
+                    HTTP_UNPROCESSABLE_ENTITY)
+
+        device = data['device'].replace('-', '')
+        location_name = data['id'].lower()
+        direction = data['trigger']
+
+        if direction == 'enter':
+            self.see(dev_id=device, location_name=location_name)
+            return "Setting location to {}".format(location_name)
+
+        elif direction == 'exit':
+            current_state = self.hass.states.get(
+                "{}.{}".format(DOMAIN, device))
+
+            if current_state is None or current_state.state == location_name:
+                self.see(dev_id=device, location_name=STATE_NOT_HOME)
+                return "Setting location to not home"
+            else:
+                # Ignore the message if it is telling us to exit a zone that we
+                # aren't currently in. This occurs when a zone is entered
+                # before the previous zone was exited. The enter message will
+                # be sent first, then the exit message will be sent second.
+                return 'Ignoring exit from {} (already in {})'.format(
+                    location_name, current_state)
+
+        elif direction == 'test':
+            # In the app, a test message can be sent. Just return something to
+            # the user to let them know that it works.
+            return "Received test message."
 
-        if current_state is None or current_state.state == location_name:
-            see(dev_id=device, location_name=STATE_NOT_HOME)
-            handler.write_text("Setting location to not home")
         else:
-            # Ignore the message if it is telling us to exit a zone that we
-            # aren't currently in. This occurs when a zone is entered before
-            # the previous zone was exited. The enter message will be sent
-            # first, then the exit message will be sent second.
-            handler.write_text(
-                'Ignoring exit from {} (already in {})'.format(
-                    location_name, current_state))
-
-    elif direction == 'test':
-        # In the app, a test message can be sent. Just return something to
-        # the user to let them know that it works.
-        handler.write_text("Received test message.")
-
-    else:
-        handler.write_text(
-            "Received unidentified message: {}".format(direction),
-            HTTP_UNPROCESSABLE_ENTITY)
-        _LOGGER.error("Received unidentified message from Locative: %s",
-                      direction)
-
-
-def _check_data(handler, data):
-    """Check the data."""
-    if 'latitude' not in data or 'longitude' not in data:
-        handler.write_text("Latitude and longitude not specified.",
-                           HTTP_UNPROCESSABLE_ENTITY)
-        _LOGGER.error("Latitude and longitude not specified.")
-        return False
-
-    if 'device' not in data:
-        handler.write_text("Device id not specified.",
-                           HTTP_UNPROCESSABLE_ENTITY)
-        _LOGGER.error("Device id not specified.")
-        return False
-
-    if 'id' not in data:
-        handler.write_text("Location id not specified.",
-                           HTTP_UNPROCESSABLE_ENTITY)
-        _LOGGER.error("Location id not specified.")
-        return False
-
-    if 'trigger' not in data:
-        handler.write_text("Trigger is not specified.",
-                           HTTP_UNPROCESSABLE_ENTITY)
-        _LOGGER.error("Trigger is not specified.")
-        return False
-
-    return True
+            _LOGGER.error("Received unidentified message from Locative: %s",
+                          direction)
+            return ("Received unidentified message: {}".format(direction),
+                    HTTP_UNPROCESSABLE_ENTITY)

homeassistant/components/device_tracker/owntracks.py

@@ -11,7 +11,7 @@ from collections import defaultdict
 
 import homeassistant.components.mqtt as mqtt
 from homeassistant.const import STATE_HOME
-from homeassistant.util import convert
+from homeassistant.util import convert, slugify
 
 DEPENDENCIES = ['mqtt']
 
@@ -53,6 +53,12 @@ def setup_scanner(hass, config, see):
                           'accuracy %s is not met: %s',
                           data_type, max_gps_accuracy, data)
             return None
+        if convert(data.get('acc'), float, 1.0) == 0.0:
+            _LOGGER.debug('Skipping %s update because GPS accuracy'
+                          'is zero',
+                          data_type)
+            return None
+
         return data
 
     def owntracks_location_update(topic, payload, qos):
@@ -91,7 +97,7 @@ def setup_scanner(hass, config, see):
             return
         # OwnTracks uses - at the start of a beacon zone
         # to switch on 'hold mode' - ignore this
-        location = data['desc'].lstrip("-")
+        location = slugify(data['desc'].lstrip("-"))
         if location.lower() == 'home':
             location = STATE_HOME
 
@@ -101,7 +107,7 @@ def setup_scanner(hass, config, see):
             """Execute enter event."""
             zone = hass.states.get("zone.{}".format(location))
             with LOCK:
-                if zone is None and data['t'] == 'b':
+                if zone is None and data.get('t') == 'b':
                     # Not a HA zone, and a beacon so assume mobile
                     beacons = MOBILE_BEACONS_ACTIVE[dev_id]
                     if location not in beacons:
@@ -180,7 +186,7 @@ def setup_scanner(hass, config, see):
 def _parse_see_args(topic, data):
     """Parse the OwnTracks location parameters, into the format see expects."""
     parts = topic.split('/')
-    dev_id = '{}_{}'.format(parts[1], parts[2])
+    dev_id = slugify('{}_{}'.format(parts[1], parts[2]))
     host_name = parts[1]
     kwargs = {
         'dev_id': dev_id,

homeassistant/components/device_tracker/snmp.py

@@ -18,7 +18,7 @@ from homeassistant.util import Throttle
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
 
 _LOGGER = logging.getLogger(__name__)
-REQUIREMENTS = ['pysnmp==4.2.5']
+REQUIREMENTS = ['pysnmp==4.3.2']
 
 CONF_COMMUNITY = "community"
 CONF_BASEOID = "baseoid"
@@ -72,7 +72,7 @@ class SnmpScanner(object):
 
     @Throttle(MIN_TIME_BETWEEN_SCANS)
     def _update_info(self):
-        """Ensure the information from the WAP is up to date.
+        """Ensure the information from the device is up to date.
 
         Return boolean if scanning successful.
         """
@@ -88,7 +88,7 @@ class SnmpScanner(object):
             return True
 
     def get_snmp_data(self):
-        """Fetch MAC addresses from WAP via SNMP."""
+        """Fetch MAC addresses from access point via SNMP."""
         devices = []
 
         errindication, errstatus, errindex, restable = self.snmp.nextCmd(
@@ -97,9 +97,10 @@ class SnmpScanner(object):
         if errindication:
             _LOGGER.error("SNMPLIB error: %s", errindication)
             return
+        # pylint: disable=no-member
         if errstatus:
             _LOGGER.error('SNMP error: %s at %s', errstatus.prettyPrint(),
-                          errindex and restable[-1][int(errindex)-1] or '?')
+                          errindex and restable[int(errindex) - 1][0] or '?')
             return
 
         for resrow in restable:

homeassistant/components/device_tracker/unifi.py

@@ -12,7 +12,8 @@ from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD
 from homeassistant.helpers import validate_config
 
 # Unifi package doesn't list urllib3 as a requirement
-REQUIREMENTS = ['urllib3', 'unifi==1.2.4']
+REQUIREMENTS = ['urllib3', 'unifi==1.2.5']
+
 _LOGGER = logging.getLogger(__name__)
 CONF_PORT = 'port'
 

homeassistant/components/discovery.py

@@ -9,70 +9,30 @@ loaded before the EVENT_PLATFORM_DISCOVERED is fired.
 import logging
 import threading
 
-from homeassistant import bootstrap
-from homeassistant.const import (
-    ATTR_DISCOVERED, ATTR_SERVICE, EVENT_HOMEASSISTANT_START,
-    EVENT_PLATFORM_DISCOVERED)
+from homeassistant.const import EVENT_HOMEASSISTANT_START
+from homeassistant.helpers.discovery import load_platform, discover
 
 DOMAIN = "discovery"
-REQUIREMENTS = ['netdisco==0.6.4']
+REQUIREMENTS = ['netdisco==0.6.7']
 
 SCAN_INTERVAL = 300  # seconds
 
 SERVICE_WEMO = 'belkin_wemo'
-SERVICE_HUE = 'philips_hue'
-SERVICE_CAST = 'google_cast'
 SERVICE_NETGEAR = 'netgear_router'
-SERVICE_SONOS = 'sonos'
-SERVICE_PLEX = 'plex_mediaserver'
-SERVICE_SQUEEZEBOX = 'logitech_mediaserver'
-SERVICE_PANASONIC_VIERA = 'panasonic_viera'
 
 SERVICE_HANDLERS = {
-    SERVICE_WEMO: "wemo",
-    SERVICE_CAST: "media_player",
-    SERVICE_HUE: "light",
-    SERVICE_NETGEAR: 'device_tracker',
-    SERVICE_SONOS: 'media_player',
-    SERVICE_PLEX: 'media_player',
-    SERVICE_SQUEEZEBOX: 'media_player',
-    SERVICE_PANASONIC_VIERA: 'media_player',
+    SERVICE_NETGEAR: ('device_tracker', None),
+    SERVICE_WEMO: ('wemo', None),
+    'philips_hue': ('light', 'hue'),
+    'google_cast': ('media_player', 'cast'),
+    'panasonic_viera': ('media_player', 'panasonic_viera'),
+    'plex_mediaserver': ('media_player', 'plex'),
+    'roku': ('media_player', 'roku'),
+    'sonos': ('media_player', 'sonos'),
+    'logitech_mediaserver': ('media_player', 'squeezebox'),
 }
 
 
-def listen(hass, service, callback):
-    """Setup listener for discovery of specific service.
-
-    Service can be a string or a list/tuple.
-    """
-    if isinstance(service, str):
-        service = (service,)
-    else:
-        service = tuple(service)
-
-    def discovery_event_listener(event):
-        """Listen for discovery events."""
-        if event.data[ATTR_SERVICE] in service:
-            callback(event.data[ATTR_SERVICE], event.data.get(ATTR_DISCOVERED))
-
-    hass.bus.listen(EVENT_PLATFORM_DISCOVERED, discovery_event_listener)
-
-
-def discover(hass, service, discovered=None, component=None, hass_config=None):
-    """Fire discovery event. Can ensure a component is loaded."""
-    if component is not None:
-        bootstrap.setup_component(hass, component, hass_config)
-
-    data = {
-        ATTR_SERVICE: service
-    }
-
-    if discovered is not None:
-        data[ATTR_DISCOVERED] = discovered
-
-    hass.bus.fire(EVENT_PLATFORM_DISCOVERED, data)
-
-
 def setup(hass, config):
     """Start a discovery service."""
     logger = logging.getLogger(__name__)
@@ -89,20 +49,18 @@ def setup(hass, config):
         with lock:
             logger.info("Found new service: %s %s", service, info)
 
-            component = SERVICE_HANDLERS.get(service)
+            comp_plat = SERVICE_HANDLERS.get(service)
 
             # We do not know how to handle this service.
-            if not component:
+            if not comp_plat:
                 return
 
-            # This component cannot be setup.
-            if not bootstrap.setup_component(hass, component, config):
-                return
+            component, platform = comp_plat
 
-            hass.bus.fire(EVENT_PLATFORM_DISCOVERED, {
-                ATTR_SERVICE: service,
-                ATTR_DISCOVERED: info
-            })
+            if platform is None:
+                discover(hass, service, info, component, config)
+            else:
+                load_platform(hass, component, platform, info, config)
 
     # pylint: disable=unused-argument
     def start_discovery(event):

homeassistant/components/dweet.py

@@ -0,0 +1,73 @@
+"""
+A component which allows you to send data to Dweet.io.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/dweet/
+"""
+import logging
+from datetime import timedelta
+import voluptuous as vol
+
+from homeassistant.const import EVENT_STATE_CHANGED, STATE_UNKNOWN
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import state as state_helper
+from homeassistant.util import Throttle
+
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = "dweet"
+DEPENDENCIES = []
+
+REQUIREMENTS = ['dweepy==0.2.0']
+
+CONF_NAME = 'name'
+CONF_WHITELIST = 'whitelist'
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=1)
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_NAME): cv.string,
+        vol.Required(CONF_WHITELIST): cv.string,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+# pylint: disable=too-many-locals
+def setup(hass, config):
+    """Setup the Dweet.io component."""
+    conf = config[DOMAIN]
+    name = conf[CONF_NAME]
+    whitelist = conf.get(CONF_WHITELIST, [])
+    json_body = {}
+
+    def dweet_event_listener(event):
+        """Listen for new messages on the bus and sends them to Dweet.io."""
+        state = event.data.get('new_state')
+        if state is None or state.state in (STATE_UNKNOWN, '') \
+                or state.entity_id not in whitelist:
+            return
+
+        try:
+            _state = state_helper.state_as_number(state)
+        except ValueError:
+            _state = state.state
+
+        json_body[state.attributes.get('friendly_name')] = _state
+
+        send_data(name, json_body)
+
+    hass.bus.listen(EVENT_STATE_CHANGED, dweet_event_listener)
+
+    return True
+
+
+@Throttle(MIN_TIME_BETWEEN_UPDATES)
+def send_data(name, msg):
+    """Send the collected data to Dweet.io."""
+    import dweepy
+    try:
+        dweepy.dweet_for(name, msg)
+    except dweepy.DweepyError:
+        _LOGGER.error("Error saving data '%s' to Dweet.io", msg)

homeassistant/components/ecobee.py

@@ -8,21 +8,18 @@ import logging
 import os
 from datetime import timedelta
 
-from homeassistant import bootstrap
-from homeassistant.const import (
-    ATTR_DISCOVERED, ATTR_SERVICE, CONF_API_KEY, EVENT_PLATFORM_DISCOVERED)
+from homeassistant.helpers import discovery
+from homeassistant.const import CONF_API_KEY
 from homeassistant.loader import get_component
 from homeassistant.util import Throttle
 
 DOMAIN = "ecobee"
-DISCOVER_THERMOSTAT = "ecobee.thermostat"
-DISCOVER_SENSORS = "ecobee.sensor"
 NETWORK = None
 HOLD_TEMP = 'hold_temp'
 
 REQUIREMENTS = [
     'https://github.com/nkgilley/python-ecobee-api/archive/'
-    '92a2f330cbaf601d0618456fdd97e5a8c42c1c47.zip#python-ecobee==0.0.4']
+    '4856a704670c53afe1882178a89c209b5f98533d.zip#python-ecobee==0.0.6']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -70,23 +67,11 @@ def setup_ecobee(hass, network, config):
         configurator = get_component('configurator')
         configurator.request_done(_CONFIGURING.pop('ecobee'))
 
-    # Ensure component is loaded
-    bootstrap.setup_component(hass, 'thermostat', config)
-    bootstrap.setup_component(hass, 'sensor', config)
-
     hold_temp = config[DOMAIN].get(HOLD_TEMP, False)
 
-    # Fire thermostat discovery event
-    hass.bus.fire(EVENT_PLATFORM_DISCOVERED, {
-        ATTR_SERVICE: DISCOVER_THERMOSTAT,
-        ATTR_DISCOVERED: {'hold_temp': hold_temp}
-    })
-
-    # Fire sensor discovery event
-    hass.bus.fire(EVENT_PLATFORM_DISCOVERED, {
-        ATTR_SERVICE: DISCOVER_SENSORS,
-        ATTR_DISCOVERED: {}
-    })
+    discovery.load_platform(hass, 'thermostat', DOMAIN,
+                            {'hold_temp': hold_temp}, config)
+    discovery.load_platform(hass, 'sensor', DOMAIN, {}, config)
 
 
 # pylint: disable=too-few-public-methods

homeassistant/components/enocean.py

@@ -0,0 +1,117 @@
+"""
+EnOcean Component.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/EnOcean/
+"""
+
+DOMAIN = "enocean"
+
+REQUIREMENTS = ['enocean==0.31']
+
+CONF_DEVICE = "device"
+
+ENOCEAN_DONGLE = None
+
+
+def setup(hass, config):
+    """Setup the EnOcean component."""
+    global ENOCEAN_DONGLE
+
+    serial_dev = config[DOMAIN].get(CONF_DEVICE, "/dev/ttyUSB0")
+
+    ENOCEAN_DONGLE = EnOceanDongle(hass, serial_dev)
+    return True
+
+
+class EnOceanDongle:
+    """Representation of an EnOcean dongle."""
+
+    def __init__(self, hass, ser):
+        """Initialize the EnOcean dongle."""
+        from enocean.communicators.serialcommunicator import SerialCommunicator
+        self.__communicator = SerialCommunicator(port=ser,
+                                                 callback=self.callback)
+        self.__communicator.start()
+        self.__devices = []
+
+    def register_device(self, dev):
+        """Register another device."""
+        self.__devices.append(dev)
+
+    def send_command(self, command):
+        """Send a command from the EnOcean dongle."""
+        self.__communicator.send(command)
+
+    def _combine_hex(self, data):  # pylint: disable=no-self-use
+        """Combine list of integer values to one big integer."""
+        output = 0x00
+        for i, j in enumerate(reversed(data)):
+            output |= (j << i * 8)
+        return output
+
+    # pylint: disable=too-many-branches
+    def callback(self, temp):
+        """Callback function for EnOcean Device.
+
+        This is the callback function called by
+        python-enocan whenever there is an incoming
+        packet.
+        """
+        from enocean.protocol.packet import RadioPacket
+        if isinstance(temp, RadioPacket):
+            rxtype = None
+            value = None
+            if temp.data[6] == 0x30:
+                rxtype = "wallswitch"
+                value = 1
+            elif temp.data[6] == 0x20:
+                rxtype = "wallswitch"
+                value = 0
+            elif temp.data[4] == 0x0c:
+                rxtype = "power"
+                value = temp.data[3] + (temp.data[2] << 8)
+            elif temp.data[2] == 0x60:
+                rxtype = "switch_status"
+                if temp.data[3] == 0xe4:
+                    value = 1
+                elif temp.data[3] == 0x80:
+                    value = 0
+            elif temp.data[0] == 0xa5 and temp.data[1] == 0x02:
+                rxtype = "dimmerstatus"
+                value = temp.data[2]
+            for device in self.__devices:
+                if rxtype == "wallswitch" and device.stype == "listener":
+                    if temp.sender == self._combine_hex(device.dev_id):
+                        device.value_changed(value, temp.data[1])
+                if rxtype == "power" and device.stype == "powersensor":
+                    if temp.sender == self._combine_hex(device.dev_id):
+                        device.value_changed(value)
+                if rxtype == "power" and device.stype == "switch":
+                    if temp.sender == self._combine_hex(device.dev_id):
+                        if value > 10:
+                            device.value_changed(1)
+                if rxtype == "switch_status" and device.stype == "switch":
+                    if temp.sender == self._combine_hex(device.dev_id):
+                        device.value_changed(value)
+                if rxtype == "dimmerstatus" and device.stype == "dimmer":
+                    if temp.sender == self._combine_hex(device.dev_id):
+                        device.value_changed(value)
+
+
+# pylint: disable=too-few-public-methods
+class EnOceanDevice():
+    """Parent class for all devices associated with the EnOcean component."""
+
+    def __init__(self):
+        """Initialize the device."""
+        ENOCEAN_DONGLE.register_device(self)
+        self.stype = ""
+        self.sensorid = [0x00, 0x00, 0x00, 0x00]
+
+    # pylint: disable=no-self-use
+    def send_command(self, data, optional, packet_type):
+        """Send a command via the EnOcean dongle."""
+        from enocean.protocol.packet import Packet
+        packet = Packet(packet_type, data=data, optional=optional)
+        ENOCEAN_DONGLE.send_command(packet)

homeassistant/components/envisalink.py

@@ -0,0 +1,210 @@
+"""
+Support for Envisalink devices.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/envisalink/
+"""
+import logging
+import time
+import voluptuous as vol
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP
+from homeassistant.helpers.entity import Entity
+from homeassistant.components.discovery import load_platform
+
+REQUIREMENTS = ['pyenvisalink==1.0', 'pydispatcher==2.0.5']
+
+_LOGGER = logging.getLogger(__name__)
+DOMAIN = 'envisalink'
+
+EVL_CONTROLLER = None
+
+CONF_EVL_HOST = 'host'
+CONF_EVL_PORT = 'port'
+CONF_PANEL_TYPE = 'panel_type'
+CONF_EVL_VERSION = 'evl_version'
+CONF_CODE = 'code'
+CONF_USERNAME = 'user_name'
+CONF_PASS = 'password'
+CONF_EVL_KEEPALIVE = 'keepalive_interval'
+CONF_ZONEDUMP_INTERVAL = 'zonedump_interval'
+CONF_ZONES = 'zones'
+CONF_PARTITIONS = 'partitions'
+
+CONF_ZONENAME = 'name'
+CONF_ZONETYPE = 'type'
+CONF_PARTITIONNAME = 'name'
+
+DEFAULT_PORT = 4025
+DEFAULT_EVL_VERSION = 3
+DEFAULT_KEEPALIVE = 60
+DEFAULT_ZONEDUMP_INTERVAL = 30
+DEFAULT_ZONETYPE = 'opening'
+
+SIGNAL_ZONE_UPDATE = 'zones_updated'
+SIGNAL_PARTITION_UPDATE = 'partition_updated'
+SIGNAL_KEYPAD_UPDATE = 'keypad_updated'
+
+ZONE_SCHEMA = vol.Schema({
+    vol.Required(CONF_ZONENAME): cv.string,
+    vol.Optional(CONF_ZONETYPE, default=DEFAULT_ZONETYPE): cv.string})
+
+PARTITION_SCHEMA = vol.Schema({
+    vol.Required(CONF_PARTITIONNAME): cv.string})
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_EVL_HOST): cv.string,
+        vol.Required(CONF_PANEL_TYPE):
+            vol.All(cv.string, vol.In(['HONEYWELL', 'DSC'])),
+        vol.Required(CONF_USERNAME): cv.string,
+        vol.Required(CONF_PASS): cv.string,
+        vol.Required(CONF_CODE): cv.string,
+        vol.Optional(CONF_ZONES): {vol.Coerce(int): ZONE_SCHEMA},
+        vol.Optional(CONF_PARTITIONS): {vol.Coerce(int): PARTITION_SCHEMA},
+        vol.Optional(CONF_EVL_PORT, default=DEFAULT_PORT):
+            vol.All(vol.Coerce(int), vol.Range(min=1, max=65535)),
+        vol.Optional(CONF_EVL_VERSION, default=DEFAULT_EVL_VERSION):
+            vol.All(vol.Coerce(int), vol.Range(min=3, max=4)),
+        vol.Optional(CONF_EVL_KEEPALIVE, default=DEFAULT_KEEPALIVE):
+            vol.All(vol.Coerce(int), vol.Range(min=15)),
+        vol.Optional(CONF_ZONEDUMP_INTERVAL,
+                     default=DEFAULT_ZONEDUMP_INTERVAL):
+            vol.All(vol.Coerce(int), vol.Range(min=15)),
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+# pylint: disable=unused-argument, too-many-function-args, too-many-locals
+# pylint: disable=too-many-return-statements
+def setup(hass, base_config):
+    """Common setup for Envisalink devices."""
+    from pyenvisalink import EnvisalinkAlarmPanel
+    from pydispatch import dispatcher
+
+    global EVL_CONTROLLER
+
+    config = base_config.get(DOMAIN)
+
+    _host = config.get(CONF_EVL_HOST)
+    _port = config.get(CONF_EVL_PORT)
+    _code = config.get(CONF_CODE)
+    _panel_type = config.get(CONF_PANEL_TYPE)
+    _version = config.get(CONF_EVL_VERSION)
+    _user = config.get(CONF_USERNAME)
+    _pass = config.get(CONF_PASS)
+    _keep_alive = config.get(CONF_EVL_KEEPALIVE)
+    _zone_dump = config.get(CONF_ZONEDUMP_INTERVAL)
+    _zones = config.get(CONF_ZONES)
+    _partitions = config.get(CONF_PARTITIONS)
+    _connect_status = {}
+    EVL_CONTROLLER = EnvisalinkAlarmPanel(_host,
+                                          _port,
+                                          _panel_type,
+                                          _version,
+                                          _user,
+                                          _pass,
+                                          _zone_dump,
+                                          _keep_alive)
+
+    def login_fail_callback(data):
+        """Callback for when the evl rejects our login."""
+        _LOGGER.error("The envisalink rejected your credentials.")
+        _connect_status['fail'] = 1
+
+    def connection_fail_callback(data):
+        """Network failure callback."""
+        _LOGGER.error("Could not establish a connection with the envisalink.")
+        _connect_status['fail'] = 1
+
+    def connection_success_callback(data):
+        """Callback for a successful connection."""
+        _LOGGER.info("Established a connection with the envisalink.")
+        _connect_status['success'] = 1
+
+    def zones_updated_callback(data):
+        """Handle zone timer updates."""
+        _LOGGER.info("Envisalink sent a zone update event.  Updating zones...")
+        dispatcher.send(signal=SIGNAL_ZONE_UPDATE,
+                        sender=None,
+                        zone=data)
+
+    def alarm_data_updated_callback(data):
+        """Handle non-alarm based info updates."""
+        _LOGGER.info("Envisalink sent new alarm info. Updating alarms...")
+        dispatcher.send(signal=SIGNAL_KEYPAD_UPDATE,
+                        sender=None,
+                        partition=data)
+
+    def partition_updated_callback(data):
+        """Handle partition changes thrown by evl (including alarms)."""
+        _LOGGER.info("The envisalink sent a partition update event.")
+        dispatcher.send(signal=SIGNAL_PARTITION_UPDATE,
+                        sender=None,
+                        partition=data)
+
+    def stop_envisalink(event):
+        """Shutdown envisalink connection and thread on exit."""
+        _LOGGER.info("Shutting down envisalink.")
+        EVL_CONTROLLER.stop()
+
+    def start_envisalink(event):
+        """Startup process for the envisalink."""
+        EVL_CONTROLLER.start()
+        for _ in range(10):
+            if 'success' in _connect_status:
+                hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_envisalink)
+                return True
+            elif 'fail' in _connect_status:
+                return False
+            else:
+                time.sleep(1)
+
+        _LOGGER.error("Timeout occurred while establishing evl connection.")
+        return False
+
+    EVL_CONTROLLER.callback_zone_timer_dump = zones_updated_callback
+    EVL_CONTROLLER.callback_zone_state_change = zones_updated_callback
+    EVL_CONTROLLER.callback_partition_state_change = partition_updated_callback
+    EVL_CONTROLLER.callback_keypad_update = alarm_data_updated_callback
+    EVL_CONTROLLER.callback_login_failure = login_fail_callback
+    EVL_CONTROLLER.callback_login_timeout = connection_fail_callback
+    EVL_CONTROLLER.callback_login_success = connection_success_callback
+
+    _result = start_envisalink(None)
+    if not _result:
+        return False
+
+    # Load sub-components for envisalink
+    if _partitions:
+        load_platform(hass, 'alarm_control_panel', 'envisalink',
+                      {'partitions': _partitions,
+                       'code': _code}, config)
+        load_platform(hass, 'sensor', 'envisalink',
+                      {'partitions': _partitions,
+                       'code': _code}, config)
+    if _zones:
+        load_platform(hass, 'binary_sensor', 'envisalink',
+                      {'zones': _zones}, config)
+
+    return True
+
+
+class EnvisalinkDevice(Entity):
+    """Representation of an envisalink devicetity."""
+
+    def __init__(self, name, info, controller):
+        """Initialize the device."""
+        self._controller = controller
+        self._info = info
+        self._name = name
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False

homeassistant/components/feedreader.py

@@ -1,7 +1,17 @@
-"""RSS/Atom feed reader for Home Assistant."""
+"""
+Support for RSS/Atom feed.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/feedreader/
+"""
 from datetime import datetime
 from logging import getLogger
+from os.path import exists
+from threading import Lock
+import pickle
 import voluptuous as vol
+
+from homeassistant.const import EVENT_HOMEASSISTANT_START
 from homeassistant.helpers.event import track_utc_time_change
 
 REQUIREMENTS = ['feedparser==5.2.1']
@@ -14,67 +24,151 @@ CONFIG_SCHEMA = vol.Schema({
         'urls': [vol.Url()],
     }
 }, extra=vol.ALLOW_EXTRA)
+MAX_ENTRIES = 20
 
 
 # pylint: disable=too-few-public-methods
 class FeedManager(object):
     """Abstraction over feedparser module."""
 
-    def __init__(self, url, hass):
+    def __init__(self, url, hass, storage):
         """Initialize the FeedManager object, poll every hour."""
         self._url = url
         self._feed = None
         self._hass = hass
-        # Initialize last entry timestamp as epoch time
-        self._last_entry_timestamp = datetime.utcfromtimestamp(0).timetuple()
-        _LOGGER.debug('Loading feed %s', self._url)
-        self._update()
+        self._firstrun = True
+        self._storage = storage
+        self._last_entry_timestamp = None
+        self._has_published_parsed = False
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_START,
+                             lambda _: self._update())
         track_utc_time_change(hass, lambda now: self._update(),
                               minute=0, second=0)
 
     def _log_no_entries(self):
         """Send no entries log at debug level."""
-        _LOGGER.debug('No new entries in feed %s', self._url)
+        _LOGGER.debug('No new entries to be published in feed "%s"', self._url)
 
     def _update(self):
-        """Update the feed and publish new entries in the event bus."""
+        """Update the feed and publish new entries to the event bus."""
         import feedparser
-        _LOGGER.info('Fetching new data from feed %s', self._url)
+        _LOGGER.info('Fetching new data from feed "%s"', self._url)
         self._feed = feedparser.parse(self._url,
                                       etag=None if not self._feed
                                       else self._feed.get('etag'),
                                       modified=None if not self._feed
                                       else self._feed.get('modified'))
         if not self._feed:
-            _LOGGER.error('Error fetching feed data from %s', self._url)
+            _LOGGER.error('Error fetching feed data from "%s"', self._url)
         else:
             if self._feed.bozo != 0:
-                _LOGGER.error('Error parsing feed %s', self._url)
+                _LOGGER.error('Error parsing feed "%s"', self._url)
             # Using etag and modified, if there's no new data available,
             # the entries list will be empty
             elif len(self._feed.entries) > 0:
-                _LOGGER.debug('Entries available in feed %s', self._url)
+                _LOGGER.debug('%s entri(es) available in feed "%s"',
+                              len(self._feed.entries),
+                              self._url)
+                if len(self._feed.entries) > MAX_ENTRIES:
+                    _LOGGER.debug('Processing only the first %s entries '
+                                  'in feed "%s"', MAX_ENTRIES, self._url)
+                    self._feed.entries = self._feed.entries[0:MAX_ENTRIES]
                 self._publish_new_entries()
-                self._last_entry_timestamp = \
-                    self._feed.entries[0].published_parsed
+                if self._has_published_parsed:
+                    self._storage.put_timestamp(self._url,
+                                                self._last_entry_timestamp)
             else:
                 self._log_no_entries()
+        _LOGGER.info('Fetch from feed "%s" completed', self._url)
+
+    def _update_and_fire_entry(self, entry):
+        """Update last_entry_timestamp and fire entry."""
+        # We are lucky, `published_parsed` data available,
+        # let's make use of it to publish only new available
+        # entries since the last run
+        if 'published_parsed' in entry.keys():
+            self._has_published_parsed = True
+            self._last_entry_timestamp = max(entry.published_parsed,
+                                             self._last_entry_timestamp)
+        else:
+            self._has_published_parsed = False
+            _LOGGER.debug('No `published_parsed` info available '
+                          'for entry "%s"', entry.title)
+        entry.update({'feed_url': self._url})
+        self._hass.bus.fire(EVENT_FEEDREADER, entry)
 
     def _publish_new_entries(self):
         """Publish new entries to the event bus."""
         new_entries = False
+        self._last_entry_timestamp = self._storage.get_timestamp(self._url)
+        if self._last_entry_timestamp:
+            self._firstrun = False
+        else:
+            # Set last entry timestamp as epoch time if not available
+            self._last_entry_timestamp = \
+                datetime.utcfromtimestamp(0).timetuple()
         for entry in self._feed.entries:
-            # Consider only entries newer then the latest parsed one
-            if entry.published_parsed > self._last_entry_timestamp:
+            if self._firstrun or (
+                    'published_parsed' in entry.keys() and
+                    entry.published_parsed > self._last_entry_timestamp):
+                self._update_and_fire_entry(entry)
                 new_entries = True
-                entry.update({'feed_url': self._url})
-                self._hass.bus.fire(EVENT_FEEDREADER, entry)
+            else:
+                _LOGGER.debug('Entry "%s" already processed', entry.title)
         if not new_entries:
             self._log_no_entries()
+        self._firstrun = False
+
+
+class StoredData(object):
+    """Abstraction over pickle data storage."""
+
+    def __init__(self, data_file):
+        """Initialize pickle data storage."""
+        self._data_file = data_file
+        self._lock = Lock()
+        self._cache_outdated = True
+        self._data = {}
+        self._fetch_data()
+
+    def _fetch_data(self):
+        """Fetch data stored into pickle file."""
+        if self._cache_outdated and exists(self._data_file):
+            try:
+                _LOGGER.debug('Fetching data from file %s', self._data_file)
+                with self._lock, open(self._data_file, 'rb') as myfile:
+                    self._data = pickle.load(myfile) or {}
+                    self._cache_outdated = False
+            # pylint: disable=bare-except
+            except:
+                _LOGGER.error('Error loading data from pickled file %s',
+                              self._data_file)
+
+    def get_timestamp(self, url):
+        """Return stored timestamp for given url."""
+        self._fetch_data()
+        return self._data.get(url)
+
+    def put_timestamp(self, url, timestamp):
+        """Update timestamp for given url."""
+        self._fetch_data()
+        with self._lock, open(self._data_file, 'wb') as myfile:
+            self._data.update({url: timestamp})
+            _LOGGER.debug('Overwriting feed "%s" timestamp in storage file %s',
+                          url, self._data_file)
+            try:
+                pickle.dump(self._data, myfile)
+            # pylint: disable=bare-except
+            except:
+                _LOGGER.error('Error saving pickled data to %s',
+                              self._data_file)
+        self._cache_outdated = True
 
 
 def setup(hass, config):
     """Setup the feedreader component."""
     urls = config.get(DOMAIN)['urls']
-    feeds = [FeedManager(url, hass) for url in urls]
+    data_file = hass.config.path("{}.pickle".format(DOMAIN))
+    storage = StoredData(data_file)
+    feeds = [FeedManager(url, hass, storage) for url in urls]
     return len(feeds) > 0

homeassistant/components/frontend/__init__.py

@@ -1,121 +1,101 @@
 """Handle the frontend for Home Assistant."""
-import re
 import os
-import logging
 
 from . import version, mdi_version
-import homeassistant.util as util
-from homeassistant.const import URL_ROOT, HTTP_OK
 from homeassistant.components import api
+from homeassistant.components.http import HomeAssistantView
 
 DOMAIN = 'frontend'
 DEPENDENCIES = ['api']
 
-INDEX_PATH = os.path.join(os.path.dirname(__file__), 'index.html.template')
-
-_LOGGER = logging.getLogger(__name__)
-
-FRONTEND_URLS = [
-    URL_ROOT, '/logbook', '/history', '/map', '/devService', '/devState',
-    '/devEvent', '/devInfo', '/devTemplate',
-    re.compile(r'/states(/([a-zA-Z\._\-0-9/]+)|)'),
-]
-
-URL_API_BOOTSTRAP = "/api/bootstrap"
-
-_FINGERPRINT = re.compile(r'^(\w+)-[a-z0-9]{32}\.(\w+)$', re.IGNORECASE)
-
 
 def setup(hass, config):
     """Setup serving the frontend."""
-    for url in FRONTEND_URLS:
-        hass.http.register_path('GET', url, _handle_get_root, False)
+    hass.wsgi.register_view(IndexView)
+    hass.wsgi.register_view(BootstrapView)
 
-    hass.http.register_path('GET', '/service_worker.js',
-                            _handle_get_service_worker, False)
-
-    # Bootstrap API
-    hass.http.register_path(
-        'GET', URL_API_BOOTSTRAP, _handle_get_api_bootstrap)
-
-    # Static files
-    hass.http.register_path(
-        'GET', re.compile(r'/static/(?P<file>[a-zA-Z\._\-0-9/]+)'),
-        _handle_get_static, False)
-    hass.http.register_path(
-        'HEAD', re.compile(r'/static/(?P<file>[a-zA-Z\._\-0-9/]+)'),
-        _handle_get_static, False)
-    hass.http.register_path(
-        'GET', re.compile(r'/local/(?P<file>[a-zA-Z\._\-0-9/]+)'),
-        _handle_get_local, False)
-
-    return True
-
-
-def _handle_get_api_bootstrap(handler, path_match, data):
-    """Return all data needed to bootstrap Home Assistant."""
-    hass = handler.server.hass
-
-    handler.write_json({
-        'config': hass.config.as_dict(),
-        'states': hass.states.all(),
-        'events': api.events_json(hass),
-        'services': api.services_json(hass),
-    })
-
-
-def _handle_get_root(handler, path_match, data):
-    """Render the frontend."""
-    if handler.server.development:
-        app_url = "home-assistant-polymer/src/home-assistant.html"
-    else:
-        app_url = "frontend-{}.html".format(version.VERSION)
-
-    # auto login if no password was set, else check api_password param
-    auth = ('no_password_set' if handler.server.api_password is None
-            else data.get('api_password', ''))
-
-    with open(INDEX_PATH) as template_file:
-        template_html = template_file.read()
-
-    template_html = template_html.replace('{{ app_url }}', app_url)
-    template_html = template_html.replace('{{ auth }}', auth)
-    template_html = template_html.replace('{{ icons }}', mdi_version.VERSION)
-
-    handler.send_response(HTTP_OK)
-    handler.write_content(template_html.encode("UTF-8"),
-                          'text/html; charset=utf-8')
-
-
-def _handle_get_service_worker(handler, path_match, data):
-    """Return service worker for the frontend."""
-    if handler.server.development:
+    www_static_path = os.path.join(os.path.dirname(__file__), 'www_static')
+    if hass.wsgi.development:
         sw_path = "home-assistant-polymer/build/service_worker.js"
     else:
         sw_path = "service_worker.js"
 
-    handler.write_file(os.path.join(os.path.dirname(__file__), 'www_static',
-                                    sw_path))
+    hass.wsgi.register_static_path(
+        "/service_worker.js",
+        os.path.join(www_static_path, sw_path),
+        0
+    )
+    hass.wsgi.register_static_path(
+        "/robots.txt",
+        os.path.join(www_static_path, "robots.txt")
+    )
+    hass.wsgi.register_static_path("/static", www_static_path)
+    hass.wsgi.register_static_path("/local", hass.config.path('www'))
+
+    return True
 
 
-def _handle_get_static(handler, path_match, data):
-    """Return a static file for the frontend."""
-    req_file = util.sanitize_path(path_match.group('file'))
+class BootstrapView(HomeAssistantView):
+    """View to bootstrap frontend with all needed data."""
 
-    # Strip md5 hash out
-    fingerprinted = _FINGERPRINT.match(req_file)
-    if fingerprinted:
-        req_file = "{}.{}".format(*fingerprinted.groups())
+    url = "/api/bootstrap"
+    name = "api:bootstrap"
 
-    path = os.path.join(os.path.dirname(__file__), 'www_static', req_file)
-
-    handler.write_file(path)
+    def get(self, request):
+        """Return all data needed to bootstrap Home Assistant."""
+        return self.json({
+            'config': self.hass.config.as_dict(),
+            'states': self.hass.states.all(),
+            'events': api.events_json(self.hass),
+            'services': api.services_json(self.hass),
+        })
 
 
-def _handle_get_local(handler, path_match, data):
-    """Return a static file from the hass.config.path/www for the frontend."""
-    req_file = util.sanitize_path(path_match.group('file'))
+class IndexView(HomeAssistantView):
+    """Serve the frontend."""
 
-    path = handler.server.hass.config.path('www', req_file)
+    url = '/'
+    name = "frontend:index"
+    requires_auth = False
+    extra_urls = ['/logbook', '/history', '/map', '/devService', '/devState',
+                  '/devEvent', '/devInfo', '/devTemplate',
+                  '/states', '/states/<entity:entity_id>']
 
-    handler.write_file(path)
+    def __init__(self, hass):
+        """Initialize the frontend view."""
+        super().__init__(hass)
+
+        from jinja2 import FileSystemLoader, Environment
+
+        self.templates = Environment(
+            loader=FileSystemLoader(
+                os.path.join(os.path.dirname(__file__), 'templates/')
+            )
+        )
+
+    def get(self, request, entity_id=None):
+        """Serve the index view."""
+        if self.hass.wsgi.development:
+            core_url = 'home-assistant-polymer/build/_core_compiled.js'
+            ui_url = 'home-assistant-polymer/src/home-assistant.html'
+        else:
+            core_url = 'core-{}.js'.format(version.CORE)
+            ui_url = 'frontend-{}.html'.format(version.UI)
+
+        # auto login if no password was set
+        if self.hass.config.api.api_password is None:
+            auth = 'true'
+        else:
+            auth = 'false'
+
+        icons_url = 'mdi-{}.html'.format(mdi_version.VERSION)
+
+        template = self.templates.get_template('index.html')
+
+        # pylint is wrong
+        # pylint: disable=no-member
+        resp = template.render(
+            core_url=core_url, ui_url=ui_url, auth=auth,
+            icons_url=icons_url, icons=mdi_version.VERSION)
+
+        return self.Response(resp, mimetype='text/html')

homeassistant/components/frontend/index.html.template

@@ -1,51 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <title>Home Assistant</title>
-
-    <link rel='manifest' href='/static/manifest.json'>
-    <link rel='icon' href='/static/favicon.ico'>
-    <link rel='apple-touch-icon' sizes='180x180'
-          href='/static/favicon-apple-180x180.png'>
-    <meta name='apple-mobile-web-app-capable' content='yes'>
-    <meta name='mobile-web-app-capable' content='yes'>
-    <meta name='viewport' content='width=device-width, user-scalable=no'>
-    <meta name='theme-color' content='#03a9f4'>
-    <style>
-      #ha-init-skeleton {
-        display: -webkit-flex;
-        display: flex;
-        -webkit-flex-direction: column;
-        -webkit-justify-content: center;
-        -webkit-align-items: center;
-        flex-direction: column;
-        justify-content: center;
-        align-items: center;
-        text-align: center;
-        position: fixed;
-        top: 0;
-        left: 0;
-        right: 0;
-        bottom: 0;
-        margin-bottom: 123px;
-      }
-    </style>
-    <link rel='import' href='/static/{{ app_url }}' async>
-  </head>
-  <body fullbleed>
-    <div id='ha-init-skeleton'><img src='/static/favicon-192x192.png' height='192'></div>
-    <script>
-      var webComponentsSupported = ('registerElement' in document &&
-                                    'import' in document.createElement('link') &&
-                                    'content' in document.createElement('template'))
-      if (!webComponentsSupported) {
-        var script = document.createElement('script')
-        script.async = true
-        script.src = '/static/webcomponents-lite.min.js'
-        document.head.appendChild(script)
-      }
-    </script>
-    <home-assistant auth='{{ auth }}' icons='{{ icons }}'></home-assistant>
-  </body>
-</html>

homeassistant/components/frontend/mdi_version.py

@@ -1,2 +1,2 @@
 """DO NOT MODIFY. Auto-generated by update_mdi script."""
-VERSION = "af8a531f1c2e477c07c4b3394bd1ce13"
+VERSION = "9ee3d4466a65bef35c2c8974e91b37c0"

homeassistant/components/frontend/templates/index.html

@@ -0,0 +1,96 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <title>Home Assistant</title>
+
+    <link rel='manifest' href='/static/manifest.json'>
+    <link rel='icon' href='/static/favicon.ico'>
+    <link rel='apple-touch-icon' sizes='180x180'
+          href='/static/favicon-apple-180x180.png'>
+    <meta name='apple-mobile-web-app-capable' content='yes'>
+    <meta name="msapplication-square70x70logo" content="/static/tile-win-70x70.png"/>
+    <meta name="msapplication-square150x150logo" content="/static/tile-win-150x150.png"/>
+    <meta name="msapplication-wide310x150logo" content="/static/tile-win-310x150.png"/>
+    <meta name="msapplication-square310x310logo" content="/static/tile-win-310x310.png"/>
+    <meta name="msapplication-TileColor" content="#3fbbf4ff"/>
+    <meta name='mobile-web-app-capable' content='yes'>
+    <meta name='viewport' content='width=device-width, user-scalable=no'>
+    <meta name='theme-color' content='#03a9f4'>
+    <style>
+      #ha-init-skeleton {
+        display: -webkit-flex;
+        display: flex;
+        -webkit-flex-direction: column;
+        -webkit-justify-content: center;
+        -webkit-align-items: center;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+        text-align: center;
+        position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        margin-bottom: 83px;
+        font-family: Roboto, sans-serif;
+        font-size: 0pt;
+        transition: font-size 2s;
+      }
+
+      #ha-init-skeleton paper-spinner {
+        height: 28px;
+        margin-top: 16px;
+      }
+
+      #ha-init-skeleton a {
+        color: #03A9F4;
+        text-decoration: none;
+        font-weight: bold;
+      }
+
+      #ha-init-skeleton.error {
+        font-size: 16px;
+      }
+
+      #ha-init-skeleton.error img,
+      #ha-init-skeleton.error paper-spinner {
+        display: none;
+      }
+    </style>
+    <script>
+      function initError() {
+        document
+          .getElementById('ha-init-skeleton')
+          .classList.add('error');
+      }
+      window.noAuth = {{ auth }}
+    </script>
+  </head>
+  <body fullbleed>
+    <div id='ha-init-skeleton'>
+      <img src='/static/favicon-192x192.png' height='192'>
+      <paper-spinner active></paper-spinner>
+      Home Assistant had trouble<br>connecting to the server.<br><br><a href='/'>TRY AGAIN</a>
+    </div>
+    <home-assistant icons='{{ icons }}'></home-assistant>
+    {# <script src='/static/home-assistant-polymer/build/_demo_data_compiled.js'></script> #}
+    <script src='/static/{{ core_url }}'></script>
+    <link rel='import' href='/static/{{ ui_url }}' onerror='initError()' async>
+    <link rel='import' href='/static/{{ icons_url }}' async>
+    <script>
+      var webComponentsSupported = (
+        'registerElement' in document &&
+        'import' in document.createElement('link') &&
+        'content' in document.createElement('template'));
+      if (!webComponentsSupported) {
+        var script = document.createElement('script')
+        script.async = true
+        script.onerror = initError;
+        script.src = '/static/webcomponents-lite.min.js'
+        document.head.appendChild(script)
+      }
+    </script>
+  </body>
+</html>

homeassistant/components/frontend/version.py

@@ -1,2 +1,3 @@
 """DO NOT MODIFY. Auto-generated by build_frontend script."""
-VERSION = "ffd8a1bde5ba13f300c3d6ad32036526"
+CORE = "db0bb387f4d3bcace002d62b94baa348"
+UI = "5b306b7e7d36799b7b67f592cbe94703"

homeassistant/components/frontend/www_static/manifest.json

@@ -4,16 +4,27 @@
   "start_url": "/",
   "display": "standalone",
   "theme_color": "#03A9F4",
+  "background_color": "#FFFFFF",
   "icons": [
     {
      "src": "/static/favicon-192x192.png",
      "sizes": "192x192",
-     "type": "image/png",
+     "type": "image/png"
     },
     {
      "src": "/static/favicon-384x384.png",
      "sizes": "384x384",
-     "type": "image/png",
+     "type": "image/png"
+    },
+    {
+     "src": "/static/favicon-512x512.png",
+     "sizes": "512x512",
+     "type": "image/png"
+    },
+    {
+     "src": "/static/favicon-1024x1024.png",
+     "sizes": "1024x1024",
+     "type": "image/png"
     }
   ]
 }