Merge pull request #2183 from home-assistant/dev

0.21

.coveragerc

@@ -5,18 +5,21 @@ omit =
     homeassistant/__main__.py
 
     # omit pieces of code that rely on external devices being present
-    homeassistant/components/alarm_control_panel/alarmdotcom.py
-    homeassistant/components/alarm_control_panel/nx584.py
+    homeassistant/components/apcupsd.py
+    homeassistant/components/*/apcupsd.py
 
     homeassistant/components/arduino.py
     homeassistant/components/*/arduino.py
 
-    homeassistant/components/apcupsd.py
-    homeassistant/components/*/apcupsd.py
-
     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/insteon_hub.py
     homeassistant/components/*/insteon_hub.py
 
@@ -26,21 +29,40 @@ omit =
     homeassistant/components/modbus.py
     homeassistant/components/*/modbus.py
 
-    homeassistant/components/tellstick.py
-    homeassistant/components/*/tellstick.py
+    homeassistant/components/mysensors.py
+    homeassistant/components/*/mysensors.py
+
+    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
+
+    homeassistant/components/scsgate.py
+    homeassistant/components/*/scsgate.py
 
     homeassistant/components/tellduslive.py
     homeassistant/components/*/tellduslive.py
 
+    homeassistant/components/tellstick.py
+    homeassistant/components/*/tellstick.py
+
+    homeassistant/components/*/thinkingcleaner.py
+
     homeassistant/components/vera.py
     homeassistant/components/*/vera.py
 
-    homeassistant/components/ecobee.py
-    homeassistant/components/*/ecobee.py
-
     homeassistant/components/verisure.py
     homeassistant/components/*/verisure.py
 
+    homeassistant/components/*/webostv.py
+
     homeassistant/components/wemo.py
     homeassistant/components/*/wemo.py
 
@@ -53,18 +75,11 @@ omit =
     homeassistant/components/zwave.py
     homeassistant/components/*/zwave.py
 
-    homeassistant/components/mysensors.py
-    homeassistant/components/*/mysensors.py
-
-    homeassistant/components/nest.py
-    homeassistant/components/*/nest.py
-
-    homeassistant/components/rpi_gpio.py
-    homeassistant/components/*/rpi_gpio.py
-
-    homeassistant/components/scsgate.py
-    homeassistant/components/*/scsgate.py
+    homeassistant/components/enocean.py
+    homeassistant/components/*/enocean.py
 
+    homeassistant/components/alarm_control_panel/alarmdotcom.py
+    homeassistant/components/alarm_control_panel/nx584.py
     homeassistant/components/binary_sensor/arest.py
     homeassistant/components/binary_sensor/rest.py
     homeassistant/components/browser.py
@@ -76,6 +91,7 @@ omit =
     homeassistant/components/device_tracker/actiontec.py
     homeassistant/components/device_tracker/aruba.py
     homeassistant/components/device_tracker/asuswrt.py
+    homeassistant/components/device_tracker/bluetooth_tracker.py
     homeassistant/components/device_tracker/ddwrt.py
     homeassistant/components/device_tracker/fritz.py
     homeassistant/components/device_tracker/icloud.py
@@ -89,6 +105,7 @@ omit =
     homeassistant/components/device_tracker/ubus.py
     homeassistant/components/discovery.py
     homeassistant/components/downloader.py
+    homeassistant/components/feedreader.py
     homeassistant/components/garage_door/wink.py
     homeassistant/components/ifttt.py
     homeassistant/components/keyboard.py
@@ -97,23 +114,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/cast.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/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/onkyo.py
-    homeassistant/components/media_player/panasonic_viera.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/googlevoice.py
     homeassistant/components/notify/gntp.py
+    homeassistant/components/notify/googlevoice.py
     homeassistant/components/notify/instapush.py
     homeassistant/components/notify/message_bird.py
     homeassistant/components/notify/nma.py
@@ -126,6 +152,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
@@ -134,22 +161,26 @@ 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/forecast.py
     homeassistant/components/sensor/glances.py
+    homeassistant/components/sensor/google_travel_time.py
     homeassistant/components/sensor/gtfs.py
-    homeassistant/components/sensor/netatmo.py
-    homeassistant/components/sensor/nzbget.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/rest.py
     homeassistant/components/sensor/sabnzbd.py
     homeassistant/components/sensor/speedtest.py
     homeassistant/components/sensor/steam_online.py
+    homeassistant/components/sensor/supervisord.py
     homeassistant/components/sensor/swiss_public_transport.py
     homeassistant/components/sensor/systemmonitor.py
     homeassistant/components/sensor/temper.py
@@ -159,6 +190,7 @@ 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
@@ -167,12 +199,16 @@ omit =
     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
     homeassistant/components/thermostat/heatmiser.py
     homeassistant/components/thermostat/homematic.py
     homeassistant/components/thermostat/proliphix.py
     homeassistant/components/thermostat/radiotherm.py
+    homeassistant/components/upnp.py
+    homeassistant/components/zeroconf.py
 
 
 [report]

.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]).
@@ -23,6 +28,6 @@ If the code does not interact with devices:
 
 [fork]: http://stackoverflow.com/a/7244456
 [squash]: https://github.com/ginatrapani/todo.txt-android/wiki/Squash-All-Commits-Related-to-a-Single-Issue-into-a-Single-Commit
-[ex-requir]: https://github.com/balloob/home-assistant/blob/dev/homeassistant/components/keyboard.py#L16
-[ex-import]: https://github.com/balloob/home-assistant/blob/dev/homeassistant/components/keyboard.py#L51
+[ex-requir]: https://github.com/home-assistant/home-assistant/blob/dev/homeassistant/components/keyboard.py#L16
+[ex-import]: https://github.com/home-assistant/home-assistant/blob/dev/homeassistant/components/keyboard.py#L51
 

.gitignore

@@ -8,6 +8,7 @@ config/custom_components/*
 !config/custom_components/hello_world.py
 !config/custom_components/mqtt_example.py
 
+tests/config/deps
 tests/config/home-assistant.log
 
 # Hide sublime text stuff
@@ -77,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

.gitmodules

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

CONTRIBUTING.md

@@ -4,10 +4,10 @@ Everybody is invited and welcome to contribute to Home Assistant. There is a lot
 
 The process is straight-forward.
 
- - Fork the Home Assistant [git repository](https://github.com/balloob/home-assistant).
+ - Fork the Home Assistant [git repository](https://github.com/home-assistant/home-assistant).
  - Write the code for your device, notification service, sensor, or IoT thing.
  - Ensure tests work.
- - Create a Pull Request against the [**dev**](https://github.com/balloob/home-assistant/tree/dev) branch of Home Assistant.
+ - Create a Pull Request against the [**dev**](https://github.com/home-assistant/home-assistant/tree/dev) branch of Home Assistant.
 
 Still interested? Then you should read the next sections and get more details. 
 
@@ -20,20 +20,20 @@ After you finish adding support for your device:
  - Check that all dependencies are included via the `REQUIREMENTS` variable in your platform/component and only imported inside functions that use them.
  - Add any new dependencies to `requirements_all.txt` if needed. Use `script/gen_requirements_all.py`.
  - Update the `.coveragerc` file to exclude your platform if there are no tests available or your new code uses a 3rd party library for communication with the device/service/sensor.
- - Provide some documentation for [home-assistant.io](https://home-assistant.io/). It's OK to just add a docstring with configuration details (sample entry for `configuration.yaml` file and alike) to the file header as a start. Visit the [website documentation](https://home-assistant.io/developers/website/) for further information on contributing to [home-assistant.io](https://github.com/balloob/home-assistant.io).
+ - Provide some documentation for [home-assistant.io](https://home-assistant.io/). It's OK to just add a docstring with configuration details (sample entry for `configuration.yaml` file and alike) to the file header as a start. Visit the [website documentation](https://home-assistant.io/developers/website/) for further information on contributing to [home-assistant.io](https://github.com/home-assistant/home-assistant.io).
  - Make sure all your code passes ``pylint`` and ``flake8`` (PEP8 and some more) validation. To check your repository, run `tox` or `script/lint`.
- - Create a Pull Request against the [**dev**](https://github.com/balloob/home-assistant/tree/dev) branch of Home Assistant.
- - Check for comments and suggestions on your Pull Request and keep an eye on the [CI output](https://travis-ci.org/balloob/home-assistant/).
+ - Create a Pull Request against the [**dev**](https://github.com/home-assistant/home-assistant/tree/dev) branch of Home Assistant.
+ - Check for comments and suggestions on your Pull Request and keep an eye on the [CI output](https://travis-ci.org/home-assistant/home-assistant/).
 
 If you add a platform for an existing component, there is usually no need for updating the frontend. Only if you've added a new component that should show up in the frontend, there are more steps needed:
 
- - Update the file [`home-assistant-icons.html`](https://github.com/balloob/home-assistant/blob/master/homeassistant/components/frontend/www_static/polymer/resources/home-assistant-icons.html) with an icon for your domain ([pick one from this list](https://www.polymer-project.org/1.0/components/core-elements/demo.html#core-icon)).
+ - Update the file [`home-assistant-icons.html`](https://github.com/home-assistant/home-assistant/blob/master/homeassistant/components/frontend/www_static/polymer/resources/home-assistant-icons.html) with an icon for your domain ([pick one from this list](https://www.polymer-project.org/1.0/components/core-elements/demo.html#core-icon)).
  - Update the demo component with two states that it provides.
  - Add your component to `home-assistant.conf.example`.
 
 Since you've updated `home-assistant-icons.html`, you've made changes to the frontend:
 
- - Run `build_frontend`. This will build a new version of the frontend. Make sure you add the changed files `frontend.py` and `frontend.html` to the commit.
+ - Run `script/build_frontend`. This will build a new version of the frontend. Make sure you add the changed files `frontend.py` and `frontend.html` to the commit.
 
 ### Setting states
 
@@ -46,11 +46,11 @@ A state can have several attributes that will help the frontend in displaying yo
  - `unit_of_measurement`: this will be appended to the state in the interface
  - `hidden`: This is a suggestion to the frontend on if the state should be hidden
 
-These attributes are defined in [homeassistant.components](https://github.com/balloob/home-assistant/blob/master/homeassistant/components/__init__.py#L25).
+These attributes are defined in [homeassistant.components](https://github.com/home-assistant/home-assistant/blob/master/homeassistant/components/__init__.py#L25).
 
 ### Proper Visibility Handling
 
-Generally, when creating a new entity for Home Assistant you will want it to be a class that inherits the [homeassistant.helpers.entity.Entity](https://github.com/balloob/home-assistant/blob/master/homeassistant/helpers/entity.py) class. If this is done, visibility will be handled for you. 
+Generally, when creating a new entity for Home Assistant you will want it to be a class that inherits the [homeassistant.helpers.entity.Entity](https://github.com/home-assistant/home-assistant/blob/master/homeassistant/helpers/entity.py) class. If this is done, visibility will be handled for you. 
 You can set a suggestion for your entity's visibility by setting the hidden property by doing something similar to the following.
 
 ```python

Dockerfile

@@ -8,9 +8,9 @@ WORKDIR /usr/src/app
 
 RUN pip3 install --no-cache-dir colorlog cython
 
-# For the nmap tracker
+# For the nmap tracker, bluetooth tracker, Z-Wave
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends nmap net-tools cython3 libudev-dev sudo && \
+    apt-get install -y --no-install-recommends nmap net-tools cython3 libudev-dev sudo libglib2.0-dev && \
     apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
 COPY script/build_python_openzwave script/build_python_openzwave
@@ -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/balloob/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,19 +80,21 @@ 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
 section <https://home-assistant.io/help/>`__ how to reach us.
 
-.. |Build Status| image:: https://travis-ci.org/balloob/home-assistant.svg?branch=master
-   :target: https://travis-ci.org/balloob/home-assistant
-.. |Coverage Status| image:: https://img.shields.io/coveralls/balloob/home-assistant.svg
-   :target: https://coveralls.io/r/balloob/home-assistant?branch=master
-.. |Join the chat at https://gitter.im/balloob/home-assistant| image:: https://badges.gitter.im/Join%20Chat.svg
-   :target: https://gitter.im/balloob/home-assistant?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-.. |screenshot-states| image:: https://raw.github.com/balloob/home-assistant/master/docs/screenshots.png
+.. |Build Status| image:: https://travis-ci.org/home-assistant/home-assistant.svg?branch=master
+   :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://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

@@ -7,7 +7,7 @@ homeassistant:
   latitude: 32.87336
   longitude: 117.22743
 
-  # C for Celcius, F for Fahrenheit
+  # C for Celsius, F for Fahrenheit
   temperature_unit: C
 
   # Pick yours from here:

config/custom_components/mqtt_example.py

@@ -14,7 +14,7 @@ To use the mqtt_example component you will need to add the following to your
 configuration.yaml file.
 
 mqtt_example:
-  topic: home-assistant/mqtt_example
+  topic: "home-assistant/mqtt_example"
 """
 import homeassistant.loader as loader
 
@@ -29,7 +29,7 @@ DEFAULT_TOPIC = 'home-assistant/mqtt_example'
 
 
 def setup(hass, config):
-    """Setup the  MQTT example component."""
+    """Setup the MQTT example component."""
     mqtt = loader.get_component('mqtt')
     topic = config[DOMAIN].get('topic', DEFAULT_TOPIC)
     entity_id = 'mqtt_example.last_message'

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__,
@@ -31,7 +31,7 @@ def validate_python():
 def ensure_config_path(config_dir):
     """Validate the configuration directory."""
     import homeassistant.config as config_util
-    lib_dir = os.path.join(config_dir, 'lib')
+    lib_dir = os.path.join(config_dir, 'deps')
 
     # Test if configuration directory exists
     if not os.path.isdir(config_dir):
@@ -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

@@ -14,6 +14,7 @@ import homeassistant.components as core_components
 import homeassistant.components.group as group
 import homeassistant.config as config_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
@@ -21,7 +22,8 @@ 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_CELCIUS, TEMP_FAHRENHEIT, PLATFORM_FORMAT, __version__)
+    TEMP_CELSIUS, TEMP_FAHRENHEIT, PLATFORM_FORMAT, __version__)
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import (
     event_decorators, service, config_per_platform, extract_domain_configs)
 from homeassistant.helpers.entity import Entity
@@ -64,7 +66,7 @@ def _handle_requirements(hass, component, name):
         return True
 
     for req in component.REQUIREMENTS:
-        if not pkg_util.install_package(req, target=hass.config.path('lib')):
+        if not pkg_util.install_package(req, target=hass.config.path('deps')):
             _LOGGER.error('Not initializing %s because could not install '
                           'dependency %s', name, req)
             return False
@@ -102,7 +104,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'):
@@ -112,12 +114,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)
@@ -134,9 +135,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)
@@ -210,12 +210,12 @@ def prepare_setup_platform(hass, config, domain, platform_name):
 
 def mount_local_lib_path(config_dir):
     """Add local library to Python Path."""
-    sys.path.insert(0, os.path.join(config_dir, 'lib'))
+    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.
 
@@ -228,17 +228,19 @@ def from_config_dict(config, hass=None, config_dir=None, enable_log=True,
             hass.config.config_dir = 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, {})))
+            core_config))
     except vol.MultipleInvalid as ex:
-        _LOGGER.error('Invalid config for [homeassistant]: %s', ex)
+        cv.log_exception(_LOGGER, ex, 'homeassistant', core_config)
         return None
 
     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:
@@ -276,8 +278,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,
@@ -291,36 +293,38 @@ def from_config_file(config_path, hass=None, verbose=False, daemon=False,
     hass.config.config_dir = config_dir
     mount_local_lib_path(config_dir)
 
-    enable_logging(hass, verbose, daemon, log_rotate_days)
+    enable_logging(hass, verbose, log_rotate_days)
 
-    config_dict = config_util.load_yaml_config_file(config_path)
+    try:
+        config_dict = config_util.load_yaml_config_file(config_path)
+    except HomeAssistantError:
+        return None
 
     return from_config_dict(config_dict, hass, enable_log=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)
@@ -368,10 +372,16 @@ def process_ha_config_upgrade(hass):
     _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__)
 
@@ -430,7 +440,7 @@ def process_ha_core_config(hass, config):
         if info.use_fahrenheit:
             hac.temperature_unit = TEMP_FAHRENHEIT
         else:
-            hac.temperature_unit = TEMP_CELCIUS
+            hac.temperature_unit = TEMP_CELSIUS
 
     if hac.location_name is None:
         hac.location_name = info.city

homeassistant/components/alarm_control_panel/__init__.py

@@ -7,12 +7,15 @@ https://home-assistant.io/components/alarm_control_panel/
 import logging
 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)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
+import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 
@@ -38,6 +41,11 @@ ATTR_TO_PROPERTY = [
     ATTR_CODE_FORMAT
 ]
 
+ALARM_SERVICE_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Optional(ATTR_CODE): cv.string,
+})
+
 
 def setup(hass, config):
     """Track states and offer events for sensors."""
@@ -51,10 +59,7 @@ def setup(hass, config):
         """Map services to methods on Alarm."""
         target_alarms = component.extract_from_service(service)
 
-        if ATTR_CODE not in service.data:
-            code = None
-        else:
-            code = service.data[ATTR_CODE]
+        code = service.data.get(ATTR_CODE)
 
         method = SERVICE_TO_METHOD[service.service]
 
@@ -68,8 +73,8 @@ def setup(hass, config):
 
     for service in SERVICE_TO_METHOD:
         hass.services.register(DOMAIN, service, alarm_service_handler,
-                               descriptions.get(service))
-
+                               descriptions.get(service),
+                               schema=ALARM_SERVICE_SCHEMA)
     return True
 
 

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)
+
+        # 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'])
+
+        if action is not None:
+            action.run(response.variables)
+
+        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
+from time import time
 
 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,365 @@ _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."""
+        from eventlet.queue import LightQueue, Empty
+        import eventlet
 
-        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
+        cur_hub = eventlet.hubs.get_hub()
+        request.environ['eventlet.minimum_write_chunk_size'] = 0
+        to_write = LightQueue()
+        stop_obj = object()
 
-        handler.server.sessions.extend_validation(session_id)
-        write_message(json.dumps(event, cls=rem.JSONEncoder))
+        restrict = request.args.get('restrict')
+        if restrict:
+            restrict = restrict.split(',')
 
-    handler.send_response(HTTP_OK)
-    handler.send_header('Content-type', 'text/event-stream')
-    session_id = handler.set_session_cookie_header()
-    handler.end_headers()
+        def thread_forward_events(event):
+            """Forward events to the open request."""
+            if event.event_type == EVENT_TIME_CHANGED:
+                return
 
-    if restrict:
-        for event in restrict:
-            hass.bus.listen(event, forward_events)
-    else:
-        hass.bus.listen(MATCH_ALL, forward_events)
+            if restrict and event.event_type not in restrict:
+                return
 
-    while True:
-        write_message(STREAM_PING_PAYLOAD)
+            _LOGGER.debug('STREAM %s FORWARDING %s', id(stop_obj), event)
 
-        block.wait(STREAM_PING_INTERVAL)
+            if event.event_type == EVENT_HOMEASSISTANT_STOP:
+                data = stop_obj
+            else:
+                data = json.dumps(event, cls=rem.JSONEncoder)
 
-        if block.is_set():
-            break
+            cur_hub.schedule_call_global(0, lambda: to_write.put(data))
 
-    if not gracefully_closed:
-        _LOGGER.info("Found broken event stream to %s, cleaning up",
-                     handler.client_address[0])
+        def stream():
+            """Stream events to response."""
+            self.hass.bus.listen(MATCH_ALL, thread_forward_events)
 
-    if restrict:
-        for event in restrict:
-            hass.bus.remove_listener(event, forward_events)
-    else:
-        hass.bus.remove_listener(MATCH_ALL, forward_events)
+            _LOGGER.debug('STREAM %s ATTACHED', id(stop_obj))
 
+            last_msg = time()
+            # Fire off one message right away to have browsers fire open event
+            to_write.put(STREAM_PING_PAYLOAD)
 
-def _handle_get_api_config(handler, path_match, data):
-    """Return the Home Assistant configuration."""
-    handler.write_json(handler.server.hass.config.as_dict())
+            while True:
+                try:
+                    # Somehow our queue.get sometimes takes too long to
+                    # be notified of arrival of data. Probably
+                    # because of our spawning on hub in other thread
+                    # hack. Because current goal is to get this out,
+                    # We just timeout every second because it will
+                    # return right away if qsize() > 0.
+                    # So yes, we're basically polling :(
+                    payload = to_write.get(timeout=1)
 
+                    if payload is stop_obj:
+                        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())
+                    msg = "data: {}\n\n".format(payload)
+                    _LOGGER.debug('STREAM %s WRITING %s', id(stop_obj),
+                                  msg.strip())
+                    yield msg.encode("UTF-8")
+                    last_msg = time()
+                except Empty:
+                    if time() - last_msg > 50:
+                        to_write.put(STREAM_PING_PAYLOAD)
+                except GeneratorExit:
+                    _LOGGER.debug('STREAM %s RESPONSE CLOSED', id(stop_obj))
+                    break
 
+            self.hass.bus.remove_listener(MATCH_ALL, thread_forward_events)
 
-def _handle_get_api_states_entity(handler, path_match, data):
-    """Return the state of a specific entity."""
-    entity_id = path_match.group('entity_id')
+        return self.Response(stream(), mimetype='text/event-stream')
 
-    state = handler.server.hass.states.get(entity_id)
 
-    if state:
-        handler.write_json(state)
-    else:
-        handler.write_json_message("State does not exist.", HTTP_NOT_FOUND)
+class APIConfigView(HomeAssistantView):
+    """View to handle Config requests."""
 
+    url = URL_API_CONFIG
+    name = "api:config"
 
-def _handle_post_state_entity(handler, path_match, data):
-    """Handle updating the state of an entity.
+    def get(self, request):
+        """Get current configuration."""
+        return self.json(self.hass.config.as_dict())
 
-    This handles the following paths:
-    /api/states/<entity_id>
-    """
-    entity_id = path_match.group('entity_id')
 
-    try:
-        new_state = data['state']
-    except KeyError:
-        handler.write_json_message("state not specified", HTTP_BAD_REQUEST)
-        return
+class APIDiscoveryView(HomeAssistantView):
+    """View to provide discovery info."""
 
-    attributes = data['attributes'] if 'attributes' in data else None
+    requires_auth = False
+    url = URL_API_DISCOVERY_INFO
+    name = "api:discovery"
 
-    is_new_state = handler.server.hass.states.get(entity_id) is 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__
+        })
 
-    # Write state
-    handler.server.hass.states.set(entity_id, new_state, attributes)
 
-    state = handler.server.hass.states.get(entity_id)
+class APIStatesView(HomeAssistantView):
+    """View to handle States requests."""
 
-    status_code = HTTP_CREATED if is_new_state else HTTP_OK
+    url = URL_API_STATES
+    name = "api:states"
 
-    handler.write_json(
-        state.as_dict(),
-        status_code=status_code,
-        location=URL_API_STATES_ENTITY.format(entity_id))
+    def get(self, request):
+        """Get current states."""
+        return self.json(self.hass.states.all())
 
 
-def _handle_delete_state_entity(handler, path_match, data):
-    """Handle request to delete an entity from state machine.
+class APIEntityStateView(HomeAssistantView):
+    """View to handle EntityState requests."""
 
-    This handles the following paths:
-    /api/states/<entity_id>
-    """
-    entity_id = path_match.group('entity_id')
+    url = "/api/states/<entity(exist=False):entity_id>"
+    name = "api:entity-state"
 
-    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 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)
 
+    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)
 
-def _handle_get_api_events(handler, path_match, data):
-    """Handle getting overview of event listeners."""
-    handler.write_json(events_json(handler.server.hass))
+        attributes = request.json.get('attributes')
 
+        is_new_state = self.hass.states.get(entity_id) is None
 
-def _handle_api_post_events_event(handler, path_match, event_data):
-    """Handle firing of an event.
+        # Write state
+        self.hass.states.set(entity_id, new_state, attributes)
 
-    This handles the following paths: /api/events/<event_type>
+        # Read the state back for our response
+        resp = self.json(self.hass.states.get(entity_id))
 
-    Events from /api are threated as remote events.
-    """
-    event_type = path_match.group('event_type')
+        if is_new_state:
+            resp.status_code = HTTP_CREATED
 
-    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
+        resp.headers.add('Location', URL_API_STATES_ENTITY.format(entity_id))
 
-    event_origin = ha.EventOrigin.remote
+        return resp
 
-    # 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))
+    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)
 
-            if state:
-                event_data[key] = state
 
-    handler.server.hass.bus.fire(event_type, event_data, event_origin)
+class APIEventListenersView(HomeAssistantView):
+    """View to handle EventListeners requests."""
 
-    handler.write_json_message("Event {} fired.".format(event_type))
+    url = URL_API_EVENTS
+    name = "api:event-listeners"
 
+    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."""
 
-# pylint: disable=invalid-name
-def _handle_post_api_services_domain_service(handler, path_match, data):
-    """Handle calling a service.
+    url = '/api/events/<event_type>'
+    name = "api:event"
 
-    This handles the following paths: /api/services/<domain>/<service>
-    """
-    domain = path_match.group('domain')
-    service = path_match.group('service')
+    def post(self, request, event_type):
+        """Fire events."""
+        event_data = request.json
 
-    with TrackStates(handler.server.hass) as changed_states:
-        handler.server.hass.services.call(domain, service, data, True)
+        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)
 
-    handler.write_json(changed_states)
+        # 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
 
-# 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
+        self.hass.bus.fire(event_type, event_data, ha.EventOrigin.remote)
 
-    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
+        return self.json_message("Event {} fired.".format(event_type))
 
-    api = rem.API(host, api_password, port)
 
-    if not api.validate_api():
-        handler.write_json_message(
-            "Unable to validate API", HTTP_UNPROCESSABLE_ENTITY)
-        return
+class APIServicesView(HomeAssistantView):
+    """View to handle Services requests."""
 
-    if handler.server.event_forwarder is None:
-        handler.server.event_forwarder = \
-            rem.EventForwarder(handler.server.hass)
+    url = URL_API_SERVICES
+    name = "api:services"
 
-    handler.server.event_forwarder.connect(api)
+    def get(self, request):
+        """Get registered services."""
+        return self.json(services_json(self.hass))
 
-    handler.write_json_message("Event forwarding setup.")
 
+class APIDomainServicesView(HomeAssistantView):
+    """View to handle DomainServices requests."""
 
-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
+    url = "/api/services/<domain>/<service>"
+    name = "api:domain-services"
 
-    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
+    def post(self, request, domain, service):
+        """Call a service.
 
-    if handler.server.event_forwarder is not None:
-        api = rem.API(host, None, port)
+        Returns a list of changed states.
+        """
+        with TrackStates(self.hass) as changed_states:
+            self.hass.services.call(domain, service, request.json, True)
 
-        handler.server.event_forwarder.disconnect(api)
+        return self.json(changed_states)
 
-    handler.write_json_message("Event forwarding cancelled.")
 
+class APIEventForwardingView(HomeAssistantView):
+    """View to handle EventForwarding requests."""
 
-def _handle_get_api_components(handler, path_match, data):
-    """Return all the loaded components."""
-    handler.write_json(handler.server.hass.config.components)
+    url = URL_API_EVENT_FORWARD
+    name = "api:event-forward"
+    event_forwarder = None
 
+    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)
 
-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)
+        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)
 
+        api = rem.API(host, api_password, port)
 
-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 not api.validate_api():
+            return self.json_message("Unable to validate API.",
+                                     HTTP_UNPROCESSABLE_ENTITY)
 
+        if self.event_forwarder is None:
+            self.event_forwarder = rem.EventForwarder(self.hass)
 
-def _handle_post_api_template(handler, path_match, data):
-    """Log user out."""
-    template_string = data.get('template', '')
+        self.event_forwarder.connect(api)
 
-    try:
-        rendered = template.render(handler.server.hass, template_string)
+        return self.json_message("Event forwarding setup.")
 
-        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
+    def delete(self, request):
+        """Remove event forwarer."""
+        data = request.json
+        if data is None:
+            return self.json_message("No data received.", HTTP_BAD_REQUEST)
+
+        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
 
@@ -51,8 +51,6 @@ def _platform_validator(method, schema):
         if not hasattr(platform, schema):
             return config
 
-        print('validating config', method, config)
-
         return getattr(platform, schema)(config)
 
     return validator
@@ -76,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),
+            ),
         ]
     )
 )
@@ -90,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):
@@ -124,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
 
@@ -139,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
 
@@ -147,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_str(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_str(before)
-        if before is None:
-            _error_time(before, CONF_BEFORE)
-            return None
-
-    if after is not None:
-        after = dt_util.parse_time_str(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/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/mysensors.py

@@ -6,11 +6,10 @@ https://home-assistant.io/components/binary_sensor.mysensors/
 """
 import logging
 
-from homeassistant.const import (
-    ATTR_BATTERY_LEVEL, STATE_OFF, STATE_ON)
-from homeassistant.components.binary_sensor import (
-    BinarySensorDevice, SENSOR_CLASSES)
-from homeassistant.loader import get_component
+from homeassistant.components import mysensors
+from homeassistant.components.binary_sensor import (SENSOR_CLASSES,
+                                                    BinarySensorDevice)
+from homeassistant.const import STATE_ON
 
 _LOGGER = logging.getLogger(__name__)
 DEPENDENCIES = []
@@ -23,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.
@@ -49,76 +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."""
-        attr = {
-            self.mysensors.ATTR_PORT: self.gateway.port,
-            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):
@@ -146,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/nest.py

@@ -4,12 +4,14 @@ Support for Nest Thermostat Binary Sensors.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.nest/
 """
-import logging
-import socket
+import voluptuous as vol
 
 import homeassistant.components.nest as nest
 from homeassistant.components.binary_sensor import BinarySensorDevice
 from homeassistant.components.sensor.nest import NestSensor
+from homeassistant.const import (
+    CONF_PLATFORM, CONF_SCAN_INTERVAL, CONF_MONITORED_CONDITIONS
+)
 
 DEPENDENCIES = ['nest']
 BINARY_TYPES = ['fan',
@@ -23,25 +25,19 @@ BINARY_TYPES = ['fan',
                 'hvac_emer_heat_state',
                 'online']
 
+PLATFORM_SCHEMA = vol.Schema({
+    vol.Required(CONF_PLATFORM): nest.DOMAIN,
+    vol.Optional(CONF_SCAN_INTERVAL):
+        vol.All(vol.Coerce(int), vol.Range(min=1)),
+    vol.Required(CONF_MONITORED_CONDITIONS): [vol.In(BINARY_TYPES)],
+})
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup Nest binary sensors."""
-    logger = logging.getLogger(__name__)
-    try:
-        for structure in nest.NEST.structures:
-            for device in structure.devices:
-                for variable in config['monitored_conditions']:
-                    if variable in BINARY_TYPES:
-                        add_devices([NestBinarySensor(structure,
-                                                      device,
-                                                      variable)])
-                    else:
-                        logger.error('Nest sensor type: "%s" does not exist',
-                                     variable)
-    except socket.error:
-        logger.error(
-            "Connection error logging into the nest web service."
-        )
+    for structure, device in nest.devices():
+        add_devices([NestBinarySensor(structure, device, variable)
+                     for variable in config[CONF_MONITORED_CONDITIONS]])
 
 
 class NestBinarySensor(NestSensor, BinarySensorDevice):

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/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/vera.py

@@ -49,8 +49,7 @@ class VeraBinarySensor(VeraDevice, BinarySensorDevice):
             last_tripped = self.vera_device.last_trip
             if last_tripped is not None:
                 utc_time = dt_util.utc_from_timestamp(int(last_tripped))
-                attr[ATTR_LAST_TRIP_TIME] = dt_util.datetime_to_str(
-                    utc_time)
+                attr[ATTR_LAST_TRIP_TIME] = utc_time.isoformat()
             else:
                 attr[ATTR_LAST_TRIP_TIME] = None
             tripped = self.vera_device.is_tripped

homeassistant/components/binary_sensor/wink.py

@@ -7,10 +7,10 @@ at https://home-assistant.io/components/sensor.wink/
 import logging
 
 from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.const import CONF_ACCESS_TOKEN
+from homeassistant.const import CONF_ACCESS_TOKEN, ATTR_BATTERY_LEVEL
 from homeassistant.helpers.entity import Entity
 
-REQUIREMENTS = ['python-wink==0.6.4']
+REQUIREMENTS = ['python-wink==0.7.6']
 
 # These are the available sensors mapped to binary_sensor class
 SENSOR_TYPES = {
@@ -48,6 +48,7 @@ class WinkBinarySensorDevice(BinarySensorDevice, Entity):
         """Initialize the Wink binary sensor."""
         self.wink = wink
         self._unit_of_measurement = self.wink.UNIT
+        self._battery = self.wink.battery_level
         self.capability = self.wink.capability()
 
     @property
@@ -85,3 +86,16 @@ class WinkBinarySensorDevice(BinarySensorDevice, Entity):
     def update(self):
         """Update state of the sensor."""
         self.wink.update_state()
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        if self._battery:
+            return {
+                ATTR_BATTERY_LEVEL: self._battery_level,
+            }
+
+    @property
+    def _battery_level(self):
+        """Return the battery level."""
+        return self.wink.battery_level * 100

homeassistant/components/binary_sensor/zwave.py

@@ -8,11 +8,7 @@ import logging
 import datetime
 import homeassistant.util.dt as dt_util
 from homeassistant.helpers.event import track_point_in_time
-
-from homeassistant.components.zwave import (
-    ATTR_NODE_ID, ATTR_VALUE_ID,
-    COMMAND_CLASS_SENSOR_BINARY, NETWORK,
-    ZWaveDeviceEntity, get_config_value)
+from homeassistant.components import zwave
 from homeassistant.components.binary_sensor import (
     DOMAIN,
     BinarySensorDevice)
@@ -36,11 +32,11 @@ DEVICE_MAPPINGS = {
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Z-Wave platform for sensors."""
-    if discovery_info is None or NETWORK is None:
+    if discovery_info is None or zwave.NETWORK is None:
         return
 
-    node = NETWORK.nodes[discovery_info[ATTR_NODE_ID]]
-    value = node.values[discovery_info[ATTR_VALUE_ID]]
+    node = zwave.NETWORK.nodes[discovery_info[zwave.ATTR_NODE_ID]]
+    value = node.values[discovery_info[zwave.ATTR_VALUE_ID]]
     value.set_change_verified(False)
 
     # Make sure that we have values for the key before converting to int
@@ -53,18 +49,19 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         if specific_sensor_key in DEVICE_MAPPINGS:
             if DEVICE_MAPPINGS[specific_sensor_key] == WORKAROUND_NO_OFF_EVENT:
                 # Default the multiplier to 4
-                re_arm_multiplier = (get_config_value(value.node, 9) or 4)
+                re_arm_multiplier = (zwave.get_config_value(value.node,
+                                                            9) or 4)
                 add_devices([
                     ZWaveTriggerSensor(value, "motion",
                                        hass, re_arm_multiplier * 8)
                 ])
                 return
 
-    if value.command_class == COMMAND_CLASS_SENSOR_BINARY:
+    if value.command_class == zwave.COMMAND_CLASS_SENSOR_BINARY:
         add_devices([ZWaveBinarySensor(value, None)])
 
 
-class ZWaveBinarySensor(BinarySensorDevice, ZWaveDeviceEntity):
+class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity):
     """Representation of a binary sensor within Z-Wave."""
 
     def __init__(self, value, sensor_class):
@@ -74,7 +71,7 @@ class ZWaveBinarySensor(BinarySensorDevice, ZWaveDeviceEntity):
         from openzwave.network import ZWaveNetwork
         from pydispatch import dispatcher
 
-        ZWaveDeviceEntity.__init__(self, value, DOMAIN)
+        zwave.ZWaveDeviceEntity.__init__(self, value, DOMAIN)
 
         dispatcher.connect(
             self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)

homeassistant/components/browser.py

@@ -4,10 +4,18 @@ Provides functionality to launch a web browser on the host machine.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/browser/
 """
+import voluptuous as vol
 
 DOMAIN = "browser"
 SERVICE_BROWSE_URL = "browse_url"
 
+ATTR_URL = 'url'
+ATTR_URL_DEFAULT = 'https://www.google.com'
+
+SERVICE_BROWSE_URL_SCHEMA = vol.Schema({
+    vol.Required(ATTR_URL, default=ATTR_URL_DEFAULT): vol.Url,
+})
+
 
 def setup(hass, config):
     """Listen for browse_url events."""
@@ -15,8 +23,7 @@ def setup(hass, config):
 
     hass.services.register(DOMAIN, SERVICE_BROWSE_URL,
                            lambda service:
-                           webbrowser.open(
-                               service.data.get(
-                                   'url', 'https://www.google.com')))
+                           webbrowser.open(service.data[ATTR_URL]),
+                           schema=SERVICE_BROWSE_URL_SCHEMA)
 
     return True

homeassistant/components/camera/__init__.py

@@ -6,17 +6,12 @@ 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']
@@ -32,10 +27,7 @@ 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
@@ -45,57 +37,11 @@ def setup(hass, config):
         logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL,
         DISCOVERY_PLATFORMS)
 
+    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 +52,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 +65,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 +86,35 @@ 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'))
+        import eventlet
+        response.content_type = ('multipart/x-mixed-replace; '
+                                 'boundary=--jpegboundary')
 
-        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)
+        def stream():
+            """Stream images as mjpeg stream."""
+            try:
+                last_image = None
+                while True:
+                    img_bytes = self.camera_image()
 
-        while True:
-            img_bytes = self.camera_image()
+                    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'
 
-            if img_bytes is None:
-                continue
+                        last_image = img_bytes
 
-            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)
+                    eventlet.sleep(0.5)
+            except GeneratorExit:
+                pass
 
-            time.sleep(0.5)
+        response.response = stream()
+
+        return response
 
     @property
     def state(self):
@@ -175,7 +129,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 +140,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/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'
@@ -68,19 +67,12 @@ 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()
+        response.mimetype = stream.headers[CONTENT_TYPE_HEADER]
+        response.response = stream.iter_content(chunk_size=1024)
+        return response
 
     @property
     def name(self):

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

@@ -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)
 
@@ -121,6 +125,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

@@ -8,9 +8,12 @@ import logging
 import re
 import warnings
 
+import voluptuous as vol
+
 from homeassistant import core
 from homeassistant.const import (
     ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON)
+import homeassistant.helpers.config_validation as cv
 
 DOMAIN = "conversation"
 
@@ -18,9 +21,13 @@ SERVICE_PROCESS = "process"
 
 ATTR_TEXT = "text"
 
+SERVICE_PROCESS_SCHEMA = vol.Schema({
+    vol.Required(ATTR_TEXT): vol.All(cv.string, vol.Lower),
+})
+
 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):
@@ -32,11 +39,7 @@ def setup(hass, config):
 
     def process(service):
         """Parse text into commands."""
-        if ATTR_TEXT not in service.data:
-            logger.error("Received process service call without a text")
-            return
-
-        text = service.data[ATTR_TEXT].lower()
+        text = service.data[ATTR_TEXT]
         match = REGEX_TURN_COMMAND.match(text)
 
         if not match:
@@ -67,6 +70,6 @@ def setup(hass, config):
             logger.error(
                 'Got unsupported command %s from text %s', command, text)
 
-    hass.services.register(DOMAIN, SERVICE_PROCESS, process)
-
+    hass.services.register(DOMAIN, SERVICE_PROCESS, process,
+                           schema=SERVICE_PROCESS_SCHEMA)
     return True

homeassistant/components/demo.py

@@ -21,6 +21,7 @@ COMPONENTS_WITH_DEMO_PLATFORM = [
     'camera',
     'device_tracker',
     'garage_door',
+    'hvac',
     'light',
     'lock',
     'media_player',

homeassistant/components/device_tracker/__init__.py

@@ -17,7 +17,7 @@ from homeassistant.config import load_yaml_config_file
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_per_platform
 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 +26,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']
 
@@ -94,7 +95,7 @@ def setup(hass, config):
     yaml_path = hass.config.path(YAML_DEVICES)
 
     conf = config.get(DOMAIN, {})
-    if isinstance(conf, list):
+    if isinstance(conf, list) and len(conf) > 0:
         conf = conf[0]
     consider_home = timedelta(
         seconds=util.convert(conf.get(CONF_CONSIDER_HOME), int,
@@ -193,7 +194,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:
@@ -204,6 +205,7 @@ class DeviceTracker(object):
                 return
 
             # If no device can be found, create it
+            dev_id = util.ensure_unique_string(dev_id, self.devices.keys())
             device = Device(
                 self.hass, self.consider_home, self.home_range, self.track_new,
                 dev_id, mac, (host_name or dev_id).replace('_', ' '))

homeassistant/components/device_tracker/asuswrt.py

@@ -19,13 +19,16 @@ 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]+))')
 
+_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' +
@@ -55,6 +58,7 @@ class AsusWrtDeviceScanner(object):
         self.host = config[CONF_HOST]
         self.username = str(config[CONF_USERNAME])
         self.password = str(config[CONF_PASSWORD])
+        self.protocol = config.get('protocol')
 
         self.lock = threading.Lock()
 
@@ -100,8 +104,26 @@ 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
+        try:
+            ssh = pxssh.pxssh()
+            ssh.login(self.host, self.username, self.password)
+            ssh.sendline(_IP_NEIGH_CMD)
+            ssh.prompt()
+            neighbors = ssh.before.split(b'\n')[1:-1]
+            ssh.sendline(_LEASES_CMD)
+            ssh.prompt()
+            leases_result = ssh.before.split(b'\n')[1:-1]
+            ssh.logout()
+            return (neighbors, leases_result)
+        except pxssh.ExceptionPxssh as exc:
+            _LOGGER.exception('Unexpected response from router: %s', exc)
+            return ('', '')
+
+    def telnet_connection(self):
+        """Retrieve data from ASUSWRT via the telnet protocol."""
         try:
             telnet = telnetlib.Telnet(self.host)
             telnet.read_until(b'login: ')
@@ -109,18 +131,26 @@ 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'))
+            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 (neighbors, leases_result)
         except EOFError:
             _LOGGER.exception("Unexpected response from router")
-            return
+            return ('', '')
         except ConnectionRefusedError:
-            _LOGGER.exception("Connection refused by router," +
+            _LOGGER.exception("Connection refused by router,"
                               " is telnet enabled?")
-            return
+            return ('', '')
+
+    def get_asuswrt_data(self):
+        """Retrieve data from ASUSWRT and return parsed result."""
+        if self.protocol == 'telnet':
+            neighbors, leases_result = self.telnet_connection()
+        else:
+            neighbors, leases_result = self.ssh_connection()
 
         devices = {}
         for lease in leases_result:

homeassistant/components/device_tracker/bluetooth_tracker.py

@@ -0,0 +1,91 @@
+"""Tracking for bluetooth devices."""
+import logging
+from datetime import timedelta
+
+from homeassistant.helpers.event import track_point_in_utc_time
+from homeassistant.components.device_tracker import (
+    YAML_DEVICES,
+    CONF_TRACK_NEW,
+    CONF_SCAN_INTERVAL,
+    DEFAULT_SCAN_INTERVAL,
+    load_config,
+)
+import homeassistant.util as util
+import homeassistant.util.dt as dt_util
+
+_LOGGER = logging.getLogger(__name__)
+
+REQUIREMENTS = ['pybluez==0.22']
+
+BT_PREFIX = 'BT_'
+
+
+def setup_scanner(hass, config, see):
+    """Setup the Bluetooth Scanner."""
+    # pylint: disable=import-error
+    import bluetooth
+
+    def see_device(device):
+        """Mark a device as seen."""
+        see(mac=BT_PREFIX + device[0], host_name=device[1])
+
+    def discover_devices():
+        """Discover bluetooth devices."""
+        result = bluetooth.discover_devices(duration=8,
+                                            lookup_names=True,
+                                            flush_cache=True,
+                                            lookup_class=False)
+        _LOGGER.debug("Bluetooth devices discovered = " + str(len(result)))
+        return result
+
+    yaml_path = hass.config.path(YAML_DEVICES)
+    devs_to_track = []
+    devs_donot_track = []
+
+    # Load all known devices.
+    # We just need the devices so set consider_home and home range
+    # to 0
+    for device in load_config(yaml_path, hass, 0, 0):
+        # check if device is a valid bluetooth device
+        if device.mac and device.mac[:3].upper() == BT_PREFIX:
+            if device.track:
+                devs_to_track.append(device.mac[3:])
+            else:
+                devs_donot_track.append(device.mac[3:])
+
+    # if track new devices is true discover new devices
+    # on startup.
+    track_new = util.convert(config.get(CONF_TRACK_NEW), bool,
+                             len(devs_to_track) == 0)
+    if track_new:
+        for dev in discover_devices():
+            if dev[0] not in devs_to_track and \
+               dev[0] not in devs_donot_track:
+                devs_to_track.append(dev[0])
+                see_device(dev)
+
+    if not devs_to_track:
+        _LOGGER.warning("No bluetooth devices to track!")
+        return False
+
+    interval = util.convert(config.get(CONF_SCAN_INTERVAL), int,
+                            DEFAULT_SCAN_INTERVAL)
+
+    def update_bluetooth(now):
+        """Lookup bluetooth device and update status."""
+        try:
+            for mac in devs_to_track:
+                _LOGGER.debug("Scanning " + mac)
+                result = bluetooth.lookup_name(mac, timeout=5)
+                if not result:
+                    # Could not lookup device name
+                    continue
+                see_device((mac, result))
+        except bluetooth.BluetoothError:
+            _LOGGER.exception('Error looking up bluetooth device!')
+        track_point_in_utc_time(hass, update_bluetooth,
+                                now + timedelta(seconds=interval))
+
+    update_bluetooth(dt_util.utcnow())
+
+    return True

homeassistant/components/device_tracker/fritz.py

@@ -12,7 +12,9 @@ from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.helpers import validate_config
 from homeassistant.util import Throttle
 
-REQUIREMENTS = ['fritzconnection==0.4.6']
+REQUIREMENTS = ['https://github.com/deisi/fritzconnection/archive/'
+                'b5c14515e1c8e2652b06b6316a7f3913df942841.zip'
+                '#fritzconnection==0.4.6']
 
 # Return cached results if last scan was less then this time ago.
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)

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:bootstrap"
 
-    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/netgear.py

@@ -9,14 +9,15 @@ import threading
 from datetime import timedelta
 
 from homeassistant.components.device_tracker import DOMAIN
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, \
+ CONF_PORT
 from homeassistant.util import Throttle
 
 # Return cached results if last scan was less then this time ago.
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
 _LOGGER = logging.getLogger(__name__)
-REQUIREMENTS = ['pynetgear==0.3.2']
+REQUIREMENTS = ['pynetgear==0.3.3']
 
 
 def get_scanner(hass, config):
@@ -25,12 +26,13 @@ def get_scanner(hass, config):
     host = info.get(CONF_HOST)
     username = info.get(CONF_USERNAME)
     password = info.get(CONF_PASSWORD)
+    port = info.get(CONF_PORT)
 
     if password is not None and host is None:
         _LOGGER.warning('Found username or password but no host')
         return None
 
-    scanner = NetgearDeviceScanner(host, username, password)
+    scanner = NetgearDeviceScanner(host, username, password, port)
 
     return scanner if scanner.success_init else None
 
@@ -38,7 +40,7 @@ def get_scanner(hass, config):
 class NetgearDeviceScanner(object):
     """Queries a Netgear wireless router using the SOAP-API."""
 
-    def __init__(self, host, username, password):
+    def __init__(self, host, username, password, port):
         """Initialize the scanner."""
         import pynetgear
 
@@ -49,8 +51,10 @@ class NetgearDeviceScanner(object):
             self._api = pynetgear.Netgear()
         elif username is None:
             self._api = pynetgear.Netgear(password, host)
-        else:
+        elif port is None:
             self._api = pynetgear.Netgear(password, host, username)
+        else:
+            self._api = pynetgear.Netgear(password, host, username, port)
 
         _LOGGER.info("Logging in")
 

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']
 
@@ -34,21 +34,39 @@ def setup_scanner(hass, config, see):
     """Setup an OwnTracks tracker."""
     max_gps_accuracy = config.get(CONF_MAX_GPS_ACCURACY)
 
-    def owntracks_location_update(topic, payload, qos):
-        """MQTT message received."""
-        # Docs on available data:
-        # http://owntracks.org/booklet/tech/json/#_typelocation
+    def validate_payload(payload, data_type):
+        """Validate OwnTracks payload."""
         try:
             data = json.loads(payload)
         except ValueError:
             # If invalid JSON
-            _LOGGER.error(
-                'Unable to parse payload as JSON: %s', payload)
-            return
+            _LOGGER.error('Unable to parse payload as JSON: %s', payload)
+            return None
+        if not isinstance(data, dict) or data.get('_type') != data_type:
+            _LOGGER.debug('Skipping %s update for following data '
+                          'because of missing or malformatted data: %s',
+                          data_type, data)
+            return None
+        if max_gps_accuracy is not None and \
+                convert(data.get('acc'), float, 0.0) > max_gps_accuracy:
+            _LOGGER.debug('Skipping %s update because expected GPS '
+                          '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
 
-        if (not isinstance(data, dict) or data.get('_type') != 'location') or (
-                max_gps_accuracy is not None and
-                convert(data.get('acc'), float, 0.0) > max_gps_accuracy):
+        return data
+
+    def owntracks_location_update(topic, payload, qos):
+        """MQTT message received."""
+        # Docs on available data:
+        # http://owntracks.org/booklet/tech/json/#_typelocation
+        data = validate_payload(payload, 'location')
+        if not data:
             return
 
         dev_id, kwargs = _parse_see_args(topic, data)
@@ -65,44 +83,36 @@ def setup_scanner(hass, config, see):
             see_beacons(dev_id, kwargs)
 
     def owntracks_event_update(topic, payload, qos):
-        # pylint: disable=too-many-branches, too-many-statements
         """MQTT event (geofences) received."""
         # Docs on available data:
         # http://owntracks.org/booklet/tech/json/#_typetransition
-        try:
-            data = json.loads(payload)
-        except ValueError:
-            # If invalid JSON
-            _LOGGER.error(
-                'Unable to parse payload as JSON: %s', payload)
-            return
-
-        if not isinstance(data, dict) or data.get('_type') != 'transition':
+        data = validate_payload(payload, 'transition')
+        if not data:
             return
 
         if data.get('desc') is None:
             _LOGGER.error(
-                "Location missing from `enter/exit` message - "
+                "Location missing from `Entering/Leaving` message - "
                 "please turn `Share` on in OwnTracks app")
             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
 
         dev_id, kwargs = _parse_see_args(topic, data)
 
-        if data['event'] == 'enter':
+        def enter_event():
+            """Execute enter event."""
             zone = hass.states.get("zone.{}".format(location))
             with LOCK:
-                if zone is None:
-                    if data['t'] == 'b':
-                        # Not a HA zone, and a beacon so assume mobile
-                        beacons = MOBILE_BEACONS_ACTIVE[dev_id]
-                        if location not in beacons:
-                            beacons.append(location)
-                        _LOGGER.info("Added beacon %s", location)
+                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:
+                        beacons.append(location)
+                    _LOGGER.info("Added beacon %s", location)
                 else:
                     # Normal region
                     regions = REGIONS_ENTERED[dev_id]
@@ -114,7 +124,8 @@ def setup_scanner(hass, config, see):
                 see(**kwargs)
                 see_beacons(dev_id, kwargs)
 
-        elif data['event'] == 'leave':
+        def leave_event():
+            """Execute leave event."""
             with LOCK:
                 regions = REGIONS_ENTERED[dev_id]
                 if location in regions:
@@ -146,6 +157,10 @@ def setup_scanner(hass, config, see):
                     beacons.remove(location)
                     _LOGGER.info("Remove beacon %s", location)
 
+        if data['event'] == 'enter':
+            enter_event()
+        elif data['event'] == 'leave':
+            leave_event()
         else:
             _LOGGER.error(
                 'Misformatted mqtt msgs, _type=transition, event=%s',
@@ -171,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

@@ -15,10 +15,12 @@ from homeassistant.const import (
     EVENT_PLATFORM_DISCOVERED)
 
 DOMAIN = "discovery"
-REQUIREMENTS = ['netdisco==0.6.1']
+REQUIREMENTS = ['netdisco==0.6.7']
 
 SCAN_INTERVAL = 300  # seconds
 
+LOAD_PLATFORM = 'load_platform'
+
 SERVICE_WEMO = 'belkin_wemo'
 SERVICE_HUE = 'philips_hue'
 SERVICE_CAST = 'google_cast'
@@ -27,6 +29,7 @@ SERVICE_SONOS = 'sonos'
 SERVICE_PLEX = 'plex_mediaserver'
 SERVICE_SQUEEZEBOX = 'logitech_mediaserver'
 SERVICE_PANASONIC_VIERA = 'panasonic_viera'
+SERVICE_ROKU = 'roku'
 
 SERVICE_HANDLERS = {
     SERVICE_WEMO: "wemo",
@@ -37,6 +40,7 @@ SERVICE_HANDLERS = {
     SERVICE_PLEX: 'media_player',
     SERVICE_SQUEEZEBOX: 'media_player',
     SERVICE_PANASONIC_VIERA: 'media_player',
+    SERVICE_ROKU: 'media_player',
 }
 
 
@@ -52,7 +56,7 @@ def listen(hass, service, callback):
 
     def discovery_event_listener(event):
         """Listen for discovery events."""
-        if event.data[ATTR_SERVICE] in service:
+        if ATTR_SERVICE in event.data and 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)
@@ -73,6 +77,32 @@ def discover(hass, service, discovered=None, component=None, hass_config=None):
     hass.bus.fire(EVENT_PLATFORM_DISCOVERED, data)
 
 
+def load_platform(hass, component, platform, info=None, hass_config=None):
+    """Helper method for generic platform loading.
+
+    This method allows a platform to be loaded dynamically without it being
+    known at runtime (in the DISCOVERY_PLATFORMS list of the component).
+    Advantages of using this method:
+    - Any component & platforms combination can be dynamically added
+    - A component (i.e. light) does not have to import every component
+      that can dynamically add a platform (e.g. wemo, wink, insteon_hub)
+    - Custom user components can take advantage of discovery/loading
+
+    Target components will be loaded and an EVENT_PLATFORM_DISCOVERED will be
+    fired to load the platform. The event will contain:
+        { ATTR_SERVICE = LOAD_PLATFORM + '.' + <<component>>
+          ATTR_DISCOVERED = {LOAD_PLATFORM: <<platform>>} }
+
+    * dev note: This listener can be found in entity_component.py
+    """
+    if info is None:
+        info = {LOAD_PLATFORM: platform}
+    else:
+        info[LOAD_PLATFORM] = platform
+    discover(hass, LOAD_PLATFORM + '.' + component, info, component,
+             hass_config)
+
+
 def setup(hass, config):
     """Start a discovery service."""
     logger = logging.getLogger(__name__)

homeassistant/components/downloader.py

@@ -10,8 +10,10 @@ import re
 import threading
 
 import requests
+import voluptuous as vol
 
 from homeassistant.helpers import validate_config
+import homeassistant.helpers.config_validation as cv
 from homeassistant.util import sanitize_filename
 
 DOMAIN = "downloader"
@@ -21,6 +23,11 @@ SERVICE_DOWNLOAD_FILE = "download_file"
 ATTR_URL = "url"
 ATTR_SUBDIR = "subdir"
 
+SERVICE_DOWNLOAD_FILE_SCHEMA = vol.Schema({
+    vol.Required(ATTR_URL): vol.Url,
+    vol.Optional(ATTR_SUBDIR): cv.string,
+})
+
 CONF_DOWNLOAD_DIR = 'download_dir'
 
 
@@ -48,10 +55,6 @@ def setup(hass, config):
 
     def download_file(service):
         """Start thread to download file specified in the URL."""
-        if ATTR_URL not in service.data:
-            logger.error("Service called but 'url' parameter not specified.")
-            return
-
         def do_download():
             """Download the file."""
             try:
@@ -127,7 +130,7 @@ def setup(hass, config):
 
         threading.Thread(target=do_download).start()
 
-    hass.services.register(DOMAIN, SERVICE_DOWNLOAD_FILE,
-                           download_file)
+    hass.services.register(DOMAIN, SERVICE_DOWNLOAD_FILE, download_file,
+                           schema=SERVICE_DOWNLOAD_FILE_SCHEMA)
 
     return True

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

@@ -22,7 +22,7 @@ HOLD_TEMP = 'hold_temp'
 
 REQUIREMENTS = [
     'https://github.com/nkgilley/python-ecobee-api/archive/'
-    '92a2f330cbaf601d0618456fdd97e5a8c42c1c47.zip#python-ecobee==0.0.4']
+    '4a884bc146a93991b4210f868f3d6aecf0a181e6.zip#python-ecobee==0.0.5']
 
 _LOGGER = logging.getLogger(__name__)
 

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/feedreader.py

@@ -0,0 +1,174 @@
+"""
+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']
+_LOGGER = getLogger(__name__)
+DOMAIN = "feedreader"
+EVENT_FEEDREADER = "feedreader"
+# pylint: disable=no-value-for-parameter
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: {
+        '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, storage):
+        """Initialize the FeedManager object, poll every hour."""
+        self._url = url
+        self._feed = None
+        self._hass = hass
+        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 to be published in feed "%s"', self._url)
+
+    def _update(self):
+        """Update the feed and publish new entries to the event bus."""
+        import feedparser
+        _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)
+        else:
+            if self._feed.bozo != 0:
+                _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('%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()
+                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:
+            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
+            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']
+    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 = "df49e6b7c930eb39b42ff1909712e95e"
+VERSION = "9ee3d4466a65bef35c2c8974e91b37c0"

homeassistant/components/frontend/templates/index.html

@@ -0,0 +1,95 @@
+<!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/{{ 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 = "4062ab87999fd5e382074ba9d7a880d7"
+CORE = "d0b415dac66c8056d81380b258af5767"
+UI = "b0ea2672fff86b1ab86dd86135d4b43a"

homeassistant/components/frontend/www_static/manifest.json

@@ -8,12 +8,12 @@
     {
      "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"
     }
   ]
 }

homeassistant/components/frontend/www_static/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

homeassistant/components/frontend/www_static/service_worker.js

@@ -1,5 +1,258 @@
-!function(e){function t(r){if(n[r])return n[r].exports;var s=n[r]={exports:{},id:r,loaded:!1};return e[r].call(s.exports,s,s.exports,t),s.loaded=!0,s.exports}var n={};return t.m=e,t.c=n,t.p="",t(0)}([/*!*************************************!*\
-  !*** ./src/service-worker/index.js ***!
-  \*************************************/
-function(e,t,n){"use strict";var r="0.10",s="/",c=["/","/logbook","/history","/map","/devService","/devState","/devEvent","/devInfo","/states"],i=["/static/favicon-192x192.png"];self.addEventListener("install",function(e){e.waitUntil(caches.open(r).then(function(e){return e.addAll(i.concat(s))}))}),self.addEventListener("activate",function(e){}),self.addEventListener("message",function(e){}),self.addEventListener("fetch",function(e){var t=e.request.url.substr(e.request.url.indexOf("/",8));i.includes(t)&&e.respondWith(caches.open(r).then(function(t){return t.match(e.request)})),c.includes(t)&&e.respondWith(caches.open(r).then(function(t){return t.match(s).then(function(n){return n||fetch(e.request).then(function(e){return t.put(s,e.clone()),e})})}))})}]);
-//# sourceMappingURL=service_worker.js.map
+/**
+ * Copyright 2016 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This generated service worker JavaScript will precache your site's resources.
+// The code needs to be saved in a .js file at the top-level of your site, and registered
+// from your pages in order to be used. See
+// https://github.com/googlechrome/sw-precache/blob/master/demo/app/js/service-worker-registration.js
+// for an example of how you can register this script and handle various service worker events.
+
+/* eslint-env worker, serviceworker */
+/* eslint-disable indent, no-unused-vars, no-multiple-empty-lines, max-nested-callbacks, space-before-function-paren */
+'use strict';
+
+
+
+
+
+/* eslint-disable quotes, comma-spacing */
+var PrecacheConfig = [["/","69818e2c5b6f4ca764c46ac78d2fea04"],["/devEvent","69818e2c5b6f4ca764c46ac78d2fea04"],["/devInfo","69818e2c5b6f4ca764c46ac78d2fea04"],["/devService","69818e2c5b6f4ca764c46ac78d2fea04"],["/devState","69818e2c5b6f4ca764c46ac78d2fea04"],["/devTemplate","69818e2c5b6f4ca764c46ac78d2fea04"],["/history","69818e2c5b6f4ca764c46ac78d2fea04"],["/logbook","69818e2c5b6f4ca764c46ac78d2fea04"],["/map","69818e2c5b6f4ca764c46ac78d2fea04"],["/states","69818e2c5b6f4ca764c46ac78d2fea04"],["/static/core-d0b415dac66c8056d81380b258af5767.js","dfafa8e9e34f53e8c36dd8b3f7299b2a"],["/static/frontend-b0ea2672fff86b1ab86dd86135d4b43a.html","69818e2c5b6f4ca764c46ac78d2fea04"],["/static/mdi-9ee3d4466a65bef35c2c8974e91b37c0.html","9a6846935116cd29279c91e0ee0a26d0"],["static/favicon-192x192.png","419903b8422586a7e28021bbe9011175"],["static/fonts/roboto/Roboto-Bold.ttf","d329cc8b34667f114a95422aaad1b063"],["static/fonts/roboto/Roboto-Light.ttf","7b5fb88f12bec8143f00e21bc3222124"],["static/fonts/roboto/Roboto-Medium.ttf","fe13e4170719c2fc586501e777bde143"],["static/fonts/roboto/Roboto-Regular.ttf","ac3f799d5bbaf5196fab15ab8de8431c"],["static/images/card_media_player_bg.png","a34281d1c1835d338a642e90930e61aa"],["static/webcomponents-lite.min.js","b0f32ad3c7749c40d486603f31c9d8b1"]];
+/* eslint-enable quotes, comma-spacing */
+var CacheNamePrefix = 'sw-precache-v1--' + (self.registration ? self.registration.scope : '') + '-';
+
+
+var IgnoreUrlParametersMatching = [/^utm_/];
+
+
+
+var addDirectoryIndex = function (originalUrl, index) {
+    var url = new URL(originalUrl);
+    if (url.pathname.slice(-1) === '/') {
+      url.pathname += index;
+    }
+    return url.toString();
+  };
+
+var getCacheBustedUrl = function (url, param) {
+    param = param || Date.now();
+
+    var urlWithCacheBusting = new URL(url);
+    urlWithCacheBusting.search += (urlWithCacheBusting.search ? '&' : '') +
+      'sw-precache=' + param;
+
+    return urlWithCacheBusting.toString();
+  };
+
+var isPathWhitelisted = function (whitelist, absoluteUrlString) {
+    // If the whitelist is empty, then consider all URLs to be whitelisted.
+    if (whitelist.length === 0) {
+      return true;
+    }
+
+    // Otherwise compare each path regex to the path of the URL passed in.
+    var path = (new URL(absoluteUrlString)).pathname;
+    return whitelist.some(function(whitelistedPathRegex) {
+      return path.match(whitelistedPathRegex);
+    });
+  };
+
+var populateCurrentCacheNames = function (precacheConfig,
+    cacheNamePrefix, baseUrl) {
+    var absoluteUrlToCacheName = {};
+    var currentCacheNamesToAbsoluteUrl = {};
+
+    precacheConfig.forEach(function(cacheOption) {
+      var absoluteUrl = new URL(cacheOption[0], baseUrl).toString();
+      var cacheName = cacheNamePrefix + absoluteUrl + '-' + cacheOption[1];
+      currentCacheNamesToAbsoluteUrl[cacheName] = absoluteUrl;
+      absoluteUrlToCacheName[absoluteUrl] = cacheName;
+    });
+
+    return {
+      absoluteUrlToCacheName: absoluteUrlToCacheName,
+      currentCacheNamesToAbsoluteUrl: currentCacheNamesToAbsoluteUrl
+    };
+  };
+
+var stripIgnoredUrlParameters = function (originalUrl,
+    ignoreUrlParametersMatching) {
+    var url = new URL(originalUrl);
+
+    url.search = url.search.slice(1) // Exclude initial '?'
+      .split('&') // Split into an array of 'key=value' strings
+      .map(function(kv) {
+        return kv.split('='); // Split each 'key=value' string into a [key, value] array
+      })
+      .filter(function(kv) {
+        return ignoreUrlParametersMatching.every(function(ignoredRegex) {
+          return !ignoredRegex.test(kv[0]); // Return true iff the key doesn't match any of the regexes.
+        });
+      })
+      .map(function(kv) {
+        return kv.join('='); // Join each [key, value] array into a 'key=value' string
+      })
+      .join('&'); // Join the array of 'key=value' strings into a string with '&' in between each
+
+    return url.toString();
+  };
+
+
+var mappings = populateCurrentCacheNames(PrecacheConfig, CacheNamePrefix, self.location);
+var AbsoluteUrlToCacheName = mappings.absoluteUrlToCacheName;
+var CurrentCacheNamesToAbsoluteUrl = mappings.currentCacheNamesToAbsoluteUrl;
+
+function deleteAllCaches() {
+  return caches.keys().then(function(cacheNames) {
+    return Promise.all(
+      cacheNames.map(function(cacheName) {
+        return caches.delete(cacheName);
+      })
+    );
+  });
+}
+
+self.addEventListener('install', function(event) {
+  event.waitUntil(
+    // Take a look at each of the cache names we expect for this version.
+    Promise.all(Object.keys(CurrentCacheNamesToAbsoluteUrl).map(function(cacheName) {
+      return caches.open(cacheName).then(function(cache) {
+        // Get a list of all the entries in the specific named cache.
+        // For caches that are already populated for a given version of a
+        // resource, there should be 1 entry.
+        return cache.keys().then(function(keys) {
+          // If there are 0 entries, either because this is a brand new version
+          // of a resource or because the install step was interrupted the
+          // last time it ran, then we need to populate the cache.
+          if (keys.length === 0) {
+            // Use the last bit of the cache name, which contains the hash,
+            // as the cache-busting parameter.
+            // See https://github.com/GoogleChrome/sw-precache/issues/100
+            var cacheBustParam = cacheName.split('-').pop();
+            var urlWithCacheBusting = getCacheBustedUrl(
+              CurrentCacheNamesToAbsoluteUrl[cacheName], cacheBustParam);
+
+            var request = new Request(urlWithCacheBusting,
+              {credentials: 'same-origin'});
+            return fetch(request).then(function(response) {
+              if (response.ok) {
+                return cache.put(CurrentCacheNamesToAbsoluteUrl[cacheName],
+                  response);
+              }
+
+              console.error('Request for %s returned a response status %d, ' +
+                'so not attempting to cache it.',
+                urlWithCacheBusting, response.status);
+              // Get rid of the empty cache if we can't add a successful response to it.
+              return caches.delete(cacheName);
+            });
+          }
+        });
+      });
+    })).then(function() {
+      return caches.keys().then(function(allCacheNames) {
+        return Promise.all(allCacheNames.filter(function(cacheName) {
+          return cacheName.indexOf(CacheNamePrefix) === 0 &&
+            !(cacheName in CurrentCacheNamesToAbsoluteUrl);
+          }).map(function(cacheName) {
+            return caches.delete(cacheName);
+          })
+        );
+      });
+    }).then(function() {
+      if (typeof self.skipWaiting === 'function') {
+        // Force the SW to transition from installing -> active state
+        self.skipWaiting();
+      }
+    })
+  );
+});
+
+if (self.clients && (typeof self.clients.claim === 'function')) {
+  self.addEventListener('activate', function(event) {
+    event.waitUntil(self.clients.claim());
+  });
+}
+
+self.addEventListener('message', function(event) {
+  if (event.data.command === 'delete_all') {
+    console.log('About to delete all caches...');
+    deleteAllCaches().then(function() {
+      console.log('Caches deleted.');
+      event.ports[0].postMessage({
+        error: null
+      });
+    }).catch(function(error) {
+      console.log('Caches not deleted:', error);
+      event.ports[0].postMessage({
+        error: error
+      });
+    });
+  }
+});
+
+
+self.addEventListener('fetch', function(event) {
+  if (event.request.method === 'GET') {
+    var urlWithoutIgnoredParameters = stripIgnoredUrlParameters(event.request.url,
+      IgnoreUrlParametersMatching);
+
+    var cacheName = AbsoluteUrlToCacheName[urlWithoutIgnoredParameters];
+    var directoryIndex = 'index.html';
+    if (!cacheName && directoryIndex) {
+      urlWithoutIgnoredParameters = addDirectoryIndex(urlWithoutIgnoredParameters, directoryIndex);
+      cacheName = AbsoluteUrlToCacheName[urlWithoutIgnoredParameters];
+    }
+
+    var navigateFallback = '';
+    // Ideally, this would check for event.request.mode === 'navigate', but that is not widely
+    // supported yet:
+    // https://code.google.com/p/chromium/issues/detail?id=540967
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1209081
+    if (!cacheName && navigateFallback && event.request.headers.has('accept') &&
+        event.request.headers.get('accept').includes('text/html') &&
+        /* eslint-disable quotes, comma-spacing */
+        isPathWhitelisted([], event.request.url)) {
+        /* eslint-enable quotes, comma-spacing */
+      var navigateFallbackUrl = new URL(navigateFallback, self.location);
+      cacheName = AbsoluteUrlToCacheName[navigateFallbackUrl.toString()];
+    }
+
+    if (cacheName) {
+      event.respondWith(
+        // Rely on the fact that each cache we manage should only have one entry, and return that.
+        caches.open(cacheName).then(function(cache) {
+          return cache.keys().then(function(keys) {
+            return cache.match(keys[0]).then(function(response) {
+              if (response) {
+                return response;
+              }
+              // If for some reason the response was deleted from the cache,
+              // raise and exception and fall back to the fetch() triggered in the catch().
+              throw Error('The cache ' + cacheName + ' is empty.');
+            });
+          });
+        }).catch(function(e) {
+          console.warn('Couldn\'t serve response for "%s" from cache: %O', event.request.url, e);
+          return fetch(event.request);
+        })
+      );
+    }
+  }
+});
+
+
+
+