Merge branch 'dev'

0.7.4rc1

.coveragerc

@@ -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,7 @@ omit =
     homeassistant/components/zwave.py
     homeassistant/components/*/zwave.py
 
+    homeassistant/components/ifttt.py
     homeassistant/components/browser.py
     homeassistant/components/camera/*
     homeassistant/components/device_tracker/actiontec.py
@@ -46,9 +45,13 @@ omit =
     homeassistant/components/light/hue.py
     homeassistant/components/light/limitlessled.py
     homeassistant/components/media_player/cast.py
+    homeassistant/components/media_player/denon.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
@@ -58,12 +61,16 @@ omit =
     homeassistant/components/notify/smtp.py
     homeassistant/components/notify/syslog.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/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/rest.py
     homeassistant/components/sensor/rfxtrx.py
     homeassistant/components/sensor/rpi_gpio.py
     homeassistant/components/sensor/sabnzbd.py
@@ -72,6 +79,8 @@ 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

.gitignore

@@ -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]
 

.gitmodules

@@ -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

.travis.yml

@@ -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

CONTRIBUTING.md

@@ -18,7 +18,7 @@ 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`.

MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-exclude tests *
+recursive-include homeassistant services.yaml

README.md

@@ -18,7 +18,7 @@ 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/)
  * [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/)
+ * [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), [Kodi (XBMC)](http://kodi.tv/), and iTunes (by way of [itunes-api](https://github.com/maddox/itunes-api))
  * 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/)
  * 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/)

config/configuration.yaml.example

@@ -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,36 @@ 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
-
-  time_hours: 16
-  time_minutes: 0
-  time_seconds: 0
-
-  execute_service: notify.notify
-  service_data:
-    message: It's 4, time for beer!
+  condition: use_trigger_values
+  action:
+     service: light.turn_off
+     entity_id: group.all_lights
 
 sensor:
   platform: systemmonitor
@@ -135,6 +152,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:

config/custom_components/example.py

@@ -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

config/custom_components/hello_world.py

@@ -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

config/custom_components/mqtt_example.py

@@ -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

homeassistant/__main__.py

@@ -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):

homeassistant/bootstrap.py

@@ -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))
 

homeassistant/components/alarm_control_panel/__init__.py

@@ -0,0 +1,132 @@
+"""
+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_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',
+}
+
+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:
+            return
+
+        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, entity_id=None):
+    """ Send the alarm the command for disarm. """
+    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, entity_id=None):
+    """ Send the alarm the command for arm home. """
+    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, entity_id=None):
+    """ Send the alarm the command for arm away. """
+    data = {ATTR_CODE: code}
+
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_AWAY, 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()
+
+    @property
+    def state_attributes(self):
+        """ Return the state attributes. """
+        state_attr = {
+            ATTR_CODE_FORMAT: self.code_format,
+            }
+        return state_attr

homeassistant/components/alarm_control_panel/mqtt.py

@@ -0,0 +1,167 @@
+"""
+homeassistant.components.alarm_control_panel.mqtt
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This platform enables the possibility to control a MQTT alarm.
+In this platform, 'state_topic' and 'command_topic' are required.
+The alarm will only change state after receiving the a new state
+from 'state_topic'. If these messages are published with RETAIN flag,
+the MQTT alarm will receive an instant state update after subscription
+and will start with correct state. Otherwise, the initial state will
+be 'unknown'.
+
+Configuration:
+
+alarm_control_panel:
+  platform: mqtt
+  name: "MQTT Alarm"
+  state_topic: "home/alarm"
+  command_topic: "home/alarm/set"
+  qos: 0
+  payload_disarm: "DISARM"
+  payload_arm_home: "ARM_HOME"
+  payload_arm_away: "ARM_AWAY"
+  code: "mySecretCode"
+
+Variables:
+
+name
+*Optional
+The name of the alarm. Default is 'MQTT Alarm'.
+
+state_topic
+*Required
+The MQTT topic subscribed to receive state updates.
+
+command_topic
+*Required
+The MQTT topic to publish commands to change the alarm state.
+
+qos
+*Optional
+The maximum QoS level of the state topic. Default is 0.
+This QoS will also be used to publishing messages.
+
+payload_disarm
+*Optional
+The payload do disarm alarm. Default is "DISARM".
+
+payload_arm_home
+*Optional
+The payload to set armed-home mode. Default is "ARM_HOME".
+
+payload_arm_away
+*Optional
+The payload to set armed-away mode. Default is "ARM_AWAY".
+
+code
+*Optional
+If defined, specifies a code to enable or disable the alarm in the frontend.
+"""
+import logging
+import homeassistant.components.mqtt as mqtt
+import homeassistant.components.alarm_control_panel as alarm
+
+from homeassistant.const import (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
+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 = code
+
+        def message_received(topic, payload, qos):
+            """ A new MQTT message has been received. """
+            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 code == str(self._code) or self.code_format is None:
+            mqtt.publish(self.hass, self._command_topic,
+                         self._payload_disarm, self._qos)
+        else:
+            _LOGGER.warning("Wrong code entered while disarming!")
+
+    def alarm_arm_home(self, code=None):
+        """ Send arm home command. """
+        if code == str(self._code) or self.code_format is None:
+            mqtt.publish(self.hass, self._command_topic,
+                         self._payload_arm_home, self._qos)
+        else:
+            _LOGGER.warning("Wrong code entered while arming home!")
+
+    def alarm_arm_away(self, code=None):
+        """ Send arm away command. """
+        if code == str(self._code) or self.code_format is None:
+            mqtt.publish(self.hass, self._command_topic,
+                         self._payload_arm_away, self._qos)
+        else:
+            _LOGGER.warning("Wrong code entered while arming away!")

homeassistant/components/alarm_control_panel/verisure.py

@@ -0,0 +1,93 @@
+"""
+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)
+
+
+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')

homeassistant/components/api.py

@@ -103,6 +103,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 +122,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

homeassistant/components/arduino.py

@@ -7,7 +7,7 @@ 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
+to your configuration.yaml file.
 
 arduino:
     port: /dev/ttyACM0

homeassistant/components/automation/__init__.py

@@ -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

homeassistant/components/automation/event.py

@@ -12,7 +12,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 +20,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)

homeassistant/components/automation/mqtt.py

@@ -10,11 +10,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)

homeassistant/components/automation/numeric_state.py

@@ -0,0 +1,91 @@
+"""
+homeassistant.components.automation.numeric_state
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Offers numeric state listening automation rules.
+"""
+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

homeassistant/components/automation/state.py

@@ -10,22 +10,23 @@ 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
 
     def state_automation_listener(entity, from_s, to_s):
         """ Listens for state changes and calls action. """
@@ -35,3 +36,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

homeassistant/components/automation/sun.py

@@ -0,0 +1,103 @@
+"""
+homeassistant.components.automation.sun
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Offers sun based automation rules.
+"""
+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())

homeassistant/components/automation/time.py

@@ -4,19 +4,41 @@ homeassistant.components.automation.time
 
 Offers time listening automation rules.
 """
+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 +48,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')

homeassistant/components/automation/zone.py

@@ -0,0 +1,85 @@
+"""
+homeassistant.components.automation.zone
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Offers zone automation rules.
+"""
+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))

homeassistant/components/camera/foscam.py

@@ -0,0 +1,105 @@
+"""
+homeassistant.components.camera.foscam
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This component provides basic support for Foscam IP cameras.
+
+As part of the basic support the following features will be provided:
+-MJPEG video streaming
+
+To use this component, add the following to your configuration.yaml file.
+
+camera:
+  platform: foscam
+  name: Door Camera
+  ip: 192.168.0.123
+  port: 88
+  username: YOUR_USERNAME
+  password: YOUR_PASSWORD
+
+Variables:
+
+ip
+*Required
+The IP address of your Foscam device.
+
+username
+*Required
+The username of a visitor or operator of your camera. Oddly admin accounts
+don't seem to have access to take snapshots.
+
+password
+*Required
+The password for accessing your camera.
+
+name
+*Optional
+This parameter allows you to override the name of your camera in homeassistant.
+
+port
+*Optional
+The port that the camera is running on. The default is 88.
+
+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

homeassistant/components/camera/generic.py

@@ -1,4 +1,6 @@
 """
+homeassistant.components.camera.generic
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Support for IP Cameras.
 
 This component provides basic support for IP cameras. For the basic support to
@@ -7,11 +9,11 @@ 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)
+- MJPEG video streaming
+- Saving a snapshot
+- Recording(JPEG frame capture)
 
-To use this component, add the following to your config/configuration.yaml:
+To use this component, add the following to your configuration.yaml file.
 
 camera:
     platform: generic
@@ -20,29 +22,24 @@ camera:
     password: YOUR_PASSWORD
     still_image_url: http://YOUR_CAMERA_IP_AND_PORT/image.jpg
 
-
-VARIABLES:
-
-These are the variables for the device_data array:
+Variables:
 
 still_image_url
 *Required
-The URL your camera serves the image on.
-Example: http://192.168.1.21:2112/
+The URL your camera serves the image on, eg. http://192.168.1.21:2112/
 
 name
 *Optional
-This parameter allows you to override the name of your camera in homeassistant
+This parameter allows you to override the name of your camera in Home
+Assistant.
 
 username
 *Optional
-THe username for acessing your camera
+The username for accessing your camera.
 
 password
 *Optional
-the password for accessing your camera
-
-
+The password for accessing your camera.
 """
 import logging
 from requests.auth import HTTPBasicAuth
@@ -78,7 +75,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 +87,5 @@ class GenericCamera(Camera):
 
     @property
     def name(self):
-        """ Return the name of this device """
+        """ Return the name of this device. """
         return self._name

homeassistant/components/demo.py

@@ -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,7 @@ 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 scripts
@@ -108,7 +108,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",
                     {

homeassistant/components/device_tracker/__init__.py

@@ -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,354 @@ 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, {})
+    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))

homeassistant/components/device_tracker/actiontec.py

@@ -1,6 +1,6 @@
 """
 homeassistant.components.device_tracker.actiontec
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Device tracker platform that supports scanning an Actiontec MI424WR
 (Verizon FIOS) router for device presence.
 
@@ -9,13 +9,16 @@ 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
+following to your configuration.yaml file. If you experience disconnects
+you can modify the home_interval variable.
 
 device_tracker:
   platform: actiontec
   host: YOUR_ROUTER_IP
   username: YOUR_ADMIN_USERNAME
   password: YOUR_ADMIN_PASSWORD
+  # optional:
+  home_interval: 10
 
 Variables:
 
@@ -30,21 +33,32 @@ The username of an user with administrative privileges, usually 'admin'.
 password
 *Required
 The password for your given admin account.
+
+home_interval
+*Optional
+If the home_interval is set then the component will not let a device
+be AWAY if it has been HOME in the last home_interval minutes. This is
+in addition to the 3 minute wait built into the device_tracker component.
 """
 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 +68,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 +78,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: ')

homeassistant/components/device_tracker/aruba.py

@@ -9,8 +9,8 @@ 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.
+to your configuration.yaml file. You also need to enable Telnet in the
+configuration page of your router.
 
 device_tracker:
   platform: aruba
@@ -51,15 +51,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 +83,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 +101,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 +117,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: ')

homeassistant/components/device_tracker/asuswrt.py

@@ -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,11 +157,19 @@ 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
+            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:

homeassistant/components/device_tracker/ddwrt.py

@@ -1,14 +1,13 @@
 """
 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
+to your configuration.yaml file.
 
 device_tracker:
   platform: ddwrt
@@ -64,7 +63,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.
     """
 
@@ -85,8 +85,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()
 
@@ -124,8 +125,10 @@ class DdWrtDeviceScanner(object):
 
     @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
 
@@ -163,7 +166,7 @@ class DdWrtDeviceScanner(object):
             return False
 
     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,

homeassistant/components/device_tracker/demo.py

@@ -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

homeassistant/components/device_tracker/luci.py

@@ -1,18 +1,16 @@
 """
 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
+to your configuration.yaml file.
 
 device_tracker:
   platform: luci
@@ -66,7 +64,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 +94,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 +124,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 +181,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)

homeassistant/components/device_tracker/mqtt.py

@@ -0,0 +1,48 @@
+"""
+homeassistant.components.device_tracker.mqtt
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+MQTT platform for the device tracker.
+
+device_tracker:
+  platform: mqtt
+  qos: 1
+  devices:
+    paulus_oneplus: /location/paulus
+    annetherese_n4: /location/annetherese
+"""
+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

homeassistant/components/device_tracker/netgear.py

@@ -1,14 +1,13 @@
 """
 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
+to your configuration.yaml file.
 
 device_tracker:
   platform: netgear
@@ -71,7 +70,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 +88,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 +105,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
 

homeassistant/components/device_tracker/nmap_tracker.py

@@ -1,13 +1,12 @@
 """
 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
+to your configuration.yaml file.
 
 device_tracker:
   platform: nmap_tracker
@@ -45,7 +44,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 +73,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 +86,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,14 +107,16 @@ 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"
+        options = "-F --host-timeout 5"
         exclude_targets = set()
         if self.home_interval:
             now = dt_util.now()

homeassistant/components/device_tracker/owntracks.py

@@ -0,0 +1,54 @@
+"""
+homeassistant.components.device_tracker.owntracks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+OwnTracks platform for the device tracker.
+
+device_tracker:
+  platform: owntracks
+"""
+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

homeassistant/components/device_tracker/thomson.py

@@ -9,7 +9,7 @@ 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
+to your configuration.yaml file.
 
 device_tracker:
   platform: thomson
@@ -71,7 +71,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 +108,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 +128,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 : ')

homeassistant/components/device_tracker/tomato.py

@@ -1,14 +1,13 @@
 """
 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
+to your configuration.yaml file.
 
 device_tracker:
   platform: tomato

homeassistant/components/device_tracker/tplink.py

@@ -1,14 +1,13 @@
 """
 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
+to your configuration.yaml file.
 
 device_tracker:
   platform: tplink
@@ -29,7 +28,6 @@ The username of an user with administrative privileges, usually 'admin'.
 password
 *Required
 The password for your given admin account.
-
 """
 import base64
 import logging
@@ -65,7 +63,8 @@ def get_scanner(hass, config):
 
 
 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 +84,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 +94,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,28 +125,33 @@ 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...")

homeassistant/components/discovery.py

@@ -19,22 +19,22 @@ from homeassistant.const import (
 
 DOMAIN = "discovery"
 DEPENDENCIES = []
-REQUIREMENTS = ['netdisco==0.3']
+REQUIREMENTS = ['netdisco==0.4.2']
 
 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_HANDLERS = {
     SERVICE_WEMO: "switch",
     SERVICE_CAST: "media_player",
     SERVICE_HUE: "light",
     SERVICE_NETGEAR: 'device_tracker',
+    SERVICE_SONOS: 'media_player',
 }
 
 
@@ -79,13 +79,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

homeassistant/components/frontend/__init__.py

@@ -21,7 +21,8 @@ _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/]+)|)')
 
 

homeassistant/components/frontend/version.py

@@ -1,2 +1,2 @@
 """ DO NOT MODIFY. Auto-generated by build_frontend script """
-VERSION = "35ecb5457a9ff0f4142c2605b53eb843"
+VERSION = "c4722afa376379bc4457d54bb9a38cee"

homeassistant/components/group.py

@@ -12,7 +12,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 +23,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):

homeassistant/components/history.py

@@ -147,8 +147,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(

homeassistant/components/http.py

@@ -205,7 +205,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 +232,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 +492,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 """

homeassistant/components/ifttt.py

@@ -0,0 +1,79 @@
+"""
+homeassistant.components.ifttt
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This component enable you to trigger Maker IFTTT recipes.
+Check https://ifttt.com/maker for details.
+
+Configuration:
+
+To use Maker IFTTT you will need to add something like the following to your
+config/configuration.yaml.
+
+ifttt:
+  key: xxxxx-x-xxxxxxxxxxxxx
+
+Variables:
+
+key
+*Required
+Your api key
+
+"""
+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

homeassistant/components/light/__init__.py

@@ -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"
@@ -275,11 +275,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
 

homeassistant/components/light/limitlessled.py

@@ -15,16 +15,19 @@ Support for LimitlessLED bulbs, also known as...
 Configuration:
 
 To use limitlessled you will need to add the following to your
-config/configuration.yaml.
+configuration.yaml file.
 
 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
-
+  bridges:
+    - host: 192.168.1.10
+      group_1_name: Living Room
+      group_2_name: Bedroom
+      group_3_name: Office
+      group_3_type: white
+      group_4_name: Kitchen
+    - host: 192.168.1.11
+      group_2_name: Basement
 """
 import logging
 
@@ -34,19 +37,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 +68,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 +144,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 +153,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 +164,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 +174,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()

homeassistant/components/light/services.yaml

@@ -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

homeassistant/components/light/tellstick.py

@@ -6,12 +6,14 @@ Support for Tellstick lights.
 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 +24,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 +61,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 +83,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 +96,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 +111,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

homeassistant/components/light/vera.py

@@ -1,7 +1,6 @@
 """
 homeassistant.components.light.vera
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 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.
@@ -9,17 +8,17 @@ 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.
+your configuration.yaml file.
 
 light:
-    platform: vera
-    vera_controller_url: http://YOUR_VERA_IP:3480/
-    device_data:
-        12:
-            name: My awesome switch
-            exclude: true
-        13:
-            name: Another switch
+  platform: vera
+  vera_controller_url: http://YOUR_VERA_IP:3480/
+  device_data:
+    12:
+      name: My awesome switch
+      exclude: true
+    13:
+      name: Another switch
 
 Variables:
 
@@ -52,8 +51,10 @@ it should be set to "true" if you want this device excluded.
 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 +62,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:

homeassistant/components/light/wink.py

@@ -9,8 +9,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):

homeassistant/components/logbook.py

@@ -10,11 +10,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 +26,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 +132,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 +162,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 +202,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:

homeassistant/components/media_player/__init__.py

@@ -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,12 +21,13 @@ 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',
 }
 
 SERVICE_YOUTUBE_VIDEO = 'play_youtube_video'
@@ -185,6 +188,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 +204,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 +222,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 +240,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 +258,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. """
@@ -267,14 +277,17 @@ def setup(hass, config):
 
     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))
 
     return True
 
@@ -483,7 +496,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:

homeassistant/components/media_player/cast.py

@@ -1,10 +1,24 @@
 """
 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
+WARNING: This platform is currently not working due to a changed Cast API.
+
+Configuration:
+
+To use the chromecast integration you will need to add something like the
+following to your configuration.yaml file.
+
+media_player:
+  platform: chromecast
+  host: 192.168.1.9
+
+Variables:
+
+host
+*Optional
+Use only if you don't want to scan for devices.
 """
 import logging
 

homeassistant/components/media_player/demo.py

@@ -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)

homeassistant/components/media_player/denon.py

@@ -0,0 +1,191 @@
+"""
+homeassistant.components.media_player.denon
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides an interface to Denon Network Receivers.
+Developed for a Denon DRA-N5, see
+http://www.denon.co.uk/chg/product/compactsystems/networkmusicsystems/ceolpiccolo
+
+A few notes:
+    - As long as this module is active and connected, the receiver does
+      not seem to accept additional telnet connections.
+
+    - Be careful with the volume. 50% or even 100% are very loud.
+
+    - To be able to wake up the receiver, activate the "remote" setting
+      in the receiver's settings.
+
+    - Play and pause are supported, toggling is not possible.
+
+    - Seeking cannot be implemented as the UI sends absolute positions.
+      Only seeking via simulated button presses is possible.
+
+Configuration:
+
+To use your Denon you will need to add something like the following to
+your config/configuration.yaml:
+
+media_player:
+  platform: denon
+  name: Music station
+  host: 192.168.0.123
+
+Variables:
+
+host
+*Required
+The ip of the player. Example: 192.168.0.123
+
+name
+*Optional
+The name of the device.
+"""
+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
+
+    add_devices([
+        DenonDevice(
+            config.get('name', 'Music station'),
+            config.get('host'))
+    ])
+
+    return True
+
+
+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._telnet = telnetlib.Telnet(self._host)
+
+    def query(self, message):
+        """ Send request and await response from server """
+        try:
+            # unspecified command, should be ignored
+            self._telnet.write("?".encode('UTF-8') + b'\r')
+        except (EOFError, BrokenPipeError, ConnectionResetError):
+            self._telnet.open(self._host)
+
+        self._telnet.read_very_eager()  # skip what is not requested
+
+        self._telnet.write(message.encode('ASCII') + b'\r')
+        # timeout 200ms, defined by protocol
+        resp = self._telnet.read_until(b'\r', timeout=0.2)\
+            .decode('UTF-8').strip()
+
+        if message == "PW?":
+            # workaround; PW? sends also SISTATUS
+            self._telnet.read_until(b'\r', timeout=0.2)
+
+        return resp
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self._name
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        pwstate = self.query('PW?')
+        if pwstate == "PWSTANDBY":
+            return STATE_OFF
+        if pwstate == "PWON":
+            return STATE_ON
+
+        return STATE_UNKNOWN
+
+    @property
+    def volume_level(self):
+        """ Volume level of the media player (0..1). """
+        return int(self.query('MV?')[len('MV'):]) / 60
+
+    @property
+    def is_volume_muted(self):
+        """ Boolean if volume is currently muted. """
+        return self.query('MU?') == "MUON"
+
+    @property
+    def media_title(self):
+        """ Current media source. """
+        return self.query('SI?')[len('SI'):]
+
+    @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.query('PWSTANDBY')
+
+    def volume_up(self):
+        """ volume_up media player. """
+        self.query('MVUP')
+
+    def volume_down(self):
+        """ volume_down media player. """
+        self.query('MVDOWN')
+
+    def set_volume_level(self, volume):
+        """ set volume level, range 0..1. """
+        # 60dB max
+        self.query('MV' + str(round(volume * 60)).zfill(2))
+
+    def mute_volume(self, mute):
+        """ mute (true) or unmute (false) media player. """
+        self.query('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.query('NS9A')
+
+    def media_pause(self):
+        """ media_pause media player. """
+        self.query('NS9B')
+
+    def media_next_track(self):
+        """ Send next track command. """
+        self.query('NS9D')
+
+    def media_previous_track(self):
+        self.query('NS9E')
+
+    def media_seek(self, position):
+        raise NotImplementedError()
+
+    def turn_on(self):
+        """ turn the media player on. """
+        self.query('PWON')

homeassistant/components/media_player/itunes.py

@@ -0,0 +1,445 @@
+"""
+homeassistant.components.media_player.itunes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides an interface to iTunes-API (https://github.com/maddox/itunes-api)
+
+The iTunes media player will allow you to control your iTunes instance. You
+can play/pause/next/previous/mute, adjust volume, etc.
+
+In addition to controlling iTunes, your available AirPlay endpoints will be
+added as media players as well. You can then individually address them append
+turn them on, turn them off, or adjust their volume.
+
+Configuration:
+
+To use iTunes you will need to add something like the following to
+your configuration.yaml file.
+
+media_player:
+  platform: itunes
+  name: iTunes
+  host: http://192.168.1.16
+  port: 8181
+
+Variables:
+
+name
+*Optional
+The name of the device.
+
+url
+*Required
+URL of your running version of iTunes-API. Example: http://192.168.1.50:8181
+
+"""
+import logging
+
+from homeassistant.components.media_player import (
+    MediaPlayerDevice, MEDIA_TYPE_MUSIC, SUPPORT_PAUSE, SUPPORT_SEEK,
+    SUPPORT_VOLUME_SET, SUPPORT_VOLUME_MUTE, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_NEXT_TRACK, SUPPORT_TURN_ON, SUPPORT_TURN_OFF,
+    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_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 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
+# pylint: disable=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 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)
+
+
+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)

homeassistant/components/media_player/kodi.py

@@ -6,7 +6,7 @@ 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.
+your configuration.yaml file.
 
 media_player:
   platform: kodi
@@ -74,7 +74,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 +107,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
@@ -235,7 +236,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 +257,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:

homeassistant/components/media_player/mpd.py

@@ -1,13 +1,12 @@
 """
 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
+configuration.yaml file.
 
 media_player:
   platform: mpd

homeassistant/components/media_player/plex.py

@@ -0,0 +1,237 @@
+"""
+homeassistant.components.media_player.plex
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Provides an interface to the Plex API
+
+Configuration:
+
+To use Plex add something like this to your configuration:
+
+media_player:
+  platform: plex
+  name: plex_server
+  user: plex
+  password: my_secure_password
+
+Variables:
+
+name
+*Required
+The name of the backend device (Under Plex Media Server > settings > server).
+
+user
+*Required
+The Plex username
+
+password
+*Required
+The Plex password
+"""
+
+import logging
+from datetime import timedelta
+
+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 (
+    STATE_IDLE, STATE_PLAYING, STATE_PAUSED, STATE_OFF, STATE_UNKNOWN)
+import homeassistant.util as util
+
+REQUIREMENTS = ['https://github.com/adrienbrault/python-plexapi/archive/'
+                'df2d0847e801d6d5cda920326d693cf75f304f1a.zip'
+                '#python-plexapi==1.0.2']
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
+MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)
+
+_LOGGER = logging.getLogger(__name__)
+
+SUPPORT_PLEX = SUPPORT_PAUSE | SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK
+
+# pylint: disable=abstract-method
+# pylint: disable=unused-argument
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Sets up the plex platform. """
+    from plexapi.myplex import MyPlexUser
+    from plexapi.exceptions import BadRequest
+
+    name = config.get('name', '')
+    user = config.get('user', '')
+    password = config.get('password', '')
+    plexuser = MyPlexUser.signin(user, password)
+    plexserver = plexuser.getResource(name).connect()
+    plex_clients = {}
+    plex_sessions = {}
+
+    @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS)
+    def update_devices():
+        """ Updates the devices objects """
+        try:
+            devices = plexuser.devices()
+        except BadRequest:
+            _LOGGER.exception("Error listing plex devices")
+            return
+
+        new_plex_clients = []
+        for device in devices:
+            if (all(x not in ['client', 'player'] for x in device.provides)
+                    or 'PlexAPI' == device.product):
+                continue
+
+            if device.clientIdentifier not in plex_clients:
+                new_client = PlexClient(device, plex_sessions, update_devices,
+                                        update_sessions)
+                plex_clients[device.clientIdentifier] = new_client
+                new_plex_clients.append(new_client)
+            else:
+                plex_clients[device.clientIdentifier].set_device(device)
+
+        if new_plex_clients:
+            add_devices(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 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()
+
+
+class PlexClient(MediaPlayerDevice):
+    """ Represents a Plex device. """
+
+    # pylint: disable=too-many-public-methods
+
+    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 session(self):
+        """ Returns the session, if any """
+        if self.device.clientIdentifier not in self.plex_sessions:
+            return None
+
+        return self.plex_sessions[self.device.clientIdentifier]
+
+    @property
+    def name(self):
+        """ Returns the name of the device. """
+        return self.device.name or self.device.product or self.device.device
+
+    @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
+        elif self.device.isReachable:
+            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({'type': 'video'})
+
+    def media_pause(self):
+        """ media_pause media player. """
+        self.device.pause({'type': 'video'})
+
+    def media_next_track(self):
+        """ Send next track command. """
+        self.device.skipNext({'type': 'video'})
+
+    def media_previous_track(self):
+        """ Send previous track command. """
+        self.device.skipPrevious({'type': 'video'})

homeassistant/components/media_player/sonos.py

@@ -0,0 +1,206 @@
+"""
+homeassistant.components.media_player.sonos
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Provides an interface to Sonos players (via SoCo)
+
+Configuration:
+
+To use SoCo, add something like this to your configuration:
+
+media_player:
+  platform: sonos
+"""
+
+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
+# pylint: disable=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):
+        """ media_play media player. """
+        self._player.play()
+
+    def media_pause(self):
+        """ media_pause media player. """
+        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()

homeassistant/components/media_player/squeezebox.py

@@ -1,12 +1,12 @@
 """
 homeassistant.components.media_player.squeezebox
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Provides an interface to the Logitech SqueezeBox API
 
 Configuration:
 
-To use SqueezeBox add something like this to your configuration:
+To use SqueezeBox add something something like the following to your
+configuration.yaml file.
 
 media_player:
   platform: squeezebox
@@ -19,19 +19,19 @@ Variables:
 
 host
 *Required
-The host name or address of the Logitech Media Server
+The host name or address of the Logitech Media Server.
 
 port
 *Optional
-Telnet port to Logitech Media Server, default 9090
+Telnet port to Logitech Media Server, default 9090.
 
 usermame
 *Optional
-Username, if password protection is enabled
+Username, if password protection is enabled.
 
 password
 *Optional
-Password, if password protection is enabled
+Password, if password protection is enabled.
 """
 
 import logging
@@ -91,7 +91,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 +111,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 +121,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 +138,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 +195,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):

homeassistant/components/modbus.py

@@ -1,17 +1,12 @@
 """
 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
+Modbus component, using pymodbus (python3 branch).
 
 Configuration:
 
 To use the Modbus component you will need to add something like the following
-to your config/configuration.yaml
+to your configuration.yaml file.
 
 #Modbus TCP
 modbus:
@@ -38,8 +33,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"

homeassistant/components/mqtt/__init__.py

@@ -23,6 +23,7 @@ mqtt:
   keepalive: 60
   username: your_username
   password: your_secret_password
+  certificate: /home/paulus/dev/addtrustexternalcaroot.crt
 
 Variables:
 
@@ -42,8 +43,13 @@ Default is a random generated one.
 keepalive
 *Optional
 The keep alive in seconds for this client. Default is 60.
+
+certificate
+*Optional
+Certificate to use for encrypting the connection to the broker.
 """
 import logging
+import os
 import socket
 
 from homeassistant.exceptions import HomeAssistantError
@@ -74,22 +80,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 +126,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 +157,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 +175,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 +186,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 +227,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 = {}

homeassistant/components/mqtt/addtrustexternalcaroot.crt

@@ -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-----

homeassistant/components/notify/__init__.py

@@ -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

homeassistant/components/notify/file.py

@@ -1,13 +1,12 @@
 """
 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
+to your configuration.yaml file.
 
 notify:
   platform: file

homeassistant/components/notify/instapush.py

@@ -1,13 +1,12 @@
 """
 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
+to your configuration.yaml file.
 
 notify:
   platform: instapush
@@ -16,7 +15,7 @@ notify:
   event: YOUR_EVENT
   tracker: YOUR_TRACKER
 
-VARIABLES:
+Variables:
 
 api_key
 *Required
@@ -50,7 +49,6 @@ curl -X POST \
     https://api.instapush.im/v1/post
 
 Details for the API : https://instapush.im/developer/rest
-
 """
 import logging
 import json

homeassistant/components/notify/nma.py

@@ -1,19 +1,18 @@
 """
 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
+to your configuration.yaml file.
 
 notify:
   platform: nma
   api_key: YOUR_API_KEY
 
-VARIABLES:
+Variables:
 
 api_key
 *Required
@@ -21,7 +20,6 @@ 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
-
 """
 import logging
 import xml.etree.ElementTree as ET

homeassistant/components/notify/pushbullet.py

@@ -1,13 +1,12 @@
 """
 homeassistant.components.notify.pushbullet
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 PushBullet platform for notify component.
 
 Configuration:
 
 To use the PushBullet notifier you will need to add something like the
-following to your config/configuration.yaml
+following to your configuration.yaml file.
 
 notify:
   platform: pushbullet
@@ -32,7 +31,7 @@ REQUIREMENTS = ['pushbullet.py==0.7.1']
 
 
 def get_service(hass, config):
-    """ Get the pushbullet notification service. """
+    """ Get the PushBullet notification service. """
 
     if not validate_config(config,
                            {DOMAIN: [CONF_API_KEY]},

homeassistant/components/notify/pushover.py

@@ -1,18 +1,17 @@
 """
 homeassistant.components.notify.pushover
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Pushover platform for notify component.
 
 Configuration:
 
 To use the Pushover notifier you will need to add something like the following
-to your config/configuration.yaml
+to your configuration.yaml file.
 
 notify:
-    platform: pushover
-    api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
-    user_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+  platform: pushover
+  api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
+  user_key: ABCDEFGHJKLMNOPQRSTUVXYZ
 
 Variables:
 
@@ -33,7 +32,6 @@ https://home-assistant.io/images/favicon-192x192.png
 user_key
 *Required
 To retrieve this value log into your account at https://pushover.net
-
 """
 import logging
 

homeassistant/components/notify/slack.py

@@ -6,7 +6,7 @@ Slack platform for notify component.
 Configuration:
 
 To use the Slack notifier you will need to add something like the following
-to your config/configuration.yaml
+to your configuration.yaml file.
 
 notify:
     platform: slack

homeassistant/components/notify/smtp.py

@@ -1,13 +1,12 @@
 """
 homeassistant.components.notify.mail
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Mail notification service.
+Mail (SMTP) notification service.
 
 Configuration:
 
 To use the Mail notifier you will need to add something like the following
-to your config/configuration.yaml
+to your configuration.yaml file.
 
 notify:
   platform: mail
@@ -141,13 +140,19 @@ class MailNotificationService(BaseNotificationService):
         self.username = username
         self.password = password
         self.recipient = recipient
+        self.tries = 2
+        self.mail = None
+
+        self.connect()
+
+    def connect(self):
+        """ Connect/Authenticate to SMTP Server """
 
         self.mail = smtplib.SMTP(self._server, self._port)
         self.mail.ehlo_or_helo_if_needed()
         if self.starttls == 1:
             self.mail.starttls()
             self.mail.ehlo()
-
         self.mail.login(self.username, self.password)
 
     def send_message(self, message="", **kwargs):
@@ -161,4 +166,12 @@ class MailNotificationService(BaseNotificationService):
         msg['From'] = self._sender
         msg['X-Mailer'] = 'HomeAssistant'
 
-        self.mail.sendmail(self._sender, self.recipient, msg.as_string())
+        for _ in range(self.tries):
+            try:
+                self.mail.sendmail(self._sender, self.recipient,
+                                   msg.as_string())
+                break
+            except smtplib.SMTPException:
+                _LOGGER.warning('SMTPException sending mail: '
+                                'retrying connection')
+                self.connect()

homeassistant/components/notify/syslog.py

@@ -1,13 +1,12 @@
 """
 homeassistant.components.notify.syslog
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Syslog notification service.
 
 Configuration:
 
 To use the Syslog notifier you will need to add something like the following
-to your config/configuration.yaml
+to your configuration.yaml file.
 
 notify:
   platform: syslog

homeassistant/components/notify/xmpp.py

@@ -6,7 +6,7 @@ Jabber (XMPP) notification service.
 Configuration:
 
 To use the Jabber notifier you will need to add something like the following
-to your config/configuration.yaml
+to your configuration.yaml file.
 
 notify:
   platform: xmpp

homeassistant/components/recorder.py

@@ -256,7 +256,7 @@ class Recorder(threading.Thread):
         """ Query the database. """
         try:
             with self.conn, self.lock:
-                _LOGGER.info("Running query %s", sql_query)
+                _LOGGER.debug("Running query %s", sql_query)
 
                 cur = self.conn.cursor()
 

homeassistant/components/scene.py

@@ -33,7 +33,7 @@ ATTR_ACTIVE_REQUESTED = "active_requested"
 
 CONF_ENTITIES = "entities"
 
-SceneConfig = namedtuple('SceneConfig', ['name', 'states'])
+SceneConfig = namedtuple('SceneConfig', ['name', 'states', 'fuzzy_match'])
 
 
 def setup(hass, config):
@@ -71,6 +71,15 @@ def setup(hass, config):
 def _process_config(scene_config):
     """ Process passed in config into a format to work with. """
     name = scene_config.get('name')
+
+    fuzzy_match = scene_config.get('fuzzy_match')
+    if fuzzy_match:
+        # default to 1%
+        if isinstance(fuzzy_match, int):
+            fuzzy_match /= 100.0
+        else:
+            fuzzy_match = 0.01
+
     states = {}
     c_entities = dict(scene_config.get(CONF_ENTITIES, {}))
 
@@ -91,7 +100,7 @@ def _process_config(scene_config):
 
         states[entity_id.lower()] = State(entity_id, state, attributes)
 
-    return SceneConfig(name, states)
+    return SceneConfig(name, states, fuzzy_match)
 
 
 class Scene(ToggleEntity):
@@ -179,9 +188,31 @@ class Scene(ToggleEntity):
         state = self.scene_config.states.get(cur_state and cur_state.entity_id)
 
         return (cur_state is not None and state.state == cur_state.state and
-                all(value == cur_state.attributes.get(key)
+                all(self._compare_state_attribites(
+                    value, cur_state.attributes.get(key))
                     for key, value in state.attributes.items()))
 
+    def _fuzzy_attribute_compare(self, attr_a, attr_b):
+        """
+        Compare the attributes passed, use fuzzy logic if they are floats.
+        """
+
+        if not (isinstance(attr_a, float) and isinstance(attr_b, float)):
+            return False
+        diff = abs(attr_a - attr_b) / (abs(attr_a) + abs(attr_b))
+        return diff <= self.scene_config.fuzzy_match
+
+    def _compare_state_attribites(self, attr1, attr2):
+        """ Compare the attributes passed, using fuzzy logic if specified. """
+        if attr1 == attr2:
+            return True
+        if not self.scene_config.fuzzy_match:
+            return False
+        if isinstance(attr1, list):
+            return all(self._fuzzy_attribute_compare(a, b)
+                       for a, b in zip(attr1, attr2))
+        return self._fuzzy_attribute_compare(attr1, attr2)
+
     def _reproduce_state(self, states):
         """ Wraps reproduce state with Scence specific logic. """
         self.ignore_updates = True

homeassistant/components/scheduler/__init__.py

@@ -1,137 +0,0 @@
-"""
-homeassistant.components.scheduler
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-A component that will act as a scheduler and perform actions based
-on the events in the schedule.
-
-It will read a json object from schedule.json in the config dir
-and create a schedule based on it.
-Each schedule is a JSON with the keys id, name, description,
-entity_ids, and events.
-- days is an array with the weekday number (monday=0) that the schedule
-    is active
-- entity_ids an array with entity ids that the events in the schedule should
-    effect (can also be groups)
-- events is an array of objects that describe the different events that is
-    supported. Read in the events descriptions for more information.
-"""
-import logging
-import json
-
-from homeassistant import bootstrap
-from homeassistant.loader import get_component
-from homeassistant.const import ATTR_ENTITY_ID
-
-DOMAIN = 'scheduler'
-
-DEPENDENCIES = []
-
-_LOGGER = logging.getLogger(__name__)
-
-_SCHEDULE_FILE = 'schedule.json'
-
-
-def setup(hass, config):
-    """ Create the schedules. """
-
-    def setup_listener(schedule, event_data):
-        """ Creates the event listener based on event_data. """
-        event_type = event_data['type']
-        component = event_type
-
-        # if the event isn't part of a component
-        if event_type in ['time']:
-            component = 'scheduler.{}'.format(event_type)
-
-        elif not bootstrap.setup_component(hass, component, config):
-            _LOGGER.warn("Could setup event listener for %s", component)
-            return None
-
-        return get_component(component).create_event_listener(schedule,
-                                                              event_data)
-
-    def setup_schedule(schedule_data):
-        """ Setup a schedule based on the description. """
-
-        schedule = Schedule(schedule_data['id'],
-                            name=schedule_data['name'],
-                            description=schedule_data['description'],
-                            entity_ids=schedule_data['entity_ids'],
-                            days=schedule_data['days'])
-
-        for event_data in schedule_data['events']:
-            event_listener = setup_listener(schedule, event_data)
-
-            if event_listener:
-                schedule.add_event_listener(event_listener)
-
-        schedule.schedule(hass)
-        return True
-
-    with open(hass.config.path(_SCHEDULE_FILE)) as schedule_file:
-        schedule_descriptions = json.load(schedule_file)
-
-    for schedule_description in schedule_descriptions:
-        if not setup_schedule(schedule_description):
-            return False
-
-    return True
-
-
-class Schedule(object):
-    """ A Schedule """
-
-    # pylint: disable=too-many-arguments
-    def __init__(self, schedule_id, name=None, description=None,
-                 entity_ids=None, days=None):
-
-        self.schedule_id = schedule_id
-        self.name = name
-        self.description = description
-
-        self.entity_ids = entity_ids or []
-
-        self.days = days or [0, 1, 2, 3, 4, 5, 6]
-
-        self.__event_listeners = []
-
-    def add_event_listener(self, event_listener):
-        """ Add a event to the schedule. """
-        self.__event_listeners.append(event_listener)
-
-    def schedule(self, hass):
-        """ Schedule all the events in the schedule. """
-        for event in self.__event_listeners:
-            event.schedule(hass)
-
-
-class EventListener(object):
-    """ The base EventListener class that the schedule uses. """
-    def __init__(self, schedule):
-        self.my_schedule = schedule
-
-    def schedule(self, hass):
-        """ Schedule the event """
-        pass
-
-    def execute(self, hass):
-        """ execute the event """
-        pass
-
-
-# pylint: disable=too-few-public-methods
-class ServiceEventListener(EventListener):
-    """ A EventListener that calls a service when executed. """
-
-    def __init__(self, schdule, service):
-        EventListener.__init__(self, schdule)
-
-        (self.domain, self.service) = service.split('.')
-
-    def execute(self, hass):
-        """ Call the service. """
-        data = {ATTR_ENTITY_ID: self.my_schedule.entity_ids}
-        hass.services.call(self.domain, self.service, data)
-
-        # Reschedule for next day
-        self.schedule(hass)

homeassistant/components/scheduler/time.py

@@ -1,70 +0,0 @@
-"""
-homeassistant.components.scheduler.time
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-An event in the scheduler component that will call the service
-every specified day at the time specified.
-A time event need to have the type 'time', which service to call and at
-which time.
-
-{
-    "type": "time",
-    "service": "switch.turn_off",
-    "time": "22:00:00"
-}
-
-"""
-from datetime import timedelta
-import logging
-
-import homeassistant.util.dt as dt_util
-from homeassistant.helpers.event import track_point_in_time
-from homeassistant.components.scheduler import ServiceEventListener
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def create_event_listener(schedule, event_listener_data):
-    """ Create a TimeEvent based on the description. """
-
-    service = event_listener_data['service']
-    (hour, minute, second) = [int(x) for x in
-                              event_listener_data['time'].split(':')]
-
-    return TimeEventListener(schedule, service, hour, minute, second)
-
-
-# pylint: disable=too-few-public-methods
-class TimeEventListener(ServiceEventListener):
-    """ The time event that the scheduler uses. """
-
-    # pylint: disable=too-many-arguments
-    def __init__(self, schedule, service, hour, minute, second):
-        ServiceEventListener.__init__(self, schedule, service)
-
-        self.hour = hour
-        self.minute = minute
-        self.second = second
-
-    def schedule(self, hass):
-        """ Schedule this event so that it will be called. """
-
-        next_time = dt_util.now().replace(
-            hour=self.hour, minute=self.minute, second=self.second)
-
-        # Calculate the next time the event should be executed.
-        # That is the next day that the schedule is configured to run
-        while next_time < dt_util.now() or \
-                next_time.weekday() not in self.my_schedule.days:
-
-            next_time = next_time + timedelta(days=1)
-
-        # pylint: disable=unused-argument
-        def execute(now):
-            """ Call the execute method """
-            self.execute(hass)
-
-        track_point_in_time(hass, execute, next_time)
-
-        _LOGGER.info(
-            'TimeEventListener scheduled for %s, will call service %s.%s',
-            next_time, self.domain, self.service)

homeassistant/components/script.py

@@ -1,7 +1,7 @@
 """
 homeassistant.components.script
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
+entity_id
 Scripts are a sequence of actions that can be triggered manually
 by the user or automatically based upon automation events, etc.
 """
@@ -22,7 +22,10 @@ CONF_ALIAS = "alias"
 CONF_SERVICE = "execute_service"
 CONF_SERVICE_DATA = "service_data"
 CONF_SEQUENCE = "sequence"
+CONF_EVENT = "event"
+CONF_EVENT_DATA = "event_data"
 CONF_DELAY = "delay"
+ATTR_ENTITY_ID = "entity_id"
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,15 +44,22 @@ def setup(hass, config):
         hass.services.register(DOMAIN, name, script)
         scripts.append(script)
 
+    def _get_entities(service):
+        """  Make sure that we always get a list of entities """
+        if isinstance(service.data[ATTR_ENTITY_ID], list):
+            return service.data[ATTR_ENTITY_ID]
+        else:
+            return [service.data[ATTR_ENTITY_ID]]
+
     def turn_on(service):
         """ Calls a script. """
-        for entity_id in service.data['entity_id']:
+        for entity_id in _get_entities(service):
             domain, service = split_entity_id(entity_id)
             hass.services.call(domain, service, {})
 
     def turn_off(service):
         """ Cancels a script. """
-        for entity_id in service.data['entity_id']:
+        for entity_id in _get_entities(service):
             for script in scripts:
                 if script.entity_id == entity_id:
                     script.cancel()
@@ -109,6 +119,8 @@ class Script(object):
         for action in self.actions:
             if CONF_SERVICE in action:
                 self._call_service(action)
+            elif CONF_EVENT in action:
+                self._fire_event(action)
             elif CONF_DELAY in action:
                 delay = timedelta(**action[CONF_DELAY])
                 point_in_time = date_util.now() + delay
@@ -140,3 +152,10 @@ class Script(object):
         domain, service = split_entity_id(action[CONF_SERVICE])
         data = action.get(CONF_SERVICE_DATA, {})
         self.hass.services.call(domain, service, data)
+
+    def _fire_event(self, action):
+        """ Fires an event. """
+        self.last_action = action.get(CONF_ALIAS, action[CONF_EVENT])
+        _LOGGER.info("Executing script %s step %s", self.alias,
+                     self.last_action)
+        self.hass.bus.fire(action[CONF_EVENT], action.get(CONF_EVENT_DATA))

homeassistant/components/sensor/arduino.py

@@ -6,6 +6,9 @@ supported.
 
 Configuration:
 
+To use the arduino sensor you will need to add something like the following
+to your configuration.yaml file.
+
 sensor:
   platform: arduino
   pins:
@@ -46,7 +49,7 @@ _LOGGER = logging.getLogger(__name__)
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """ Sets up the Arduino platform. """
 
-    # Verify that Arduino board is present
+    # Verify that the Arduino board is present
     if arduino.BOARD is None:
         _LOGGER.error('A connection has not been made to the Arduino board.')
         return False

homeassistant/components/sensor/arest.py

@@ -0,0 +1,150 @@
+"""
+homeassistant.components.sensor.arest
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The arest sensor will consume an exposed aREST API of a device.
+
+Configuration:
+
+To use the arest sensor you will need to add something like the following
+to your configuration.yaml file.
+
+sensor:
+  platform: arest
+  resource: http://IP_ADDRESS
+  monitored_variables:
+    - name: temperature
+      unit: '°C'
+    - name: humidity
+      unit: '%'
+
+Variables:
+
+resource:
+*Required
+IP address of the device that is exposing an aREST API.
+
+These are the variables for the monitored_variables array:
+
+name
+*Required
+The name of the variable you wish to monitor.
+
+unit
+*Optional
+Defines the units of measurement of the sensor, if any.
+
+Details for the API: http://arest.io
+
+Format of a default JSON response by aREST:
+{
+   "variables":{
+      "temperature":21,
+      "humidity":89
+   },
+   "id":"device008",
+   "name":"Bedroom",
+   "connected":true
+}
+"""
+import logging
+from requests import get, exceptions
+from datetime import timedelta
+
+from homeassistant.util import Throttle
+from homeassistant.helpers.entity import Entity
+
+_LOGGER = logging.getLogger(__name__)
+
+# Return cached results if last scan was less then this time ago
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """ Get the aREST sensor. """
+
+    resource = config.get('resource', None)
+
+    try:
+        response = get(resource, timeout=10)
+    except exceptions.MissingSchema:
+        _LOGGER.error("Missing resource or schema in configuration. "
+                      "Add http:// to your URL.")
+        return False
+    except exceptions.ConnectionError:
+        _LOGGER.error("No route to device. "
+                      "Please check the IP address in the configuration file.")
+        return False
+
+    rest = ArestData(resource)
+
+    dev = []
+    for variable in config['monitored_variables']:
+        if 'unit' not in variable:
+            variable['unit'] = ' '
+        if variable['name'] not in response.json()['variables']:
+            _LOGGER.error('Variable: "%s" does not exist', variable['name'])
+        else:
+            dev.append(ArestSensor(rest,
+                                   response.json()['name'],
+                                   variable['name'],
+                                   variable['unit']))
+
+    add_devices(dev)
+
+
+class ArestSensor(Entity):
+    """ Implements an aREST sensor. """
+
+    def __init__(self, rest, location, variable, unit_of_measurement):
+        self.rest = rest
+        self._name = '{} {}'.format(location.title(), variable.title())
+        self._variable = variable
+        self._state = 'n/a'
+        self._unit_of_measurement = unit_of_measurement
+        self.update()
+
+    @property
+    def name(self):
+        """ The name of the sensor. """
+        return self._name
+
+    @property
+    def unit_of_measurement(self):
+        """ Unit the value is expressed in. """
+        return self._unit_of_measurement
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        return self._state
+
+    def update(self):
+        """ Gets the latest data from aREST API and updates the state. """
+        self.rest.update()
+        values = self.rest.data
+
+        if 'error' in values:
+            self._state = values['error']
+        else:
+            self._state = values[self._variable]
+
+
+# pylint: disable=too-few-public-methods
+class ArestData(object):
+    """ Class for handling the data retrieval. """
+
+    def __init__(self, resource):
+        self.resource = resource
+        self.data = dict()
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """ Gets the latest data from aREST device. """
+        try:
+            response = get(self.resource, timeout=10)
+            if 'error' in self.data:
+                del self.data['error']
+            self.data = response.json()['variables']
+        except exceptions.ConnectionError:
+            _LOGGER.error("No route to device. Is device offline?")
+            self.data['error'] = 'n/a'

homeassistant/components/sensor/bitcoin.py

@@ -1,7 +1,6 @@
 """
 homeassistant.components.sensor.bitcoin
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Bitcoin information service that uses blockchain.info and its online wallet.
 
 Configuration:
@@ -12,7 +11,7 @@ check 'Enable Api Access'. You will get an email message from blockchain.info
 where you must authorize the API access.
 
 To use the Bitcoin sensor you will need to add something like the following
-to your config/configuration.yaml
+to your configuration.yaml file.
 
 sensor:
   platform: bitcoin

homeassistant/components/sensor/command_sensor.py

@@ -0,0 +1,139 @@
+"""
+homeassistant.components.sensor.command_sensor
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Allows to configure custom shell commands to turn a value for a sensor.
+
+Configuration:
+
+To use the command_line sensor you will need to add something like the
+following to your configuration.yaml file.
+
+sensor:
+  platform: command_sensor
+  name: "Command sensor"
+  command: sensor_command
+  unit_of_measurement: "°C"
+  correction_factor: 0.0001
+  decimal_places: 0
+
+Variables:
+
+name
+*Optional
+Name of the command sensor.
+
+command
+*Required
+The action to take to get the value.
+
+unit_of_measurement
+*Optional
+Defines the units of measurement of the sensor, if any.
+
+correction_factor
+*Optional
+A float value to do some basic calculations.
+
+decimal_places
+*Optional
+Number of decimal places of the value. Default is 0.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/sensor.command_sensor.html
+"""
+import logging
+import subprocess
+from datetime import timedelta
+
+from homeassistant.helpers.entity import Entity
+from homeassistant.util import Throttle
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = "Command Sensor"
+
+# Return cached results if last scan was less then this time ago
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices_callback, discovery_info=None):
+    """ Add the Command Sensor. """
+
+    if config.get('command') is None:
+        _LOGGER.error('Missing required variable: "command"')
+        return False
+
+    data = CommandSensorData(config.get('command'))
+
+    add_devices_callback([CommandSensor(
+        data,
+        config.get('name', DEFAULT_NAME),
+        config.get('unit_of_measurement'),
+        config.get('correction_factor', 1.0),
+        config.get('decimal_places', 0)
+    )])
+
+
+# pylint: disable=too-many-arguments
+class CommandSensor(Entity):
+    """ Represents a sensor that is returning a value of a shell commands. """
+    def __init__(self, data, name, unit_of_measurement, corr_factor,
+                 decimal_places):
+        self.data = data
+        self._name = name
+        self._state = False
+        self._unit_of_measurement = unit_of_measurement
+        self._corr_factor = float(corr_factor)
+        self._decimal_places = decimal_places
+        self.update()
+
+    @property
+    def name(self):
+        """ The name of the sensor. """
+        return self._name
+
+    @property
+    def unit_of_measurement(self):
+        """ Unit the value is expressed in. """
+        return self._unit_of_measurement
+
+    @property
+    def state(self):
+        """ Returns the state of the device. """
+        return self._state
+
+    def update(self):
+        """ Gets the latest data and updates the state. """
+        self.data.update()
+        value = self.data.value
+
+        try:
+            if value is not None:
+                if self._corr_factor is not None:
+                    self._state = round((float(value) * self._corr_factor),
+                                        self._decimal_places)
+                else:
+                    self._state = value
+        except ValueError:
+            self._state = value
+
+
+# pylint: disable=too-few-public-methods
+class CommandSensorData(object):
+    """ Class for handling the data retrieval. """
+
+    def __init__(self, command):
+        self.command = command
+        self.value = None
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """ Gets the latest data with a shell command. """
+        _LOGGER.info('Running command: %s', self.command)
+
+        try:
+            return_value = subprocess.check_output(self.command.split())
+            self.value = return_value.strip().decode('utf-8')
+        except subprocess.CalledProcessError:
+            _LOGGER.error('Command failed: %s', self.command)