Version bump to 0.7.7.dev0

Version bump to 0.7.6
Merge pull request #547 from krzynio/dev
2015-10-26 21:32:07 -07:00 · 2015-10-26 21:27:50 -07:00 · 2015-10-26 21:26:13 -07:00 · 2015-10-26 20:49:20 -07:00 · 2015-10-26 16:32:12 +00:00 · 2015-10-26 11:55:20 +01:00
256 changed files with 14155 additions and 6222 deletions
@@ -4,8 +4,6 @@ source = homeassistant
 omit =
    homeassistant/__main__.py

-    homeassistant/external/*
-
    # omit pieces of code that rely on external devices being present
    homeassistant/components/arduino.py
    homeassistant/components/*/arduino.py
@@ -28,6 +26,10 @@ omit =
    homeassistant/components/zwave.py
    homeassistant/components/*/zwave.py

+    homeassistant/components/rfxtrx.py
+    homeassistant/components/*/rfxtrx.py
+
+    homeassistant/components/ifttt.py
    homeassistant/components/browser.py
    homeassistant/components/camera/*
    homeassistant/components/device_tracker/actiontec.py
@@ -35,20 +37,29 @@ omit =
    homeassistant/components/device_tracker/asuswrt.py
    homeassistant/components/device_tracker/ddwrt.py
    homeassistant/components/device_tracker/luci.py
+    homeassistant/components/device_tracker/ubus.py
    homeassistant/components/device_tracker/netgear.py
    homeassistant/components/device_tracker/nmap_tracker.py
    homeassistant/components/device_tracker/thomson.py
    homeassistant/components/device_tracker/tomato.py
    homeassistant/components/device_tracker/tplink.py
+    homeassistant/components/device_tracker/snmp.py
    homeassistant/components/discovery.py
    homeassistant/components/downloader.py
    homeassistant/components/keyboard.py
    homeassistant/components/light/hue.py
    homeassistant/components/light/limitlessled.py
+    homeassistant/components/light/blinksticklight.py
+    homeassistant/components/light/hyperion.py
    homeassistant/components/media_player/cast.py
+    homeassistant/components/media_player/denon.py
+    homeassistant/components/media_player/firetv.py
+    homeassistant/components/media_player/itunes.py
    homeassistant/components/media_player/kodi.py
    homeassistant/components/media_player/mpd.py
+    homeassistant/components/media_player/plex.py
    homeassistant/components/media_player/squeezebox.py
+    homeassistant/components/media_player/sonos.py
    homeassistant/components/notify/file.py
    homeassistant/components/notify/instapush.py
    homeassistant/components/notify/nma.py
@@ -57,14 +68,19 @@ omit =
    homeassistant/components/notify/slack.py
    homeassistant/components/notify/smtp.py
    homeassistant/components/notify/syslog.py
+    homeassistant/components/notify/telegram.py
    homeassistant/components/notify/xmpp.py
+    homeassistant/components/sensor/arest.py
    homeassistant/components/sensor/bitcoin.py
+    homeassistant/components/sensor/command_sensor.py
+    homeassistant/components/sensor/cpuspeed.py
    homeassistant/components/sensor/dht.py
    homeassistant/components/sensor/efergy.py
    homeassistant/components/sensor/forecast.py
+    homeassistant/components/sensor/glances.py
    homeassistant/components/sensor/mysensors.py
    homeassistant/components/sensor/openweathermap.py
-    homeassistant/components/sensor/rfxtrx.py
+    homeassistant/components/sensor/rest.py
    homeassistant/components/sensor/rpi_gpio.py
    homeassistant/components/sensor/sabnzbd.py
    homeassistant/components/sensor/swiss_public_transport.py
@@ -72,13 +88,17 @@ omit =
    homeassistant/components/sensor/temper.py
    homeassistant/components/sensor/time_date.py
    homeassistant/components/sensor/transmission.py
+    homeassistant/components/sensor/worldclock.py
+    homeassistant/components/switch/arest.py
    homeassistant/components/switch/command_switch.py
    homeassistant/components/switch/edimax.py
    homeassistant/components/switch/hikvisioncam.py
+    homeassistant/components/switch/rest.py
    homeassistant/components/switch/rpi_gpio.py
    homeassistant/components/switch/transmission.py
    homeassistant/components/switch/wemo.py
    homeassistant/components/thermostat/nest.py
+    homeassistant/components/thermostat/radiotherm.py


 [report]
@@ -15,10 +15,6 @@ tests/config/home-assistant.log
 *.sublime-project
 *.sublime-workspace

-# Hide code validator output
-pep8.txt
-pylint.txt
-
 # Hide some OS X stuff
 .DS_Store
 .AppleDouble
@@ -30,6 +26,9 @@ Icon

 .idea

+# pytest
+.cache
+
 # GITHUB Proposed Python stuff:
 *.py[cod]

@@ -1,12 +1,3 @@
-[submodule "homeassistant/external/noop"]
-	path = homeassistant/external/noop
-	url = https://github.com/balloob/noop.git
-[submodule "homeassistant/external/vera"]
-	path = homeassistant/external/vera
-	url = https://github.com/jamespcole/home-assistant-vera-api.git
-[submodule "homeassistant/external/nzbclients"]
-        path = homeassistant/external/nzbclients
-        url = https://github.com/jamespcole/home-assistant-nzb-clients.git
 [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
@@ -1,13 +1,11 @@
 sudo: false
 language: python
+cache:
+  directories:
+    - $HOME/virtualenv/python3.4.2/
 python:
  - "3.4"
 install:
-  - pip install -r requirements_all.txt
-  - pip install flake8 pylint coveralls
+  - script/bootstrap_server
 script:
-  - flake8 homeassistant --exclude bower_components,external
-  - pylint homeassistant
-  - coverage run -m unittest discover tests
-after_success:
-  - coveralls
+  - script/cibuild
@@ -18,10 +18,10 @@ For help on building your component, please see the [developer documentation](ht
 After you finish adding support for your device:

 - Update the supported devices in the `README.md` file.
- - Add any new dependencies to `requirements.txt`.
+ - Add any new dependencies to `requirements_all.txt`. There is no ordering right now, so just add it to the end.
 - Update the `.coveragerc` file.
- - Provide some documentation for [home-assistant.io](https://home-assistant.io/). The documentation is handled in a separate [git repository](https://github.com/balloob/home-assistant.io).
- - Make sure all your code passes Pylint and flake8 (PEP8 and some more) validation. To generate reports, run `pylint homeassistant > pylint.txt` and `flake8 homeassistant --exclude bower_components,external > flake8.txt`.
+ - Provide some documentation for [home-assistant.io](https://home-assistant.io/). The documentation is handled in a separate [git repository](https://github.com/balloob/home-assistant.io). It's OK to add a docstring with configuration details to the file header.
+ - Make sure all your code passes ``pylint`` and ``flake8`` (PEP8 and some more) validation. To check your repository, run `./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 [Travis output](https://travis-ci.org/balloob/home-assistant/).

@@ -10,11 +10,10 @@ RUN apt-get update && \
    apt-get install -y --no-install-recommends nmap net-tools && \
    apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

-# Open Z-Wave disabled because broken
-#RUN apt-get update && \
-#    apt-get install -y cython3 libudev-dev && \
-#    apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* && \
-#    pip3 install cython && \
-#    scripts/build_python_openzwave
+RUN apt-get update && \
+   apt-get install -y cython3 libudev-dev && \
+   apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* && \
+   pip3 install "cython<0.23" && \
+   script/build_python_openzwave

 CMD [ "python", "-m", "homeassistant", "--config", "/config" ]
@@ -0,0 +1,5 @@
+include README.md
+include LICENSE
+graft homeassistant
+prune homeassistant/components/frontend/www_static/home-assistant-polymer
+recursive-exclude * *.py[co]
@@ -16,10 +16,12 @@ Check out [the website](https://home-assistant.io) for [a demo][demo], installat

 Examples of devices it can interface it:

- * Monitoring connected devices to a wireless router: [OpenWrt](https://openwrt.org/), [Tomato](http://www.polarcloud.com/tomato), [Netgear](http://netgear.com), [DD-WRT](http://www.dd-wrt.com/site/index), [TPLink](http://www.tp-link.us/), and [ASUSWRT](http://event.asus.com/2013/nw/ASUSWRT/)
+ * Monitoring connected devices to a wireless router: [OpenWrt](https://openwrt.org/), [Tomato](http://www.polarcloud.com/tomato), [Netgear](http://netgear.com), [DD-WRT](http://www.dd-wrt.com/site/index), [TPLink](http://www.tp-link.us/), [ASUSWRT](http://event.asus.com/2013/nw/ASUSWRT/) and any SNMP capable Linksys WAP/WRT
+ * 
 * [Philips Hue](http://meethue.com) lights, [WeMo](http://www.belkin.com/us/Products/home-automation/c/wemo-home-automation/) switches, [Edimax](http://www.edimax.com/) switches, [Efergy](https://efergy.com) energy monitoring, RFXtrx sensors, and [Tellstick](http://www.telldus.se/products/tellstick) devices and sensors
- * [Google Chromecasts](http://www.google.com/intl/en/chrome/devices/chromecast), [Music Player Daemon](http://www.musicpd.org/), [Logitech Squeezebox](https://en.wikipedia.org/wiki/Squeezebox_%28network_music_player%29), and [Kodi (XBMC)](http://kodi.tv/)
- * Support for [ISY994](https://www.universal-devices.com/residential/isy994i-series/) (Insteon and X10 devices), [Z-Wave](http://www.z-wave.com/), [Nest Thermostats](https://nest.com/), [Arduino](https://www.arduino.cc/), [Raspberry Pi](https://www.raspberrypi.org/), and [Modbus](http://www.modbus.org/)
+ * [Google Chromecasts](http://www.google.com/intl/en/chrome/devices/chromecast), [Music Player Daemon](http://www.musicpd.org/), [Logitech Squeezebox](https://en.wikipedia.org/wiki/Squeezebox_%28network_music_player%29), [Plex](https://plex.tv/), [Kodi (XBMC)](http://kodi.tv/), iTunes (by way of [itunes-api](https://github.com/maddox/itunes-api)), and Amazon Fire TV (by way of [python-firetv](https://github.com/happyleavesaoc/python-firetv))
+ * Support for [ISY994](https://www.universal-devices.com/residential/isy994i-series/) (Insteon and X10 devices), [Z-Wave](http://www.z-wave.com/), [Nest Thermostats](https://nest.com/), [RFXtrx](http://www.rfxcom.com/), [Arduino](https://www.arduino.cc/), [Raspberry Pi](https://www.raspberrypi.org/), and [Modbus](http://www.modbus.org/)
+ * Interaction with [IFTTT](https://ifttt.com/)
 * Integrate data from the [Bitcoin](https://bitcoin.org) network, meteorological data from [OpenWeatherMap](http://openweathermap.org/) and [Forecast.io](https://forecast.io/), [Transmission](http://www.transmissionbt.com/), or [SABnzbd](http://sabnzbd.org).
 * [See full list of supported devices](https://home-assistant.io/components/)

@@ -29,8 +31,8 @@ Built home automation on top of your devices:
 * Turn on the lights when people get home after sun set
 * Turn on lights slowly during sun set to compensate for less light
 * Turn off all lights and devices when everybody leaves the house
- * Offers a [REST API](https://home-assistant.io/developers/api.html) and can interface with MQTT for easy integration with other projects
- * Allow sending notifications using [Instapush](https://instapush.im), [Notify My Android (NMA)](http://www.notifymyandroid.com/), [PushBullet](https://www.pushbullet.com/), [PushOver](https://pushover.net/), [Slack](https://slack.com/), and [Jabber (XMPP)](http://xmpp.org)
+ * Offers a [REST API](https://home-assistant.io/developers/api.html) and can interface with MQTT for easy integration with other projects like [OwnTracks](http://owntracks.org/)
+ * Allow sending notifications using [Instapush](https://instapush.im), [Notify My Android (NMA)](http://www.notifymyandroid.com/), [PushBullet](https://www.pushbullet.com/), [PushOver](https://pushover.net/), [Slack](https://slack.com/), [Telegram](https://telegram.org/), and [Jabber (XMPP)](http://xmpp.org)

 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) and the [section on creating your own components](https://home-assistant.io/developers/creating_components.html).

@@ -1,7 +1,9 @@
 homeassistant:
  # Omitted values in this section will be auto detected using freegeoip.net

-  # Location required to calculate the time the sun rises and sets
+  # Location required to calculate the time the sun rises and sets.  
+  # Cooridinates are also used for location for weather related components. 
+  # Google Maps can be used to determine more precise GPS cooridinates.
  latitude: 32.87336
  longitude: 117.22743

@@ -68,11 +70,18 @@ device_sun_light_trigger:

 # A comma separated list of states that have to be tracked as a single group
 # Grouped states should share the same type of states (ON/OFF or HOME/NOT_HOME)
+# You can also have groups within groups.
 group:
+  Home:
+    - group.living_room
+    - group.kitchen
  living_room:
    - light.Bowl
    - light.Ceiling
    - light.TV_back_light
+  kitchen:
+    - light.fan_bulb_1
+    - light.fan_bulb_2
  children:
   - device_tracker.child_1
   - device_tracker.child_2
@@ -94,28 +103,39 @@ browser:
 keyboard:

 automation:
-  platform: state
-  alias: Sun starts shining
+- alias: 'Rule 1 Light on in the evening'
+  trigger:
+    - platform: sun
+      event: sunset
+      offset: "-01:00:00"
+    - platform: state
+      entity_id: group.all_devices
+      state: home
+  condition:
+    - platform: state
+      entity_id: group.all_devices
+      state: home
+    - platform: time
+      after: "16:00:00"
+      before: "23:00:00"
+  action:
+    service: homeassistant.turn_on
+    entity_id: group.living_room

-  state_entity_id: sun.sun
-  # Next two are optional, omit to match all
-  state_from: below_horizon
-  state_to: above_horizon
+- alias: 'Rule 2 - Away Mode'

-  execute_service: light.turn_off
-  service_entity_id: group.living_room
+  trigger:
+   - platform: state
+     entity_id: group.all_devices
+     state: 'not_home'

-automation 2:
-  platform: time
-  alias: Beer o Clock
+  condition: use_trigger_values
+  action:
+     service: light.turn_off
+     entity_id: group.all_lights

-  time_hours: 16
-  time_minutes: 0
-  time_seconds: 0
-
-  execute_service: notify.notify
-  service_data:
-    message: It's 4, time for beer!
+# Sensors need to be added into the configuration.yaml as sensor:, sensor 2:, sensor 3:, etc. 
+# Each sensor label should be unique or your sensors might not load correctly.

 sensor:
  platform: systemmonitor
@@ -135,6 +155,23 @@ sensor:
    - type: 'process'
      arg: 'octave-cli'

+sensor 2:
+  platform: forecast
+  api_key: <register on Forecast.io for your PRIVATE API>
+  monitored_conditions:
+    - summary
+    - precip_type
+    - precip_intensity
+    - temperature
+    - dew_point
+    - wind_speed
+    - wind_bearing
+    - cloud_cover
+    - humidity
+    - pressure
+    - visibility
+    - ozone
+
 script:
  # Turns on the bedroom lights and then the living room lights 1 minute later
  wakeup:
@@ -12,7 +12,7 @@ Example component to target an entity_id to:
 Configuration:

 To use the Example custom component you will need to add the following to
-your config/configuration.yaml
+your configuration.yaml file.

 example:
  target: TARGET_ENTITY
@@ -1,16 +1,14 @@
 """
 custom_components.hello_world
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Implements the bare minimum that a component should implement.

 Configuration:

 To use the hello_word component you will need to add the following to your
-config/configuration.yaml
+configuration.yaml file.

 hello_world:
-
 """

 # The domain of your component. Should be equal to the name of your component
@@ -1,7 +1,6 @@
 """
 custom_components.mqtt_example
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Shows how to communicate with MQTT. Follows a topic on MQTT and updates the
 state of an entity to the last message received on that topic.

@@ -12,7 +11,7 @@ example payload {"new_state": "some new state"}.
 Configuration:

 To use the mqtt_example component you will need to add the following to your
-config/configuration.yaml
+configuration.yaml file.

 mqtt_example:
  topic: home-assistant/mqtt_example
@@ -77,6 +77,10 @@ def get_arguments():
        '--open-ui',
        action='store_true',
        help='Open the webinterface in a browser')
+    parser.add_argument(
+        '--skip-pip',
+        action='store_true',
+        help='Skips pip install of required packages on startup')
    parser.add_argument(
        '-v', '--verbose',
        action='store_true',
@@ -86,6 +90,23 @@ def get_arguments():
        metavar='path_to_pid_file',
        default=None,
        help='Path to PID file useful for running as daemon')
+    parser.add_argument(
+        '--log-rotate-days',
+        type=int,
+        default=None,
+        help='Enables daily log rotation and keeps up to the specified days')
+    parser.add_argument(
+        '--install-osx',
+        action='store_true',
+        help='Installs as a service on OS X and loads on boot.')
+    parser.add_argument(
+        '--uninstall-osx',
+        action='store_true',
+        help='Uninstalls from OS X.')
+    parser.add_argument(
+        '--restart-osx',
+        action='store_true',
+        help='Restarts on OS X.')
    if os.name != "nt":
        parser.add_argument(
            '--daemon',
@@ -143,6 +164,46 @@ def write_pid(pid_file):
        sys.exit(1)


+def install_osx():
+    """ Setup to run via launchd on OS X """
+    with os.popen('which hass') as inp:
+        hass_path = inp.read().strip()
+
+    with os.popen('whoami') as inp:
+        user = inp.read().strip()
+
+    cwd = os.path.dirname(__file__)
+    template_path = os.path.join(cwd, 'startup', 'launchd.plist')
+
+    with open(template_path, 'r', encoding='utf-8') as inp:
+        plist = inp.read()
+
+    plist = plist.replace("$HASS_PATH$", hass_path)
+    plist = plist.replace("$USER$", user)
+
+    path = os.path.expanduser("~/Library/LaunchAgents/org.homeassistant.plist")
+
+    try:
+        with open(path, 'w', encoding='utf-8') as outp:
+            outp.write(plist)
+    except IOError as err:
+        print('Unable to write to ' + path, err)
+        return
+
+    os.popen('launchctl load -w -F ' + path)
+
+    print("Home Assistant has been installed. \
+        Open it here: http://localhost:8123")
+
+
+def uninstall_osx():
+    """ Unload from launchd on OS X """
+    path = os.path.expanduser("~/Library/LaunchAgents/org.homeassistant.plist")
+    os.popen('launchctl unload ' + path)
+
+    print("Home Assistant has been uninstalled.")
+
+
 def main():
    """ Starts Home Assistant. """
    validate_python()
@@ -152,6 +213,18 @@ def main():
    config_dir = os.path.join(os.getcwd(), args.config)
    ensure_config_path(config_dir)

+    # os x launchd functions
+    if args.install_osx:
+        install_osx()
+        return
+    if args.uninstall_osx:
+        uninstall_osx()
+        return
+    if args.restart_osx:
+        uninstall_osx()
+        install_osx()
+        return
+
    # daemon functions
    if args.pid_file:
        check_pid(args.pid_file)
@@ -161,15 +234,20 @@ def main():
        write_pid(args.pid_file)

    if args.demo_mode:
-        hass = bootstrap.from_config_dict({
+        config = {
            'frontend': {},
            'demo': {}
-        }, config_dir=config_dir, daemon=args.daemon, verbose=args.verbose)
+        }
+        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)
    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)
+            config_file, daemon=args.daemon, verbose=args.verbose,
+            skip_pip=args.skip_pip, log_rotate_days=args.log_rotate_days)

    if args.open_ui:
        def open_browser(event):
@@ -12,6 +12,7 @@ start by calling homeassistant.start_home_assistant(bus)
 import os
 import sys
 import logging
+import logging.handlers
 from collections import defaultdict

 import homeassistant.core as core
@@ -61,7 +62,7 @@ def setup_component(hass, domain, config=None):

 def _handle_requirements(hass, component, name):
    """ Installs requirements for component. """
-    if not hasattr(component, 'REQUIREMENTS'):
+    if hass.config.skip_pip or not hasattr(component, 'REQUIREMENTS'):
        return True

    for req in component.REQUIREMENTS:
@@ -122,6 +123,7 @@ def prepare_setup_platform(hass, config, domain, platform_name):

    # Not found
    if platform is None:
+        _LOGGER.error('Unable to find platform %s', platform_path)
        return None

    # Already loaded
@@ -151,7 +153,8 @@ def mount_local_lib_path(config_dir):

 # 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):
+                     verbose=False, daemon=False, skip_pip=False,
+                     log_rotate_days=None):
    """
    Tries to configure Home Assistant from a config dict.

@@ -167,7 +170,12 @@ def from_config_dict(config, hass=None, config_dir=None, enable_log=True,
    process_ha_core_config(hass, config.get(core.DOMAIN, {}))

    if enable_log:
-        enable_logging(hass, verbose, daemon)
+        enable_logging(hass, verbose, daemon, log_rotate_days)
+
+    hass.config.skip_pip = skip_pip
+    if skip_pip:
+        _LOGGER.warning('Skipping pip installation of required modules. '
+                        'This may cause issues.')

    _ensure_loader_prepared(hass)

@@ -178,8 +186,8 @@ def from_config_dict(config, hass=None, config_dir=None, enable_log=True,
        dict, {key: value or {} for key, value in config.items()})

    # Filter out the repeating and common config section [homeassistant]
-    components = (key for key in config.keys()
-                  if ' ' not in key and key != core.DOMAIN)
+    components = set(key.split(' ')[0] for key in config.keys()
+                     if key != core.DOMAIN)

    if not core_components.setup(hass, config):
        _LOGGER.error('Home Assistant core failed to initialize. '
@@ -196,7 +204,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):
+def from_config_file(config_path, hass=None, verbose=False, daemon=False,
+                     skip_pip=True, log_rotate_days=None):
    """
    Reads the configuration file and tries to start all the required
    functionality. Will add functionality to 'hass' parameter if given,
@@ -210,14 +219,15 @@ 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)
+    enable_logging(hass, verbose, daemon, log_rotate_days)

    config_dict = config_util.load_config_file(config_path)

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


-def enable_logging(hass, verbose=False, daemon=False):
+def enable_logging(hass, verbose=False, daemon=False, log_rotate_days=None):
    """ Setup the logging for home assistant. """
    if not daemon:
        logging.basicConfig(level=logging.INFO)
@@ -250,8 +260,12 @@ def enable_logging(hass, verbose=False, daemon=False):
    if (err_path_exists and os.access(err_log_path, os.W_OK)) or \
       (not err_path_exists and os.access(hass.config.config_dir, os.W_OK)):

-        err_handler = logging.FileHandler(
-            err_log_path, mode='w', delay=True)
+        if log_rotate_days:
+            err_handler = logging.handlers.TimedRotatingFileHandler(
+                err_log_path, when='midnight', backupCount=log_rotate_days)
+        else:
+            err_handler = logging.FileHandler(
+                err_log_path, mode='w', delay=True)

        err_handler.setLevel(logging.INFO if verbose else logging.WARNING)
        err_handler.setFormatter(
@@ -283,11 +297,15 @@ def process_ha_core_config(hass, config):
        else:
            _LOGGER.error('Received invalid time zone %s', time_zone_str)

-    for key, attr in ((CONF_LATITUDE, 'latitude'),
-                      (CONF_LONGITUDE, 'longitude'),
-                      (CONF_NAME, 'location_name')):
+    for key, attr, typ in ((CONF_LATITUDE, 'latitude', float),
+                           (CONF_LONGITUDE, 'longitude', float),
+                           (CONF_NAME, 'location_name', str)):
        if key in config:
-            setattr(hac, attr, config[key])
+            try:
+                setattr(hac, attr, typ(config[key]))
+            except ValueError:
+                _LOGGER.error('Received invalid %s value for %s: %s',
+                              typ.__name__, key, attr)

    set_time_zone(config.get(CONF_TIME_ZONE))

@@ -0,0 +1,151 @@
+"""
+homeassistant.components.alarm_control_panel
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Component to interface with a alarm control panel.
+"""
+import logging
+import os
+
+from homeassistant.components import verisure
+from homeassistant.const import (
+    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.entity import Entity
+from homeassistant.helpers.entity_component import EntityComponent
+
+DOMAIN = 'alarm_control_panel'
+DEPENDENCIES = []
+SCAN_INTERVAL = 30
+
+ENTITY_ID_FORMAT = DOMAIN + '.{}'
+
+# Maps discovered services to their platforms
+DISCOVERY_PLATFORMS = {
+    verisure.DISCOVER_SENSORS: 'verisure'
+}
+
+SERVICE_TO_METHOD = {
+    SERVICE_ALARM_DISARM: 'alarm_disarm',
+    SERVICE_ALARM_ARM_HOME: 'alarm_arm_home',
+    SERVICE_ALARM_ARM_AWAY: 'alarm_arm_away',
+    SERVICE_ALARM_TRIGGER: 'alarm_trigger'
+}
+
+ATTR_CODE = 'code'
+ATTR_CODE_FORMAT = 'code_format'
+
+ATTR_TO_PROPERTY = [
+    ATTR_CODE,
+    ATTR_CODE_FORMAT
+]
+
+
+def setup(hass, config):
+    """ Track states and offer events for sensors. """
+    component = EntityComponent(
+        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL,
+        DISCOVERY_PLATFORMS)
+
+    component.setup(config)
+
+    def alarm_service_handler(service):
+        """ Maps 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]
+
+        method = SERVICE_TO_METHOD[service.service]
+
+        for alarm in target_alarms:
+            getattr(alarm, method)(code)
+
+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+
+    for service in SERVICE_TO_METHOD:
+        hass.services.register(DOMAIN, service, alarm_service_handler,
+                               descriptions.get(service))
+
+    return True
+
+
+def alarm_disarm(hass, code=None, entity_id=None):
+    """ Send the alarm the command for disarm. """
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_DISARM, data)
+
+
+def alarm_arm_home(hass, code=None, entity_id=None):
+    """ Send the alarm the command for arm home. """
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_HOME, data)
+
+
+def alarm_arm_away(hass, code=None, entity_id=None):
+    """ Send the alarm the command for arm away. """
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_AWAY, data)
+
+
+def alarm_trigger(hass, code=None, entity_id=None):
+    """ Send the alarm the command for trigger. """
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_TRIGGER, data)
+
+
+# pylint: disable=no-self-use
+class AlarmControlPanel(Entity):
+    """ ABC for alarm control devices. """
+
+    @property
+    def code_format(self):
+        """ regex for code format or None if no code is required. """
+        return None
+
+    def alarm_disarm(self, code=None):
+        """ Send disarm command. """
+        raise NotImplementedError()
+
+    def alarm_arm_home(self, code=None):
+        """ Send arm home command. """
+        raise NotImplementedError()
+
+    def alarm_arm_away(self, code=None):
+        """ Send arm away command. """
+        raise NotImplementedError()
+
+    def alarm_trigger(self, code=None):
+        """ Send alarm trigger command. """
+        raise NotImplementedError()
+
+    @property
+    def state_attributes(self):
+        """ Return the state attributes. """
+        state_attr = {
+            ATTR_CODE_FORMAT: self.code_format,
+            }
+        return state_attr
@@ -0,0 +1,149 @@
+"""
+homeassistant.components.alarm_control_panel.manual
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Support for manual alarms.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.manual.html
+"""
+import logging
+import datetime
+import homeassistant.components.alarm_control_panel as alarm
+from homeassistant.helpers.event import track_point_in_time
+import homeassistant.util.dt as dt_util
+
+from homeassistant.const import (
+    STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_AWAY,
+    STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = []
+
+DEFAULT_ALARM_NAME = 'HA Alarm'
+DEFAULT_PENDING_TIME = 60
+DEFAULT_TRIGGER_TIME = 120
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Sets up the manual alarm platform. """
+
+    add_devices([ManualAlarm(
+        hass,
+        config.get('name', DEFAULT_ALARM_NAME),
+        config.get('code'),
+        config.get('pending_time', DEFAULT_PENDING_TIME),
+        config.get('trigger_time', DEFAULT_TRIGGER_TIME),
+        )])
+
+
+# pylint: disable=too-many-arguments, too-many-instance-attributes
+# pylint: disable=abstract-method
+class ManualAlarm(alarm.AlarmControlPanel):
+    """
+    Represents an alarm status.
+
+    When armed, will be pending for 'pending_time', after that armed.
+    When triggered, will be pending for 'trigger_time'. After that will be
+    triggered for 'trigger_time', after that we return to disarmed.
+    """
+
+    def __init__(self, hass, name, code, pending_time, trigger_time):
+        self._state = STATE_ALARM_DISARMED
+        self._hass = hass
+        self._name = name
+        self._code = str(code) if code else None
+        self._pending_time = datetime.timedelta(seconds=pending_time)
+        self._trigger_time = datetime.timedelta(seconds=trigger_time)
+        self._state_ts = None
+
+    @property
+    def should_poll(self):
+        """ No polling needed. """
+        return False
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self._name
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        if self._state in (STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_AWAY) and \
+           self._pending_time and self._state_ts + self._pending_time > \
+           dt_util.utcnow():
+            return STATE_ALARM_PENDING
+
+        if self._state == STATE_ALARM_TRIGGERED and self._trigger_time:
+            if self._state_ts + self._pending_time > dt_util.utcnow():
+                return STATE_ALARM_PENDING
+            elif (self._state_ts + self._pending_time +
+                  self._trigger_time) < dt_util.utcnow():
+                return STATE_ALARM_DISARMED
+
+        return self._state
+
+    @property
+    def code_format(self):
+        """ One or more characters. """
+        return None if self._code is None else '.+'
+
+    def alarm_disarm(self, code=None):
+        """ Send disarm command. """
+        if not self._validate_code(code, STATE_ALARM_DISARMED):
+            return
+
+        self._state = STATE_ALARM_DISARMED
+        self._state_ts = dt_util.utcnow()
+        self.update_ha_state()
+
+    def alarm_arm_home(self, code=None):
+        """ Send arm home command. """
+        if not self._validate_code(code, STATE_ALARM_ARMED_HOME):
+            return
+
+        self._state = STATE_ALARM_ARMED_HOME
+        self._state_ts = dt_util.utcnow()
+        self.update_ha_state()
+
+        if self._pending_time:
+            track_point_in_time(
+                self._hass, self.update_ha_state,
+                self._state_ts + self._pending_time)
+
+    def alarm_arm_away(self, code=None):
+        """ Send arm away command. """
+        if not self._validate_code(code, STATE_ALARM_ARMED_AWAY):
+            return
+
+        self._state = STATE_ALARM_ARMED_AWAY
+        self._state_ts = dt_util.utcnow()
+        self.update_ha_state()
+
+        if self._pending_time:
+            track_point_in_time(
+                self._hass, self.update_ha_state,
+                self._state_ts + self._pending_time)
+
+    def alarm_trigger(self, code=None):
+        """ Send alarm trigger command. No code needed. """
+        self._state = STATE_ALARM_TRIGGERED
+        self._state_ts = dt_util.utcnow()
+        self.update_ha_state()
+
+        if self._trigger_time:
+            track_point_in_time(
+                self._hass, self.update_ha_state,
+                self._state_ts + self._pending_time)
+
+            track_point_in_time(
+                self._hass, self.update_ha_state,
+                self._state_ts + self._pending_time + self._trigger_time)
+
+    def _validate_code(self, code, state):
+        """ Validate given code. """
+        check = self._code is None or code == self._code
+        if not check:
+            _LOGGER.warning('Invalid code given for %s', state)
+        return check
@@ -0,0 +1,127 @@
+"""
+homeassistant.components.alarm_control_panel.mqtt
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This platform enables the possibility to control a MQTT alarm.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.mqtt.html
+"""
+import logging
+import homeassistant.components.mqtt as mqtt
+import homeassistant.components.alarm_control_panel as alarm
+
+from homeassistant.const import (
+    STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_AWAY,
+    STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED, STATE_UNKNOWN)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = "MQTT Alarm"
+DEFAULT_QOS = 0
+DEFAULT_PAYLOAD_DISARM = "DISARM"
+DEFAULT_PAYLOAD_ARM_HOME = "ARM_HOME"
+DEFAULT_PAYLOAD_ARM_AWAY = "ARM_AWAY"
+
+DEPENDENCIES = ['mqtt']
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Sets up the MQTT platform. """
+
+    if config.get('state_topic') is None:
+        _LOGGER.error("Missing required variable: state_topic")
+        return False
+
+    if config.get('command_topic') is None:
+        _LOGGER.error("Missing required variable: command_topic")
+        return False
+
+    add_devices([MqttAlarm(
+        hass,
+        config.get('name', DEFAULT_NAME),
+        config.get('state_topic'),
+        config.get('command_topic'),
+        config.get('qos', DEFAULT_QOS),
+        config.get('payload_disarm', DEFAULT_PAYLOAD_DISARM),
+        config.get('payload_arm_home', DEFAULT_PAYLOAD_ARM_HOME),
+        config.get('payload_arm_away', DEFAULT_PAYLOAD_ARM_AWAY),
+        config.get('code'))])
+
+
+# pylint: disable=too-many-arguments, too-many-instance-attributes
+# pylint: disable=abstract-method
+class MqttAlarm(alarm.AlarmControlPanel):
+    """ represents a MQTT alarm status within home assistant. """
+
+    def __init__(self, hass, name, state_topic, command_topic, qos,
+                 payload_disarm, payload_arm_home, payload_arm_away, code):
+        self._state = STATE_UNKNOWN
+        self._hass = hass
+        self._name = name
+        self._state_topic = state_topic
+        self._command_topic = command_topic
+        self._qos = qos
+        self._payload_disarm = payload_disarm
+        self._payload_arm_home = payload_arm_home
+        self._payload_arm_away = payload_arm_away
+        self._code = str(code) if code else None
+
+        def message_received(topic, payload, qos):
+            """ A new MQTT message has been received. """
+            if payload not in (STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME,
+                               STATE_ALARM_ARMED_AWAY, STATE_ALARM_PENDING,
+                               STATE_ALARM_TRIGGERED):
+                _LOGGER.warning('Received unexpected payload: %s', payload)
+                return
+            self._state = payload
+            self.update_ha_state()
+
+        mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
+
+    @property
+    def should_poll(self):
+        """ No polling needed """
+        return False
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self._name
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        return self._state
+
+    @property
+    def code_format(self):
+        """ One or more characters if code is defined """
+        return None if self._code is None else '.+'
+
+    def alarm_disarm(self, code=None):
+        """ Send disarm command. """
+        if not self._validate_code(code, 'disarming'):
+            return
+        mqtt.publish(self.hass, self._command_topic,
+                     self._payload_disarm, self._qos)
+
+    def alarm_arm_home(self, code=None):
+        """ Send arm home command. """
+        if not self._validate_code(code, 'arming home'):
+            return
+        mqtt.publish(self.hass, self._command_topic,
+                     self._payload_arm_home, self._qos)
+
+    def alarm_arm_away(self, code=None):
+        """ Send arm away command. """
+        if not self._validate_code(code, 'arming away'):
+            return
+        mqtt.publish(self.hass, self._command_topic,
+                     self._payload_arm_away, self._qos)
+
+    def _validate_code(self, code, state):
+        """ Validate given code. """
+        check = self._code is None or code == self._code
+        if not check:
+            _LOGGER.warning('Wrong code entered for %s', state)
+        return check
@@ -0,0 +1,94 @@
+"""
+homeassistant.components.alarm_control_panel.verisure
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Interfaces with Verisure alarm control panel.
+"""
+import logging
+
+import homeassistant.components.verisure as verisure
+import homeassistant.components.alarm_control_panel as alarm
+
+from homeassistant.const import (
+    STATE_UNKNOWN,
+    STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_AWAY)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Sets up the Verisure platform. """
+
+    if not verisure.MY_PAGES:
+        _LOGGER.error('A connection has not been made to Verisure mypages.')
+        return False
+
+    alarms = []
+
+    alarms.extend([
+        VerisureAlarm(value)
+        for value in verisure.get_alarm_status().values()
+        if verisure.SHOW_ALARM
+        ])
+
+    add_devices(alarms)
+
+
+# pylint: disable=abstract-method
+class VerisureAlarm(alarm.AlarmControlPanel):
+    """ Represents a Verisure alarm status. """
+
+    def __init__(self, alarm_status):
+        self._id = alarm_status.id
+        self._device = verisure.MY_PAGES.DEVICE_ALARM
+        self._state = STATE_UNKNOWN
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return 'Alarm {}'.format(self._id)
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        return self._state
+
+    @property
+    def code_format(self):
+        """ Four digit code required. """
+        return '^\\d{4}$'
+
+    def update(self):
+        """ Update alarm status """
+        verisure.update()
+
+        if verisure.STATUS[self._device][self._id].status == 'unarmed':
+            self._state = STATE_ALARM_DISARMED
+        elif verisure.STATUS[self._device][self._id].status == 'armedhome':
+            self._state = STATE_ALARM_ARMED_HOME
+        elif verisure.STATUS[self._device][self._id].status == 'armedaway':
+            self._state = STATE_ALARM_ARMED_AWAY
+        elif verisure.STATUS[self._device][self._id].status != 'pending':
+            _LOGGER.error(
+                'Unknown alarm state %s',
+                verisure.STATUS[self._device][self._id].status)
+
+    def alarm_disarm(self, code=None):
+        """ Send disarm command. """
+        verisure.MY_PAGES.set_alarm_status(
+            code,
+            verisure.MY_PAGES.ALARM_DISARMED)
+        _LOGGER.warning('disarming')
+
+    def alarm_arm_home(self, code=None):
+        """ Send arm home command. """
+        verisure.MY_PAGES.set_alarm_status(
+            code,
+            verisure.MY_PAGES.ALARM_ARMED_HOME)
+        _LOGGER.warning('arming home')
+
+    def alarm_arm_away(self, code=None):
+        """ Send arm away command. """
+        verisure.MY_PAGES.set_alarm_status(
+            code,
+            verisure.MY_PAGES.ALARM_ARMED_AWAY)
+        _LOGGER.warning('arming away')
@@ -1,8 +1,10 @@
 """
 homeassistant.components.api
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provides a Rest API for Home Assistant.
+
+For more details about the RESTful API, please refer to the documentation at
+https://home-assistant.io/developers/api.html
 """
 import re
 import logging
@@ -103,6 +105,10 @@ def _handle_get_api_stream(handler, path_match, data):
    write_lock = threading.Lock()
    block = threading.Event()

+    restrict = data.get('restrict')
+    if restrict:
+        restrict = restrict.split(',')
+
    def write_message(payload):
        """ Writes a message to the output. """
        with write_lock:
@@ -118,7 +124,8 @@ def _handle_get_api_stream(handler, path_match, data):
        """ Forwards events to the open request. """
        nonlocal gracefully_closed

-        if block.is_set() or event.event_type == EVENT_TIME_CHANGED:
+        if block.is_set() or event.event_type == EVENT_TIME_CHANGED or \
+           restrict and event.event_type not in restrict:
            return
        elif event.event_type == EVENT_HOMEASSISTANT_STOP:
            gracefully_closed = True
@@ -4,26 +4,8 @@ components.arduino
 Arduino component that connects to a directly attached Arduino board which
 runs with the Firmata firmware.

-Configuration:
-
-To use the Arduino board you will need to add something like the following
-to your config/configuration.yaml
-
-arduino:
-    port: /dev/ttyACM0
-
-Variables:
-
-port
-*Required
-The port where is your board connected to your Home Assistant system.
-If you are using an original Arduino the port will be named ttyACM*. The exact
-number can be determined with 'ls /dev/ttyACM*' or check your 'dmesg'/
-'journalctl -f' output. Keep in mind that Arduino clones are often using a
-different name for the port (e.g. '/dev/ttyUSB*').
-
-A word of caution: The Arduino is not storing states. This means that with
-every initialization the pins are set to off/low.
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/arduino.html
 """
 import logging

@@ -7,68 +7,217 @@ Allows to setup simple automation rules via the config file.
 import logging

 from homeassistant.bootstrap import prepare_setup_platform
-from homeassistant.helpers import config_per_platform
 from homeassistant.util import split_entity_id
-from homeassistant.const import ATTR_ENTITY_ID
+from homeassistant.const import ATTR_ENTITY_ID, CONF_PLATFORM
+from homeassistant.components import logbook

-DOMAIN = "automation"
+DOMAIN = 'automation'

-DEPENDENCIES = ["group"]
+DEPENDENCIES = ['group']

-CONF_ALIAS = "alias"
-CONF_SERVICE = "execute_service"
-CONF_SERVICE_ENTITY_ID = "service_entity_id"
-CONF_SERVICE_DATA = "service_data"
+CONF_ALIAS = 'alias'
+CONF_SERVICE = 'service'
+CONF_SERVICE_ENTITY_ID = 'entity_id'
+CONF_SERVICE_DATA = 'data'
+
+CONF_CONDITION = 'condition'
+CONF_ACTION = 'action'
+CONF_TRIGGER = 'trigger'
+CONF_CONDITION_TYPE = 'condition_type'
+
+CONDITION_USE_TRIGGER_VALUES = 'use_trigger_values'
+CONDITION_TYPE_AND = 'and'
+CONDITION_TYPE_OR = 'or'
+
+DEFAULT_CONDITION_TYPE = CONDITION_TYPE_AND

 _LOGGER = logging.getLogger(__name__)


 def setup(hass, config):
    """ Sets up automation. """
-    success = False
+    config_key = DOMAIN
+    found = 1

-    for p_type, p_config in config_per_platform(config, DOMAIN, _LOGGER):
-        platform = prepare_setup_platform(hass, config, DOMAIN, p_type)
+    while config_key in config:
+        # check for one block syntax
+        if isinstance(config[config_key], dict):
+            config_block = _migrate_old_config(config[config_key])
+            name = config_block.get(CONF_ALIAS, config_key)
+            _setup_automation(hass, config_block, name, config)

-        if platform is None:
-            _LOGGER.error("Unknown automation platform specified: %s", p_type)
-            continue
+        # check for multiple block syntax
+        elif isinstance(config[config_key], list):
+            for list_no, config_block in enumerate(config[config_key]):
+                name = config_block.get(CONF_ALIAS,
+                                        "{}, {}".format(config_key, list_no))
+                _setup_automation(hass, config_block, name, config)

-        if platform.register(hass, p_config, _get_action(hass, p_config)):
-            _LOGGER.info(
-                "Initialized %s rule %s", p_type, p_config.get(CONF_ALIAS, ""))
-            success = True
+        # any scalar value is incorrect
        else:
-            _LOGGER.error(
-                "Error setting up rule %s", p_config.get(CONF_ALIAS, ""))
+            _LOGGER.error('Error in config in section %s.', config_key)

-    return success
+        found += 1
+        config_key = "{} {}".format(DOMAIN, found)
+
+    return True


-def _get_action(hass, config):
+def _setup_automation(hass, config_block, name, config):
+    """ Setup one instance of automation """
+
+    action = _get_action(hass, config_block.get(CONF_ACTION, {}), name)
+
+    if action is None:
+        return False
+
+    if CONF_CONDITION in config_block or CONF_CONDITION_TYPE in config_block:
+        action = _process_if(hass, config, config_block, action)
+
+        if action is None:
+            return False
+
+    _process_trigger(hass, config, config_block.get(CONF_TRIGGER, []), name,
+                     action)
+    return True
+
+
+def _get_action(hass, config, name):
    """ Return an action based on a config. """

+    if CONF_SERVICE not in config:
+        _LOGGER.error('Error setting up %s, no action specified.', name)
+        return None
+
    def action():
        """ Action to be executed. """
-        _LOGGER.info("Executing rule %s", config.get(CONF_ALIAS, ""))
+        _LOGGER.info('Executing %s', name)
+        logbook.log_entry(hass, name, 'has been triggered', DOMAIN)

-        if CONF_SERVICE in config:
-            domain, service = split_entity_id(config[CONF_SERVICE])
+        domain, service = split_entity_id(config[CONF_SERVICE])
+        service_data = config.get(CONF_SERVICE_DATA, {})

-            service_data = config.get(CONF_SERVICE_DATA, {})
+        if not isinstance(service_data, dict):
+            _LOGGER.error("%s should be a dictionary", CONF_SERVICE_DATA)
+            service_data = {}

-            if not isinstance(service_data, dict):
-                _LOGGER.error("%s should be a dictionary", CONF_SERVICE_DATA)
-                service_data = {}
+        if CONF_SERVICE_ENTITY_ID in config:
+            try:
+                service_data[ATTR_ENTITY_ID] = \
+                    config[CONF_SERVICE_ENTITY_ID].split(",")
+            except AttributeError:
+                service_data[ATTR_ENTITY_ID] = \
+                    config[CONF_SERVICE_ENTITY_ID]

-            if CONF_SERVICE_ENTITY_ID in config:
-                try:
-                    service_data[ATTR_ENTITY_ID] = \
-                        config[CONF_SERVICE_ENTITY_ID].split(",")
-                except AttributeError:
-                    service_data[ATTR_ENTITY_ID] = \
-                        config[CONF_SERVICE_ENTITY_ID]
-
-            hass.services.call(domain, service, service_data)
+        hass.services.call(domain, service, service_data)

    return action
+
+
+def _migrate_old_config(config):
+    """ Migrate old config to new. """
+    if CONF_PLATFORM not in config:
+        return config
+
+    _LOGGER.warning(
+        'You are using an old configuration format. Please upgrade: '
+        'https://home-assistant.io/components/automation.html')
+
+    new_conf = {
+        CONF_TRIGGER: dict(config),
+        CONF_CONDITION: config.get('if', []),
+        CONF_ACTION: dict(config),
+    }
+
+    for cat, key, new_key in (('trigger', 'mqtt_topic', 'topic'),
+                              ('trigger', 'mqtt_payload', 'payload'),
+                              ('trigger', 'state_entity_id', 'entity_id'),
+                              ('trigger', 'state_before', 'before'),
+                              ('trigger', 'state_after', 'after'),
+                              ('trigger', 'state_to', 'to'),
+                              ('trigger', 'state_from', 'from'),
+                              ('trigger', 'state_hours', 'hours'),
+                              ('trigger', 'state_minutes', 'minutes'),
+                              ('trigger', 'state_seconds', 'seconds'),
+                              ('action', 'execute_service', 'service'),
+                              ('action', 'service_entity_id', 'entity_id'),
+                              ('action', 'service_data', 'data')):
+        if key in new_conf[cat]:
+            new_conf[cat][new_key] = new_conf[cat].pop(key)
+
+    return new_conf
+
+
+def _process_if(hass, config, p_config, action):
+    """ Processes if checks. """
+
+    cond_type = p_config.get(CONF_CONDITION_TYPE,
+                             DEFAULT_CONDITION_TYPE).lower()
+
+    if_configs = p_config.get(CONF_CONDITION)
+    use_trigger = if_configs == CONDITION_USE_TRIGGER_VALUES
+
+    if use_trigger:
+        if_configs = p_config[CONF_TRIGGER]
+
+    if isinstance(if_configs, dict):
+        if_configs = [if_configs]
+
+    checks = []
+    for if_config in if_configs:
+        platform = _resolve_platform('if_action', hass, config,
+                                     if_config.get(CONF_PLATFORM))
+        if platform is None:
+            continue
+
+        check = platform.if_action(hass, if_config)
+
+        # Invalid conditions are allowed if we base it on trigger
+        if check is None and not use_trigger:
+            return None
+
+        checks.append(check)
+
+    if cond_type == CONDITION_TYPE_AND:
+        def if_action():
+            """ AND all conditions. """
+            if all(check() for check in checks):
+                action()
+    else:
+        def if_action():
+            """ OR all conditions. """
+            if any(check() for check in checks):
+                action()
+
+    return if_action
+
+
+def _process_trigger(hass, config, trigger_configs, name, action):
+    """ Setup triggers. """
+    if isinstance(trigger_configs, dict):
+        trigger_configs = [trigger_configs]
+
+    for conf in trigger_configs:
+        platform = _resolve_platform('trigger', hass, config,
+                                     conf.get(CONF_PLATFORM))
+        if platform is None:
+            continue
+
+        if platform.trigger(hass, conf, action):
+            _LOGGER.info("Initialized rule %s", name)
+        else:
+            _LOGGER.error("Error setting up rule %s", name)
+
+
+def _resolve_platform(method, hass, config, platform):
+    """ Find automation platform. """
+    if platform is None:
+        return None
+    platform = prepare_setup_platform(hass, config, DOMAIN, platform)
+
+    if platform is None or not hasattr(platform, method):
+        _LOGGER.error("Unknown automation platform specified for %s: %s",
+                      method, platform)
+        return None
+
+    return platform
@@ -1,8 +1,10 @@
 """
 homeassistant.components.automation.event
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Offers event listening automation rules.
+
+For more details about this automation rule, please refer to the documentation
+at https://home-assistant.io/components/automation.html#event-trigger
 """
 import logging

@@ -12,7 +14,7 @@ CONF_EVENT_DATA = "event_data"
 _LOGGER = logging.getLogger(__name__)


-def register(hass, config, action):
+def trigger(hass, config, action):
    """ Listen for events based on config. """
    event_type = config.get(CONF_EVENT_TYPE)

@@ -20,11 +22,12 @@ def register(hass, config, action):
        _LOGGER.error("Missing configuration key %s", CONF_EVENT_TYPE)
        return False

-    event_data = config.get(CONF_EVENT_DATA, {})
+    event_data = config.get(CONF_EVENT_DATA)

    def handle_event(event):
        """ Listens for events and calls the action when data matches. """
-        if event_data == event.data:
+        if not event_data or all(val == event.data.get(key) for key, val
+                                 in event_data.items()):
            action()

    hass.bus.listen(event_type, handle_event)
@@ -1,8 +1,10 @@
 """
 homeassistant.components.automation.mqtt
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Offers MQTT listening automation rules.
+
+For more details about this automation rule, please refer to the documentation
+at https://home-assistant.io/components/automation.html#mqtt-trigger
 """
 import logging

@@ -10,11 +12,11 @@ import homeassistant.components.mqtt as mqtt

 DEPENDENCIES = ['mqtt']

-CONF_TOPIC = 'mqtt_topic'
-CONF_PAYLOAD = 'mqtt_payload'
+CONF_TOPIC = 'topic'
+CONF_PAYLOAD = 'payload'


-def register(hass, config, action):
+def trigger(hass, config, action):
    """ Listen for state changes based on `config`. """
    topic = config.get(CONF_TOPIC)
    payload = config.get(CONF_PAYLOAD)
@@ -0,0 +1,93 @@
+"""
+homeassistant.components.automation.numeric_state
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Offers numeric state listening automation rules.
+
+For more details about this automation rule, please refer to the documentation
+at https://home-assistant.io/components/automation.html#numeric-state-trigger
+"""
+import logging
+
+from homeassistant.helpers.event import track_state_change
+
+
+CONF_ENTITY_ID = "entity_id"
+CONF_BELOW = "below"
+CONF_ABOVE = "above"
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def trigger(hass, config, action):
+    """ Listen for state changes based on `config`. """
+    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)
+
+    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
+
+    # pylint: disable=unused-argument
+    def state_automation_listener(entity, from_s, to_s):
+        """ Listens for state changes and calls action. """
+
+        # Fire action if we go from outside range into range
+        if _in_range(to_s.state, above, below) and \
+                (from_s is None or not _in_range(from_s.state, above, below)):
+            action()
+
+    track_state_change(
+        hass, entity_id, state_automation_listener)
+
+    return True
+
+
+def if_action(hass, config):
+    """ Wraps 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)
+
+    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
+
+    def if_numeric_state():
+        """ Test numeric state condition. """
+        state = hass.states.get(entity_id)
+        return state is not None and _in_range(state.state, above, below)
+
+    return if_numeric_state
+
+
+def _in_range(value, range_start, range_end):
+    """ Checks if value is inside the range """
+
+    try:
+        value = float(value)
+    except ValueError:
+        _LOGGER.warn("Missing value in numeric check")
+        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
@@ -1,8 +1,10 @@
 """
 homeassistant.components.automation.state
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Offers state listening automation rules.
+
+For more details about this automation rule, please refer to the documentation
+at https://home-assistant.io/components/automation.html#state-trigger
 """
 import logging

@@ -10,22 +12,28 @@ from homeassistant.helpers.event import track_state_change
 from homeassistant.const import MATCH_ALL


-CONF_ENTITY_ID = "state_entity_id"
-CONF_FROM = "state_from"
-CONF_TO = "state_to"
+CONF_ENTITY_ID = "entity_id"
+CONF_FROM = "from"
+CONF_TO = "to"
+CONF_STATE = "state"


-def register(hass, config, action):
+def trigger(hass, config, action):
    """ Listen for state changes based on `config`. """
    entity_id = config.get(CONF_ENTITY_ID)

    if entity_id is None:
        logging.getLogger(__name__).error(
-            "Missing configuration key %s", CONF_ENTITY_ID)
+            "Missing trigger configuration key %s", CONF_ENTITY_ID)
        return False

    from_state = config.get(CONF_FROM, MATCH_ALL)
-    to_state = config.get(CONF_TO, MATCH_ALL)
+    to_state = config.get(CONF_TO) or config.get(CONF_STATE) or MATCH_ALL
+
+    if isinstance(from_state, bool) or isinstance(to_state, bool):
+        logging.getLogger(__name__).error(
+            'Config error. Surround to/from values with quotes.')
+        return False

    def state_automation_listener(entity, from_s, to_s):
        """ Listens for state changes and calls action. """
@@ -35,3 +43,23 @@ def register(hass, config, action):
        hass, entity_id, state_automation_listener, from_state, to_state)

    return True
+
+
+def if_action(hass, config):
+    """ Wraps action method with state based condition. """
+    entity_id = config.get(CONF_ENTITY_ID)
+    state = config.get(CONF_STATE)
+
+    if entity_id is None or state is None:
+        logging.getLogger(__name__).error(
+            "Missing if-condition configuration key %s or %s", CONF_ENTITY_ID,
+            CONF_STATE)
+        return None
+
+    state = str(state)
+
+    def if_state():
+        """ Test if condition. """
+        return hass.states.is_state(entity_id, state)
+
+    return if_state
@@ -0,0 +1,105 @@
+"""
+homeassistant.components.automation.sun
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Offers sun based automation rules.
+
+For more details about this automation rule, please refer to the documentation
+at https://home-assistant.io/components/automation.html#sun-trigger
+"""
+import logging
+from datetime import timedelta
+
+from homeassistant.components import sun
+from homeassistant.helpers.event import track_point_in_utc_time
+import homeassistant.util.dt as dt_util
+
+DEPENDENCIES = ['sun']
+
+CONF_OFFSET = 'offset'
+CONF_EVENT = 'event'
+
+EVENT_SUNSET = 'sunset'
+EVENT_SUNRISE = 'sunrise'
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def trigger(hass, config, action):
+    """ Listen for events based on config. """
+    event = config.get(CONF_EVENT)
+
+    if event is None:
+        _LOGGER.error("Missing configuration key %s", CONF_EVENT)
+        return False
+
+    event = event.lower()
+    if event not in (EVENT_SUNRISE, EVENT_SUNSET):
+        _LOGGER.error("Invalid value for %s: %s", CONF_EVENT, event)
+        return False
+
+    if CONF_OFFSET in config:
+        raw_offset = config.get(CONF_OFFSET)
+
+        negative_offset = False
+        if raw_offset.startswith('-'):
+            negative_offset = True
+            raw_offset = raw_offset[1:]
+
+        try:
+            (hour, minute, second) = [int(x) for x in raw_offset.split(':')]
+        except ValueError:
+            _LOGGER.error('Could not parse offset %s', raw_offset)
+            return False
+
+        offset = timedelta(hours=hour, minutes=minute, seconds=second)
+
+        if negative_offset:
+            offset *= -1
+    else:
+        offset = timedelta(0)
+
+    # Do something to call action
+    if event == EVENT_SUNRISE:
+        trigger_sunrise(hass, action, offset)
+    else:
+        trigger_sunset(hass, action, offset)
+
+    return True
+
+
+def trigger_sunrise(hass, action, offset):
+    """ Trigger action at next sun rise. """
+    def next_rise():
+        """ Returns next sunrise. """
+        next_time = sun.next_rising_utc(hass) + offset
+
+        while next_time < dt_util.utcnow():
+            next_time = next_time + timedelta(days=1)
+
+        return next_time
+
+    def sunrise_automation_listener(now):
+        """ Called when it's time for action. """
+        track_point_in_utc_time(hass, sunrise_automation_listener, next_rise())
+        action()
+
+    track_point_in_utc_time(hass, sunrise_automation_listener, next_rise())
+
+
+def trigger_sunset(hass, action, offset):
+    """ Trigger action at next sun set. """
+    def next_set():
+        """ Returns next sunrise. """
+        next_time = sun.next_setting_utc(hass) + offset
+
+        while next_time < dt_util.utcnow():
+            next_time = next_time + timedelta(days=1)
+
+        return next_time
+
+    def sunset_automation_listener(now):
+        """ Called when it's time for action. """
+        track_point_in_utc_time(hass, sunset_automation_listener, next_set())
+        action()
+
+    track_point_in_utc_time(hass, sunset_automation_listener, next_set())
@@ -1,22 +1,46 @@
 """
 homeassistant.components.automation.time
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Offers time listening automation rules.
+
+For more details about this automation rule, please refer to the documentation
+at https://home-assistant.io/components/automation.html#time-trigger
 """
+import logging
+
 from homeassistant.util import convert
+import homeassistant.util.dt as dt_util
 from homeassistant.helpers.event import track_time_change

-CONF_HOURS = "time_hours"
-CONF_MINUTES = "time_minutes"
-CONF_SECONDS = "time_seconds"
+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__)


-def register(hass, config, action):
+def trigger(hass, config, action):
    """ Listen for state changes based on `config`. """
-    hours = convert(config.get(CONF_HOURS), int)
-    minutes = convert(config.get(CONF_MINUTES), int)
-    seconds = convert(config.get(CONF_SECONDS), int)
+    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
+        hours, minutes, seconds = after.hour, after.minute, after.second
+    elif (CONF_HOURS in config or CONF_MINUTES in config
+          or CONF_SECONDS in config):
+        hours = convert(config.get(CONF_HOURS), int)
+        minutes = convert(config.get(CONF_MINUTES), int)
+        seconds = convert(config.get(CONF_SECONDS), int)
+    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):
        """ Listens for time changes and calls action. """
@@ -26,3 +50,58 @@ def register(hass, config, action):
                      hour=hours, minute=minutes, second=seconds)

    return True
+
+
+def if_action(hass, config):
+    """ Wraps 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:
+        logging.getLogger(__name__).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')
@@ -0,0 +1,87 @@
+"""
+homeassistant.components.automation.zone
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Offers zone automation rules.
+
+For more details about this automation rule, please refer to the documentation
+at https://home-assistant.io/components/automation.html#zone-trigger
+"""
+import logging
+
+from homeassistant.components import zone
+from homeassistant.helpers.event import track_state_change
+from homeassistant.const import (
+    ATTR_GPS_ACCURACY, ATTR_LATITUDE, ATTR_LONGITUDE, MATCH_ALL)
+
+
+CONF_ENTITY_ID = "entity_id"
+CONF_ZONE = "zone"
+CONF_EVENT = "event"
+EVENT_ENTER = "enter"
+EVENT_LEAVE = "leave"
+DEFAULT_EVENT = EVENT_ENTER
+
+
+def trigger(hass, config, action):
+    """ Listen for state changes based on `config`. """
+    entity_id = config.get(CONF_ENTITY_ID)
+    zone_entity_id = config.get(CONF_ZONE)
+
+    if entity_id is None or zone_entity_id is None:
+        logging.getLogger(__name__).error(
+            "Missing trigger configuration key %s or %s", CONF_ENTITY_ID,
+            CONF_ZONE)
+        return False
+
+    event = config.get(CONF_EVENT, DEFAULT_EVENT)
+
+    def zone_automation_listener(entity, from_s, to_s):
+        """ Listens 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)):
+            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)
+
+        if event == EVENT_ENTER and not from_match and to_match or \
+           event == EVENT_LEAVE and from_match and not to_match:
+            action()
+
+    track_state_change(
+        hass, entity_id, zone_automation_listener, MATCH_ALL, MATCH_ALL)
+
+    return True
+
+
+def if_action(hass, config):
+    """ Wraps action method with zone based condition. """
+    entity_id = config.get(CONF_ENTITY_ID)
+    zone_entity_id = config.get(CONF_ZONE)
+
+    if entity_id is None or zone_entity_id is None:
+        logging.getLogger(__name__).error(
+            "Missing condition configuration key %s or %s", CONF_ENTITY_ID,
+            CONF_ZONE)
+        return False
+
+    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))
@@ -0,0 +1,69 @@
+"""
+homeassistant.components.camera.foscam
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This component provides basic support for Foscam IP cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.foscam.html
+"""
+import logging
+from homeassistant.helpers import validate_config
+from homeassistant.components.camera import DOMAIN
+from homeassistant.components.camera import Camera
+import requests
+import re
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """ Adds a Foscam IP Camera. """
+    if not validate_config({DOMAIN: config},
+                           {DOMAIN: ['username', 'password', 'ip']}, _LOGGER):
+        return None
+
+    add_devices_callback([FoscamCamera(config)])
+
+
+# pylint: disable=too-many-instance-attributes
+class FoscamCamera(Camera):
+    """ An implementation of a Foscam IP camera. """
+
+    def __init__(self, device_info):
+        super(FoscamCamera, self).__init__()
+
+        ip_address = device_info.get('ip')
+        port = device_info.get('port', 88)
+
+        self._base_url = 'http://' + ip_address + ':' + str(port) + '/'
+        self._username = device_info.get('username')
+        self._password = device_info.get('password')
+        self._snap_picture_url = self._base_url \
+            + 'cgi-bin/CGIProxy.fcgi?cmd=snapPicture&usr=' \
+            + self._username + '&pwd=' + self._password
+        self._name = device_info.get('name', 'Foscam Camera')
+
+        _LOGGER.info('Using the following URL for %s: %s',
+                     self._name, self._snap_picture_url)
+
+    def camera_image(self):
+        """ Return a still image reponse from the camera. """
+
+        # send the request to snap a picture
+        response = requests.get(self._snap_picture_url)
+
+        # parse the response to find the image file name
+
+        pattern = re.compile('src="[.][.]/(.*[.]jpg)"')
+        filename = pattern.search(response.content.decode("utf-8")).group(1)
+
+        # send request for the image
+        response = requests.get(self._base_url + filename)
+
+        return response.content
+
+    @property
+    def name(self):
+        """ Return the name of this device. """
+        return self._name
@@ -1,48 +1,10 @@
 """
+homeassistant.components.camera.generic
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Support for IP Cameras.

-This component provides basic support for IP cameras. For the basic support to
-work you camera must support accessing a JPEG snapshot via a URL and you will
-need to specify the "still_image_url" parameter which should be the location of
-the JPEG image.
-
-As part of the basic support the following features will be provided:
-MJPEG video streaming
-Saving a snapshot
-Recording(JPEG frame capture)
-
-To use this component, add the following to your config/configuration.yaml:
-
-camera:
-    platform: generic
-    name: Door Camera
-    username: YOUR_USERNAME
-    password: YOUR_PASSWORD
-    still_image_url: http://YOUR_CAMERA_IP_AND_PORT/image.jpg
-
-
-VARIABLES:
-
-These are the variables for the device_data array:
-
-still_image_url
-*Required
-The URL your camera serves the image on.
-Example: http://192.168.1.21:2112/
-
-name
-*Optional
-This parameter allows you to override the name of your camera in homeassistant
-
-username
-*Optional
-THe username for acessing your camera
-
-password
-*Optional
-the password for accessing your camera
-
-
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.generic.html
 """
 import logging
 from requests.auth import HTTPBasicAuth
@@ -78,7 +40,7 @@ class GenericCamera(Camera):
        self._still_image_url = device_info['still_image_url']

    def camera_image(self):
-        """ Return a still image reponse from the camera """
+        """ Return a still image reponse from the camera. """
        if self._username and self._password:
            response = requests.get(
                self._still_image_url,
@@ -90,5 +52,5 @@ class GenericCamera(Camera):

    @property
    def name(self):
-        """ Return the name of this device """
+        """ Return the name of this device. """
        return self._name
@@ -1,9 +1,10 @@
 """
 homeassistant.components.conversation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provides functionality to have conversations with Home Assistant.
-This is more a proof of concept.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/conversation.html
 """
 import logging
 import re
@@ -17,7 +17,7 @@ DOMAIN = "demo"
 DEPENDENCIES = ['introduction', 'conversation']

 COMPONENTS_WITH_DEMO_PLATFORM = [
-    'switch', 'light', 'thermostat', 'sensor', 'media_player', 'notify']
+    'switch', 'light', 'sensor', 'thermostat', 'media_player', 'notify']


 def setup(hass, config):
@@ -33,10 +33,10 @@ def setup(hass, config):

    # Setup sun
    if not hass.config.latitude:
-        hass.config.latitude = '32.87336'
+        hass.config.latitude = 32.87336

    if not hass.config.longitude:
-        hass.config.longitude = '117.22743'
+        hass.config.longitude = 117.22743

    bootstrap.setup_component(hass, 'sun')

@@ -60,7 +60,15 @@ def setup(hass, config):
        {'camera': {
            'platform': 'generic',
            'name': 'IP Camera',
-            'still_image_url': 'http://194.218.96.92/jpg/image.jpg',
+            'still_image_url': 'http://home-assistant.io/demo/webcam.jpg',
+        }})
+
+    # Setup alarm_control_panel
+    bootstrap.setup_component(
+        hass, 'alarm_control_panel',
+        {'alarm_control_panel': {
+            'platform': 'manual',
+            'name': 'Test Alarm',
        }})

    # Setup scripts
@@ -108,7 +116,9 @@ def setup(hass, config):
                     "http://graph.facebook.com/297400035/picture",
                     ATTR_FRIENDLY_NAME: 'Paulus'})
    hass.states.set("device_tracker.anne_therese", "not_home",
-                    {ATTR_FRIENDLY_NAME: 'Anne Therese'})
+                    {ATTR_FRIENDLY_NAME: 'Anne Therese',
+                     'latitude': hass.config.latitude + 0.002,
+                     'longitude': hass.config.longitude + 0.002})

    hass.states.set("group.all_devices", "home",
                    {
@@ -1,52 +1,90 @@
 """
-homeassistant.components.tracker
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+homeassistant.components.device_tracker
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Provides functionality to keep track of devices.
+
+device_tracker:
+  platform: netgear
+
+  # Optional
+
+  # How many seconds to wait after not seeing device to consider it not home
+  consider_home: 180
+
+  # Seconds between each scan
+  interval_seconds: 12
+
+  # New found devices auto found
+  track_new_devices: yes
+
+  # Maximum distance from home we consider people home
+  range_home: 100
 """
-import logging
-import threading
-import os
+# pylint: disable=too-many-instance-attributes, too-many-arguments
+# pylint: disable=too-many-locals
 import csv
 from datetime import timedelta
+import logging
+import os
+import threading

-from homeassistant.helpers import validate_config
-from homeassistant.helpers.entity import _OVERWRITE
+from homeassistant.bootstrap import prepare_setup_platform
+from homeassistant.components import discovery, group, zone
+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
 import homeassistant.util as util
 import homeassistant.util.dt as dt_util
-from homeassistant.bootstrap import prepare_setup_platform

 from homeassistant.helpers.event import track_utc_time_change
 from homeassistant.const import (
-    STATE_HOME, STATE_NOT_HOME, ATTR_ENTITY_PICTURE, ATTR_FRIENDLY_NAME,
-    CONF_PLATFORM, DEVICE_DEFAULT_NAME)
-from homeassistant.components import group
+    ATTR_ENTITY_PICTURE, ATTR_GPS_ACCURACY, ATTR_LATITUDE, ATTR_LONGITUDE,
+    DEVICE_DEFAULT_NAME, STATE_HOME, STATE_NOT_HOME)

 DOMAIN = "device_tracker"
-DEPENDENCIES = []
-
-SERVICE_DEVICE_TRACKER_RELOAD = "reload_devices_csv"
+DEPENDENCIES = ['zone']

 GROUP_NAME_ALL_DEVICES = 'all devices'
 ENTITY_ID_ALL_DEVICES = group.ENTITY_ID_FORMAT.format('all_devices')

 ENTITY_ID_FORMAT = DOMAIN + '.{}'

-# After how much time do we consider a device not home if
-# it does not show up on scans
-TIME_DEVICE_NOT_FOUND = timedelta(minutes=3)
+CSV_DEVICES = "known_devices.csv"
+YAML_DEVICES = 'known_devices.yaml'

-# Filename to save known devices to
-KNOWN_DEVICES_FILE = "known_devices.csv"
+CONF_TRACK_NEW = "track_new_devices"
+DEFAULT_CONF_TRACK_NEW = True

-CONF_SECONDS = "interval_seconds"
+CONF_CONSIDER_HOME = 'consider_home'
+DEFAULT_CONSIDER_HOME = 180  # seconds

-DEFAULT_CONF_SECONDS = 12
+CONF_SCAN_INTERVAL = "interval_seconds"
+DEFAULT_SCAN_INTERVAL = 12

-TRACK_NEW_DEVICES = "track_new_devices"
+CONF_AWAY_HIDE = 'hide_if_away'
+DEFAULT_AWAY_HIDE = False

+CONF_HOME_RANGE = 'home_range'
+DEFAULT_HOME_RANGE = 100
+
+SERVICE_SEE = 'see'
+
+ATTR_MAC = 'mac'
+ATTR_DEV_ID = 'dev_id'
+ATTR_HOST_NAME = 'host_name'
+ATTR_LOCATION_NAME = 'location_name'
+ATTR_GPS = 'gps'
+ATTR_BATTERY = 'battery'
+
+DISCOVERY_PLATFORMS = {
+    discovery.SERVICE_NETGEAR: 'netgear',
+}
 _LOGGER = logging.getLogger(__name__)

+# pylint: disable=too-many-arguments
+

 def is_on(hass, entity_id=None):
    """ Returns if any or specified device is home. """
@@ -55,293 +93,356 @@ def is_on(hass, entity_id=None):
    return hass.states.is_state(entity, STATE_HOME)


+def see(hass, mac=None, dev_id=None, host_name=None, location_name=None,
+        gps=None, gps_accuracy=None, battery=None):
+    """ Call service to notify you see device. """
+    data = {key: value for key, value in
+            ((ATTR_MAC, mac),
+             (ATTR_DEV_ID, dev_id),
+             (ATTR_HOST_NAME, host_name),
+             (ATTR_LOCATION_NAME, location_name),
+             (ATTR_GPS, gps)) if value is not None}
+    hass.services.call(DOMAIN, SERVICE_SEE, data)
+
+
 def setup(hass, config):
-    """ Sets up the device tracker. """
+    """ Setup device tracker """
+    yaml_path = hass.config.path(YAML_DEVICES)
+    csv_path = hass.config.path(CSV_DEVICES)
+    if os.path.isfile(csv_path) and not os.path.isfile(yaml_path) and \
+       convert_csv_config(csv_path, yaml_path):
+        os.remove(csv_path)

-    if not validate_config(config, {DOMAIN: [CONF_PLATFORM]}, _LOGGER):
-        return False
+    conf = config.get(DOMAIN, {})
+    if isinstance(conf, list):
+        conf = conf[0]
+    consider_home = timedelta(
+        seconds=util.convert(conf.get(CONF_CONSIDER_HOME), int,
+                             DEFAULT_CONSIDER_HOME))
+    track_new = util.convert(conf.get(CONF_TRACK_NEW), bool,
+                             DEFAULT_CONF_TRACK_NEW)
+    home_range = util.convert(conf.get(CONF_HOME_RANGE), int,
+                              DEFAULT_HOME_RANGE)

-    tracker_type = config[DOMAIN].get(CONF_PLATFORM)
+    devices = load_config(yaml_path, hass, consider_home, home_range)
+    tracker = DeviceTracker(hass, consider_home, track_new, home_range,
+                            devices)

-    tracker_implementation = \
-        prepare_setup_platform(hass, config, DOMAIN, tracker_type)
-
-    if tracker_implementation is None:
-        _LOGGER.error("Unknown device_tracker type specified: %s.",
-                      tracker_type)
-
-        return False
-
-    device_scanner = tracker_implementation.get_scanner(hass, config)
-
-    if device_scanner is None:
-        _LOGGER.error("Failed to initialize device scanner: %s",
-                      tracker_type)
-
-        return False
-
-    seconds = util.convert(config[DOMAIN].get(CONF_SECONDS), int,
-                           DEFAULT_CONF_SECONDS)
-
-    track_new_devices = config[DOMAIN].get(TRACK_NEW_DEVICES) or False
-    _LOGGER.info("Tracking new devices: %s", track_new_devices)
-
-    tracker = DeviceTracker(hass, device_scanner, seconds, track_new_devices)
-
-    # We only succeeded if we got to parse the known devices file
-    return not tracker.invalid_known_devices_file
-
-
-class DeviceTracker(object):
-    """ Class that tracks which devices are home and which are not. """
-
-    def __init__(self, hass, device_scanner, seconds, track_new_devices):
-        self.hass = hass
-
-        self.device_scanner = device_scanner
-
-        self.lock = threading.Lock()
-
-        # Do we track new devices by default?
-        self.track_new_devices = track_new_devices
-
-        # Dictionary to keep track of known devices and devices we track
-        self.tracked = {}
-        self.untracked_devices = set()
-
-        # Did we encounter an invalid known devices file
-        self.invalid_known_devices_file = False
-
-        # Wrap it in a func instead of lambda so it can be identified in
-        # the bus by its __name__ attribute.
-        def update_device_state(now):
-            """ Triggers update of the device states. """
-            self.update_devices(now)
-
-        dev_group = group.Group(
-            hass, GROUP_NAME_ALL_DEVICES, user_defined=False)
-
-        def reload_known_devices_service(service):
-            """ Reload known devices file. """
-            self._read_known_devices_file()
-
-            self.update_devices(dt_util.utcnow())
-
-            dev_group.update_tracked_entity_ids(self.device_entity_ids)
-
-        reload_known_devices_service(None)
-
-        if self.invalid_known_devices_file:
-            return
-
-        seconds = range(0, 60, seconds)
-
-        _LOGGER.info("Device tracker interval second=%s", seconds)
-        track_utc_time_change(hass, update_device_state, second=seconds)
-
-        hass.services.register(DOMAIN,
-                               SERVICE_DEVICE_TRACKER_RELOAD,
-                               reload_known_devices_service)
-
-    @property
-    def device_entity_ids(self):
-        """ Returns a set containing all device entity ids
-            that are being tracked. """
-        return set(device['entity_id'] for device in self.tracked.values())
-
-    def _update_state(self, now, device, is_home):
-        """ Update the state of a device. """
-        dev_info = self.tracked[device]
-
-        if is_home:
-            # Update last seen if at home
-            dev_info['last_seen'] = now
-        else:
-            # State remains at home if it has been seen in the last
-            # TIME_DEVICE_NOT_FOUND
-            is_home = now - dev_info['last_seen'] < TIME_DEVICE_NOT_FOUND
-
-        state = STATE_HOME if is_home else STATE_NOT_HOME
-
-        # overwrite properties that have been set in the config file
-        attr = dict(dev_info['state_attr'])
-        attr.update(_OVERWRITE.get(dev_info['entity_id'], {}))
-
-        self.hass.states.set(
-            dev_info['entity_id'], state, attr)
-
-    def update_devices(self, now):
-        """ Update device states based on the found devices. """
-        if not self.lock.acquire(False):
+    def setup_platform(p_type, p_config, disc_info=None):
+        """ Setup a device tracker platform. """
+        platform = prepare_setup_platform(hass, config, DOMAIN, p_type)
+        if platform is None:
            return

        try:
-            found_devices = set(dev.upper() for dev in
-                                self.device_scanner.scan_devices())
+            if hasattr(platform, 'get_scanner'):
+                scanner = platform.get_scanner(hass, {DOMAIN: p_config})

-            for device in self.tracked:
-                is_home = device in found_devices
+                if scanner is None:
+                    _LOGGER.error('Error setting up platform %s', p_type)
+                    return

-                self._update_state(now, device, is_home)
+                setup_scanner_platform(hass, p_config, scanner, tracker.see)
+                return

-                if is_home:
-                    found_devices.remove(device)
+            if not platform.setup_scanner(hass, p_config, tracker.see):
+                _LOGGER.error('Error setting up platform %s', p_type)
+        except Exception:  # pylint: disable=broad-except
+            _LOGGER.exception('Error setting up platform %s', p_type)

-            # Did we find any devices that we didn't know about yet?
-            new_devices = found_devices - self.untracked_devices
+    for p_type, p_config in \
+            config_per_platform(config, DOMAIN, _LOGGER):
+        setup_platform(p_type, p_config)

-            if new_devices:
-                if not self.track_new_devices:
-                    self.untracked_devices.update(new_devices)
+    def device_tracker_discovered(service, info):
+        """ Called when a device tracker platform is discovered. """
+        setup_platform(DISCOVERY_PLATFORMS[service], {}, info)

-                self._update_known_devices_file(new_devices)
-        finally:
-            self.lock.release()
+    discovery.listen(hass, DISCOVERY_PLATFORMS.keys(),
+                     device_tracker_discovered)

-    # pylint: disable=too-many-branches
-    def _read_known_devices_file(self):
-        """ Parse and process the known devices file. """
-        known_dev_path = self.hass.config.path(KNOWN_DEVICES_FILE)
+    def update_stale(now):
+        """ Clean up stale devices. """
+        tracker.update_stale(now)
+    track_utc_time_change(hass, update_stale, second=range(0, 60, 5))

-        # Return if no known devices file exists
-        if not os.path.isfile(known_dev_path):
+    tracker.setup_group()
+
+    def see_service(call):
+        """ Service to see a device. """
+        args = {key: value for key, value in call.data.items() if key in
+                (ATTR_MAC, ATTR_DEV_ID, ATTR_HOST_NAME, ATTR_LOCATION_NAME,
+                 ATTR_GPS, ATTR_GPS_ACCURACY, ATTR_BATTERY)}
+        tracker.see(**args)
+
+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+    hass.services.register(DOMAIN, SERVICE_SEE, see_service,
+                           descriptions.get(SERVICE_SEE))
+
+    return True
+
+
+class DeviceTracker(object):
+    """ Track devices """
+    def __init__(self, hass, consider_home, track_new, home_range, devices):
+        self.hass = hass
+        self.devices = {dev.dev_id: dev for dev in devices}
+        self.mac_to_dev = {dev.mac: dev for dev in devices if dev.mac}
+        self.consider_home = consider_home
+        self.track_new = track_new
+        self.home_range = home_range
+        self.lock = threading.Lock()
+
+        for device in devices:
+            if device.track:
+                device.update_ha_state()
+
+        self.group = None
+
+    def see(self, mac=None, dev_id=None, host_name=None, location_name=None,
+            gps=None, gps_accuracy=None, battery=None):
+        """ Notify device tracker that you see a device. """
+        with self.lock:
+            if mac is None and dev_id is None:
+                raise HomeAssistantError('Neither mac or device id passed in')
+            elif mac is not None:
+                mac = mac.upper()
+                device = self.mac_to_dev.get(mac)
+                if not device:
+                    dev_id = util.slugify(host_name or '') or util.slugify(mac)
+            else:
+                dev_id = str(dev_id).lower()
+                device = self.devices.get(dev_id)
+
+            if device:
+                device.seen(host_name, location_name, gps, gps_accuracy,
+                            battery)
+                if device.track:
+                    device.update_ha_state()
+                return
+
+            # If no device can be found, create it
+            device = Device(
+                self.hass, self.consider_home, self.home_range, self.track_new,
+                dev_id, mac, (host_name or dev_id).replace('_', ' '))
+            self.devices[dev_id] = device
+            if mac is not None:
+                self.mac_to_dev[mac] = device
+
+            device.seen(host_name, location_name, gps, gps_accuracy, battery)
+            if device.track:
+                device.update_ha_state()
+
+            # During init, we ignore the group
+            if self.group is not None:
+                self.group.update_tracked_entity_ids(
+                    list(self.group.tracking) + [device.entity_id])
+            update_config(self.hass.config.path(YAML_DEVICES), dev_id, device)
+
+    def setup_group(self):
+        """ Initializes group for all tracked devices. """
+        entity_ids = (dev.entity_id for dev in self.devices.values()
+                      if dev.track)
+        self.group = group.setup_group(
+            self.hass, GROUP_NAME_ALL_DEVICES, entity_ids, False)
+
+    def update_stale(self, now):
+        """ Update stale devices. """
+        with self.lock:
+            for device in self.devices.values():
+                if (device.track and device.last_update_home and
+                        device.stale(now)):
+                    device.update_ha_state(True)
+
+
+class Device(Entity):
+    """ Tracked device. """
+
+    host_name = None
+    location_name = None
+    gps = None
+    gps_accuracy = 0
+    last_seen = None
+    battery = None
+
+    # Track if the last update of this device was HOME
+    last_update_home = False
+    _state = STATE_NOT_HOME
+
+    def __init__(self, hass, consider_home, home_range, track, dev_id, mac,
+                 name=None, picture=None, away_hide=False):
+        self.hass = hass
+        self.entity_id = ENTITY_ID_FORMAT.format(dev_id)
+
+        # Timedelta object how long we consider a device home if it is not
+        # detected anymore.
+        self.consider_home = consider_home
+
+        # Distance in meters
+        self.home_range = home_range
+        # Device ID
+        self.dev_id = dev_id
+        self.mac = mac
+
+        # If we should track this device
+        self.track = track
+
+        # Configured name
+        self.config_name = name
+
+        # Configured picture
+        self.config_picture = picture
+        self.away_hide = away_hide
+
+    @property
+    def gps_home(self):
+        """ Return if device is within range of home. """
+        distance = max(
+            0, self.hass.config.distance(*self.gps) - self.gps_accuracy)
+        return self.gps is not None and distance <= self.home_range
+
+    @property
+    def name(self):
+        """ Returns the name of the entity. """
+        return self.config_name or self.host_name or DEVICE_DEFAULT_NAME
+
+    @property
+    def state(self):
+        """ State of the device. """
+        return self._state
+
+    @property
+    def state_attributes(self):
+        """ Device state attributes. """
+        attr = {}
+
+        if self.config_picture:
+            attr[ATTR_ENTITY_PICTURE] = self.config_picture
+
+        if self.gps:
+            attr[ATTR_LATITUDE] = self.gps[0]
+            attr[ATTR_LONGITUDE] = self.gps[1]
+            attr[ATTR_GPS_ACCURACY] = self.gps_accuracy
+
+        if self.battery:
+            attr[ATTR_BATTERY] = self.battery
+
+        return attr
+
+    @property
+    def hidden(self):
+        """ If device should be hidden. """
+        return self.away_hide and self.state != STATE_HOME
+
+    def seen(self, host_name=None, location_name=None, gps=None,
+             gps_accuracy=0, battery=None):
+        """ Mark the device as seen. """
+        self.last_seen = dt_util.utcnow()
+        self.host_name = host_name
+        self.location_name = location_name
+        self.gps_accuracy = gps_accuracy or 0
+        self.battery = battery
+        if gps is None:
+            self.gps = None
+        else:
+            try:
+                self.gps = tuple(float(val) for val in gps)
+            except ValueError:
+                _LOGGER.warning('Could not parse gps value for %s: %s',
+                                self.dev_id, gps)
+                self.gps = None
+        self.update()
+
+    def stale(self, now=None):
+        """ Return if device state is stale. """
+        return self.last_seen and \
+            (now or dt_util.utcnow()) - self.last_seen > self.consider_home
+
+    def update(self):
+        """ Update state of entity. """
+        if not self.last_seen:
            return
+        elif self.location_name:
+            self._state = self.location_name
+        elif self.gps is not None:
+            zone_state = zone.active_zone(self.hass, self.gps[0], self.gps[1],
+                                          self.gps_accuracy)
+            if zone_state is None:
+                self._state = STATE_NOT_HOME
+            elif zone_state.entity_id == zone.ENTITY_ID_HOME:
+                self._state = STATE_HOME
+            else:
+                self._state = zone_state.name

-        self.lock.acquire()
+        elif self.stale():
+            self._state = STATE_NOT_HOME
+            self.last_update_home = False
+        else:
+            self._state = STATE_HOME
+            self.last_update_home = True

-        self.untracked_devices.clear()

-        with open(known_dev_path) as inp:
+def convert_csv_config(csv_path, yaml_path):
+    """ Convert CSV config file format to YAML. """
+    used_ids = set()
+    with open(csv_path) as inp:
+        for row in csv.DictReader(inp):
+            dev_id = util.ensure_unique_string(
+                (util.slugify(row['name']) or DEVICE_DEFAULT_NAME).lower(),
+                used_ids)
+            used_ids.add(dev_id)
+            device = Device(None, None, None, row['track'] == '1', dev_id,
+                            row['device'], row['name'], row['picture'])
+            update_config(yaml_path, dev_id, device)
+    return True

-            # To track which devices need an entity_id assigned
-            need_entity_id = []

-            # All devices that are still in this set after we read the CSV file
-            # have been removed from the file and thus need to be cleaned up.
-            removed_devices = set(self.tracked.keys())
+def load_config(path, hass, consider_home, home_range):
+    """ Load devices from YAML config file. """
+    if not os.path.isfile(path):
+        return []
+    return [
+        Device(hass, consider_home, home_range, device.get('track', False),
+               str(dev_id).lower(), str(device.get('mac')).upper(),
+               device.get('name'), device.get('picture'),
+               device.get(CONF_AWAY_HIDE, DEFAULT_AWAY_HIDE))
+        for dev_id, device in load_yaml_config_file(path).items()]

-            try:
-                for row in csv.DictReader(inp):
-                    device = row['device'].upper()

-                    if row['track'] == '1':
-                        if device in self.tracked:
-                            # Device exists
-                            removed_devices.remove(device)
-                        else:
-                            # We found a new device
-                            need_entity_id.append(device)
+def setup_scanner_platform(hass, config, scanner, see_device):
+    """ Helper method to connect scanner-based platform to device tracker. """
+    interval = util.convert(config.get(CONF_SCAN_INTERVAL), int,
+                            DEFAULT_SCAN_INTERVAL)

-                            self._track_device(device, row['name'])
+    # Initial scan of each mac we also tell about host name for config
+    seen = set()

-                        # Update state_attr with latest from file
-                        state_attr = {
-                            ATTR_FRIENDLY_NAME: row['name']
-                        }
+    def device_tracker_scan(now):
+        """ Called when interval matches. """
+        for mac in scanner.scan_devices():
+            if mac in seen:
+                host_name = None
+            else:
+                host_name = scanner.get_device_name(mac)
+                seen.add(mac)
+            see_device(mac=mac, host_name=host_name)

-                        if row['picture']:
-                            state_attr[ATTR_ENTITY_PICTURE] = row['picture']
+    track_utc_time_change(hass, device_tracker_scan, second=range(0, 60,
+                                                                  interval))

-                        self.tracked[device]['state_attr'] = state_attr
+    device_tracker_scan(None)

-                    else:
-                        self.untracked_devices.add(device)

-                # Remove existing devices that we no longer track
-                for device in removed_devices:
-                    entity_id = self.tracked[device]['entity_id']
+def update_config(path, dev_id, device):
+    """ Add device to YAML config file. """
+    with open(path, 'a') as out:
+        out.write('\n')
+        out.write('{}:\n'.format(device.dev_id))

-                    _LOGGER.info("Removing entity %s", entity_id)
-
-                    self.hass.states.remove(entity_id)
-
-                    self.tracked.pop(device)
-
-                self._generate_entity_ids(need_entity_id)
-
-                if not self.tracked:
-                    _LOGGER.warning(
-                        "No devices to track. Please update %s.",
-                        known_dev_path)
-
-                _LOGGER.info("Loaded devices from %s", known_dev_path)
-
-            except KeyError:
-                self.invalid_known_devices_file = True
-
-                _LOGGER.warning(
-                    ("Invalid known devices file: %s. "
-                     "We won't update it with new found devices."),
-                    known_dev_path)
-
-            finally:
-                self.lock.release()
-
-    def _update_known_devices_file(self, new_devices):
-        """ Add new devices to known devices file. """
-        if not self.invalid_known_devices_file:
-            known_dev_path = self.hass.config.path(KNOWN_DEVICES_FILE)
-
-            try:
-                # If file does not exist we will write the header too
-                is_new_file = not os.path.isfile(known_dev_path)
-
-                with open(known_dev_path, 'a') as outp:
-                    _LOGGER.info("Found %d new devices, updating %s",
-                                 len(new_devices), known_dev_path)
-
-                    writer = csv.writer(outp)
-
-                    if is_new_file:
-                        writer.writerow(("device", "name", "track", "picture"))
-
-                    for device in new_devices:
-                        # See if the device scanner knows the name
-                        # else defaults to unknown device
-                        name = self.device_scanner.get_device_name(device) or \
-                            DEVICE_DEFAULT_NAME
-
-                        track = 0
-                        if self.track_new_devices:
-                            self._track_device(device, name)
-                            track = 1
-
-                        writer.writerow((device, name, track, ""))
-
-                if self.track_new_devices:
-                    self._generate_entity_ids(new_devices)
-
-            except IOError:
-                _LOGGER.exception("Error updating %s with %d new devices",
-                                  known_dev_path, len(new_devices))
-
-    def _track_device(self, device, name):
-        """
-        Add a device to the list of tracked devices.
-        Does not generate the entity id yet.
-        """
-        default_last_seen = dt_util.utcnow().replace(year=1990)
-
-        self.tracked[device] = {
-            'name': name,
-            'last_seen': default_last_seen,
-            'state_attr': {ATTR_FRIENDLY_NAME: name}
-        }
-
-    def _generate_entity_ids(self, need_entity_id):
-        """ Generate entity ids for a list of devices. """
-        # Setup entity_ids for the new devices
-        used_entity_ids = [info['entity_id'] for device, info
-                           in self.tracked.items()
-                           if device not in need_entity_id]
-
-        for device in need_entity_id:
-            name = self.tracked[device]['name']
-
-            entity_id = util.ensure_unique_string(
-                ENTITY_ID_FORMAT.format(util.slugify(name)),
-                used_entity_ids)
-
-            used_entity_ids.append(entity_id)
-
-            self.tracked[device]['entity_id'] = entity_id
+        for key, value in (('name', device.name), ('mac', device.mac),
+                           ('picture', device.config_picture),
+                           ('track', 'yes' if device.track else 'no'),
+                           (CONF_AWAY_HIDE,
+                            'yes' if device.away_hide else 'no')):
+            out.write('  {}: {}\n'.format(key, '' if value is None else value))
@@ -1,50 +1,31 @@
 """
 homeassistant.components.device_tracker.actiontec
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Device tracker platform that supports scanning an Actiontec MI424WR
 (Verizon FIOS) router for device presence.

-This device tracker needs telnet to be enabled on the router.
-
-Configuration:
-
-To use the Actiontec tracker you will need to add something like the
-following to your config/configuration.yaml
-
-device_tracker:
-  platform: actiontec
-  host: YOUR_ROUTER_IP
-  username: YOUR_ADMIN_USERNAME
-  password: YOUR_ADMIN_PASSWORD
-
-Variables:
-
-host
-*Required
-The IP address of your router, e.g. 192.168.1.1.
-
-username
-*Required
-The username of an user with administrative privileges, usually 'admin'.
-
-password
-*Required
-The password for your given admin account.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.actiontec.html
 """
 import logging
 from datetime import timedelta
+from collections import namedtuple
 import re
 import threading
 import telnetlib

+import homeassistant.util.dt as dt_util
 from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD
 from homeassistant.helpers import validate_config
-from homeassistant.util import Throttle
+from homeassistant.util import Throttle, convert
 from homeassistant.components.device_tracker import DOMAIN

 # Return cached results if last scan was less then this time ago
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)

+# Interval in minutes to exclude devices from a scan while they are home
+CONF_HOME_INTERVAL = "home_interval"
+
 _LOGGER = logging.getLogger(__name__)

 _LEASES_REGEX = re.compile(
@@ -54,7 +35,7 @@ _LEASES_REGEX = re.compile(

 # pylint: disable=unused-argument
 def get_scanner(hass, config):
-    """ Validates config and returns a DD-WRT scanner. """
+    """ Validates config and returns an Actiontec scanner. """
    if not validate_config(config,
                           {DOMAIN: [CONF_HOST, CONF_USERNAME, CONF_PASSWORD]},
                           _LOGGER):
@@ -64,59 +45,87 @@ def get_scanner(hass, config):

    return scanner if scanner.success_init else None

+Device = namedtuple("Device", ["mac", "ip", "last_update"])
+

 class ActiontecDeviceScanner(object):
-    """ This class queries a an actiontec router
-    for connected devices. Adapted from DD-WRT scanner.
+    """
+    This class queries a an actiontec router for connected devices.
+    Adapted from DD-WRT scanner.
    """

    def __init__(self, config):
        self.host = config[CONF_HOST]
        self.username = config[CONF_USERNAME]
        self.password = config[CONF_PASSWORD]
+        minutes = convert(config.get(CONF_HOME_INTERVAL), int, 0)
+        self.home_interval = timedelta(minutes=minutes)

        self.lock = threading.Lock()

-        self.last_results = {}
+        self.last_results = []

        # Test the router is accessible
        data = self.get_actiontec_data()
        self.success_init = data is not None
+        _LOGGER.info("actiontec scanner initialized")
+        if self.home_interval:
+            _LOGGER.info("home_interval set to: %s", self.home_interval)

    def scan_devices(self):
-        """ Scans for new devices and return a
-            list containing found device ids. """
+        """
+        Scans for new devices and return a list containing found device ids.
+        """

        self._update_info()
-        return [client['mac'] for client in self.last_results]
+        return [client.mac for client in self.last_results]

    def get_device_name(self, device):
        """ Returns the name of the given device or None if we don't know. """
        if not self.last_results:
            return None
        for client in self.last_results:
-            if client['mac'] == device:
-                return client['ip']
+            if client.mac == device:
+                return client.ip
        return None

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Ensures the information from the Actiontec MI424WR router is up
-            to date. Returns boolean if scanning successful. """
+        """
+        Ensures the information from the Actiontec MI424WR router is up
+        to date. Returns boolean if scanning successful.
+        """
+        _LOGGER.info("Scanning")
        if not self.success_init:
            return False

        with self.lock:
-            # _LOGGER.info("Checking ARP")
-            data = self.get_actiontec_data()
-            if not data:
+            exclude_targets = set()
+            exclude_target_list = []
+            now = dt_util.now()
+            if self.home_interval:
+                for host in self.last_results:
+                    if host.last_update + self.home_interval > now:
+                        exclude_targets.add(host)
+                if len(exclude_targets) > 0:
+                    exclude_target_list = [t.ip for t in exclude_targets]
+
+            actiontec_data = self.get_actiontec_data()
+            if not actiontec_data:
                return False
-            active_clients = [client for client in data.values()]
-            self.last_results = active_clients
+            self.last_results = []
+            for client in exclude_target_list:
+                if client in actiontec_data:
+                    actiontec_data.pop(client)
+            for name, data in actiontec_data.items():
+                device = Device(data['mac'], name, now)
+                self.last_results.append(device)
+            self.last_results.extend(exclude_targets)
+            _LOGGER.info("actiontec scan successful")
            return True

    def get_actiontec_data(self):
-        """ Retrieve data from Actiontec MI424WR and return parsed result.  """
+        """ Retrieve data from Actiontec MI424WR and return parsed result. """
        try:
            telnet = telnetlib.Telnet(self.host)
            telnet.read_until(b'Username: ')
@@ -4,33 +4,8 @@ homeassistant.components.device_tracker.aruba
 Device tracker platform that supports scanning a Aruba Access Point for device
 presence.

-This device tracker needs telnet to be enabled on the router.
-
-Configuration:
-
-To use the Aruba tracker you will need to add something like the following
-to your config/configuration.yaml. You also need to enable Telnet in the
-configuration pages.
-
-device_tracker:
-  platform: aruba
-  host: YOUR_ACCESS_POINT_IP
-  username: YOUR_ADMIN_USERNAME
-  password: YOUR_ADMIN_PASSWORD
-
-Variables:
-
-host
-*Required
-The IP address of your router, e.g. 192.168.1.1.
-
-username
-*Required
-The username of an user with administrative privileges, usually 'admin'.
-
-password
-*Required
-The password for your given admin account.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.aruba.html
 """
 import logging
 from datetime import timedelta
@@ -51,15 +26,7 @@ _LOGGER = logging.getLogger(__name__)
 _DEVICES_REGEX = re.compile(
    r'(?P<name>([^\s]+))\s+' +
    r'(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\s+' +
-    r'(?P<mac>(([0-9a-f]{2}[:-]){5}([0-9a-f]{2})))\s+' +
-    r'(?P<os>([^\s]+))\s+' +
-    r'(?P<network>([^\s]+))\s+' +
-    r'(?P<ap>([^\s]+))\s+' +
-    r'(?P<channel>([^\s]+))\s+' +
-    r'(?P<type>([^\s]+))\s+' +
-    r'(?P<role>([^\s]+))\s+' +
-    r'(?P<signal>([^\s]+))\s+' +
-    r'(?P<speed>([^\s]+))')
+    r'(?P<mac>(([0-9a-f]{2}[:-]){5}([0-9a-f]{2})))\s+')


 # pylint: disable=unused-argument
@@ -91,8 +58,9 @@ class ArubaDeviceScanner(object):
        self.success_init = data is not None

    def scan_devices(self):
-        """ Scans for new devices and return a list containing found device
-            ids. """
+        """
+        Scans for new devices and return a list containing found device IDs.
+        """

        self._update_info()
        return [client['mac'] for client in self.last_results]
@@ -108,8 +76,10 @@ class ArubaDeviceScanner(object):

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Ensures the information from the Aruba Access Point is up to date.
-            Returns boolean if scanning successful. """
+        """
+        Ensures the information from the Aruba Access Point is up to date.
+        Returns boolean if scanning successful.
+        """
        if not self.success_init:
            return False

@@ -122,8 +92,7 @@ class ArubaDeviceScanner(object):
            return True

    def get_aruba_data(self):
-        """ Retrieve data from Aruba Access Point and return parsed
-            result.  """
+        """ Retrieve data from Aruba Access Point and return parsed result. """
        try:
            telnet = telnetlib.Telnet(self.host)
            telnet.read_until(b'User: ')
@@ -9,7 +9,7 @@ This device tracker needs telnet to be enabled on the router.
 Configuration:

 To use the ASUSWRT tracker you will need to add something like the following
-to your config/configuration.yaml
+to your configuration.yaml file.

 device_tracker:
  platform: asuswrt
@@ -63,7 +63,7 @@ _IP_NEIGH_REGEX = re.compile(

 # pylint: disable=unused-argument
 def get_scanner(hass, config):
-    """ Validates config and returns a DD-WRT scanner. """
+    """ Validates config and returns an ASUS-WRT scanner. """
    if not validate_config(config,
                           {DOMAIN: [CONF_HOST, CONF_USERNAME, CONF_PASSWORD]},
                           _LOGGER):
@@ -75,7 +75,8 @@ def get_scanner(hass, config):


 class AsusWrtDeviceScanner(object):
-    """ This class queries a router running ASUSWRT firmware
+    """
+    This class queries a router running ASUSWRT firmware
    for connected devices. Adapted from DD-WRT scanner.
    """

@@ -93,8 +94,9 @@ class AsusWrtDeviceScanner(object):
        self.success_init = data is not None

    def scan_devices(self):
-        """ Scans for new devices and return a
-            list containing found device ids. """
+        """
+        Scans for new devices and return a list containing found device IDs.
+        """

        self._update_info()
        return [client['mac'] for client in self.last_results]
@@ -110,8 +112,10 @@ class AsusWrtDeviceScanner(object):

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Ensures the information from the ASUSWRT router is up to date.
-            Returns boolean if scanning successful. """
+        """
+        Ensures the information from the ASUSWRT router is up to date.
+        Returns boolean if scanning successful.
+        """
        if not self.success_init:
            return False

@@ -129,7 +133,7 @@ class AsusWrtDeviceScanner(object):
            return True

    def get_asuswrt_data(self):
-        """ Retrieve data from ASUSWRT and return parsed result.  """
+        """ Retrieve data from ASUSWRT and return parsed result. """
        try:
            telnet = telnetlib.Telnet(self.host)
            telnet.read_until(b'login: ')
@@ -153,15 +157,24 @@ class AsusWrtDeviceScanner(object):
        devices = {}
        for lease in leases_result:
            match = _LEASES_REGEX.search(lease.decode('utf-8'))
+
+            # For leases where the client doesn't set a hostname, ensure
+            # it is blank and not '*', which breaks the entity_id down
+            # the line
+            if match:
+                host = match.group('host')
+                if host == '*':
+                    host = ''
+
            devices[match.group('ip')] = {
+                'host': host,
+                'status': '',
                'ip': match.group('ip'),
                'mac': match.group('mac').upper(),
-                'host': match.group('host'),
-                'status': ''
                }

        for neighbor in neighbors:
            match = _IP_NEIGH_REGEX.search(neighbor.decode('utf-8'))
-            if match.group('ip') in devices:
+            if match and match.group('ip') in devices:
                devices[match.group('ip')]['status'] = match.group('status')
        return devices
@@ -1,34 +1,11 @@
 """
 homeassistant.components.device_tracker.ddwrt
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Device tracker platform that supports scanning a DD-WRT router for device
 presence.

-Configuration:
-
-To use the DD-WRT tracker you will need to add something like the following
-to your config/configuration.yaml
-
-device_tracker:
-  platform: ddwrt
-  host: YOUR_ROUTER_IP
-  username: YOUR_ADMIN_USERNAME
-  password: YOUR_ADMIN_PASSWORD
-
-Variables:
-
-host
-*Required
-The IP address of your router, e.g. 192.168.1.1.
-
-username
-*Required
-The username of an user with administrative privileges, usually 'admin'.
-
-password
-*Required
-The password for your given admin account.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.ddwrt.html
 """
 import logging
 from datetime import timedelta
@@ -47,6 +24,7 @@ MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 _LOGGER = logging.getLogger(__name__)

 _DDWRT_DATA_REGEX = re.compile(r'\{(\w+)::([^\}]*)\}')
+_MAC_REGEX = re.compile(r'(([0-9A-Fa-f]{1,2}\:){5}[0-9A-Fa-f]{1,2})')


 # pylint: disable=unused-argument
@@ -64,7 +42,8 @@ def get_scanner(hass, config):

 # pylint: disable=too-many-instance-attributes
 class DdWrtDeviceScanner(object):
-    """ This class queries a wireless router running DD-WRT firmware
+    """
+    This class queries a wireless router running DD-WRT firmware
    for connected devices. Adapted from Tomato scanner.
    """

@@ -77,7 +56,7 @@ class DdWrtDeviceScanner(object):

        self.last_results = {}

-        self.mac2name = None
+        self.mac2name = {}

        # Test the router is accessible
        url = 'http://{}/Status_Wireless.live.asp'.format(self.host)
@@ -85,8 +64,9 @@ class DdWrtDeviceScanner(object):
        self.success_init = data is not None

    def scan_devices(self):
-        """ Scans for new devices and return a
-            list containing found device ids. """
+        """
+        Scans for new devices and return a list containing found device ids.
+        """

        self._update_info()

@@ -97,35 +77,40 @@ class DdWrtDeviceScanner(object):

        with self.lock:
            # if not initialised and not already scanned and not found
-            if self.mac2name is None or device not in self.mac2name:
+            if device not in self.mac2name:
                url = 'http://{}/Status_Lan.live.asp'.format(self.host)
                data = self.get_ddwrt_data(url)

                if not data:
-                    return
+                    return None

                dhcp_leases = data.get('dhcp_leases', None)
-                if dhcp_leases:
-                    # remove leading and trailing single quotes
-                    cleaned_str = dhcp_leases.strip().strip('"')
-                    elements = cleaned_str.split('","')
-                    num_clients = int(len(elements)/5)
-                    self.mac2name = {}
-                    for idx in range(0, num_clients):
-                        # this is stupid but the data is a single array
-                        # every 5 elements represents one hosts, the MAC
-                        # is the third element and the name is the first
-                        mac_index = (idx * 5) + 2
-                        if mac_index < len(elements):
-                            mac = elements[mac_index]
-                            self.mac2name[mac] = elements[idx * 5]

-            return self.mac2name.get(device, None)
+                if not dhcp_leases:
+                    return None
+
+                # remove leading and trailing single quotes
+                cleaned_str = dhcp_leases.strip().strip('"')
+                elements = cleaned_str.split('","')
+                num_clients = int(len(elements)/5)
+                self.mac2name = {}
+                for idx in range(0, num_clients):
+                    # this is stupid but the data is a single array
+                    # every 5 elements represents one hosts, the MAC
+                    # is the third element and the name is the first
+                    mac_index = (idx * 5) + 2
+                    if mac_index < len(elements):
+                        mac = elements[mac_index]
+                        self.mac2name[mac] = elements[idx * 5]
+
+            return self.mac2name.get(device)

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Ensures the information from the DD-WRT router is up to date.
-            Returns boolean if scanning successful. """
+        """
+        Ensures the information from the DD-WRT router is up to date.
+        Returns boolean if scanning successful.
+        """
        if not self.success_init:
            return False

@@ -138,32 +123,28 @@ class DdWrtDeviceScanner(object):
            if not data:
                return False

-            if data:
-                self.last_results = []
-                active_clients = data.get('active_wireless', None)
-                if active_clients:
-                    # This is really lame, instead of using JSON the DD-WRT UI
-                    # uses its own data format for some reason and then
-                    # regex's out values so I guess I have to do the same,
-                    # LAME!!!
+            self.last_results = []

-                    # remove leading and trailing single quotes
-                    clean_str = active_clients.strip().strip("'")
-                    elements = clean_str.split("','")
+            active_clients = data.get('active_wireless', None)
+            if not active_clients:
+                return False

-                    num_clients = int(len(elements)/9)
-                    for idx in range(0, num_clients):
-                        # get every 9th element which is the MAC address
-                        index = idx * 9
-                        if index < len(elements):
-                            self.last_results.append(elements[index])
+            # This is really lame, instead of using JSON the DD-WRT UI
+            # uses its own data format for some reason and then
+            # regex's out values so I guess I have to do the same,
+            # LAME!!!

-                    return True
+            # remove leading and trailing single quotes
+            clean_str = active_clients.strip().strip("'")
+            elements = clean_str.split("','")

-            return False
+            self.last_results.extend(item for item in elements
+                                     if _MAC_REGEX.match(item))
+
+            return True

    def get_ddwrt_data(self, url):
-        """ Retrieve data from DD-WRT and return parsed result.  """
+        """ Retrieve data from DD-WRT and return parsed result. """
        try:
            response = requests.get(
                url,
@@ -0,0 +1,50 @@
+"""
+homeassistant.components.device_tracker.demo
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Demo platform for the device tracker.
+
+device_tracker:
+  platform: demo
+"""
+import random
+
+from homeassistant.components.device_tracker import DOMAIN
+
+
+def setup_scanner(hass, config, see):
+    """ Set up a demo tracker. """
+
+    def offset():
+        """ Return random offset. """
+        return (random.randrange(500, 2000)) / 2e5 * random.choice((-1, 1))
+
+    def random_see(dev_id, name):
+        """ Randomize a sighting. """
+        see(
+            dev_id=dev_id,
+            host_name=name,
+            gps=(hass.config.latitude + offset(),
+                 hass.config.longitude + offset()),
+            gps_accuracy=random.randrange(50, 150),
+            battery=random.randrange(10, 90)
+        )
+
+    def observe(call=None):
+        """ Observe three entities. """
+        random_see('demo_paulus', 'Paulus')
+        random_see('demo_anne_therese', 'Anne Therese')
+
+    observe()
+
+    see(
+        dev_id='demo_home_boy',
+        host_name='Home Boy',
+        gps=[hass.config.latitude - 0.00002, hass.config.longitude + 0.00002],
+        gps_accuracy=20,
+        battery=53
+    )
+
+    hass.services.register(DOMAIN, 'demo', observe)
+
+    return True
@@ -0,0 +1,71 @@
+"""
+homeassistant.components.device_tracker.geofancy
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Geofancy platform for the device tracker.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.geofancy.html
+"""
+
+from homeassistant.const import (
+    HTTP_UNPROCESSABLE_ENTITY, HTTP_INTERNAL_SERVER_ERROR)
+
+DEPENDENCIES = ['http']
+
+_SEE = 0
+
+URL_API_GEOFANCY_ENDPOINT = "/api/geofancy"
+
+
+def setup_scanner(hass, config, see):
+    """ Set up an endpoint for the Geofancy app. """
+
+    # Use a global variable to keep setup_scanner compact when using a callback
+    global _SEE
+    _SEE = see
+
+    # POST would be semantically better, but that currently does not work
+    # since Geofancy 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_GEOFANCY_ENDPOINT, _handle_get_api_geofancy)
+
+    return True
+
+
+def _handle_get_api_geofancy(handler, path_match, data):
+    """ Geofancy message received. """
+
+    if not isinstance(data, dict):
+        handler.write_json_message(
+            "Error while parsing Geofancy message.",
+            HTTP_INTERNAL_SERVER_ERROR)
+        return
+    if 'latitude' not in data or 'longitude' not in data:
+        handler.write_json_message(
+            "Location not specified.",
+            HTTP_UNPROCESSABLE_ENTITY)
+        return
+    if 'device' not in data or 'id' not in data:
+        handler.write_json_message(
+            "Device id or location id not specified.",
+            HTTP_UNPROCESSABLE_ENTITY)
+        return
+
+    try:
+        gps_coords = (float(data['latitude']), float(data['longitude']))
+    except ValueError:
+        # If invalid latitude / longitude format
+        handler.write_json_message(
+            "Invalid latitude / longitude format.",
+            HTTP_UNPROCESSABLE_ENTITY)
+        return
+
+    # entity id's in Home Assistant must be alphanumerical
+    device_uuid = data['device']
+    device_entity_id = device_uuid.replace('-', '')
+
+    _SEE(dev_id=device_entity_id, gps=gps_coords, location_name=data['id'])
+
+    handler.write_json_message("Geofancy message processed")
@@ -1,38 +1,11 @@
 """
 homeassistant.components.device_tracker.luci
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Device tracker platform that supports scanning a OpenWRT router for device
 presence.

-
-It's required that the luci RPC package is installed on the OpenWRT router:
-# opkg install luci-mod-rpc
-
-Configuration:
-
-To use the Luci tracker you will need to add something like the following
-to your config/configuration.yaml
-
-device_tracker:
-  platform: luci
-  host: YOUR_ROUTER_IP
-  username: YOUR_ADMIN_USERNAME
-  password: YOUR_ADMIN_PASSWORD
-
-Variables:
-
-host
-*Required
-The IP address of your router, e.g. 192.168.1.1.
-
-username
-*Required
-The username of an user with administrative privileges, usually 'admin'.
-
-password
-*Required
-The password for your given admin account.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.luci.html
 """
 import logging
 import json
@@ -66,7 +39,8 @@ def get_scanner(hass, config):

 # pylint: disable=too-many-instance-attributes
 class LuciDeviceScanner(object):
-    """ This class queries a wireless router running OpenWrt firmware
+    """
+    This class queries a wireless router running OpenWrt firmware
    for connected devices. Adapted from Tomato scanner.

    # opkg install luci-mod-rpc
@@ -95,8 +69,9 @@ class LuciDeviceScanner(object):
        self.success_init = self.token is not None

    def scan_devices(self):
-        """ Scans for new devices and return a
-            list containing found device ids. """
+        """
+        Scans for new devices and return a list containing found device ids.
+        """

        self._update_info()

@@ -124,8 +99,10 @@ class LuciDeviceScanner(object):

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Ensures the information from the Luci router is up to date.
-            Returns boolean if scanning successful. """
+        """
+        Ensures the information from the Luci router is up to date.
+        Returns boolean if scanning successful.
+        """
        if not self.success_init:
            return False

@@ -179,6 +156,6 @@ def _req_json_rpc(url, method, *args, **kwargs):


 def _get_token(host, username, password):
-    """ Get authentication token for the given host+username+password """
+    """ Get authentication token for the given host+username+password. """
    url = 'http://{}/cgi-bin/luci/rpc/auth'.format(host)
    return _req_json_rpc(url, 'login', username, password)
@@ -0,0 +1,43 @@
+"""
+homeassistant.components.device_tracker.mqtt
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+MQTT platform for the device tracker.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.mqtt.html
+"""
+import logging
+from homeassistant import util
+import homeassistant.components.mqtt as mqtt
+
+DEPENDENCIES = ['mqtt']
+
+CONF_QOS = 'qos'
+CONF_DEVICES = 'devices'
+
+DEFAULT_QOS = 0
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_scanner(hass, config, see):
+    """ Set up a MQTT tracker. """
+    devices = config.get(CONF_DEVICES)
+    qos = util.convert(config.get(CONF_QOS), int, DEFAULT_QOS)
+
+    if not isinstance(devices, dict):
+        _LOGGER.error('Expected %s to be a dict, found %s', CONF_DEVICES,
+                      devices)
+        return False
+
+    dev_id_lookup = {}
+
+    def device_tracker_message_received(topic, payload, qos):
+        """ MQTT message received. """
+        see(dev_id=dev_id_lookup[topic], location_name=payload)
+
+    for dev_id, topic in devices.items():
+        dev_id_lookup[topic] = dev_id
+        mqtt.subscribe(hass, topic, device_tracker_message_received, qos)
+
+    return True
@@ -1,34 +1,11 @@
 """
 homeassistant.components.device_tracker.netgear
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Device tracker platform that supports scanning a Netgear router for device
 presence.

-Configuration:
-
-To use the Netgear tracker you will need to add something like the following
-to your config/configuration.yaml
-
-device_tracker:
-  platform: netgear
-  host: YOUR_ROUTER_IP
-  username: YOUR_ADMIN_USERNAME
-  password: YOUR_ADMIN_PASSWORD
-
-Variables:
-
-host
-*Required
-The IP address of your router, e.g. 192.168.1.1.
-
-username
-*Required
-The username of an user with administrative privileges, usually 'admin'.
-
-password
-*Required
-The password for your given admin account.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.netgear.html
 """
 import logging
 from datetime import timedelta
@@ -71,7 +48,6 @@ class NetgearDeviceScanner(object):
        self.lock = threading.Lock()

        if host is None:
-            print("BIER")
            self._api = pynetgear.Netgear()
        elif username is None:
            self._api = pynetgear.Netgear(password, host)
@@ -90,8 +66,9 @@ class NetgearDeviceScanner(object):
            _LOGGER.error("Failed to Login")

    def scan_devices(self):
-        """ Scans for new devices and return a
-            list containing found device ids. """
+        """
+        Scans for new devices and return a list containing found device ids.
+        """
        self._update_info()

        return (device.mac for device in self.last_results)
@@ -106,8 +83,10 @@ class NetgearDeviceScanner(object):

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Retrieves latest information from the Netgear router.
-            Returns boolean if scanning successful. """
+        """
+        Retrieves latest information from the Netgear router.
+        Returns boolean if scanning successful.
+        """
        if not self.success_init:
            return

@@ -1,29 +1,10 @@
 """
 homeassistant.components.device_tracker.nmap
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Device tracker platform that supports scanning a network with nmap.

-Configuration:
-
-To use the nmap tracker you will need to add something like the following
-to your config/configuration.yaml
-
-device_tracker:
-  platform: nmap_tracker
-  hosts: 192.168.1.1/24
-
-Variables:
-
-hosts
-*Required
-The IP addresses to scan in the network-prefix notation (192.168.1.1/24) or
-the range notation (192.168.1.1-255).
-
-home_interval
-*Optional
-Number of minutes it will not scan devices that it found in previous results.
-This is to save battery.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.nmap_scanner.html
 """
 import logging
 from datetime import timedelta
@@ -45,7 +26,7 @@ _LOGGER = logging.getLogger(__name__)
 # interval in minutes to exclude devices from a scan while they are home
 CONF_HOME_INTERVAL = "home_interval"

-REQUIREMENTS = ['python-nmap==0.4.1']
+REQUIREMENTS = ['python-nmap==0.4.3']


 def get_scanner(hass, config):
@@ -74,7 +55,7 @@ def _arp(ip_address):


 class NmapDeviceScanner(object):
-    """ This class scans for devices using nmap """
+    """ This class scans for devices using nmap. """

    def __init__(self, config):
        self.last_results = []
@@ -87,8 +68,9 @@ class NmapDeviceScanner(object):
        _LOGGER.info("nmap scanner initialized")

    def scan_devices(self):
-        """ Scans for new devices and return a
-            list containing found device ids. """
+        """
+        Scans for new devices and return a list containing found device ids.
+        """

        self._update_info()

@@ -107,23 +89,28 @@ class NmapDeviceScanner(object):

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Scans the network for devices.
-            Returns boolean if scanning successful. """
+        """
+        Scans the network for devices.
+        Returns boolean if scanning successful.
+        """
        _LOGGER.info("Scanning")

        from nmap import PortScanner, PortScannerError
        scanner = PortScanner()

-        options = "-sP --host-timeout 5"
-        exclude_targets = set()
+        options = "-F --host-timeout 5"
+
        if self.home_interval:
-            now = dt_util.now()
-            for host in self.last_results:
-                if host.last_update + self.home_interval > now:
-                    exclude_targets.add(host)
-            if len(exclude_targets) > 0:
-                target_list = [t.ip for t in exclude_targets]
-                options += " --exclude {}".format(",".join(target_list))
+            boundary = dt_util.now() - self.home_interval
+            last_results = [device for device in self.last_results
+                            if device.last_update > boundary]
+            if last_results:
+                # Pylint is confused here.
+                # pylint: disable=no-member
+                options += " --exclude {}".format(",".join(device.ip for device
+                                                           in last_results))
+        else:
+            last_results = []

        try:
            result = scanner.scan(hosts=self.hosts, arguments=options)
@@ -131,18 +118,17 @@ class NmapDeviceScanner(object):
            return False

        now = dt_util.now()
-        self.last_results = []
        for ipv4, info in result['scan'].items():
            if info['status']['state'] != 'up':
                continue
-            name = info['hostnames'][0] if info['hostnames'] else ipv4
+            name = info['hostnames'][0]['name'] if info['hostnames'] else ipv4
            # Mac address only returned if nmap ran as root
            mac = info['addresses'].get('mac') or _arp(ipv4)
            if mac is None:
                continue
-            device = Device(mac.upper(), name, ipv4, now)
-            self.last_results.append(device)
-        self.last_results.extend(exclude_targets)
+            last_results.append(Device(mac.upper(), name, ipv4, now))
+
+        self.last_results = last_results

        _LOGGER.info("nmap scan successful")
        return True
@@ -0,0 +1,53 @@
+"""
+homeassistant.components.device_tracker.owntracks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+OwnTracks platform for the device tracker.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.owntracks.html
+"""
+import json
+import logging
+
+import homeassistant.components.mqtt as mqtt
+
+DEPENDENCIES = ['mqtt']
+
+LOCATION_TOPIC = 'owntracks/+/+'
+
+
+def setup_scanner(hass, config, see):
+    """ Set up a OwnTracksks tracker. """
+
+    def owntracks_location_update(topic, payload, qos):
+        """ MQTT message received. """
+
+        # Docs on available data:
+        # http://owntracks.org/booklet/tech/json/#_typelocation
+        try:
+            data = json.loads(payload)
+        except ValueError:
+            # If invalid JSON
+            logging.getLogger(__name__).error(
+                'Unable to parse payload as JSON: %s', payload)
+            return
+
+        if not isinstance(data, dict) or data.get('_type') != 'location':
+            return
+
+        parts = topic.split('/')
+        kwargs = {
+            'dev_id': '{}_{}'.format(parts[1], parts[2]),
+            'host_name': parts[1],
+            'gps': (data['lat'], data['lon']),
+        }
+        if 'acc' in data:
+            kwargs['gps_accuracy'] = data['acc']
+        if 'batt' in data:
+            kwargs['battery'] = data['batt']
+
+        see(**kwargs)
+
+    mqtt.subscribe(hass, LOCATION_TOPIC, owntracks_location_update, 1)
+
+    return True
@@ -0,0 +1,119 @@
+"""
+homeassistant.components.device_tracker.snmp
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Device tracker platform that supports fetching WiFi associations
+through SNMP.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.snmp.html
+"""
+import logging
+from datetime import timedelta
+import threading
+import binascii
+
+from homeassistant.const import CONF_HOST
+from homeassistant.helpers import validate_config
+from homeassistant.util import Throttle
+from homeassistant.components.device_tracker import DOMAIN
+
+# Return cached results if last scan was less then this time ago
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
+
+_LOGGER = logging.getLogger(__name__)
+REQUIREMENTS = ['pysnmp==4.2.5']
+
+CONF_COMMUNITY = "community"
+CONF_BASEOID = "baseoid"
+
+
+# pylint: disable=unused-argument
+def get_scanner(hass, config):
+    """ Validates config and returns an snmp scanner """
+    if not validate_config(config,
+                           {DOMAIN: [CONF_HOST, CONF_COMMUNITY, CONF_BASEOID]},
+                           _LOGGER):
+        return None
+
+    scanner = SnmpScanner(config[DOMAIN])
+
+    return scanner if scanner.success_init else None
+
+
+class SnmpScanner(object):
+    """
+    This class queries any SNMP capable Acces Point for connected devices.
+    """
+    def __init__(self, config):
+        self.host = config[CONF_HOST]
+        self.community = config[CONF_COMMUNITY]
+        self.baseoid = config[CONF_BASEOID]
+
+        self.lock = threading.Lock()
+
+        self.last_results = []
+
+        # Test the router is accessible
+        data = self.get_snmp_data()
+        self.success_init = data is not None
+
+    def scan_devices(self):
+        """
+        Scans for new devices and return a list containing found device IDs.
+        """
+
+        self._update_info()
+        return [client['mac'] for client in self.last_results]
+
+    # Supressing no-self-use warning
+    # pylint: disable=R0201
+    def get_device_name(self, device):
+        """ Returns the name of the given device or None if we don't know. """
+        # We have no names
+        return None
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """
+        Ensures the information from the WAP is up to date.
+        Returns boolean if scanning successful.
+        """
+        if not self.success_init:
+            return False
+
+        with self.lock:
+            data = self.get_snmp_data()
+            if not data:
+                return False
+
+            self.last_results = data
+            return True
+
+    def get_snmp_data(self):
+        """ Fetch mac addresses from WAP via SNMP. """
+        from pysnmp.entity.rfc3413.oneliner import cmdgen
+
+        devices = []
+
+        snmp = cmdgen.CommandGenerator()
+        errindication, errstatus, errindex, restable = snmp.nextCmd(
+            cmdgen.CommunityData(self.community),
+            cmdgen.UdpTransportTarget((self.host, 161)),
+            cmdgen.MibVariable(self.baseoid)
+        )
+
+        if errindication:
+            _LOGGER.error("SNMPLIB error: %s", errindication)
+            return
+        if errstatus:
+            _LOGGER.error('SNMP error: %s at %s', errstatus.prettyPrint(),
+                          errindex and restable[-1][int(errindex)-1]
+                          or '?')
+            return
+
+        for resrow in restable:
+            for _, val in resrow:
+                mac = binascii.hexlify(val.asOctets()).decode('utf-8')
+                mac = ':'.join([mac[i:i+2] for i in range(0, len(mac), 2)])
+                devices.append({'mac': mac})
+        return devices
@@ -4,32 +4,8 @@ homeassistant.components.device_tracker.thomson
 Device tracker platform that supports scanning a THOMSON router for device
 presence.

-This device tracker needs telnet to be enabled on the router.
-
-Configuration:
-
-To use the THOMSON tracker you will need to add something like the following
-to your config/configuration.yaml
-
-device_tracker:
-  platform: thomson
-  host: YOUR_ROUTER_IP
-  username: YOUR_ADMIN_USERNAME
-  password: YOUR_ADMIN_PASSWORD
-
-Variables:
-
-host
-*Required
-The IP address of your router, e.g. 192.168.1.1.
-
-username
-*Required
-The username of an user with administrative privileges, usually 'admin'.
-
-password
-*Required
-The password for your given admin account.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.thomson.html
 """
 import logging
 from datetime import timedelta
@@ -71,7 +47,8 @@ def get_scanner(hass, config):


 class ThomsonDeviceScanner(object):
-    """ This class queries a router running THOMSON firmware
+    """
+    This class queries a router running THOMSON firmware
    for connected devices. Adapted from ASUSWRT scanner.
    """

@@ -107,8 +84,10 @@ class ThomsonDeviceScanner(object):

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Ensures the information from the THOMSON router is up to date.
-            Returns boolean if scanning successful. """
+        """
+        Ensures the information from the THOMSON router is up to date.
+        Returns boolean if scanning successful.
+        """
        if not self.success_init:
            return False

@@ -125,7 +104,7 @@ class ThomsonDeviceScanner(object):
            return True

    def get_thomson_data(self):
-        """ Retrieve data from THOMSON and return parsed result.  """
+        """ Retrieve data from THOMSON and return parsed result. """
        try:
            telnet = telnetlib.Telnet(self.host)
            telnet.read_until(b'Username : ')
@@ -1,40 +1,11 @@
 """
 homeassistant.components.device_tracker.tomato
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Device tracker platform that supports scanning a Tomato router for device
 presence.

-Configuration:
-
-To use the Tomato tracker you will need to add something like the following
-to your config/configuration.yaml
-
-device_tracker:
-  platform: tomato
-  host: YOUR_ROUTER_IP
-  username: YOUR_ADMIN_USERNAME
-  password: YOUR_ADMIN_PASSWORD
-  http_id: ABCDEFG
-
-Variables:
-
-host
-*Required
-The IP address of your router, e.g. 192.168.1.1.
-
-username
-*Required
-The username of an user with administrative privileges, usually 'admin'.
-
-password
-*Required
-The password for your given admin account.
-
-http_id
-*Required
-The value can be obtained by logging in to the Tomato admin interface and
-search for http_id in the page source code.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.tomato.html
 """
 import logging
 import json
@@ -1,35 +1,11 @@
 """
 homeassistant.components.device_tracker.tplink
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Device tracker platform that supports scanning a TP-Link router for device
 presence.

-Configuration:
-
-To use the TP-Link tracker you will need to add something like the following
-to your config/configuration.yaml
-
-device_tracker:
-  platform: tplink
-  host: YOUR_ROUTER_IP
-  username: YOUR_ADMIN_USERNAME
-  password: YOUR_ADMIN_PASSWORD
-
-Variables:
-
-host
-*Required
-The IP address of your router, e.g. 192.168.1.1.
-
-username
-*Required
-The username of an user with administrative privileges, usually 'admin'.
-
-password
-*Required
-The password for your given admin account.
-
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.tplink.html
 """
 import base64
 import logging
@@ -56,16 +32,20 @@ def get_scanner(hass, config):
                           _LOGGER):
        return None

-    scanner = Tplink2DeviceScanner(config[DOMAIN])
+    scanner = Tplink3DeviceScanner(config[DOMAIN])

    if not scanner.success_init:
-        scanner = TplinkDeviceScanner(config[DOMAIN])
+        scanner = Tplink2DeviceScanner(config[DOMAIN])
+
+        if not scanner.success_init:
+            scanner = TplinkDeviceScanner(config[DOMAIN])

    return scanner if scanner.success_init else None


 class TplinkDeviceScanner(object):
-    """ This class queries a wireless router running TP-Link firmware
+    """
+    This class queries a wireless router running TP-Link firmware
    for connected devices.
    """

@@ -85,8 +65,9 @@ class TplinkDeviceScanner(object):
        self.success_init = self._update_info()

    def scan_devices(self):
-        """ Scans for new devices and return a
-            list containing found device ids. """
+        """
+        Scans for new devices and return a list containing found device ids.
+        """

        self._update_info()

@@ -94,15 +75,18 @@ class TplinkDeviceScanner(object):

    # pylint: disable=no-self-use
    def get_device_name(self, device):
-        """ The TP-Link firmware doesn't save the name of the wireless
-            device. """
+        """
+        The TP-Link firmware doesn't save the name of the wireless device.
+        """

        return None

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Ensures the information from the TP-Link router is up to date.
-            Returns boolean if scanning successful. """
+        """
+        Ensures the information from the TP-Link router is up to date.
+        Returns boolean if scanning successful.
+        """

        with self.lock:
            _LOGGER.info("Loading wireless clients...")
@@ -122,33 +106,38 @@ class TplinkDeviceScanner(object):


 class Tplink2DeviceScanner(TplinkDeviceScanner):
-    """ This class queries a wireless router running newer version of TP-Link
+    """
+    This class queries a wireless router running newer version of TP-Link
    firmware for connected devices.
    """

    def scan_devices(self):
-        """ Scans for new devices and return a
-            list containing found device ids. """
+        """
+        Scans for new devices and return a list containing found device ids.
+        """

        self._update_info()
        return self.last_results.keys()

    # pylint: disable=no-self-use
    def get_device_name(self, device):
-        """ The TP-Link firmware doesn't save the name of the wireless
-            device. """
+        """
+        The TP-Link firmware doesn't save the name of the wireless device.
+        """

        return self.last_results.get(device)

    @Throttle(MIN_TIME_BETWEEN_SCANS)
    def _update_info(self):
-        """ Ensures the information from the TP-Link router is up to date.
-            Returns boolean if scanning successful. """
+        """
+        Ensures the information from the TP-Link router is up to date.
+        Returns boolean if scanning successful.
+        """

        with self.lock:
            _LOGGER.info("Loading wireless clients...")

-            url = 'http://{}/data/map_access_wireless_client_grid.json'\
+            url = 'http://{}/data/map_access_wireless_client_grid.json' \
                .format(self.host)
            referer = 'http://{}'.format(self.host)

@@ -158,7 +147,7 @@ class Tplink2DeviceScanner(TplinkDeviceScanner):
            b64_encoded_username_password = base64.b64encode(
                username_password.encode('ascii')
            ).decode('ascii')
-            cookie = 'Authorization=Basic {}'\
+            cookie = 'Authorization=Basic {}' \
                .format(b64_encoded_username_password)

            response = requests.post(url, headers={'referer': referer,
@@ -175,7 +164,119 @@ class Tplink2DeviceScanner(TplinkDeviceScanner):
                self.last_results = {
                    device['mac_addr'].replace('-', ':'): device['name']
                    for device in result
-                }
+                    }
+                return True
+
+            return False
+
+
+class Tplink3DeviceScanner(TplinkDeviceScanner):
+    """
+    This class queries the Archer C9 router running version 150811 or higher
+    of TP-Link firmware for connected devices.
+    """
+
+    def __init__(self, config):
+        self.stok = ''
+        self.sysauth = ''
+        super(Tplink3DeviceScanner, self).__init__(config)
+
+    def scan_devices(self):
+        """
+        Scans for new devices and return a list containing found device ids.
+        """
+
+        self._update_info()
+        return self.last_results.keys()
+
+    # pylint: disable=no-self-use
+    def get_device_name(self, device):
+        """
+        The TP-Link firmware doesn't save the name of the wireless device.
+        We are forced to use the MAC address as name here.
+        """
+
+        return self.last_results.get(device)
+
+    def _get_auth_tokens(self):
+        """
+        Retrieves auth tokens from the router.
+        """
+
+        _LOGGER.info("Retrieving auth tokens...")
+
+        url = 'http://{}/cgi-bin/luci/;stok=/login?form=login' \
+            .format(self.host)
+        referer = 'http://{}/webpages/login.html'.format(self.host)
+
+        # if possible implement rsa encryption of password here
+
+        response = requests.post(url,
+                                 params={'operation': 'login',
+                                         'username': self.username,
+                                         'password': self.password},
+                                 headers={'referer': referer})
+
+        try:
+            self.stok = response.json().get('data').get('stok')
+            _LOGGER.info(self.stok)
+            regex_result = re.search('sysauth=(.*);',
+                                     response.headers['set-cookie'])
+            self.sysauth = regex_result.group(1)
+            _LOGGER.info(self.sysauth)
+            return True
+        except ValueError:
+            _LOGGER.error("Couldn't fetch auth tokens!")
+            return False
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """
+        Ensures the information from the TP-Link router is up to date.
+        Returns boolean if scanning successful.
+        """
+
+        with self.lock:
+            if (self.stok == '') or (self.sysauth == ''):
+                self._get_auth_tokens()
+
+            _LOGGER.info("Loading wireless clients...")
+
+            url = 'http://{}/cgi-bin/luci/;stok={}/admin/wireless?form=statistics' \
+                .format(self.host, self.stok)
+            referer = 'http://{}/webpages/index.html'.format(self.host)
+
+            response = requests.post(url,
+                                     params={'operation': 'load'},
+                                     headers={'referer': referer},
+                                     cookies={'sysauth': self.sysauth})
+
+            try:
+                json_response = response.json()
+
+                if json_response.get('success'):
+                    result = response.json().get('data')
+                else:
+                    if json_response.get('errorcode') == 'timeout':
+                        _LOGGER.info("Token timed out. "
+                                     "Relogging on next scan.")
+                        self.stok = ''
+                        self.sysauth = ''
+                        return False
+                    else:
+                        _LOGGER.error("An unknown error happened "
+                                      "while fetching data.")
+                        return False
+            except ValueError:
+                _LOGGER.error("Router didn't respond with JSON. "
+                              "Check if credentials are correct.")
+                return False
+
+            if result:
+                self.last_results = {
+                    device['mac'].replace('-', ':'): device['mac']
+                    for device in result
+                    }
                return True

            return False
@@ -0,0 +1,173 @@
+"""
+homeassistant.components.device_tracker.ubus
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Device tracker platform that supports scanning a OpenWRT router for device
+presence.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.ubus.html
+"""
+import logging
+import json
+from datetime import timedelta
+import re
+import threading
+import requests
+
+from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD
+from homeassistant.helpers import validate_config
+from homeassistant.util import Throttle
+from homeassistant.components.device_tracker import DOMAIN
+
+# Return cached results if last scan was less then this time ago
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def get_scanner(hass, config):
+    """ Validates config and returns a Luci scanner. """
+    if not validate_config(config,
+                           {DOMAIN: [CONF_HOST, CONF_USERNAME, CONF_PASSWORD]},
+                           _LOGGER):
+        return None
+
+    scanner = UbusDeviceScanner(config[DOMAIN])
+
+    return scanner if scanner.success_init else None
+
+
+# pylint: disable=too-many-instance-attributes
+class UbusDeviceScanner(object):
+    """
+    This class queries a wireless router running OpenWrt firmware
+    for connected devices. Adapted from Tomato scanner.
+
+    Configure your routers' ubus ACL based on following instructions:
+
+    http://wiki.openwrt.org/doc/techref/ubus
+
+    Read only access will be fine.
+
+    To use this class you have to install rpcd-mod-file package
+    in your OpenWrt router:
+
+    opkg install rpcd-mod-file
+
+    """
+
+    def __init__(self, config):
+        host = config[CONF_HOST]
+        username, password = config[CONF_USERNAME], config[CONF_PASSWORD]
+
+        self.parse_api_pattern = re.compile(r"(?P<param>\w*) = (?P<value>.*);")
+        self.lock = threading.Lock()
+        self.last_results = {}
+        self.url = 'http://{}/ubus'.format(host)
+
+        self.session_id = _get_session_id(self.url, username, password)
+        self.hostapd = []
+        self.leasefile = None
+        self.mac2name = None
+        self.success_init = self.session_id is not None
+
+    def scan_devices(self):
+        """
+        Scans for new devices and return a list containing found device ids.
+        """
+
+        self._update_info()
+
+        return self.last_results
+
+    def get_device_name(self, device):
+        """ Returns the name of the given device or None if we don't know. """
+
+        with self.lock:
+            if self.leasefile is None:
+                result = _req_json_rpc(self.url, self.session_id,
+                                       'call', 'uci', 'get',
+                                       config="dhcp", type="dnsmasq")
+                if result:
+                    values = result["values"].values()
+                    self.leasefile = next(iter(values))["leasefile"]
+                else:
+                    return
+
+            if self.mac2name is None:
+                result = _req_json_rpc(self.url, self.session_id,
+                                       'call', 'file', 'read',
+                                       path=self.leasefile)
+                if result:
+                    self.mac2name = dict()
+                    for line in result["data"].splitlines():
+                        hosts = line.split(" ")
+                        self.mac2name[hosts[1].upper()] = hosts[3]
+                else:
+                    # Error, handled in the _req_json_rpc
+                    return
+
+            return self.mac2name.get(device.upper(), None)
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """
+        Ensures the information from the Luci router is up to date.
+        Returns boolean if scanning successful.
+        """
+        if not self.success_init:
+            return False
+
+        with self.lock:
+            _LOGGER.info("Checking ARP")
+
+            if not self.hostapd:
+                hostapd = _req_json_rpc(self.url, self.session_id,
+                                        'list', 'hostapd.*', '')
+                self.hostapd.extend(hostapd.keys())
+
+            self.last_results = []
+            results = 0
+            for hostapd in self.hostapd:
+                result = _req_json_rpc(self.url, self.session_id,
+                                       'call', hostapd, 'get_clients')
+
+                if result:
+                    results = results + 1
+                    self.last_results.extend(result['clients'].keys())
+
+            return bool(results)
+
+
+def _req_json_rpc(url, session_id, rpcmethod, subsystem, method, **params):
+    """ Perform one JSON RPC operation. """
+
+    data = json.dumps({"jsonrpc": "2.0",
+                       "id": 1,
+                       "method": rpcmethod,
+                       "params": [session_id,
+                                  subsystem,
+                                  method,
+                                  params]})
+
+    try:
+        res = requests.post(url, data=data, timeout=5)
+
+    except requests.exceptions.Timeout:
+        return
+
+    if res.status_code == 200:
+        response = res.json()
+
+        if rpcmethod == "call":
+            return response["result"][1]
+        else:
+            return response["result"]
+
+
+def _get_session_id(url, username, password):
+    """ Get authentication token for the given host+username+password. """
+    res = _req_json_rpc(url, "00000000000000000000000000000000", 'call',
+                        'session', 'login', username=username,
+                        password=password)
+    return res["ubus_rpc_session"]
@@ -19,22 +19,24 @@ from homeassistant.const import (

 DOMAIN = "discovery"
 DEPENDENCIES = []
-REQUIREMENTS = ['netdisco==0.3']
+REQUIREMENTS = ['netdisco==0.5.1']

 SCAN_INTERVAL = 300  # seconds

-# Next 3 lines for now a mirror from netdisco.const
-# Should setup a mapping netdisco.const -> own constants
 SERVICE_WEMO = 'belkin_wemo'
 SERVICE_HUE = 'philips_hue'
 SERVICE_CAST = 'google_cast'
 SERVICE_NETGEAR = 'netgear_router'
+SERVICE_SONOS = 'sonos'
+SERVICE_PLEX = 'plex_mediaserver'

 SERVICE_HANDLERS = {
    SERVICE_WEMO: "switch",
    SERVICE_CAST: "media_player",
    SERVICE_HUE: "light",
    SERVICE_NETGEAR: 'device_tracker',
+    SERVICE_SONOS: 'media_player',
+    SERVICE_PLEX: 'media_player',
 }


@@ -79,13 +81,6 @@ def setup(hass, config):
            if not component:
                return

-            # Hack - fix when device_tracker supports discovery
-            if service == SERVICE_NETGEAR:
-                bootstrap.setup_component(hass, component, {
-                    'device_tracker': {'platform': 'netgear'}
-                })
-                return
-
            # This component cannot be setup.
            if not bootstrap.setup_component(hass, component, config):
                return
@@ -95,6 +90,7 @@ def setup(hass, config):
                ATTR_DISCOVERED: info
            })

+    # pylint: disable=unused-argument
    def start_discovery(event):
        """ Start discovering. """
        netdisco = DiscoveryService(SCAN_INTERVAL)
@@ -1,8 +1,10 @@
 """
 homeassistant.components.downloader
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provides functionality to download files.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/downloader.html
 """
 import os
 import logging
@@ -42,6 +44,10 @@ def setup(hass, config):

    download_path = config[DOMAIN][CONF_DOWNLOAD_DIR]

+    # If path is relative, we assume relative to HASS config dir
+    if not os.path.isabs(download_path):
+        download_path = hass.config.path(download_path)
+
    if not os.path.isdir(download_path):

        logger.error(
@@ -11,6 +11,7 @@ import logging
 from . import version
 import homeassistant.util as util
 from homeassistant.const import URL_ROOT, HTTP_OK
+from homeassistant.config import get_default_config_dir

 DOMAIN = 'frontend'
 DEPENDENCIES = ['api']
@@ -19,9 +20,9 @@ INDEX_PATH = os.path.join(os.path.dirname(__file__), 'index.html.template')

 _LOGGER = logging.getLogger(__name__)

-
 FRONTEND_URLS = [
-    URL_ROOT, '/logbook', '/history', '/devService', '/devState', '/devEvent']
+    URL_ROOT, '/logbook', '/history', '/map', '/devService', '/devState',
+    '/devEvent']
 STATES_URL = re.compile(r'/states(/([a-zA-Z\._\-0-9/]+)|)')


@@ -43,6 +44,9 @@ def setup(hass, config):
    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

@@ -83,3 +87,16 @@ def _handle_get_static(handler, path_match, data):
    path = os.path.join(os.path.dirname(__file__), 'www_static', req_file)

    handler.write_file(path)
+
+
+def _handle_get_local(handler, path_match, data):
+    """
+    Returns a static file from the hass.config.path/www for the frontend.
+    """
+    req_file = util.sanitize_path(path_match.group('file'))
+
+    path = os.path.join(get_default_config_dir(), 'www', req_file)
+    if not os.path.isfile(path):
+        return False
+
+    handler.write_file(path)
@@ -1,2 +1,2 @@
 """ DO NOT MODIFY. Auto-generated by build_frontend script """
-VERSION = "35ecb5457a9ff0f4142c2605b53eb843"
+VERSION = "beb922c55bb26ea576581b453f6d7c04"
@@ -1,10 +1,11 @@
 """
 homeassistant.components.group
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provides functionality to group devices that can be turned on or off.
-"""

+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/group.html
+"""
 import homeassistant.core as ha
 from homeassistant.helpers import generate_entity_id
 from homeassistant.helpers.event import track_state_change
@@ -12,7 +13,8 @@ from homeassistant.helpers.entity import Entity
 import homeassistant.util as util
 from homeassistant.const import (
    ATTR_ENTITY_ID, STATE_ON, STATE_OFF,
-    STATE_HOME, STATE_NOT_HOME, STATE_UNKNOWN)
+    STATE_HOME, STATE_NOT_HOME, STATE_OPEN, STATE_CLOSED,
+    STATE_UNKNOWN)

 DOMAIN = "group"
 DEPENDENCIES = []
@@ -22,7 +24,8 @@ ENTITY_ID_FORMAT = DOMAIN + ".{}"
 ATTR_AUTO = "auto"

 # List of ON/OFF state tuples for groupable states
-_GROUP_TYPES = [(STATE_ON, STATE_OFF), (STATE_HOME, STATE_NOT_HOME)]
+_GROUP_TYPES = [(STATE_ON, STATE_OFF), (STATE_HOME, STATE_NOT_HOME),
+                (STATE_OPEN, STATE_CLOSED)]


 def _get_group_on_off(state):
@@ -1,8 +1,10 @@
 """
 homeassistant.components.history
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provide pre-made queries on top of the recorder component.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/history.html
 """
 import re
 from datetime import timedelta
@@ -147,8 +149,6 @@ def _api_history_period(handler, path_match, data):

    end_time = start_time + one_day

-    print("Fetchign", start_time, end_time)
-
    entity_id = data.get('filter_entity_id')

    handler.write_json(
@@ -1,76 +1,11 @@
 """
-homeassistant.components.httpinterface
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
+homeassistant.components.http
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 This module provides an API and a HTTP interface for debug purposes.

-By default it will run on port 8123.
-
-All API calls have to be accompanied by an 'api_password' parameter and will
-return JSON. If successful calls will return status code 200 or 201.
-
-Other status codes that can occur are:
- - 400 (Bad Request)
- - 401 (Unauthorized)
- - 404 (Not Found)
- - 405 (Method not allowed)
-
-The api supports the following actions:
-
-/api - GET
-Returns message if API is up and running.
-Example result:
-{
-  "message": "API running."
-}
-
-/api/states - GET
-Returns a list of entities for which a state is available
-Example result:
-[
-    { .. state object .. },
-    { .. state object .. }
-]
-
-/api/states/<entity_id> - GET
-Returns the current state from an entity
-Example result:
-{
-    "attributes": {
-        "next_rising": "07:04:15 29-10-2013",
-        "next_setting": "18:00:31 29-10-2013"
-    },
-    "entity_id": "weather.sun",
-    "last_changed": "23:24:33 28-10-2013",
-    "state": "below_horizon"
-}
-
-/api/states/<entity_id> - POST
-Updates the current state of an entity. Returns status code 201 if successful
-with location header of updated resource and as body the new state.
-parameter: new_state - string
-optional parameter: attributes - JSON encoded object
-Example result:
-{
-    "attributes": {
-        "next_rising": "07:04:15 29-10-2013",
-        "next_setting": "18:00:31 29-10-2013"
-    },
-    "entity_id": "weather.sun",
-    "last_changed": "23:24:33 28-10-2013",
-    "state": "below_horizon"
-}
-
-/api/events/<event_type> - POST
-Fires an event with event_type
-optional parameter: event_data - JSON encoded object
-Example result:
-{
-    "message": "Event download_file fired."
-}
-
+For more details about the RESTful API, please refer to the documentation at
+https://home-assistant.io/developers/api.html
 """
-
 import json
 import threading
 import logging
@@ -205,7 +140,7 @@ class HomeAssistantHTTPServer(ThreadingMixIn, HTTPServer):
        self.serve_forever()

    def register_path(self, method, url, callback, require_auth=True):
-        """ Registers a path wit the server. """
+        """ Registers a path with the server. """
        self.paths.append((method, url, callback, require_auth))

    def log_message(self, fmt, *args):
@@ -232,7 +167,12 @@ class RequestHandler(SimpleHTTPRequestHandler):

    def log_message(self, fmt, *arguments):
        """ Redirect built-in log to HA logging """
-        _LOGGER.info(fmt, *arguments)
+        if self.server.no_password_set:
+            _LOGGER.info(fmt, *arguments)
+        else:
+            _LOGGER.info(
+                fmt, *(arg.replace(self.server.api_password, '*******')
+                       if isinstance(arg, str) else arg for arg in arguments))

    def _handle_request(self, method):  # pylint: disable=too-many-branches
        """ Does some common checks and calls appropriate method. """
@@ -487,7 +427,7 @@ class ServerSession:
        return self._expiry < date_util.utcnow()


-class SessionStore:
+class SessionStore(object):
    """ Responsible for storing and retrieving http sessions """
    def __init__(self, enabled=True):
        """ Set up the session store """
@@ -0,0 +1,66 @@
+"""
+homeassistant.components.ifttt
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This component enable you to trigger Maker IFTTT recipes.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/ifttt.html
+"""
+import logging
+import requests
+
+from homeassistant.helpers import validate_config
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = "ifttt"
+
+SERVICE_TRIGGER = 'trigger'
+
+ATTR_EVENT = 'event'
+ATTR_VALUE1 = 'value1'
+ATTR_VALUE2 = 'value2'
+ATTR_VALUE3 = 'value3'
+
+DEPENDENCIES = []
+
+REQUIREMENTS = ['pyfttt==0.3']
+
+
+def trigger(hass, event, value1=None, value2=None, value3=None):
+    """ Trigger a Maker IFTTT recipe """
+    data = {
+        ATTR_EVENT: event,
+        ATTR_VALUE1: value1,
+        ATTR_VALUE2: value2,
+        ATTR_VALUE3: value3,
+    }
+    hass.services.call(DOMAIN, SERVICE_TRIGGER, data)
+
+
+def setup(hass, config):
+    """ Setup the ifttt service component """
+
+    if not validate_config(config, {DOMAIN: ['key']}, _LOGGER):
+        return False
+
+    key = config[DOMAIN]['key']
+
+    def trigger_service(call):
+        """ Handle ifttt trigger service calls. """
+        event = call.data.get(ATTR_EVENT)
+        value1 = call.data.get(ATTR_VALUE1)
+        value2 = call.data.get(ATTR_VALUE2)
+        value3 = call.data.get(ATTR_VALUE3)
+        if event is None:
+            return
+
+        try:
+            import pyfttt as pyfttt
+            pyfttt.send_event(key, event, value1, value2, value3)
+        except requests.exceptions.RequestException:
+            _LOGGER.exception("Error communicating with IFTTT")
+
+    hass.services.register(DOMAIN, SERVICE_TRIGGER, trigger_service)
+
+    return True
@@ -1,8 +1,10 @@
 """
 homeassistant.components.introduction
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Component that will help guide the user taking its first steps.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/introduction.html
 """
 import logging

@@ -1,8 +1,10 @@
 """
 homeassistant.components.keyboard
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provides functionality to emulate keyboard presses on host machine.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/keyboard.html
 """
 import logging

@@ -52,14 +52,14 @@ import logging
 import os
 import csv

-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.entity import ToggleEntity
-
-import homeassistant.util as util
-import homeassistant.util.color as color_util
+from homeassistant.components import group, discovery, wink, isy994
+from homeassistant.config import load_yaml_config_file
 from homeassistant.const import (
    STATE_ON, SERVICE_TURN_ON, SERVICE_TURN_OFF, ATTR_ENTITY_ID)
-from homeassistant.components import group, discovery, wink, isy994
+from homeassistant.helpers.entity import ToggleEntity
+from homeassistant.helpers.entity_component import EntityComponent
+import homeassistant.util as util
+import homeassistant.util.color as color_util


 DOMAIN = "light"
@@ -246,6 +246,7 @@ def setup(hass, config):
                rgb_color = dat.get(ATTR_RGB_COLOR)

                if len(rgb_color) == 3:
+                    params[ATTR_RGB_COLOR] = [int(val) for val in rgb_color]
                    params[ATTR_XY_COLOR] = \
                        color_util.color_RGB_to_xy(int(rgb_color[0]),
                                                   int(rgb_color[1]),
@@ -275,11 +276,13 @@ def setup(hass, config):
                light.update_ha_state(True)

    # Listen for light on and light off service calls
-    hass.services.register(DOMAIN, SERVICE_TURN_ON,
-                           handle_light_service)
+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+    hass.services.register(DOMAIN, SERVICE_TURN_ON, handle_light_service,
+                           descriptions.get(SERVICE_TURN_ON))

-    hass.services.register(DOMAIN, SERVICE_TURN_OFF,
-                           handle_light_service)
+    hass.services.register(DOMAIN, SERVICE_TURN_OFF, handle_light_service,
+                           descriptions.get(SERVICE_TURN_OFF))

    return True

@@ -0,0 +1,76 @@
+"""
+homeassistant.components.light.blinksticklight
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Support for Blinkstick lights.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/light.blinksticklight.html
+"""
+import logging
+
+from blinkstick import blinkstick
+
+from homeassistant.components.light import (Light, ATTR_RGB_COLOR)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+REQUIREMENTS = ["blinkstick==1.1.7"]
+DEPENDENCIES = []
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """ Add device specified by serial number. """
+    stick = blinkstick.find_by_serial(config['serial'])
+
+    add_devices_callback([BlinkStickLight(stick, config['name'])])
+
+
+class BlinkStickLight(Light):
+    """ Represents a BlinkStick light. """
+
+    def __init__(self, stick, name):
+        self._stick = stick
+        self._name = name
+        self._serial = stick.get_serial()
+        self._rgb_color = stick.get_color()
+
+    @property
+    def should_poll(self):
+        """ Polling needed. """
+        return True
+
+    @property
+    def name(self):
+        """ The name of the light. """
+        return self._name
+
+    @property
+    def rgb_color(self):
+        """ Read back the color of the light. """
+        return self._rgb_color
+
+    @property
+    def is_on(self):
+        """ Check whether any of the LEDs colors are non-zero. """
+        return sum(self._rgb_color) > 0
+
+    def update(self):
+        """ Read back the device state """
+        self._rgb_color = self._stick.get_color()
+
+    def turn_on(self, **kwargs):
+        """ Turn the device on. """
+        if ATTR_RGB_COLOR in kwargs:
+            self._rgb_color = kwargs[ATTR_RGB_COLOR]
+        else:
+            self._rgb_color = [255, 255, 255]
+
+        self._stick.set_color(red=self._rgb_color[0],
+                              green=self._rgb_color[1],
+                              blue=self._rgb_color[2])
+
+    def turn_off(self, **kwargs):
+        """ Turn the device off """
+        self._stick.turn_off()
@@ -2,6 +2,8 @@
 homeassistant.components.light.hue
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Support for Hue lights.
+
+https://home-assistant.io/components/light.hue.html
 """
 import logging
 import socket
@@ -0,0 +1,125 @@
+"""
+homeassistant.components.light.hyperion
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Support for Hyperion remotes.
+
+https://home-assistant.io/components/light.hyperion.html
+"""
+import logging
+import socket
+import json
+
+from homeassistant.const import CONF_HOST
+from homeassistant.components.light import (Light, ATTR_RGB_COLOR)
+
+_LOGGER = logging.getLogger(__name__)
+REQUIREMENTS = []
+
+
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """ Sets up a Hyperion server remote """
+    host = config.get(CONF_HOST, None)
+    port = config.get("port", 19444)
+    device = Hyperion(host, port)
+    if device.setup():
+        add_devices_callback([device])
+        return True
+    else:
+        return False
+
+
+class Hyperion(Light):
+    """ Represents a Hyperion remote """
+
+    def __init__(self, host, port):
+        self._host = host
+        self._port = port
+        self._name = host
+        self._is_available = True
+        self._rgb_color = [255, 255, 255]
+
+    @property
+    def name(self):
+        """ Return the hostname of the server. """
+        return self._name
+
+    @property
+    def rgb_color(self):
+        """ Last RGB color value set. """
+        return self._rgb_color
+
+    @property
+    def is_on(self):
+        """ True if the device is online. """
+        return self._is_available
+
+    def turn_on(self, **kwargs):
+        """ Turn the lights on. """
+        if self._is_available:
+            if ATTR_RGB_COLOR in kwargs:
+                self._rgb_color = kwargs[ATTR_RGB_COLOR]
+
+            self.json_request({"command": "color", "priority": 128,
+                               "color": self._rgb_color})
+
+    def turn_off(self, **kwargs):
+        """ Disconnect the remote. """
+        self.json_request({"command": "clearall"})
+
+    def update(self):
+        """ Ping the remote. """
+        # just see if the remote port is open
+        self._is_available = self.json_request()
+
+    def setup(self):
+        """ Get the hostname of the remote. """
+        response = self.json_request({"command": "serverinfo"})
+        if response:
+            self._name = response["info"]["hostname"]
+            return True
+
+        return False
+
+    def json_request(self, request=None, wait_for_response=False):
+        """ Communicate with the json server. """
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(5)
+
+        try:
+            sock.connect((self._host, self._port))
+        except OSError:
+            sock.close()
+            return False
+
+        if not request:
+            # no communication needed, simple presence detection returns True
+            sock.close()
+            return True
+
+        sock.send(bytearray(json.dumps(request) + "\n", "utf-8"))
+        try:
+            buf = sock.recv(4096)
+        except socket.timeout:
+            # something is wrong, assume it's offline
+            sock.close()
+            return False
+
+        # read until a newline or timeout
+        buffering = True
+        while buffering:
+            if "\n" in str(buf, "utf-8"):
+                response = str(buf, "utf-8").split("\n")[0]
+                buffering = False
+            else:
+                try:
+                    more = sock.recv(4096)
+                except socket.timeout:
+                    more = None
+                if not more:
+                    buffering = False
+                    response = str(buf, "utf-8")
+                else:
+                    buf += more
+
+        sock.close()
+        return json.loads(response)
@@ -12,19 +12,7 @@ Support for LimitlessLED bulbs, also known as...
 - dekolight
 - iLight

-Configuration:
-
-To use limitlessled you will need to add the following to your
-config/configuration.yaml.
-
-light:
-  platform: limitlessled
-  host: 192.168.1.10
-  group_1_name: Living Room
-  group_2_name: Bedroom
-  group_3_name: Office
-  group_4_name: Kitchen
-
+https://home-assistant.io/components/light.limitlessled.html
 """
 import logging

@@ -34,19 +22,30 @@ from homeassistant.components.light import (Light, ATTR_BRIGHTNESS,
 from homeassistant.util.color import color_RGB_to_xy

 _LOGGER = logging.getLogger(__name__)
-REQUIREMENTS = ['ledcontroller==1.0.7']
+REQUIREMENTS = ['ledcontroller==1.1.0']


 def setup_platform(hass, config, add_devices_callback, discovery_info=None):
    """ Gets the LimitlessLED lights. """
    import ledcontroller

-    led = ledcontroller.LedController(config['host'])
+    # Handle old configuration format:
+    bridges = config.get('bridges', [config])
+
+    for bridge_id, bridge in enumerate(bridges):
+        bridge['id'] = bridge_id
+
+    pool = ledcontroller.LedControllerPool([x['host'] for x in bridges])

    lights = []
-    for i in range(1, 5):
-        if 'group_%d_name' % (i) in config:
-            lights.append(LimitlessLED(led, i, config['group_%d_name' % (i)]))
+    for bridge in bridges:
+        for i in range(1, 5):
+            name_key = 'group_%d_name' % i
+            if name_key in bridge:
+                group_type = bridge.get('group_%d_type' % i, 'rgbw')
+                lights.append(LimitlessLED.factory(pool, bridge['id'], i,
+                                                   bridge[name_key],
+                                                   group_type))

    add_devices_callback(lights)

@@ -54,15 +53,57 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
 class LimitlessLED(Light):
    """ Represents a LimitlessLED light """

-    def __init__(self, led, group, name):
-        self.led = led
+    @staticmethod
+    def factory(pool, controller_id, group, name, group_type):
+        ''' Construct a Limitless LED of the appropriate type '''
+        if group_type == 'white':
+            return WhiteLimitlessLED(pool, controller_id, group, name)
+        elif group_type == 'rgbw':
+            return RGBWLimitlessLED(pool, controller_id, group, name)
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, pool, controller_id, group, name, group_type):
+        self.pool = pool
+        self.controller_id = controller_id
        self.group = group

+        self.pool.execute(self.controller_id, "set_group_type", self.group,
+                          group_type)
+
        # LimitlessLEDs don't report state, we have track it ourselves.
-        self.led.off(self.group)
+        self.pool.execute(self.controller_id, "off", self.group)

        self._name = name or DEVICE_DEFAULT_NAME
        self._state = False
+
+    @property
+    def should_poll(self):
+        """ No polling needed. """
+        return False
+
+    @property
+    def name(self):
+        """ Returns the name of the device if any. """
+        return self._name
+
+    @property
+    def is_on(self):
+        """ True if device is on. """
+        return self._state
+
+    def turn_off(self, **kwargs):
+        """ Turn the device off. """
+        self._state = False
+        self.pool.execute(self.controller_id, "off", self.group)
+        self.update_ha_state()
+
+
+class RGBWLimitlessLED(LimitlessLED):
+    """ Represents a RGBW LimitlessLED light """
+
+    def __init__(self, pool, controller_id, group, name):
+        super().__init__(pool, controller_id, group, name, 'rgbw')
+
        self._brightness = 100
        self._xy_color = color_RGB_to_xy(255, 255, 255)

@@ -88,16 +129,6 @@ class LimitlessLED(Light):
            ((0xE6, 0xE6, 0xFA), 'lavendar'),
        ]]

-    @property
-    def should_poll(self):
-        """ No polling needed for a demo light. """
-        return False
-
-    @property
-    def name(self):
-        """ Returns the name of the device if any. """
-        return self._name
-
    @property
    def brightness(self):
        return self._brightness
@@ -107,7 +138,7 @@ class LimitlessLED(Light):
        return self._xy_color

    def _xy_to_led_color(self, xy_color):
-        """ Convert an XY color to the closest LedController color string """
+        """ Convert an XY color to the closest LedController color string. """
        def abs_dist_squared(p_0, p_1):
            """ Returns the absolute value of the squared distance """
            return abs((p_0[0] - p_1[0])**2 + (p_0[1] - p_1[1])**2)
@@ -118,11 +149,6 @@ class LimitlessLED(Light):
        # First candidate in the sorted list is closest to desired color:
        return sorted(candidates)[0][1]

-    @property
-    def is_on(self):
-        """ True if device is on. """
-        return self._state
-
    def turn_on(self, **kwargs):
        """ Turn the device on. """
        self._state = True
@@ -133,12 +159,21 @@ class LimitlessLED(Light):
        if ATTR_XY_COLOR in kwargs:
            self._xy_color = kwargs[ATTR_XY_COLOR]

-        self.led.set_color(self._xy_to_led_color(self._xy_color), self.group)
-        self.led.set_brightness(self._brightness / 255.0, self.group)
+        self.pool.execute(self.controller_id, "set_color",
+                          self._xy_to_led_color(self._xy_color), self.group)
+        self.pool.execute(self.controller_id, "set_brightness",
+                          self._brightness / 255.0, self.group)
        self.update_ha_state()

-    def turn_off(self, **kwargs):
-        """ Turn the device off. """
-        self._state = False
-        self.led.off(self.group)
+
+class WhiteLimitlessLED(LimitlessLED):
+    """ Represents a White LimitlessLED light """
+
+    def __init__(self, pool, controller_id, group, name):
+        super().__init__(pool, controller_id, group, name, 'white')
+
+    def turn_on(self, **kwargs):
+        """ Turn the device on. """
+        self._state = True
+        self.pool.execute(self.controller_id, "on", self.group)
        self.update_ha_state()
@@ -0,0 +1,112 @@
+"""
+homeassistant.components.light.rfxtrx
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Support for RFXtrx lights.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/light.rfxtrx.html
+"""
+import logging
+import homeassistant.components.rfxtrx as rfxtrx
+import RFXtrx as rfxtrxmod
+
+from homeassistant.components.light import Light
+from homeassistant.util import slugify
+
+DEPENDENCIES = ['rfxtrx']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """ Setup the RFXtrx platform. """
+    lights = []
+    devices = config.get('devices', None)
+    if devices:
+        for entity_id, entity_info in devices.items():
+            if entity_id not in rfxtrx.RFX_DEVICES:
+                _LOGGER.info("Add %s rfxtrx.light", entity_info['name'])
+                rfxobject = rfxtrx.get_rfx_object(entity_info['packetid'])
+                new_light = RfxtrxLight(entity_info['name'], rfxobject, False)
+                rfxtrx.RFX_DEVICES[entity_id] = new_light
+                lights.append(new_light)
+
+    add_devices_callback(lights)
+
+    def light_update(event):
+        """ Callback for light updates from the RFXtrx gateway. """
+        if not isinstance(event.device, rfxtrxmod.LightingDevice):
+            return
+
+        # Add entity if not exist and the automatic_add is True
+        entity_id = slugify(event.device.id_string.lower())
+        if entity_id not in rfxtrx.RFX_DEVICES:
+            automatic_add = config.get('automatic_add', False)
+            if not automatic_add:
+                return
+
+            _LOGGER.info(
+                "Automatic add %s rfxtrx.light (Class: %s Sub: %s)",
+                entity_id,
+                event.device.__class__.__name__,
+                event.device.subtype
+            )
+            pkt_id = "".join("{0:02x}".format(x) for x in event.data)
+            entity_name = "%s : %s" % (entity_id, pkt_id)
+            new_light = RfxtrxLight(entity_name, event, False)
+            rfxtrx.RFX_DEVICES[entity_id] = new_light
+            add_devices_callback([new_light])
+
+        # Check if entity exists or previously added automatically
+        if entity_id in rfxtrx.RFX_DEVICES:
+            if event.values['Command'] == 'On'\
+                    or event.values['Command'] == 'Off':
+                if event.values['Command'] == 'On':
+                    rfxtrx.RFX_DEVICES[entity_id].turn_on()
+                else:
+                    rfxtrx.RFX_DEVICES[entity_id].turn_off()
+
+    # Subscribe to main rfxtrx events
+    if light_update not in rfxtrx.RECEIVED_EVT_SUBSCRIBERS:
+        rfxtrx.RECEIVED_EVT_SUBSCRIBERS.append(light_update)
+
+
+class RfxtrxLight(Light):
+    """ Provides a RFXtrx light. """
+    def __init__(self, name, event, state):
+        self._name = name
+        self._event = event
+        self._state = state
+
+    @property
+    def should_poll(self):
+        """ No polling needed for a light. """
+        return False
+
+    @property
+    def name(self):
+        """ Returns the name of the light if any. """
+        return self._name
+
+    @property
+    def is_on(self):
+        """ True if light is on. """
+        return self._state
+
+    def turn_on(self, **kwargs):
+        """ Turn the light on. """
+
+        if hasattr(self, '_event') and self._event:
+            self._event.device.send_on(rfxtrx.RFXOBJECT.transport)
+
+        self._state = True
+        self.update_ha_state()
+
+    def turn_off(self, **kwargs):
+        """ Turn the light off. """
+
+        if hasattr(self, '_event') and self._event:
+            self._event.device.send_off(rfxtrx.RFXOBJECT.transport)
+
+        self._state = False
+        self.update_ha_state()
@@ -0,0 +1,52 @@
+# Describes the format for available light services
+
+turn_on:
+  description: Turn a light on
+
+  fields:
+    entity_id:
+      description: Name(s) of entities to turn on
+      example: 'light.kitchen'
+
+    transition:
+      description: Duration in seconds it takes to get to next state
+      example: 60
+
+    rgb_color:
+      description: Color for the light in RGB-format
+      example: '[255, 100, 100]'
+
+    xy_color:
+      description: Color for the light in XY-format
+      example: '[0.52, 0.43]'
+
+    brightness:
+      description: Number between 0..255 indicating brightness
+      example: 120
+
+    profile:
+      description: Name of a light profile to use
+      example: relax
+
+    flash:
+      description: If the light should flash
+      values:
+        - short
+        - long
+
+    effect:
+      description: Light effect
+      values:
+        - colorloop
+
+turn_off:
+  description: Turn a light off
+
+  fields:
+    entity_id:
+      description: Name(s) of entities to turn off
+      example: 'light.kitchen'
+
+    transition:
+      description: Duration in seconds it takes to get to next state
+      example: 60
@@ -2,16 +2,21 @@
 homeassistant.components.light.tellstick
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Support for Tellstick lights.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/light.tellstick.html
 """
 import logging
 # pylint: disable=no-name-in-module, import-error
 from homeassistant.components.light import Light, ATTR_BRIGHTNESS
-from homeassistant.const import ATTR_FRIENDLY_NAME
+from homeassistant.const import (EVENT_HOMEASSISTANT_STOP,
+                                 ATTR_FRIENDLY_NAME)
 import tellcore.constants as tellcore_constants
-
-REQUIREMENTS = ['tellcore-py==1.0.4']
+from tellcore.library import DirectCallbackDispatcher
+REQUIREMENTS = ['tellcore-py==1.1.2']


+# pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices_callback, discovery_info=None):
    """ Find and return Tellstick lights. """

@@ -22,13 +27,32 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
            "Failed to import tellcore")
        return []

-    core = telldus.TelldusCore()
+    core = telldus.TelldusCore(callback_dispatcher=DirectCallbackDispatcher())
+
    switches_and_lights = core.devices()
    lights = []

    for switch in switches_and_lights:
        if switch.methods(tellcore_constants.TELLSTICK_DIM):
            lights.append(TellstickLight(switch))
+
+    def _device_event_callback(id_, method, data, cid):
+        """ Called from the TelldusCore library to update one device """
+        for light_device in lights:
+            if light_device.tellstick_device.id == id_:
+                # Execute the update in another thread
+                light_device.update_ha_state(True)
+                break
+
+    callback_id = core.register_device_event(_device_event_callback)
+
+    def unload_telldus_lib(event):
+        """ Un-register the callback bindings """
+        if callback_id is not None:
+            core.unregister_callback(callback_id)
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, unload_telldus_lib)
+
    add_devices_callback(lights)


@@ -40,15 +64,15 @@ class TellstickLight(Light):
                              tellcore_constants.TELLSTICK_UP |
                              tellcore_constants.TELLSTICK_DOWN)

-    def __init__(self, tellstick):
-        self.tellstick = tellstick
-        self.state_attr = {ATTR_FRIENDLY_NAME: tellstick.name}
+    def __init__(self, tellstick_device):
+        self.tellstick_device = tellstick_device
+        self.state_attr = {ATTR_FRIENDLY_NAME: tellstick_device.name}
        self._brightness = 0

    @property
    def name(self):
        """ Returns the name of the switch if any. """
-        return self.tellstick.name
+        return self.tellstick_device.name

    @property
    def is_on(self):
@@ -62,8 +86,9 @@ class TellstickLight(Light):

    def turn_off(self, **kwargs):
        """ Turns the switch off. """
-        self.tellstick.turn_off()
+        self.tellstick_device.turn_off()
        self._brightness = 0
+        self.update_ha_state()

    def turn_on(self, **kwargs):
        """ Turns the switch on. """
@@ -74,11 +99,12 @@ class TellstickLight(Light):
        else:
            self._brightness = brightness

-        self.tellstick.dim(self._brightness)
+        self.tellstick_device.dim(self._brightness)
+        self.update_ha_state()

    def update(self):
        """ Update state of the light. """
-        last_command = self.tellstick.last_sent_command(
+        last_command = self.tellstick_device.last_sent_command(
            self.last_sent_command_mask)

        if last_command == tellcore_constants.TELLSTICK_TURNON:
@@ -88,6 +114,11 @@ class TellstickLight(Light):
        elif (last_command == tellcore_constants.TELLSTICK_DIM or
              last_command == tellcore_constants.TELLSTICK_UP or
              last_command == tellcore_constants.TELLSTICK_DOWN):
-            last_sent_value = self.tellstick.last_sent_value()
+            last_sent_value = self.tellstick_device.last_sent_value()
            if last_sent_value is not None:
                self._brightness = last_sent_value
+
+    @property
+    def should_poll(self):
+        """ Tells Home Assistant not to poll this entity. """
+        return False
@@ -1,59 +1,18 @@
 """
 homeassistant.components.light.vera
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Support for Vera lights.

-Support for Vera lights. This component is useful if you wish for switches
-connected to your Vera controller to appear as lights in Home Assistant.
-All switches will be added as a light unless you exclude them in the config.
-
-Configuration:
-
-To use the Vera lights you will need to add something like the following to
-your config/configuration.yaml.
-
-light:
-    platform: vera
-    vera_controller_url: http://YOUR_VERA_IP:3480/
-    device_data:
-        12:
-            name: My awesome switch
-            exclude: true
-        13:
-            name: Another switch
-
-Variables:
-
-vera_controller_url
-*Required
-This is the base URL of your vera controller including the port number if not
-running on 80. Example: http://192.168.1.21:3480/
-
-device_data
-*Optional
-This contains an array additional device info for your Vera devices. It is not
-required and if not specified all lights configured in your Vera controller
-will be added with default values. You should use the id of your vera device
-as the key for the device within device_data.
-
-These are the variables for the device_data array:
-
-name
-*Optional
-This parameter allows you to override the name of your Vera device in the HA
-interface, if not specified the value configured for the device in your Vera
-will be used.
-
-exclude
-*Optional
-This parameter allows you to exclude the specified device from Home Assistant,
-it should be set to "true" if you want this device excluded.
-
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/light.vera.html
 """
 import logging
 from requests.exceptions import RequestException
 from homeassistant.components.switch.vera import VeraSwitch
-# pylint: disable=no-name-in-module, import-error
-import homeassistant.external.vera.vera as veraApi
+
+REQUIREMENTS = ['https://github.com/balloob/home-assistant-vera-api/archive/'
+                'a8f823066ead6c7da6fb5e7abaf16fef62e63364.zip'
+                '#python-vera==0.1']

 _LOGGER = logging.getLogger(__name__)

@@ -61,6 +20,7 @@ _LOGGER = logging.getLogger(__name__)
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices_callback, discovery_info=None):
    """ Find and return Vera lights. """
+    import pyvera as veraApi

    base_url = config.get('vera_controller_url')
    if not base_url:
@@ -2,6 +2,9 @@
 homeassistant.components.light.wink
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Support for Wink lights.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/light.wink.html
 """
 import logging

@@ -9,8 +12,9 @@ from homeassistant.components.light import ATTR_BRIGHTNESS
 from homeassistant.components.wink import WinkToggleDevice
 from homeassistant.const import CONF_ACCESS_TOKEN

-REQUIREMENTS = ['https://github.com/balloob/python-wink/archive/' +
-                'c2b700e8ca866159566ecf5e644d9c297f69f257.zip']
+REQUIREMENTS = ['https://github.com/balloob/python-wink/archive/'
+                'c2b700e8ca866159566ecf5e644d9c297f69f257.zip'
+                '#python-wink==0.1']


 def setup_platform(hass, config, add_devices_callback, discovery_info=None):
@@ -1,8 +1,10 @@
 """
 homeassistant.components.logbook
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Parses events and generates a human log.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/logbook.html
 """
 from datetime import timedelta
 from itertools import groupby
@@ -10,11 +12,12 @@ import re

 from homeassistant.core import State, DOMAIN as HA_DOMAIN
 from homeassistant.const import (
-    EVENT_STATE_CHANGED, STATE_HOME, STATE_ON, STATE_OFF,
+    EVENT_STATE_CHANGED, STATE_NOT_HOME, STATE_ON, STATE_OFF,
    EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP, HTTP_BAD_REQUEST)
+from homeassistant import util
 import homeassistant.util.dt as dt_util
-import homeassistant.components.recorder as recorder
-import homeassistant.components.sun as sun
+from homeassistant.components import recorder, sun
+

 DOMAIN = "logbook"
 DEPENDENCIES = ['recorder', 'http']
@@ -25,8 +28,29 @@ QUERY_EVENTS_BETWEEN = """
    SELECT * FROM events WHERE time_fired > ? AND time_fired < ?
 """

+EVENT_LOGBOOK_ENTRY = 'LOGBOOK_ENTRY'
+
 GROUP_BY_MINUTES = 15

+ATTR_NAME = 'name'
+ATTR_MESSAGE = 'message'
+ATTR_DOMAIN = 'domain'
+ATTR_ENTITY_ID = 'entity_id'
+
+
+def log_entry(hass, name, message, domain=None, entity_id=None):
+    """ Adds an entry to the logbook. """
+    data = {
+        ATTR_NAME: name,
+        ATTR_MESSAGE: message
+    }
+
+    if domain is not None:
+        data[ATTR_DOMAIN] = domain
+    if entity_id is not None:
+        data[ATTR_ENTITY_ID] = entity_id
+    hass.bus.fire(EVENT_LOGBOOK_ENTRY, data)
+

 def setup(hass, config):
    """ Listens for download events to download files. """
@@ -110,7 +134,10 @@ def humanify(events):
        # Process events
        for event in events_batch:
            if event.event_type == EVENT_STATE_CHANGED:
-                entity_id = event.data['entity_id']
+                entity_id = event.data.get('entity_id')
+
+                if entity_id is None:
+                    continue

                if entity_id.startswith('sensor.'):
                    last_sensor_event[entity_id] = event
@@ -137,10 +164,12 @@ def humanify(events):

                to_state = State.from_dict(event.data.get('new_state'))

-                # if last_changed == last_updated only attributes have changed
-                # we do not report on that yet.
+                # if last_changed != last_updated only attributes have changed
+                # we do not report on that yet. Also filter auto groups.
                if not to_state or \
-                   to_state.last_changed != to_state.last_updated:
+                   to_state.last_changed != to_state.last_updated or \
+                   to_state.domain == 'group' and \
+                   to_state.attributes.get('auto', False):
                    continue

                domain = to_state.domain
@@ -175,14 +204,31 @@ def humanify(events):
                    event.time_fired, "Home Assistant", action,
                    domain=HA_DOMAIN)

+            elif event.event_type == EVENT_LOGBOOK_ENTRY:
+                domain = event.data.get(ATTR_DOMAIN)
+                entity_id = event.data.get(ATTR_ENTITY_ID)
+                if domain is None and entity_id is not None:
+                    try:
+                        domain = util.split_entity_id(str(entity_id))[0]
+                    except IndexError:
+                        pass
+
+                yield Entry(
+                    event.time_fired, event.data.get(ATTR_NAME),
+                    event.data.get(ATTR_MESSAGE), domain,
+                    entity_id)
+

 def _entry_message_from_state(domain, state):
    """ Convert a state to a message for the logbook. """
    # We pass domain in so we don't have to split entity_id again
+    # pylint: disable=too-many-return-statements

    if domain == 'device_tracker':
-        return '{} home'.format(
-            'arrived' if state.state == STATE_HOME else 'left')
+        if state.state == STATE_NOT_HOME:
+            return 'is away'
+        else:
+            return 'is at {}'.format(state.state)

    elif domain == 'sun':
        if state.state == sun.STATE_ABOVE_HORIZON:
@@ -5,8 +5,10 @@ homeassistant.components.media_player
 Component to interface with various media players.
 """
 import logging
+import os

 from homeassistant.components import discovery
+from homeassistant.config import load_yaml_config_file
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.const import (
@@ -19,15 +21,18 @@ from homeassistant.const import (

 DOMAIN = 'media_player'
 DEPENDENCIES = []
-SCAN_INTERVAL = 30
+SCAN_INTERVAL = 10

 ENTITY_ID_FORMAT = DOMAIN + '.{}'

 DISCOVERY_PLATFORMS = {
    discovery.SERVICE_CAST: 'cast',
+    discovery.SERVICE_SONOS: 'sonos',
+    discovery.SERVICE_PLEX: 'plex',
 }

 SERVICE_YOUTUBE_VIDEO = 'play_youtube_video'
+SERVICE_PLAY_MEDIA = 'play_media'

 ATTR_MEDIA_VOLUME_LEVEL = 'volume_level'
 ATTR_MEDIA_VOLUME_MUTED = 'is_volume_muted'
@@ -43,6 +48,8 @@ ATTR_MEDIA_TRACK = 'media_track'
 ATTR_MEDIA_SERIES_TITLE = 'media_series_title'
 ATTR_MEDIA_SEASON = 'media_season'
 ATTR_MEDIA_EPISODE = 'media_episode'
+ATTR_MEDIA_CHANNEL = 'media_channel'
+ATTR_MEDIA_PLAYLIST = 'media_playlist'
 ATTR_APP_ID = 'app_id'
 ATTR_APP_NAME = 'app_name'
 ATTR_SUPPORTED_MEDIA_COMMANDS = 'supported_media_commands'
@@ -50,6 +57,9 @@ ATTR_SUPPORTED_MEDIA_COMMANDS = 'supported_media_commands'
 MEDIA_TYPE_MUSIC = 'music'
 MEDIA_TYPE_TVSHOW = 'tvshow'
 MEDIA_TYPE_VIDEO = 'movie'
+MEDIA_TYPE_EPISODE = 'episode'
+MEDIA_TYPE_CHANNEL = 'channel'
+MEDIA_TYPE_PLAYLIST = 'playlist'

 SUPPORT_PAUSE = 1
 SUPPORT_SEEK = 2
@@ -60,6 +70,7 @@ SUPPORT_NEXT_TRACK = 32
 SUPPORT_YOUTUBE = 64
 SUPPORT_TURN_ON = 128
 SUPPORT_TURN_OFF = 256
+SUPPORT_PLAY_MEDIA = 512

 YOUTUBE_COVER_URL_FORMAT = 'https://img.youtube.com/vi/{}/1.jpg'

@@ -73,6 +84,7 @@ SERVICE_TO_METHOD = {
    SERVICE_MEDIA_PAUSE: 'media_pause',
    SERVICE_MEDIA_NEXT_TRACK: 'media_next_track',
    SERVICE_MEDIA_PREVIOUS_TRACK: 'media_previous_track',
+    SERVICE_PLAY_MEDIA: 'play_media',
 }

 ATTR_TO_PROPERTY = [
@@ -89,6 +101,8 @@ ATTR_TO_PROPERTY = [
    ATTR_MEDIA_SERIES_TITLE,
    ATTR_MEDIA_SEASON,
    ATTR_MEDIA_EPISODE,
+    ATTR_MEDIA_CHANNEL,
+    ATTR_MEDIA_PLAYLIST,
    ATTR_APP_ID,
    ATTR_APP_NAME,
    ATTR_SUPPORTED_MEDIA_COMMANDS,
@@ -177,6 +191,16 @@ def media_previous_track(hass, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_MEDIA_PREVIOUS_TRACK, data)


+def play_media(hass, media_type, media_id, entity_id=None):
+    """ Send the media player the command for playing media. """
+    data = {"media_type": media_type, "media_id": media_id}
+
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_PLAY_MEDIA, data)
+
+
 def setup(hass, config):
    """ Track states and offer events for media_players. """
    component = EntityComponent(
@@ -185,6 +209,9 @@ def setup(hass, config):

    component.setup(config)

+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+
    def media_player_service_handler(service):
        """ Maps services to methods on MediaPlayerDevice. """
        target_players = component.extract_from_service(service)
@@ -198,7 +225,8 @@ def setup(hass, config):
                player.update_ha_state(True)

    for service in SERVICE_TO_METHOD:
-        hass.services.register(DOMAIN, service, media_player_service_handler)
+        hass.services.register(DOMAIN, service, media_player_service_handler,
+                               descriptions.get(service))

    def volume_set_service(service):
        """ Set specified volume on the media player. """
@@ -215,7 +243,8 @@ def setup(hass, config):
            if player.should_poll:
                player.update_ha_state(True)

-    hass.services.register(DOMAIN, SERVICE_VOLUME_SET, volume_set_service)
+    hass.services.register(DOMAIN, SERVICE_VOLUME_SET, volume_set_service,
+                           descriptions.get(SERVICE_VOLUME_SET))

    def volume_mute_service(service):
        """ Mute (true) or unmute (false) the media player. """
@@ -232,7 +261,8 @@ def setup(hass, config):
            if player.should_poll:
                player.update_ha_state(True)

-    hass.services.register(DOMAIN, SERVICE_VOLUME_MUTE, volume_mute_service)
+    hass.services.register(DOMAIN, SERVICE_VOLUME_MUTE, volume_mute_service,
+                           descriptions.get(SERVICE_VOLUME_MUTE))

    def media_seek_service(service):
        """ Seek to a position. """
@@ -249,7 +279,8 @@ def setup(hass, config):
            if player.should_poll:
                player.update_ha_state(True)

-    hass.services.register(DOMAIN, SERVICE_MEDIA_SEEK, media_seek_service)
+    hass.services.register(DOMAIN, SERVICE_MEDIA_SEEK, media_seek_service,
+                           descriptions.get(SERVICE_MEDIA_SEEK))

    def play_youtube_video_service(service, media_id=None):
        """ Plays specified media_id on the media player. """
@@ -265,16 +296,40 @@ def setup(hass, config):
            if player.should_poll:
                player.update_ha_state(True)

+    def play_media_service(service):
+        """ Plays specified media_id on the media player. """
+        media_type = service.data.get('media_type')
+        media_id = service.data.get('media_id')
+
+        if media_type is None:
+            return
+
+        if media_id is None:
+            return
+
+        for player in component.extract_from_service(service):
+            player.play_media(media_type, media_id)
+
+            if player.should_poll:
+                player.update_ha_state(True)
+
    hass.services.register(
        DOMAIN, "start_fireplace",
-        lambda service: play_youtube_video_service(service, "eyU3bRy2x44"))
+        lambda service: play_youtube_video_service(service, "eyU3bRy2x44"),
+        descriptions.get('start_fireplace'))

    hass.services.register(
        DOMAIN, "start_epic_sax",
-        lambda service: play_youtube_video_service(service, "kxopViU98Xo"))
+        lambda service: play_youtube_video_service(service, "kxopViU98Xo"),
+        descriptions.get('start_epic_sax'))

    hass.services.register(
-        DOMAIN, SERVICE_YOUTUBE_VIDEO, play_youtube_video_service)
+        DOMAIN, SERVICE_YOUTUBE_VIDEO, play_youtube_video_service,
+        descriptions.get(SERVICE_YOUTUBE_VIDEO))
+
+    hass.services.register(
+        DOMAIN, SERVICE_PLAY_MEDIA, play_media_service,
+        descriptions.get(SERVICE_PLAY_MEDIA))

    return True

@@ -360,6 +415,16 @@ class MediaPlayerDevice(Entity):
        """ Episode of current playing media. (TV Show only) """
        return None

+    @property
+    def media_channel(self):
+        """ Channel currently playing. """
+        return None
+
+    @property
+    def media_playlist(self):
+        """ Title of Playlist currently playing. """
+        return None
+
    @property
    def app_id(self):
        """  ID of the current running app. """
@@ -420,6 +485,10 @@ class MediaPlayerDevice(Entity):
        """ Plays a YouTube media. """
        raise NotImplementedError()

+    def play_media(self, media_type, media_id):
+        """ Plays a piece of media. """
+        raise NotImplementedError()
+
    # No need to overwrite these.
    @property
    def support_pause(self):
@@ -456,6 +525,11 @@ class MediaPlayerDevice(Entity):
        """ Boolean if YouTube is supported. """
        return bool(self.supported_media_commands & SUPPORT_YOUTUBE)

+    @property
+    def support_play_media(self):
+        """ Boolean if play media command supported. """
+        return bool(self.supported_media_commands & SUPPORT_PLAY_MEDIA)
+
    def volume_up(self):
        """ volume_up media player. """
        if self.volume_level < 1:
@@ -483,7 +557,7 @@ class MediaPlayerDevice(Entity):
        else:
            state_attr = {
                attr: getattr(self, attr) for attr
-                in ATTR_TO_PROPERTY if getattr(self, attr)
+                in ATTR_TO_PROPERTY if getattr(self, attr) is not None
            }

            if self.media_image_url:
@@ -1,10 +1,10 @@
 """
 homeassistant.components.media_player.chromecast
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provides functionality to interact with Cast devices on the network.

-WARNING: This platform is currently not working due to a changed Cast API
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.cast.html
 """
 import logging

@@ -76,6 +76,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class CastDevice(MediaPlayerDevice):
    """ Represents a Cast device on the network. """

+    # pylint: disable=abstract-method
    # pylint: disable=too-many-public-methods

    def __init__(self, host):
@@ -1,9 +1,7 @@
 """
 homeassistant.components.media_player.demo
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Demo implementation of the media player.
-
 """
 from homeassistant.const import (
    STATE_PLAYING, STATE_PAUSED, STATE_OFF)
@@ -0,0 +1,172 @@
+"""
+homeassistant.components.media_player.denon
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides an interface to Denon Network Receivers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.denon.html
+"""
+import telnetlib
+import logging
+
+from homeassistant.components.media_player import (
+    MediaPlayerDevice, SUPPORT_PAUSE, SUPPORT_VOLUME_SET,
+    SUPPORT_VOLUME_MUTE, SUPPORT_PREVIOUS_TRACK, SUPPORT_NEXT_TRACK,
+    SUPPORT_TURN_ON, SUPPORT_TURN_OFF,
+    DOMAIN)
+from homeassistant.const import (
+    CONF_HOST, STATE_OFF, STATE_ON, STATE_UNKNOWN)
+
+_LOGGER = logging.getLogger(__name__)
+
+SUPPORT_DENON = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
+    SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | \
+    SUPPORT_TURN_ON | SUPPORT_TURN_OFF
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Sets up the Denon platform. """
+    if not config.get(CONF_HOST):
+        _LOGGER.error(
+            "Missing required configuration items in %s: %s",
+            DOMAIN,
+            CONF_HOST)
+        return False
+
+    denon = DenonDevice(
+        config.get("name", "Music station"),
+        config.get("host")
+    )
+    if denon.update():
+        add_devices([denon])
+        return True
+    else:
+        return False
+
+
+class DenonDevice(MediaPlayerDevice):
+    """ Represents a Denon device. """
+
+    # pylint: disable=too-many-public-methods
+
+    def __init__(self, name, host):
+        self._name = name
+        self._host = host
+        self._pwstate = "PWSTANDBY"
+        self._volume = 0
+        self._muted = False
+        self._mediasource = ""
+
+    @classmethod
+    def telnet_request(cls, telnet, command):
+        """ Executes `command` and returns the response. """
+        telnet.write(command.encode("ASCII") + b"\r")
+        return telnet.read_until(b"\r", timeout=0.2).decode("ASCII").strip()
+
+    def telnet_command(self, command):
+        """ Establishes a telnet connection and sends `command`. """
+        telnet = telnetlib.Telnet(self._host)
+        telnet.write(command.encode("ASCII") + b"\r")
+        telnet.read_very_eager()  # skip response
+        telnet.close()
+
+    def update(self):
+        try:
+            telnet = telnetlib.Telnet(self._host)
+        except ConnectionRefusedError:
+            return False
+
+        self._pwstate = self.telnet_request(telnet, "PW?")
+        # PW? sends also SISTATUS, which is not interesting
+        telnet.read_until(b"\r", timeout=0.2)
+
+        volume_str = self.telnet_request(telnet, "MV?")[len("MV"):]
+        self._volume = int(volume_str) / 60
+        self._muted = (self.telnet_request(telnet, "MU?") == "MUON")
+        self._mediasource = self.telnet_request(telnet, "SI?")[len("SI"):]
+
+        telnet.close()
+        return True
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self._name
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        if self._pwstate == "PWSTANDBY":
+            return STATE_OFF
+        if self._pwstate == "PWON":
+            return STATE_ON
+
+        return STATE_UNKNOWN
+
+    @property
+    def volume_level(self):
+        """ Volume level of the media player (0..1). """
+        return self._volume
+
+    @property
+    def is_volume_muted(self):
+        """ Boolean if volume is currently muted. """
+        return self._muted
+
+    @property
+    def media_title(self):
+        """ Current media source. """
+        return self._mediasource
+
+    @property
+    def supported_media_commands(self):
+        """ Flags of media commands that are supported. """
+        return SUPPORT_DENON
+
+    def turn_off(self):
+        """ turn_off media player. """
+        self.telnet_command("PWSTANDBY")
+
+    def volume_up(self):
+        """ volume_up media player. """
+        self.telnet_command("MVUP")
+
+    def volume_down(self):
+        """ volume_down media player. """
+        self.telnet_command("MVDOWN")
+
+    def set_volume_level(self, volume):
+        """ set volume level, range 0..1. """
+        # 60dB max
+        self.telnet_command("MV" + str(round(volume * 60)).zfill(2))
+
+    def mute_volume(self, mute):
+        """ mute (true) or unmute (false) media player. """
+        self.telnet_command("MU" + ("ON" if mute else "OFF"))
+
+    def media_play_pause(self):
+        """ media_play_pause media player. """
+        raise NotImplementedError()
+
+    def media_play(self):
+        """ media_play media player. """
+        self.telnet_command("NS9A")
+
+    def media_pause(self):
+        """ media_pause media player. """
+        self.telnet_command("NS9B")
+
+    def media_next_track(self):
+        """ Send next track command. """
+        self.telnet_command("NS9D")
+
+    def media_previous_track(self):
+        self.telnet_command("NS9E")
+
+    def media_seek(self, position):
+        raise NotImplementedError()
+
+    def turn_on(self):
+        """ turn the media player on. """
+        self.telnet_command("PWON")
@@ -0,0 +1,190 @@
+"""
+homeassistant.components.media_player.firetv
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides functionality to interact with FireTV devices.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.firetv.html
+"""
+import logging
+import requests
+
+from homeassistant.const import (
+    STATE_PLAYING, STATE_PAUSED, STATE_IDLE, STATE_OFF,
+    STATE_UNKNOWN, STATE_STANDBY)
+
+from homeassistant.components.media_player import (
+    MediaPlayerDevice,
+    SUPPORT_PAUSE, SUPPORT_VOLUME_SET,
+    SUPPORT_TURN_ON, SUPPORT_TURN_OFF,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_NEXT_TRACK)
+
+SUPPORT_FIRETV = SUPPORT_PAUSE | \
+    SUPPORT_TURN_ON | SUPPORT_TURN_OFF | SUPPORT_PREVIOUS_TRACK | \
+    SUPPORT_NEXT_TRACK | SUPPORT_VOLUME_SET
+
+DOMAIN = 'firetv'
+DEVICE_LIST_URL = 'http://{0}/devices/list'
+DEVICE_STATE_URL = 'http://{0}/devices/state/{1}'
+DEVICE_ACTION_URL = 'http://{0}/devices/action/{1}/{2}'
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Sets up the FireTV platform. """
+    host = config.get('host', 'localhost:5556')
+    device_id = config.get('device', 'default')
+    try:
+        response = requests.get(DEVICE_LIST_URL.format(host)).json()
+        if device_id in response['devices'].keys():
+            add_devices([
+                FireTVDevice(
+                    host,
+                    device_id,
+                    config.get('name', 'Amazon Fire TV')
+                )
+            ])
+            _LOGGER.info(
+                'Device %s accessible and ready for control', device_id)
+        else:
+            _LOGGER.warn(
+                'Device %s is not registered with firetv-server', device_id)
+    except requests.exceptions.RequestException:
+        _LOGGER.error('Could not connect to firetv-server at %s', host)
+
+
+class FireTV(object):
+    """ firetv-server client.
+
+    Should a native Python 3 ADB module become available, python-firetv can
+    support Python 3, it can be added as a dependency, and this class can be
+    dispensed of.
+
+    For now, it acts as a client to the firetv-server HTTP server (which must
+    be running via Python 2).
+    """
+
+    def __init__(self, host, device_id):
+        self.host = host
+        self.device_id = device_id
+
+    @property
+    def state(self):
+        """ Get the device state. An exception means UNKNOWN state. """
+        try:
+            response = requests.get(
+                DEVICE_STATE_URL.format(
+                    self.host,
+                    self.device_id
+                    )
+                ).json()
+            return response.get('state', STATE_UNKNOWN)
+        except requests.exceptions.RequestException:
+            _LOGGER.error(
+                'Could not retrieve device state for %s', self.device_id)
+            return STATE_UNKNOWN
+
+    def action(self, action_id):
+        """ Perform an action on the device. """
+        try:
+            requests.get(
+                DEVICE_ACTION_URL.format(
+                    self.host,
+                    self.device_id,
+                    action_id
+                    )
+                )
+        except requests.exceptions.RequestException:
+            _LOGGER.error(
+                'Action request for %s was not accepted for device %s',
+                action_id, self.device_id)
+
+
+class FireTVDevice(MediaPlayerDevice):
+    """ Represents an Amazon Fire TV device on the network. """
+
+    def __init__(self, host, device, name):
+        self._firetv = FireTV(host, device)
+        self._name = name
+        self._state = STATE_UNKNOWN
+
+    @property
+    def name(self):
+        """ Get the device name. """
+        return self._name
+
+    @property
+    def should_poll(self):
+        """ Device should be polled. """
+        return True
+
+    @property
+    def supported_media_commands(self):
+        """ Flags of media commands that are supported. """
+        return SUPPORT_FIRETV
+
+    @property
+    def state(self):
+        """ State of the player. """
+        return self._state
+
+    def update(self):
+        """ Update device state. """
+        self._state = {
+            'idle': STATE_IDLE,
+            'off': STATE_OFF,
+            'play': STATE_PLAYING,
+            'pause': STATE_PAUSED,
+            'standby': STATE_STANDBY,
+            'disconnected': STATE_UNKNOWN,
+        }.get(self._firetv.state, STATE_UNKNOWN)
+
+    def turn_on(self):
+        """ Turns on the device. """
+        self._firetv.action('turn_on')
+
+    def turn_off(self):
+        """ Turns off the device. """
+        self._firetv.action('turn_off')
+
+    def media_play(self):
+        """ Send play command. """
+        self._firetv.action('media_play')
+
+    def media_pause(self):
+        """ Send pause command. """
+        self._firetv.action('media_pause')
+
+    def media_play_pause(self):
+        """ Send play/pause command. """
+        self._firetv.action('media_play_pause')
+
+    def volume_up(self):
+        """ Send volume up command. """
+        self._firetv.action('volume_up')
+
+    def volume_down(self):
+        """ Send volume down command. """
+        self._firetv.action('volume_down')
+
+    def media_previous_track(self):
+        """ Send previous track command (results in rewind). """
+        self._firetv.action('media_previous')
+
+    def media_next_track(self):
+        """ Send next track command (results in fast-forward). """
+        self._firetv.action('media_next')
+
+    def media_seek(self, position):
+        raise NotImplementedError()
+
+    def mute_volume(self, mute):
+        raise NotImplementedError()
+
+    def play_youtube(self, media_id):
+        raise NotImplementedError()
+
+    def set_volume_level(self, volume):
+        raise NotImplementedError()
@@ -0,0 +1,443 @@
+"""
+homeassistant.components.media_player.itunes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides an interface to iTunes API.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.itunes.html
+"""
+import logging
+
+from homeassistant.components.media_player import (
+    MediaPlayerDevice, MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, SUPPORT_PAUSE,
+    SUPPORT_SEEK, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_MUTE,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_NEXT_TRACK, SUPPORT_TURN_ON,
+    SUPPORT_TURN_OFF, SUPPORT_PLAY_MEDIA,
+    ATTR_ENTITY_PICTURE, ATTR_SUPPORTED_MEDIA_COMMANDS)
+from homeassistant.const import (
+    STATE_IDLE, STATE_PLAYING, STATE_PAUSED, STATE_OFF, STATE_ON)
+
+import requests
+
+_LOGGER = logging.getLogger(__name__)
+
+SUPPORT_ITUNES = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
+    SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | SUPPORT_SEEK | \
+    SUPPORT_PLAY_MEDIA
+
+SUPPORT_AIRPLAY = SUPPORT_VOLUME_SET | SUPPORT_TURN_ON | SUPPORT_TURN_OFF
+
+DOMAIN = 'itunes'
+
+
+class Itunes(object):
+    """ itunes-api client. """
+
+    def __init__(self, host, port):
+        self.host = host
+        self.port = port
+
+    @property
+    def _base_url(self):
+        """ Returns the base url for endpoints. """
+        return self.host + ":" + str(self.port)
+
+    def _request(self, method, path, params=None):
+        """ Makes the actual request and returns the parsed response. """
+        url = self._base_url + path
+
+        try:
+            if method == 'GET':
+                response = requests.get(url)
+            elif method == "POST":
+                response = requests.put(url, params)
+            elif method == "PUT":
+                response = requests.put(url, params)
+            elif method == "DELETE":
+                response = requests.delete(url)
+
+            return response.json()
+        except requests.exceptions.HTTPError:
+            return {'player_state': 'error'}
+        except requests.exceptions.RequestException:
+            return {'player_state': 'offline'}
+
+    def _command(self, named_command):
+        """ Makes a request for a controlling command. """
+        return self._request('PUT', '/' + named_command)
+
+    def now_playing(self):
+        """ Returns the current state. """
+        return self._request('GET', '/now_playing')
+
+    def set_volume(self, level):
+        """ Sets the volume and returns the current state, level 0-100. """
+        return self._request('PUT', '/volume', {'level': level})
+
+    def set_muted(self, muted):
+        """ Mutes and returns the current state, muted True or False. """
+        return self._request('PUT', '/mute', {'muted': muted})
+
+    def play(self):
+        """ Sets playback to play and returns the current state. """
+        return self._command('play')
+
+    def pause(self):
+        """ Sets playback to paused and returns the current state. """
+        return self._command('pause')
+
+    def next(self):
+        """ Skips to the next track and returns the current state. """
+        return self._command('next')
+
+    def previous(self):
+        """ Skips back and returns the current state. """
+        return self._command('previous')
+
+    def play_playlist(self, playlist_id_or_name):
+        """ Sets a playlist to be current and returns the current state. """
+        response = self._request('GET', '/playlists')
+        playlists = response.get('playlists', [])
+
+        found_playlists = \
+            [playlist for playlist in playlists if
+             (playlist_id_or_name in [playlist["name"], playlist["id"]])]
+
+        if len(found_playlists) > 0:
+            playlist = found_playlists[0]
+            path = '/playlists/' + playlist['id'] + '/play'
+            return self._request('PUT', path)
+
+    def artwork_url(self):
+        """ Returns a URL of the current track's album art. """
+        return self._base_url + '/artwork'
+
+    def airplay_devices(self):
+        """ Returns a list of AirPlay devices. """
+        return self._request('GET', '/airplay_devices')
+
+    def airplay_device(self, device_id):
+        """ Returns an AirPlay device. """
+        return self._request('GET', '/airplay_devices/' + device_id)
+
+    def toggle_airplay_device(self, device_id, toggle):
+        """ Toggles airplay device on or off, id, toggle True or False. """
+        command = 'on' if toggle else 'off'
+        path = '/airplay_devices/' + device_id + '/' + command
+        return self._request('PUT', path)
+
+    def set_volume_airplay_device(self, device_id, level):
+        """ Sets volume, returns current state of device, id,level 0-100. """
+        path = '/airplay_devices/' + device_id + '/volume'
+        return self._request('PUT', path, {'level': level})
+
+
+# pylint: disable=unused-argument, abstract-method
+# pylint: disable=too-many-instance-attributes
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Sets up the itunes platform. """
+
+    add_devices([
+        ItunesDevice(
+            config.get('name', 'iTunes'),
+            config.get('host'),
+            config.get('port'),
+            add_devices
+        )
+    ])
+
+
+class ItunesDevice(MediaPlayerDevice):
+    """ Represents a iTunes-API instance. """
+
+    # pylint: disable=too-many-public-methods
+    def __init__(self, name, host, port, add_devices):
+        self._name = name
+        self._host = host
+        self._port = port
+        self._add_devices = add_devices
+
+        self.client = Itunes(self._host, self._port)
+
+        self.current_volume = None
+        self.muted = None
+        self.current_title = None
+        self.current_album = None
+        self.current_artist = None
+        self.current_playlist = None
+        self.content_id = None
+
+        self.player_state = None
+
+        self.airplay_devices = {}
+
+        self.update()
+
+    def update_state(self, state_hash):
+        """ Update all the state properties with the passed in dictionary. """
+        self.player_state = state_hash.get('player_state', None)
+
+        self.current_volume = state_hash.get('volume', 0)
+        self.muted = state_hash.get('muted', None)
+        self.current_title = state_hash.get('name', None)
+        self.current_album = state_hash.get('album', None)
+        self.current_artist = state_hash.get('artist', None)
+        self.current_playlist = state_hash.get('playlist', None)
+        self.content_id = state_hash.get('id', None)
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self._name
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+
+        if self.player_state == 'offline' or self.player_state is None:
+            return 'offline'
+
+        if self.player_state == 'error':
+            return 'error'
+
+        if self.player_state == 'stopped':
+            return STATE_IDLE
+
+        if self.player_state == 'paused':
+            return STATE_PAUSED
+        else:
+            return STATE_PLAYING
+
+    def update(self):
+        """ Retrieve latest state. """
+        now_playing = self.client.now_playing()
+        self.update_state(now_playing)
+
+        found_devices = self.client.airplay_devices()
+        found_devices = found_devices.get('airplay_devices', [])
+
+        new_devices = []
+
+        for device_data in found_devices:
+            device_id = device_data.get('id')
+
+            if self.airplay_devices.get(device_id):
+                # update it
+                airplay_device = self.airplay_devices.get(device_id)
+                airplay_device.update_state(device_data)
+            else:
+                # add it
+                airplay_device = AirPlayDevice(device_id, self.client)
+                airplay_device.update_state(device_data)
+                self.airplay_devices[device_id] = airplay_device
+                new_devices.append(airplay_device)
+
+        if new_devices:
+            self._add_devices(new_devices)
+
+    @property
+    def is_volume_muted(self):
+        """ Boolean if volume is currently muted. """
+        return self.muted
+
+    @property
+    def volume_level(self):
+        """ Volume level of the media player (0..1). """
+        return self.current_volume/100.0
+
+    @property
+    def media_content_id(self):
+        """ Content ID of current playing media. """
+        return self.content_id
+
+    @property
+    def media_content_type(self):
+        """ Content type of current playing media. """
+        return MEDIA_TYPE_MUSIC
+
+    @property
+    def media_image_url(self):
+        """ Image url of current playing media. """
+
+        if self.player_state in (STATE_PLAYING, STATE_IDLE, STATE_PAUSED) and \
+           self.current_title is not None:
+            return self.client.artwork_url()
+        else:
+            return 'https://cloud.githubusercontent.com/assets/260/9829355' \
+                '/33fab972-58cf-11e5-8ea2-2ca74bdaae40.png'
+
+    @property
+    def media_title(self):
+        """ Title of current playing media. """
+        return self.current_title
+
+    @property
+    def media_artist(self):
+        """ Artist of current playing media. (Music track only) """
+        return self.current_artist
+
+    @property
+    def media_album_name(self):
+        """ Album of current playing media. (Music track only) """
+        return self.current_album
+
+    @property
+    def media_playlist(self):
+        """ Title of the currently playing playlist. """
+        return self.current_playlist
+
+    @property
+    def supported_media_commands(self):
+        """ Flags of media commands that are supported. """
+        return SUPPORT_ITUNES
+
+    def set_volume_level(self, volume):
+        """ set volume level, range 0..1. """
+        response = self.client.set_volume(int(volume * 100))
+        self.update_state(response)
+
+    def mute_volume(self, mute):
+        """ mute (true) or unmute (false) media player. """
+        response = self.client.set_muted(mute)
+        self.update_state(response)
+
+    def media_play(self):
+        """ media_play media player. """
+        response = self.client.play()
+        self.update_state(response)
+
+    def media_pause(self):
+        """ media_pause media player. """
+        response = self.client.pause()
+        self.update_state(response)
+
+    def media_next_track(self):
+        """ media_next media player. """
+        response = self.client.next()
+        self.update_state(response)
+
+    def media_previous_track(self):
+        """ media_previous media player. """
+        response = self.client.previous()
+        self.update_state(response)
+
+    def play_media(self, media_type, media_id):
+        """ play_media media player. """
+        if media_type == MEDIA_TYPE_PLAYLIST:
+            response = self.client.play_playlist(media_id)
+            self.update_state(response)
+
+
+class AirPlayDevice(MediaPlayerDevice):
+    """ Represents an AirPlay device via an iTunes-API instance. """
+
+    # pylint: disable=too-many-public-methods
+
+    def __init__(self, device_id, client):
+        self._id = device_id
+
+        self.client = client
+
+        self.device_name = "AirPlay"
+        self.kind = None
+        self.active = False
+        self.selected = False
+        self.volume = 0
+        self.supports_audio = False
+        self.supports_video = False
+        self.player_state = None
+
+    def update_state(self, state_hash):
+        """ Update all the state properties with the passed in dictionary. """
+
+        if 'player_state' in state_hash:
+            self.player_state = state_hash.get('player_state', None)
+
+        if 'name' in state_hash:
+            name = state_hash.get('name', '')
+            self.device_name = (name + ' AirTunes Speaker').strip()
+
+        if 'kind' in state_hash:
+            self.kind = state_hash.get('kind', None)
+
+        if 'active' in state_hash:
+            self.active = state_hash.get('active', None)
+
+        if 'selected' in state_hash:
+            self.selected = state_hash.get('selected', None)
+
+        if 'sound_volume' in state_hash:
+            self.volume = state_hash.get('sound_volume', 0)
+
+        if 'supports_audio' in state_hash:
+            self.supports_audio = state_hash.get('supports_audio', None)
+
+        if 'supports_video' in state_hash:
+            self.supports_video = state_hash.get('supports_video', None)
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self.device_name
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+
+        if self.selected is True:
+            return STATE_ON
+        else:
+            return STATE_OFF
+
+    def update(self):
+        """ Retrieve latest state. """
+
+    @property
+    def volume_level(self):
+        return float(self.volume)/100.0
+
+    @property
+    def media_content_type(self):
+        return MEDIA_TYPE_MUSIC
+
+    @property
+    def supported_media_commands(self):
+        """ Flags of media commands that are supported. """
+        return SUPPORT_AIRPLAY
+
+    @property
+    def device_state_attributes(self):
+        """ Return the state attributes. """
+        state_attr = {}
+        state_attr[ATTR_SUPPORTED_MEDIA_COMMANDS] = SUPPORT_AIRPLAY
+
+        if self.state == STATE_OFF:
+            state_attr[ATTR_ENTITY_PICTURE] = \
+                ('https://cloud.githubusercontent.com/assets/260/9833073'
+                 '/6eb5c906-5958-11e5-9b4a-472cdf36be16.png')
+        else:
+            state_attr[ATTR_ENTITY_PICTURE] = \
+                ('https://cloud.githubusercontent.com/assets/260/9833072'
+                 '/6eb13cce-5958-11e5-996f-e2aaefbc9a24.png')
+
+        return state_attr
+
+    def set_volume_level(self, volume):
+        """ set volume level, range 0..1. """
+        volume = int(volume * 100)
+        response = self.client.set_volume_airplay_device(self._id, volume)
+        self.update_state(response)
+
+    def turn_on(self):
+        """ Select AirPlay. """
+        self.update_state({"selected": True})
+        self.update_ha_state()
+        response = self.client.toggle_airplay_device(self._id, True)
+        self.update_state(response)
+
+    def turn_off(self):
+        """ Deselect AirPlay. """
+        self.update_state({"selected": False})
+        self.update_ha_state()
+        response = self.client.toggle_airplay_device(self._id, False)
+        self.update_state(response)
@@ -3,35 +3,8 @@ homeassistant.components.media_player.kodi
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Provides an interface to the XBMC/Kodi JSON-RPC API

-Configuration:
-
-To use the Kodi you will need to add something like the following to
-your config/configuration.yaml.
-
-media_player:
-  platform: kodi
-  name: Kodi
-  url: http://192.168.0.123/jsonrpc
-  user: kodi
-  password: my_secure_password
-
-Variables:
-
-name
-*Optional
-The name of the device.
-
-url
-*Required
-The URL of the XBMC/Kodi JSON-RPC API. Example: http://192.168.0.123/jsonrpc
-
-user
-*Optional
-The XBMC/Kodi HTTP username.
-
-password
-*Optional
-The XBMC/Kodi HTTP password.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.kodi.html
 """
 import urllib
 import logging
@@ -74,7 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):


 def _get_image_url(kodi_url):
-    """ Helper function that parses the thumbnail URLs used by Kodi """
+    """ Helper function that parses the thumbnail URLs used by Kodi. """
    url_components = urllib.parse.urlparse(kodi_url)

    if url_components.scheme == 'image':
@@ -107,6 +80,7 @@ class KodiDevice(MediaPlayerDevice):
        try:
            return self._server.Player.GetActivePlayers()
        except jsonrpc_requests.jsonrpc.TransportError:
+            _LOGGER.exception('Unable to fetch kodi data')
            return None

    @property
@@ -166,7 +140,7 @@ class KodiDevice(MediaPlayerDevice):
    def media_content_id(self):
        """ Content ID of current playing media. """
        if self._item is not None:
-            return self._item['uniqueid']
+            return self._item.get('uniqueid', None)

    @property
    def media_content_type(self):
@@ -235,7 +209,7 @@ class KodiDevice(MediaPlayerDevice):
        self.update_ha_state()

    def _set_play_state(self, state):
-        """ Helper method for play/pause/toggle """
+        """ Helper method for play/pause/toggle. """
        players = self._get_players()

        if len(players) != 0:
@@ -256,7 +230,7 @@ class KodiDevice(MediaPlayerDevice):
        self._set_play_state(False)

    def _goto(self, direction):
-        """ Helper method used for previous/next track """
+        """ Helper method used for previous/next track. """
        players = self._get_players()

        if len(players) != 0:
@@ -1,38 +1,10 @@
 """
 homeassistant.components.media_player.mpd
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provides functionality to interact with a Music Player Daemon.

-Configuration:
-
-To use MPD you will need to add something like the following to your
-config/configuration.yaml
-
-media_player:
-  platform: mpd
-  server: 127.0.0.1
-  port: 6600
-  location: bedroom
-  password: superSecretPassword123
-
-Variables:
-
-server
-*Required
-IP address of the Music Player Daemon. Example: 192.168.1.32
-
-port
-*Optional
-Port of the Music Player Daemon, defaults to 6600. Example: 6600
-
-location
-*Optional
-Location of your Music Player Daemon.
-
-password
-*Optional
-Password for your Music Player Daemon.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.mpd.html
 """
 import logging
 import socket
@@ -0,0 +1,318 @@
+"""
+homeassistant.components.media_player.plex
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides an interface to the Plex API.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.plex.html
+"""
+import os
+import json
+import logging
+from datetime import timedelta
+from urllib.parse import urlparse
+
+from homeassistant.loader import get_component
+import homeassistant.util as util
+from homeassistant.components.media_player import (
+    MediaPlayerDevice, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_NEXT_TRACK, MEDIA_TYPE_TVSHOW, MEDIA_TYPE_VIDEO)
+from homeassistant.const import (
+    DEVICE_DEFAULT_NAME, STATE_IDLE, STATE_PLAYING,
+    STATE_PAUSED, STATE_OFF, STATE_UNKNOWN)
+
+REQUIREMENTS = ['plexapi==1.1.0']
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
+MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)
+
+PLEX_CONFIG_FILE = 'plex.conf'
+
+# Map ip to request id for configuring
+_CONFIGURING = {}
+_LOGGER = logging.getLogger(__name__)
+
+SUPPORT_PLEX = SUPPORT_PAUSE | SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK
+
+
+def config_from_file(filename, config=None):
+    ''' Small configuration file management function'''
+    if config:
+        # We're writing configuration
+        try:
+            with open(filename, 'w') as fdesc:
+                fdesc.write(json.dumps(config))
+        except IOError as error:
+            _LOGGER.error('Saving config file failed: %s', error)
+            return False
+        return True
+    else:
+        # We're reading config
+        if os.path.isfile(filename):
+            try:
+                with open(filename, 'r') as fdesc:
+                    return json.loads(fdesc.read())
+            except IOError as error:
+                _LOGGER.error('Reading config file failed: %s', error)
+                # This won't work yet
+                return False
+        else:
+            return {}
+
+
+# pylint: disable=abstract-method, unused-argument
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """ Sets up the plex platform. """
+
+    config = config_from_file(hass.config.path(PLEX_CONFIG_FILE))
+    if len(config):
+        # Setup a configured PlexServer
+        host, token = config.popitem()
+        token = token['token']
+    # Via discovery
+    elif discovery_info is not None:
+        # Parse discovery data
+        host = urlparse(discovery_info[1]).netloc
+        _LOGGER.info('Discovered PLEX server: %s', host)
+
+        if host in _CONFIGURING:
+            return
+        token = None
+    else:
+        return
+
+    setup_plexserver(host, token, hass, add_devices_callback)
+
+
+# pylint: disable=too-many-branches
+def setup_plexserver(host, token, hass, add_devices_callback):
+    ''' Setup a plexserver based on host parameter'''
+    import plexapi.server
+    import plexapi.exceptions
+
+    try:
+        plexserver = plexapi.server.PlexServer('http://%s' % host, token)
+    except (plexapi.exceptions.BadRequest,
+            plexapi.exceptions.Unauthorized,
+            plexapi.exceptions.NotFound) as error:
+        _LOGGER.info(error)
+        # No token or wrong token
+        request_configuration(host, hass, add_devices_callback)
+        return
+
+    # If we came here and configuring this host, mark as done
+    if host in _CONFIGURING:
+        request_id = _CONFIGURING.pop(host)
+        configurator = get_component('configurator')
+        configurator.request_done(request_id)
+        _LOGGER.info('Discovery configuration done!')
+
+    # Save config
+    if not config_from_file(
+            hass.config.path(PLEX_CONFIG_FILE),
+            {host: {'token': token}}):
+        _LOGGER.error('failed to save config file')
+
+    _LOGGER.info('Connected to: htts://%s', host)
+
+    plex_clients = {}
+    plex_sessions = {}
+
+    @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS)
+    def update_devices():
+        """ Updates the devices objects. """
+        try:
+            devices = plexserver.clients()
+        except plexapi.exceptions.BadRequest:
+            _LOGGER.exception("Error listing plex devices")
+            return
+
+        new_plex_clients = []
+        for device in devices:
+            # For now, let's allow all deviceClass types
+            if device.deviceClass in ['badClient']:
+                continue
+
+            if device.machineIdentifier not in plex_clients:
+                new_client = PlexClient(device, plex_sessions, update_devices,
+                                        update_sessions)
+                plex_clients[device.machineIdentifier] = new_client
+                new_plex_clients.append(new_client)
+            else:
+                plex_clients[device.machineIdentifier].set_device(device)
+
+        if new_plex_clients:
+            add_devices_callback(new_plex_clients)
+
+    @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS)
+    def update_sessions():
+        """ Updates the sessions objects. """
+        try:
+            sessions = plexserver.sessions()
+        except plexapi.exceptions.BadRequest:
+            _LOGGER.exception("Error listing plex sessions")
+            return
+
+        plex_sessions.clear()
+        for session in sessions:
+            plex_sessions[session.player.machineIdentifier] = session
+
+    update_devices()
+    update_sessions()
+
+
+def request_configuration(host, hass, add_devices_callback):
+    """ Request configuration steps from the user. """
+    configurator = get_component('configurator')
+
+    # We got an error if this method is called while we are configuring
+    if host in _CONFIGURING:
+        configurator.notify_errors(
+            _CONFIGURING[host], "Failed to register, please try again.")
+
+        return
+
+    def plex_configuration_callback(data):
+        """ Actions to do when our configuration callback is called. """
+        setup_plexserver(host, data.get('token'), hass, add_devices_callback)
+
+    _CONFIGURING[host] = configurator.request_config(
+        hass, "Plex Media Server", plex_configuration_callback,
+        description=('Enter the X-Plex-Token'),
+        description_image="/static/images/config_plex_mediaserver.png",
+        submit_caption="Confirm",
+        fields=[{'id': 'token', 'name': 'X-Plex-Token', 'type': ''}]
+    )
+
+
+class PlexClient(MediaPlayerDevice):
+    """ Represents a Plex device. """
+
+    # pylint: disable=too-many-public-methods, attribute-defined-outside-init
+    def __init__(self, device, plex_sessions, update_devices, update_sessions):
+        self.plex_sessions = plex_sessions
+        self.update_devices = update_devices
+        self.update_sessions = update_sessions
+        self.set_device(device)
+
+    def set_device(self, device):
+        """ Sets the device property. """
+        self.device = device
+
+    @property
+    def unique_id(self):
+        """ Returns the id of this plex client """
+        return "{}.{}".format(
+            self.__class__, self.device.machineIdentifier or self.device.name)
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self.device.name or DEVICE_DEFAULT_NAME
+
+    @property
+    def session(self):
+        """ Returns the session, if any. """
+        if self.device.machineIdentifier not in self.plex_sessions:
+            return None
+
+        return self.plex_sessions[self.device.machineIdentifier]
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        if self.session:
+            state = self.session.player.state
+            if state == 'playing':
+                return STATE_PLAYING
+            elif state == 'paused':
+                return STATE_PAUSED
+        # This is nasty. Need to find a way to determine alive
+        elif self.device:
+            return STATE_IDLE
+        else:
+            return STATE_OFF
+
+        return STATE_UNKNOWN
+
+    def update(self):
+        self.update_devices(no_throttle=True)
+        self.update_sessions(no_throttle=True)
+
+    @property
+    def media_content_id(self):
+        """ Content ID of current playing media. """
+        if self.session is not None:
+            return self.session.ratingKey
+
+    @property
+    def media_content_type(self):
+        """ Content type of current playing media. """
+        if self.session is None:
+            return None
+        media_type = self.session.type
+        if media_type == 'episode':
+            return MEDIA_TYPE_TVSHOW
+        elif media_type == 'movie':
+            return MEDIA_TYPE_VIDEO
+        return None
+
+    @property
+    def media_duration(self):
+        """ Duration of current playing media in seconds. """
+        if self.session is not None:
+            return self.session.duration
+
+    @property
+    def media_image_url(self):
+        """ Image url of current playing media. """
+        if self.session is not None:
+            return self.session.thumbUrl
+
+    @property
+    def media_title(self):
+        """ Title of current playing media. """
+        # find a string we can use as a title
+        if self.session is not None:
+            return self.session.title
+
+    @property
+    def media_season(self):
+        """ Season of curent playing media (TV Show only). """
+        from plexapi.video import Show
+        if isinstance(self.session, Show):
+            return self.session.seasons()[0].index
+
+    @property
+    def media_series_title(self):
+        """ Series title of current playing media (TV Show only). """
+        from plexapi.video import Show
+        if isinstance(self.session, Show):
+            return self.session.grandparentTitle
+
+    @property
+    def media_episode(self):
+        """ Episode of current playing media (TV Show only). """
+        from plexapi.video import Show
+        if isinstance(self.session, Show):
+            return self.session.index
+
+    @property
+    def supported_media_commands(self):
+        """ Flags of media commands that are supported. """
+        return SUPPORT_PLEX
+
+    def media_play(self):
+        """ media_play media player. """
+        self.device.play()
+
+    def media_pause(self):
+        """ media_pause media player. """
+        self.device.pause()
+
+    def media_next_track(self):
+        """ Send next track command. """
+        self.device.skipNext()
+
+    def media_previous_track(self):
+        """ Send previous track command. """
+        self.device.skipPrevious()
@@ -0,0 +1,199 @@
+"""
+homeassistant.components.media_player.sonos
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides an interface to Sonos players (via SoCo)
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.sonos.html
+"""
+import logging
+import datetime
+
+from homeassistant.components.media_player import (
+    MediaPlayerDevice, SUPPORT_PAUSE, SUPPORT_SEEK, SUPPORT_VOLUME_SET,
+    SUPPORT_VOLUME_MUTE, SUPPORT_PREVIOUS_TRACK, SUPPORT_NEXT_TRACK,
+    MEDIA_TYPE_MUSIC)
+
+from homeassistant.const import (
+    STATE_IDLE, STATE_PLAYING, STATE_PAUSED, STATE_UNKNOWN)
+
+
+REQUIREMENTS = ['SoCo==0.11.1']
+
+_LOGGER = logging.getLogger(__name__)
+
+# The soco library is excessively chatty when it comes to logging and
+# causes a LOT of spam in the logs due to making a http connection to each
+# speaker every 10 seconds. Quiet it down a bit to just actual problems.
+_SOCO_LOGGER = logging.getLogger('soco')
+_SOCO_LOGGER.setLevel(logging.ERROR)
+_REQUESTS_LOGGER = logging.getLogger('requests')
+_REQUESTS_LOGGER.setLevel(logging.ERROR)
+
+SUPPORT_SONOS = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE |\
+    SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | SUPPORT_SEEK
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Sets up the Sonos platform. """
+    import soco
+
+    players = soco.discover()
+    if not players:
+        _LOGGER.warning('No Sonos speakers found. Disabling: %s', __name__)
+        return False
+
+    add_devices(SonosDevice(hass, p) for p in players)
+    _LOGGER.info('Added %s Sonos speakers', len(players))
+
+    return True
+
+
+# pylint: disable=too-many-instance-attributes, too-many-public-methods
+# pylint: disable=abstract-method
+class SonosDevice(MediaPlayerDevice):
+    """ Represents a Sonos device. """
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, hass, player):
+        self.hass = hass
+        super(SonosDevice, self).__init__()
+        self._player = player
+        self.update()
+
+    @property
+    def should_poll(self):
+        return True
+
+    def update_sonos(self, now):
+        """ Updates state, called by track_utc_time_change. """
+        self.update_ha_state(True)
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self._name
+
+    @property
+    def unique_id(self):
+        """ Returns a unique id. """
+        return "{}.{}".format(self.__class__, self._player.uid)
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        if self._status == 'PAUSED_PLAYBACK':
+            return STATE_PAUSED
+        if self._status == 'PLAYING':
+            return STATE_PLAYING
+        if self._status == 'STOPPED':
+            return STATE_IDLE
+        return STATE_UNKNOWN
+
+    def update(self):
+        """ Retrieve latest state. """
+        self._name = self._player.get_speaker_info()['zone_name'].replace(
+            ' (R)', '').replace(' (L)', '')
+        self._status = self._player.get_current_transport_info().get(
+            'current_transport_state')
+        self._trackinfo = self._player.get_current_track_info()
+
+    @property
+    def volume_level(self):
+        """ Volume level of the media player (0..1). """
+        return self._player.volume / 100.0
+
+    @property
+    def is_volume_muted(self):
+        return self._player.mute
+
+    @property
+    def media_content_id(self):
+        """ Content ID of current playing media. """
+        return self._trackinfo.get('title', None)
+
+    @property
+    def media_content_type(self):
+        """ Content type of current playing media. """
+        return MEDIA_TYPE_MUSIC
+
+    @property
+    def media_duration(self):
+        """ Duration of current playing media in seconds. """
+        dur = self._trackinfo.get('duration', '0:00')
+
+        # If the speaker is playing from the "line-in" source, getting
+        # track metadata can return NOT_IMPLEMENTED, which breaks the
+        # volume logic below
+        if dur == 'NOT_IMPLEMENTED':
+            return None
+
+        return sum(60 ** x[0] * int(x[1]) for x in
+                   enumerate(reversed(dur.split(':'))))
+
+    @property
+    def media_image_url(self):
+        """ Image url of current playing media. """
+        if 'album_art' in self._trackinfo:
+            return self._trackinfo['album_art']
+
+    @property
+    def media_title(self):
+        """ Title of current playing media. """
+        if 'artist' in self._trackinfo and 'title' in self._trackinfo:
+            return '{artist} - {title}'.format(
+                artist=self._trackinfo['artist'],
+                title=self._trackinfo['title']
+            )
+        if 'title' in self._status:
+            return self._trackinfo['title']
+
+    @property
+    def supported_media_commands(self):
+        """ Flags of media commands that are supported. """
+        return SUPPORT_SONOS
+
+    def turn_off(self):
+        """ Turn off media player. """
+        self._player.pause()
+
+    def volume_up(self):
+        """ Volume up media player. """
+        self._player.volume += 1
+
+    def volume_down(self):
+        """ Volume down media player. """
+        self._player.volume -= 1
+
+    def set_volume_level(self, volume):
+        """ Set volume level, range 0..1. """
+        self._player.volume = str(int(volume * 100))
+
+    def mute_volume(self, mute):
+        """ Mute (true) or unmute (false) media player. """
+        self._player.mute = mute
+
+    def media_play(self):
+        """ Send paly command. """
+        self._player.play()
+
+    def media_pause(self):
+        """ Send pause command. """
+        self._player.pause()
+
+    def media_next_track(self):
+        """ Send next track command. """
+        self._player.next()
+
+    def media_previous_track(self):
+        """ Send next track command. """
+        self._player.previous()
+
+    def media_seek(self, position):
+        """ Send seek command. """
+        self._player.seek(str(datetime.timedelta(seconds=int(position))))
+
+    def turn_on(self):
+        """ Turn the media player on. """
+        self._player.play()
@@ -1,39 +1,11 @@
 """
 homeassistant.components.media_player.squeezebox
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Provides an interface to the Logitech SqueezeBox API

-Configuration:
-
-To use SqueezeBox add something like this to your configuration:
-
-media_player:
-  platform: squeezebox
-  host: 192.168.1.21
-  port: 9090
-  username: user
-  password: password
-
-Variables:
-
-host
-*Required
-The host name or address of the Logitech Media Server
-
-port
-*Optional
-Telnet port to Logitech Media Server, default 9090
-
-usermame
-*Optional
-Username, if password protection is enabled
-
-password
-*Optional
-Password, if password protection is enabled
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.squeezebox.html
 """
-
 import logging
 import telnetlib
 import urllib.parse
@@ -91,7 +63,7 @@ class LogitechMediaServer(object):
        self.init_success = True if self.http_port else False

    def _get_http_port(self):
-        """ Get http port from media server, it is used to get cover art """
+        """ Get http port from media server, it is used to get cover art. """
        http_port = None
        try:
            http_port = self.query('pref', 'httpport', '?')
@@ -111,7 +83,7 @@ class LogitechMediaServer(object):
            return

    def create_players(self):
-        """ Create a list of SqueezeBoxDevices connected to the LMS """
+        """ Create a list of SqueezeBoxDevices connected to the LMS. """
        players = []
        count = self.query('player', 'count', '?')
        for index in range(0, int(count)):
@@ -121,7 +93,7 @@ class LogitechMediaServer(object):
        return players

    def query(self, *parameters):
-        """ Send request and await response from server  """
+        """ Send request and await response from server. """
        telnet = telnetlib.Telnet(self.host, self.port)
        if self._username and self._password:
            telnet.write('login {username} {password}\n'.format(
@@ -138,7 +110,7 @@ class LogitechMediaServer(object):
        return urllib.parse.unquote(response)

    def get_player_status(self, player):
-        """ Get ithe status of a player """
+        """ Get ithe status of a player. """
        #   (title) : Song title
        # Requested Information
        # a (artist): Artist name 'artist'
@@ -195,7 +167,7 @@ class SqueezeBoxDevice(MediaPlayerDevice):

    def update(self):
        """ Retrieve latest state. """
-        self._status = self._lms.get_player_status(self._name)
+        self._status = self._lms.get_player_status(self._id)

    @property
    def volume_level(self):
@@ -291,7 +263,7 @@ class SqueezeBoxDevice(MediaPlayerDevice):

    def media_pause(self):
        """ media_pause media player. """
-        self._lms.query(self._id, 'pause', '0')
+        self._lms.query(self._id, 'pause', '1')
        self.update_ha_state()

    def media_next_track(self):
@@ -1,34 +1,10 @@
 """
 homeassistant.components.modbus
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Modbus component, using pymodbus (python3 branch)
-
-Configuration:
-
-To use the Forecast sensor you will need to add something like the
-following to your config/configuration.yaml
-
-Configuration:
-
-To use the Modbus component you will need to add something like the following
-to your config/configuration.yaml
-
-#Modbus TCP
-modbus:
-    type: tcp
-    host: 127.0.0.1
-    port: 2020
-
-#Modbus RTU
-modbus:
-    type: serial
-    method: rtu
-    port: /dev/ttyUSB0
-    baudrate: 9600
-    stopbits: 1
-    bytesize: 8
-    parity: N
+Modbus component, using pymodbus (python3 branch).

+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/modbus.html
 """
 import logging

@@ -38,8 +14,8 @@ from homeassistant.const import (EVENT_HOMEASSISTANT_START,
 DOMAIN = "modbus"

 DEPENDENCIES = []
-REQUIREMENTS = ['https://github.com/bashwork/pymodbus/archive/' +
-                'd7fc4f1cc975631e0a9011390e8017f64b612661.zip']
+REQUIREMENTS = ['https://github.com/bashwork/pymodbus/archive/'
+                'd7fc4f1cc975631e0a9011390e8017f64b612661.zip#pymodbus==1.2.0']

 # Type of network
 MEDIUM = "type"
@@ -1,49 +1,13 @@
 """
 homeassistant.components.mqtt
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-MQTT component, using paho-mqtt. This component needs a MQTT broker like
-Mosquitto or Mosca. The Eclipse Foundation is running a public MQTT server
-at iot.eclipse.org. If you prefer to use that one, keep in mind to adjust
-the topic/client ID and that your messages are public.
+MQTT component, using paho-mqtt.

-Configuration:
-
-To use MQTT you will need to add something like the following to your
-config/configuration.yaml.
-
-mqtt:
-  broker: 127.0.0.1
-
-Or, if you want more options:
-
-mqtt:
-  broker: 127.0.0.1
-  port: 1883
-  client_id: home-assistant-1
-  keepalive: 60
-  username: your_username
-  password: your_secret_password
-
-Variables:
-
-broker
-*Required
-This is the IP address of your MQTT broker, e.g. 192.168.1.32.
-
-port
-*Optional
-The network port to connect to. Default is 1883.
-
-client_id
-*Optional
-Client ID that Home Assistant will use. Has to be unique on the server.
-Default is a random generated one.
-
-keepalive
-*Optional
-The keep alive in seconds for this client. Default is 60.
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/mqtt.html
 """
 import logging
+import os
 import socket

 from homeassistant.exceptions import HomeAssistantError
@@ -74,22 +38,25 @@ CONF_CLIENT_ID = 'client_id'
 CONF_KEEPALIVE = 'keepalive'
 CONF_USERNAME = 'username'
 CONF_PASSWORD = 'password'
+CONF_CERTIFICATE = 'certificate'

-ATTR_QOS = 'qos'
 ATTR_TOPIC = 'topic'
 ATTR_PAYLOAD = 'payload'
+ATTR_QOS = 'qos'


-def publish(hass, topic, payload):
+def publish(hass, topic, payload, qos=None):
    """ Send an MQTT message. """
    data = {
        ATTR_TOPIC: topic,
        ATTR_PAYLOAD: payload,
    }
+    if qos is not None:
+        data[ATTR_QOS] = qos
    hass.services.call(DOMAIN, SERVICE_PUBLISH, data)


-def subscribe(hass, topic, callback, qos=0):
+def subscribe(hass, topic, callback, qos=DEFAULT_QOS):
    """ Subscribe to a topic. """
    def mqtt_topic_subscriber(event):
        """ Match subscribed MQTT topic. """
@@ -117,11 +84,18 @@ def setup(hass, config):
    keepalive = util.convert(conf.get(CONF_KEEPALIVE), int, DEFAULT_KEEPALIVE)
    username = util.convert(conf.get(CONF_USERNAME), str)
    password = util.convert(conf.get(CONF_PASSWORD), str)
+    certificate = util.convert(conf.get(CONF_CERTIFICATE), str)
+
+    # For cloudmqtt.com, secured connection, auto fill in certificate
+    if certificate is None and 19999 < port < 30000 and \
+       broker.endswith('.cloudmqtt.com'):
+        certificate = os.path.join(os.path.dirname(__file__),
+                                   'addtrustexternalcaroot.crt')

    global MQTT_CLIENT
    try:
        MQTT_CLIENT = MQTT(hass, broker, port, client_id, keepalive, username,
-                           password)
+                           password, certificate)
    except socket.error:
        _LOGGER.exception("Can't connect to the broker. "
                          "Please check your settings and the broker "
@@ -141,9 +115,10 @@ def setup(hass, config):
        """ Handle MQTT publish service calls. """
        msg_topic = call.data.get(ATTR_TOPIC)
        payload = call.data.get(ATTR_PAYLOAD)
+        qos = call.data.get(ATTR_QOS, DEFAULT_QOS)
        if msg_topic is None or payload is None:
            return
-        MQTT_CLIENT.publish(msg_topic, payload)
+        MQTT_CLIENT.publish(msg_topic, payload, qos)

    hass.bus.listen_once(EVENT_HOMEASSISTANT_START, start_mqtt)

@@ -158,7 +133,7 @@ def setup(hass, config):
 class MQTT(object):  # pragma: no cover
    """ Implements messaging service for MQTT. """
    def __init__(self, hass, broker, port, client_id, keepalive, username,
-                 password):
+                 password, certificate):
        import paho.mqtt.client as mqtt

        self.hass = hass
@@ -169,17 +144,21 @@ class MQTT(object):  # pragma: no cover
            self._mqttc = mqtt.Client()
        else:
            self._mqttc = mqtt.Client(client_id)
+
        if username is not None:
            self._mqttc.username_pw_set(username, password)
+        if certificate is not None:
+            self._mqttc.tls_set(certificate)
+
        self._mqttc.on_subscribe = self._mqtt_on_subscribe
        self._mqttc.on_unsubscribe = self._mqtt_on_unsubscribe
        self._mqttc.on_connect = self._mqtt_on_connect
        self._mqttc.on_message = self._mqtt_on_message
        self._mqttc.connect(broker, port, keepalive)

-    def publish(self, topic, payload):
+    def publish(self, topic, payload, qos):
        """ Publish a MQTT message. """
-        self._mqttc.publish(topic, payload)
+        self._mqttc.publish(topic, payload, qos)

    def unsubscribe(self, topic):
        """ Unsubscribe from topic. """
@@ -206,6 +185,17 @@ class MQTT(object):  # pragma: no cover

    def _mqtt_on_connect(self, mqttc, obj, flags, result_code):
        """ On connect, resubscribe to all topics we were subscribed to. """
+        if result_code != 0:
+            _LOGGER.error('Unable to connect to the MQTT broker: %s', {
+                1: 'Incorrect protocol version',
+                2: 'Invalid client identifier',
+                3: 'Server unavailable',
+                4: 'Bad username or password',
+                5: 'Not authorised'
+            }.get(result_code))
+            self._mqttc.disconnect()
+            return
+
        old_topics = self.topics
        self._progress = {}
        self.topics = {}
@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU
+MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs
+IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290
+MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux
+FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h
+bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v
+dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt
+H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9
+uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX
+mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX
+a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN
+E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0
+WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD
+VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0
+Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU
+cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx
+IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN
+AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH
+YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5
+6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC
+Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX
+c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a
+mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ=
+-----END CERTIFICATE-----
@@ -6,7 +6,9 @@ Provides functionality to notify people.
 """
 from functools import partial
 import logging
+import os

+from homeassistant.config import load_yaml_config_file
 from homeassistant.loader import get_component
 from homeassistant.helpers import config_per_platform

@@ -36,6 +38,9 @@ def setup(hass, config):
    """ Sets up notify services. """
    success = False

+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+
    for platform, p_config in config_per_platform(config, DOMAIN, _LOGGER):
        # get platform
        notify_implementation = get_component(
@@ -69,7 +74,8 @@ def setup(hass, config):
        # register service
        service_call_handler = partial(notify_message, notify_service)
        service_notify = p_config.get(CONF_NAME, SERVICE_NOTIFY)
-        hass.services.register(DOMAIN, service_notify, service_call_handler)
+        hass.services.register(DOMAIN, service_notify, service_call_handler,
+                               descriptions.get(service_notify))
        success = True

    return success
@@ -1,29 +1,10 @@
 """
 homeassistant.components.notify.file
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 File notification service.

-Configuration:
-
-To use the File notifier you will need to add something like the following
-to your config/configuration.yaml
-
-notify:
-  platform: file
-  filename: FILENAME
-  timestamp: 1 or 0
-
-Variables:
-
-filename
-*Required
-Name of the file to use. The file will be created if it doesn't exist and saved
-in your config/ folder.
-
-timestamp
-*Required
-Add a timestamp to the entry, valid entries are 1 or 0.
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/notify.file.html
 """
 import logging
 import os
@@ -1,56 +1,10 @@
 """
 homeassistant.components.notify.instapush
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Instapush notification service.

-Configuration:
-
-To use the Instapush notifier you will need to add something like the following
-to your config/configuration.yaml
-
-notify:
-  platform: instapush
-  api_key: YOUR_APP_KEY
-  app_secret: YOUR_APP_SECRET
-  event: YOUR_EVENT
-  tracker: YOUR_TRACKER
-
-VARIABLES:
-
-api_key
-*Required
-To retrieve this value log into your account at https://instapush.im and go
-to 'APPS', choose an app, and check 'Basic Info'.
-
-app_secret
-*Required
-To get this value log into your account at https://instapush.im and go to
-'APPS'. The 'Application ID' can be found under 'Basic Info'.
-
-event
-*Required
-To retrieve a valid event log into your account at https://instapush.im and go
-to 'APPS'. If you have no events to use with Home Assistant, create one event
-for your app.
-
-tracker
-*Required
-To retrieve the tracker value log into your account at https://instapush.im and
-go to 'APPS', choose the app, and check the event entries.
-
-Example usage of Instapush if you have an event 'notification' and a tracker
-'home-assistant'.
-
-curl -X POST \
-    -H "x-instapush-appid: YOUR_APP_KEY" \
-    -H "x-instapush-appsecret: YOUR_APP_SECRET" \
-    -H "Content-Type: application/json" \
-      -d '{"event":"notification","trackers":{"home-assistant":"Switch 1"}}' \
-    https://api.instapush.im/v1/post
-
-Details for the API : https://instapush.im/developer/rest
-
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/notify.instapush.html
 """
 import logging
 import json
@@ -1,27 +1,10 @@
 """
 homeassistant.components.notify.nma
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 NMA (Notify My Android) notification service.

-Configuration:
-
-To use the NMA notifier you will need to add something like the following
-to your config/configuration.yaml
-
-notify:
-  platform: nma
-  api_key: YOUR_API_KEY
-
-VARIABLES:
-
-api_key
-*Required
-Enter the API key for NMA. Go to https://www.notifymyandroid.com and create a
-new API key to use with Home Assistant.
-
-Details for the API : https://www.notifymyandroid.com/api.jsp
-
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/notify.nma.html
 """
 import logging
 import xml.etree.ElementTree as ET
--- a/Show More
+++ b/Show More