Merge pull request #4988 from home-assistant/release-0-35-1

0.35.1

.coveragerc

@@ -122,6 +122,8 @@ omit =
     homeassistant/components/alarm_control_panel/simplisafe.py
     homeassistant/components/binary_sensor/arest.py
     homeassistant/components/binary_sensor/concord232.py
+    homeassistant/components/binary_sensor/flic.py
+    homeassistant/components/binary_sensor/hikvision.py
     homeassistant/components/binary_sensor/rest.py
     homeassistant/components/browser.py
     homeassistant/components/camera/amcrest.py
@@ -165,6 +167,7 @@ omit =
     homeassistant/components/discovery.py
     homeassistant/components/downloader.py
     homeassistant/components/emoncms_history.py
+    homeassistant/components/emulated_hue/upnp.py
     homeassistant/components/fan/mqtt.py
     homeassistant/components/feedreader.py
     homeassistant/components/foursquare.py
@@ -183,6 +186,7 @@ omit =
     homeassistant/components/light/x10.py
     homeassistant/components/light/yeelight.py
     homeassistant/components/lirc.py
+    homeassistant/components/media_player/aquostv.py
     homeassistant/components/media_player/braviatv.py
     homeassistant/components/media_player/cast.py
     homeassistant/components/media_player/cmus.py
@@ -210,6 +214,7 @@ omit =
     homeassistant/components/media_player/snapcast.py
     homeassistant/components/media_player/sonos.py
     homeassistant/components/media_player/squeezebox.py
+    homeassistant/components/media_player/vlc.py
     homeassistant/components/media_player/yamaha.py
     homeassistant/components/notify/aws_lambda.py
     homeassistant/components/notify/aws_sns.py
@@ -248,6 +253,7 @@ omit =
     homeassistant/components/sensor/bbox.py
     homeassistant/components/sensor/bitcoin.py
     homeassistant/components/sensor/bom.py
+    homeassistant/components/sensor/broadlink.py
     homeassistant/components/sensor/coinmarketcap.py
     homeassistant/components/sensor/cpuspeed.py
     homeassistant/components/sensor/cups.py
@@ -280,6 +286,7 @@ omit =
     homeassistant/components/sensor/mhz19.py
     homeassistant/components/sensor/miflora.py
     homeassistant/components/sensor/mqtt_room.py
+    homeassistant/components/sensor/netdata.py
     homeassistant/components/sensor/neurio_energy.py
     homeassistant/components/sensor/nut.py
     homeassistant/components/sensor/nzbget.py
@@ -292,6 +299,7 @@ omit =
     homeassistant/components/sensor/pvoutput.py
     homeassistant/components/sensor/sabnzbd.py
     homeassistant/components/sensor/scrape.py
+    homeassistant/components/sensor/sensehat.py
     homeassistant/components/sensor/serial_pm.py
     homeassistant/components/sensor/snmp.py
     homeassistant/components/sensor/sonarr.py
@@ -313,10 +321,12 @@ omit =
     homeassistant/components/sensor/waqi.py
     homeassistant/components/sensor/xbox_live.py
     homeassistant/components/sensor/yweather.py
-    homeassistant/components/sensor/waqi.py
+    homeassistant/components/sensor/zamg.py
     homeassistant/components/switch/acer_projector.py
     homeassistant/components/switch/anel_pwrctrl.py
     homeassistant/components/switch/arest.py
+    homeassistant/components/switch/broadlink.py
+    homeassistant/components/switch/digitalloggers.py
     homeassistant/components/switch/dlink.py
     homeassistant/components/switch/edimax.py
     homeassistant/components/switch/hikvisioncam.py

CONTRIBUTING.md

@@ -1,13 +1,14 @@
 # Contributing to Home Assistant
 
-Everybody is invited and welcome to contribute to Home Assistant. There is a lot to do...if you are not a developer perhaps you would like to help with the documentation on [home-assistant.io](https://home-assistant.io/)? If you are a developer and have devices in your home which aren't working with Home Assistant yet, why not spent a couple of hours and help to integrate them? 
+Everybody is invited and welcome to contribute to Home Assistant. There is a lot to do...if you are not a developer perhaps you would like to help with the documentation on [home-assistant.io](https://home-assistant.io/)? If you are a developer and have devices in your home which aren't working with Home Assistant yet, why not spent a couple of hours and help to integrate them?
 
 The process is straight-forward.
 
+ - Read [How to get faster PR reviews](https://github.com/kubernetes/kubernetes/blob/master/docs/devel/faster_reviews.md) by Kubernetes (but skip step 0)
  - Fork the Home Assistant [git repository](https://github.com/home-assistant/home-assistant).
  - Write the code for your device, notification service, sensor, or IoT thing.
  - Ensure tests work.
  - Create a Pull Request against the [**dev**](https://github.com/home-assistant/home-assistant/tree/dev) branch of Home Assistant.
 
-Still interested? Then you should take a peak at the [developer documentation](https://home-assistant.io/developers/) to get more details. 
+Still interested? Then you should take a peak at the [developer documentation](https://home-assistant.io/developers/) to get more details.
 

Dockerfile

@@ -8,9 +8,12 @@ WORKDIR /usr/src/app
 
 RUN pip3 install --no-cache-dir colorlog cython
 
-# For the nmap tracker, bluetooth tracker, Z-Wave
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends nmap net-tools cython3 libudev-dev sudo libglib2.0-dev bluetooth libbluetooth-dev && \
+# For the nmap tracker, bluetooth tracker, Z-Wave, tellstick
+RUN echo "deb http://download.telldus.com/debian/ stable main" >> /etc/apt/sources.list.d/telldus.list && \
+    wget -qO - http://download.telldus.se/debian/telldus-public.key | apt-key add - && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends nmap net-tools cython3 libudev-dev sudo libglib2.0-dev bluetooth libbluetooth-dev \
+            libtelldus-core2 && \
     apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
 COPY script/build_python_openzwave script/build_python_openzwave

homeassistant/bootstrap.py

@@ -20,6 +20,7 @@ import homeassistant.loader as loader
 import homeassistant.util.package as pkg_util
 from homeassistant.util.async import (
     run_coroutine_threadsafe, run_callback_threadsafe)
+from homeassistant.util.logging import AsyncHandler
 from homeassistant.util.yaml import clear_secret_cache
 from homeassistant.const import EVENT_COMPONENT_LOADED, PLATFORM_FORMAT
 from homeassistant.exceptions import HomeAssistantError
@@ -528,6 +529,10 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
     except ImportError:
         pass
 
+    # AsyncHandler allready exists?
+    if hass.data.get(core.DATA_ASYNCHANDLER):
+        return
+
     # Log errors to a file if we have write access to file or config dir
     err_log_path = hass.config.path(ERROR_LOG_FILENAME)
     err_path_exists = os.path.isfile(err_log_path)
@@ -548,8 +553,12 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
         err_handler.setFormatter(
             logging.Formatter('%(asctime)s %(name)s: %(message)s',
                               datefmt='%y-%m-%d %H:%M:%S'))
+
+        async_handler = AsyncHandler(hass.loop, err_handler)
+        hass.data[core.DATA_ASYNCHANDLER] = async_handler
+
         logger = logging.getLogger('')
-        logger.addHandler(err_handler)
+        logger.addHandler(async_handler)
         logger.setLevel(logging.INFO)
 
     else:

homeassistant/components/alarm_control_panel/__init__.py

@@ -4,6 +4,7 @@ Component to interface with an alarm control panel.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel/
 """
+import asyncio
 import logging
 import os
 
@@ -42,36 +43,6 @@ ALARM_SERVICE_SCHEMA = vol.Schema({
 })
 
 
-def setup(hass, config):
-    """Track states and offer events for sensors."""
-    component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
-
-    component.setup(config)
-
-    def alarm_service_handler(service):
-        """Map services to methods on Alarm."""
-        target_alarms = component.extract_from_service(service)
-
-        code = service.data.get(ATTR_CODE)
-
-        method = SERVICE_TO_METHOD[service.service]
-
-        for alarm in target_alarms:
-            getattr(alarm, method)(code)
-            if alarm.should_poll:
-                alarm.update_ha_state(True)
-
-    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),
-                               schema=ALARM_SERVICE_SCHEMA)
-    return True
-
-
 def alarm_disarm(hass, code=None, entity_id=None):
     """Send the alarm the command for disarm."""
     data = {}
@@ -116,6 +87,53 @@ def alarm_trigger(hass, code=None, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_ALARM_TRIGGER, data)
 
 
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Track states and offer events for sensors."""
+    component = EntityComponent(
+        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
+
+    yield from component.async_setup(config)
+
+    @asyncio.coroutine
+    def async_alarm_service_handler(service):
+        """Map services to methods on Alarm."""
+        target_alarms = component.async_extract_from_service(service)
+
+        code = service.data.get(ATTR_CODE)
+
+        method = "async_{}".format(SERVICE_TO_METHOD[service.service])
+
+        for alarm in target_alarms:
+            yield from getattr(alarm, method)(code)
+
+        update_tasks = []
+        for alarm in target_alarms:
+            if not alarm.should_poll:
+                continue
+
+            update_coro = hass.loop.create_task(
+                alarm.async_update_ha_state(True))
+            if hasattr(alarm, 'async_update'):
+                update_tasks.append(hass.loop.create_task(update_coro))
+            else:
+                yield from update_coro
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)
+
+    descriptions = yield from hass.loop.run_in_executor(
+        None, load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml'))
+
+    for service in SERVICE_TO_METHOD:
+        hass.services.async_register(
+            DOMAIN, service, async_alarm_service_handler,
+            descriptions.get(service), schema=ALARM_SERVICE_SCHEMA)
+
+    return True
+
+
 # pylint: disable=no-self-use
 class AlarmControlPanel(Entity):
     """An abstract class for alarm control devices."""
@@ -134,18 +152,42 @@ class AlarmControlPanel(Entity):
         """Send disarm command."""
         raise NotImplementedError()
 
+    @asyncio.coroutine
+    def async_alarm_disarm(self, code=None):
+        """Send disarm command."""
+        yield from self.hass.loop.run_in_executor(
+            None, self.alarm_disarm, code)
+
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
         raise NotImplementedError()
 
+    @asyncio.coroutine
+    def async_alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        yield from self.hass.loop.run_in_executor(
+            None, self.alarm_arm_home, code)
+
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         raise NotImplementedError()
 
+    @asyncio.coroutine
+    def async_alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        yield from self.hass.loop.run_in_executor(
+            None, self.alarm_arm_away, code)
+
     def alarm_trigger(self, code=None):
         """Send alarm trigger command."""
         raise NotImplementedError()
 
+    @asyncio.coroutine
+    def async_alarm_trigger(self, code=None):
+        """Send alarm trigger command."""
+        yield from self.hass.loop.run_in_executor(
+            None, self.alarm_trigger, code)
+
     @property
     def state_attributes(self):
         """Return the state attributes."""

homeassistant/components/alarm_control_panel/alarmdotcom.py

@@ -56,11 +56,6 @@ class AlarmDotCom(alarm.AlarmControlPanel):
         self._password = password
         self._state = STATE_UNKNOWN
 
-    @property
-    def should_poll(self):
-        """No polling needed."""
-        return True
-
     def update(self):
         """Fetch the latest state."""
         self._state = self._alarm.state

homeassistant/components/alarm_control_panel/concord232.py

@@ -71,11 +71,6 @@ class Concord232Alarm(alarm.AlarmControlPanel):
         self._alarm.last_partition_update = datetime.datetime.now()
         self.update()
 
-    @property
-    def should_poll(self):
-        """Polling needed."""
-        return True
-
     @property
     def name(self):
         """Return the name of the device."""
@@ -126,7 +121,3 @@ class Concord232Alarm(alarm.AlarmControlPanel):
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         self._alarm.arm('auto')
-
-    def alarm_trigger(self, code=None):
-        """Alarm trigger command."""
-        raise NotImplementedError()

homeassistant/components/alarm_control_panel/envisalink.py

@@ -97,7 +97,7 @@ class EnvisalinkAlarm(EnvisalinkDevice, alarm.AlarmControlPanel):
     def _update_callback(self, partition):
         """Update HA state, if needed."""
         if partition is None or int(partition) == self._partition_number:
-            self.hass.async_add_job(self.update_ha_state)
+            self.hass.async_add_job(self.async_update_ha_state())
 
     @property
     def code_format(self):

homeassistant/components/alarm_control_panel/manual.py

@@ -116,7 +116,7 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
         self._state = STATE_ALARM_DISARMED
         self._state_ts = dt_util.utcnow()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
@@ -125,7 +125,7 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
         self._state = STATE_ALARM_ARMED_HOME
         self._state_ts = dt_util.utcnow()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
         if self._pending_time:
             track_point_in_time(
@@ -139,7 +139,7 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
         self._state = STATE_ALARM_ARMED_AWAY
         self._state_ts = dt_util.utcnow()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
         if self._pending_time:
             track_point_in_time(
@@ -151,7 +151,7 @@ class ManualAlarm(alarm.AlarmControlPanel):
         self._pre_trigger_state = self._state
         self._state = STATE_ALARM_TRIGGERED
         self._state_ts = dt_util.utcnow()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
         if self._trigger_time:
             track_point_in_time(

homeassistant/components/alarm_control_panel/nx584.py

@@ -62,11 +62,6 @@ class NX584Alarm(alarm.AlarmControlPanel):
         self._alarm.list_zones()
         self._state = STATE_UNKNOWN
 
-    @property
-    def should_poll(self):
-        """Polling needed."""
-        return True
-
     @property
     def name(self):
         """Return the name of the device."""
@@ -122,7 +117,3 @@ class NX584Alarm(alarm.AlarmControlPanel):
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         self._alarm.arm('exit')
-
-    def alarm_trigger(self, code=None):
-        """Alarm trigger command."""
-        raise NotImplementedError()

homeassistant/components/alarm_control_panel/simplisafe.py

@@ -61,11 +61,6 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
         else:
             self._state = STATE_UNKNOWN
 
-    @property
-    def should_poll(self):
-        """Poll the SimpliSafe API."""
-        return True
-
     @property
     def name(self):
         """Return the name of the device."""
@@ -104,7 +99,6 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
             return
         self.simplisafe.set_state('off')
         _LOGGER.info('SimpliSafe alarm disarming')
-        self.update()
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
@@ -112,7 +106,6 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
             return
         self.simplisafe.set_state('home')
         _LOGGER.info('SimpliSafe alarm arming home')
-        self.update()
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
@@ -120,7 +113,6 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
             return
         self.simplisafe.set_state('away')
         _LOGGER.info('SimpliSafe alarm arming away')
-        self.update()
 
     def _validate_code(self, code, state):
         """Validate given code."""

homeassistant/components/alarm_control_panel/verisure.py

@@ -84,18 +84,15 @@ class VerisureAlarm(alarm.AlarmControlPanel):
         hub.my_pages.alarm.set(code, 'DISARMED')
         _LOGGER.info('verisure alarm disarming')
         hub.my_pages.alarm.wait_while_pending()
-        self.update()
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
         hub.my_pages.alarm.set(code, 'ARMED_HOME')
         _LOGGER.info('verisure alarm arming home')
         hub.my_pages.alarm.wait_while_pending()
-        self.update()
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         hub.my_pages.alarm.set(code, 'ARMED_AWAY')
         _LOGGER.info('verisure alarm arming away')
         hub.my_pages.alarm.wait_while_pending()
-        self.update()

homeassistant/components/automation/__init__.py

@@ -166,7 +166,9 @@ def async_setup(hass, config):
         for entity in component.async_extract_from_service(service_call):
             tasks.append(entity.async_trigger(
                 service_call.data.get(ATTR_VARIABLES), True))
-        yield from asyncio.wait(tasks, loop=hass.loop)
+
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     @asyncio.coroutine
     def turn_onoff_service_handler(service_call):
@@ -175,7 +177,9 @@ def async_setup(hass, config):
         method = 'async_{}'.format(service_call.service)
         for entity in component.async_extract_from_service(service_call):
             tasks.append(getattr(entity, method)())
-        yield from asyncio.wait(tasks, loop=hass.loop)
+
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     @asyncio.coroutine
     def toggle_service_handler(service_call):
@@ -186,7 +190,9 @@ def async_setup(hass, config):
                 tasks.append(entity.async_turn_off())
             else:
                 tasks.append(entity.async_turn_on())
-        yield from asyncio.wait(tasks, loop=hass.loop)
+
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     @asyncio.coroutine
     def reload_service_handler(service_call):

homeassistant/components/automation/mqtt.py

@@ -4,6 +4,8 @@ Offer MQTT listening automation rules.
 For more details about this automation rule, please refer to the documentation
 at https://home-assistant.io/components/automation/#mqtt-trigger
 """
+import json
+
 import voluptuous as vol
 
 from homeassistant.core import callback
@@ -31,13 +33,20 @@ def async_trigger(hass, config, action):
     def mqtt_automation_listener(msg_topic, msg_payload, qos):
         """Listen for MQTT messages."""
         if payload is None or payload == msg_payload:
+            data = {
+                'platform': 'mqtt',
+                'topic': msg_topic,
+                'payload': msg_payload,
+                'qos': qos,
+            }
+
+            try:
+                data['payload_json'] = json.loads(msg_payload)
+            except ValueError:
+                pass
+
             hass.async_run_job(action, {
-                'trigger': {
-                    'platform': 'mqtt',
-                    'topic': msg_topic,
-                    'payload': msg_payload,
-                    'qos': qos,
-                }
+                'trigger': data
             })
 
     return mqtt.async_subscribe(hass, topic, mqtt_automation_listener)

homeassistant/components/automation/state.py

@@ -64,10 +64,19 @@ def async_trigger(hass, config, action):
             call_action()
             return
 
+        @callback
+        def clear_listener():
+            """Clear all unsub listener."""
+            nonlocal async_remove_state_for_cancel
+            nonlocal async_remove_state_for_listener
+            async_remove_state_for_listener = None
+            async_remove_state_for_cancel = None
+
         @callback
         def state_for_listener(now):
             """Fire on state changes after a delay and calls action."""
             async_remove_state_for_cancel()
+            clear_listener()
             call_action()
 
         @callback
@@ -77,6 +86,7 @@ def async_trigger(hass, config, action):
                 return
             async_remove_state_for_listener()
             async_remove_state_for_cancel()
+            clear_listener()
 
         async_remove_state_for_listener = async_track_point_in_utc_time(
             hass, state_for_listener, dt_util.utcnow() + time_delta)

homeassistant/components/binary_sensor/enocean.py

@@ -20,7 +20,7 @@ DEPENDENCIES = ['enocean']
 DEFAULT_NAME = 'EnOcean binary sensor'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_ID): cv.string,
+    vol.Required(CONF_ID): vol.All(cv.ensure_list, [vol.Coerce(int)]),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_SENSOR_CLASS, default=None): SENSOR_CLASSES_SCHEMA,
 })

homeassistant/components/binary_sensor/flic.py

@@ -0,0 +1,257 @@
+"""Contains functionality to use flic buttons as a binary sensor."""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import (
+    CONF_HOST, CONF_PORT, CONF_DISCOVERY, CONF_TIMEOUT,
+    EVENT_HOMEASSISTANT_STOP)
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.util.async import run_callback_threadsafe
+
+
+REQUIREMENTS = ['https://github.com/soldag/pyflic/archive/0.4.zip#pyflic==0.4']
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_TIMEOUT = 3
+
+CLICK_TYPE_SINGLE = "single"
+CLICK_TYPE_DOUBLE = "double"
+CLICK_TYPE_HOLD = "hold"
+CLICK_TYPES = [CLICK_TYPE_SINGLE, CLICK_TYPE_DOUBLE, CLICK_TYPE_HOLD]
+
+CONF_IGNORED_CLICK_TYPES = "ignored_click_types"
+
+EVENT_NAME = "flic_click"
+EVENT_DATA_NAME = "button_name"
+EVENT_DATA_ADDRESS = "button_address"
+EVENT_DATA_TYPE = "click_type"
+EVENT_DATA_QUEUED_TIME = "queued_time"
+
+# Validation of the user's configuration
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_HOST, default='localhost'): cv.string,
+    vol.Optional(CONF_PORT, default=5551): cv.port,
+    vol.Optional(CONF_DISCOVERY, default=True): cv.boolean,
+    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
+    vol.Optional(CONF_IGNORED_CLICK_TYPES): vol.All(cv.ensure_list,
+                                                    [vol.In(CLICK_TYPES)])
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_entities,
+                         discovery_info=None):
+    """Setup the flic platform."""
+    import pyflic
+
+    # Initialize flic client responsible for
+    # connecting to buttons and retrieving events
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    discovery = config.get(CONF_DISCOVERY)
+
+    try:
+        client = pyflic.FlicClient(host, port)
+    except ConnectionRefusedError:
+        _LOGGER.error("Failed to connect to flic server.")
+        return
+
+    def new_button_callback(address):
+        """Setup newly verified button as device in home assistant."""
+        hass.add_job(async_setup_button(hass, config, async_add_entities,
+                                        client, address))
+
+    client.on_new_verified_button = new_button_callback
+    if discovery:
+        start_scanning(hass, config, async_add_entities, client)
+
+    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP,
+                               lambda event: client.close())
+    hass.loop.run_in_executor(None, client.handle_events)
+
+    # Get addresses of already verified buttons
+    addresses = yield from async_get_verified_addresses(client)
+    if addresses:
+        for address in addresses:
+            yield from async_setup_button(hass, config, async_add_entities,
+                                          client, address)
+
+
+def start_scanning(hass, config, async_add_entities, client):
+    """Start a new flic client for scanning & connceting to new buttons."""
+    import pyflic
+
+    scan_wizard = pyflic.ScanWizard()
+
+    def scan_completed_callback(scan_wizard, result, address, name):
+        """Restart scan wizard to constantly check for new buttons."""
+        if result == pyflic.ScanWizardResult.WizardSuccess:
+            _LOGGER.info("Found new button (%s)", address)
+        elif result != pyflic.ScanWizardResult.WizardFailedTimeout:
+            _LOGGER.warning("Failed to connect to button (%s). Reason: %s",
+                            address, result)
+
+        # Restart scan wizard
+        start_scanning(hass, config, async_add_entities, client)
+
+    scan_wizard.on_completed = scan_completed_callback
+    client.add_scan_wizard(scan_wizard)
+
+
+@asyncio.coroutine
+def async_setup_button(hass, config, async_add_entities, client, address):
+    """Setup single button device."""
+    timeout = config.get(CONF_TIMEOUT)
+    ignored_click_types = config.get(CONF_IGNORED_CLICK_TYPES)
+    button = FlicButton(hass, client, address, timeout, ignored_click_types)
+    _LOGGER.info("Connected to button (%s)", address)
+
+    yield from async_add_entities([button])
+
+
+@asyncio.coroutine
+def async_get_verified_addresses(client):
+    """Retrieve addresses of verified buttons."""
+    future = asyncio.Future()
+    loop = asyncio.get_event_loop()
+
+    def get_info_callback(items):
+        """Set the addressed of connected buttons as result of the future."""
+        addresses = items["bd_addr_of_verified_buttons"]
+        run_callback_threadsafe(loop, future.set_result, addresses)
+    client.get_info(get_info_callback)
+
+    return future
+
+
+class FlicButton(BinarySensorDevice):
+    """Representation of a flic button."""
+
+    def __init__(self, hass, client, address, timeout, ignored_click_types):
+        """Initialize the flic button."""
+        import pyflic
+
+        self._hass = hass
+        self._address = address
+        self._timeout = timeout
+        self._is_down = False
+        self._ignored_click_types = ignored_click_types or []
+        self._hass_click_types = {
+            pyflic.ClickType.ButtonClick: CLICK_TYPE_SINGLE,
+            pyflic.ClickType.ButtonSingleClick: CLICK_TYPE_SINGLE,
+            pyflic.ClickType.ButtonDoubleClick: CLICK_TYPE_DOUBLE,
+            pyflic.ClickType.ButtonHold: CLICK_TYPE_HOLD,
+        }
+
+        self._channel = self._create_channel()
+        client.add_connection_channel(self._channel)
+
+    def _create_channel(self):
+        """Create a new connection channel to the button."""
+        import pyflic
+
+        channel = pyflic.ButtonConnectionChannel(self._address)
+        channel.on_button_up_or_down = self._on_up_down
+
+        # If all types of clicks should be ignored, skip registering callbacks
+        if set(self._ignored_click_types) == set(CLICK_TYPES):
+            return channel
+
+        if CLICK_TYPE_DOUBLE in self._ignored_click_types:
+            # Listen to all but double click type events
+            channel.on_button_click_or_hold = self._on_click
+        elif CLICK_TYPE_HOLD in self._ignored_click_types:
+            # Listen to all but hold click type events
+            channel.on_button_single_or_double_click = self._on_click
+        else:
+            # Listen to all click type events
+            channel.on_button_single_or_double_click_or_hold = self._on_click
+
+        return channel
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return "flic_%s" % self.address.replace(":", "")
+
+    @property
+    def address(self):
+        """Return the bluetooth address of the device."""
+        return self._address
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._is_down
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def state_attributes(self):
+        """Return device specific state attributes."""
+        attr = super(FlicButton, self).state_attributes
+        attr["address"] = self.address
+
+        return attr
+
+    def _queued_event_check(self, click_type, time_diff):
+        """Generate a log message and returns true if timeout exceeded."""
+        time_string = "{:d} {}".format(
+            time_diff, "second" if time_diff == 1 else "seconds")
+
+        if time_diff > self._timeout:
+            _LOGGER.warning(
+                "Queued %s dropped for %s. Time in queue was %s.",
+                click_type, self.address, time_string)
+            return True
+        else:
+            _LOGGER.info(
+                "Queued %s allowed for %s. Time in queue was %s.",
+                click_type, self.address, time_string)
+            return False
+
+    def _on_up_down(self, channel, click_type, was_queued, time_diff):
+        """Update device state, if event was not queued."""
+        import pyflic
+
+        if was_queued and self._queued_event_check(click_type, time_diff):
+            return
+
+        self._is_down = click_type == pyflic.ClickType.ButtonDown
+        self.schedule_update_ha_state()
+
+    def _on_click(self, channel, click_type, was_queued, time_diff):
+        """Fire click event, if event was not queued."""
+        # Return if click event was queued beyond allowed timeout
+        if was_queued and self._queued_event_check(click_type, time_diff):
+            return
+
+        # Return if click event is in ignored click types
+        hass_click_type = self._hass_click_types[click_type]
+        if hass_click_type in self._ignored_click_types:
+            return
+
+        self._hass.bus.fire(EVENT_NAME, {
+            EVENT_DATA_NAME: self.name,
+            EVENT_DATA_ADDRESS: self.address,
+            EVENT_DATA_QUEUED_TIME: time_diff,
+            EVENT_DATA_TYPE: hass_click_type
+        })
+
+    def _connection_status_changed(self, channel,
+                                   connection_status, disconnect_reason):
+        """Remove device, if button disconnects."""
+        import pyflic
+
+        if connection_status == pyflic.ConnectionStatus.Disconnected:
+            _LOGGER.info("Button (%s) disconnected. Reason: %s",
+                         self.address, disconnect_reason)
+            self.remove()

homeassistant/components/binary_sensor/hikvision.py

@@ -0,0 +1,262 @@
+"""
+Support for Hikvision event stream events represented as binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.hikvision/
+"""
+import logging
+from datetime import timedelta
+import voluptuous as vol
+
+from homeassistant.helpers.event import track_point_in_utc_time
+from homeassistant.util.dt import utcnow
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import (
+    CONF_HOST, CONF_PORT, CONF_NAME, CONF_USERNAME, CONF_PASSWORD,
+    CONF_SSL, EVENT_HOMEASSISTANT_STOP, ATTR_LAST_TRIP_TIME, CONF_CUSTOMIZE)
+
+REQUIREMENTS = ['pyhik==0.0.6', 'pydispatcher==2.0.5']
+_LOGGER = logging.getLogger(__name__)
+
+CONF_IGNORED = 'ignored'
+CONF_DELAY = 'delay'
+
+DEFAULT_PORT = 80
+DEFAULT_IGNORED = False
+DEFAULT_DELAY = 0
+
+ATTR_DELAY = 'delay'
+
+SENSOR_CLASS_MAP = {
+    'Motion': 'motion',
+    'Line Crossing': 'motion',
+    'IO Trigger': None,
+    'Field Detection': 'motion',
+    'Video Loss': None,
+    'Tamper Detection': 'motion',
+    'Shelter Alarm': None,
+    'Disk Full': None,
+    'Disk Error': None,
+    'Net Interface Broken': 'connectivity',
+    'IP Conflict': 'connectivity',
+    'Illegal Access': None,
+    'Video Mismatch': None,
+    'Bad Video': None,
+    'PIR Alarm': 'motion',
+    'Face Detection': 'motion',
+}
+
+CUSTOMIZE_SCHEMA = vol.Schema({
+    vol.Optional(CONF_IGNORED, default=DEFAULT_IGNORED): cv.boolean,
+    vol.Optional(CONF_DELAY, default=DEFAULT_DELAY): cv.positive_int
+    })
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=None): cv.string,
+    vol.Required(CONF_HOST): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_SSL, default=False): cv.boolean,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_CUSTOMIZE, default={}):
+        vol.Schema({cv.string: CUSTOMIZE_SCHEMA}),
+})
+
+
+def setup_platform(hass, config, add_entities, discovery_info=None):
+    """Setup Hikvision binary sensor devices."""
+    name = config.get(CONF_NAME)
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+
+    customize = config.get(CONF_CUSTOMIZE)
+
+    if config.get(CONF_SSL):
+        protocol = "https"
+    else:
+        protocol = "http"
+
+    url = '{}://{}'.format(protocol, host)
+
+    data = HikvisionData(hass, url, port, name, username, password)
+
+    if data.sensors is None:
+        _LOGGER.error('Hikvision event stream has no data, unable to setup.')
+        return False
+
+    entities = []
+
+    for sensor in data.sensors:
+        # Build sensor name, then parse customize config.
+        sensor_name = sensor.replace(' ', '_')
+
+        custom = customize.get(sensor_name.lower(), {})
+        ignore = custom.get(CONF_IGNORED)
+        delay = custom.get(CONF_DELAY)
+
+        _LOGGER.debug('Entity: %s - %s, Options - Ignore: %s, Delay: %s',
+                      data.name, sensor_name, ignore, delay)
+        if not ignore:
+            entities.append(HikvisionBinarySensor(hass, sensor, data, delay))
+
+    add_entities(entities)
+
+
+class HikvisionData(object):
+    """Hikvision camera event stream object."""
+
+    def __init__(self, hass, url, port, name, username, password):
+        """Initialize the data oject."""
+        from pyhik.hikvision import HikCamera
+        self._url = url
+        self._port = port
+        self._name = name
+        self._username = username
+        self._password = password
+
+        # Establish camera
+        self._cam = HikCamera(self._url, self._port,
+                              self._username, self._password)
+
+        if self._name is None:
+            self._name = self._cam.get_name
+
+        # Start event stream
+        self._cam.start_stream()
+
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, self.stop_hik)
+
+    def stop_hik(self, event):
+        """Shutdown Hikvision subscriptions and subscription thread on exit."""
+        self._cam.disconnect()
+
+    @property
+    def sensors(self):
+        """Return list of available sensors and their states."""
+        return self._cam.current_event_states
+
+    @property
+    def cam_id(self):
+        """Return camera id."""
+        return self._cam.get_id
+
+    @property
+    def name(self):
+        """Return camera name."""
+        return self._name
+
+
+class HikvisionBinarySensor(BinarySensorDevice):
+    """Representation of a Hikvision binary sensor."""
+
+    def __init__(self, hass, sensor, cam, delay):
+        """Initialize the binary_sensor."""
+        from pydispatch import dispatcher
+
+        self._hass = hass
+        self._cam = cam
+        self._name = self._cam.name + ' ' + sensor
+        self._id = self._cam.cam_id + '.' + sensor
+        self._sensor = sensor
+
+        if delay is None:
+            self._delay = 0
+        else:
+            self._delay = delay
+
+        self._timer = None
+
+        # Form signal for dispatcher
+        signal = 'ValueChanged.{}'.format(self._cam.cam_id)
+
+        dispatcher.connect(self._update_callback,
+                           signal=signal,
+                           sender=self._sensor)
+
+    def _sensor_state(self):
+        """Extract sensor state."""
+        return self._cam.sensors[self._sensor][0]
+
+    def _sensor_last_update(self):
+        """Extract sensor last update time."""
+        return self._cam.sensors[self._sensor][3]
+
+    @property
+    def name(self):
+        """Return the name of the Hikvision sensor."""
+        return self._name
+
+    @property
+    def unique_id(self):
+        """Return an unique ID."""
+        return '{}.{}'.format(self.__class__, self._id)
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._sensor_state()
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        try:
+            return SENSOR_CLASS_MAP[self._sensor]
+        except KeyError:
+            # Sensor must be unknown to us, add as generic
+            return None
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attr = {}
+        attr[ATTR_LAST_TRIP_TIME] = self._sensor_last_update()
+
+        if self._delay != 0:
+            attr[ATTR_DELAY] = self._delay
+
+        return attr
+
+    def _update_callback(self, signal, sender):
+        """Update the sensor's state, if needed."""
+        _LOGGER.debug('Dispatcher callback, signal: %s, sender: %s',
+                      signal, sender)
+
+        if sender is not self._sensor:
+            return
+
+        if self._delay > 0 and not self.is_on:
+            # Set timer to wait until updating the state
+            def _delay_update(now):
+                """Timer callback for sensor update."""
+                _LOGGER.debug('%s Called delayed (%ssec) update.',
+                              self._name, self._delay)
+                self.schedule_update_ha_state()
+                self._timer = None
+
+            if self._timer is not None:
+                self._timer()
+                self._timer = None
+
+            self._timer = track_point_in_utc_time(
+                self._hass, _delay_update,
+                utcnow() + timedelta(seconds=self._delay))
+
+        elif self._delay > 0 and self.is_on:
+            # For delayed sensors kill any callbacks on true events and update
+            if self._timer is not None:
+                self._timer()
+                self._timer = None
+
+            self.schedule_update_ha_state()
+
+        else:
+            self.schedule_update_ha_state()

homeassistant/components/binary_sensor/netatmo.py

@@ -23,9 +23,11 @@ _LOGGER = logging.getLogger(__name__)
 
 # These are the available sensors mapped to binary_sensor class
 SENSOR_TYPES = {
-    "Someone known": "motion",
-    "Someone unknown": "motion",
-    "Motion": "motion",
+    "Someone known": 'occupancy',
+    "Someone unknown": 'motion',
+    "Motion": 'motion',
+    "Tag Vibration": 'vibration',
+    "Tag Open": 'opening',
 }
 
 CONF_HOME = 'home'
@@ -48,6 +50,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     home = config.get(CONF_HOME, None)
     timeout = config.get(CONF_TIMEOUT, 15)
 
+    module_name = None
+
     import lnetatmo
     try:
         data = WelcomeData(netatmo.NETATMO_AUTH, home)
@@ -64,23 +68,35 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                camera_name not in config[CONF_CAMERAS]:
                 continue
         for variable in sensors:
-            add_devices([WelcomeBinarySensor(data, camera_name, home, timeout,
-                                             variable)])
+            if variable in ('Tag Vibration', 'Tag Open'):
+                continue
+            add_devices([WelcomeBinarySensor(data, camera_name, module_name,
+                                             home, timeout, variable)])
+
+        for module_name in data.get_module_names(camera_name):
+            for variable in sensors:
+                if variable in ('Tag Vibration', 'Tag Open'):
+                    add_devices([WelcomeBinarySensor(data, camera_name,
+                                                     module_name, home,
+                                                     timeout, variable)])
 
 
 class WelcomeBinarySensor(BinarySensorDevice):
     """Represent a single binary sensor in a Netatmo Welcome device."""
 
-    def __init__(self, data, camera_name, home, timeout, sensor):
+    def __init__(self, data, camera_name, module_name, home, timeout, sensor):
         """Setup for access to the Netatmo camera events."""
         self._data = data
         self._camera_name = camera_name
+        self._module_name = module_name
         self._home = home
         self._timeout = timeout
         if home:
             self._name = home + ' / ' + camera_name
         else:
             self._name = camera_name
+        if module_name:
+            self._name += ' / ' + module_name
         self._sensor_name = sensor
         self._name += ' ' + sensor
         camera_id = data.welcomedata.cameraByName(camera=camera_name,
@@ -112,7 +128,7 @@ class WelcomeBinarySensor(BinarySensorDevice):
     def update(self):
         """Request an update from the Netatmo API."""
         self._data.update()
-        self._data.welcomedata.updateEvent(home=self._data.home)
+        self._data.update_event()
 
         if self._sensor_name == "Someone known":
             self._state =\
@@ -129,5 +145,16 @@ class WelcomeBinarySensor(BinarySensorDevice):
                 self._data.welcomedata.motionDetected(self._home,
                                                       self._camera_name,
                                                       self._timeout*60)
+        elif self._sensor_name == "Tag Vibration":
+            self._state =\
+                self._data.welcomedata.moduleMotionDetected(self._home,
+                                                            self._module_name,
+                                                            self._camera_name,
+                                                            self._timeout*60)
+        elif self._sensor_name == "Tag Open":
+            self._state =\
+                self._data.welcomedata.moduleOpened(self._home,
+                                                    self._module_name,
+                                                    self._camera_name)
         else:
             return None

homeassistant/components/binary_sensor/wink.py

@@ -40,6 +40,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     for sensor in pywink.get_smoke_and_co_detectors():
         add_devices([WinkBinarySensorDevice(sensor, hass)])
 
+    for hub in pywink.get_hubs():
+        add_devices([WinkHub(hub, hass)])
+
 
 class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
     """Representation of a Wink binary sensor."""
@@ -79,3 +82,24 @@ class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
     def sensor_class(self):
         """Return the class of this sensor, from SENSOR_CLASSES."""
         return SENSOR_TYPES.get(self.capability)
+
+
+class WinkHub(WinkDevice, BinarySensorDevice, Entity):
+    """Representation of a Wink Hub."""
+
+    def __init(self, wink, hass):
+        """Initialize the hub sensor."""
+        WinkDevice.__init__(self, wink, hass)
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'update needed': self.wink.update_needed(),
+            'firmware version': self.wink.firmware_version()
+        }
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.wink.state()

homeassistant/components/camera/amcrest.py

@@ -18,16 +18,26 @@ REQUIREMENTS = ['amcrest==1.0.0']
 
 _LOGGER = logging.getLogger(__name__)
 
-DEFAULT_PORT = 80
+CONF_RESOLUTION = 'resolution'
+
 DEFAULT_NAME = 'Amcrest Camera'
+DEFAULT_PORT = 80
+DEFAULT_RESOLUTION = 'high'
 
 NOTIFICATION_ID = 'amcrest_notification'
 NOTIFICATION_TITLE = 'Amcrest Camera Setup'
 
+RESOLUTION_LIST = {
+    'high': 0,
+    'low': 1,
+}
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Required(CONF_USERNAME): cv.string,
     vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_RESOLUTION, default=DEFAULT_RESOLUTION):
+        vol.All(vol.In(RESOLUTION_LIST)),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
 })
@@ -64,13 +74,14 @@ class AmcrestCam(Camera):
     def __init__(self, device_info, data):
         """Initialize an Amcrest camera."""
         super(AmcrestCam, self).__init__()
-        self._name = device_info.get(CONF_NAME)
         self._data = data
+        self._name = device_info.get(CONF_NAME)
+        self._resolution = RESOLUTION_LIST[device_info.get(CONF_RESOLUTION)]
 
     def camera_image(self):
         """Return a still image reponse from the camera."""
         # Send the request to snap a picture and return raw jpg data
-        response = self._data.camera.snapshot()
+        response = self._data.camera.snapshot(channel=self._resolution)
         return response.data
 
     @property

homeassistant/components/camera/rpi_camera.py

@@ -39,7 +39,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_FILE_PATH): cv.string,
     vol.Optional(CONF_HORIZONTAL_FLIP, default=DEFAULT_HORIZONTAL_FLIP):
         vol.All(vol.Coerce(int), vol.Range(min=0, max=1)),
-    vol.Optional(CONF_IMAGE_HEIGHT, default=DEFAULT_HORIZONTAL_FLIP):
+    vol.Optional(CONF_IMAGE_HEIGHT, default=DEFAULT_IMAGE_HEIGHT):
         vol.Coerce(int),
     vol.Optional(CONF_IMAGE_QUALITY, default=DEFAULT_IMAGE_QUALITIY):
         vol.All(vol.Coerce(int), vol.Range(min=0, max=100)),

homeassistant/components/climate/ecobee.py

@@ -195,8 +195,9 @@ class Thermostat(ClimateDevice):
         mode = self.mode
         events = self.thermostat['events']
         for event in events:
-            if event['running']:
-                mode = event['holdClimateRef']
+            if event['holdClimateRef'] == 'away' or \
+               event['type'] == 'autoAway':
+                mode = "away"
                 break
         return 'away' in mode
 

homeassistant/components/climate/generic_thermostat.py

@@ -198,24 +198,30 @@ class GenericThermostat(ClimateDevice):
                 return
 
         if self.ac_mode:
-            too_hot = self._cur_temp - self._target_temp > self._tolerance
             is_cooling = self._is_device_active
-            if too_hot and not is_cooling:
-                _LOGGER.info('Turning on AC %s', self.heater_entity_id)
-                switch.turn_on(self.hass, self.heater_entity_id)
-            elif not too_hot and is_cooling:
-                _LOGGER.info('Turning off AC %s', self.heater_entity_id)
-                switch.turn_off(self.hass, self.heater_entity_id)
+            if is_cooling:
+                too_cold = self._target_temp - self._cur_temp > self._tolerance
+                if too_cold:
+                    _LOGGER.info('Turning off AC %s', self.heater_entity_id)
+                    switch.turn_off(self.hass, self.heater_entity_id)
+            else:
+                too_hot = self._cur_temp - self._target_temp > self._tolerance
+                if too_hot:
+                    _LOGGER.info('Turning on AC %s', self.heater_entity_id)
+                    switch.turn_on(self.hass, self.heater_entity_id)
         else:
-            too_cold = self._target_temp - self._cur_temp > self._tolerance
             is_heating = self._is_device_active
-
-            if too_cold and not is_heating:
-                _LOGGER.info('Turning on heater %s', self.heater_entity_id)
-                switch.turn_on(self.hass, self.heater_entity_id)
-            elif not too_cold and is_heating:
-                _LOGGER.info('Turning off heater %s', self.heater_entity_id)
-                switch.turn_off(self.hass, self.heater_entity_id)
+            if is_heating:
+                too_hot = self._cur_temp - self._target_temp > self._tolerance
+                if too_hot:
+                    _LOGGER.info('Turning off heater %s',
+                                 self.heater_entity_id)
+                    switch.turn_off(self.hass, self.heater_entity_id)
+            else:
+                too_cold = self._target_temp - self._cur_temp > self._tolerance
+                if too_cold:
+                    _LOGGER.info('Turning on heater %s', self.heater_entity_id)
+                    switch.turn_on(self.hass, self.heater_entity_id)
 
     @property
     def _is_device_active(self):

homeassistant/components/climate/nest.py

@@ -86,6 +86,8 @@ class NestThermostat(ClimateDevice):
         self._eco_temperature = None
         self._is_locked = None
         self._locked_temperature = None
+        self._min_temperature = None
+        self._max_temperature = None
 
     @property
     def name(self):
@@ -153,8 +155,8 @@ class NestThermostat(ClimateDevice):
         """Set new target temperature."""
         target_temp_low = kwargs.get(ATTR_TARGET_TEMP_LOW)
         target_temp_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
-        if target_temp_low is not None and target_temp_high is not None:
-            if self._mode == STATE_HEAT_COOL:
+        if self._mode == STATE_HEAT_COOL:
+            if target_temp_low is not None and target_temp_high is not None:
                 temp = (target_temp_low, target_temp_high)
         else:
             temp = kwargs.get(ATTR_TEMPERATURE)
@@ -204,18 +206,12 @@ class NestThermostat(ClimateDevice):
     @property
     def min_temp(self):
         """Identify min_temp in Nest API or defaults if not available."""
-        if self._is_locked:
-            return self._locked_temperature[0]
-        else:
-            return None
+        return self._min_temperature
 
     @property
     def max_temp(self):
         """Identify max_temp in Nest API or defaults if not available."""
-        if self._is_locked:
-            return self._locked_temperature[1]
-        else:
-            return None
+        return self._max_temperature
 
     def update(self):
         """Cache value from Python-nest."""
@@ -229,6 +225,8 @@ class NestThermostat(ClimateDevice):
         self._away = self.structure.away == 'away'
         self._eco_temperature = self.device.eco_temperature
         self._locked_temperature = self.device.locked_temperature
+        self._min_temperature = self.device.min_temperature
+        self._max_temperature = self.device.max_temperature
         self._is_locked = self.device.is_locked
         if self.device.temperature_scale == 'C':
             self._temperature_scale = TEMP_CELSIUS

homeassistant/components/climate/radiotherm.py

@@ -23,10 +23,19 @@ ATTR_FAN = 'fan'
 ATTR_MODE = 'mode'
 
 CONF_HOLD_TEMP = 'hold_temp'
+CONF_AWAY_TEMPERATURE_HEAT = 'away_temperature_heat'
+CONF_AWAY_TEMPERATURE_COOL = 'away_temperature_cool'
+
+DEFAULT_AWAY_TEMPERATURE_HEAT = 60
+DEFAULT_AWAY_TEMPERATURE_COOL = 85
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_HOST): vol.All(cv.ensure_list, [cv.string]),
     vol.Optional(CONF_HOLD_TEMP, default=False): cv.boolean,
+    vol.Optional(CONF_AWAY_TEMPERATURE_HEAT,
+                 default=DEFAULT_AWAY_TEMPERATURE_HEAT): vol.Coerce(float),
+    vol.Optional(CONF_AWAY_TEMPERATURE_COOL,
+                 default=DEFAULT_AWAY_TEMPERATURE_COOL): vol.Coerce(float),
 })
 
 
@@ -45,12 +54,16 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         return False
 
     hold_temp = config.get(CONF_HOLD_TEMP)
+    away_temps = [
+        config.get(CONF_AWAY_TEMPERATURE_HEAT),
+        config.get(CONF_AWAY_TEMPERATURE_COOL)
+    ]
     tstats = []
 
     for host in hosts:
         try:
             tstat = radiotherm.get_thermostat(host)
-            tstats.append(RadioThermostat(tstat, hold_temp))
+            tstats.append(RadioThermostat(tstat, hold_temp, away_temps))
         except OSError:
             _LOGGER.exception("Unable to connect to Radio Thermostat: %s",
                               host)
@@ -61,7 +74,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class RadioThermostat(ClimateDevice):
     """Representation of a Radio Thermostat."""
 
-    def __init__(self, device, hold_temp):
+    def __init__(self, device, hold_temp, away_temps):
         """Initialize the thermostat."""
         self.device = device
         self.set_time()
@@ -71,7 +84,10 @@ class RadioThermostat(ClimateDevice):
         self._name = None
         self._fmode = None
         self._tmode = None
-        self.hold_temp = hold_temp
+        self._hold_temp = hold_temp
+        self._away = False
+        self._away_temps = away_temps
+        self._prev_temp = None
         self.update()
         self._operation_list = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
 
@@ -113,6 +129,11 @@ class RadioThermostat(ClimateDevice):
         """Return the temperature we try to reach."""
         return self._target_temperature
 
+    @property
+    def is_away_mode_on(self):
+        """Return true if away mode is on."""
+        return self._away
+
     def update(self):
         """Update the data from the thermostat."""
         self._current_temperature = self.device.temp['raw']
@@ -138,7 +159,7 @@ class RadioThermostat(ClimateDevice):
             self.device.t_cool = round(temperature * 2.0) / 2.0
         elif self._current_operation == STATE_HEAT:
             self.device.t_heat = round(temperature * 2.0) / 2.0
-        if self.hold_temp:
+        if self._hold_temp or self._away:
             self.device.hold = 1
         else:
             self.device.hold = 0
@@ -162,3 +183,23 @@ class RadioThermostat(ClimateDevice):
             self.device.t_cool = round(self._target_temperature * 2.0) / 2.0
         elif operation_mode == STATE_HEAT:
             self.device.t_heat = round(self._target_temperature * 2.0) / 2.0
+
+    def turn_away_mode_on(self):
+        """Turn away on.
+
+        The RTCOA app simulates away mode by using a hold.
+        """
+        away_temp = None
+        if not self._away:
+            self._prev_temp = self._target_temperature
+            if self._current_operation == STATE_HEAT:
+                away_temp = self._away_temps[0]
+            elif self._current_operation == STATE_COOL:
+                away_temp = self._away_temps[1]
+        self._away = True
+        self.set_temperature(temperature=away_temp)
+
+    def turn_away_mode_off(self):
+        """Turn away off."""
+        self._away = False
+        self.set_temperature(temperature=self._prev_temp)

homeassistant/components/cover/__init__.py

@@ -135,12 +135,19 @@ def setup(hass, config):
         params = service.data.copy()
         params.pop(ATTR_ENTITY_ID, None)
 
-        if method:
-            for cover in component.extract_from_service(service):
-                getattr(cover, method['method'])(**params)
+        if not method:
+            return
 
-                if cover.should_poll:
-                    cover.update_ha_state(True)
+        covers = component.extract_from_service(service)
+
+        for cover in covers:
+            getattr(cover, method['method'])(**params)
+
+        for cover in covers:
+            if not cover.should_poll:
+                continue
+
+            cover.update_ha_state(True)
 
     descriptions = load_yaml_config_file(
         os.path.join(os.path.dirname(__file__), 'services.yaml'))

homeassistant/components/cover/tellduslive.py

@@ -0,0 +1,46 @@
+"""
+Support for Tellstick covers using Tellstick Net.
+
+This platform uses the Telldus Live online service.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/cover.tellduslive/
+
+"""
+import logging
+
+from homeassistant.components.cover import CoverDevice
+from homeassistant.components.tellduslive import TelldusLiveEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup covers."""
+    if discovery_info is None:
+        return
+    add_devices(TelldusLiveCover(hass, cover) for cover in discovery_info)
+
+
+class TelldusLiveCover(TelldusLiveEntity, CoverDevice):
+    """Representation of a cover."""
+
+    @property
+    def is_closed(self):
+        """Return the current position of the cover."""
+        return self.device.is_down
+
+    def close_cover(self, **kwargs):
+        """Close the cover."""
+        self.device.down()
+        self.changed()
+
+    def open_cover(self, **kwargs):
+        """Open the cover."""
+        self.device.up()
+        self.changed()
+
+    def stop_cover(self, **kwargs):
+        """Stop the cover."""
+        self.device.stop()
+        self.changed()

homeassistant/components/device_tracker/__init__.py

@@ -282,7 +282,7 @@ class DeviceTracker(object):
                 list(self.group.tracking) + [device.entity_id])
 
         # lookup mac vendor string to be stored in config
-        device.set_vendor_for_mac()
+        yield from device.set_vendor_for_mac()
 
         # update known_devices.yaml
         self.hass.async_add_job(
@@ -370,6 +370,7 @@ class Device(Entity):
 
         self.away_hide = hide_if_away
         self.vendor = vendor
+        self._attributes = {}
 
     @property
     def name(self):
@@ -399,12 +400,13 @@ class Device(Entity):
         if self.battery:
             attr[ATTR_BATTERY] = self.battery
 
-        if self.attributes:
-            for key, value in self.attributes.items():
-                attr[key] = value
-
         return attr
 
+    @property
+    def device_state_attributes(self):
+        """Return device state attributes."""
+        return self._attributes
+
     @property
     def hidden(self):
         """If device should be hidden."""
@@ -419,8 +421,11 @@ class Device(Entity):
         self.host_name = host_name
         self.location_name = location_name
         self.gps_accuracy = gps_accuracy or 0
-        self.battery = battery
-        self.attributes = attributes
+        if battery:
+            self.battery = battery
+        if attributes:
+            self._attributes.update(attributes)
+
         self.gps = None
 
         if gps is not None:

homeassistant/components/device_tracker/asuswrt.py

@@ -286,8 +286,10 @@ class AsusWrtDeviceScanner(object):
 
                 # match mac addresses to IP addresses in ARP table
                 for arp in result.arp:
-                    if match.group('mac').lower() in arp.decode('utf-8'):
-                        arp_match = _ARP_REGEX.search(arp.decode('utf-8'))
+                    if match.group('mac').lower() in \
+                            arp.decode('utf-8').lower():
+                        arp_match = _ARP_REGEX.search(
+                            arp.decode('utf-8').lower())
                         if not arp_match:
                             _LOGGER.warning('Could not parse arp row: %s', arp)
                             continue

homeassistant/components/device_tracker/gpslogger.py

@@ -64,9 +64,22 @@ class GPSLoggerView(HomeAssistantView):
         if 'battery' in data:
             battery = float(data['battery'])
 
+        attrs = {}
+        if 'speed' in data:
+            attrs['speed'] = float(data['speed'])
+        if 'direction' in data:
+            attrs['direction'] = float(data['direction'])
+        if 'altitude' in data:
+            attrs['altitude'] = float(data['altitude'])
+        if 'provider' in data:
+            attrs['provider'] = data['provider']
+        if 'activity' in data:
+            attrs['activity'] = data['activity']
+
         yield from hass.loop.run_in_executor(
             None, partial(self.see, dev_id=device,
                           gps=gps_location, battery=battery,
-                          gps_accuracy=accuracy))
+                          gps_accuracy=accuracy,
+                          attributes=attrs))
 
         return 'Setting location for {}'.format(device)

homeassistant/components/device_tracker/nmap_tracker.py

@@ -25,6 +25,8 @@ _LOGGER = logging.getLogger(__name__)
 CONF_EXCLUDE = 'exclude'
 # Interval in minutes to exclude devices from a scan while they are home
 CONF_HOME_INTERVAL = 'home_interval'
+CONF_OPTIONS = 'scan_options'
+DEFAULT_OPTIONS = '-F --host-timeout 5s'
 
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
 
@@ -33,7 +35,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOSTS): cv.ensure_list,
     vol.Required(CONF_HOME_INTERVAL, default=0): cv.positive_int,
     vol.Optional(CONF_EXCLUDE, default=[]):
-        vol.All(cv.ensure_list, vol.Length(min=1))
+        vol.All(cv.ensure_list, vol.Length(min=1)),
+    vol.Optional(CONF_OPTIONS, default=DEFAULT_OPTIONS):
+        cv.string
 })
 
 
@@ -69,8 +73,9 @@ class NmapDeviceScanner(object):
         self.last_results = []
 
         self.hosts = config[CONF_HOSTS]
-        self.exclude = config.get(CONF_EXCLUDE, [])
+        self.exclude = config[CONF_EXCLUDE]
         minutes = config[CONF_HOME_INTERVAL]
+        self._options = config[CONF_OPTIONS]
         self.home_interval = timedelta(minutes=minutes)
 
         self.success_init = self._update_info()
@@ -103,7 +108,7 @@ class NmapDeviceScanner(object):
         from nmap import PortScanner, PortScannerError
         scanner = PortScanner()
 
-        options = '-F --host-timeout 5s '
+        options = self._options
 
         if self.home_interval:
             boundary = dt_util.now() - self.home_interval

homeassistant/components/device_tracker/unifi.py

@@ -9,16 +9,20 @@ import urllib
 import voluptuous as vol
 
 import homeassistant.helpers.config_validation as cv
+import homeassistant.loader as loader
 from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
 from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD
 
 # Unifi package doesn't list urllib3 as a requirement
-REQUIREMENTS = ['urllib3', 'unifi==1.2.5']
+REQUIREMENTS = ['urllib3', 'pyunifi==1.3']
 
 _LOGGER = logging.getLogger(__name__)
 CONF_PORT = 'port'
 CONF_SITE_ID = 'site_id'
 
+NOTIFICATION_ID = 'unifi_notification'
+NOTIFICATION_TITLE = 'Unifi Device Tracker Setup'
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_HOST, default='localhost'): cv.string,
     vol.Optional(CONF_SITE_ID, default='default'): cv.string,
@@ -30,7 +34,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 def get_scanner(hass, config):
     """Setup Unifi device_tracker."""
-    from unifi.controller import Controller
+    from pyunifi.controller import Controller
 
     host = config[DOMAIN].get(CONF_HOST)
     username = config[DOMAIN].get(CONF_USERNAME)
@@ -38,10 +42,18 @@ def get_scanner(hass, config):
     site_id = config[DOMAIN].get(CONF_SITE_ID)
     port = config[DOMAIN].get(CONF_PORT)
 
+    persistent_notification = loader.get_component('persistent_notification')
     try:
         ctrl = Controller(host, username, password, port, 'v4', site_id)
     except urllib.error.HTTPError as ex:
-        _LOGGER.error('Failed to connect to unifi: %s', ex)
+        _LOGGER.error('Failed to connect to Unifi: %s', ex)
+        persistent_notification.create(
+            hass, 'Failed to connect to Unifi. '
+            'Error: {}<br />'
+            'You will need to restart hass after fixing.'
+            ''.format(ex),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
         return False
 
     return UnifiScanner(ctrl)

homeassistant/components/discovery.py

@@ -14,7 +14,7 @@ import voluptuous as vol
 from homeassistant.const import EVENT_HOMEASSISTANT_START
 from homeassistant.helpers.discovery import load_platform, discover
 
-REQUIREMENTS = ['netdisco==0.7.7']
+REQUIREMENTS = ['netdisco==0.8.1']
 
 DOMAIN = 'discovery'
 
@@ -36,6 +36,8 @@ SERVICE_HANDLERS = {
     'yamaha': ('media_player', 'yamaha'),
     'logitech_mediaserver': ('media_player', 'squeezebox'),
     'directv': ('media_player', 'directv'),
+    'denonavr': ('media_player', 'denonavr'),
+    'samsung_tv': ('media_player', 'samsungtv'),
 }
 
 CONFIG_SCHEMA = vol.Schema({

homeassistant/components/emulated_hue/hue_api.py

@@ -6,12 +6,16 @@ from aiohttp import web
 
 from homeassistant import core
 from homeassistant.const import (
-    ATTR_ENTITY_ID, ATTR_FRIENDLY_NAME, SERVICE_TURN_OFF, SERVICE_TURN_ON,
+    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON, SERVICE_VOLUME_SET,
     STATE_ON, STATE_OFF, HTTP_BAD_REQUEST, HTTP_NOT_FOUND,
 )
 from homeassistant.components.light import (
     ATTR_BRIGHTNESS, ATTR_SUPPORTED_FEATURES, SUPPORT_BRIGHTNESS
 )
+from homeassistant.components.media_player import (
+    ATTR_MEDIA_VOLUME_LEVEL, ATTR_SUPPORTED_MEDIA_COMMANDS,
+    SUPPORT_VOLUME_SET,
+)
 from homeassistant.components.http import HomeAssistantView
 
 _LOGGER = logging.getLogger(__name__)
@@ -65,8 +69,11 @@ class HueAllLightsStateView(HomeAssistantView):
 
         for entity in hass.states.async_all():
             if self.config.is_entity_exposed(entity):
+                state, brightness = get_entity_state(self.config, entity)
+
                 number = self.config.entity_id_to_number(entity.entity_id)
-                json_response[number] = entity_to_json(entity)
+                json_response[number] = entity_to_json(
+                    entity, state, brightness)
 
         return self.json(json_response)
 
@@ -97,16 +104,9 @@ class HueOneLightStateView(HomeAssistantView):
             _LOGGER.error('Entity not exposed: %s', entity_id)
             return web.Response(text="Entity not exposed", status=404)
 
-        cached_state = self.config.cached_states.get(entity_id, None)
+        state, brightness = get_entity_state(self.config, entity)
 
-        if cached_state is None:
-            final_state = entity.state == STATE_ON
-            final_brightness = entity.attributes.get(
-                ATTR_BRIGHTNESS, 255 if final_state else 0)
-        else:
-            final_state, final_brightness = cached_state
-
-        json_response = entity_to_json(entity, final_state, final_brightness)
+        json_response = entity_to_json(entity, state, brightness)
 
         return self.json(json_response)
 
@@ -158,14 +158,24 @@ class HueOneLightChangeView(HomeAssistantView):
 
         result, brightness = parsed
 
+        # Choose general HA domain
+        domain = core.DOMAIN
+
         # Convert the resulting "on" status into the service we need to call
         service = SERVICE_TURN_ON if result else SERVICE_TURN_OFF
 
         # Construct what we need to send to the service
         data = {ATTR_ENTITY_ID: entity_id}
 
+        # Make sure the entity actually supports brightness
+        entity_features = entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
+
+        if (entity_features & SUPPORT_BRIGHTNESS) == SUPPORT_BRIGHTNESS:
+            if brightness is not None:
+                data[ATTR_BRIGHTNESS] = brightness
+
         # If the requested entity is a script add some variables
-        if entity.domain == "script":
+        elif entity.domain == "script":
             data['variables'] = {
                 'requested_state': STATE_ON if result else STATE_OFF
             }
@@ -173,8 +183,16 @@ class HueOneLightChangeView(HomeAssistantView):
             if brightness is not None:
                 data['variables']['requested_level'] = brightness
 
-        elif brightness is not None:
-            data[ATTR_BRIGHTNESS] = brightness
+        # If the requested entity is a media player, convert to volume
+        elif entity.domain == "media_player":
+            media_commands = entity.attributes.get(
+                ATTR_SUPPORTED_MEDIA_COMMANDS, 0)
+            if media_commands & SUPPORT_VOLUME_SET == SUPPORT_VOLUME_SET:
+                if brightness is not None:
+                    domain = entity.domain
+                    service = SERVICE_VOLUME_SET
+                    # Convert 0-100 to 0.0-1.0
+                    data[ATTR_MEDIA_VOLUME_LEVEL] = brightness / 100.0
 
         if entity.domain in config.off_maps_to_on_domains:
             # Map the off command to on
@@ -187,9 +205,14 @@ class HueOneLightChangeView(HomeAssistantView):
             # as the actual requested command.
             config.cached_states[entity_id] = (result, brightness)
 
-        # Perform the requested action
-        yield from hass.services.async_call(core.DOMAIN, service, data,
-                                            blocking=True)
+        # Separate call to turn on needed
+        if domain != core.DOMAIN:
+            hass.async_add_job(hass.services.async_call(
+                core.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: entity_id},
+                blocking=True))
+
+        hass.async_add_job(hass.services.async_call(
+            domain, service, data, blocking=True))
 
         json_response = \
             [create_hue_success_response(entity_id, HUE_API_STATE_ON, result)]
@@ -219,23 +242,23 @@ def parse_hue_api_put_light_body(request_json, entity):
             result = False
 
     if HUE_API_STATE_BRI in request_json:
+        try:
+            # Clamp brightness from 0 to 255
+            brightness = \
+                max(0, min(int(request_json[HUE_API_STATE_BRI]), 255))
+        except ValueError:
+            return None
+
         # Make sure the entity actually supports brightness
         entity_features = entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
 
         if (entity_features & SUPPORT_BRIGHTNESS) == SUPPORT_BRIGHTNESS:
-            try:
-                # Clamp brightness from 0 to 255
-                brightness = \
-                    max(0, min(int(request_json[HUE_API_STATE_BRI]), 255))
-            except ValueError:
-                return None
-
             report_brightness = True
             result = (brightness > 0)
-        elif entity.domain.lower() == "script":
-            # Convert 0-255 to 0-100
-            level = int(request_json[HUE_API_STATE_BRI]) / 255 * 100
 
+        elif entity.domain == "script" or entity.domain == "media_player":
+            # Convert 0-255 to 0-100
+            level = brightness / 255 * 100
             brightness = round(level)
             report_brightness = True
             result = True
@@ -243,16 +266,35 @@ def parse_hue_api_put_light_body(request_json, entity):
     return (result, brightness) if report_brightness else (result, None)
 
 
+def get_entity_state(config, entity):
+    """Retrieve and convert state and brightness values for an entity."""
+    cached_state = config.cached_states.get(entity.entity_id, None)
+
+    if cached_state is None:
+        final_state = entity.state != STATE_OFF
+        final_brightness = entity.attributes.get(
+            ATTR_BRIGHTNESS, 255 if final_state else 0)
+
+        # Make sure the entity actually supports brightness
+        entity_features = entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
+
+        if (entity_features & SUPPORT_BRIGHTNESS) == SUPPORT_BRIGHTNESS:
+            pass
+
+        elif entity.domain == "media_player":
+            level = entity.attributes.get(
+                ATTR_MEDIA_VOLUME_LEVEL, 1.0 if final_state else 0.0)
+            # Convert 0.0-1.0 to 0-255
+            final_brightness = round(min(1.0, level) * 255)
+    else:
+        final_state, final_brightness = cached_state
+
+    return (final_state, final_brightness)
+
+
 def entity_to_json(entity, is_on=None, brightness=None):
     """Convert an entity to its Hue bridge JSON representation."""
-    if is_on is None:
-        is_on = entity.state == STATE_ON
-
-    if brightness is None:
-        brightness = 255 if is_on else 0
-
-    name = entity.attributes.get(
-        ATTR_EMULATED_HUE_NAME, entity.attributes[ATTR_FRIENDLY_NAME])
+    name = entity.attributes.get(ATTR_EMULATED_HUE_NAME, entity.name)
 
     return {
         'state':

homeassistant/components/emulated_hue/upnp.py

@@ -74,6 +74,7 @@ CACHE-CONTROL: max-age=60
 EXT:
 LOCATION: http://{0}:{1}/description.xml
 SERVER: FreeRTOS/6.0.5, UPnP/1.0, IpBridge/0.1
+hue-bridgeid: 1234
 ST: urn:schemas-upnp-org:device:basic:1
 USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1
 

homeassistant/components/frontend/version.py

@@ -1,18 +1,18 @@
 """DO NOT MODIFY. Auto-generated by script/fingerprint_frontend."""
 
 FINGERPRINTS = {
-    "core.js": "5dfb2d3e567fad37af0321d4b29265ed",
-    "frontend.html": "6a89b74ab2b76c7d28fad2aea9444ec2",
+    "core.js": "ad1ebcd0614c98a390d982087a7ca75c",
+    "frontend.html": "826ee6a4b39c939e31aa468b1ef618f9",
     "mdi.html": "46a76f877ac9848899b8ed382427c16f",
     "micromarkdown-js.html": "93b5ec4016f0bba585521cf4d18dec1a",
     "panels/ha-panel-dev-event.html": "c2d5ec676be98d4474d19f94d0262c1e",
     "panels/ha-panel-dev-info.html": "a9c07bf281fe9791fb15827ec1286825",
-    "panels/ha-panel-dev-service.html": "b3fe49532c5c03198fafb0c6ed58b76a",
+    "panels/ha-panel-dev-service.html": "ac74f7ce66fd7136d25c914ea12f4351",
     "panels/ha-panel-dev-state.html": "65e5f791cc467561719bf591f1386054",
     "panels/ha-panel-dev-template.html": "7d744ab7f7c08b6d6ad42069989de400",
     "panels/ha-panel-history.html": "efe1bcdd7733b09e55f4f965d171c295",
     "panels/ha-panel-iframe.html": "d920f0aa3c903680f2f8795e2255daab",
     "panels/ha-panel-logbook.html": "4bc5c8370a85a4215413fbae8f85addb",
-    "panels/ha-panel-map.html": "1bf6965b24d76db71a1871865cd4a3a2",
+    "panels/ha-panel-map.html": "3b0ca63286cbe80f27bd36dbc2434e89",
     "websocket_test.html": "575de64b431fe11c3785bf96d7813450"
 }

homeassistant/components/group.py

@@ -29,11 +29,13 @@ ENTITY_ID_FORMAT = DOMAIN + '.{}'
 
 CONF_ENTITIES = 'entities'
 CONF_VIEW = 'view'
+CONF_CONTROL = 'control'
 
 ATTR_AUTO = 'auto'
 ATTR_ORDER = 'order'
 ATTR_VIEW = 'view'
 ATTR_VISIBLE = 'visible'
+ATTR_CONTROL = 'control'
 
 SERVICE_SET_VISIBILITY = 'set_visibility'
 SET_VISIBILITY_SERVICE_SCHEMA = vol.Schema({
@@ -61,6 +63,7 @@ CONFIG_SCHEMA = vol.Schema({
         CONF_VIEW: cv.boolean,
         CONF_NAME: cv.string,
         CONF_ICON: cv.icon,
+        CONF_CONTROL: cv.string,
     }, cv.match_all))
 }, extra=vol.ALLOW_EXTRA)
 
@@ -206,11 +209,13 @@ def _async_process_config(hass, config, component):
         entity_ids = conf.get(CONF_ENTITIES) or []
         icon = conf.get(CONF_ICON)
         view = conf.get(CONF_VIEW)
+        control = conf.get(CONF_CONTROL)
 
         # Don't create tasks and await them all. The order is important as
         # groups get a number based on creation order.
         group = yield from Group.async_create_group(
-            hass, name, entity_ids, icon=icon, view=view, object_id=object_id)
+            hass, name, entity_ids, icon=icon, view=view,
+            control=control, object_id=object_id)
         groups.append(group)
 
     if groups:
@@ -221,7 +226,7 @@ class Group(Entity):
     """Track a group of entity ids."""
 
     def __init__(self, hass, name, order=None, user_defined=True, icon=None,
-                 view=False):
+                 view=False, control=None):
         """Initialize a group.
 
         This Object has factory function for creation.
@@ -239,20 +244,22 @@ class Group(Entity):
         self._assumed_state = False
         self._async_unsub_state_changed = None
         self._visible = True
+        self._control = control
 
     @staticmethod
     def create_group(hass, name, entity_ids=None, user_defined=True,
-                     icon=None, view=False, object_id=None):
+                     icon=None, view=False, control=None, object_id=None):
         """Initialize a group."""
         return run_coroutine_threadsafe(
             Group.async_create_group(hass, name, entity_ids, user_defined,
-                                     icon, view, object_id),
+                                     icon, view, control, object_id),
             hass.loop).result()
 
     @staticmethod
     @asyncio.coroutine
     def async_create_group(hass, name, entity_ids=None, user_defined=True,
-                           icon=None, view=False, object_id=None):
+                           icon=None, view=False, control=None,
+                           object_id=None):
         """Initialize a group.
 
         This method must be run in the event loop.
@@ -260,7 +267,8 @@ class Group(Entity):
         group = Group(
             hass, name,
             order=len(hass.states.async_entity_ids(DOMAIN)),
-            user_defined=user_defined, icon=icon, view=view)
+            user_defined=user_defined, icon=icon, view=view,
+            control=control)
 
         group.entity_id = async_generate_entity_id(
             ENTITY_ID_FORMAT, object_id or name, hass=hass)
@@ -319,6 +327,8 @@ class Group(Entity):
             data[ATTR_AUTO] = True
         if self._view:
             data[ATTR_VIEW] = True
+        if self._control:
+            data[ATTR_CONTROL] = self._control
         return data
 
     @property

homeassistant/components/homematic.py

@@ -825,7 +825,7 @@ class HMDevice(Entity):
         if have_change:
             _LOGGER.debug("%s update_ha_state after '%s'", self._name,
                           attribute)
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def _subscribe_homematic_events(self):
         """Subscribe all required events to handle job."""

homeassistant/components/http/__init__.py

@@ -18,7 +18,7 @@ from aiohttp.web_exceptions import HTTPUnauthorized, HTTPMovedPermanently
 
 import homeassistant.helpers.config_validation as cv
 import homeassistant.remote as rem
-from homeassistant.util import get_local_ip
+import homeassistant.util as hass_util
 from homeassistant.components import persistent_notification
 from homeassistant.const import (
     SERVER_PORT, CONTENT_TYPE_JSON, ALLOWED_CORS_HEADERS,
@@ -32,7 +32,7 @@ from .const import (
     KEY_USE_X_FORWARDED_FOR, KEY_TRUSTED_NETWORKS,
     KEY_BANS_ENABLED, KEY_LOGIN_THRESHOLD,
     KEY_DEVELOPMENT, KEY_AUTHENTICATED)
-from .static import GZIP_FILE_SENDER, staticresource_middleware
+from .static import FILE_SENDER, GZIP_FILE_SENDER, staticresource_middleware
 from .util import get_real_ip
 
 DOMAIN = 'http'
@@ -41,6 +41,7 @@ REQUIREMENTS = ('aiohttp_cors==0.5.0',)
 CONF_API_PASSWORD = 'api_password'
 CONF_SERVER_HOST = 'server_host'
 CONF_SERVER_PORT = 'server_port'
+CONF_BASE_URL = 'base_url'
 CONF_DEVELOPMENT = 'development'
 CONF_SSL_CERTIFICATE = 'ssl_certificate'
 CONF_SSL_KEY = 'ssl_key'
@@ -84,6 +85,7 @@ HTTP_SCHEMA = vol.Schema({
     vol.Optional(CONF_SERVER_HOST, default=DEFAULT_SERVER_HOST): cv.string,
     vol.Optional(CONF_SERVER_PORT, default=SERVER_PORT):
         vol.All(vol.Coerce(int), vol.Range(min=1, max=65535)),
+    vol.Optional(CONF_BASE_URL): cv.string,
     vol.Optional(CONF_DEVELOPMENT, default=DEFAULT_DEVELOPMENT): cv.string,
     vol.Optional(CONF_SSL_CERTIFICATE, default=None): cv.isfile,
     vol.Optional(CONF_SSL_KEY, default=None): cv.isfile,
@@ -155,9 +157,17 @@ def async_setup(hass, config):
     hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, start_server)
 
     hass.http = server
-    hass.config.api = rem.API(server_host if server_host != '0.0.0.0'
-                              else get_local_ip(),
-                              api_password, server_port,
+
+    host = conf.get(CONF_BASE_URL)
+
+    if host:
+        pass
+    elif server_host != DEFAULT_SERVER_HOST:
+        host = server_host
+    else:
+        host = hass_util.get_local_ip()
+
+    hass.config.api = rem.API(host, api_password, server_port,
                               ssl_certificate is not None)
 
     return True
@@ -288,10 +298,16 @@ class HomeAssistantWSGI(object):
                 cors_added.add(route)
 
         if self.ssl_certificate:
-            context = ssl.SSLContext(SSL_VERSION)
-            context.options |= SSL_OPTS
-            context.set_ciphers(CIPHERS)
-            context.load_cert_chain(self.ssl_certificate, self.ssl_key)
+            try:
+                context = ssl.SSLContext(SSL_VERSION)
+                context.options |= SSL_OPTS
+                context.set_ciphers(CIPHERS)
+                context.load_cert_chain(self.ssl_certificate, self.ssl_key)
+            except OSError as error:
+                _LOGGER.error("Could not read SSL certificate from %s: %s",
+                              self.ssl_certificate, error)
+                context = None
+                return
         else:
             context = None
 
@@ -305,18 +321,24 @@ class HomeAssistantWSGI(object):
 
         self._handler = self.app.make_handler()
 
-        self.server = yield from self.hass.loop.create_server(
-            self._handler, self.server_host, self.server_port, ssl=context)
+        try:
+            self.server = yield from self.hass.loop.create_server(
+                self._handler, self.server_host, self.server_port, ssl=context)
+        except OSError as error:
+            _LOGGER.error("Failed to create HTTP server at port %d: %s",
+                          self.server_port, error)
 
         self.app._frozen = False  # pylint: disable=protected-access
 
     @asyncio.coroutine
     def stop(self):
         """Stop the wsgi server."""
-        self.server.close()
-        yield from self.server.wait_closed()
+        if self.server:
+            self.server.close()
+            yield from self.server.wait_closed()
         yield from self.app.shutdown()
-        yield from self._handler.finish_connections(60.0)
+        if self._handler:
+            yield from self._handler.finish_connections(60.0)
         yield from self.app.cleanup()
 
 
@@ -344,7 +366,7 @@ class HomeAssistantView(object):
     def file(self, request, fil):
         """Return a file."""
         assert isinstance(fil, str), 'only string paths allowed'
-        response = yield from GZIP_FILE_SENDER.send(request, Path(fil))
+        response = yield from FILE_SENDER.send(request, Path(fil))
         return response
 
     def register(self, router):

homeassistant/components/http/static.py

@@ -63,6 +63,7 @@ class GzipFileSender(FileSender):
 
 
 GZIP_FILE_SENDER = GzipFileSender()
+FILE_SENDER = FileSender()
 
 
 @asyncio.coroutine

homeassistant/components/influxdb.py

@@ -24,23 +24,20 @@ CONF_TAGS = 'tags'
 CONF_DEFAULT_MEASUREMENT = 'default_measurement'
 
 DEFAULT_DATABASE = 'home_assistant'
-DEFAULT_HOST = 'localhost'
-DEFAULT_PORT = 8086
-DEFAULT_SSL = False
-DEFAULT_VERIFY_SSL = False
+DEFAULT_VERIFY_SSL = True
 DOMAIN = 'influxdb'
 TIMEOUT = 5
 
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: vol.Schema({
-        vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string,
+        vol.Optional(CONF_HOST): cv.string,
         vol.Inclusive(CONF_USERNAME, 'authentication'): cv.string,
         vol.Inclusive(CONF_PASSWORD, 'authentication'): cv.string,
         vol.Optional(CONF_BLACKLIST, default=[]):
             vol.All(cv.ensure_list, [cv.entity_id]),
         vol.Optional(CONF_DB_NAME, default=DEFAULT_DATABASE): cv.string,
-        vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
-        vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean,
+        vol.Optional(CONF_PORT): cv.port,
+        vol.Optional(CONF_SSL): cv.boolean,
         vol.Optional(CONF_DEFAULT_MEASUREMENT): cv.string,
         vol.Optional(CONF_TAGS, default={}):
             vol.Schema({cv.string: cv.string}),
@@ -57,23 +54,34 @@ def setup(hass, config):
 
     conf = config[DOMAIN]
 
-    host = conf.get(CONF_HOST)
-    port = conf.get(CONF_PORT)
-    database = conf.get(CONF_DB_NAME)
-    username = conf.get(CONF_USERNAME)
-    password = conf.get(CONF_PASSWORD)
-    ssl = conf.get(CONF_SSL)
-    verify_ssl = conf.get(CONF_VERIFY_SSL)
+    kwargs = {
+        'database': conf[CONF_DB_NAME],
+        'verify_ssl': conf[CONF_VERIFY_SSL],
+        'timeout': TIMEOUT
+    }
+
+    if CONF_HOST in conf:
+        kwargs['host'] = conf[CONF_HOST]
+
+    if CONF_PORT in conf:
+        kwargs['port'] = conf[CONF_PORT]
+
+    if CONF_USERNAME in conf:
+        kwargs['username'] = conf[CONF_USERNAME]
+
+    if CONF_PASSWORD in conf:
+        kwargs['password'] = conf[CONF_PASSWORD]
+
+    if CONF_SSL in conf:
+        kwargs['ssl'] = conf[CONF_SSL]
+
     blacklist = conf.get(CONF_BLACKLIST)
     whitelist = conf.get(CONF_WHITELIST)
     tags = conf.get(CONF_TAGS)
     default_measurement = conf.get(CONF_DEFAULT_MEASUREMENT)
 
     try:
-        influx = InfluxDBClient(
-            host=host, port=port, username=username, password=password,
-            database=database, ssl=ssl, verify_ssl=verify_ssl,
-            timeout=TIMEOUT)
+        influx = InfluxDBClient(**kwargs)
         influx.query("select * from /.*/ LIMIT 1;")
     except exceptions.InfluxDBClientError as exc:
         _LOGGER.error("Database host is not accessible due to '%s', please "

homeassistant/components/input_boolean.py

@@ -95,7 +95,8 @@ def async_setup(hass, config):
             attr = 'async_toggle'
 
         tasks = [getattr(input_b, attr)() for input_b in target_inputs]
-        yield from asyncio.wait(tasks, loop=hass.loop)
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     hass.services.async_register(
         DOMAIN, SERVICE_TURN_OFF, async_handler_service, schema=SERVICE_SCHEMA)

homeassistant/components/input_select.py

@@ -113,7 +113,8 @@ def async_setup(hass, config):
 
         tasks = [input_select.async_select_option(call.data[ATTR_OPTION])
                  for input_select in target_inputs]
-        yield from asyncio.wait(tasks, loop=hass.loop)
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     hass.services.async_register(
         DOMAIN, SERVICE_SELECT_OPTION, async_select_option_service,
@@ -126,7 +127,8 @@ def async_setup(hass, config):
 
         tasks = [input_select.async_offset_index(1)
                  for input_select in target_inputs]
-        yield from asyncio.wait(tasks, loop=hass.loop)
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     hass.services.async_register(
         DOMAIN, SERVICE_SELECT_NEXT, async_select_next_service,
@@ -139,7 +141,8 @@ def async_setup(hass, config):
 
         tasks = [input_select.async_offset_index(-1)
                  for input_select in target_inputs]
-        yield from asyncio.wait(tasks, loop=hass.loop)
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     hass.services.async_register(
         DOMAIN, SERVICE_SELECT_PREVIOUS, async_select_previous_service,

homeassistant/components/input_slider.py

@@ -105,7 +105,8 @@ def async_setup(hass, config):
 
         tasks = [input_slider.async_select_value(call.data[ATTR_VALUE])
                  for input_slider in target_inputs]
-        yield from asyncio.wait(tasks, loop=hass.loop)
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     hass.services.async_register(
         DOMAIN, SERVICE_SELECT_VALUE, async_select_value_service,

homeassistant/components/light/__init__.py

@@ -236,7 +236,6 @@ def async_setup(hass, config):
         if color_name is not None:
             params[ATTR_RGB_COLOR] = color_util.color_name_to_rgb(color_name)
 
-        update_tasks = []
         for light in target_lights:
             if service.service == SERVICE_TURN_ON:
                 yield from light.async_turn_on(**params)
@@ -245,12 +244,18 @@ def async_setup(hass, config):
             else:
                 yield from light.async_toggle(**params)
 
-            if light.should_poll:
-                update_coro = light.async_update_ha_state(True)
-                if hasattr(light, 'async_update'):
-                    update_tasks.append(hass.loop.create_task(update_coro))
-                else:
-                    yield from update_coro
+        update_tasks = []
+
+        for light in target_lights:
+            if not light.should_poll:
+                continue
+
+            update_coro = hass.loop.create_task(
+                light.async_update_ha_state(True))
+            if hasattr(light, 'async_update'):
+                update_tasks.append(hass.loop.create_task(update_coro))
+            else:
+                yield from update_coro
 
         if update_tasks:
             yield from asyncio.wait(update_tasks, loop=hass.loop)

homeassistant/components/light/enocean.py

@@ -26,8 +26,9 @@ DEPENDENCIES = ['enocean']
 SUPPORT_ENOCEAN = SUPPORT_BRIGHTNESS
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_ID): cv.string,
-    vol.Required(CONF_SENDER_ID): cv.string,
+    vol.Optional(CONF_ID, default=[]): vol.All(cv.ensure_list,
+                                               [vol.Coerce(int)]),
+    vol.Required(CONF_SENDER_ID): vol.All(cv.ensure_list, [vol.Coerce(int)]),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
 })
 

homeassistant/components/light/flux_led.py

@@ -17,8 +17,8 @@ from homeassistant.components.light import (
     PLATFORM_SCHEMA)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['https://github.com/Danielhiversen/flux_led/archive/0.9.zip'
-                '#flux_led==0.9']
+REQUIREMENTS = ['https://github.com/Danielhiversen/flux_led/archive/0.10.zip'
+                '#flux_led==0.10']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/light/hue.py

@@ -90,6 +90,10 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     if discovery_info is not None:
         host = urlparse(discovery_info[1]).hostname
+
+        if "HASS Bridge" in discovery_info[0]:
+            _LOGGER.info('Emulated hue found, will not add')
+            return False
     else:
         host = config.get(CONF_HOST, None)
 
@@ -138,10 +142,14 @@ def setup_bridge(host, hass, add_devices, filename, allow_unreachable):
         configurator.request_done(request_id)
 
     lights = {}
+    lightgroups = {}
+    skip_groups = False
 
     @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS)
     def update_lights():
         """Update the Hue light objects with latest info from the bridge."""
+        nonlocal skip_groups
+
         try:
             api = bridge.get_api()
         except socket.error:
@@ -149,9 +157,18 @@ def setup_bridge(host, hass, add_devices, filename, allow_unreachable):
             _LOGGER.exception("Cannot reach the bridge")
             return
 
-        api_states = api.get('lights')
+        api_lights = api.get('lights')
 
-        if not isinstance(api_states, dict):
+        if not isinstance(api_lights, dict):
+            _LOGGER.error("Got unexpected result from Hue API")
+            return
+
+        if skip_groups:
+            api_groups = {}
+        else:
+            api_groups = api.get('groups')
+
+        if not isinstance(api_groups, dict):
             _LOGGER.error("Got unexpected result from Hue API")
             return
 
@@ -163,7 +180,7 @@ def setup_bridge(host, hass, add_devices, filename, allow_unreachable):
         else:
             bridge_type = 'hue'
 
-        for light_id, info in api_states.items():
+        for light_id, info in api_lights.items():
             if light_id not in lights:
                 lights[light_id] = HueLight(int(light_id), info,
                                             bridge, update_lights,
@@ -171,6 +188,23 @@ def setup_bridge(host, hass, add_devices, filename, allow_unreachable):
                 new_lights.append(lights[light_id])
             else:
                 lights[light_id].info = info
+                lights[light_id].schedule_update_ha_state()
+
+        for lightgroup_id, info in api_groups.items():
+            if 'state' not in info:
+                _LOGGER.warning('Group info does not contain state. '
+                                'Please update your hub.')
+                skip_groups = True
+                break
+
+            if lightgroup_id not in lightgroups:
+                lightgroups[lightgroup_id] = HueLight(
+                    int(lightgroup_id), info, bridge, update_lights,
+                    bridge_type, allow_unreachable, True)
+                new_lights.append(lightgroups[lightgroup_id])
+            else:
+                lightgroups[lightgroup_id].info = info
+                lightgroups[lightgroup_id].schedule_update_ha_state()
 
         if new_lights:
             add_devices(new_lights)
@@ -225,15 +259,20 @@ class HueLight(Light):
     """Representation of a Hue light."""
 
     def __init__(self, light_id, info, bridge, update_lights,
-                 bridge_type, allow_unreachable):
+                 bridge_type, allow_unreachable, is_group=False):
         """Initialize the light."""
         self.light_id = light_id
         self.info = info
         self.bridge = bridge
         self.update_lights = update_lights
         self.bridge_type = bridge_type
-
         self.allow_unreachable = allow_unreachable
+        self.is_group = is_group
+
+        if is_group:
+            self._command_func = self.bridge.set_group
+        else:
+            self._command_func = self.bridge.set_light
 
     @property
     def unique_id(self):
@@ -243,33 +282,44 @@ class HueLight(Light):
 
     @property
     def name(self):
-        """Return the mame of the Hue light."""
+        """Return the name of the Hue light."""
         return self.info.get('name', DEVICE_DEFAULT_NAME)
 
     @property
     def brightness(self):
         """Return the brightness of this light between 0..255."""
-        return self.info['state'].get('bri')
+        if self.is_group:
+            return self.info['action'].get('bri')
+        else:
+            return self.info['state'].get('bri')
 
     @property
     def xy_color(self):
         """Return the XY color value."""
-        return self.info['state'].get('xy')
+        if self.is_group:
+            return self.info['action'].get('xy')
+        else:
+            return self.info['state'].get('xy')
 
     @property
     def color_temp(self):
         """Return the CT color value."""
-        return self.info['state'].get('ct')
+        if self.is_group:
+            return self.info['action'].get('ct')
+        else:
+            return self.info['state'].get('ct')
 
     @property
     def is_on(self):
         """Return true if device is on."""
-        self.update_lights()
-
-        if self.allow_unreachable:
-            return self.info['state']['on']
+        if self.is_group:
+            return self.info['state']['any_on']
         else:
-            return self.info['state']['reachable'] and self.info['state']['on']
+            if self.allow_unreachable:
+                return self.info['state']['on']
+            else:
+                return self.info['state']['reachable'] and \
+                    self.info['state']['on']
 
     @property
     def supported_features(self):
@@ -318,7 +368,7 @@ class HueLight(Light):
         elif self.bridge_type == 'hue':
             command['effect'] = 'none'
 
-        self.bridge.set_light(self.light_id, command)
+        self._command_func(self.light_id, command)
 
     def turn_off(self, **kwargs):
         """Turn the specified or all lights off."""
@@ -340,7 +390,7 @@ class HueLight(Light):
         elif self.bridge_type == 'hue':
             command['alert'] = 'none'
 
-        self.bridge.set_light(self.light_id, command)
+        self._command_func(self.light_id, command)
 
     def update(self):
         """Synchronize state with bridge."""

homeassistant/components/light/tellduslive.py

@@ -0,0 +1,63 @@
+"""
+Support for Tellstick switches using Tellstick Net.
+
+This platform uses the Telldus Live online service.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/light.tellduslive/
+
+"""
+import logging
+
+from homeassistant.components.light import (
+    ATTR_BRIGHTNESS, SUPPORT_BRIGHTNESS, Light)
+from homeassistant.components.tellduslive import TelldusLiveEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup lights."""
+    if discovery_info is None:
+        return
+    add_devices(TelldusLiveLight(hass, light) for light in discovery_info)
+
+
+class TelldusLiveLight(TelldusLiveEntity, Light):
+    """Representation of a light."""
+
+    def __init__(self, hass, device_id):
+        """Initialize the light."""
+        super().__init__(hass, device_id)
+        self._last_brightness = self.brightness
+
+    def changed(self):
+        """A property of the device might have changed."""
+        self._last_brightness = self.brightness
+        super().changed()
+
+    @property
+    def brightness(self):
+        """Return the brightness of this light between 0..255."""
+        return self.device.dim_level
+
+    @property
+    def supported_features(self):
+        """Flag supported features."""
+        return SUPPORT_BRIGHTNESS
+
+    @property
+    def is_on(self):
+        """Return true if light is on."""
+        return self.device.is_on
+
+    def turn_on(self, **kwargs):
+        """Turn the light on."""
+        brightness = kwargs.get(ATTR_BRIGHTNESS, self._last_brightness)
+        self.device.dim(level=brightness)
+        self.changed()
+
+    def turn_off(self, **kwargs):
+        """Turn the light off."""
+        self.device.turn_off()
+        self.changed()

homeassistant/components/light/tellstick.py

@@ -29,16 +29,17 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     signal_repetitions = discovery_info.get(ATTR_DISCOVER_CONFIG,
                                             DEFAULT_SIGNAL_REPETITIONS)
 
-    add_devices(TellstickLight(tellcore_id, signal_repetitions)
+    add_devices(TellstickLight(tellcore_id, hass.data['tellcore_registry'],
+                               signal_repetitions)
                 for tellcore_id in discovery_info[ATTR_DISCOVER_DEVICES])
 
 
 class TellstickLight(TellstickDevice, Light):
     """Representation of a Tellstick light."""
 
-    def __init__(self, tellcore_id, signal_repetitions):
+    def __init__(self, tellcore_id, tellcore_registry, signal_repetitions):
         """Initialize the light."""
-        super().__init__(tellcore_id, signal_repetitions)
+        super().__init__(tellcore_id, tellcore_registry, signal_repetitions)
 
         self._brightness = 255
 
@@ -71,7 +72,11 @@ class TellstickLight(TellstickDevice, Light):
             if brightness is not None:
                 self._brightness = brightness
 
-            self._state = (self._brightness > 0)
+            # _brightness is not defined when called from super
+            try:
+                self._state = (self._brightness > 0)
+            except AttributeError:
+                self._state = True
         else:
             self._state = False
 

homeassistant/components/lock/__init__.py

@@ -85,8 +85,11 @@ def setup(hass, config):
             else:
                 item.unlock(code=code)
 
-            if item.should_poll:
-                item.update_ha_state(True)
+        for item in target_locks:
+            if not item.should_poll:
+                continue
+
+            item.update_ha_state(True)
 
     descriptions = load_yaml_config_file(
         os.path.join(os.path.dirname(__file__), 'services.yaml'))

homeassistant/components/media_player/__init__.py

@@ -162,7 +162,7 @@ MEDIA_PLAYER_MEDIA_SEEK_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
 MEDIA_PLAYER_PLAY_MEDIA_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({
     vol.Required(ATTR_MEDIA_CONTENT_TYPE): cv.string,
     vol.Required(ATTR_MEDIA_CONTENT_ID): cv.string,
-    ATTR_MEDIA_ENQUEUE: cv.boolean,
+    vol.Optional(ATTR_MEDIA_ENQUEUE): cv.boolean,
 })
 
 MEDIA_PLAYER_SELECT_SOURCE_SCHEMA = MEDIA_PLAYER_SCHEMA.extend({

homeassistant/components/media_player/aquostv.py

@@ -0,0 +1,161 @@
+"""
+Support for interface with an Aquos TV.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.aquostv/
+"""
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.media_player import (
+    SUPPORT_TURN_ON, SUPPORT_TURN_OFF,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
+    SUPPORT_VOLUME_SET, MediaPlayerDevice, PLATFORM_SCHEMA)
+
+from homeassistant.const import (
+    CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN,
+    CONF_PORT, CONF_USERNAME, CONF_PASSWORD)
+
+
+import homeassistant.helpers.config_validation as cv
+
+REQUIREMENTS = ['sharp-aquos-rc==0.2']
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Sharp Aquos TV'
+DEFAULT_PORT = 10002
+DEFAULT_USERNAME = 'admin'
+DEFAULT_PASSWORD = 'password'
+
+SUPPORT_SHARPTV = SUPPORT_VOLUME_STEP | \
+    SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
+    SUPPORT_TURN_OFF | SUPPORT_TURN_ON
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string,
+    vol.Optional(CONF_PASSWORD, default=DEFAULT_PASSWORD): cv.string,
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Sharp Aquos TV platform."""
+    import sharp_aquos_rc
+
+    name = config.get(CONF_NAME)
+    port = config.get(CONF_PORT)
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+
+    if discovery_info:
+        _LOGGER.debug('%s', discovery_info)
+        vals = discovery_info.split(':')
+        if len(vals) > 1:
+            port = vals[1]
+
+        host = vals[0]
+        remote = sharp_aquos_rc.TV(host,
+                                   port,
+                                   username,
+                                   password)
+        add_devices([SharpAquosTVDevice(name, remote)])
+        return True
+
+    host = config.get(CONF_HOST)
+    remote = sharp_aquos_rc.TV(host,
+                               port,
+                               username,
+                               password)
+
+    add_devices([SharpAquosTVDevice(name, remote)])
+    return True
+
+
+# pylint: disable=abstract-method
+class SharpAquosTVDevice(MediaPlayerDevice):
+    """Representation of a Aquos TV."""
+
+    # pylint: disable=too-many-public-methods
+    def __init__(self, name, remote):
+        """Initialize the aquos device."""
+        # Save a reference to the imported class
+        self._name = name
+        # Assume that the TV is not muted
+        self._muted = False
+        # Assume that the TV is in Play mode
+        self._playing = True
+        self._state = STATE_UNKNOWN
+        self._remote = remote
+        self._volume = 0
+
+    def update(self):
+        """Retrieve the latest data."""
+        try:
+            if self._remote.power() == 1:
+                self._state = STATE_ON
+            else:
+                self._state = STATE_OFF
+
+            # Set TV to be able to remotely power on
+            # self._remote.power_on_command_settings(2)
+            if self._remote.mute() == 2:
+                self._muted = False
+            else:
+                self._muted = True
+            self._volume = self._remote.volume() / 60
+        except OSError:
+            self._state = STATE_OFF
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._state
+
+    @property
+    def volume_level(self):
+        """Volume level of the media player (0..1)."""
+        return self._volume
+
+    @property
+    def is_volume_muted(self):
+        """Boolean if volume is currently muted."""
+        return self._muted
+
+    @property
+    def supported_media_commands(self):
+        """Flag of media commands that are supported."""
+        return SUPPORT_SHARPTV
+
+    def turn_off(self):
+        """Turn off tvplayer."""
+        self._remote.power(0)
+
+    def volume_up(self):
+        """Volume up the media player."""
+        self._remote.volume(int(self._volume * 60) + 2)
+
+    def volume_down(self):
+        """Volume down media player."""
+        self._remote.volume(int(self._volume * 60) - 2)
+
+    def set_volume_level(self, level):
+        """Set Volume media player."""
+        self._remote.volume(int(level * 60))
+
+    def mute_volume(self, mute):
+        """Send mute command."""
+        self._remote.mute(0)
+
+    def turn_on(self):
+        """Turn the media player on."""
+        self._remote.power(1)

homeassistant/components/media_player/braviatv.py

@@ -13,7 +13,7 @@ import voluptuous as vol
 
 from homeassistant.loader import get_component
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_ON,
     SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
     SUPPORT_VOLUME_SET, SUPPORT_SELECT_SOURCE, MediaPlayerDevice,
     PLATFORM_SCHEMA)
@@ -40,7 +40,8 @@ _LOGGER = logging.getLogger(__name__)
 SUPPORT_BRAVIA = SUPPORT_PAUSE | SUPPORT_VOLUME_STEP | \
                  SUPPORT_VOLUME_MUTE | SUPPORT_VOLUME_SET | \
                  SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | \
-                 SUPPORT_TURN_OFF | SUPPORT_SELECT_SOURCE
+                 SUPPORT_TURN_ON | SUPPORT_TURN_OFF | \
+                 SUPPORT_SELECT_SOURCE
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,

homeassistant/components/media_player/cast.py

@@ -18,6 +18,7 @@ from homeassistant.const import (
     CONF_HOST, STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING,
     STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
+import homeassistant.util.dt as dt_util
 
 REQUIREMENTS = ['pychromecast==0.7.6']
 
@@ -105,6 +106,7 @@ class CastDevice(MediaPlayerDevice):
 
         self.cast_status = self.cast.status
         self.media_status = self.cast.media_controller.status
+        self.media_status_received = None
 
     @property
     def should_poll(self):
@@ -231,6 +233,30 @@ class CastDevice(MediaPlayerDevice):
         """Flag of media commands that are supported."""
         return SUPPORT_CAST
 
+    @property
+    def media_position(self):
+        """Position of current playing media in seconds."""
+        if self.media_status is None or self.media_status_received is None or \
+                not (self.media_status.player_is_playing or
+                     self.media_status.player_is_idle):
+            return None
+
+        position = self.media_status.current_time
+
+        if self.media_status.player_is_playing:
+            position += (dt_util.utcnow() -
+                         self.media_status_received).total_seconds()
+
+        return position
+
+    @property
+    def media_position_updated_at(self):
+        """When was the position of the current playing media valid.
+
+        Returns value from homeassistant.util.dt.utcnow().
+        """
+        return self.media_status_received
+
     def turn_on(self):
         """Turn on the ChromeCast."""
         # The only way we can turn the Chromecast is on is by launching an app
@@ -292,4 +318,5 @@ class CastDevice(MediaPlayerDevice):
     def new_media_status(self, status):
         """Called when a new media status is received."""
         self.media_status = status
+        self.media_status_received = dt_util.utcnow()
         self.schedule_update_ha_state()

homeassistant/components/media_player/demo.py

@@ -10,6 +10,7 @@ from homeassistant.components.media_player import (
     SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
     SUPPORT_SELECT_SOURCE, SUPPORT_CLEAR_PLAYLIST, MediaPlayerDevice)
 from homeassistant.const import STATE_OFF, STATE_PAUSED, STATE_PLAYING
+import homeassistant.util.dt as dt_util
 
 
 # pylint: disable=unused-argument
@@ -18,8 +19,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     add_devices([
         DemoYoutubePlayer(
             'Living Room', 'eyU3bRy2x44',
-            '♥♥ The Best Fireplace Video (3 hours)'),
-        DemoYoutubePlayer('Bedroom', 'kxopViU98Xo', 'Epic sax guy 10 hours'),
+            '♥♥ The Best Fireplace Video (3 hours)', 300),
+        DemoYoutubePlayer('Bedroom', 'kxopViU98Xo', 'Epic sax guy 10 hours',
+                          360000),
         DemoMusicPlayer(), DemoTVShowPlayer(),
     ])
 
@@ -78,32 +80,32 @@ class AbstractDemoPlayer(MediaPlayerDevice):
     def turn_on(self):
         """Turn the media player on."""
         self._player_state = STATE_PLAYING
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def turn_off(self):
         """Turn the media player off."""
         self._player_state = STATE_OFF
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def mute_volume(self, mute):
         """Mute the volume."""
         self._volume_muted = mute
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def set_volume_level(self, volume):
         """Set the volume level, range 0..1."""
         self._volume_level = volume
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def media_play(self):
         """Send play command."""
         self._player_state = STATE_PLAYING
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def media_pause(self):
         """Send pause command."""
         self._player_state = STATE_PAUSED
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
 
 class DemoYoutubePlayer(AbstractDemoPlayer):
@@ -111,11 +113,14 @@ class DemoYoutubePlayer(AbstractDemoPlayer):
 
     # We only implement the methods that we support
 
-    def __init__(self, name, youtube_id=None, media_title=None):
+    def __init__(self, name, youtube_id=None, media_title=None, duration=360):
         """Initialize the demo device."""
         super().__init__(name)
         self.youtube_id = youtube_id
         self._media_title = media_title
+        self._duration = duration
+        self._progress = int(duration * .15)
+        self._progress_updated_at = dt_util.utcnow()
 
     @property
     def media_content_id(self):
@@ -130,7 +135,7 @@ class DemoYoutubePlayer(AbstractDemoPlayer):
     @property
     def media_duration(self):
         """Return the duration of current playing media in seconds."""
-        return 360
+        return self._duration
 
     @property
     def media_image_url(self):
@@ -152,10 +157,39 @@ class DemoYoutubePlayer(AbstractDemoPlayer):
         """Flag of media commands that are supported."""
         return YOUTUBE_PLAYER_SUPPORT
 
+    @property
+    def media_position(self):
+        """Position of current playing media in seconds."""
+        if self._progress is None:
+            return None
+
+        position = self._progress
+
+        if self._player_state == STATE_PLAYING:
+            position += (dt_util.utcnow() -
+                         self._progress_updated_at).total_seconds()
+
+        return position
+
+    @property
+    def media_position_updated_at(self):
+        """When was the position of the current playing media valid.
+
+        Returns value from homeassistant.util.dt.utcnow().
+        """
+        if self._player_state == STATE_PLAYING:
+            return self._progress_updated_at
+
     def play_media(self, media_type, media_id, **kwargs):
         """Play a piece of media."""
         self.youtube_id = media_id
-        self.update_ha_state()
+        self.schedule_update_ha_state()
+
+    def media_pause(self):
+        """Send pause command."""
+        self._progress = self.media_position
+        self._progress_updated_at = dt_util.utcnow()
+        super().media_pause()
 
 
 class DemoMusicPlayer(AbstractDemoPlayer):
@@ -249,20 +283,20 @@ class DemoMusicPlayer(AbstractDemoPlayer):
         """Send previous track command."""
         if self._cur_track > 0:
             self._cur_track -= 1
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def media_next_track(self):
         """Send next track command."""
         if self._cur_track < len(self.tracks) - 1:
             self._cur_track += 1
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def clear_playlist(self):
         """Clear players playlist."""
         self.tracks = []
         self._cur_track = 0
         self._player_state = STATE_OFF
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
 
 class DemoTVShowPlayer(AbstractDemoPlayer):
@@ -344,15 +378,15 @@ class DemoTVShowPlayer(AbstractDemoPlayer):
         """Send previous track command."""
         if self._cur_episode > 1:
             self._cur_episode -= 1
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def media_next_track(self):
         """Send next track command."""
         if self._cur_episode < self._episode_count:
             self._cur_episode += 1
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def select_source(self, source):
         """Set the input source."""
         self._source = source
-        self.update_ha_state()
+        self.schedule_update_ha_state()

homeassistant/components/media_player/denon.py

@@ -13,7 +13,7 @@ from homeassistant.components.media_player import (
     PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_SELECT_SOURCE,
     SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_OFF,
     SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    MediaPlayerDevice)
+    SUPPORT_STOP, MediaPlayerDevice)
 from homeassistant.const import (
     CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
@@ -22,16 +22,32 @@ _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME = 'Music station'
 
-SUPPORT_DENON = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | \
-    SUPPORT_VOLUME_MUTE | SUPPORT_PREVIOUS_TRACK | \
-    SUPPORT_SELECT_SOURCE | SUPPORT_NEXT_TRACK | \
-    SUPPORT_TURN_ON | SUPPORT_TURN_OFF
+SUPPORT_DENON = SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
+    SUPPORT_TURN_ON | SUPPORT_TURN_OFF | SUPPORT_SELECT_SOURCE \
+
+SUPPORT_MEDIA_MODES = SUPPORT_PAUSE | SUPPORT_STOP | \
+    SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
 })
 
+NORMAL_INPUTS = {'Cd': 'CD', 'Dvd': 'DVD', 'Blue ray': 'BD', 'TV': 'TV',
+                 'Satelite / Cable': 'SAT/CBL', 'Game': 'GAME',
+                 'Game2': 'GAME2', 'Video Aux': 'V.AUX', 'Dock': 'DOCK'}
+
+MEDIA_MODES = {'Tuner': 'TUNER', 'Media server': 'SERVER',
+               'Ipod dock': 'IPOD', 'Net/USB': 'NET/USB',
+               'Rapsody': 'RHAPSODY', 'Napster': 'NAPSTER',
+               'Pandora': 'PANDORA', 'LastFM': 'LASTFM',
+               'Flickr': 'FLICKR', 'Favorites': 'FAVORITES',
+               'Internet Radio': 'IRADIO', 'USB/IPOD': 'USB/IPOD'}
+
+# Sub-modes of 'NET/USB'
+# {'USB': 'USB', 'iPod Direct': 'IPD', 'Internet Radio': 'IRP',
+#  'Favorites': 'FVP'}
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Denon platform."""
@@ -53,14 +69,39 @@ class DenonDevice(MediaPlayerDevice):
         self._host = host
         self._pwstate = 'PWSTANDBY'
         self._volume = 0
-        self._source_list = {'TV': 'SITV', 'Tuner': 'SITUNER',
-                             'Internet Radio': 'SIIRP', 'Favorites': 'SIFVP'}
+        # Initial value 60dB, changed if we get a MVMAX
+        self._volume_max = 60
+        self._source_list = NORMAL_INPUTS.copy()
+        self._source_list.update(MEDIA_MODES)
         self._muted = False
         self._mediasource = ''
+        self._mediainfo = ''
+
+        self._should_setup_sources = True
+
+    def _setup_sources(self, telnet):
+        # NSFRN - Network name
+        self._name = self.telnet_request(telnet, 'NSFRN ?')[len('NSFRN '):]
+
+        # SSFUN - Configured sources with names
+        self._source_list = {}
+        for line in self.telnet_request(telnet, 'SSFUN ?', all_lines=True):
+            source, configured_name = line[len('SSFUN'):].split(" ", 1)
+            self._source_list[configured_name] = source
+
+        # SSSOD - Deleted sources
+        for line in self.telnet_request(telnet, 'SSSOD ?', all_lines=True):
+            source, status = line[len('SSSOD'):].split(" ", 1)
+            if status == 'DEL':
+                for pretty_name, name in self._source_list.items():
+                    if source == name:
+                        del self._source_list[pretty_name]
+                        break
 
     @classmethod
-    def telnet_request(cls, telnet, command):
+    def telnet_request(cls, telnet, command, all_lines=False):
         """Execute `command` and return the response."""
+        _LOGGER.debug('Sending: "%s"', command)
         telnet.write(command.encode('ASCII') + b'\r')
         lines = []
         while True:
@@ -68,12 +109,16 @@ class DenonDevice(MediaPlayerDevice):
             if not line:
                 break
             lines.append(line.decode('ASCII').strip())
+            _LOGGER.debug('Recived: "%s"', line)
 
+        if all_lines:
+            return lines
         return lines[0]
 
     def telnet_command(self, command):
         """Establish a telnet connection and sends `command`."""
         telnet = telnetlib.Telnet(self._host)
+        _LOGGER.debug('Sending: "%s"', command)
         telnet.write(command.encode('ASCII') + b'\r')
         telnet.read_very_eager()  # skip response
         telnet.close()
@@ -85,12 +130,30 @@ class DenonDevice(MediaPlayerDevice):
         except OSError:
             return False
 
+        if self._should_setup_sources:
+            self._setup_sources(telnet)
+            self._should_setup_sources = False
+
         self._pwstate = self.telnet_request(telnet, 'PW?')
-        volume_str = self.telnet_request(telnet, 'MV?')[len('MV'):]
-        self._volume = int(volume_str) / 60
+        for line in self.telnet_request(telnet, 'MV?', all_lines=True):
+            if line.startswith('MVMAX '):
+                # only grab two digit max, don't care about any half digit
+                self._volume_max = int(line[len('MVMAX '):len('MVMAX XX')])
+                continue
+            if line.startswith('MV'):
+                self._volume = int(line[len('MV'):])
         self._muted = (self.telnet_request(telnet, 'MU?') == 'MUON')
         self._mediasource = self.telnet_request(telnet, 'SI?')[len('SI'):]
 
+        if self._mediasource in MEDIA_MODES.values():
+            self._mediainfo = ""
+            answer_codes = ["NSE0", "NSE1X", "NSE2X", "NSE3X", "NSE4", "NSE5",
+                            "NSE6", "NSE7", "NSE8"]
+            for line in self.telnet_request(telnet, 'NSE', all_lines=True):
+                self._mediainfo += line[len(answer_codes.pop()):] + '\n'
+        else:
+            self._mediainfo = self.source
+
         telnet.close()
         return True
 
@@ -112,7 +175,7 @@ class DenonDevice(MediaPlayerDevice):
     @property
     def volume_level(self):
         """Volume level of the media player (0..1)."""
-        return self._volume
+        return self._volume / self._volume_max
 
     @property
     def is_volume_muted(self):
@@ -122,17 +185,27 @@ class DenonDevice(MediaPlayerDevice):
     @property
     def source_list(self):
         """List of available input sources."""
-        return list(self._source_list.keys())
+        return sorted(list(self._source_list.keys()))
 
     @property
     def media_title(self):
-        """Current media source."""
-        return self._mediasource
+        """Current media info."""
+        return self._mediainfo
 
     @property
     def supported_media_commands(self):
         """Flag of media commands that are supported."""
-        return SUPPORT_DENON
+        if self._mediasource in MEDIA_MODES.values():
+            return SUPPORT_DENON | SUPPORT_MEDIA_MODES
+        else:
+            return SUPPORT_DENON
+
+    @property
+    def source(self):
+        """Return the current input source."""
+        for pretty_name, name in self._source_list.items():
+            if self._mediasource == name:
+                return pretty_name
 
     def turn_off(self):
         """Turn off media player."""
@@ -148,8 +221,8 @@ class DenonDevice(MediaPlayerDevice):
 
     def set_volume_level(self, volume):
         """Set volume level, range 0..1."""
-        # 60dB max
-        self.telnet_command('MV' + str(round(volume * 60)).zfill(2))
+        self.telnet_command('MV' +
+                            str(round(volume * self._volume_max)).zfill(2))
 
     def mute_volume(self, mute):
         """Mute (true) or unmute (false) media player."""
@@ -163,6 +236,10 @@ class DenonDevice(MediaPlayerDevice):
         """Pause media player."""
         self.telnet_command('NS9B')
 
+    def media_stop(self):
+        """Pause media player."""
+        self.telnet_command('NS9C')
+
     def media_next_track(self):
         """Send the next track command."""
         self.telnet_command('NS9D')
@@ -177,4 +254,4 @@ class DenonDevice(MediaPlayerDevice):
 
     def select_source(self, source):
         """Select input source."""
-        self.telnet_command(self._source_list.get(source))
+        self.telnet_command('SI' + self._source_list.get(source))

homeassistant/components/media_player/denonavr.py

@@ -13,26 +13,27 @@ from homeassistant.components.media_player import (
     SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
     SUPPORT_SELECT_SOURCE, SUPPORT_PLAY_MEDIA, MEDIA_TYPE_CHANNEL,
     MediaPlayerDevice, PLATFORM_SCHEMA, SUPPORT_TURN_ON,
-    MEDIA_TYPE_MUSIC)
+    MEDIA_TYPE_MUSIC, SUPPORT_VOLUME_SET)
 from homeassistant.const import (
     CONF_HOST, STATE_OFF, STATE_PLAYING, STATE_PAUSED,
     CONF_NAME, STATE_ON)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['denonavr==0.1.6']
+REQUIREMENTS = ['denonavr==0.2.2']
 
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME = None
+KEY_DENON_CACHE = 'denonavr_hosts'
 
 SUPPORT_DENON = SUPPORT_VOLUME_STEP | SUPPORT_VOLUME_MUTE | \
     SUPPORT_TURN_ON | SUPPORT_TURN_OFF | \
     SUPPORT_SELECT_SOURCE | SUPPORT_PLAY_MEDIA | \
     SUPPORT_PAUSE | SUPPORT_PREVIOUS_TRACK | \
-    SUPPORT_NEXT_TRACK
+    SUPPORT_NEXT_TRACK | SUPPORT_VOLUME_SET
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_HOST): cv.string,
+    vol.Optional(CONF_HOST): cv.string,
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
 })
 
@@ -41,11 +42,53 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Denon platform."""
     import denonavr
 
-    receiver = denonavr.DenonAVR(config.get(CONF_HOST), config.get(CONF_NAME))
+    # Initialize list with receivers to be started
+    receivers = []
 
-    add_devices([DenonDevice(receiver)])
-    _LOGGER.info("Denon receiver at host %s initialized",
-                 config.get(CONF_HOST))
+    cache = hass.data.get(KEY_DENON_CACHE)
+    if cache is None:
+        cache = hass.data[KEY_DENON_CACHE] = set()
+
+    # Start assignment of host and name
+    # 1. option: manual setting
+    if config.get(CONF_HOST) is not None:
+        host = config.get(CONF_HOST)
+        name = config.get(CONF_NAME)
+        # Check if host not in cache, append it and save for later starting
+        if host not in cache:
+            cache.add(host)
+            receivers.append(
+                DenonDevice(denonavr.DenonAVR(host, name)))
+            _LOGGER.info("Denon receiver at host %s initialized", host)
+    # 2. option: discovery using netdisco
+    if discovery_info is not None:
+        host = discovery_info[0]
+        name = discovery_info[1]
+        # Check if host not in cache, append it and save for later starting
+        if host not in cache:
+            cache.add(host)
+            receivers.append(
+                DenonDevice(denonavr.DenonAVR(host, name)))
+            _LOGGER.info("Denon receiver at host %s initialized", host)
+    # 3. option: discovery using denonavr library
+    if config.get(CONF_HOST) is None and discovery_info is None:
+        d_receivers = denonavr.discover()
+        # More than one receiver could be discovered by that method
+        if d_receivers is not None:
+            for d_receiver in d_receivers:
+                host = d_receiver["host"]
+                name = d_receiver["friendlyName"]
+                # Check if host not in cache, append it and save for later
+                # starting
+                if host not in cache:
+                    cache.add(host)
+                    receivers.append(
+                        DenonDevice(denonavr.DenonAVR(host, name)))
+                    _LOGGER.info("Denon receiver at host %s initialized", host)
+
+    # Add all freshly discovered receivers
+    if receivers:
+        add_devices(receivers)
 
 
 class DenonDevice(MediaPlayerDevice):
@@ -107,7 +150,8 @@ class DenonDevice(MediaPlayerDevice):
     @property
     def volume_level(self):
         """Volume level of the media player (0..1)."""
-        # Volume is send in a format like -50.0. Minimum is around -80.0
+        # Volume is sent in a format like -50.0. Minimum is -80.0,
+        # maximum is 18.0
         return (float(self._volume) + 80) / 100
 
     @property
@@ -240,6 +284,22 @@ class DenonDevice(MediaPlayerDevice):
         """Volume down media player."""
         return self._receiver.volume_down()
 
+    def set_volume_level(self, volume):
+        """Set volume level, range 0..1."""
+        # Volume has to be sent in a format like -50.0. Minimum is -80.0,
+        # maximum is 18.0
+        volume_denon = float((volume * 100) - 80)
+        if volume_denon > 18:
+            volume_denon = float(18)
+        try:
+            if self._receiver.set_volume(volume_denon):
+                self._volume = volume_denon
+                return True
+            else:
+                return False
+        except ValueError:
+            return False
+
     def mute_volume(self, mute):
         """Send mute command."""
         return self._receiver.mute(mute)

homeassistant/components/media_player/emby.py

@@ -20,12 +20,15 @@ from homeassistant.const import (
     STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING, STATE_UNKNOWN)
 from homeassistant.helpers.event import (track_utc_time_change)
 from homeassistant.util import Throttle
+import homeassistant.util.dt as dt_util
 
-REQUIREMENTS = ['pyemby==0.1']
+REQUIREMENTS = ['pyemby==0.2']
 
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
 MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)
 
+MEDIA_TYPE_TRAILER = 'trailer'
+
 DEFAULT_PORT = 8096
 
 _LOGGER = logging.getLogger(__name__)
@@ -119,6 +122,8 @@ class EmbyClient(MediaPlayerDevice):
         self.update_sessions = update_sessions
         self.client = client
         self.set_device(device)
+        self.media_status_last_position = None
+        self.media_status_received = None
 
     def set_device(self, device):
         """Set the device property."""
@@ -178,6 +183,17 @@ class EmbyClient(MediaPlayerDevice):
         """Get the latest details."""
         self.update_devices(no_throttle=True)
         self.update_sessions(no_throttle=True)
+        # Check if we should update progress
+        try:
+            position = self.session['PlayState']['PositionTicks']
+        except (KeyError, TypeError):
+            self.media_status_last_position = None
+            self.media_status_received = None
+        else:
+            position = int(position) / 10000000
+            if position != self.media_status_last_position:
+                self.media_status_last_position = position
+                self.media_status_received = dt_util.utcnow()
 
     def play_percent(self):
         """Return current media percent complete."""
@@ -220,6 +236,8 @@ class EmbyClient(MediaPlayerDevice):
                 return MEDIA_TYPE_TVSHOW
             elif media_type == 'Movie':
                 return MEDIA_TYPE_VIDEO
+            elif media_type == 'Trailer':
+                return MEDIA_TYPE_TRAILER
             return None
         except KeyError:
             return None
@@ -233,19 +251,32 @@ class EmbyClient(MediaPlayerDevice):
             except KeyError:
                 return None
 
+    @property
+    def media_position(self):
+        """Position of current playing media in seconds."""
+        return self.media_status_last_position
+
+    @property
+    def media_position_updated_at(self):
+        """
+        When was the position of the current playing media valid.
+
+        Returns value from homeassistant.util.dt.utcnow().
+        """
+        return self.media_status_received
+
     @property
     def media_image_url(self):
         """Image url of current playing media."""
         if self.now_playing_item is not None:
             try:
                 return self.client.get_image(
-                    self.now_playing_item['ThumbItemId'], 'Thumb',
-                    self.play_percent())
+                    self.now_playing_item['ThumbItemId'], 'Thumb', 0)
             except KeyError:
                 try:
                     return self.client.get_image(
-                        self.now_playing_item['PrimaryImageItemId'], 'Primary',
-                        self.play_percent())
+                        self.now_playing_item[
+                            'PrimaryImageItemId'], 'Primary', 0)
                 except KeyError:
                     return None
 

homeassistant/components/media_player/kodi.py

@@ -36,10 +36,10 @@ SUPPORT_KODI = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_PASSWORD): cv.string,
     vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
     vol.Optional(CONF_TURN_OFF_ACTION, default=None): vol.In(TURN_OFF_ACTION),
-    vol.Optional(CONF_USERNAME): cv.string,
+    vol.Inclusive(CONF_USERNAME, 'auth'): cv.string,
+    vol.Inclusive(CONF_PASSWORD, 'auth'): cv.string,
 })
 
 
@@ -51,11 +51,19 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     if jsonrpc_url:
         url = jsonrpc_url.rstrip('/jsonrpc')
 
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+
+    if username is not None:
+        auth = (username, password)
+    else:
+        auth = None
+
     add_devices([
         KodiDevice(
             config.get(CONF_NAME),
             url,
-            auth=(config.get(CONF_USERNAME), config.get(CONF_PASSWORD)),
+            auth=auth,
             turn_off_action=config.get(CONF_TURN_OFF_ACTION)),
     ])
 
@@ -68,10 +76,21 @@ class KodiDevice(MediaPlayerDevice):
         import jsonrpc_requests
         self._name = name
         self._url = url
+        self._basic_auth_url = None
+
+        kwargs = {'timeout': 5}
+
+        if auth is not None:
+            kwargs['auth'] = auth
+            scheme, netloc, path, query, fragment = urllib.parse.urlsplit(url)
+            self._basic_auth_url = \
+                urllib.parse.urlunsplit((scheme, '{}:{}@{}'.format
+                                         (auth[0], auth[1], netloc),
+                                         path, query, fragment))
+
         self._server = jsonrpc_requests.Server(
-            '{}/jsonrpc'.format(self._url),
-            auth=auth,
-            timeout=5)
+            '{}/jsonrpc'.format(self._url), **kwargs)
+
         self._turn_off_action = turn_off_action
         self._players = list()
         self._properties = None
@@ -182,6 +201,11 @@ class KodiDevice(MediaPlayerDevice):
         url_components = urllib.parse.urlparse(self._item['thumbnail'])
 
         if url_components.scheme == 'image':
+            if self._basic_auth_url is not None:
+                return '{}/image/{}'.format(
+                    self._basic_auth_url,
+                    urllib.parse.quote_plus(self._item['thumbnail']))
+
             return '{}/image/{}'.format(
                 self._url,
                 urllib.parse.quote_plus(self._item['thumbnail']))

homeassistant/components/media_player/onkyo.py

@@ -89,7 +89,7 @@ class OnkyoDevice(MediaPlayerDevice):
         except (ValueError, OSError, AttributeError, AssertionError):
             if self._receiver.command_socket:
                 self._receiver.command_socket = None
-                _LOGGER.info('Reseting connection to %s.', self._name)
+                _LOGGER.info('Resetting connection to %s.', self._name)
             else:
                 _LOGGER.info('%s is disconnected. Attempting to reconnect.',
                              self._name)
@@ -173,7 +173,7 @@ class OnkyoDevice(MediaPlayerDevice):
 
     def turn_on(self):
         """Turn the media player on."""
-        self._receiver.power_on()
+        self.command('system-power on')
 
     def select_source(self, source):
         """Set the input source."""

homeassistant/components/media_player/panasonic_viera.py

@@ -10,16 +10,20 @@ import voluptuous as vol
 
 from homeassistant.components.media_player import (
     SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_TURN_ON, SUPPORT_TURN_OFF,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
     SUPPORT_VOLUME_STEP, MediaPlayerDevice, PLATFORM_SCHEMA)
 from homeassistant.const import (
     CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN, CONF_PORT)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['panasonic_viera==0.2']
+REQUIREMENTS = ['panasonic_viera==0.2',
+                'wakeonlan==0.2.2']
 
 _LOGGER = logging.getLogger(__name__)
 
+CONF_MAC = 'mac'
+
 DEFAULT_NAME = 'Panasonic Viera TV'
 DEFAULT_PORT = 55000
 
@@ -30,6 +34,7 @@ SUPPORT_VIERATV = SUPPORT_PAUSE | SUPPORT_VOLUME_STEP | \
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
+    vol.Optional(CONF_MAC): cv.string,
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
 })
@@ -40,6 +45,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Panasonic Viera TV platform."""
     from panasonic_viera import RemoteControl
 
+    mac = config.get(CONF_MAC)
     name = config.get(CONF_NAME)
     port = config.get(CONF_PORT)
 
@@ -51,29 +57,25 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
         host = vals[0]
         remote = RemoteControl(host, port)
-        add_devices([PanasonicVieraTVDevice(name, remote)])
+        add_devices([PanasonicVieraTVDevice(mac, name, remote)])
         return True
 
     host = config.get(CONF_HOST)
     remote = RemoteControl(host, port)
 
-    try:
-        remote.get_mute()
-    except OSError as error:
-        _LOGGER.error('Panasonic Viera TV is not available at %s:%d: %s',
-                      host, port, error)
-        return False
-
-    add_devices([PanasonicVieraTVDevice(name, remote)])
+    add_devices([PanasonicVieraTVDevice(mac, name, remote)])
     return True
 
 
 class PanasonicVieraTVDevice(MediaPlayerDevice):
     """Representation of a Panasonic Viera TV."""
 
-    def __init__(self, name, remote):
+    def __init__(self, mac, name, remote):
         """Initialize the Panasonic device."""
+        from wakeonlan import wol
         # Save a reference to the imported class
+        self._wol = wol
+        self._mac = mac
         self._name = name
         self._muted = False
         self._playing = True
@@ -123,8 +125,15 @@ class PanasonicVieraTVDevice(MediaPlayerDevice):
     @property
     def supported_media_commands(self):
         """Flag of media commands that are supported."""
+        if self._mac:
+            return SUPPORT_VIERATV | SUPPORT_TURN_ON
         return SUPPORT_VIERATV
 
+    def turn_on(self):
+        """Turn on the media player."""
+        if self._mac:
+            self._wol.send_magic_packet(self._mac)
+
     def turn_off(self):
         """Turn off media player."""
         self.send_key('NRC_POWER-ONOFF')

homeassistant/components/media_player/plex.py

@@ -200,6 +200,7 @@ class PlexClient(MediaPlayerDevice):
         self.update_devices = update_devices
         self.update_sessions = update_sessions
         self.set_device(device)
+        self._season = None
 
     def set_device(self, device):
         """Set the device property."""
@@ -240,9 +241,15 @@ class PlexClient(MediaPlayerDevice):
 
     def update(self):
         """Get the latest details."""
+        from plexapi.video import Show
+
         self.update_devices(no_throttle=True)
         self.update_sessions(no_throttle=True)
 
+        if isinstance(self.session, Show):
+            self._season = self._convert_na_to_none(
+                self.session.seasons()[0].index)
+
     # pylint: disable=no-self-use, singleton-comparison
     def _convert_na_to_none(self, value):
         """Convert PlexAPI _NA() instances to None."""
@@ -310,9 +317,7 @@ class PlexClient(MediaPlayerDevice):
     @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._convert_na_to_none(self.session.seasons()[0].index)
+        return self._season
 
     @property
     def media_series_title(self):

homeassistant/components/media_player/samsungtv.py

@@ -5,6 +5,7 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.samsungtv/
 """
 import logging
+import socket
 
 import voluptuous as vol
 
@@ -26,6 +27,8 @@ DEFAULT_NAME = 'Samsung TV Remote'
 DEFAULT_PORT = 55000
 DEFAULT_TIMEOUT = 0
 
+KNOWN_DEVICES_KEY = 'samsungtv_known_devices'
+
 SUPPORT_SAMSUNGTV = SUPPORT_PAUSE | SUPPORT_VOLUME_STEP | \
     SUPPORT_VOLUME_MUTE | SUPPORT_PREVIOUS_TRACK | \
     SUPPORT_NEXT_TRACK | SUPPORT_TURN_OFF
@@ -41,25 +44,42 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Samsung TV platform."""
-    name = config.get(CONF_NAME)
+    known_devices = hass.data.get(KNOWN_DEVICES_KEY)
+    if known_devices is None:
+        known_devices = set()
+        hass.data[KNOWN_DEVICES_KEY] = known_devices
 
-    # Generate a configuration for the Samsung library
-    remote_config = {
-        'name': 'HomeAssistant',
-        'description': config.get(CONF_NAME),
-        'id': 'ha.component.samsung',
-        'port': config.get(CONF_PORT),
-        'host': config.get(CONF_HOST),
-        'timeout': config.get(CONF_TIMEOUT),
-    }
+    # Is this a manual configuration?
+    if config.get(CONF_HOST) is not None:
+        host = config.get(CONF_HOST)
+        port = config.get(CONF_PORT)
+        name = config.get(CONF_NAME)
+        timeout = config.get(CONF_TIMEOUT)
+    elif discovery_info is not None:
+        tv_name, model, host = discovery_info
+        name = "{} ({})".format(tv_name, model)
+        port = DEFAULT_PORT
+        timeout = DEFAULT_TIMEOUT
+    else:
+        _LOGGER.warning(
+            'Internal error on samsungtv component. Cannot determine device')
+        return
 
-    add_devices([SamsungTVDevice(name, remote_config)])
+    # Only add a device once, so discovered devices do not override manual
+    # config.
+    ip_addr = socket.gethostbyname(host)
+    if ip_addr not in known_devices:
+        known_devices.add(ip_addr)
+        add_devices([SamsungTVDevice(host, port, name, timeout)])
+        _LOGGER.info("Samsung TV %s:%d added as '%s'", host, port, name)
+    else:
+        _LOGGER.info("Ignoring duplicate Samsung TV %s:%d", host, port)
 
 
 class SamsungTVDevice(MediaPlayerDevice):
     """Representation of a Samsung TV."""
 
-    def __init__(self, name, config):
+    def __init__(self, host, port, name, timeout):
         """Initialize the Samsung device."""
         from samsungctl import Remote
         # Save a reference to the imported class
@@ -71,7 +91,15 @@ class SamsungTVDevice(MediaPlayerDevice):
         self._playing = True
         self._state = STATE_UNKNOWN
         self._remote = None
-        self._config = config
+        # Generate a configuration for the Samsung library
+        self._config = {
+            'name': 'HomeAssistant',
+            'description': name,
+            'id': 'ha.component.samsung',
+            'port': port,
+            'host': host,
+            'timeout': timeout,
+        }
 
     def update(self):
         """Retrieve the latest data."""

homeassistant/components/media_player/sonos.py

@@ -15,7 +15,7 @@ from homeassistant.components.media_player import (
     ATTR_MEDIA_ENQUEUE, DOMAIN, MEDIA_TYPE_MUSIC, SUPPORT_NEXT_TRACK,
     SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK,
     SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_CLEAR_PLAYLIST,
-    SUPPORT_SELECT_SOURCE, MediaPlayerDevice, PLATFORM_SCHEMA)
+    SUPPORT_SELECT_SOURCE, MediaPlayerDevice, PLATFORM_SCHEMA, SUPPORT_STOP)
 from homeassistant.const import (
     STATE_IDLE, STATE_PAUSED, STATE_PLAYING, STATE_OFF, ATTR_ENTITY_ID,
     CONF_HOSTS)
@@ -36,9 +36,10 @@ _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_PLAY_MEDIA |\
-    SUPPORT_SEEK | SUPPORT_CLEAR_PLAYLIST | SUPPORT_SELECT_SOURCE
+SUPPORT_SONOS = SUPPORT_STOP | SUPPORT_PAUSE | SUPPORT_VOLUME_SET |\
+    SUPPORT_VOLUME_MUTE | SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK |\
+    SUPPORT_PLAY_MEDIA | SUPPORT_SEEK | SUPPORT_CLEAR_PLAYLIST |\
+    SUPPORT_SELECT_SOURCE
 
 SERVICE_GROUP_PLAYERS = 'sonos_group_players'
 SERVICE_UNJOIN = 'sonos_unjoin'
@@ -289,6 +290,7 @@ class SonosDevice(MediaPlayerDevice):
         self._media_next_title = None
         self._support_previous_track = False
         self._support_next_track = False
+        self._support_stop = False
         self._support_pause = False
         self._current_track_uri = None
         self._current_track_is_radio_stream = False
@@ -296,6 +298,8 @@ class SonosDevice(MediaPlayerDevice):
         self._last_avtransport_event = None
         self._is_playing_line_in = None
         self._is_playing_tv = None
+        self._favorite_sources = None
+        self._source_name = None
         self.soco_snapshot = Snapshot(self._player)
 
     @property
@@ -423,6 +427,7 @@ class SonosDevice(MediaPlayerDevice):
 
                 media_position = None
                 media_position_updated_at = None
+                source_name = None
 
                 is_radio_stream = \
                     current_media_uri.startswith('x-sonosapi-stream:') or \
@@ -433,6 +438,7 @@ class SonosDevice(MediaPlayerDevice):
 
                     support_previous_track = False
                     support_next_track = False
+                    support_stop = False
                     support_pause = False
 
                     if is_playing_tv:
@@ -440,6 +446,8 @@ class SonosDevice(MediaPlayerDevice):
                     else:
                         media_artist = SUPPORT_SOURCE_LINEIN
 
+                    source_name = media_artist
+
                     media_album_name = None
                     media_title = None
                     media_image_url = None
@@ -450,8 +458,19 @@ class SonosDevice(MediaPlayerDevice):
                     )
                     support_previous_track = False
                     support_next_track = False
+                    support_stop = False
                     support_pause = False
 
+                    source_name = 'Radio'
+                    # Check if currently playing radio station is in favorites
+                    favs = self._player.get_sonos_favorites()['favorites']
+                    favc = [
+                        fav for fav in favs if fav['uri'] == current_media_uri
+                        ]
+                    if len(favc) == 1:
+                        src = favc.pop()
+                        source_name = src['title']
+
                     # for radio streams we set the radio station name as the
                     # title.
                     if media_artist and media_title:
@@ -506,6 +525,7 @@ class SonosDevice(MediaPlayerDevice):
                     )
                     support_previous_track = True
                     support_next_track = True
+                    support_stop = True
                     support_pause = True
 
                     position_info = self._player.avTransport.GetPositionInfo(
@@ -583,9 +603,11 @@ class SonosDevice(MediaPlayerDevice):
                 self._current_track_is_radio_stream = is_radio_stream
                 self._support_previous_track = support_previous_track
                 self._support_next_track = support_next_track
+                self._support_stop = support_stop
                 self._support_pause = support_pause
                 self._is_playing_tv = is_playing_tv
                 self._is_playing_line_in = is_playing_line_in
+                self._source_name = source_name
 
                 # update state of the whole group
                 # pylint: disable=protected-access
@@ -595,6 +617,8 @@ class SonosDevice(MediaPlayerDevice):
 
                 if self._queue is None and self.entity_id is not None:
                     self._subscribe_to_player_events()
+            favs = self._player.get_sonos_favorites().get('favorites', [])
+            self._favorite_sources = [fav['title'] for fav in favs]
         else:
             self._player_volume = None
             self._player_volume_muted = None
@@ -614,9 +638,12 @@ class SonosDevice(MediaPlayerDevice):
             self._current_track_is_radio_stream = False
             self._support_previous_track = False
             self._support_next_track = False
+            self._support_stop = False
             self._support_pause = False
             self._is_playing_tv = False
             self._is_playing_line_in = False
+            self._favorite_sources = None
+            self._source_name = None
 
         self._last_avtransport_event = None
 
@@ -764,16 +791,15 @@ class SonosDevice(MediaPlayerDevice):
 
         supported = SUPPORT_SONOS
 
-        if not self.source_list:
-            # some devices do not allow source selection
-            supported = supported ^ SUPPORT_SELECT_SOURCE
-
         if not self._support_previous_track:
             supported = supported ^ SUPPORT_PREVIOUS_TRACK
 
         if not self._support_next_track:
             supported = supported ^ SUPPORT_NEXT_TRACK
 
+        if not self._support_stop:
+            supported = supported ^ SUPPORT_STOP
+
         if not self._support_pause:
             supported = supported ^ SUPPORT_PAUSE
 
@@ -798,19 +824,31 @@ class SonosDevice(MediaPlayerDevice):
     def select_source(self, source):
         """Select input source."""
         if source == SUPPORT_SOURCE_LINEIN:
+            self._source_name = SUPPORT_SOURCE_LINEIN
             self._player.switch_to_line_in()
         elif source == SUPPORT_SOURCE_TV:
+            self._source_name = SUPPORT_SOURCE_TV
             self._player.switch_to_tv()
+        else:
+            favorites = self._player.get_sonos_favorites()['favorites']
+            fav = [fav for fav in favorites if fav['title'] == source]
+            if len(fav) == 1:
+                src = fav.pop()
+                self._source_name = src['title']
+                self._player.play_uri(src['uri'], src['meta'], src['title'])
 
     @property
     def source_list(self):
         """List of available input sources."""
         model_name = self._speaker_info['model_name']
 
+        sources = self._favorite_sources
+
         if 'PLAY:5' in model_name:
-            return [SUPPORT_SOURCE_LINEIN]
+            sources += [SUPPORT_SOURCE_LINEIN]
         elif 'PLAYBAR' in model_name:
-            return [SUPPORT_SOURCE_LINEIN, SUPPORT_SOURCE_TV]
+            sources += [SUPPORT_SOURCE_LINEIN, SUPPORT_SOURCE_TV]
+        return sources
 
     @property
     def source(self):
@@ -818,12 +856,7 @@ class SonosDevice(MediaPlayerDevice):
         if self._coordinator:
             return self._coordinator.source
         else:
-            if self._is_playing_line_in:
-                return SUPPORT_SOURCE_LINEIN
-            elif self._is_playing_tv:
-                return SUPPORT_SOURCE_TV
-
-        return None
+            return self._source_name
 
     def turn_off(self):
         """Turn off media player."""
@@ -836,6 +869,13 @@ class SonosDevice(MediaPlayerDevice):
         else:
             self._player.play()
 
+    def media_stop(self):
+        """Send stop command."""
+        if self._coordinator:
+            self._coordinator.media_stop()
+        else:
+            self._player.stop()
+
     def media_pause(self):
         """Send pause command."""
         if self._coordinator:

homeassistant/components/media_player/universal.py

@@ -14,7 +14,7 @@ from homeassistant.components.media_player import (
     ATTR_MEDIA_CONTENT_TYPE, ATTR_MEDIA_DURATION, ATTR_MEDIA_EPISODE,
     ATTR_MEDIA_PLAYLIST, ATTR_MEDIA_SEASON, ATTR_MEDIA_SEEK_POSITION,
     ATTR_MEDIA_SERIES_TITLE, ATTR_MEDIA_TITLE, ATTR_MEDIA_TRACK,
-    ATTR_MEDIA_VOLUME_LEVEL, ATTR_MEDIA_VOLUME_MUTED,
+    ATTR_MEDIA_VOLUME_LEVEL, ATTR_MEDIA_VOLUME_MUTED, ATTR_INPUT_SOURCE_LIST,
     ATTR_SUPPORTED_MEDIA_COMMANDS, DOMAIN, SERVICE_PLAY_MEDIA,
     SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
     SUPPORT_VOLUME_STEP, SUPPORT_SELECT_SOURCE, SUPPORT_CLEAR_PLAYLIST,
@@ -38,6 +38,7 @@ CONF_COMMANDS = 'commands'
 CONF_PLATFORM = 'platform'
 CONF_SERVICE = 'service'
 CONF_SERVICE_DATA = 'service_data'
+ATTR_DATA = 'data'
 CONF_STATE = 'state'
 
 OFF_STATES = [STATE_IDLE, STATE_OFF]
@@ -178,14 +179,15 @@ class UniversalMediaPlayer(MediaPlayerDevice):
     def _call_service(self, service_name, service_data=None,
                       allow_override=False):
         """Call either a specified or active child's service."""
-        if allow_override and service_name in self._cmds:
-            call_from_config(
-                self.hass, self._cmds[service_name], blocking=True)
-            return
-
         if service_data is None:
             service_data = {}
 
+        if allow_override and service_name in self._cmds:
+            call_from_config(
+                self.hass, self._cmds[service_name],
+                variables=service_data, blocking=True)
+            return
+
         active_child = self._child_state
         service_data[ATTR_ENTITY_ID] = active_child.entity_id
 
@@ -233,7 +235,7 @@ class UniversalMediaPlayer(MediaPlayerDevice):
     @property
     def volume_level(self):
         """Volume level of entity specified in attributes or active child."""
-        return self._child_attr(ATTR_MEDIA_VOLUME_LEVEL)
+        return self._override_or_child_attr(ATTR_MEDIA_VOLUME_LEVEL)
 
     @property
     def is_volume_muted(self):
@@ -261,6 +263,17 @@ class UniversalMediaPlayer(MediaPlayerDevice):
         """Image url of current playing media."""
         return self._child_attr(ATTR_ENTITY_PICTURE)
 
+    @property
+    def entity_picture(self):
+        """
+        Return image of the media playing.
+
+        The universal media player doesn't use the parent class logic, since
+        the url is coming from child entity pictures which have already been
+        sent through the API proxy.
+        """
+        return self.media_image_url
+
     @property
     def media_title(self):
         """Title of current playing media."""
@@ -322,9 +335,14 @@ class UniversalMediaPlayer(MediaPlayerDevice):
         return self._child_attr(ATTR_APP_NAME)
 
     @property
-    def current_source(self):
+    def source(self):
         """"Return the current input source of the device."""
-        return self._child_attr(ATTR_INPUT_SOURCE)
+        return self._override_or_child_attr(ATTR_INPUT_SOURCE)
+
+    @property
+    def source_list(self):
+        """List of available input sources."""
+        return self._override_or_child_attr(ATTR_INPUT_SOURCE_LIST)
 
     @property
     def supported_media_commands(self):
@@ -340,6 +358,8 @@ class UniversalMediaPlayer(MediaPlayerDevice):
                                               SERVICE_VOLUME_DOWN]]):
             flags |= SUPPORT_VOLUME_STEP
             flags &= ~SUPPORT_VOLUME_SET
+        elif SERVICE_VOLUME_SET in self._cmds:
+            flags |= SUPPORT_VOLUME_SET
 
         if SERVICE_VOLUME_MUTE in self._cmds and \
                 ATTR_MEDIA_VOLUME_MUTED in self._attrs:
@@ -376,7 +396,7 @@ class UniversalMediaPlayer(MediaPlayerDevice):
     def set_volume_level(self, volume_level):
         """Set volume level, range 0..1."""
         data = {ATTR_MEDIA_VOLUME_LEVEL: volume_level}
-        self._call_service(SERVICE_VOLUME_SET, data)
+        self._call_service(SERVICE_VOLUME_SET, data, allow_override=True)
 
     def media_play(self):
         """Send play commmand."""
@@ -424,7 +444,7 @@ class UniversalMediaPlayer(MediaPlayerDevice):
     def select_source(self, source):
         """Set the input source."""
         data = {ATTR_INPUT_SOURCE: source}
-        self._call_service(SERVICE_SELECT_SOURCE, data)
+        self._call_service(SERVICE_SELECT_SOURCE, data, allow_override=True)
 
     def clear_playlist(self):
         """Clear players playlist."""

homeassistant/components/media_player/vlc.py

@@ -0,0 +1,152 @@
+"""
+Provide functionality to interact with vlc devices on the network.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/media_player.vlc/
+"""
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.media_player import (
+    SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    MediaPlayerDevice, PLATFORM_SCHEMA, MEDIA_TYPE_MUSIC)
+from homeassistant.const import (CONF_NAME, STATE_IDLE, STATE_PAUSED,
+                                 STATE_PLAYING)
+import homeassistant.helpers.config_validation as cv
+import homeassistant.util.dt as dt_util
+
+REQUIREMENTS = ['python-vlc==1.1.2']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+SUPPORT_VLC = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
+    SUPPORT_PLAY_MEDIA
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME): cv.string,
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the vlc platform."""
+    add_devices([VlcDevice(config.get(CONF_NAME))])
+
+
+class VlcDevice(MediaPlayerDevice):
+    """Representation of a vlc player."""
+
+    def __init__(self, name):
+        """Initialize the vlc device."""
+        import vlc
+        self._instance = vlc.Instance()
+        self._vlc = self._instance.media_player_new()
+        self._name = name
+        self._volume = None
+        self._muted = None
+        self._state = None
+        self._media_position_updated_at = None
+        self._media_position = None
+        self._media_duration = None
+
+    def update(self):
+        """Get the latest details from the device."""
+        import vlc
+        status = self._vlc.get_state()
+        if status == vlc.State.Playing:
+            self._state = STATE_PLAYING
+        elif status == vlc.State.Paused:
+            self._state = STATE_PAUSED
+        else:
+            self._state = STATE_IDLE
+        self._media_duration = self._vlc.get_length()/1000
+        self._media_position = self._vlc.get_position() * self._media_duration
+        self._media_position_updated_at = dt_util.utcnow()
+
+        self._volume = self._vlc.audio_get_volume() / 100
+        self._muted = (self._vlc.audio_get_mute() == 1)
+
+        return True
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._state
+
+    @property
+    def volume_level(self):
+        """Volume level of the media player (0..1)."""
+        return self._volume
+
+    @property
+    def is_volume_muted(self):
+        """Boolean if volume is currently muted."""
+        return self._muted
+
+    @property
+    def supported_media_commands(self):
+        """Flag of media commands that are supported."""
+        return SUPPORT_VLC
+
+    @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."""
+        return self._media_duration
+
+    @property
+    def media_position(self):
+        """Position of current playing media in seconds."""
+        return self._media_position
+
+    @property
+    def media_position_updated_at(self):
+        """When was the position of the current playing media valid."""
+        return self._media_position_updated_at
+
+    def media_seek(self, position):
+        """Seek the media to a specific location."""
+        track_length = self._vlc.get_length()/1000
+        self._vlc.set_position(position/track_length)
+
+    def mute_volume(self, mute):
+        """Mute the volume."""
+        self._vlc.audio_set_mute(mute)
+        self._muted = mute
+
+    def set_volume_level(self, volume):
+        """Set volume level, range 0..1."""
+        self._vlc.audio_set_volume(int(volume * 100))
+        self._volume = volume
+
+    def media_play(self):
+        """Send play commmand."""
+        self._vlc.play()
+        self._state = STATE_PLAYING
+
+    def media_pause(self):
+        """Send pause command."""
+        self._vlc.pause()
+        self._state = STATE_PAUSED
+
+    def play_media(self, media_type, media_id, **kwargs):
+        """Play media from a URL or file."""
+        if not media_type == MEDIA_TYPE_MUSIC:
+            _LOGGER.error(
+                "Invalid media type %s. Only %s is supported",
+                media_type, MEDIA_TYPE_MUSIC)
+            return
+        self._vlc.set_media(self._instance.media_new(media_id))
+        self._vlc.play()
+        self._state = STATE_PLAYING

homeassistant/components/media_player/webostv.py

@@ -1,5 +1,5 @@
 """
-Support for interface with an LG WebOS TV.
+Support for interface with an LG webOS Smart TV.
 
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.webostv/
@@ -12,53 +12,48 @@ import voluptuous as vol
 
 import homeassistant.util as util
 from homeassistant.components.media_player import (
+    SUPPORT_TURN_ON, SUPPORT_TURN_OFF,
     SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
     SUPPORT_SELECT_SOURCE, SUPPORT_PLAY_MEDIA, MEDIA_TYPE_CHANNEL,
     MediaPlayerDevice, PLATFORM_SCHEMA)
 from homeassistant.const import (
-    CONF_HOST, CONF_CUSTOMIZE, STATE_OFF, STATE_PLAYING, STATE_PAUSED,
+    CONF_HOST, CONF_MAC, CONF_CUSTOMIZE, STATE_OFF,
+    STATE_PLAYING, STATE_PAUSED,
     STATE_UNKNOWN, CONF_NAME)
 from homeassistant.loader import get_component
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['https://github.com/TheRealLink/pylgtv'
                 '/archive/v0.1.2.zip'
-                '#pylgtv==0.1.2']
+                '#pylgtv==0.1.2',
+                'websockets==3.2',
+                'wakeonlan==0.2.2']
 
-_CONFIGURING = {}
+_CONFIGURING = {}  # type: Dict[str, str]
 _LOGGER = logging.getLogger(__name__)
 
 CONF_SOURCES = 'sources'
 
-DEFAULT_NAME = 'LG WebOS Smart TV'
+DEFAULT_NAME = 'LG webOS Smart TV'
 
-SUPPORT_WEBOSTV = SUPPORT_PAUSE | SUPPORT_VOLUME_STEP | \
-                  SUPPORT_VOLUME_MUTE | SUPPORT_PREVIOUS_TRACK | \
-                  SUPPORT_NEXT_TRACK | SUPPORT_TURN_OFF | \
-                  SUPPORT_SELECT_SOURCE | SUPPORT_PLAY_MEDIA
+SUPPORT_WEBOSTV = SUPPORT_TURN_OFF | \
+    SUPPORT_NEXT_TRACK | SUPPORT_PAUSE | SUPPORT_PREVIOUS_TRACK | \
+    SUPPORT_VOLUME_MUTE | SUPPORT_VOLUME_STEP | \
+    SUPPORT_SELECT_SOURCE | SUPPORT_PLAY_MEDIA
 
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
 MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)
 
-WEBOS_APP_LIVETV = 'com.webos.app.livetv'
-WEBOS_APP_YOUTUBE = 'youtube.leanback.v4'
-WEBOS_APP_MAKO = 'makotv'
-
-WEBOS_APPS_SHORT = {
-    'livetv': WEBOS_APP_LIVETV,
-    'youtube': WEBOS_APP_YOUTUBE,
-    'makotv': WEBOS_APP_MAKO
-}
-
 CUSTOMIZE_SCHEMA = vol.Schema({
     vol.Optional(CONF_SOURCES):
-        vol.All(cv.ensure_list, [vol.In(WEBOS_APPS_SHORT)]),
+        vol.All(cv.ensure_list, [cv.string]),
 })
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_HOST): cv.string,
+    vol.Optional(CONF_MAC): cv.string,
     vol.Optional(CONF_CUSTOMIZE, default={}): CUSTOMIZE_SCHEMA,
 })
 
@@ -79,15 +74,17 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     if host in _CONFIGURING:
         return
 
+    mac = config.get(CONF_MAC)
     name = config.get(CONF_NAME)
     customize = config.get(CONF_CUSTOMIZE)
-    setup_tv(host, name, customize, hass, add_devices)
+    setup_tv(host, mac, name, customize, hass, add_devices)
 
 
-def setup_tv(host, name, customize, hass, add_devices):
-    """Setup a phue bridge based on host parameter."""
+def setup_tv(host, mac, name, customize, hass, add_devices):
+    """Setup a LG WebOS TV based on host parameter."""
     from pylgtv import WebOsClient
     from pylgtv import PyLGTVPairException
+    from websockets.exceptions import ConnectionClosed
 
     client = WebOsClient(host)
 
@@ -98,15 +95,16 @@ def setup_tv(host, name, customize, hass, add_devices):
                 client.register()
             except PyLGTVPairException:
                 _LOGGER.warning(
-                    "Connected to LG WebOS TV %s but not paired", host)
+                    "Connected to LG webOS TV %s but not paired", host)
                 return
-            except OSError:
+            except (OSError, ConnectionClosed):
                 _LOGGER.error("Unable to connect to host %s", host)
                 return
         else:
             # Not registered, request configuration.
-            _LOGGER.warning("LG WebOS TV %s needs to be paired", host)
-            request_configuration(host, name, customize, hass, add_devices)
+            _LOGGER.warning("LG webOS TV %s needs to be paired", host)
+            request_configuration(
+                host, mac, name, customize, hass, add_devices)
             return
 
     # If we came here and configuring this host, mark as done.
@@ -115,10 +113,11 @@ def setup_tv(host, name, customize, hass, add_devices):
         configurator = get_component('configurator')
         configurator.request_done(request_id)
 
-    add_devices([LgWebOSDevice(host, name, customize)])
+    add_devices([LgWebOSDevice(host, mac, name, customize)], True)
 
 
-def request_configuration(host, name, customize, hass, add_devices):
+def request_configuration(
+        host, mac, name, customize, hass, add_devices):
     """Request configuration steps from the user."""
     configurator = get_component('configurator')
 
@@ -131,10 +130,10 @@ def request_configuration(host, name, customize, hass, add_devices):
     # pylint: disable=unused-argument
     def lgtv_configuration_callback(data):
         """The actions to do when our configuration callback is called."""
-        setup_tv(host, name, customize, hass, add_devices)
+        setup_tv(host, mac, name, customize, hass, add_devices)
 
     _CONFIGURING[host] = configurator.request_config(
-        hass, 'LG WebOS TV', lgtv_configuration_callback,
+        hass, name, lgtv_configuration_callback,
         description='Click start and accept the pairing request on your TV.',
         description_image='/static/images/config_webos.png',
         submit_caption='Start pairing request'
@@ -144,10 +143,13 @@ def request_configuration(host, name, customize, hass, add_devices):
 class LgWebOSDevice(MediaPlayerDevice):
     """Representation of a LG WebOS TV."""
 
-    def __init__(self, host, name, customize):
+    def __init__(self, host, mac, name, customize):
         """Initialize the webos device."""
         from pylgtv import WebOsClient
+        from wakeonlan import wol
         self._client = WebOsClient(host)
+        self._wol = wol
+        self._mac = mac
         self._customize = customize
 
         self._name = name
@@ -158,15 +160,14 @@ class LgWebOSDevice(MediaPlayerDevice):
         self._volume = 0
         self._current_source = None
         self._current_source_id = None
-        self._source_list = None
         self._state = STATE_UNKNOWN
-        self._app_list = None
-
-        self.update()
+        self._source_list = {}
+        self._app_list = {}
 
     @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS)
     def update(self):
         """Retrieve the latest data."""
+        from websockets.exceptions import ConnectionClosed
         try:
             self._state = STATE_PLAYING
             self._muted = self._client.get_muted()
@@ -175,20 +176,16 @@ class LgWebOSDevice(MediaPlayerDevice):
             self._source_list = {}
             self._app_list = {}
 
-            custom_sources = []
-            for source in self._customize.get(CONF_SOURCES, []):
-                app_id = WEBOS_APPS_SHORT.get(source, None)
-                if app_id:
-                    custom_sources.append(app_id)
-                else:
-                    custom_sources.append(source)
+            custom_sources = self._customize.get(CONF_SOURCES, [])
 
             for app in self._client.get_apps():
                 self._app_list[app['id']] = app
                 if app['id'] == self._current_source_id:
                     self._current_source = app['title']
                     self._source_list[app['title']] = app
-                if app['id'] in custom_sources:
+                elif (app['id'] in custom_sources or
+                      any(word in app['title'] for word in custom_sources) or
+                      any(word in app['id'] for word in custom_sources)):
                     self._source_list[app['title']] = app
 
             for source in self._client.get_inputs():
@@ -197,7 +194,7 @@ class LgWebOSDevice(MediaPlayerDevice):
                 app = self._app_list[source['appId']]
                 self._source_list[app['title']] = app
 
-        except OSError:
+        except (OSError, ConnectionClosed):
             self._state = STATE_OFF
 
     @property
@@ -245,12 +242,23 @@ class LgWebOSDevice(MediaPlayerDevice):
     @property
     def supported_media_commands(self):
         """Flag of media commands that are supported."""
+        if self._mac:
+            return SUPPORT_WEBOSTV | SUPPORT_TURN_ON
         return SUPPORT_WEBOSTV
 
     def turn_off(self):
         """Turn off media player."""
+        from websockets.exceptions import ConnectionClosed
         self._state = STATE_OFF
-        self._client.power_off()
+        try:
+            self._client.power_off()
+        except (OSError, ConnectionClosed):
+            pass
+
+    def turn_on(self):
+        """Turn on the media player."""
+        if self._mac:
+            self._wol.send_magic_packet(self._mac)
 
     def volume_up(self):
         """Volume up the media player."""

homeassistant/components/nest.py

@@ -19,8 +19,8 @@ _LOGGER = logging.getLogger(__name__)
 
 REQUIREMENTS = [
     'http://github.com/technicalpickles/python-nest'
-    '/archive/2512973b4b390d3965da43529cd20402ad374bfa.zip'  # nest-cam branch
-    '#python-nest==3.0.0']
+    '/archive/b8391d2b3cb8682f8b0c2bdff477179983609f39.zip'  # nest-cam branch
+    '#python-nest==3.0.2']
 
 DOMAIN = 'nest'
 

homeassistant/components/netatmo.py

@@ -18,7 +18,7 @@ from homeassistant.util import Throttle
 
 REQUIREMENTS = [
     'https://github.com/jabesq/netatmo-api-python/archive/'
-    'v0.7.0.zip#lnetatmo==0.7.0']
+    'v0.8.0.zip#lnetatmo==0.8.0']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -30,6 +30,7 @@ NETATMO_AUTH = None
 DEFAULT_DISCOVERY = True
 
 MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=10)
+MIN_TIME_BETWEEN_EVENT_UPDATES = timedelta(seconds=10)
 
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: vol.Schema({
@@ -72,10 +73,11 @@ class WelcomeData(object):
         self.auth = auth
         self.welcomedata = None
         self.camera_names = []
+        self.module_names = []
         self.home = home
 
     def get_camera_names(self):
-        """Return all module available on the API as a list."""
+        """Return all camera available on the API as a list."""
         self.camera_names = []
         self.update()
         if not self.home:
@@ -87,8 +89,24 @@ class WelcomeData(object):
                 self.camera_names.append(camera['name'])
         return self.camera_names
 
+    def get_module_names(self, camera_name):
+        """Return all module available on the API as a list."""
+        self.module_names = []
+        self.update()
+        cam_id = self.welcomedata.cameraByName(camera=camera_name,
+                                               home=self.home)['id']
+        for module in self.welcomedata.modules.values():
+            if cam_id == module['cam_id']:
+                self.module_names.append(module['name'])
+        return self.module_names
+
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
     def update(self):
         """Call the Netatmo API to update the data."""
         import lnetatmo
-        self.welcomedata = lnetatmo.WelcomeData(self.auth)
+        self.welcomedata = lnetatmo.WelcomeData(self.auth, size=100)
+
+    @Throttle(MIN_TIME_BETWEEN_EVENT_UPDATES)
+    def update_event(self):
+        """Call the Netatmo API to update the list of events."""
+        self.welcomedata.updateEvent(home=self.home)

homeassistant/components/notify/kodi.py

@@ -22,8 +22,8 @@ DEFAULT_PORT = 8080
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
-    vol.Optional(CONF_USERNAME): cv.string,
-    vol.Optional(CONF_PASSWORD): cv.string,
+    vol.Inclusive(CONF_USERNAME, 'auth'): cv.string,
+    vol.Inclusive(CONF_PASSWORD, 'auth'): cv.string,
 })
 
 ATTR_DISPLAYTIME = 'displaytime'
@@ -33,7 +33,13 @@ def get_service(hass, config):
     """Return the notify service."""
     url = '{}:{}'.format(config.get(CONF_HOST), config.get(CONF_PORT))
 
-    auth = (config.get(CONF_USERNAME), config.get(CONF_PASSWORD))
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+
+    if username is not None:
+        auth = (username, password)
+    else:
+        auth = None
 
     return KODINotificationService(
         url,
@@ -48,10 +54,14 @@ class KODINotificationService(BaseNotificationService):
         """Initialize the service."""
         import jsonrpc_requests
         self._url = url
+
+        kwargs = {'timeout': 5}
+
+        if auth is not None:
+            kwargs['auth'] = auth
+
         self._server = jsonrpc_requests.Server(
-            '{}/jsonrpc'.format(self._url),
-            auth=auth,
-            timeout=5)
+            '{}/jsonrpc'.format(self._url), **kwargs)
 
     def send_message(self, message="", **kwargs):
         """Send a message to Kodi."""

homeassistant/components/notify/nfandroidtv.py

@@ -77,7 +77,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
         vol.In(TRANSPARENCIES.keys()),
     vol.Optional(CONF_COLOR, default=DEFAULT_COLOR):
         vol.In(COLORS.keys()),
-    vol.Optional(CONF_COLOR, default=DEFAULT_COLOR): cv.string,
     vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): vol.Coerce(int),
     vol.Optional(CONF_INTERRUPT, default=DEFAULT_INTERRUPT): cv.boolean,
 })

homeassistant/components/notify/smtp.py

@@ -9,6 +9,7 @@ import smtplib
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from email.mime.image import MIMEImage
+import email.utils
 
 import voluptuous as vol
 
@@ -18,6 +19,7 @@ from homeassistant.components.notify import (
 from homeassistant.const import (
     CONF_USERNAME, CONF_PASSWORD, CONF_PORT, CONF_SENDER, CONF_RECIPIENT)
 import homeassistant.helpers.config_validation as cv
+import homeassistant.util.dt as dt_util
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -134,6 +136,8 @@ class MailNotificationService(BaseNotificationService):
         msg['To'] = self.recipient
         msg['From'] = self._sender
         msg['X-Mailer'] = 'HomeAssistant'
+        msg['Date'] = email.utils.format_datetime(dt_util.now())
+        msg['Message-Id'] = email.utils.make_msgid()
 
         return self._send_email(msg)
 

homeassistant/components/notify/telegram.py

@@ -19,7 +19,7 @@ from homeassistant.const import (
 
 _LOGGER = logging.getLogger(__name__)
 
-REQUIREMENTS = ['python-telegram-bot==5.2.0']
+REQUIREMENTS = ['python-telegram-bot==5.3.0']
 
 ATTR_PHOTO = 'photo'
 ATTR_DOCUMENT = 'document'

homeassistant/components/remote/__init__.py

@@ -4,7 +4,9 @@ Component to interface with universal remote control devices.
 For more details about this component, please refer to the documentation
 at https://home-assistant.io/components/remote/
 """
+import asyncio
 from datetime import timedelta
+import functools as ft
 import logging
 import os
 
@@ -80,21 +82,17 @@ def send_command(hass, device, command, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SEND_COMMAND, data)
 
 
-def sync(hass, entity_id=None):
-    """Sync remote device."""
-    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
-    hass.services.call(DOMAIN, SERVICE_SYNC, data)
-
-
-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
     """Track states and offer events for remotes."""
     component = EntityComponent(
         _LOGGER, DOMAIN, hass, SCAN_INTERVAL, GROUP_NAME_ALL_REMOTES)
-    component.setup(config)
+    yield from component.async_setup(config)
 
-    def handle_remote_service(service):
+    @asyncio.coroutine
+    def async_handle_remote_service(service):
         """Handle calls to the remote services."""
-        target_remotes = component.extract_from_service(service)
+        target_remotes = component.async_extract_from_service(service)
 
         activity_id = service.data.get(ATTR_ACTIVITY)
         device = service.data.get(ATTR_DEVICE)
@@ -102,28 +100,43 @@ def setup(hass, config):
 
         for remote in target_remotes:
             if service.service == SERVICE_TURN_ON:
-                remote.turn_on(activity=activity_id)
+                yield from remote.async_turn_on(activity=activity_id)
             elif service.service == SERVICE_SEND_COMMAND:
-                remote.send_command(device=device, command=command)
-            elif service.service == SERVICE_SYNC:
-                remote.sync()
+                yield from remote.async_send_command(
+                    device=device, command=command)
             else:
-                remote.turn_off()
+                yield from remote.async_turn_off()
 
-            if remote.should_poll:
-                remote.update_ha_state(True)
+        update_tasks = []
+        for remote in target_remotes:
+            if not remote.should_poll:
+                continue
 
-    descriptions = load_yaml_config_file(
-        os.path.join(os.path.dirname(__file__), 'services.yaml'))
-    hass.services.register(DOMAIN, SERVICE_TURN_OFF, handle_remote_service,
-                           descriptions.get(SERVICE_TURN_OFF),
-                           schema=REMOTE_SERVICE_SCHEMA)
-    hass.services.register(DOMAIN, SERVICE_TURN_ON, handle_remote_service,
-                           descriptions.get(SERVICE_TURN_ON),
-                           schema=REMOTE_SERVICE_TURN_ON_SCHEMA)
-    hass.services.register(DOMAIN, SERVICE_SEND_COMMAND, handle_remote_service,
-                           descriptions.get(SERVICE_SEND_COMMAND),
-                           schema=REMOTE_SERVICE_SEND_COMMAND_SCHEMA)
+            update_coro = hass.loop.create_task(
+                remote.async_update_ha_state(True))
+            if hasattr(remote, 'async_update'):
+                update_tasks.append(hass.loop.create_task(update_coro))
+            else:
+                yield from update_coro
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)
+
+    descriptions = yield from hass.loop.run_in_executor(
+        None, load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml'))
+    hass.services.async_register(
+        DOMAIN, SERVICE_TURN_OFF, async_handle_remote_service,
+        descriptions.get(SERVICE_TURN_OFF),
+        schema=REMOTE_SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_TURN_ON, async_handle_remote_service,
+        descriptions.get(SERVICE_TURN_ON),
+        schema=REMOTE_SERVICE_TURN_ON_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_SEND_COMMAND, async_handle_remote_service,
+        descriptions.get(SERVICE_SEND_COMMAND),
+        schema=REMOTE_SERVICE_SEND_COMMAND_SCHEMA)
 
     return True
 
@@ -131,14 +144,11 @@ def setup(hass, config):
 class RemoteDevice(ToggleEntity):
     """Representation of a remote."""
 
-    def turn_on(self, **kwargs):
-        """Turn a device on with the remote."""
-        raise NotImplementedError()
-
-    def turn_off(self, **kwargs):
-        """Turn a device off with the remote."""
-        raise NotImplementedError()
-
     def send_command(self, **kwargs):
         """Send a command to a device."""
         raise NotImplementedError()
+
+    def async_send_command(self, **kwargs):
+        """Send a command to a device."""
+        yield from self.hass.loop.run_in_executor(
+            None, ft.partial(self.send_command, **kwargs))

homeassistant/components/remote/harmony.py

@@ -14,7 +14,8 @@ import homeassistant.components.remote as remote
 import homeassistant.helpers.config_validation as cv
 from homeassistant.const import (
     CONF_NAME, CONF_HOST, CONF_PORT, ATTR_ENTITY_ID)
-from homeassistant.components.remote import PLATFORM_SCHEMA, DOMAIN
+from homeassistant.components.remote import (
+    PLATFORM_SCHEMA, DOMAIN, ATTR_DEVICE, ATTR_COMMAND, ATTR_ACTIVITY)
 from homeassistant.util import slugify
 from homeassistant.config import load_yaml_config_file
 
@@ -22,10 +23,6 @@ REQUIREMENTS = ['pyharmony==1.0.12']
 
 _LOGGER = logging.getLogger(__name__)
 
-ATTR_DEVICE = 'device'
-ATTR_COMMAND = 'command'
-ATTR_ACTIVITY = 'activity'
-
 DEFAULT_PORT = 5222
 DEVICES = []
 

homeassistant/components/sensor/arwn.py

@@ -1,23 +1,25 @@
-"""Support for collecting data from the ARWN project.
-
-For more details about this platform, please refer to the
-documentation at https://home-assistant.io/components/sensor.arwn/
+"""
+Support for collecting data from the ARWN project.
 
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/sensor.arwn/
 """
 import json
 import logging
-from homeassistant.helpers.entity import Entity
+
 import homeassistant.components.mqtt as mqtt
 from homeassistant.const import (TEMP_FAHRENHEIT, TEMP_CELSIUS)
+from homeassistant.helpers.entity import Entity
 from homeassistant.util import slugify
 
-DEPENDENCIES = ['mqtt']
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['mqtt']
+DOMAIN = 'arwn'
 
-DOMAIN = "arwn"
-TOPIC = 'arwn/#'
 SENSORS = {}
 
-_LOGGER = logging.getLogger(__name__)
+TOPIC = 'arwn/#'
 
 
 def discover_sensors(topic, payload):
@@ -25,23 +27,23 @@ def discover_sensors(topic, payload):
     parts = topic.split('/')
     unit = payload.get('units', '')
     domain = parts[1]
-    if domain == "temperature":
+    if domain == 'temperature':
         name = parts[2]
-        if unit == "F":
+        if unit == 'F':
             unit = TEMP_FAHRENHEIT
         else:
             unit = TEMP_CELSIUS
-        return (ArwnSensor(name, 'temp', unit),)
-    if domain == "barometer":
-        return (ArwnSensor("Barometer", 'pressure', unit),)
-    if domain == "wind":
-        return (ArwnSensor("Wind Speed", 'speed', unit),
-                ArwnSensor("Wind Gust", 'gust', unit),
-                ArwnSensor("Wind Direction", 'direction', '°'))
+        return ArwnSensor(name, 'temp', unit)
+    if domain == 'barometer':
+        return ArwnSensor('Barometer', 'pressure', unit)
+    if domain == 'wind':
+        return (ArwnSensor('Wind Speed', 'speed', unit),
+                ArwnSensor('Wind Gust', 'gust', unit),
+                ArwnSensor('Wind Direction', 'direction', '°'))
 
 
 def _slug(name):
-    return "sensor.arwn_%s" % slugify(name)
+    return 'sensor.arwn_{}'.format(slugify(name))
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
@@ -84,7 +86,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class ArwnSensor(Entity):
-    """Represents an ARWN sensor."""
+    """Representation of an ARWN sensor."""
 
     def __init__(self, name, state_key, units):
         """Initialize the sensor."""

homeassistant/components/sensor/broadlink.py

@@ -0,0 +1,130 @@
+
+"""
+Support for the Broadlink RM2 Pro (only temperature) and A1 devices.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/sensor.broadlink/
+"""
+from datetime import timedelta
+import binascii
+import logging
+import socket
+import voluptuous as vol
+
+from homeassistant.components.sensor import PLATFORM_SCHEMA
+from homeassistant.const import (CONF_HOST, CONF_MAC,
+                                 CONF_MONITORED_CONDITIONS,
+                                 CONF_NAME, TEMP_CELSIUS, CONF_TIMEOUT)
+from homeassistant.helpers.entity import Entity
+from homeassistant.util import Throttle
+import homeassistant.helpers.config_validation as cv
+
+REQUIREMENTS = ['broadlink==0.2']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_UPDATE_INTERVAL = 'update_interval'
+DEVICE_DEFAULT_NAME = 'Broadlink sensor'
+DEFAULT_TIMEOUT = 10
+
+SENSOR_TYPES = {
+    'temperature': ['Temperature', TEMP_CELSIUS],
+    'air_quality': ['Air Quality', ' '],
+    'humidity': ['Humidity', '%'],
+    'light': ['Light', ' '],
+    'noise': ['Noise', ' ']
+}
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEVICE_DEFAULT_NAME): vol.Coerce(str),
+    vol.Optional(CONF_MONITORED_CONDITIONS, default=[]):
+        vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
+    vol.Optional(CONF_UPDATE_INTERVAL, default=timedelta(seconds=300)): (
+        vol.All(cv.time_period, cv.positive_timedelta)),
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_MAC): cv.string,
+    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Broadlink device sensors."""
+    mac = config.get(CONF_MAC).encode().replace(b':', b'')
+    mac_addr = binascii.unhexlify(mac)
+    broadlink_data = BroadlinkData(
+        config.get(CONF_UPDATE_INTERVAL),
+        config.get(CONF_HOST),
+        mac_addr, config.get(CONF_TIMEOUT))
+
+    dev = []
+    for variable in config[CONF_MONITORED_CONDITIONS]:
+        dev.append(BroadlinkSensor(
+            config.get(CONF_NAME),
+            broadlink_data,
+            variable))
+    add_devices(dev)
+
+
+class BroadlinkSensor(Entity):
+    """Representation of a Broadlink device sensor."""
+
+    def __init__(self, name, broadlink_data, sensor_type):
+        """Initialize the sensor."""
+        self._name = "%s %s" % (name, SENSOR_TYPES[sensor_type][0])
+        self._state = None
+        self._type = sensor_type
+        self._broadlink_data = broadlink_data
+        self._unit_of_measurement = SENSOR_TYPES[sensor_type][1]
+        self.update()
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        return self._state
+
+    @property
+    def unit_of_measurement(self):
+        """Return the unit this state is expressed in."""
+        return self._unit_of_measurement
+
+    def update(self):
+        """Get the latest data from the sensor."""
+        self._broadlink_data.update()
+        if self._broadlink_data.data is None:
+            return
+        self._state = self._broadlink_data.data[self._type]
+
+
+class BroadlinkData(object):
+    """Representation of a Broadlink data object."""
+
+    def __init__(self, interval, ip_addr, mac_addr, timeout):
+        """Initialize the data object."""
+        import broadlink
+        self.data = None
+        self._device = broadlink.a1((ip_addr, 80), mac_addr)
+        self._device.timeout = timeout
+        self.update = Throttle(interval)(self._update)
+        try:
+            self._device.auth()
+        except socket.timeout:
+            _LOGGER.error("Failed to connect to device.")
+
+    def _update(self, retry=2):
+        try:
+            self.data = self._device.check_sensors_raw()
+        except socket.timeout as error:
+            if retry < 1:
+                _LOGGER.error(error)
+                return
+            try:
+                self._device.auth()
+            except socket.timeout:
+                pass
+            return self._update(max(0, retry-1))

homeassistant/components/sensor/coinmarketcap.py

@@ -77,7 +77,7 @@ class CoinMarketCapSensor(Entity):
     @property
     def state(self):
         """Return the state of the sensor."""
-        return self._ticker.get('price_usd')
+        return round(float(self._ticker.get('price_usd')), 2)
 
     @property
     def unit_of_measurement(self):

homeassistant/components/sensor/darksky.py

@@ -104,19 +104,17 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     else:
         units = 'us'
 
-    # Create a data fetcher to support all of the configured sensors. Then make
-    # the first call to init the data and confirm we can connect.
-    try:
-        forecast_data = DarkSkyData(
-            api_key=config.get(CONF_API_KEY, None),
-            latitude=hass.config.latitude,
-            longitude=hass.config.longitude,
-            units=units,
-            interval=config.get(CONF_UPDATE_INTERVAL))
-        forecast_data.update()
-        forecast_data.update_currently()
-    except ValueError as error:
-        _LOGGER.error(error)
+    forecast_data = DarkSkyData(
+        api_key=config.get(CONF_API_KEY, None),
+        latitude=hass.config.latitude,
+        longitude=hass.config.longitude,
+        units=units,
+        interval=config.get(CONF_UPDATE_INTERVAL))
+    forecast_data.update()
+    forecast_data.update_currently()
+
+    # If connection failed don't setup platform.
+    if forecast_data.data is None:
         return False
 
     name = config.get(CONF_NAME)
@@ -227,7 +225,10 @@ class DarkSkySensor(Entity):
         If the sensor type is unknown, the current state is returned.
         """
         lookup_type = convert_to_camel(self.type)
-        state = getattr(data, lookup_type, 0)
+        state = getattr(data, lookup_type, None)
+
+        if state is None:
+            return state
 
         # Some state data needs to be rounded to whole values or converted to
         # percentages
@@ -284,21 +285,22 @@ class DarkSkyData(object):
             self.data = forecastio.load_forecast(
                 self._api_key, self.latitude, self.longitude, units=self.units)
         except (ConnectError, HTTPError, Timeout, ValueError) as error:
-            raise ValueError("Unable to init Dark Sky. %s", error)
-        self.unit_system = self.data.json['flags']['units']
+            _LOGGER.error("Unable to connect to Dark Sky. %s", error)
+            self.data = None
+        self.unit_system = self.data and self.data.json['flags']['units']
 
     def _update_currently(self):
         """Update currently data."""
-        self.data_currently = self.data.currently()
+        self.data_currently = self.data and self.data.currently()
 
     def _update_minutely(self):
         """Update minutely data."""
-        self.data_minutely = self.data.minutely()
+        self.data_minutely = self.data and self.data.minutely()
 
     def _update_hourly(self):
         """Update hourly data."""
-        self.data_hourly = self.data.hourly()
+        self.data_hourly = self.data and self.data.hourly()
 
     def _update_daily(self):
         """Update daily data."""
-        self.data_daily = self.data.daily()
+        self.data_daily = self.data and self.data.daily()

homeassistant/components/sensor/dsmr.py

@@ -26,15 +26,15 @@ stores/caches the latest telegram and notifies the Entities that the telegram
 has been updated.
 """
 import asyncio
-import logging
 from datetime import timedelta
+import logging
 
-import voluptuous as vol
-
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.sensor import PLATFORM_SCHEMA
-from homeassistant.const import CONF_PORT, EVENT_HOMEASSISTANT_STOP
+from homeassistant.const import (
+    CONF_PORT, EVENT_HOMEASSISTANT_STOP, STATE_UNKNOWN)
+import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import Entity
+import voluptuous as vol
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -65,30 +65,37 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     # Suppress logging
     logging.getLogger('dsmr_parser').setLevel(logging.ERROR)
 
-    from dsmr_parser import obis_references as obis
+    from dsmr_parser import obis_references as obis_ref
     from dsmr_parser.protocol import create_dsmr_reader
 
     dsmr_version = config[CONF_DSMR_VERSION]
 
     # Define list of name,obis mappings to generate entities
     obis_mapping = [
-        ['Power Consumption', obis.CURRENT_ELECTRICITY_USAGE],
-        ['Power Production', obis.CURRENT_ELECTRICITY_DELIVERY],
-        ['Power Tariff', obis.ELECTRICITY_ACTIVE_TARIFF],
-        ['Power Consumption (low)', obis.ELECTRICITY_USED_TARIFF_1],
-        ['Power Consumption (normal)', obis.ELECTRICITY_USED_TARIFF_2],
-        ['Power Production (low)', obis.ELECTRICITY_DELIVERED_TARIFF_1],
-        ['Power Production (normal)', obis.ELECTRICITY_DELIVERED_TARIFF_2],
+        ['Power Consumption', obis_ref.CURRENT_ELECTRICITY_USAGE],
+        ['Power Production', obis_ref.CURRENT_ELECTRICITY_DELIVERY],
+        ['Power Tariff', obis_ref.ELECTRICITY_ACTIVE_TARIFF],
+        ['Power Consumption (low)', obis_ref.ELECTRICITY_USED_TARIFF_1],
+        ['Power Consumption (normal)', obis_ref.ELECTRICITY_USED_TARIFF_2],
+        ['Power Production (low)', obis_ref.ELECTRICITY_DELIVERED_TARIFF_1],
+        ['Power Production (normal)', obis_ref.ELECTRICITY_DELIVERED_TARIFF_2],
     ]
-    # Protocol version specific obis
-    if dsmr_version == '4':
-        obis_mapping.append(['Gas Consumption', obis.HOURLY_GAS_METER_READING])
-    else:
-        obis_mapping.append(['Gas Consumption', obis.GAS_METER_READING])
 
     # Generate device entities
     devices = [DSMREntity(name, obis) for name, obis in obis_mapping]
 
+    # Protocol version specific obis
+    if dsmr_version == '4':
+        gas_obis = obis_ref.HOURLY_GAS_METER_READING
+    else:
+        gas_obis = obis_ref.GAS_METER_READING
+
+    # add gas meter reading and derivative for usage
+    devices += [
+        DSMREntity('Gas Consumption', gas_obis),
+        DerivativeDSMREntity('Hourly Gas Consumption', gas_obis),
+    ]
+
     yield from async_add_devices(devices)
 
     def update_entities_telegram(telegram):
@@ -151,7 +158,10 @@ class DSMREntity(Entity):
         if self._obis == obis.ELECTRICITY_ACTIVE_TARIFF:
             return self.translate_tariff(value)
         else:
-            return value
+            if value:
+                return value
+            else:
+                return STATE_UNKNOWN
 
     @property
     def unit_of_measurement(self):
@@ -168,4 +178,55 @@ class DSMREntity(Entity):
         elif value == '0001':
             return 'low'
         else:
-            return None
+            return STATE_UNKNOWN
+
+
+class DerivativeDSMREntity(DSMREntity):
+    """Calculated derivative for values where the DSMR doesn't offer one.
+
+    Gas readings are only reported per hour and don't offer a rate only
+    the current meter reading. This entity converts subsequents readings
+    into a hourly rate.
+    """
+
+    _previous_reading = None
+    _previous_timestamp = None
+    _state = STATE_UNKNOWN
+
+    @property
+    def state(self):
+        """Return the calculated current hourly rate."""
+        return self._state
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Recalculate hourly rate if timestamp has changed.
+
+        DSMR updates gas meter reading every hour. Along with the
+        new value a timestamp is provided for the reading. Test
+        if the last known timestamp differs from the current one
+        then calculate a new rate for the previous hour.
+        """
+        # check if the timestamp for the object differs from the previous one
+        timestamp = self.get_dsmr_object_attr('datetime')
+        if timestamp and timestamp != self._previous_timestamp:
+            current_reading = self.get_dsmr_object_attr('value')
+
+            if self._previous_reading is None:
+                # can't calculate rate without previous datapoint
+                # just store current point
+                pass
+            else:
+                # recalculate the rate
+                diff = current_reading - self._previous_reading
+                self._state = diff
+
+            self._previous_reading = current_reading
+            self._previous_timestamp = timestamp
+
+    @property
+    def unit_of_measurement(self):
+        """Return the unit of measurement of this entity, per hour, if any."""
+        unit = self.get_dsmr_object_attr('unit')
+        if unit:
+            return unit + '/h'

homeassistant/components/sensor/eliqonline.py

@@ -14,7 +14,7 @@ from homeassistant.const import (CONF_ACCESS_TOKEN, CONF_NAME, STATE_UNKNOWN)
 from homeassistant.helpers.entity import Entity
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['eliqonline==1.0.12']
+REQUIREMENTS = ['eliqonline==1.0.13']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/sensor/enocean.py

@@ -20,7 +20,7 @@ DEFAULT_NAME = 'EnOcean sensor'
 DEPENDENCIES = ['enocean']
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_ID): cv.string,
+    vol.Required(CONF_ID): vol.All(cv.ensure_list, [vol.Coerce(int)]),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
 })
 

homeassistant/components/sensor/fastdotcom.py

@@ -22,6 +22,7 @@ CONF_SECOND = 'second'
 CONF_MINUTE = 'minute'
 CONF_HOUR = 'hour'
 CONF_DAY = 'day'
+CONF_MANUAL = 'manual'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_SECOND, default=[0]):
@@ -32,6 +33,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
         vol.All(cv.ensure_list, [vol.All(vol.Coerce(int), vol.Range(0, 23))]),
     vol.Optional(CONF_DAY):
         vol.All(cv.ensure_list, [vol.All(vol.Coerce(int), vol.Range(1, 31))]),
+    vol.Optional(CONF_MANUAL, default=False): cv.boolean,
 })
 
 
@@ -104,11 +106,12 @@ class SpeedtestData(object):
     def __init__(self, hass, config):
         """Initialize the data object."""
         self.data = None
-        track_time_change(hass, self.update,
-                          second=config.get(CONF_SECOND),
-                          minute=config.get(CONF_MINUTE),
-                          hour=config.get(CONF_HOUR),
-                          day=config.get(CONF_DAY))
+        if not config.get(CONF_MANUAL):
+            track_time_change(hass, self.update,
+                              second=config.get(CONF_SECOND),
+                              minute=config.get(CONF_MINUTE),
+                              hour=config.get(CONF_HOUR),
+                              day=config.get(CONF_DAY))
 
     def update(self, now):
         """Get the latest data from fast.com."""

homeassistant/components/sensor/gtfs.py

@@ -95,6 +95,9 @@ def get_next_departure(sched, start_station_id, end_station_id):
     for row in result:
         item = row
 
+    if item == {}:
+        return None
+
     today = datetime.datetime.today().strftime('%Y-%m-%d')
     departure_time_string = '{} {}'.format(today, item[2])
     arrival_time_string = '{} {}'.format(today, item[3])
@@ -221,6 +224,13 @@ class GTFSDepartureSensor(Entity):
         with self.lock:
             self._departure = get_next_departure(self._pygtfs, self.origin,
                                                  self.destination)
+            if not self._departure:
+                self._state = 0
+                self._attributes = {'Info': 'No more bus today'}
+                if self._name == '':
+                    self._name = (self._custom_name or "GTFS Sensor")
+                return
+
             self._state = self._departure['minutes_until_departure']
 
             origin_station = self._departure['origin_station']

homeassistant/components/sensor/nest.py

@@ -18,7 +18,8 @@ from homeassistant.const import (
 
 DEPENDENCIES = ['nest']
 SENSOR_TYPES = ['humidity',
-                'operation_mode']
+                'operation_mode',
+                'hvac_state']
 
 SENSOR_TYPES_DEPRECATED = ['last_ip',
                            'local_ip',
@@ -128,13 +129,20 @@ class NestSensor(Entity):
 
         # device specific
         self._location = self.device.where
-        self._name = self.device.name_long
+        self._name = "{} {}".format(self.device.name_long,
+                                    self.variable.replace("_", " "))
         self._state = None
+        self._unit = None
 
     @property
     def name(self):
         """Return the name of the nest, if any."""
-        return "{} {}".format(self._name, self.variable.replace("_", " "))
+        return self._name
+
+    @property
+    def unit_of_measurement(self):
+        """Return the unit the value is expressed in."""
+        return self._unit
 
 
 class NestBasicSensor(NestSensor):
@@ -145,13 +153,10 @@ class NestBasicSensor(NestSensor):
         """Return the state of the sensor."""
         return self._state
 
-    @property
-    def unit_of_measurement(self):
-        """Return the unit the value is expressed in."""
-        return SENSOR_UNITS.get(self.variable, None)
-
     def update(self):
         """Retrieve latest state."""
+        self._unit = SENSOR_UNITS.get(self.variable, None)
+
         if self.variable == 'operation_mode':
             self._state = getattr(self.device, "mode")
         else:
@@ -161,14 +166,6 @@ class NestBasicSensor(NestSensor):
 class NestTempSensor(NestSensor):
     """Representation of a Nest Temperature sensor."""
 
-    @property
-    def unit_of_measurement(self):
-        """Return the unit the value is expressed in."""
-        if self.device.temperature_scale == 'C':
-            return TEMP_CELSIUS
-        else:
-            return TEMP_FAHRENHEIT
-
     @property
     def state(self):
         """Return the state of the sensor."""
@@ -176,6 +173,11 @@ class NestTempSensor(NestSensor):
 
     def update(self):
         """Retrieve latest state."""
+        if self.device.temperature_scale == 'C':
+            self._unit = TEMP_CELSIUS
+        else:
+            self._unit = TEMP_FAHRENHEIT
+
         temp = getattr(self.device, self.variable)
         if temp is None:
             self._state = None