desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Duration of current playing media in seconds.'
| @property
def media_duration(self):
| return None
|
'Image url of current playing media.'
| @property
def media_image_url(self):
| if (self._current_source in self._receiver.playing_func_list):
return self._media_image_url
return None
|
'Title of current playing media.'
| @property
def media_title(self):
| if (self._current_source not in self._receiver.playing_func_list):
return self._current_source
elif (self._title is not None):
return self._title
return self._frequency
|
'Artist of current playing media, music track only.'
| @property
def media_artist(self):
| if (self._artist is not None):
return self._artist
return self._band
|
'Album name of current playing media, music track only.'
| @property
def media_album_name(self):
| if (self._album is not None):
return self._album
return self._station
|
'Album artist of current playing media, music track only.'
| @property
def media_album_artist(self):
| return None
|
'Track number of current playing media, music track only.'
| @property
def media_track(self):
| return None
|
'Title of series of current playing media, TV show only.'
| @property
def media_series_title(self):
| return None
|
'Season of current playing media, TV show only.'
| @property
def media_season(self):
| return None
|
'Episode of current playing media, TV show only.'
| @property
def media_episode(self):
| return None
|
'Simulate play pause media player.'
| def media_play_pause(self):
| return self._receiver.toggle_play_pause()
|
'Send previous track command.'
| def media_previous_track(self):
| return self._receiver.previous_track()
|
'Send next track command.'
| def media_next_track(self):
| return self._receiver.next_track()
|
'Select input source.'
| def select_source(self, source):
| return self._receiver.set_input_func(source)
|
'Turn on media player.'
| def turn_on(self):
| if self._receiver.power_on():
self._state = STATE_ON
|
'Turn off media player.'
| def turn_off(self):
| if self._receiver.power_off():
self._state = STATE_OFF
|
'Volume up the media player.'
| def volume_up(self):
| return self._receiver.volume_up()
|
'Volume down media player.'
| def volume_down(self):
| return self._receiver.volume_down()
|
'Set volume level, range 0..1.'
| def set_volume_level(self, volume):
| volume_denon = float(((volume * 100) - 80))
if (volume_denon > 18):
volume_denon = float(18)
try:
if self._receiver.set_volume(volume_denon):
self._volume = volume_denon
except ValueError:
pass
|
'Send mute command.'
| def mute_volume(self, mute):
| return self._receiver.mute(mute)
|
'Initialize the LG TV device.'
| def __init__(self, client, name):
| self._client = client
self._name = name
self._muted = False
self._playing = True
self._volume = 0
self._channel_name = ''
self._program_name = ''
self._state = STATE_UNKNOWN
self._sources = {}
self._source_names = []
|
'Send remote control commands to the TV.'
| def send_command(self, command):
| from pylgnetcast import LgNetCastError
try:
with self._client as client:
client.send_command(command)
except (LgNetCastError, RequestException):
self._state = STATE_OFF
|
'Retrieve the latest data from the LG TV.'
| @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS)
def update(self):
| from pylgnetcast import LgNetCastError
try:
with self._client as client:
self._state = STATE_PLAYING
volume_info = client.query_data('volume_info')
if volume_info:
volume_info = volume_info[0]
self._volume = float(volume_info.find('leve... |
'Return the name of the device.'
| @property
def name(self):
| return self._name
|
'Return the state of the device.'
| @property
def state(self):
| return self._state
|
'Boolean if volume is currently muted.'
| @property
def is_volume_muted(self):
| return self._muted
|
'Volume level of the media player (0..1).'
| @property
def volume_level(self):
| return (self._volume / 100.0)
|
'Return the current input source.'
| @property
def source(self):
| return self._channel_name
|
'List of available input sources.'
| @property
def source_list(self):
| return self._source_names
|
'Content type of current playing media.'
| @property
def media_content_type(self):
| return MEDIA_TYPE_CHANNEL
|
'Channel currently playing.'
| @property
def media_channel(self):
| return self._channel_name
|
'Title of current playing media.'
| @property
def media_title(self):
| return self._program_name
|
'Flag media player features that are supported.'
| @property
def supported_features(self):
| return SUPPORT_LGTV
|
'URL for obtaining a screen capture.'
| @property
def media_image_url(self):
| return (self._client.url + 'data?target=screen_image')
|
'Turn off media player.'
| def turn_off(self):
| self.send_command(1)
|
'Volume up the media player.'
| def volume_up(self):
| self.send_command(24)
|
'Volume down media player.'
| def volume_down(self):
| self.send_command(25)
|
'Send mute command.'
| def mute_volume(self, mute):
| self.send_command(26)
|
'Select input source.'
| def select_source(self, source):
| self._client.change_channel(self._sources[source])
|
'Simulate play pause media player.'
| def media_play_pause(self):
| if self._playing:
self.media_pause()
else:
self.media_play()
|
'Send play command.'
| def media_play(self):
| self._playing = True
self._state = STATE_PLAYING
self.send_command(33)
|
'Send media pause command to media player.'
| def media_pause(self):
| self._playing = False
self._state = STATE_PAUSED
self.send_command(34)
|
'Send next track command.'
| def media_next_track(self):
| self.send_command(36)
|
'Send the previous track command.'
| def media_previous_track(self):
| self.send_command(37)
|
'Initialize the Samsung device.'
| def __init__(self, host, port, name, timeout, mac):
| from samsungctl import exceptions
from samsungctl import Remote
from wakeonlan import wol
self._exceptions_class = exceptions
self._remote_class = Remote
self._name = name
self._mac = mac
self._wol = wol
self._muted = False
self._playing = True
self._state = STATE_UNKNOWN
... |
'Retrieve the latest data.'
| def update(self):
| return self.send_key('KEY')
|
'Create or return a remote control instance.'
| def get_remote(self):
| if (self._remote is None):
self._remote = self._remote_class(self._config)
return self._remote
|
'Send a key to the tv and handles exceptions.'
| def send_key(self, key):
| try:
self.get_remote().control(key)
self._state = STATE_ON
except (self._exceptions_class.UnhandledResponse, self._exceptions_class.AccessDenied, BrokenPipeError):
self._state = STATE_ON
self._remote = None
return False
except (self._exceptions_class.ConnectionClosed,... |
'Return the name of the device.'
| @property
def name(self):
| return self._name
|
'Return the state of the device.'
| @property
def state(self):
| return self._state
|
'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):
| if self._mac:
return (SUPPORT_SAMSUNGTV | SUPPORT_TURN_ON)
return SUPPORT_SAMSUNGTV
|
'Turn off media player.'
| def turn_off(self):
| if (self._config['method'] == 'websocket'):
self.send_key('KEY_POWER')
else:
self.send_key('KEY_POWEROFF')
self.get_remote().close()
|
'Volume up the media player.'
| def volume_up(self):
| self.send_key('KEY_VOLUP')
|
'Volume down media player.'
| def volume_down(self):
| self.send_key('KEY_VOLDOWN')
|
'Send mute command.'
| def mute_volume(self, mute):
| self.send_key('KEY_MUTE')
|
'Simulate play pause media player.'
| def media_play_pause(self):
| if self._playing:
self.media_pause()
else:
self.media_play()
|
'Send play command.'
| def media_play(self):
| self._playing = True
self.send_key('KEY_PLAY')
|
'Send media pause command to media player.'
| def media_pause(self):
| self._playing = False
self.send_key('KEY_PAUSE')
|
'Send next track command.'
| def media_next_track(self):
| self.send_key('KEY_FF')
|
'Send the previous track command.'
| def media_previous_track(self):
| self.send_key('KEY_REWIND')
|
'Turn the media player on.'
| def turn_on(self):
| if self._mac:
self._wol.send_magic_packet(self._mac)
else:
self.send_key('KEY_POWERON')
|
'Initialise the Openhome device.'
| def __init__(self, hass, device):
| self.hass = hass
self._device = device
self._track_information = {}
self._in_standby = None
self._transport_state = None
self._volume_level = None
self._volume_muted = None
self._supported_features = SUPPORT_OPENHOME
self._source_names = list()
self._source_index = {}
self._s... |
'Update state of device.'
| def update(self):
| self._in_standby = self._device.IsInStandby()
self._transport_state = self._device.TransportState()
self._track_information = self._device.TrackInfo()
self._volume_level = self._device.VolumeLevel()
self._volume_muted = self._device.IsMuted()
self._source = self._device.Source()
self._name =... |
'Bring device out of standby.'
| def turn_on(self):
| self._device.SetStandby(False)
|
'Put device in standby.'
| def turn_off(self):
| self._device.SetStandby(True)
|
'Send pause command.'
| def media_pause(self):
| self._device.Pause()
|
'Send stop command.'
| def media_stop(self):
| self._device.Stop()
|
'Send play commmand.'
| def media_play(self):
| self._device.Play()
|
'Send next track command.'
| def media_next_track(self):
| self._device.Skip(1)
|
'Send previous track command.'
| def media_previous_track(self):
| self._device.Skip((-1))
|
'Select input source.'
| def select_source(self, source):
| self._device.SetSource(self._source_index[source])
|
'Return the name of the device.'
| @property
def name(self):
| return self._name
|
'Flag of features commands that are supported.'
| @property
def supported_features(self):
| return self._supported_features
|
'Return the polling state.'
| @property
def should_poll(self):
| return True
|
'Return an unique ID.'
| @property
def unique_id(self):
| return self._device.Uuid()
|
'Return the state of the device.'
| @property
def state(self):
| return self._state
|
'List of available input sources.'
| @property
def source_list(self):
| return self._source_names
|
'Image url of current playing media.'
| @property
def media_image_url(self):
| return self._track_information.get('albumArtwork')
|
'Artist of current playing media, music track only.'
| @property
def media_artist(self):
| artists = self._track_information.get('artist')
if artists:
return artists[0]
|
'Album name of current playing media, music track only.'
| @property
def media_album_name(self):
| return self._track_information.get('albumTitle')
|
'Title of current playing media.'
| @property
def media_title(self):
| return self._track_information.get('title')
|
'Name of the current input source.'
| @property
def source(self):
| return self._source.get('name')
|
'Volume level of the media player (0..1).'
| @property
def volume_level(self):
| return (self._volume_level / 100.0)
|
'Return true if volume is muted.'
| @property
def is_volume_muted(self):
| return self._volume_muted
|
'Volume up media player.'
| def volume_up(self):
| self._device.IncreaseVolume()
|
'Volume down media player.'
| def volume_down(self):
| self._device.DecreaseVolume()
|
'Set volume level, range 0..1.'
| def set_volume_level(self, volume):
| self._device.SetVolumeLevel(int((volume * 100)))
|
'Mute (true) or unmute (false) media player.'
| def mute_volume(self, mute):
| self._device.SetMute(mute)
|
'Initialise the Russound RNET device.'
| def __init__(self, hass, russ, sources, zone_id, extra):
| self._name = extra['name']
self._russ = russ
self._sources = sources
self._zone_id = zone_id
self._state = None
self._volume = None
self._source = None
|
'Retrieve latest state.'
| def update(self):
| if (self._russ.get_power('1', self._zone_id) == 0):
self._state = STATE_OFF
else:
self._state = STATE_ON
self._volume = (self._russ.get_volume('1', self._zone_id) / 100.0)
index = self._russ.get_source('1', self._zone_id)
try:
self._source = self._sources[index]
except In... |
'Return the name of the zone.'
| @property
def name(self):
| return self._name
|
'Return the state of the device.'
| @property
def state(self):
| return self._state
|
'Flag media player features that are supported.'
| @property
def supported_features(self):
| return SUPPORT_RUSSOUND
|
'Get the currently selected source.'
| @property
def source(self):
| return self._source
|
'Volume level of the media player (0..1).
Value is returned based on a range (0..100).
Therefore float divide by 100 to get to the required range.'
| @property
def volume_level(self):
| return self._volume
|
'Set volume level. Volume has a range (0..1).
Translate this to a range of (0..100) as expected expected
by _russ.set_volume()'
| def set_volume_level(self, volume):
| self._russ.set_volume('1', self._zone_id, (volume * 100))
|
'Turn the media player on.'
| def turn_on(self):
| self._russ.set_power('1', self._zone_id, '1')
|
'Turn off media player.'
| def turn_off(self):
| self._russ.set_power('1', self._zone_id, '0')
|
'Send mute command.'
| def mute_volume(self, mute):
| self._russ.toggle_mute('1', self._zone_id)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.