Order imports (#16515)

homeassistant/components/mailbox/__init__.py

@@ -4,31 +4,33 @@ Provides functionality for mailboxes.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/mailbox/
 """
-
 import asyncio
-import logging
 from contextlib import suppress
 from datetime import timedelta
-
+import logging
-import async_timeout
 
 from aiohttp import web
 from aiohttp.web_exceptions import HTTPNotFound
+import async_timeout
 
-from homeassistant.core import callback
-from homeassistant.helpers import config_per_platform, discovery
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.entity import Entity
 from homeassistant.components.http import HomeAssistantView
+from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_per_platform, discovery
+from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.setup import async_prepare_setup_platform
 
+_LOGGER = logging.getLogger(__name__)
+
+CONTENT_TYPE_MPEG = 'audio/mpeg'
+
 DEPENDENCIES = ['http']
 DOMAIN = 'mailbox'
+
 EVENT = 'mailbox_updated'
-CONTENT_TYPE_MPEG = 'audio/mpeg'
+
 SCAN_INTERVAL = timedelta(seconds=30)
-_LOGGER = logging.getLogger(__name__)
 
 
 @asyncio.coroutine

homeassistant/components/mailbox/asterisk_mbox.py

@@ -7,17 +7,18 @@ https://home-assistant.io/components/mailbox.asteriskvm/
 import asyncio
 import logging
 
-from homeassistant.core import callback
 from homeassistant.components.asterisk_mbox import DOMAIN
-from homeassistant.components.mailbox import (Mailbox, CONTENT_TYPE_MPEG,
+from homeassistant.components.mailbox import (
-                                              StreamError)
+    CONTENT_TYPE_MPEG, Mailbox, StreamError)
+from homeassistant.core import callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 
-DEPENDENCIES = ['asterisk_mbox']
 _LOGGER = logging.getLogger(__name__)
 
-SIGNAL_MESSAGE_UPDATE = 'asterisk_mbox.message_updated'
+DEPENDENCIES = ['asterisk_mbox']
+
 SIGNAL_MESSAGE_REQUEST = 'asterisk_mbox.message_request'
+SIGNAL_MESSAGE_UPDATE = 'asterisk_mbox.message_updated'
 
 
 @asyncio.coroutine

homeassistant/components/mailbox/demo.py

@@ -5,16 +5,16 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/mailbox.asteriskvm/
 """
 import asyncio
+from hashlib import sha1
 import logging
 import os
-from hashlib import sha1
 
+from homeassistant.components.mailbox import (
+    CONTENT_TYPE_MPEG, Mailbox, StreamError)
 from homeassistant.util import dt
 
-from homeassistant.components.mailbox import (Mailbox, CONTENT_TYPE_MPEG,
-                                              StreamError)
-
 _LOGGER = logging.getLogger(__name__)
+
 DOMAIN = "DemoMailbox"
 
 
@@ -38,11 +38,15 @@ class DemoMailbox(Mailbox):
             msgtxt = "Message {}. {}".format(
                 idx + 1, txt * (1 + idx * (idx % 2)))
             msgsha = sha1(msgtxt.encode('utf-8')).hexdigest()
-            msg = {"info": {"origtime": msgtime,
+            msg = {
-                            "callerid": "John Doe <212-555-1212>",
+                'info': {
-                            "duration": "10"},
+                    'origtime': msgtime,
-                   "text": msgtxt,
+                    'callerid': 'John Doe <212-555-1212>',
-                   "sha":  msgsha}
+                    'duration': '10',
+                },
+                'text': msgtxt,
+                'sha':  msgsha,
+            }
             self._messages[msgsha] = msg
 
     @property

homeassistant/components/media_player/__init__.py

@@ -15,33 +15,32 @@ from random import SystemRandom
 from urllib.parse import urlparse
 
 from aiohttp import web
-from aiohttp.hdrs import CONTENT_TYPE, CACHE_CONTROL
+from aiohttp.hdrs import CACHE_CONTROL, CONTENT_TYPE
 import async_timeout
 import voluptuous as vol
 
-from homeassistant.core import callback
+from homeassistant.components import websocket_api
 from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
 from homeassistant.const import (
-    STATE_OFF, STATE_IDLE, STATE_PLAYING, STATE_UNKNOWN, ATTR_ENTITY_ID,
+    ATTR_ENTITY_ID, SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_PAUSE,
-    SERVICE_TOGGLE, SERVICE_TURN_ON, SERVICE_TURN_OFF, SERVICE_VOLUME_UP,
+    SERVICE_MEDIA_PLAY, SERVICE_MEDIA_PLAY_PAUSE, SERVICE_MEDIA_PREVIOUS_TRACK,
-    SERVICE_MEDIA_PLAY, SERVICE_MEDIA_SEEK, SERVICE_MEDIA_STOP,
+    SERVICE_MEDIA_SEEK, SERVICE_MEDIA_STOP, SERVICE_SHUFFLE_SET,
-    SERVICE_VOLUME_SET, SERVICE_MEDIA_PAUSE, SERVICE_SHUFFLE_SET,
+    SERVICE_TOGGLE, SERVICE_TURN_OFF, SERVICE_TURN_ON, SERVICE_VOLUME_DOWN,
-    SERVICE_VOLUME_DOWN, SERVICE_VOLUME_MUTE, SERVICE_MEDIA_NEXT_TRACK,
+    SERVICE_VOLUME_MUTE, SERVICE_VOLUME_SET, SERVICE_VOLUME_UP, STATE_IDLE,
-    SERVICE_MEDIA_PLAY_PAUSE, SERVICE_MEDIA_PREVIOUS_TRACK)
+    STATE_OFF, STATE_PLAYING, STATE_UNKNOWN)
+from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.loader import bind_hass
-from homeassistant.components import websocket_api
 
 _LOGGER = logging.getLogger(__name__)
 _RND = SystemRandom()
 
 DOMAIN = 'media_player'
 DEPENDENCIES = ['http']
-SCAN_INTERVAL = timedelta(seconds=10)
 
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 
@@ -97,6 +96,8 @@ MEDIA_TYPE_CHANNEL = 'channel'
 MEDIA_TYPE_PLAYLIST = 'playlist'
 MEDIA_TYPE_URL = 'url'
 
+SCAN_INTERVAL = timedelta(seconds=10)
+
 SUPPORT_PAUSE = 1
 SUPPORT_SEEK = 2
 SUPPORT_VOLUME_SET = 4

homeassistant/components/media_player/anthemav.py

@@ -4,17 +4,17 @@ Support for Anthem Network Receivers and Processors.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.anthemav/
 """
-import logging
 import asyncio
+import logging
 
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    PLATFORM_SCHEMA, SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_SELECT_SOURCE,
+    PLATFORM_SCHEMA, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
     SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_NAME, CONF_HOST, CONF_PORT, STATE_OFF, STATE_ON, STATE_UNKNOWN,
+    CONF_HOST, CONF_NAME, CONF_PORT, EVENT_HOMEASSISTANT_STOP, STATE_OFF,
-    EVENT_HOMEASSISTANT_STOP)
+    STATE_ON, STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['anthemav==1.1.8']
@@ -32,7 +32,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Optional(CONF_NAME): cv.string,
     vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
-    })
+})
 
 
 @asyncio.coroutine

homeassistant/components/media_player/apple_tv.py

@@ -7,20 +7,19 @@ https://home-assistant.io/components/media_player.apple_tv/
 import asyncio
 import logging
 
-from homeassistant.core import callback
 from homeassistant.components.apple_tv import (
     ATTR_ATV, ATTR_POWER, DATA_APPLE_TV, DATA_ENTITIES)
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK,
+    MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW, MEDIA_TYPE_VIDEO, SUPPORT_NEXT_TRACK,
-    SUPPORT_STOP, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_TURN_ON,
+    SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_TURN_OFF, MediaPlayerDevice, MEDIA_TYPE_MUSIC,
+    SUPPORT_SEEK, SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    MEDIA_TYPE_VIDEO, MEDIA_TYPE_TVSHOW)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_IDLE, STATE_PAUSED, STATE_PLAYING, STATE_STANDBY, CONF_HOST,
+    CONF_HOST, CONF_NAME, EVENT_HOMEASSISTANT_STOP, STATE_IDLE, STATE_OFF,
-    STATE_OFF, CONF_NAME, EVENT_HOMEASSISTANT_STOP)
+    STATE_PAUSED, STATE_PLAYING, STATE_STANDBY)
+from homeassistant.core import callback
 import homeassistant.util.dt as dt_util
 
-
 DEPENDENCIES = ['apple_tv']
 
 _LOGGER = logging.getLogger(__name__)
@@ -31,8 +30,8 @@ SUPPORT_APPLE_TV = SUPPORT_TURN_ON | SUPPORT_TURN_OFF | SUPPORT_PLAY_MEDIA | \
 
 
 @asyncio.coroutine
-def async_setup_platform(hass, config, async_add_entities,
+def async_setup_platform(
-                         discovery_info=None):
+        hass, config, async_add_entities, discovery_info=None):
     """Set up the Apple TV platform."""
     if not discovery_info:
         return

homeassistant/components/media_player/aquostv.py

@@ -9,16 +9,13 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_SELECT_SOURCE,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
-    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP, SUPPORT_PLAY,
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    SUPPORT_VOLUME_SET, MediaPlayerDevice, PLATFORM_SCHEMA)
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
-
 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN,
+    CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT, CONF_TIMEOUT,
-    CONF_PORT, CONF_USERNAME, CONF_PASSWORD, CONF_TIMEOUT)
+    CONF_USERNAME, STATE_OFF, STATE_ON, STATE_UNKNOWN)
-
-
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['sharp_aquos_rc==0.3.2']

homeassistant/components/media_player/blackbird.py

@@ -13,15 +13,15 @@ from homeassistant.components.media_player import (
     DOMAIN, MEDIA_PLAYER_SCHEMA, PLATFORM_SCHEMA, SUPPORT_SELECT_SOURCE,
     SUPPORT_TURN_OFF, SUPPORT_TURN_ON, MediaPlayerDevice)
 from homeassistant.const import (
-    ATTR_ENTITY_ID, CONF_NAME, CONF_HOST, CONF_PORT, STATE_OFF, STATE_ON)
+    ATTR_ENTITY_ID, CONF_HOST, CONF_NAME, CONF_PORT, CONF_TYPE, STATE_OFF,
+    STATE_ON)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['pyblackbird==0.5']
 
 _LOGGER = logging.getLogger(__name__)
 
-SUPPORT_BLACKBIRD = SUPPORT_TURN_ON | SUPPORT_TURN_OFF | \
+SUPPORT_BLACKBIRD = SUPPORT_TURN_ON | SUPPORT_TURN_OFF | SUPPORT_SELECT_SOURCE
-                    SUPPORT_SELECT_SOURCE
 
 ZONE_SCHEMA = vol.Schema({
     vol.Required(CONF_NAME): cv.string,
@@ -33,7 +33,6 @@ SOURCE_SCHEMA = vol.Schema({
 
 CONF_ZONES = 'zones'
 CONF_SOURCES = 'sources'
-CONF_TYPE = 'type'
 
 DATA_BLACKBIRD = 'blackbird'
 

homeassistant/components/media_player/bluesound.py

@@ -24,8 +24,8 @@ from homeassistant.components.media_player import (
     MediaPlayerDevice)
 from homeassistant.const import (
     ATTR_ENTITY_ID, CONF_HOST, CONF_HOSTS, CONF_NAME, CONF_PORT,
-    EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP, STATE_IDLE,
+    EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP, STATE_IDLE, STATE_OFF,
-    STATE_OFF, STATE_PAUSED, STATE_PLAYING)
+    STATE_PAUSED, STATE_PLAYING)
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 import homeassistant.helpers.config_validation as cv

homeassistant/components/media_player/braviatv.py

@@ -10,11 +10,11 @@ import re
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_ON,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP, SUPPORT_PLAY,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
-    SUPPORT_VOLUME_SET, SUPPORT_SELECT_SOURCE, MediaPlayerDevice,
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    PLATFORM_SCHEMA)
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
-from homeassistant.const import (CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON)
+from homeassistant.const import CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util.json import load_json, save_json
 

homeassistant/components/media_player/cast.py

@@ -7,26 +7,27 @@ https://home-assistant.io/components/media_player.cast/
 import asyncio
 import logging
 import threading
+
 from typing import Optional, Tuple
 
-import voluptuous as vol
 import attr
+import voluptuous as vol
 
-from homeassistant.exceptions import PlatformNotReady
-from homeassistant.helpers.typing import HomeAssistantType, ConfigType
-from homeassistant.core import callback
-from homeassistant.helpers.dispatcher import (dispatcher_send,
-                                              async_dispatcher_connect)
 from homeassistant.components.cast import DOMAIN as CAST_DOMAIN
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW, MEDIA_TYPE_MOVIE, SUPPORT_NEXT_TRACK,
+    MEDIA_TYPE_MOVIE, MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW, PLATFORM_SCHEMA,
-    SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA,
-    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_STOP, SUPPORT_PLAY, MediaPlayerDevice, PLATFORM_SCHEMA)
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING,
+    CONF_HOST, EVENT_HOMEASSISTANT_STOP, STATE_IDLE, STATE_OFF, STATE_PAUSED,
-    EVENT_HOMEASSISTANT_STOP)
+    STATE_PLAYING)
+from homeassistant.core import callback
+from homeassistant.exceptions import PlatformNotReady
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.dispatcher import (
+    async_dispatcher_connect, dispatcher_send)
+from homeassistant.helpers.typing import ConfigType, HomeAssistantType
 import homeassistant.util.dt as dt_util
 
 DEPENDENCIES = ('cast',)
@@ -57,8 +58,8 @@ SIGNAL_CAST_DISCOVERED = 'cast_discovered'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_HOST): cv.string,
-    vol.Optional(CONF_IGNORE_CEC, default=[]): vol.All(cv.ensure_list,
+    vol.Optional(CONF_IGNORE_CEC, default=[]):
-                                                       [cv.string])
+        vol.All(cv.ensure_list, [cv.string]),
 })
 
 

homeassistant/components/media_player/channels.py

@@ -9,18 +9,18 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_CHANNEL, MEDIA_TYPE_TVSHOW, MEDIA_TYPE_EPISODE,
+    DOMAIN, MEDIA_TYPE_CHANNEL, MEDIA_TYPE_EPISODE, MEDIA_TYPE_MOVIE,
-    MEDIA_TYPE_MOVIE, SUPPORT_PLAY, SUPPORT_PAUSE, SUPPORT_STOP,
+    MEDIA_TYPE_TVSHOW, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_VOLUME_MUTE, SUPPORT_NEXT_TRACK, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_PLAY_MEDIA, SUPPORT_SELECT_SOURCE, DOMAIN, PLATFORM_SCHEMA,
+    SUPPORT_SELECT_SOURCE, SUPPORT_STOP, SUPPORT_VOLUME_MUTE,
     MediaPlayerDevice)
-
 from homeassistant.const import (
-    CONF_HOST, CONF_PORT, CONF_NAME, STATE_IDLE, STATE_PAUSED, STATE_PLAYING,
+    ATTR_ENTITY_ID, CONF_HOST, CONF_NAME, CONF_PORT, STATE_IDLE, STATE_PAUSED,
-    ATTR_ENTITY_ID)
+    STATE_PLAYING)
-
 import homeassistant.helpers.config_validation as cv
 
+REQUIREMENTS = ['pychannels==1.0.0']
+
 _LOGGER = logging.getLogger(__name__)
 
 DATA_CHANNELS = 'channels'
@@ -52,16 +52,11 @@ CHANNELS_SEEK_BY_SCHEMA = CHANNELS_SCHEMA.extend({
     vol.Required(ATTR_SECONDS): vol.Coerce(int),
 })
 
-REQUIREMENTS = ['pychannels==1.0.0']
-
 
 def setup_platform(hass, config, add_entities, discovery_info=None):
     """Set up the Channels platform."""
     device = ChannelsPlayer(
-        config.get('name'),
+        config.get(CONF_NAME), config.get(CONF_HOST), config.get(CONF_PORT))
-        config.get(CONF_HOST),
-        config.get(CONF_PORT)
-        )
 
     if DATA_CHANNELS not in hass.data:
         hass.data[DATA_CHANNELS] = []
@@ -77,8 +72,8 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
                        device.entity_id == entity_id), None)
 
         if device is None:
-            _LOGGER.warning("Unable to find Channels with entity_id: %s",
+            _LOGGER.warning(
-                            entity_id)
+                "Unable to find Channels with entity_id: %s", entity_id)
             return
 
         if service.service == SERVICE_SEEK_FORWARD:
@@ -90,12 +85,10 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
             device.seek_by(seconds)
 
     hass.services.register(
-        DOMAIN, SERVICE_SEEK_FORWARD, service_handler,
+        DOMAIN, SERVICE_SEEK_FORWARD, service_handler, schema=CHANNELS_SCHEMA)
-        schema=CHANNELS_SCHEMA)
 
     hass.services.register(
-        DOMAIN, SERVICE_SEEK_BACKWARD, service_handler,
+        DOMAIN, SERVICE_SEEK_BACKWARD, service_handler, schema=CHANNELS_SCHEMA)
-        schema=CHANNELS_SCHEMA)
 
     hass.services.register(
         DOMAIN, SERVICE_SEEK_BY, service_handler,

homeassistant/components/media_player/clementine.py

@@ -4,7 +4,6 @@ Support for Clementine Music Player as media player.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.clementine/
 """
-
 import asyncio
 from datetime import timedelta
 import logging
@@ -12,24 +11,24 @@ import time
 
 import voluptuous as vol
 
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, PLATFORM_SCHEMA,
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_VOLUME_STEP, SUPPORT_SELECT_SOURCE, SUPPORT_PLAY, MEDIA_TYPE_MUSIC,
+    SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE,
-    SUPPORT_VOLUME_SET, MediaPlayerDevice)
+    SUPPORT_VOLUME_SET, SUPPORT_VOLUME_STEP, MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, CONF_PORT, CONF_ACCESS_TOKEN,
+    CONF_ACCESS_TOKEN, CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF,
-    STATE_OFF, STATE_PLAYING, STATE_PAUSED, STATE_UNKNOWN)
+    STATE_PAUSED, STATE_PLAYING)
+import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['python-clementine-remote==1.0.1']
 
-SCAN_INTERVAL = timedelta(seconds=5)
-
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME = 'Clementine Remote'
 DEFAULT_PORT = 5500
 
+SCAN_INTERVAL = timedelta(seconds=5)
+
 SUPPORT_CLEMENTINE = SUPPORT_PAUSE | SUPPORT_VOLUME_STEP | \
                      SUPPORT_PREVIOUS_TRACK | SUPPORT_VOLUME_SET | \
                      SUPPORT_NEXT_TRACK | \
@@ -69,7 +68,7 @@ class ClementineDevice(MediaPlayerDevice):
         self._track_name = ''
         self._track_artist = ''
         self._track_album_name = ''
-        self._state = STATE_UNKNOWN
+        self._state = None
 
     def update(self):
         """Retrieve the latest data from the Clementine Player."""

homeassistant/components/media_player/cmus.py

@@ -8,15 +8,14 @@ import logging
 
 import voluptuous as vol
 
-
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
+    MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_PLAY,
+    SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_VOLUME_SET, SUPPORT_PLAY_MEDIA, SUPPORT_SEEK, PLATFORM_SCHEMA,
+    SUPPORT_SEEK, SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_SET,
     MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_OFF, STATE_PAUSED, STATE_PLAYING, CONF_HOST, CONF_NAME, CONF_PORT,
+    CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT, STATE_OFF, STATE_PAUSED,
-    CONF_PASSWORD)
+    STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['pycmus==0.1.1']

homeassistant/components/media_player/demo.py

@@ -5,11 +5,12 @@ For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/demo/
 """
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW, MEDIA_TYPE_MOVIE, SUPPORT_NEXT_TRACK,
+    MEDIA_TYPE_MOVIE, MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW,
-    SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_CLEAR_PLAYLIST, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOUND_MODE,
-    SUPPORT_SELECT_SOURCE, SUPPORT_SELECT_SOUND_MODE, SUPPORT_CLEAR_PLAYLIST,
+    SUPPORT_SELECT_SOURCE, SUPPORT_SHUFFLE_SET, SUPPORT_TURN_OFF,
-    SUPPORT_PLAY, SUPPORT_SHUFFLE_SET, MediaPlayerDevice)
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    MediaPlayerDevice)
 from homeassistant.const import STATE_OFF, STATE_PAUSED, STATE_PLAYING
 import homeassistant.util.dt as dt_util
 
@@ -20,8 +21,8 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
         DemoYoutubePlayer(
             'Living Room', 'eyU3bRy2x44',
             '♥♥ The Best Fireplace Video (3 hours)', 300),
-        DemoYoutubePlayer('Bedroom', 'kxopViU98Xo', 'Epic sax guy 10 hours',
+        DemoYoutubePlayer(
-                          360000),
+            'Bedroom', 'kxopViU98Xo', 'Epic sax guy 10 hours', 360000),
         DemoMusicPlayer(), DemoTVShowPlayer(),
     ])
 

homeassistant/components/media_player/denon.py

@@ -10,10 +10,10 @@ import telnetlib
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_SELECT_SOURCE,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_OFF,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_STOP,
-    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    SUPPORT_STOP, SUPPORT_PLAY, MediaPlayerDevice)
+    MediaPlayerDevice)
 from homeassistant.const import (
     CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv

homeassistant/components/media_player/denonavr.py

@@ -5,35 +5,37 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.denon/
 """
 
-import logging
 from collections import namedtuple
+import logging
+
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_PAUSE, SUPPORT_NEXT_TRACK, SUPPORT_PREVIOUS_TRACK,
+    MEDIA_TYPE_CHANNEL, MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK,
-    SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
+    SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_SELECT_SOURCE, SUPPORT_SELECT_SOUND_MODE,
+    SUPPORT_SELECT_SOUND_MODE, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
-    SUPPORT_PLAY_MEDIA, MEDIA_TYPE_CHANNEL, MediaPlayerDevice,
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    PLATFORM_SCHEMA, SUPPORT_TURN_ON, MEDIA_TYPE_MUSIC,
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
-    SUPPORT_VOLUME_SET, SUPPORT_PLAY)
 from homeassistant.const import (
-    CONF_HOST, STATE_OFF, STATE_PLAYING, STATE_PAUSED,
+    CONF_HOST, CONF_NAME, CONF_TIMEOUT, CONF_ZONE, STATE_OFF, STATE_ON,
-    CONF_NAME, STATE_ON, CONF_ZONE, CONF_TIMEOUT)
+    STATE_PAUSED, STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['denonavr==0.7.5']
 
 _LOGGER = logging.getLogger(__name__)
 
+ATTR_SOUND_MODE_RAW = 'sound_mode_raw'
+
+CONF_INVALID_ZONES_ERR = 'Invalid Zone (expected Zone2 or Zone3)'
+CONF_SHOW_ALL_SOURCES = 'show_all_sources'
+CONF_VALID_ZONES = ['Zone2', 'Zone3']
+CONF_ZONES = 'zones'
+
 DEFAULT_SHOW_SOURCES = False
 DEFAULT_TIMEOUT = 2
-CONF_SHOW_ALL_SOURCES = 'show_all_sources'
-CONF_ZONES = 'zones'
-CONF_VALID_ZONES = ['Zone2', 'Zone3']
-CONF_INVALID_ZONES_ERR = 'Invalid Zone (expected Zone2 or Zone3)'
-KEY_DENON_CACHE = 'denonavr_hosts'
 
-ATTR_SOUND_MODE_RAW = 'sound_mode_raw'
+KEY_DENON_CACHE = 'denonavr_hosts'
 
 SUPPORT_DENON = SUPPORT_VOLUME_STEP | SUPPORT_VOLUME_MUTE | \
     SUPPORT_TURN_ON | SUPPORT_TURN_OFF | \

homeassistant/components/media_player/directv.py

@@ -4,29 +4,28 @@ Support for the DirecTV receivers.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.directv/
 """
-import voluptuous as vol
 import requests
+import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_TVSHOW, MEDIA_TYPE_MOVIE, SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA,
+    MEDIA_TYPE_MOVIE, MEDIA_TYPE_TVSHOW, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK,
-    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_STOP, PLATFORM_SCHEMA,
+    SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_NEXT_TRACK, SUPPORT_PREVIOUS_TRACK, SUPPORT_PLAY,
+    SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON, MediaPlayerDevice)
-    MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_DEVICE, CONF_HOST, CONF_NAME, STATE_OFF, STATE_PLAYING, CONF_PORT)
+    CONF_DEVICE, CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF, STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['directpy==0.5']
 
 DEFAULT_DEVICE = '0'
-DEFAULT_NAME = 'DirecTV Receiver'
+DEFAULT_NAME = "DirecTV Receiver"
 DEFAULT_PORT = 8080
 
 SUPPORT_DTV = SUPPORT_PAUSE | SUPPORT_TURN_ON | SUPPORT_TURN_OFF | \
     SUPPORT_PLAY_MEDIA | SUPPORT_STOP | SUPPORT_NEXT_TRACK | \
     SUPPORT_PREVIOUS_TRACK | SUPPORT_PLAY
 
-DATA_DIRECTV = "data_directv"
+DATA_DIRECTV = 'data_directv'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
@@ -51,9 +50,9 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
 
     elif discovery_info:
         host = discovery_info.get('host')
-        name = 'DirecTV_' + discovery_info.get('serial', '')
+        name = 'DirecTV_{}'.format(discovery_info.get('serial', ''))
 
-        # attempt to discover additional RVU units
+        # Attempt to discover additional RVU units
         try:
             resp = requests.get(
                 'http://%s:%d/info/getLocations' % (host, DEFAULT_PORT)).json()
@@ -65,7 +64,7 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
                                       DEFAULT_PORT, loc["clientAddr"]])
 
         except requests.exceptions.RequestException:
-            # bail out and just go forward with uPnP data
+            # Bail out and just go forward with uPnP data
             if DEFAULT_DEVICE not in known_devices:
                 hosts.append([name, host, DEFAULT_PORT, DEFAULT_DEVICE])
 
@@ -78,8 +77,6 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
     add_entities(dtvs)
     hass.data[DATA_DIRECTV] = known_devices
 
-    return True
-
 
 class DirecTvDevice(MediaPlayerDevice):
     """Representation of a DirecTV receiver on the network."""

homeassistant/components/media_player/dlna_dmr.py

@@ -1,43 +1,36 @@
-# -*- coding: utf-8 -*-
 """
 Support for DLNA DMR (Device Media Renderer).
 
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.dlna_dmr/
 """
-
 import asyncio
+from datetime import datetime
 import functools
 import logging
-from datetime import datetime
 
 import aiohttp
 import voluptuous as vol
 
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.media_player import (
-    SUPPORT_PLAY, SUPPORT_PAUSE, SUPPORT_STOP,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_STOP,
-    SUPPORT_PLAY_MEDIA,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MediaPlayerDevice)
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_NEXT_TRACK,
-    MediaPlayerDevice,
-    PLATFORM_SCHEMA)
 from homeassistant.const import (
-    EVENT_HOMEASSISTANT_STOP,
+    CONF_NAME, CONF_URL, EVENT_HOMEASSISTANT_STOP, STATE_IDLE, STATE_OFF,
-    CONF_URL, CONF_NAME,
+    STATE_ON, STATE_PAUSED, STATE_PLAYING)
-    STATE_OFF, STATE_ON, STATE_IDLE, STATE_PLAYING, STATE_PAUSED)
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+import homeassistant.helpers.config_validation as cv
 from homeassistant.util import get_local_ip
 
+REQUIREMENTS = ['async-upnp-client==0.12.4']
+
+_LOGGER = logging.getLogger(__name__)
 
 DLNA_DMR_DATA = 'dlna_dmr'
 
-REQUIREMENTS = [
-    'async-upnp-client==0.12.4',
-]
-
 DEFAULT_NAME = 'DLNA Digital Media Renderer'
 DEFAULT_LISTEN_PORT = 8301
 
@@ -68,8 +61,6 @@ HOME_ASSISTANT_UPNP_MIME_TYPE_MAPPING = {
     'playlist': 'playlist/*',
 }
 
-_LOGGER = logging.getLogger(__name__)
-
 
 def catch_request_errors():
     """Catch asyncio.TimeoutError, aiohttp.ClientError errors."""
@@ -96,13 +87,11 @@ async def async_start_event_handler(hass, server_host, server_port, requester):
 
     # start event handler
     from async_upnp_client.aiohttp import AiohttpNotifyServer
-    server = AiohttpNotifyServer(requester,
+    server = AiohttpNotifyServer(
-                                 server_port,
+        requester, server_port, server_host, hass.loop)
-                                 server_host,
-                                 hass.loop)
     await server.start_server()
-    _LOGGER.info('UPNP/DLNA event handler listening on: %s',
+    _LOGGER.info(
-                 server.callback_url)
+        'UPNP/DLNA event handler listening on: %s', server.callback_url)
     hass_data['notify_server'] = server
     hass_data['event_handler'] = server.event_handler
 
@@ -116,10 +105,8 @@ async def async_start_event_handler(hass, server_host, server_port, requester):
     return hass_data['event_handler']
 
 
-async def async_setup_platform(hass: HomeAssistant,
+async def async_setup_platform(
-                               config,
+        hass: HomeAssistant, config, async_add_entities, discovery_info=None):
-                               async_add_entities,
-                               discovery_info=None):
     """Set up DLNA DMR platform."""
     if config.get(CONF_URL) is not None:
         url = config[CONF_URL]
@@ -145,10 +132,8 @@ async def async_setup_platform(hass: HomeAssistant,
         if server_host is None:
             server_host = get_local_ip()
         server_port = config.get(CONF_LISTEN_PORT, DEFAULT_LISTEN_PORT)
-        event_handler = await async_start_event_handler(hass,
+        event_handler = await async_start_event_handler(
-                                                        server_host,
+            hass, server_host, server_port, requester)
-                                                        server_port,
-                                                        requester)
 
     # create upnp device
     from async_upnp_client import UpnpFactory
@@ -183,10 +168,10 @@ class DlnaDmrDevice(MediaPlayerDevice):
         """Handle addition."""
         self._device.on_event = self._on_event
 
-        # register unsubscribe on stop
+        # Register unsubscribe on stop
         bus = self.hass.bus
-        bus.async_listen_once(EVENT_HOMEASSISTANT_STOP,
+        bus.async_listen_once(
-                              self._async_on_hass_stop)
+            EVENT_HOMEASSISTANT_STOP, self._async_on_hass_stop)
 
     @property
     def available(self):
@@ -306,23 +291,21 @@ class DlnaDmrDevice(MediaPlayerDevice):
         mime_type = HOME_ASSISTANT_UPNP_MIME_TYPE_MAPPING[media_type]
         upnp_class = HOME_ASSISTANT_UPNP_CLASS_MAPPING[media_type]
 
-        # stop current playing media
+        # Stop current playing media
         if self._device.can_stop:
             await self.async_media_stop()
 
-        # queue media
+        # +ueue media
-        await self._device.async_set_transport_uri(media_id,
+        await self._device.async_set_transport_uri(
-                                                   title,
+            media_id, title, mime_type, upnp_class)
-                                                   mime_type,
-                                                   upnp_class)
         await self._device.async_wait_for_can_play()
 
-        # if already playing, no need to call Play
+        # If already playing, no need to call Play
         from async_upnp_client import dlna
         if self._device.state == dlna.STATE_PLAYING:
             return
 
-        # play it
+        # Play it
         await self.async_media_play()
 
     @catch_request_errors()

homeassistant/components/media_player/dunehd.py

@@ -6,13 +6,13 @@ https://home-assistant.io/components/media_player.dunehd/
 """
 import voluptuous as vol
 
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.media_player import (
-    SUPPORT_PAUSE, SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_NEXT_TRACK,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, PLATFORM_SCHEMA,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
-    SUPPORT_PLAY, MediaPlayerDevice)
+    SUPPORT_TURN_ON, MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, STATE_OFF, STATE_PAUSED, STATE_ON, STATE_PLAYING)
+    CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_PAUSED, STATE_PLAYING)
+import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['pdunehd==1.3']
 

homeassistant/components/media_player/emby.py

@@ -10,13 +10,13 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_TVSHOW, MEDIA_TYPE_MOVIE, MEDIA_TYPE_MUSIC, SUPPORT_NEXT_TRACK,
+    MEDIA_TYPE_MOVIE, MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW, PLATFORM_SCHEMA,
-    SUPPORT_PAUSE, SUPPORT_SEEK, SUPPORT_STOP, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK,
-    MediaPlayerDevice, SUPPORT_PLAY, PLATFORM_SCHEMA)
+    SUPPORT_SEEK, SUPPORT_STOP, MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING,
+    CONF_API_KEY, CONF_HOST, CONF_PORT, CONF_SSL, DEVICE_DEFAULT_NAME,
-    CONF_HOST, CONF_PORT, CONF_SSL, CONF_API_KEY, DEVICE_DEFAULT_NAME,
+    EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP, STATE_IDLE, STATE_OFF,
-    EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP)
+    STATE_PAUSED, STATE_PLAYING)
 from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 import homeassistant.util.dt as dt_util
@@ -42,11 +42,11 @@ SUPPORT_EMBY = SUPPORT_PAUSE | SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | \
     SUPPORT_STOP | SUPPORT_SEEK | SUPPORT_PLAY
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string,
-    vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean,
     vol.Required(CONF_API_KEY): cv.string,
-    vol.Optional(CONF_PORT): cv.port,
     vol.Optional(CONF_AUTO_HIDE, default=DEFAULT_AUTO_HIDE): cv.boolean,
+    vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string,
+    vol.Optional(CONF_PORT): cv.port,
+    vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean,
 })
 
 
@@ -95,7 +95,7 @@ def async_setup_platform(hass, config, async_add_entities,
 
         if new_devices:
             _LOGGER.debug("Adding new devices: %s", new_devices)
-            async_add_entities(new_devices, update_before_add=True)
+            async_add_entities(new_devices, True)
 
     @callback
     def device_removal_callback(data):

homeassistant/components/media_player/epson.py

@@ -5,6 +5,7 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/media_player.epson/
 """
 import logging
+
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
@@ -20,37 +21,45 @@ import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['epson-projector==0.1.3']
 
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_CMODE = 'cmode'
+
 DATA_EPSON = 'epson'
 DEFAULT_NAME = 'EPSON Projector'
 
-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=80): cv.port,
-    vol.Optional(CONF_SSL, default=False): cv.boolean
-})
-
 SERVICE_SELECT_CMODE = 'epson_select_cmode'
-ATTR_CMODE = 'cmode'
 SUPPORT_CMODE = 33001
 
 SUPPORT_EPSON = SUPPORT_TURN_ON | SUPPORT_TURN_OFF | SUPPORT_SELECT_SOURCE |\
             SUPPORT_CMODE | SUPPORT_VOLUME_MUTE | SUPPORT_VOLUME_STEP | \
             SUPPORT_NEXT_TRACK | SUPPORT_PREVIOUS_TRACK
-_LOGGER = logging.getLogger(__name__)
 
 
-async def async_setup_platform(hass, config, async_add_entities,
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-                               discovery_info=None):
+    vol.Required(CONF_HOST): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_PORT, default=80): cv.port,
+    vol.Optional(CONF_SSL, default=False): cv.boolean,
+})
+
+
+async def async_setup_platform(
+        hass, config, async_add_entities, discovery_info=None):
     """Set up the Epson media player platform."""
+    from epson_projector.const import (CMODE_LIST_SET)
+
     if DATA_EPSON not in hass.data:
         hass.data[DATA_EPSON] = []
+
     name = config.get(CONF_NAME)
     host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    ssl = config.get(CONF_SSL)
+
+    epson = EpsonProjector(async_get_clientsession(
+        hass, verify_ssl=False), name, host, port, ssl)
 
-    epson = EpsonProjector(async_get_clientsession(hass, verify_ssl=False),
-                           name, host,
-                           config.get(CONF_PORT), config.get(CONF_SSL))
     hass.data[DATA_EPSON].append(epson)
     async_add_entities([epson], update_before_add=True)
 
@@ -67,7 +76,7 @@ async def async_setup_platform(hass, config, async_add_entities,
                 cmode = service.data.get(ATTR_CMODE)
                 await device.select_cmode(cmode)
             await device.update()
-    from epson_projector.const import (CMODE_LIST_SET)
+
     epson_schema = MEDIA_PLAYER_SCHEMA.extend({
         vol.Required(ATTR_CMODE): vol.All(cv.string, vol.Any(*CMODE_LIST_SET))
     })
@@ -81,13 +90,12 @@ class EpsonProjector(MediaPlayerDevice):
 
     def __init__(self, websession, name, host, port, encryption):
         """Initialize entity to control Epson projector."""
-        self._name = name
         import epson_projector as epson
         from epson_projector.const import DEFAULT_SOURCES
+
+        self._name = name
         self._projector = epson.Projector(
-            host,
+            host, websession=websession, port=port)
-            websession=websession,
-            port=port)
         self._cmode = None
         self._source_list = list(DEFAULT_SOURCES.values())
         self._source = None
@@ -97,9 +105,8 @@ class EpsonProjector(MediaPlayerDevice):
     async def update(self):
         """Update state of device."""
         from epson_projector.const import (
-            EPSON_CODES, POWER,
+            EPSON_CODES, POWER, CMODE, CMODE_LIST, SOURCE, VOLUME, BUSY,
-            CMODE, CMODE_LIST, SOURCE, VOLUME,
+            SOURCE_LIST)
-            BUSY, SOURCE_LIST)
         is_turned_on = await self._projector.get_property(POWER)
         _LOGGER.debug("Project turn on/off status: %s", is_turned_on)
         if is_turned_on and is_turned_on == EPSON_CODES[POWER]:

homeassistant/components/media_player/firetv.py

@@ -10,13 +10,13 @@ import requests
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, PLATFORM_SCHEMA,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
-    SUPPORT_VOLUME_SET, SUPPORT_PLAY, MediaPlayerDevice)
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_SET, MediaPlayerDevice)
 from homeassistant.const import (
+    CONF_DEVICE, CONF_DEVICES, CONF_HOST, CONF_NAME, CONF_PORT, CONF_SSL,
     STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING, STATE_STANDBY,
-    STATE_UNKNOWN, CONF_HOST, CONF_PORT, CONF_SSL, CONF_NAME, CONF_DEVICE,
+    STATE_UNKNOWN)
-    CONF_DEVICES)
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/media_player/frontier_silicon.py

@@ -10,14 +10,14 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK,
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_PLAY_MEDIA, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK,
-    SUPPORT_VOLUME_STEP, SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
+    SUPPORT_SELECT_SOURCE, SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_PLAY, SUPPORT_SELECT_SOURCE, MediaPlayerDevice, PLATFORM_SCHEMA,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_STEP,
-    MEDIA_TYPE_MUSIC)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_OFF, STATE_PLAYING, STATE_PAUSED, STATE_UNKNOWN,
+    CONF_HOST, CONF_PASSWORD, CONF_PORT, STATE_OFF, STATE_PAUSED,
-    CONF_HOST, CONF_PORT, CONF_PASSWORD)
+    STATE_PLAYING, STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['afsapi==0.0.4']
@@ -42,16 +42,15 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 @asyncio.coroutine
-def async_setup_platform(hass, config, async_add_entities,
+def async_setup_platform(
-                         discovery_info=None):
+        hass, config, async_add_entities, discovery_info=None):
     """Set up the Frontier Silicon platform."""
     import requests
 
     if discovery_info is not None:
         async_add_entities(
-            [AFSAPIDevice(discovery_info['ssdp_description'],
+            [AFSAPIDevice(
-                          DEFAULT_PASSWORD)],
+                discovery_info['ssdp_description'], DEFAULT_PASSWORD)], True)
-            update_before_add=True)
         return True
 
     host = config.get(CONF_HOST)
@@ -60,8 +59,7 @@ def async_setup_platform(hass, config, async_add_entities,
 
     try:
         async_add_entities(
-            [AFSAPIDevice(DEVICE_URL.format(host, port), password)],
+            [AFSAPIDevice(DEVICE_URL.format(host, port), password)], True)
-            update_before_add=True)
         _LOGGER.debug("FSAPI device %s:%s -> %s", host, port, password)
         return True
     except requests.exceptions.RequestException:
@@ -78,7 +76,7 @@ class AFSAPIDevice(MediaPlayerDevice):
         """Initialize the Frontier Silicon API device."""
         self._device_url = device_url
         self._password = password
-        self._state = STATE_UNKNOWN
+        self._state = None
 
         self._name = None
         self._title = None

homeassistant/components/media_player/gpmdp.py

@@ -4,19 +4,19 @@ Support for Google Play Music Desktop Player.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.gpmdp/
 """
-import logging
 import json
+import logging
 import socket
 import time
 
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MUSIC, SUPPORT_NEXT_TRACK, SUPPORT_PREVIOUS_TRACK,
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_PAUSE, SUPPORT_VOLUME_SET, SUPPORT_SEEK, SUPPORT_PLAY,
+    SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK, SUPPORT_VOLUME_SET,
-    MediaPlayerDevice, PLATFORM_SCHEMA)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_PLAYING, STATE_PAUSED, STATE_OFF, CONF_HOST, CONF_PORT, CONF_NAME)
+    CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF, STATE_PAUSED, STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util.json import load_json, save_json
 
@@ -55,9 +55,11 @@ def request_configuration(hass, config, url, add_entities_callback):
         return
     from websocket import create_connection
     websocket = create_connection((url), timeout=1)
-    websocket.send(json.dumps({'namespace': 'connect',
+    websocket.send(json.dumps({
-                               'method': 'connect',
+        'namespace': 'connect',
-                               'arguments': ['Home Assistant']}))
+        'method': 'connect',
+        'arguments': ['Home Assistant']
+    }))
 
     def gpmdp_configuration_callback(callback_data):
         """Handle configuration changes."""

homeassistant/components/media_player/gstreamer.py

@@ -9,21 +9,18 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MUSIC, SUPPORT_VOLUME_SET, SUPPORT_PAUSE,
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_PLAY_MEDIA, SUPPORT_PLAY, SUPPORT_NEXT_TRACK,
+    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_VOLUME_SET, MediaPlayerDevice)
-    PLATFORM_SCHEMA, MediaPlayerDevice)
+from homeassistant.const import CONF_NAME, EVENT_HOMEASSISTANT_STOP, STATE_IDLE
-from homeassistant.const import (
-    STATE_IDLE, CONF_NAME, EVENT_HOMEASSISTANT_STOP)
 import homeassistant.helpers.config_validation as cv
 
+REQUIREMENTS = ['gstreamer-player==1.1.0']
 
 _LOGGER = logging.getLogger(__name__)
 
-
-REQUIREMENTS = ['gstreamer-player==1.1.0']
-DOMAIN = 'gstreamer'
 CONF_PIPELINE = 'pipeline'
 
+DOMAIN = 'gstreamer'
 
 SUPPORT_GSTREAMER = SUPPORT_VOLUME_SET | SUPPORT_PLAY | SUPPORT_PAUSE |\
      SUPPORT_PLAY_MEDIA | SUPPORT_NEXT_TRACK

homeassistant/components/media_player/hdmi_cec.py

@@ -7,12 +7,12 @@ https://home-assistant.io/components/hdmi_cec/
 import logging
 
 from homeassistant.components.hdmi_cec import ATTR_NEW, CecDevice
-from homeassistant.components.media_player import MediaPlayerDevice, DOMAIN, \
+from homeassistant.components.media_player import (
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_PLAY_MEDIA, SUPPORT_PAUSE, \
+    DOMAIN, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_NEXT_TRACK, SUPPORT_STOP, \
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_VOLUME_STEP, SUPPORT_VOLUME_MUTE
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP, MediaPlayerDevice)
-from homeassistant.const import STATE_ON, STATE_OFF, STATE_PLAYING, \
+from homeassistant.const import (
-    STATE_IDLE, STATE_PAUSED
+    STATE_IDLE, STATE_OFF, STATE_ON, STATE_PAUSED, STATE_PLAYING)
 from homeassistant.core import HomeAssistant
 
 DEPENDENCIES = ['hdmi_cec']

homeassistant/components/media_player/horizon.py

@@ -4,27 +4,26 @@ Support for the Unitymedia Horizon HD Recorder.
 For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/media_player.horizon/
 """
-
 from datetime import timedelta
 import logging
 
 import voluptuous as vol
 
+from homeassistant import util
 from homeassistant.components.media_player import (
-    MediaPlayerDevice, PLATFORM_SCHEMA, MEDIA_TYPE_CHANNEL,
+    MEDIA_TYPE_CHANNEL, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_NEXT_TRACK, SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_PAUSE,
+    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_OFF,
-    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK)
+    SUPPORT_TURN_ON, MediaPlayerDevice)
-from homeassistant.const import (CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF,
+from homeassistant.const import (
-                                 STATE_PAUSED, STATE_PLAYING)
+    CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF, STATE_PAUSED, STATE_PLAYING)
 from homeassistant.exceptions import PlatformNotReady
 import homeassistant.helpers.config_validation as cv
-from homeassistant import util
 
 REQUIREMENTS = ['einder==0.3.1']
 
 _LOGGER = logging.getLogger(__name__)
 
-DEFAULT_NAME = "Horizon"
+DEFAULT_NAME = 'Horizon'
 DEFAULT_PORT = 5900
 
 MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)

homeassistant/components/media_player/itunes.py

@@ -10,21 +10,21 @@ import requests
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
+    MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK,
-    SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK, SUPPORT_TURN_OFF,
+    SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, PLATFORM_SCHEMA,
+    SUPPORT_SEEK, SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE,
-    SUPPORT_PLAY, MediaPlayerDevice)
+    SUPPORT_VOLUME_SET, MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_IDLE, STATE_OFF, STATE_ON, STATE_PAUSED, STATE_PLAYING, CONF_NAME,
+    CONF_HOST, CONF_NAME, CONF_PORT, CONF_SSL, STATE_IDLE, STATE_OFF, STATE_ON,
-    CONF_HOST, CONF_PORT, CONF_SSL)
+    STATE_PAUSED, STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME = 'iTunes'
 DEFAULT_PORT = 8181
-DEFAULT_TIMEOUT = 10
 DEFAULT_SSL = False
+DEFAULT_TIMEOUT = 10
 DOMAIN = 'itunes'
 
 SUPPORT_ITUNES = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
@@ -52,7 +52,7 @@ class Itunes:
 
     @property
     def _base_url(self):
-        """Return the base url for endpoints."""
+        """Return the base URL for endpoints."""
         if self.use_ssl:
             uri_scheme = 'https://'
         else:

homeassistant/components/media_player/kodi.py

@@ -8,27 +8,29 @@ import asyncio
 from collections import OrderedDict
 from functools import wraps
 import logging
+import re
 import socket
 import urllib
-import re
 
 import aiohttp
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK,
+    DOMAIN, MEDIA_PLAYER_SCHEMA, MEDIA_TYPE_CHANNEL, MEDIA_TYPE_MOVIE,
-    SUPPORT_PLAY_MEDIA, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_STOP,
+    MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, MEDIA_TYPE_TVSHOW, MEDIA_TYPE_VIDEO,
-    SUPPORT_TURN_OFF, SUPPORT_PLAY, SUPPORT_VOLUME_STEP, SUPPORT_SHUFFLE_SET,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    MediaPlayerDevice, PLATFORM_SCHEMA, MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW,
+    SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK,
-    MEDIA_TYPE_MOVIE, MEDIA_TYPE_VIDEO, MEDIA_TYPE_CHANNEL,
+    SUPPORT_SHUFFLE_SET, SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    MEDIA_TYPE_PLAYLIST, MEDIA_PLAYER_SCHEMA, DOMAIN, SUPPORT_TURN_ON)
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_STEP,
+    MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING, CONF_HOST, CONF_NAME,
+    CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT, CONF_PROXY_SSL,
-    CONF_PORT, CONF_PROXY_SSL, CONF_USERNAME, CONF_PASSWORD,
+    CONF_TIMEOUT, CONF_USERNAME, EVENT_HOMEASSISTANT_STOP, STATE_IDLE,
-    CONF_TIMEOUT, EVENT_HOMEASSISTANT_STOP)
+    STATE_OFF, STATE_PAUSED, STATE_PLAYING)
 from homeassistant.core import callback
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import script
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers import script, config_validation as cv
 from homeassistant.helpers.template import Template
 from homeassistant.util.yaml import dump
 

homeassistant/components/media_player/lg_netcast.py

@@ -10,15 +10,16 @@ import logging
 from requests import RequestException
 import voluptuous as vol
 
-import homeassistant.helpers.config_validation as cv
-from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, PLATFORM_SCHEMA,
-    SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
-    SUPPORT_SELECT_SOURCE, SUPPORT_PLAY, MEDIA_TYPE_CHANNEL, MediaPlayerDevice)
-from homeassistant.const import (
-    CONF_HOST, CONF_NAME, CONF_ACCESS_TOKEN,
-    STATE_OFF, STATE_PLAYING, STATE_PAUSED, STATE_UNKNOWN)
 from homeassistant import util
+from homeassistant.components.media_player import (
+    MEDIA_TYPE_CHANNEL, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
+    SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE,
+    SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
+    MediaPlayerDevice)
+from homeassistant.const import (
+    CONF_ACCESS_TOKEN, CONF_HOST, CONF_NAME, STATE_OFF, STATE_PAUSED,
+    STATE_PLAYING, STATE_UNKNOWN)
+import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['pylgnetcast-homeassistant==0.2.0.dev0']
 
@@ -35,16 +36,16 @@ SUPPORT_LGTV = SUPPORT_PAUSE | SUPPORT_VOLUME_STEP | \
                SUPPORT_SELECT_SOURCE | SUPPORT_PLAY
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Required(CONF_HOST): cv.string,
-    vol.Optional(CONF_ACCESS_TOKEN):
+    vol.Optional(CONF_ACCESS_TOKEN): vol.All(cv.string, vol.Length(max=6)),
-        vol.All(cv.string, vol.Length(max=6)),
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
 })
 
 
 def setup_platform(hass, config, add_entities, discovery_info=None):
     """Set up the LG TV platform."""
     from pylgnetcast import LgNetCastClient
+
     host = config.get(CONF_HOST)
     access_token = config.get(CONF_ACCESS_TOKEN)
     name = config.get(CONF_NAME)

homeassistant/components/media_player/liveboxplaytv.py

@@ -5,20 +5,20 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.liveboxplaytv/
 """
 import asyncio
-import logging
 from datetime import timedelta
+import logging
 
 import requests
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_PLAY,
+    MEDIA_TYPE_CHANNEL, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE,
-    SUPPORT_VOLUME_STEP, SUPPORT_VOLUME_MUTE, SUPPORT_SELECT_SOURCE,
+    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE,
-    MEDIA_TYPE_CHANNEL, MediaPlayerDevice, PLATFORM_SCHEMA)
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, CONF_PORT, STATE_ON, STATE_OFF, STATE_PLAYING,
+    CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF, STATE_ON, STATE_PAUSED,
-    STATE_PAUSED, CONF_NAME)
+    STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 import homeassistant.util.dt as dt_util
 
@@ -40,7 +40,7 @@ MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
 })
 
 

homeassistant/components/media_player/mediaroom.py

@@ -8,45 +8,41 @@ import logging
 
 import voluptuous as vol
 
-from homeassistant.core import callback
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_CHANNEL, SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA, SUPPORT_TURN_OFF,
+    MEDIA_TYPE_CHANNEL, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_TURN_ON, SUPPORT_STOP, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK,
+    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_STOP,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_PLAY, SUPPORT_VOLUME_STEP,
+    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE,
-    SUPPORT_VOLUME_MUTE, MediaPlayerDevice,
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
-)
-from homeassistant.helpers.dispatcher import (
-    dispatcher_send, async_dispatcher_connect
-)
 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, CONF_OPTIMISTIC, STATE_OFF,
+    CONF_HOST, CONF_NAME, CONF_OPTIMISTIC, CONF_TIMEOUT,
-    CONF_TIMEOUT, STATE_PAUSED, STATE_PLAYING, STATE_STANDBY,
+    EVENT_HOMEASSISTANT_STOP, STATE_OFF, STATE_PAUSED, STATE_PLAYING,
-    STATE_UNAVAILABLE, EVENT_HOMEASSISTANT_STOP
+    STATE_STANDBY, STATE_UNAVAILABLE)
-)
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.dispatcher import (
+    async_dispatcher_connect, dispatcher_send)
 
 REQUIREMENTS = ['pymediaroom==0.6.4']
 
 _LOGGER = logging.getLogger(__name__)
 
-DEFAULT_NAME = 'Mediaroom STB'
+DATA_MEDIAROOM = 'mediaroom_known_stb'
+DEFAULT_NAME = "Mediaroom STB"
 DEFAULT_TIMEOUT = 9
-DATA_MEDIAROOM = "mediaroom_known_stb"
+DISCOVERY_MEDIAROOM = 'mediaroom_discovery_installed'
-DISCOVERY_MEDIAROOM = "mediaroom_discovery_installed"
+
 SIGNAL_STB_NOTIFY = 'mediaroom_stb_discovered'
 SUPPORT_MEDIAROOM = SUPPORT_PAUSE | SUPPORT_TURN_ON | SUPPORT_TURN_OFF \
     | SUPPORT_VOLUME_STEP | SUPPORT_VOLUME_MUTE | SUPPORT_PLAY_MEDIA \
     | SUPPORT_STOP | SUPPORT_NEXT_TRACK | SUPPORT_PREVIOUS_TRACK \
     | SUPPORT_PLAY
 
-PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    {
+    vol.Optional(CONF_HOST): cv.string,
-        vol.Optional(CONF_HOST): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
-        vol.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
+    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
-        vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
+})
-    }
-)
 
 
 async def async_setup_platform(hass, config, async_add_entities,
@@ -57,10 +53,9 @@ async def async_setup_platform(hass, config, async_add_entities,
         known_hosts = hass.data[DATA_MEDIAROOM] = []
     host = config.get(CONF_HOST, None)
     if host:
-        async_add_entities([MediaroomDevice(host=host,
+        async_add_entities([MediaroomDevice(
-                                            device_id=None,
+            host=host, device_id=None, optimistic=config[CONF_OPTIMISTIC],
-                                            optimistic=config[CONF_OPTIMISTIC],
+            timeout=config[CONF_TIMEOUT])])
-                                            timeout=config[CONF_TIMEOUT])])
         hass.data[DATA_MEDIAROOM].append(host)
 
     _LOGGER.debug("Trying to discover Mediaroom STB")
@@ -75,8 +70,7 @@ async def async_setup_platform(hass, config, async_add_entities,
         hass.data[DATA_MEDIAROOM].append(notify.ip_address)
         new_stb = MediaroomDevice(
             host=notify.ip_address, device_id=notify.device_uuid,
-            optimistic=False
+            optimistic=False)
-        )
         async_add_entities([new_stb])
 
     if not config[CONF_OPTIMISTIC]:
@@ -90,11 +84,11 @@ async def async_setup_platform(hass, config, async_add_entities,
             @callback
             def stop_discovery(event):
                 """Stop discovery of new mediaroom STB's."""
-                _LOGGER.debug("Stopping internal pymediaroom discovery.")
+                _LOGGER.debug("Stopping internal pymediaroom discovery")
                 hass.data[DISCOVERY_MEDIAROOM].close()
 
-            hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP,
+            hass.bus.async_listen_once(
-                                       stop_discovery)
+                EVENT_HOMEASSISTANT_STOP, stop_discovery)
 
             _LOGGER.debug("Auto discovery installed")
 
@@ -118,8 +112,8 @@ class MediaroomDevice(MediaPlayerDevice):
 
         self._state = state_map[mediaroom_state]
 
-    def __init__(self, host, device_id, optimistic=False,
+    def __init__(
-                 timeout=DEFAULT_TIMEOUT):
+            self, host, device_id, optimistic=False, timeout=DEFAULT_TIMEOUT):
         """Initialize the device."""
         from pymediaroom import Remote
 
@@ -160,8 +154,8 @@ class MediaroomDevice(MediaPlayerDevice):
             self._available = True
             self.async_schedule_update_ha_state()
 
-        async_dispatcher_connect(self.hass, SIGNAL_STB_NOTIFY,
+        async_dispatcher_connect(
-                                 async_notify_received)
+            self.hass, SIGNAL_STB_NOTIFY, async_notify_received)
 
     async def async_play_media(self, media_type, media_id, **kwargs):
         """Play media."""

homeassistant/components/media_player/mpchc.py

@@ -11,12 +11,12 @@ import requests
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_VOLUME_MUTE, SUPPORT_PAUSE, SUPPORT_STOP, SUPPORT_NEXT_TRACK,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_VOLUME_STEP, SUPPORT_PLAY,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_STOP, SUPPORT_VOLUME_MUTE,
-    MediaPlayerDevice, PLATFORM_SCHEMA)
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_OFF, STATE_IDLE, STATE_PAUSED, STATE_PLAYING, CONF_NAME, CONF_HOST,
+    CONF_HOST, CONF_NAME, CONF_PORT, STATE_IDLE, STATE_OFF, STATE_PAUSED,
-    CONF_PORT)
+    STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/media_player/nad.py

@@ -9,12 +9,10 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_VOLUME_SET,
+    PLATFORM_SCHEMA, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_VOLUME_MUTE, SUPPORT_TURN_ON, SUPPORT_TURN_OFF,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_STEP,
-    SUPPORT_VOLUME_STEP, SUPPORT_SELECT_SOURCE, MediaPlayerDevice,
+    MediaPlayerDevice)
-    PLATFORM_SCHEMA)
+from homeassistant.const import CONF_NAME, STATE_OFF, STATE_ON
-from homeassistant.const import (
-    CONF_NAME, STATE_OFF, STATE_ON)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['nad_receiver==0.0.9']

homeassistant/components/media_player/onkyo.py

@@ -12,10 +12,10 @@ from typing import List  # noqa: F401
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
+    PLATFORM_SCHEMA, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_SELECT_SOURCE,
     SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    SUPPORT_VOLUME_STEP, SUPPORT_SELECT_SOURCE, SUPPORT_PLAY,
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
-    SUPPORT_PLAY_MEDIA, MediaPlayerDevice, PLATFORM_SCHEMA)
+from homeassistant.const import CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON
-from homeassistant.const import (STATE_OFF, STATE_ON, CONF_HOST, CONF_NAME)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['onkyo-eiscp==1.2.4']

homeassistant/components/media_player/openhome.py

@@ -7,12 +7,12 @@ https://home-assistant.io/components/media_player.openhome/
 import logging
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_ON,
+    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_TURN_OFF, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_MUTE,
+    SUPPORT_SELECT_SOURCE, SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_VOLUME_STEP, SUPPORT_STOP, SUPPORT_PLAY, SUPPORT_SELECT_SOURCE,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_STEP,
     MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_IDLE, STATE_PAUSED, STATE_PLAYING, STATE_OFF)
+    STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING)
 
 REQUIREMENTS = ['openhomedevice==0.4.2']
 

homeassistant/components/media_player/panasonic_viera.py

@@ -9,22 +9,19 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
+    MEDIA_TYPE_URL, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_PLAY,
+    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_STOP,
-    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MEDIA_TYPE_URL,
+    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    SUPPORT_PLAY_MEDIA, SUPPORT_STOP,
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
-    SUPPORT_VOLUME_STEP, MediaPlayerDevice, PLATFORM_SCHEMA)
 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN, CONF_PORT)
+    CONF_HOST, CONF_MAC, CONF_NAME, CONF_PORT, STATE_OFF, STATE_ON,
+    STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['panasonic_viera==0.3.1',
+REQUIREMENTS = ['panasonic_viera==0.3.1', 'wakeonlan==1.0.0']
-                'wakeonlan==1.0.0']
 
 _LOGGER = logging.getLogger(__name__)
 
-CONF_MAC = 'mac'
-
 DEFAULT_NAME = 'Panasonic Viera TV'
 DEFAULT_PORT = 55000
 

homeassistant/components/media_player/pandora.py

@@ -4,23 +4,22 @@ Component for controlling Pandora stations through the pianobar client.
 For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/media_player.pandora/
 """
-import logging
-import re
-import os
-import signal
 from datetime import timedelta
+import logging
+import os
+import re
 import shutil
+import signal
 
-from homeassistant.const import EVENT_HOMEASSISTANT_STOP
-from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, MEDIA_TYPE_MUSIC,
-    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_PLAY,
-    SUPPORT_SELECT_SOURCE, SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_PLAY_PAUSE,
-    SERVICE_MEDIA_PLAY, SERVICE_VOLUME_UP, SERVICE_VOLUME_DOWN,
-    MediaPlayerDevice)
-from homeassistant.const import (STATE_OFF, STATE_PAUSED, STATE_PLAYING,
-                                 STATE_IDLE)
 from homeassistant import util
+from homeassistant.components.media_player import (
+    MEDIA_TYPE_MUSIC, SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_PLAY,
+    SERVICE_MEDIA_PLAY_PAUSE, SERVICE_VOLUME_DOWN, SERVICE_VOLUME_UP,
+    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_SELECT_SOURCE,
+    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, MediaPlayerDevice)
+from homeassistant.const import (
+    EVENT_HOMEASSISTANT_STOP, STATE_IDLE, STATE_OFF, STATE_PAUSED,
+    STATE_PLAYING)
 
 REQUIREMENTS = ['pexpect==4.6.0']
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/media_player/philips_js.py

@@ -4,19 +4,19 @@ Media Player component to integrate TVs exposing the Joint Space API.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.philips_js/
 """
-import logging
 from datetime import timedelta
+import logging
 
 import voluptuous as vol
 
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.media_player import (
-    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PREVIOUS_TRACK,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK,
     SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
     SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_STEP,
-    SUPPORT_PLAY, MediaPlayerDevice)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, CONF_API_VERSION, STATE_OFF, STATE_ON, STATE_UNKNOWN)
+    CONF_API_VERSION, CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN)
+import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.script import Script
 from homeassistant.util import Throttle
 
@@ -37,7 +37,7 @@ CONF_ON_ACTION = 'turn_on_action'
 
 DEFAULT_DEVICE = 'default'
 DEFAULT_HOST = '127.0.0.1'
-DEFAULT_NAME = 'Philips TV'
+DEFAULT_NAME = "Philips TV"
 DEFAULT_API_VERSION = '1'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({

homeassistant/components/media_player/pioneer.py

@@ -10,12 +10,12 @@ import telnetlib
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_PAUSE, SUPPORT_SELECT_SOURCE, MediaPlayerDevice, PLATFORM_SCHEMA,
+    PLATFORM_SCHEMA, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_SELECT_SOURCE,
     SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    SUPPORT_PLAY)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, STATE_OFF, STATE_ON, STATE_UNKNOWN, CONF_NAME, CONF_PORT,
+    CONF_HOST, CONF_NAME, CONF_PORT, CONF_TIMEOUT, STATE_OFF, STATE_ON,
-    CONF_TIMEOUT)
+    STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/media_player/pjlink.py

@@ -9,11 +9,10 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE,
+    PLATFORM_SCHEMA, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_SELECT_SOURCE, PLATFORM_SCHEMA, MediaPlayerDevice)
+    SUPPORT_VOLUME_MUTE, MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_OFF, STATE_ON, CONF_HOST,
+    CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT, STATE_OFF, STATE_ON)
-    CONF_NAME, CONF_PASSWORD, CONF_PORT)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['pypjlink2==1.2.0']
@@ -87,8 +86,8 @@ class PjLinkDevice(MediaPlayerDevice):
     def projector(self):
         """Create PJLink Projector instance."""
         from pypjlink import Projector
-        projector = Projector.from_address(self._host, self._port,
+        projector = Projector.from_address(
-                                           self._encoding)
+            self._host, self._port, self._encoding)
         projector.authenticate(self._password)
         return projector
 

homeassistant/components/media_player/plex.py

@@ -4,17 +4,16 @@ Support to interface with the Plex API.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.plex/
 """
+from datetime import timedelta
 import json
 import logging
 
-from datetime import timedelta
-
 import requests
 import voluptuous as vol
 
 from homeassistant import util
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW, MEDIA_TYPE_MOVIE, PLATFORM_SCHEMA,
+    MEDIA_TYPE_MOVIE, MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW, PLATFORM_SCHEMA,
     SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK,
     SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
     MediaPlayerDevice)
@@ -22,9 +21,8 @@ from homeassistant.const import (
     DEVICE_DEFAULT_NAME, STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING)
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.event import track_utc_time_change
-from homeassistant.util.json import load_json, save_json
 from homeassistant.util import dt as dt_util
-
+from homeassistant.util.json import load_json, save_json
 
 REQUIREMENTS = ['plexapi==3.0.6']
 
@@ -35,6 +33,7 @@ MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
 MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=1)
 
 PLEX_CONFIG_FILE = 'plex.conf'
+PLEX_DATA = 'plex'
 
 CONF_INCLUDE_NON_CLIENTS = 'include_non_clients'
 CONF_USE_EPISODE_ART = 'use_episode_art'
@@ -44,20 +43,14 @@ CONF_REMOVE_UNAVAILABLE_CLIENTS = 'remove_unavailable_clients'
 CONF_CLIENT_REMOVE_INTERVAL = 'client_remove_interval'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_INCLUDE_NON_CLIENTS, default=False):
+    vol.Optional(CONF_INCLUDE_NON_CLIENTS, default=False): cv.boolean,
-    cv.boolean,
+    vol.Optional(CONF_USE_EPISODE_ART, default=False): cv.boolean,
-    vol.Optional(CONF_USE_EPISODE_ART, default=False):
+    vol.Optional(CONF_USE_CUSTOM_ENTITY_IDS, default=False): cv.boolean,
-    cv.boolean,
+    vol.Optional(CONF_REMOVE_UNAVAILABLE_CLIENTS, default=True): cv.boolean,
-    vol.Optional(CONF_USE_CUSTOM_ENTITY_IDS, default=False):
-    cv.boolean,
-    vol.Optional(CONF_REMOVE_UNAVAILABLE_CLIENTS, default=True):
-    cv.boolean,
     vol.Optional(CONF_CLIENT_REMOVE_INTERVAL, default=timedelta(seconds=600)):
         vol.All(cv.time_period, cv.positive_timedelta),
 })
 
-PLEX_DATA = "plex"
-
 
 def setup_platform(hass, config, add_entities_callback, discovery_info=None):
     """Set up the Plex platform."""
@@ -157,8 +150,8 @@ def setup_plexserver(
             _LOGGER.exception("Error listing plex devices")
             return
         except requests.exceptions.RequestException as ex:
-            _LOGGER.error("Could not connect to plex server at http://%s (%s)",
+            _LOGGER.error(
-                          host, ex)
+                "Could not connect to plex server at http://%s (%s)", host, ex)
             return
 
         new_plex_clients = []
@@ -171,9 +164,9 @@ def setup_plexserver(
             available_client_ids.append(device.machineIdentifier)
 
             if device.machineIdentifier not in plex_clients:
-                new_client = PlexClient(config, device, None,
+                new_client = PlexClient(
-                                        plex_sessions, update_devices,
+                    config, device, None, plex_sessions, update_devices,
-                                        update_sessions)
+                    update_sessions)
                 plex_clients[device.machineIdentifier] = new_client
                 new_plex_clients.append(new_client)
             else:
@@ -184,9 +177,9 @@ def setup_plexserver(
             for machine_identifier, session in plex_sessions.items():
                 if (machine_identifier not in plex_clients
                         and machine_identifier is not None):
-                    new_client = PlexClient(config, None, session,
+                    new_client = PlexClient(
-                                            plex_sessions, update_devices,
+                        config, None, session, plex_sessions, update_devices,
-                                            update_sessions)
+                        update_sessions)
                     plex_clients[machine_identifier] = new_client
                     new_plex_clients.append(new_client)
                 else:
@@ -225,8 +218,8 @@ def setup_plexserver(
             _LOGGER.exception("Error listing plex sessions")
             return
         except requests.exceptions.RequestException as ex:
-            _LOGGER.error("Could not connect to plex server at http://%s (%s)",
+            _LOGGER.error(
-                          host, ex)
+                "Could not connect to plex server at http://%s (%s)", host, ex)
             return
 
         plex_sessions.clear()

homeassistant/components/media_player/roku.py

@@ -9,11 +9,11 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MOVIE, SUPPORT_NEXT_TRACK, SUPPORT_PLAY_MEDIA,
+    MEDIA_TYPE_MOVIE, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PLAY,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE,
-    SUPPORT_SELECT_SOURCE, SUPPORT_PLAY, MediaPlayerDevice, PLATFORM_SCHEMA)
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, STATE_IDLE, STATE_PLAYING, STATE_UNKNOWN, STATE_HOME)
+    CONF_HOST, STATE_HOME, STATE_IDLE, STATE_PLAYING, STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['python-roku==3.1.5']
@@ -40,13 +40,13 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
     hosts = []
 
     if discovery_info:
-        host = discovery_info.get("host")
+        host = discovery_info.get('host')
 
         if host in KNOWN_HOSTS:
             return
 
         _LOGGER.debug("Discovered Roku: %s", host)
-        hosts.append(discovery_info.get("host"))
+        hosts.append(discovery_info.get('host'))
 
     elif CONF_HOST in config:
         hosts.append(config.get(CONF_HOST))

homeassistant/components/media_player/russound_rio.py

@@ -4,20 +4,19 @@ Support for Russound multizone controllers using RIO Protocol.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.russound_rio/
 """
-
 import asyncio
 import logging
 
 import voluptuous as vol
 
-from homeassistant.core import callback
 from homeassistant.components.media_player import (
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
-    SUPPORT_SELECT_SOURCE, MediaPlayerDevice, PLATFORM_SCHEMA,
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    MEDIA_TYPE_MUSIC)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, CONF_PORT, STATE_OFF, STATE_ON,
+    CONF_HOST, CONF_NAME, CONF_PORT, EVENT_HOMEASSISTANT_STOP, STATE_OFF,
-    CONF_NAME, EVENT_HOMEASSISTANT_STOP)
+    STATE_ON)
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['russound_rio==0.1.4']
@@ -31,26 +30,24 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Required(CONF_NAME): cv.string,
     vol.Optional(CONF_PORT, default=9621): cv.port,
-    })
+})
 
 
 @asyncio.coroutine
-def async_setup_platform(hass, config, async_add_entities,
+def async_setup_platform(
-                         discovery_info=None):
+        hass, config, async_add_entities, discovery_info=None):
     """Set up the Russound RIO platform."""
+    from russound_rio import Russound
+
     host = config.get(CONF_HOST)
     port = config.get(CONF_PORT)
 
-    from russound_rio import Russound
-
     russ = Russound(hass.loop, host, port)
 
     yield from russ.connect()
 
-    # Discover sources
+    # Discover sources and zones
     sources = yield from russ.enumerate_sources()
-
-    # Discover zones
     valid_zones = yield from russ.enumerate_zones()
 
     devices = []
@@ -81,9 +78,8 @@ class RussoundZoneDevice(MediaPlayerDevice):
         self._sources = sources
 
     def _zone_var(self, name, default=None):
-        return self._russ.get_cached_zone_variable(self._zone_id,
+        return self._russ.get_cached_zone_variable(
-                                                   name,
+            self._zone_id, name, default)
-                                                   default)
 
     def _source_var(self, name, default=None):
         current = int(self._zone_var('currentsource', 0))
@@ -188,21 +184,17 @@ class RussoundZoneDevice(MediaPlayerDevice):
 
     def async_turn_off(self):
         """Turn off the zone."""
-        return self._russ.send_zone_event(self._zone_id,
+        return self._russ.send_zone_event(self._zone_id, 'ZoneOff')
-                                          "ZoneOff")
 
     def async_turn_on(self):
         """Turn on the zone."""
-        return self._russ.send_zone_event(self._zone_id,
+        return self._russ.send_zone_event(self._zone_id, 'ZoneOn')
-                                          "ZoneOn")
 
     def async_set_volume_level(self, volume):
         """Set the volume level."""
         rvol = int(volume * 50.0)
-        return self._russ.send_zone_event(self._zone_id,
+        return self._russ.send_zone_event(
-                                          "KeyPress",
+            self._zone_id, 'KeyPress', 'Volume', rvol)
-                                          "Volume",
-                                          rvol)
 
     def async_select_source(self, source):
         """Select the source input for this zone."""
@@ -210,4 +202,4 @@ class RussoundZoneDevice(MediaPlayerDevice):
             if name.lower() != source.lower():
                 continue
             return self._russ.send_zone_event(
-                self._zone_id, "SelectSource", source_id)
+                self._zone_id, 'SelectSource', source_id)

homeassistant/components/media_player/russound_rnet.py

@@ -9,10 +9,10 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    PLATFORM_SCHEMA, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_SELECT_SOURCE, MediaPlayerDevice, PLATFORM_SCHEMA)
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, CONF_PORT, STATE_OFF, STATE_ON, CONF_NAME)
+    CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF, STATE_ON)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['russound==0.1.9']

homeassistant/components/media_player/samsungtv.py

@@ -5,23 +5,22 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.samsungtv/
 """
 import asyncio
+from datetime import timedelta
 import logging
 import socket
-from datetime import timedelta
+import subprocess
-
 import sys
 
-import subprocess
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
+    MEDIA_TYPE_CHANNEL, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_PLAY,
+    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_OFF,
-    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP, SUPPORT_PLAY_MEDIA,
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
-    MediaPlayerDevice, PLATFORM_SCHEMA, MEDIA_TYPE_CHANNEL)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_UNKNOWN, CONF_PORT,
+    CONF_HOST, CONF_MAC, CONF_NAME, CONF_PORT, CONF_TIMEOUT, STATE_OFF,
-    CONF_MAC)
+    STATE_ON, STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util import dt as dt_util
 
@@ -29,13 +28,11 @@ REQUIREMENTS = ['samsungctl[websocket]==0.7.1', 'wakeonlan==1.0.0']
 
 _LOGGER = logging.getLogger(__name__)
 
-CONF_TIMEOUT = 'timeout'
-
 DEFAULT_NAME = 'Samsung TV Remote'
 DEFAULT_PORT = 55000
 DEFAULT_TIMEOUT = 0
-KEY_PRESS_TIMEOUT = 1.2
 
+KEY_PRESS_TIMEOUT = 1.2
 KNOWN_DEVICES_KEY = 'samsungtv_known_devices'
 
 SUPPORT_SAMSUNGTV = SUPPORT_PAUSE | SUPPORT_VOLUME_STEP | \

homeassistant/components/media_player/sisyphus.py

@@ -7,25 +7,18 @@ https://home-assistant.io/components/media_player.sisyphus/
 import logging
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK,
+    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_PAUSE,
+    SUPPORT_SHUFFLE_SET, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_PLAY,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MediaPlayerDevice)
-    SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_SHUFFLE_SET,
-    SUPPORT_TURN_OFF,
-    SUPPORT_TURN_ON,
-    SUPPORT_VOLUME_MUTE,
-    SUPPORT_VOLUME_SET,
-    MediaPlayerDevice)
 from homeassistant.components.sisyphus import DATA_SISYPHUS
-from homeassistant.const import CONF_HOST, CONF_NAME, STATE_PLAYING, \
+from homeassistant.const import (
-    STATE_PAUSED, STATE_IDLE, STATE_OFF
+    CONF_HOST, CONF_NAME, STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING)
 
 _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['sisyphus']
 
-MEDIA_TYPE_TRACK = "sisyphus_track"
+MEDIA_TYPE_TRACK = 'sisyphus_track'
 
 SUPPORTED_FEATURES = SUPPORT_VOLUME_MUTE \
     | SUPPORT_VOLUME_SET \
@@ -44,21 +37,14 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
     name = discovery_info[CONF_NAME]
     host = discovery_info[CONF_HOST]
     add_entities(
-        [SisyphusPlayer(name, host, hass.data[DATA_SISYPHUS][name])],
+        [SisyphusPlayer(name, host, hass.data[DATA_SISYPHUS][name])], True)
-        update_before_add=True)
 
 
 class SisyphusPlayer(MediaPlayerDevice):
-    """Represents a single Sisyphus table as a media player device."""
+    """Representation of a Sisyphus table as a media player device."""
 
     def __init__(self, name, host, table):
-        """
+        """Initialize the Sisyphus media device."""
-        Constructor.
-
-        :param name: name of the table
-        :param host: hostname or ip address
-        :param table: sisyphus-control Table object
-        """
         self._name = name
         self._host = host
         self._table = table
@@ -99,11 +85,7 @@ class SisyphusPlayer(MediaPlayerDevice):
         return self._table.is_shuffle
 
     async def async_set_shuffle(self, shuffle):
-        """
+        """Change the shuffle mode of the current playlist."""
-        Change the shuffle mode of the current playlist.
-
-        :param shuffle: True to shuffle, False not to
-        """
         await self._table.set_shuffle(shuffle)
 
     @property

homeassistant/components/media_player/songpal.py

@@ -9,32 +9,30 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    PLATFORM_SCHEMA, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
+    DOMAIN, PLATFORM_SCHEMA, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
-    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP, SUPPORT_VOLUME_SET,
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    SUPPORT_TURN_ON, MediaPlayerDevice, DOMAIN)
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
-from homeassistant.const import (
+from homeassistant.const import ATTR_ENTITY_ID, CONF_NAME, STATE_OFF, STATE_ON
-    CONF_NAME, STATE_ON, STATE_OFF, ATTR_ENTITY_ID)
 from homeassistant.exceptions import PlatformNotReady
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['python-songpal==0.0.8']
 
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ENDPOINT = 'endpoint'
+
+PARAM_NAME = 'name'
+PARAM_VALUE = 'value'
+
+PLATFORM = 'songpal'
+
+SET_SOUND_SETTING = 'songpal_set_sound_setting'
+
 SUPPORT_SONGPAL = SUPPORT_VOLUME_SET | SUPPORT_VOLUME_STEP | \
                   SUPPORT_VOLUME_MUTE | SUPPORT_SELECT_SOURCE | \
                   SUPPORT_TURN_ON | SUPPORT_TURN_OFF
 
-_LOGGER = logging.getLogger(__name__)
-
-
-PLATFORM = "songpal"
-
-SET_SOUND_SETTING = "songpal_set_sound_setting"
-
-PARAM_NAME = "name"
-PARAM_VALUE = "value"
-
-CONF_ENDPOINT = "endpoint"
-
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_NAME): cv.string,
     vol.Required(CONF_ENDPOINT): cv.string,
@@ -43,13 +41,15 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 SET_SOUND_SCHEMA = vol.Schema({
     vol.Optional(ATTR_ENTITY_ID): cv.entity_id,
     vol.Required(PARAM_NAME): cv.string,
-    vol.Required(PARAM_VALUE): cv.string})
+    vol.Required(PARAM_VALUE): cv.string,
+})
 
 
-async def async_setup_platform(hass, config,
+async def async_setup_platform(
-                               async_add_entities, discovery_info=None):
+        hass, config, async_add_entities, discovery_info=None):
     """Set up the Songpal platform."""
     from songpal import SongpalException
+
     if PLATFORM not in hass.data:
         hass.data[PLATFORM] = {}
 
@@ -85,8 +85,8 @@ async def async_setup_platform(hass, config,
                 _LOGGER.debug("Calling %s (entity: %s) with params %s",
                               service, entity_id, params)
 
-                await device.async_set_sound_setting(params[PARAM_NAME],
+                await device.async_set_sound_setting(
-                                                     params[PARAM_VALUE])
+                    params[PARAM_NAME], params[PARAM_VALUE])
 
     hass.services.async_register(
         DOMAIN, SET_SOUND_SETTING, async_service_handler,
@@ -151,8 +151,8 @@ class SongpalDevice(MediaPlayerDevice):
                 return
 
             if len(volumes) > 1:
-                _LOGGER.debug("Got %s volume controls, using the first one",
+                _LOGGER.debug(
-                              volumes)
+                    "Got %s volume controls, using the first one", volumes)
 
             volume = volumes[0]
             _LOGGER.debug("Current volume: %s", volume)

homeassistant/components/media_player/sonos.py

@@ -9,8 +9,8 @@ import datetime
 import functools as ft
 import logging
 import socket
-import urllib
 import threading
+import urllib
 
 import voluptuous as vol
 

homeassistant/components/media_player/soundtouch.py

@@ -5,19 +5,19 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.soundtouch/
 """
 import logging
-
 import re
+
 import voluptuous as vol
 
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK,
+    DOMAIN, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_TURN_OFF, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_STEP,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    SUPPORT_VOLUME_SET, SUPPORT_TURN_ON, SUPPORT_PLAY, MediaPlayerDevice,
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_STEP,
-    DOMAIN, PLATFORM_SCHEMA)
+    MediaPlayerDevice)
-from homeassistant.const import (CONF_HOST, CONF_NAME, STATE_OFF, CONF_PORT,
+from homeassistant.const import (
-                                 STATE_PAUSED, STATE_PLAYING,
+    CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF, STATE_PAUSED, STATE_PLAYING,
-                                 STATE_UNAVAILABLE)
+    STATE_UNAVAILABLE)
+import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['libsoundtouch==0.7.2']
 
@@ -43,17 +43,17 @@ SOUNDTOUCH_PLAY_EVERYWHERE = vol.Schema({
 
 SOUNDTOUCH_CREATE_ZONE_SCHEMA = vol.Schema({
     vol.Required('master'): cv.entity_id,
-    vol.Required('slaves'): cv.entity_ids
+    vol.Required('slaves'): cv.entity_ids,
 })
 
 SOUNDTOUCH_ADD_ZONE_SCHEMA = vol.Schema({
     vol.Required('master'): cv.entity_id,
-    vol.Required('slaves'): cv.entity_ids
+    vol.Required('slaves'): cv.entity_ids,
 })
 
 SOUNDTOUCH_REMOVE_ZONE_SCHEMA = vol.Schema({
     vol.Required('master'): cv.entity_id,
-    vol.Required('slaves'): cv.entity_ids
+    vol.Required('slaves'): cv.entity_ids,
 })
 
 DEFAULT_NAME = 'Bose Soundtouch'
@@ -67,7 +67,7 @@ SUPPORT_SOUNDTOUCH = SUPPORT_PAUSE | SUPPORT_VOLUME_STEP | \
 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_PORT, default=DEFAULT_PORT): cv.port,
 })
 
 

homeassistant/components/media_player/spotify.py

@@ -4,48 +4,54 @@ Support for interacting with Spotify Connect.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.spotify/
 """
-import logging
 from datetime import timedelta
+import logging
 
 import voluptuous as vol
 
-from homeassistant.core import callback
 from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.media_player import (
-    MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, SUPPORT_VOLUME_SET,
+    MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK,
-    SUPPORT_PLAY, SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA, SUPPORT_NEXT_TRACK,
+    SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_SHUFFLE_SET,
+    SUPPORT_SELECT_SOURCE, SUPPORT_SHUFFLE_SET, SUPPORT_VOLUME_SET,
-    PLATFORM_SCHEMA, MediaPlayerDevice)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_NAME, STATE_PLAYING, STATE_PAUSED, STATE_IDLE, STATE_UNKNOWN)
+    CONF_NAME, STATE_IDLE, STATE_PAUSED, STATE_PLAYING, STATE_UNKNOWN)
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['spotipy-homeassistant==2.4.4.dev1']
 
-DEPENDENCIES = ['http']
-
 _LOGGER = logging.getLogger(__name__)
 
+AUTH_CALLBACK_NAME = 'api:spotify'
+AUTH_CALLBACK_PATH = '/api/spotify'
+
+CONF_ALIASES = 'aliases'
+CONF_CACHE_PATH = 'cache_path'
+CONF_CLIENT_ID = 'client_id'
+CONF_CLIENT_SECRET = 'client_secret'
+
+CONFIGURATOR_DESCRIPTION = 'To link your Spotify account, ' \
+                           'click the link, login, and authorize:'
+CONFIGURATOR_LINK_NAME = 'Link Spotify account'
+CONFIGURATOR_SUBMIT_CAPTION = 'I authorized successfully'
+
+DEFAULT_CACHE_PATH = '.spotify-token-cache'
+DEFAULT_NAME = 'Spotify'
+DEPENDENCIES = ['http']
+DOMAIN = 'spotify'
+
+ICON = 'mdi:spotify'
+
+SCAN_INTERVAL = timedelta(seconds=30)
+
+SCOPE = 'user-read-playback-state user-modify-playback-state user-read-private'
+
 SUPPORT_SPOTIFY = SUPPORT_VOLUME_SET | SUPPORT_PAUSE | SUPPORT_PLAY |\
     SUPPORT_NEXT_TRACK | SUPPORT_PREVIOUS_TRACK | SUPPORT_SELECT_SOURCE |\
     SUPPORT_PLAY_MEDIA | SUPPORT_SHUFFLE_SET
 
-SCOPE = 'user-read-playback-state user-modify-playback-state user-read-private'
-DEFAULT_CACHE_PATH = '.spotify-token-cache'
-AUTH_CALLBACK_PATH = '/api/spotify'
-AUTH_CALLBACK_NAME = 'api:spotify'
-ICON = 'mdi:spotify'
-DEFAULT_NAME = 'Spotify'
-DOMAIN = 'spotify'
-CONF_ALIASES = 'aliases'
-CONF_CLIENT_ID = 'client_id'
-CONF_CLIENT_SECRET = 'client_secret'
-CONF_CACHE_PATH = 'cache_path'
-CONFIGURATOR_LINK_NAME = 'Link Spotify account'
-CONFIGURATOR_SUBMIT_CAPTION = 'I authorized successfully'
-CONFIGURATOR_DESCRIPTION = 'To link your Spotify account, ' \
-                           'click the link, login, and authorize:'
-
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_CLIENT_ID): cv.string,
     vol.Required(CONF_CLIENT_SECRET): cv.string,
@@ -54,8 +60,6 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_ALIASES, default={}): {cv.string: cv.string}
 })
 
-SCAN_INTERVAL = timedelta(seconds=30)
-
 
 def request_configuration(hass, config, add_entities, oauth):
     """Request Spotify authorization."""
@@ -71,6 +75,7 @@ def request_configuration(hass, config, add_entities, oauth):
 def setup_platform(hass, config, add_entities, discovery_info=None):
     """Set up the Spotify platform."""
     import spotipy.oauth2
+
     callback_url = '{}{}'.format(hass.config.api.base_url, AUTH_CALLBACK_PATH)
     cache = config.get(CONF_CACHE_PATH, hass.config.path(DEFAULT_CACHE_PATH))
     oauth = spotipy.oauth2.SpotifyOAuth(
@@ -88,8 +93,8 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
         configurator = hass.components.configurator
         configurator.request_done(hass.data.get(DOMAIN))
         del hass.data[DOMAIN]
-    player = SpotifyMediaPlayer(oauth, config.get(CONF_NAME, DEFAULT_NAME),
+    player = SpotifyMediaPlayer(
-                                config[CONF_ALIASES])
+        oauth, config.get(CONF_NAME, DEFAULT_NAME), config[CONF_ALIASES])
     add_entities([player], True)
 
 

homeassistant/components/media_player/squeezebox.py

@@ -4,26 +4,26 @@ Support for interfacing to the Logitech SqueezeBox API.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.squeezebox/
 """
-import logging
 import asyncio
-import urllib.parse
 import json
+import logging
+import urllib.parse
+
 import aiohttp
 import async_timeout
-
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    ATTR_MEDIA_ENQUEUE, SUPPORT_PLAY_MEDIA,
+    ATTR_MEDIA_ENQUEUE, DOMAIN, MEDIA_PLAYER_SCHEMA, MEDIA_TYPE_MUSIC,
-    MEDIA_TYPE_MUSIC, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, PLATFORM_SCHEMA,
+    PLATFORM_SCHEMA, SUPPORT_CLEAR_PLAYLIST, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
+    SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK,
-    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_PLAY, MediaPlayerDevice,
+    SUPPORT_SHUFFLE_SET, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
-    MEDIA_PLAYER_SCHEMA, DOMAIN, SUPPORT_SHUFFLE_SET, SUPPORT_CLEAR_PLAYLIST)
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, STATE_IDLE, STATE_OFF,
+    ATTR_COMMAND, CONF_HOST, CONF_PASSWORD, CONF_PORT, CONF_USERNAME,
-    STATE_PAUSED, STATE_PLAYING, STATE_UNKNOWN, CONF_PORT, ATTR_COMMAND)
+    STATE_IDLE, STATE_OFF, STATE_PAUSED, STATE_PLAYING, STATE_UNKNOWN)
-import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+import homeassistant.helpers.config_validation as cv
 from homeassistant.util.dt import utcnow
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/media_player/ue_smart_radio.py

@@ -6,31 +6,34 @@ https://home-assistant.io/components/media_player.ue_smart_radio/
 """
 
 import logging
-import voluptuous as vol
+
 import requests
+import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    MediaPlayerDevice, MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA,
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
-    SUPPORT_PLAY, SUPPORT_PAUSE, SUPPORT_STOP, SUPPORT_PREVIOUS_TRACK,
+    SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK, SUPPORT_STOP, SUPPORT_TURN_OFF,
-    SUPPORT_NEXT_TRACK, SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_VOLUME_SET,
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    SUPPORT_VOLUME_MUTE)
+    MediaPlayerDevice)
 from homeassistant.const import (
-    CONF_USERNAME, CONF_PASSWORD, STATE_OFF, STATE_IDLE, STATE_PLAYING,
+    CONF_PASSWORD, CONF_USERNAME, STATE_IDLE, STATE_OFF, STATE_PAUSED,
-    STATE_PAUSED)
+    STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
-ICON = "mdi:radio"
+ICON = 'mdi:radio'
-URL = "http://decibel.logitechmusic.com/jsonrpc.js"
+URL = 'http://decibel.logitechmusic.com/jsonrpc.js'
 
 SUPPORT_UE_SMART_RADIO = SUPPORT_PLAY | SUPPORT_PAUSE | SUPPORT_STOP | \
     SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | SUPPORT_TURN_ON | \
     SUPPORT_TURN_OFF | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE
 
-PLAYBACK_DICT = {"play": STATE_PLAYING,
+PLAYBACK_DICT = {
-                 "pause": STATE_PAUSED,
+    'play': STATE_PLAYING,
-                 "stop": STATE_IDLE}
+    'pause': STATE_PAUSED,
+    'stop': STATE_IDLE,
+}
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_USERNAME): cv.string,
@@ -41,10 +44,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 def send_request(payload, session):
     """Send request to radio."""
     try:
-        request = requests.post(URL,
+        request = requests.post(
-                                cookies={"sdi_squeezenetwork_session":
+            URL, cookies={"sdi_squeezenetwork_session": session},
-                                         session},
+            json=payload, timeout=5)
-                                json=payload, timeout=5)
     except requests.exceptions.Timeout:
         _LOGGER.error("Timed out when sending request")
     except requests.exceptions.ConnectionError:
@@ -58,9 +60,9 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
     email = config.get(CONF_USERNAME)
     password = config.get(CONF_PASSWORD)
 
-    session_request = requests.post("https://www.uesmartradio.com/user/login",
+    session_request = requests.post(
-                                    data={"email": email, "password":
+        "https://www.uesmartradio.com/user/login",
-                                          password})
+        data={"email": email, "password": password}, timeout=5)
     session = session_request.cookies["sdi_squeezenetwork_session"]
 
     player_request = send_request({"params": ["", ["serverstatus"]]}, session)

homeassistant/components/media_player/universal.py

@@ -4,12 +4,11 @@ Combination of multiple media players into one for a universal controller.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/media_player.universal/
 """
-import logging
 from copy import copy
+import logging
 
 import voluptuous as vol
 
-from homeassistant.core import callback
 from homeassistant.components.media_player import (
     ATTR_APP_ID, ATTR_APP_NAME, ATTR_INPUT_SOURCE, ATTR_INPUT_SOURCE_LIST,
     ATTR_MEDIA_ALBUM_ARTIST, ATTR_MEDIA_ALBUM_NAME, ATTR_MEDIA_ARTIST,
@@ -18,36 +17,35 @@ from homeassistant.components.media_player import (
     ATTR_MEDIA_POSITION, ATTR_MEDIA_POSITION_UPDATED_AT, ATTR_MEDIA_SEASON,
     ATTR_MEDIA_SEEK_POSITION, ATTR_MEDIA_SERIES_TITLE, ATTR_MEDIA_SHUFFLE,
     ATTR_MEDIA_TITLE, ATTR_MEDIA_TRACK, ATTR_MEDIA_VOLUME_LEVEL,
-    ATTR_MEDIA_VOLUME_MUTED, DOMAIN, MediaPlayerDevice, PLATFORM_SCHEMA,
+    ATTR_MEDIA_VOLUME_MUTED, DOMAIN, PLATFORM_SCHEMA, SERVICE_CLEAR_PLAYLIST,
-    SERVICE_CLEAR_PLAYLIST, SERVICE_PLAY_MEDIA, SERVICE_SELECT_SOURCE,
+    SERVICE_PLAY_MEDIA, SERVICE_SELECT_SOURCE, SUPPORT_CLEAR_PLAYLIST,
-    SUPPORT_CLEAR_PLAYLIST, SUPPORT_SELECT_SOURCE, SUPPORT_SHUFFLE_SET,
+    SUPPORT_SELECT_SOURCE, SUPPORT_SHUFFLE_SET, SUPPORT_TURN_OFF,
-    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    SUPPORT_VOLUME_STEP)
+    SUPPORT_VOLUME_STEP, MediaPlayerDevice)
 from homeassistant.const import (
     ATTR_ENTITY_ID, ATTR_ENTITY_PICTURE, ATTR_SUPPORTED_FEATURES, CONF_NAME,
-    CONF_STATE_TEMPLATE, SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_PAUSE,
+    CONF_STATE, CONF_STATE_TEMPLATE, SERVICE_MEDIA_NEXT_TRACK,
-    SERVICE_MEDIA_PLAY, SERVICE_MEDIA_PLAY_PAUSE, SERVICE_MEDIA_PREVIOUS_TRACK,
+    SERVICE_MEDIA_PAUSE, SERVICE_MEDIA_PLAY, SERVICE_MEDIA_PLAY_PAUSE,
-    SERVICE_MEDIA_SEEK, SERVICE_TURN_OFF, SERVICE_TURN_ON, SERVICE_VOLUME_DOWN,
+    SERVICE_MEDIA_PREVIOUS_TRACK, SERVICE_MEDIA_SEEK, SERVICE_MEDIA_STOP,
-    SERVICE_VOLUME_MUTE, SERVICE_VOLUME_SET, SERVICE_VOLUME_UP,
+    SERVICE_SHUFFLE_SET, SERVICE_TURN_OFF, SERVICE_TURN_ON,
-    SERVICE_SHUFFLE_SET, STATE_IDLE, STATE_OFF, STATE_ON, STATE_UNAVAILABLE,
+    SERVICE_VOLUME_DOWN, SERVICE_VOLUME_MUTE, SERVICE_VOLUME_SET,
-    SERVICE_MEDIA_STOP)
+    SERVICE_VOLUME_UP, STATE_IDLE, STATE_OFF, STATE_ON, STATE_UNAVAILABLE)
+from homeassistant.core import callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.service import async_call_from_config
 
+_LOGGER = logging.getLogger(__name__)
+
 ATTR_ACTIVE_CHILD = 'active_child'
+ATTR_DATA = 'data'
 
 CONF_ATTRS = 'attributes'
 CONF_CHILDREN = 'children'
 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, STATE_UNAVAILABLE]
-REQUIREMENTS = []
-_LOGGER = logging.getLogger(__name__)
 
 ATTRS_SCHEMA = vol.Schema({cv.slug: cv.string})
 CMD_SCHEMA = vol.Schema({cv.slug: cv.SERVICE_SCHEMA})

homeassistant/components/media_player/vizio.py

@@ -9,6 +9,7 @@ import logging
 
 import voluptuous as vol
 
+from homeassistant import util
 from homeassistant.components.media_player import (
     PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PREVIOUS_TRACK,
     SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
@@ -18,7 +19,6 @@ from homeassistant.const import (
     CONF_ACCESS_TOKEN, CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON,
     STATE_UNKNOWN)
 from homeassistant.helpers import config_validation as cv
-from homeassistant import util
 
 REQUIREMENTS = ['pyvizio==0.0.3']
 

homeassistant/components/media_player/vlc.py

@@ -9,12 +9,11 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_PAUSE, SUPPORT_PLAY_MEDIA, SUPPORT_STOP, SUPPORT_VOLUME_MUTE,
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_VOLUME_SET, SUPPORT_PLAY, MediaPlayerDevice, PLATFORM_SCHEMA,
+    SUPPORT_PLAY_MEDIA, SUPPORT_STOP, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
-    MEDIA_TYPE_MUSIC)
+    MediaPlayerDevice)
-
+from homeassistant.const import (
-from homeassistant.const import (CONF_NAME, STATE_IDLE, STATE_PAUSED,
+    CONF_NAME, STATE_IDLE, STATE_PAUSED, STATE_PLAYING)
-                                 STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
 import homeassistant.util.dt as dt_util
 
@@ -29,8 +28,8 @@ SUPPORT_VLC = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
     SUPPORT_PLAY_MEDIA | SUPPORT_PLAY | SUPPORT_STOP
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_NAME): cv.string,
     vol.Optional(CONF_ARGUMENTS, default=''): cv.string,
+    vol.Optional(CONF_NAME): cv.string,
 })
 
 

homeassistant/components/media_player/volumio.py

@@ -6,23 +6,24 @@ https://home-assistant.io/components/media_player.volumio/
 
 Volumio rest API: https://volumio.github.io/docs/API/REST_API.html
 """
+import asyncio
 from datetime import timedelta
 import logging
 import socket
-import asyncio
-import aiohttp
 
+import aiohttp
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK,
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_CLEAR_PLAYLIST,
-    SUPPORT_PLAY_MEDIA, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_STOP,
+    SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA,
-    SUPPORT_PLAY, MediaPlayerDevice, PLATFORM_SCHEMA, MEDIA_TYPE_MUSIC,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK, SUPPORT_SELECT_SOURCE, SUPPORT_STOP,
-    SUPPORT_VOLUME_STEP, SUPPORT_SELECT_SOURCE, SUPPORT_CLEAR_PLAYLIST)
+    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, SUPPORT_VOLUME_STEP,
+    MediaPlayerDevice)
 from homeassistant.const import (
-    STATE_PLAYING, STATE_PAUSED, STATE_IDLE, CONF_HOST, CONF_PORT, CONF_NAME)
+    CONF_HOST, CONF_NAME, CONF_PORT, STATE_IDLE, STATE_PAUSED, STATE_PLAYING)
-import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+import homeassistant.helpers.config_validation as cv
 from homeassistant.util import Throttle
 
 _CONFIGURING = {}

homeassistant/components/media_player/webostv.py

@@ -14,6 +14,7 @@ from typing import Dict  # noqa: F401
 
 import voluptuous as vol
 
+from homeassistant import util
 from homeassistant.components.media_player import (
     MEDIA_TYPE_CHANNEL, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
     SUPPORT_PLAY, SUPPORT_PLAY_MEDIA, SUPPORT_PREVIOUS_TRACK,
@@ -24,7 +25,6 @@ from homeassistant.const import (
     STATE_OFF, STATE_PAUSED, STATE_PLAYING, STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.script import Script
-from homeassistant import util
 
 REQUIREMENTS = ['pylgtv==0.1.7', 'websockets==3.2']
 
@@ -34,7 +34,7 @@ _LOGGER = logging.getLogger(__name__)
 CONF_SOURCES = 'sources'
 CONF_ON_ACTION = 'turn_on_action'
 
-DEFAULT_NAME = 'LG webOS Smart TV'
+DEFAULT_NAME = "LG webOS Smart TV"
 LIVETV_APP_ID = 'com.webos.app.livetv'
 
 WEBOSTV_CONFIG_FILE = 'webostv.conf'

homeassistant/components/media_player/xiaomi_tv.py

@@ -4,14 +4,15 @@ Add support for the Xiaomi TVs.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/xiaomi_tv/
 """
-
 import logging
+
 import voluptuous as vol
-import homeassistant.helpers.config_validation as cv
+
-from homeassistant.const import (CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON)
 from homeassistant.components.media_player import (
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF, MediaPlayerDevice, PLATFORM_SCHEMA,
+    PLATFORM_SCHEMA, SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_STEP,
-    SUPPORT_VOLUME_STEP)
+    MediaPlayerDevice)
+from homeassistant.const import CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON
+import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['pymitv==1.4.0']
 
@@ -41,8 +42,7 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
         # Check if there's a valid TV at the IP address.
         if not Discover().check_ip(host):
             _LOGGER.error(
-                "Could not find Xiaomi TV with specified IP: %s", host
+                "Could not find Xiaomi TV with specified IP: %s", host)
-            )
         else:
             # Register TV with Home Assistant.
             add_entities([XiaomiTV(host, name)])

homeassistant/components/media_player/yamaha.py

@@ -12,9 +12,9 @@ import voluptuous as vol
 from homeassistant.components.media_player import (
     DOMAIN, MEDIA_PLAYER_SCHEMA, MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA,
     SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY, SUPPORT_PLAY_MEDIA,
-    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_STOP,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOUND_MODE, SUPPORT_SELECT_SOURCE,
-    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    SUPPORT_STOP, SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE,
-    SUPPORT_SELECT_SOUND_MODE, MediaPlayerDevice)
+    SUPPORT_VOLUME_SET, MediaPlayerDevice)
 from homeassistant.const import (
     ATTR_ENTITY_ID, CONF_HOST, CONF_NAME, STATE_IDLE, STATE_OFF, STATE_ON,
     STATE_PLAYING)

homeassistant/components/media_player/yamaha_musiccast.py

@@ -1,28 +1,26 @@
-"""Example for configuration.yaml.
-
-media_player:
-  - platform: yamaha_musiccast
-    host: 192.168.xxx.xx
-    port: 5005
-
 """
+Support for Yamaha MusicCast Receivers.
 
+For more details about this platform, please refer to the documentation at
+https://www.home-assistant.io/components/media_player.yamaha_musiccast/
+"""
 import logging
+
 import voluptuous as vol
+
+from homeassistant.components.media_player import (
+    MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE,
+    SUPPORT_PLAY, SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_STOP,
+    SUPPORT_TURN_OFF, SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
+    MediaPlayerDevice)
+from homeassistant.const import (
+    CONF_HOST, CONF_PORT, STATE_IDLE, STATE_ON, STATE_PAUSED, STATE_PLAYING,
+    STATE_UNKNOWN)
 import homeassistant.helpers.config_validation as cv
 import homeassistant.util.dt as dt_util
 
-from homeassistant.const import (
+REQUIREMENTS = ['pymusiccast==0.1.6']
-    CONF_HOST, CONF_PORT,
+
-    STATE_UNKNOWN, STATE_ON, STATE_PLAYING, STATE_PAUSED, STATE_IDLE
-)
-from homeassistant.components.media_player import (
-    MediaPlayerDevice, MEDIA_TYPE_MUSIC, PLATFORM_SCHEMA,
-    SUPPORT_PAUSE, SUPPORT_PREVIOUS_TRACK, SUPPORT_NEXT_TRACK,
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF, SUPPORT_PLAY,
-    SUPPORT_VOLUME_SET, SUPPORT_VOLUME_MUTE,
-    SUPPORT_SELECT_SOURCE, SUPPORT_STOP
-)
 _LOGGER = logging.getLogger(__name__)
 
 SUPPORTED_FEATURES = (
@@ -36,8 +34,6 @@ SUPPORTED_FEATURES = (
 KNOWN_HOSTS_KEY = 'data_yamaha_musiccast'
 INTERVAL_SECONDS = 'interval_seconds'
 
-REQUIREMENTS = ['pymusiccast==0.1.6']
-
 DEFAULT_PORT = 5005
 DEFAULT_INTERVAL = 480
 
@@ -71,11 +67,11 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
         return
 
     if [item for item in known_hosts if item[0] == ipaddr]:
-        _LOGGER.warning("Host %s:%d already registered.", host, port)
+        _LOGGER.warning("Host %s:%d already registered", host, port)
         return
 
     if [item for item in known_hosts if item[1] == port]:
-        _LOGGER.warning("Port %s:%d already registered.", host, port)
+        _LOGGER.warning("Port %s:%d already registered", host, port)
         return
 
     reg_host = (ipaddr, port)
@@ -91,11 +87,9 @@ def setup_platform(hass, config, add_entities, discovery_info=None):
     if receiver:
         for zone in receiver.zones:
             _LOGGER.debug(
-                "receiver: %s / Port: %d / Zone: %s",
+                "Receiver: %s / Port: %d / Zone: %s", receiver, port, zone)
-                receiver, port, zone)
             add_entities(
-                [YamahaDevice(receiver, receiver.zones[zone])],
+                [YamahaDevice(receiver, receiver.zones[zone])], True)
-                True)
     else:
         known_hosts.remove(reg_host)
 

homeassistant/components/media_player/ziggo_mediabox_xl.py

@@ -10,10 +10,9 @@ import socket
 import voluptuous as vol
 
 from homeassistant.components.media_player import (
-    PLATFORM_SCHEMA, MediaPlayerDevice,
+    PLATFORM_SCHEMA, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, SUPPORT_PLAY,
-    SUPPORT_TURN_ON, SUPPORT_TURN_OFF,
+    SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE, SUPPORT_TURN_OFF,
-    SUPPORT_NEXT_TRACK, SUPPORT_PREVIOUS_TRACK, SUPPORT_SELECT_SOURCE,
+    SUPPORT_TURN_ON, MediaPlayerDevice)
-    SUPPORT_PLAY, SUPPORT_PAUSE)
 from homeassistant.const import (
     CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON, STATE_PAUSED, STATE_PLAYING)
 import homeassistant.helpers.config_validation as cv
@@ -169,6 +168,5 @@ class ZiggoMediaboxXLDevice(MediaPlayerDevice):
         if digits is None:
             return
 
-        self.send_keys(['NUM_{}'.format(digit)
+        self.send_keys(['NUM_{}'.format(digit) for digit in str(digits)])
-                        for digit in str(digits)])
         self._state = STATE_PLAYING