desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Set the input source.'
| def select_source(self, source):
| if (source in self._sources):
index = self._sources.index(source)
self._russ.set_source('1', self._zone_id, index)
|
'Return a list of available input sources.'
| @property
def source_list(self):
| return self._sources
|
'Initialize.'
| def __init__(self, config, add_devices, oauth):
| self.config = config
self.add_devices = add_devices
self.oauth = oauth
|
'Receive authorization token.'
| @callback
def get(self, request):
| hass = request.app['hass']
self.oauth.get_access_token(request.query['code'])
hass.async_add_job(setup_platform, hass, self.config, self.add_devices)
|
'Initialize.'
| def __init__(self, oauth, name, aliases):
| self._name = name
self._oauth = oauth
self._album = None
self._title = None
self._artist = None
self._uri = None
self._image_url = None
self._state = STATE_UNKNOWN
self._current_device = None
self._devices = {}
self._volume = None
self._shuffle = False
self._player = ... |
'Fetch a new spotify instance.'
| def refresh_spotify_instance(self):
| import spotipy
token_refreshed = False
need_token = ((self._token_info is None) or self._oauth.is_token_expired(self._token_info))
if need_token:
new_token = self._oauth.refresh_access_token(self._token_info['refresh_token'])
self._token_info = new_token
token_refreshed = True
... |
'Update state and attributes.'
| def update(self):
| self.refresh_spotify_instance()
player_devices = self._player.devices()
if (player_devices is not None):
devices = player_devices.get('devices')
if (devices is not None):
old_devices = self._devices
self._devices = {self._aliases.get(device.get('id'), device.get('name... |
'Set the volume level.'
| def set_volume_level(self, volume):
| self._player.volume(int((volume * 100)))
|
'Enable/Disable shuffle mode.'
| def set_shuffle(self, shuffle):
| self._player.shuffle(shuffle)
|
'Skip to next track.'
| def media_next_track(self):
| self._player.next_track()
|
'Skip to previous track.'
| def media_previous_track(self):
| self._player.previous_track()
|
'Start or resume playback.'
| def media_play(self):
| self._player.start_playback()
|
'Pause playback.'
| def media_pause(self):
| self._player.pause_playback()
|
'Select playback device.'
| def select_source(self, source):
| if self._devices:
self._player.transfer_playback(self._devices[source], (self._state == STATE_PLAYING))
|
'Play media.'
| def play_media(self, media_type, media_id, **kwargs):
| kwargs = {}
if (media_type == MEDIA_TYPE_MUSIC):
kwargs['uris'] = [media_id]
elif (media_type == MEDIA_TYPE_PLAYLIST):
kwargs['context_uri'] = media_id
else:
_LOGGER.error('media type %s is not supported', media_type)
return
if (not media_id.startswith(... |
'Return the name.'
| @property
def name(self):
| return self._name
|
'Return the icon.'
| @property
def icon(self):
| return ICON
|
'Return the playback state.'
| @property
def state(self):
| return self._state
|
'Return the device volume.'
| @property
def volume_level(self):
| return self._volume
|
'Shuffling state.'
| @property
def shuffle(self):
| return self._shuffle
|
'Return a list of source devices.'
| @property
def source_list(self):
| if self._devices:
return list(self._devices.keys())
|
'Return the current playback device.'
| @property
def source(self):
| return self._current_device
|
'Return the media URL.'
| @property
def media_content_id(self):
| return self._uri
|
'Return the media image URL.'
| @property
def media_image_url(self):
| return self._image_url
|
'Return the media artist.'
| @property
def media_artist(self):
| return self._artist
|
'Return the media album.'
| @property
def media_album_name(self):
| return self._album
|
'Return the media title.'
| @property
def media_title(self):
| return self._title
|
'Return the media player features that are supported.'
| @property
def supported_features(self):
| if ((self._user is not None) and (self._user['product'] == 'premium')):
return SUPPORT_SPOTIFY
return None
|
'Return the media type.'
| @property
def media_content_type(self):
| return MEDIA_TYPE_MUSIC
|
'Initialize the Yamaha Receiver.'
| def __init__(self, name, receiver, source_ignore, source_names):
| self._receiver = receiver
self._muted = False
self._volume = 0
self._pwstate = STATE_OFF
self._current_source = None
self._source_list = None
self._source_ignore = (source_ignore or [])
self._source_names = (source_names or {})
self._reverse_mapping = None
self._playback_support ... |
'Get the latest details from the device.'
| def update(self):
| self._play_status = self._receiver.play_status()
if self._receiver.on:
if (self._play_status is None):
self._pwstate = STATE_ON
elif self._play_status.playing:
self._pwstate = STATE_PLAYING
else:
self._pwstate = STATE_IDLE
else:
self._pwsta... |
'Build the source list.'
| def build_source_list(self):
| self._reverse_mapping = {alias: source for (source, alias) in self._source_names.items()}
self._source_list = sorted((self._source_names.get(source, source) for source in self._receiver.inputs() if (source not in self._source_ignore)))
|
'Return the name of the device.'
| @property
def name(self):
| name = self._name
if (self._zone != 'Main_Zone'):
name += (' ' + self._zone.replace('_', ' '))
return name
|
'Return the state of the device.'
| @property
def state(self):
| return self._pwstate
|
'Volume level of the media player (0..1).'
| @property
def volume_level(self):
| return self._volume
|
'Boolean if volume is currently muted.'
| @property
def is_volume_muted(self):
| return self._muted
|
'Return the current input source.'
| @property
def source(self):
| return self._current_source
|
'List of available input sources.'
| @property
def source_list(self):
| return self._source_list
|
'Flag media player features that are supported.'
| @property
def supported_features(self):
| supported_features = SUPPORT_YAMAHA
supports = self._playback_support
mapping = {'play': (SUPPORT_PLAY | SUPPORT_PLAY_MEDIA), 'pause': SUPPORT_PAUSE, 'stop': SUPPORT_STOP, 'skip_f': SUPPORT_NEXT_TRACK, 'skip_r': SUPPORT_PREVIOUS_TRACK}
for (attr, feature) in mapping.items():
if getattr(supports,... |
'Turn off media player.'
| def turn_off(self):
| self._receiver.on = False
|
'Set volume level, range 0..1.'
| def set_volume_level(self, volume):
| receiver_vol = (100 - (volume * 100))
negative_receiver_vol = (- receiver_vol)
self._receiver.volume = negative_receiver_vol
|
'Mute (true) or unmute (false) media player.'
| def mute_volume(self, mute):
| self._receiver.mute = mute
|
'Turn the media player on.'
| def turn_on(self):
| self._receiver.on = True
self._volume = ((self._receiver.volume / 100) + 1)
|
'Send play commmand.'
| def media_play(self):
| self._call_playback_function(self._receiver.play, 'play')
|
'Send pause command.'
| def media_pause(self):
| self._call_playback_function(self._receiver.pause, 'pause')
|
'Send stop command.'
| def media_stop(self):
| self._call_playback_function(self._receiver.stop, 'stop')
|
'Send previous track command.'
| def media_previous_track(self):
| self._call_playback_function(self._receiver.previous, 'previous track')
|
'Send next track command.'
| def media_next_track(self):
| self._call_playback_function(self._receiver.next, 'next track')
|
'Select input source.'
| def select_source(self, source):
| self._receiver.input = self._reverse_mapping.get(source, source)
|
'Play media from an ID.
This exposes a pass through for various input sources in the
Yamaha to direct play certain kinds of media. media_type is
treated as the input type that we are setting, and media id is
specific to it.'
| def play_media(self, media_type, media_id, **kwargs):
| if (media_type == 'NET RADIO'):
self._receiver.net_radio(media_id)
|
'Artist of current playing media.'
| @property
def media_artist(self):
| if (self._play_status is not None):
return self._play_status.artist
|
'Album of current playing media.'
| @property
def media_album_name(self):
| if (self._play_status is not None):
return self._play_status.album
|
'Content type of current playing media.'
| @property
def media_content_type(self):
| if self._is_playback_supported:
return MEDIA_TYPE_MUSIC
return None
|
'Artist of current playing media.'
| @property
def media_title(self):
| if (self._play_status is not None):
song = self._play_status.song
station = self._play_status.station
if (song and station):
return '{}: {}'.format(station, song)
return (song or station)
|
'Initialize the Pioneer device.'
| def __init__(self, name, host, port, timeout):
| self._name = name
self._host = host
self._port = port
self._timeout = timeout
self._pwstate = 'PWR1'
self._volume = 0
self._muted = False
self._selected_source = ''
self._source_name_to_number = {}
self._source_number_to_name = {}
|
'Execute `command` and return the response.'
| @classmethod
def telnet_request(cls, telnet, command, expected_prefix):
| try:
telnet.write((command.encode('ASCII') + '\r'))
except telnetlib.socket.timeout:
_LOGGER.debug('Pioneer command %s timed out', command)
return None
for _ in range(3):
result = telnet.read_until('\r\n', timeout=0.2).decode('ASCII').strip()
if result.sta... |
'Establish a telnet connection and sends command.'
| def telnet_command(self, command):
| try:
try:
telnet = telnetlib.Telnet(self._host, self._port, self._timeout)
except (ConnectionRefusedError, OSError):
_LOGGER.warning('Pioneer %s refused connection', self._name)
return
telnet.write((command.encode('ASCII') + '\r'))
telnet.... |
'Get the latest details from the device.'
| def update(self):
| try:
telnet = telnetlib.Telnet(self._host, self._port, self._timeout)
except (ConnectionRefusedError, OSError):
_LOGGER.warning('Pioneer %s refused connection', self._name)
return False
pwstate = self.telnet_request(telnet, '?P', 'PWR')
if pwstate:
self._pwstate ... |
'Return the name of the device.'
| @property
def name(self):
| return self._name
|
'Return the state of the device.'
| @property
def state(self):
| if (self._pwstate == 'PWR1'):
return STATE_OFF
if (self._pwstate == 'PWR0'):
return STATE_ON
return STATE_UNKNOWN
|
'Volume level of the media player (0..1).'
| @property
def volume_level(self):
| return self._volume
|
'Boolean if volume is currently muted.'
| @property
def is_volume_muted(self):
| return self._muted
|
'Flag media player features that are supported.'
| @property
def supported_features(self):
| return SUPPORT_PIONEER
|
'Return the current input source.'
| @property
def source(self):
| return self._selected_source
|
'List of available input sources.'
| @property
def source_list(self):
| return list(self._source_name_to_number.keys())
|
'Title of current playing media.'
| @property
def media_title(self):
| return self._selected_source
|
'Turn off media player.'
| def turn_off(self):
| self.telnet_command('PF')
|
'Volume up media player.'
| def volume_up(self):
| self.telnet_command('VU')
|
'Volume down media player.'
| def volume_down(self):
| self.telnet_command('VD')
|
'Set volume level, range 0..1.'
| def set_volume_level(self, volume):
| self.telnet_command((str(round((volume * MAX_VOLUME))).zfill(3) + 'VL'))
|
'Mute (true) or unmute (false) media player.'
| def mute_volume(self, mute):
| self.telnet_command(('MO' if mute else 'MF'))
|
'Turn the media player on.'
| def turn_on(self):
| self.telnet_command('PO')
|
'Select input source.'
| def select_source(self, source):
| self.telnet_command((self._source_name_to_number.get(source) + 'FN'))
|
'Initialize the demo device.'
| def __init__(self, name):
| self._name = name
self._player_state = STATE_PLAYING
self._volume_level = 1.0
self._volume_muted = False
self._shuffle = False
|
'Push an update after each command.'
| @property
def should_poll(self):
| return False
|
'Return the name of the media player.'
| @property
def name(self):
| return self._name
|
'Return the state of the player.'
| @property
def state(self):
| return self._player_state
|
'Return the volume level of the media player (0..1).'
| @property
def volume_level(self):
| return self._volume_level
|
'Return boolean if volume is currently muted.'
| @property
def is_volume_muted(self):
| return self._volume_muted
|
'Boolean if shuffling is enabled.'
| @property
def shuffle(self):
| return self._shuffle
|
'Turn the media player on.'
| def turn_on(self):
| self._player_state = STATE_PLAYING
self.schedule_update_ha_state()
|
'Turn the media player off.'
| def turn_off(self):
| self._player_state = STATE_OFF
self.schedule_update_ha_state()
|
'Mute the volume.'
| def mute_volume(self, mute):
| self._volume_muted = mute
self.schedule_update_ha_state()
|
'Set the volume level, range 0..1.'
| def set_volume_level(self, volume):
| self._volume_level = volume
self.schedule_update_ha_state()
|
'Send play command.'
| def media_play(self):
| self._player_state = STATE_PLAYING
self.schedule_update_ha_state()
|
'Send pause command.'
| def media_pause(self):
| self._player_state = STATE_PAUSED
self.schedule_update_ha_state()
|
'Enable/disable shuffle mode.'
| def set_shuffle(self, shuffle):
| self._shuffle = shuffle
self.schedule_update_ha_state()
|
'Initialize the demo device.'
| def __init__(self, name, youtube_id=None, media_title=None, duration=360):
| super().__init__(name)
self.youtube_id = youtube_id
self._media_title = media_title
self._duration = duration
self._progress = int((duration * 0.15))
self._progress_updated_at = dt_util.utcnow()
|
'Return the content ID of current playing media.'
| @property
def media_content_id(self):
| return self.youtube_id
|
'Return the content type of current playing media.'
| @property
def media_content_type(self):
| return MEDIA_TYPE_VIDEO
|
'Return the duration of current playing media in seconds.'
| @property
def media_duration(self):
| return self._duration
|
'Return the image url of current playing media.'
| @property
def media_image_url(self):
| return YOUTUBE_COVER_URL_FORMAT.format(self.youtube_id)
|
'Return the title of current playing media.'
| @property
def media_title(self):
| return self._media_title
|
'Return the current running application.'
| @property
def app_name(self):
| return 'YouTube'
|
'Flag media player features that are supported.'
| @property
def supported_features(self):
| return YOUTUBE_PLAYER_SUPPORT
|
'Position of current playing media in seconds.'
| @property
def media_position(self):
| if (self._progress is None):
return None
position = self._progress
if (self._player_state == STATE_PLAYING):
position += (dt_util.utcnow() - self._progress_updated_at).total_seconds()
return position
|
'When was the position of the current playing media valid.
Returns value from homeassistant.util.dt.utcnow().'
| @property
def media_position_updated_at(self):
| if (self._player_state == STATE_PLAYING):
return self._progress_updated_at
|
'Play a piece of media.'
| def play_media(self, media_type, media_id, **kwargs):
| self.youtube_id = media_id
self.schedule_update_ha_state()
|
'Send pause command.'
| def media_pause(self):
| self._progress = self.media_position
self._progress_updated_at = dt_util.utcnow()
super().media_pause()
|
'Initialize the demo device.'
| def __init__(self):
| super().__init__('Walkman')
self._cur_track = 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.