jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-21 20:27:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Changed to async/await (#13246)

Browse Source 
* Changed to async/await

* Hound fixes

* Lint fixes

* Changed sleep
This commit is contained in:
thrawnarn 2018-03-17 12:14:01 +01:00 committed by Pascal Vizeli
parent 66c6f9cdd6
commit 05676ba18b
1 changed files with 52 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
homeassistant/components/media_player/bluesound.py
View File

@ -131,8 +131,8 @@ def _add_player(hass, async_add_devices, host, port=None, name=None):
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, _init_player) hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, _init_player)
@asyncio.coroutine async def async_setup_platform(hass, config, async_add_devices,
def async_setup_platform(hass, config, async_add_devices, discovery_info=None): discovery_info=None):
"""Set up the Bluesound platforms.""" """Set up the Bluesound platforms."""
if DATA_BLUESOUND not in hass.data: if DATA_BLUESOUND not in hass.data:
hass.data[DATA_BLUESOUND] = [] hass.data[DATA_BLUESOUND] = []
@ -149,8 +149,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
hass, async_add_devices, host.get(CONF_HOST), hass, async_add_devices, host.get(CONF_HOST),
host.get(CONF_PORT), host.get(CONF_NAME)) host.get(CONF_PORT), host.get(CONF_NAME))
@asyncio.coroutine async def async_service_handler(service):
def async_service_handler(service):
"""Map services to method of Bluesound devices.""" """Map services to method of Bluesound devices."""
method = SERVICE_TO_METHOD.get(service.service) method = SERVICE_TO_METHOD.get(service.service)
if not method: if not method:
@ -166,7 +165,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
target_players = hass.data[DATA_BLUESOUND] target_players = hass.data[DATA_BLUESOUND]
for player in target_players: for player in target_players:
yield from getattr(player, method['method'])(**params) await getattr(player, method['method'])(**params)
for service in SERVICE_TO_METHOD: for service in SERVICE_TO_METHOD:
schema = SERVICE_TO_METHOD[service]['schema'] schema = SERVICE_TO_METHOD[service]['schema']
@ -211,13 +210,12 @@ class BluesoundPlayer(MediaPlayerDevice):
except ValueError: except ValueError:
return -1 return -1
@asyncio.coroutine async def force_update_sync_status(
def force_update_sync_status(
self, on_updated_cb=None, raise_timeout=False): self, on_updated_cb=None, raise_timeout=False):
"""Update the internal status.""" """Update the internal status."""
resp = None resp = None
try: try:
resp = yield from self.send_bluesound_command( resp = await self.send_bluesound_command(
'SyncStatus', raise_timeout, raise_timeout) 'SyncStatus', raise_timeout, raise_timeout)
except Exception: except Exception:
raise raise
@ -254,16 +252,15 @@ class BluesoundPlayer(MediaPlayerDevice):
on_updated_cb() on_updated_cb()
return True return True
@asyncio.coroutine async def _start_poll_command(self):
def _start_poll_command(self):
"""Loop which polls the status of the player.""" """Loop which polls the status of the player."""
try: try:
while True: while True:
yield from self.async_update_status() await self.async_update_status()
except (asyncio.TimeoutError, ClientError): except (asyncio.TimeoutError, ClientError):
_LOGGER.info("Node %s is offline, retrying later", self._name) _LOGGER.info("Node %s is offline, retrying later", self._name)
yield from asyncio.sleep( await asyncio.sleep(
NODE_OFFLINE_CHECK_TIMEOUT, loop=self._hass.loop) NODE_OFFLINE_CHECK_TIMEOUT, loop=self._hass.loop)
self.start_polling() self.start_polling()
@ -282,15 +279,14 @@ class BluesoundPlayer(MediaPlayerDevice):
"""Stop the polling task.""" """Stop the polling task."""
self._polling_task.cancel() self._polling_task.cancel()
@asyncio.coroutine async def async_init(self, triggered=None):
def async_init(self):
"""Initialize the player async.""" """Initialize the player async."""
try: try:
if self._retry_remove is not None: if self._retry_remove is not None:
self._retry_remove() self._retry_remove()
self._retry_remove = None self._retry_remove = None
yield from self.force_update_sync_status( await self.force_update_sync_status(
self._init_callback, True) self._init_callback, True)
except (asyncio.TimeoutError, ClientError): except (asyncio.TimeoutError, ClientError):
_LOGGER.info("Node %s is offline, retrying later", self.host) _LOGGER.info("Node %s is offline, retrying later", self.host)
@ -301,20 +297,18 @@ class BluesoundPlayer(MediaPlayerDevice):
self.host) self.host)
raise raise
@asyncio.coroutine async def async_update(self):
def async_update(self):
"""Update internal status of the entity.""" """Update internal status of the entity."""
if not self._is_online: if not self._is_online:
return return
yield from self.async_update_sync_status() await self.async_update_sync_status()
yield from self.async_update_presets() await self.async_update_presets()
yield from self.async_update_captures() await self.async_update_captures()
yield from self.async_update_services() await self.async_update_services()
@asyncio.coroutine async def send_bluesound_command(self, method, raise_timeout=False,
def send_bluesound_command(self, method, raise_timeout=False, allow_offline=False):
allow_offline=False):
"""Send command to the player.""" """Send command to the player."""
import xmltodict import xmltodict
@ -330,10 +324,10 @@ class BluesoundPlayer(MediaPlayerDevice):
try: try:
websession = async_get_clientsession(self._hass) websession = async_get_clientsession(self._hass)
with async_timeout.timeout(10, loop=self._hass.loop): with async_timeout.timeout(10, loop=self._hass.loop):
response = yield from websession.get(url) response = await websession.get(url)
if response.status == 200: if response.status == 200:
result = yield from response.text() result = await response.text()
if len(result) < 1: if len(result) < 1:
data = None data = None
else: else:
@ -352,8 +346,7 @@ class BluesoundPlayer(MediaPlayerDevice):
return data return data
@asyncio.coroutine async def async_update_status(self):
def async_update_status(self):
"""Use the poll session to always get the status of the player.""" """Use the poll session to always get the status of the player."""
import xmltodict import xmltodict
response = None response = None
@ -372,7 +365,7 @@ class BluesoundPlayer(MediaPlayerDevice):
try: try:
with async_timeout.timeout(125, loop=self._hass.loop): with async_timeout.timeout(125, loop=self._hass.loop):
response = yield from self._polling_session.get( response = await self._polling_session.get(
url, url,
headers={CONNECTION: KEEP_ALIVE}) headers={CONNECTION: KEEP_ALIVE})
@ -380,7 +373,7 @@ class BluesoundPlayer(MediaPlayerDevice):
_LOGGER.error("Error %s on %s. Trying one more time.", _LOGGER.error("Error %s on %s. Trying one more time.",
response.status, url) response.status, url)
else: else:
result = yield from response.text() result = await response.text()
self._is_online = True self._is_online = True
self._last_status_update = dt_util.utcnow() self._last_status_update = dt_util.utcnow()
self._status = xmltodict.parse(result)['status'].copy() self._status = xmltodict.parse(result)['status'].copy()
@ -392,8 +385,8 @@ class BluesoundPlayer(MediaPlayerDevice):
self._group_name = group_name self._group_name = group_name
# the sleep is needed to make sure that the # the sleep is needed to make sure that the
# devices is synced # devices is synced
yield from asyncio.sleep(1, loop=self._hass.loop) await asyncio.sleep(1, loop=self._hass.loop)
yield from self.async_trigger_sync_on_all() await self.async_trigger_sync_on_all()
elif self.is_grouped: elif self.is_grouped:
# when player is grouped we need to fetch volume from # when player is grouped we need to fetch volume from
# sync_status. We will force an update if the player is # sync_status. We will force an update if the player is
@ -402,7 +395,7 @@ class BluesoundPlayer(MediaPlayerDevice):
# the device is playing. This would solve alot of # the device is playing. This would solve alot of
# problems. This change will be done when the # problems. This change will be done when the
# communication is moved to a separate library # communication is moved to a separate library
yield from self.force_update_sync_status() await self.force_update_sync_status()
self.async_schedule_update_ha_state() self.async_schedule_update_ha_state()
@ -415,13 +408,12 @@ class BluesoundPlayer(MediaPlayerDevice):
self._name) self._name)
raise raise
@asyncio.coroutine async def async_trigger_sync_on_all(self):
def async_trigger_sync_on_all(self):
"""Trigger sync status update on all devices.""" """Trigger sync status update on all devices."""
_LOGGER.debug("Trigger sync status on all devices") _LOGGER.debug("Trigger sync status on all devices")
for player in self._hass.data[DATA_BLUESOUND]: for player in self._hass.data[DATA_BLUESOUND]:
yield from player.force_update_sync_status() await player.force_update_sync_status()
@Throttle(SYNC_STATUS_INTERVAL) @Throttle(SYNC_STATUS_INTERVAL)
async def async_update_sync_status(self, on_updated_cb=None, async def async_update_sync_status(self, on_updated_cb=None,
@ -788,8 +780,7 @@ class BluesoundPlayer(MediaPlayerDevice):
"""Return true if shuffle is active.""" """Return true if shuffle is active."""
return True if self._status.get('shuffle', '0') == '1' else False return True if self._status.get('shuffle', '0') == '1' else False
@asyncio.coroutine async def async_join(self, master):
def async_join(self, master):
"""Join the player to a group.""" """Join the player to a group."""
master_device = [device for device in self.hass.data[DATA_BLUESOUND] master_device = [device for device in self.hass.data[DATA_BLUESOUND]
if device.entity_id == master] if device.entity_id == master]
@ -798,37 +789,33 @@ class BluesoundPlayer(MediaPlayerDevice):
_LOGGER.debug("Trying to join player: %s to master: %s", _LOGGER.debug("Trying to join player: %s to master: %s",
self.host, master_device[0].host) self.host, master_device[0].host)
yield from master_device[0].async_add_slave(self) await master_device[0].async_add_slave(self)
else: else:
_LOGGER.error("Master not found %s", master_device) _LOGGER.error("Master not found %s", master_device)
@asyncio.coroutine async def async_unjoin(self):
def async_unjoin(self):
"""Unjoin the player from a group.""" """Unjoin the player from a group."""
if self._master is None: if self._master is None:
return return
_LOGGER.debug("Trying to unjoin player: %s", self.host) _LOGGER.debug("Trying to unjoin player: %s", self.host)
yield from self._master.async_remove_slave(self) await self._master.async_remove_slave(self)
@asyncio.coroutine async def async_add_slave(self, slave_device):
def async_add_slave(self, slave_device):
"""Add slave to master.""" """Add slave to master."""
return self.send_bluesound_command('/AddSlave?slave={}&port={}' return self.send_bluesound_command('/AddSlave?slave={}&port={}'
.format(slave_device.host, .format(slave_device.host,
slave_device.port)) slave_device.port))
@asyncio.coroutine async def async_remove_slave(self, slave_device):
def async_remove_slave(self, slave_device):
"""Remove slave to master.""" """Remove slave to master."""
return self.send_bluesound_command('/RemoveSlave?slave={}&port={}' return self.send_bluesound_command('/RemoveSlave?slave={}&port={}'
.format(slave_device.host, .format(slave_device.host,
slave_device.port)) slave_device.port))
@asyncio.coroutine async def async_increase_timer(self):
def async_increase_timer(self):
"""Increase sleep time on player.""" """Increase sleep time on player."""
sleep_time = yield from self.send_bluesound_command('/Sleep') sleep_time = await self.send_bluesound_command('/Sleep')
if sleep_time is None: if sleep_time is None:
_LOGGER.error('Error while increasing sleep time on player: %s', _LOGGER.error('Error while increasing sleep time on player: %s',
self.host) self.host)
@ -836,21 +823,18 @@ class BluesoundPlayer(MediaPlayerDevice):
return int(sleep_time.get('sleep', '0')) return int(sleep_time.get('sleep', '0'))
@asyncio.coroutine async def async_clear_timer(self):
def async_clear_timer(self):
"""Clear sleep timer on player.""" """Clear sleep timer on player."""
sleep = 1 sleep = 1
while sleep > 0: while sleep > 0:
sleep = yield from self.async_increase_timer() sleep = await self.async_increase_timer()
@asyncio.coroutine async def async_set_shuffle(self, shuffle):
def async_set_shuffle(self, shuffle):
"""Enable or disable shuffle mode.""" """Enable or disable shuffle mode."""
return self.send_bluesound_command('/Shuffle?state={}' return self.send_bluesound_command('/Shuffle?state={}'
.format('1' if shuffle else '0')) .format('1' if shuffle else '0'))
@asyncio.coroutine async def async_select_source(self, source):
def async_select_source(self, source):
"""Select input source.""" """Select input source."""
if self.is_grouped and not self.is_master: if self.is_grouped and not self.is_master:
return return
@ -874,16 +858,14 @@ class BluesoundPlayer(MediaPlayerDevice):
return self.send_bluesound_command(url) return self.send_bluesound_command(url)
@asyncio.coroutine async def async_clear_playlist(self):
def async_clear_playlist(self):
"""Clear players playlist.""" """Clear players playlist."""
if self.is_grouped and not self.is_master: if self.is_grouped and not self.is_master:
return return
return self.send_bluesound_command('Clear') return self.send_bluesound_command('Clear')
@asyncio.coroutine async def async_media_next_track(self):
def async_media_next_track(self):
"""Send media_next command to media player.""" """Send media_next command to media player."""
if self.is_grouped and not self.is_master: if self.is_grouped and not self.is_master:
return return
@ -897,8 +879,7 @@ class BluesoundPlayer(MediaPlayerDevice):
return self.send_bluesound_command(cmd) return self.send_bluesound_command(cmd)
@asyncio.coroutine async def async_media_previous_track(self):
def async_media_previous_track(self):
"""Send media_previous command to media player.""" """Send media_previous command to media player."""
if self.is_grouped and not self.is_master: if self.is_grouped and not self.is_master:
return return
@ -912,40 +893,35 @@ class BluesoundPlayer(MediaPlayerDevice):
return self.send_bluesound_command(cmd) return self.send_bluesound_command(cmd)
@asyncio.coroutine async def async_media_play(self):
def async_media_play(self):
"""Send media_play command to media player.""" """Send media_play command to media player."""
if self.is_grouped and not self.is_master: if self.is_grouped and not self.is_master:
return return
return self.send_bluesound_command('Play') return self.send_bluesound_command('Play')
@asyncio.coroutine async def async_media_pause(self):
def async_media_pause(self):
"""Send media_pause command to media player.""" """Send media_pause command to media player."""
if self.is_grouped and not self.is_master: if self.is_grouped and not self.is_master:
return return
return self.send_bluesound_command('Pause') return self.send_bluesound_command('Pause')
@asyncio.coroutine async def async_media_stop(self):
def async_media_stop(self):
"""Send stop command.""" """Send stop command."""
if self.is_grouped and not self.is_master: if self.is_grouped and not self.is_master:
return return
return self.send_bluesound_command('Pause') return self.send_bluesound_command('Pause')
@asyncio.coroutine async def async_media_seek(self, position):
def async_media_seek(self, position):
"""Send media_seek command to media player.""" """Send media_seek command to media player."""
if self.is_grouped and not self.is_master: if self.is_grouped and not self.is_master:
return return
return self.send_bluesound_command('Play?seek=' + str(float(position))) return self.send_bluesound_command('Play?seek=' + str(float(position)))
@asyncio.coroutine async def async_play_media(self, media_type, media_id, **kwargs):
def async_play_media(self, media_type, media_id, **kwargs):
""" """
Send the play_media command to the media player. Send the play_media command to the media player.
@ -961,24 +937,21 @@ class BluesoundPlayer(MediaPlayerDevice):
return self.send_bluesound_command(url) return self.send_bluesound_command(url)
@asyncio.coroutine async def async_volume_up(self):
def async_volume_up(self):
"""Volume up the media player.""" """Volume up the media player."""
current_vol = self.volume_level current_vol = self.volume_level
if not current_vol or current_vol < 0: if not current_vol or current_vol < 0:
return return
return self.async_set_volume_level(((current_vol*100)+1)/100) return self.async_set_volume_level(((current_vol*100)+1)/100)
@asyncio.coroutine async def async_volume_down(self):
def async_volume_down(self):
"""Volume down the media player.""" """Volume down the media player."""
current_vol = self.volume_level current_vol = self.volume_level
if not current_vol or current_vol < 0: if not current_vol or current_vol < 0:
return return
return self.async_set_volume_level(((current_vol*100)-1)/100) return self.async_set_volume_level(((current_vol*100)-1)/100)
@asyncio.coroutine async def async_set_volume_level(self, volume):
def async_set_volume_level(self, volume):
"""Send volume_up command to media player.""" """Send volume_up command to media player."""
if volume < 0: if volume < 0:
volume = 0 volume = 0
@ -987,8 +960,7 @@ class BluesoundPlayer(MediaPlayerDevice):
return self.send_bluesound_command( return self.send_bluesound_command(
'Volume?level=' + str(float(volume) * 100)) 'Volume?level=' + str(float(volume) * 100))
@asyncio.coroutine async def async_mute_volume(self, mute):
def async_mute_volume(self, mute):
"""Send mute command to media player.""" """Send mute command to media player."""
if mute: if mute:
volume = self.volume_level volume = self.volume_level