desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Content type of current playing media.'
| @property
def media_content_type(self):
| return MEDIA_TYPE_MUSIC
|
'Return the state of the device.'
| @property
def state(self):
| return self._status
|
'Title of current playing media.'
| @property
def media_title(self):
| return self._title
|
'Artist of current playing media (Music track only).'
| @property
def media_artist(self):
| return self._artist
|
'Image url of current playing media.'
| @property
def media_image_url(self):
| return self._albumart
|
'Time in seconds of current seek position.'
| @property
def media_seek_position(self):
| return self._seek_position
|
'Time in seconds of current song duration.'
| @property
def media_duration(self):
| return self._duration
|
'Volume level of the media player (0..1).'
| @property
def volume_level(self):
| return self._volume
|
'Return the name of the device.'
| @property
def name(self):
| return self._name
|
'Flag media player features that are supported.'
| @property
def supported_features(self):
| return SUPPORT_GPMDP
|
'Send media_next command to media player.'
| def media_next_track(self):
| self.send_gpmdp_msg('playback', 'forward', False)
|
'Send media_previous command to media player.'
| def media_previous_track(self):
| self.send_gpmdp_msg('playback', 'rewind', False)
|
'Send media_play command to media player.'
| def media_play(self):
| self.send_gpmdp_msg('playback', 'playPause', False)
self._status = STATE_PLAYING
self.schedule_update_ha_state()
|
'Send media_pause command to media player.'
| def media_pause(self):
| self.send_gpmdp_msg('playback', 'playPause', False)
self._status = STATE_PAUSED
self.schedule_update_ha_state()
|
'Send media_seek command to media player.'
| def media_seek(self, position):
| websocket = self.get_ws()
if (websocket is None):
return
websocket.send(json.dumps({'namespace': 'playback', 'method': 'setCurrentTime', 'arguments': [(position * 1000)]}))
self.schedule_update_ha_state()
|
'Send volume_up command to media player.'
| def volume_up(self):
| websocket = self.get_ws()
if (websocket is None):
return
websocket.send('{"namespace": "volume", "method": "increaseVolume"}')
self.schedule_update_ha_state()
|
'Send volume_down command to media player.'
| def volume_down(self):
| websocket = self.get_ws()
if (websocket is None):
return
websocket.send('{"namespace": "volume", "method": "decreaseVolume"}')
self.schedule_update_ha_state()
|
'Set volume on media player, range(0..1).'
| def set_volume_level(self, volume):
| websocket = self.get_ws()
if (websocket is None):
return
websocket.send(json.dumps({'namespace': 'volume', 'method': 'setVolume', 'arguments': [(volume * 100)]}))
self.schedule_update_ha_state()
|
'Initialize the Panasonic device.'
| def __init__(self, mac, name, remote):
| from wakeonlan import wol
self._wol = wol
self._mac = mac
self._name = name
self._muted = False
self._playing = True
self._state = STATE_UNKNOWN
self._remote = remote
self._volume = 0
|
'Retrieve the latest data.'
| def update(self):
| try:
self._muted = self._remote.get_mute()
self._volume = (self._remote.get_volume() / 100)
self._state = STATE_ON
except OSError:
self._state = STATE_OFF
|
'Send a key to the tv and handles exceptions.'
| def send_key(self, key):
| try:
self._remote.send_key(key)
self._state = STATE_ON
except OSError:
self._state = STATE_OFF
return False
return True
|
'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
|
'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):
| if self._mac:
return (SUPPORT_VIERATV | SUPPORT_TURN_ON)
return SUPPORT_VIERATV
|
'Turn on the media player.'
| def turn_on(self):
| if self._mac:
self._wol.send_magic_packet(self._mac)
self._state = STATE_ON
|
'Turn off media player.'
| def turn_off(self):
| if (self._state != STATE_OFF):
self.send_key('NRC_POWER-ONOFF')
self._state = STATE_OFF
|
'Volume up the media player.'
| def volume_up(self):
| self.send_key('NRC_VOLUP-ONOFF')
|
'Volume down media player.'
| def volume_down(self):
| self.send_key('NRC_VOLDOWN-ONOFF')
|
'Send mute command.'
| def mute_volume(self, mute):
| self.send_key('NRC_MUTE-ONOFF')
|
'Set volume level, range 0..1.'
| def set_volume_level(self, volume):
| volume = int((volume * 100))
try:
self._remote.set_volume(volume)
self._state = STATE_ON
except OSError:
self._state = STATE_OFF
|
'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('NRC_PLAY-ONOFF')
|
'Send media pause command to media player.'
| def media_pause(self):
| self._playing = False
self.send_key('NRC_PAUSE-ONOFF')
|
'Send next track command.'
| def media_next_track(self):
| self.send_key('NRC_FF-ONOFF')
|
'Send the previous track command.'
| def media_previous_track(self):
| self.send_key('NRC_REW-ONOFF')
|
'Initialize the Roku device.'
| def __init__(self, host):
| from roku import Roku
self.roku = Roku(host)
self.ip_address = host
self.channels = []
self.current_app = None
self.device_info = {}
self.update()
|
'Retrieve latest state.'
| def update(self):
| import requests.exceptions
try:
self.device_info = self.roku.device_info
self.ip_address = self.roku.host
self.channels = self.get_source_list()
if (self.roku.current_app is not None):
self.current_app = self.roku.current_app
else:
self.current_app... |
'Get the list of applications to be used as sources.'
| def get_source_list(self):
| return (['Home'] + sorted((channel.name for channel in self.roku.apps)))
|
'Device should be polled.'
| @property
def should_poll(self):
| return True
|
'Return the name of the device.'
| @property
def name(self):
| if self.device_info.userdevicename:
return self.device_info.userdevicename
return 'Roku {}'.format(self.device_info.sernum)
|
'Return the state of the device.'
| @property
def state(self):
| if (self.current_app is None):
return STATE_UNKNOWN
if ((self.current_app.name == 'Power Saver') or self.current_app.is_screensaver):
return STATE_IDLE
elif (self.current_app.name == 'Roku'):
return STATE_HOME
elif (self.current_app.name is not None):
return STATE_PLAY... |
'Flag media player features that are supported.'
| @property
def supported_features(self):
| return SUPPORT_ROKU
|
'Content type of current playing media.'
| @property
def media_content_type(self):
| if (self.current_app is None):
return None
elif (self.current_app.name == 'Power Saver'):
return None
elif (self.current_app.name == 'Roku'):
return None
return MEDIA_TYPE_VIDEO
|
'Image url of current playing media.'
| @property
def media_image_url(self):
| if (self.current_app is None):
return None
elif (self.current_app.name == 'Roku'):
return None
elif (self.current_app.name == 'Power Saver'):
return None
elif (self.current_app.id is None):
return None
return 'http://{0}:{1}/query/icon/{2}'.format(self.ip_address, ... |
'Name of the current running app.'
| @property
def app_name(self):
| if (self.current_app is not None):
return self.current_app.name
|
'Return the ID of the current running app.'
| @property
def app_id(self):
| if (self.current_app is not None):
return self.current_app.id
|
'Return the current input source.'
| @property
def source(self):
| if (self.current_app is not None):
return self.current_app.name
|
'List of available input sources.'
| @property
def source_list(self):
| return self.channels
|
'Send play/pause command.'
| def media_play_pause(self):
| if (self.current_app is not None):
self.roku.play()
|
'Send previous track command.'
| def media_previous_track(self):
| if (self.current_app is not None):
self.roku.reverse()
|
'Send next track command.'
| def media_next_track(self):
| if (self.current_app is not None):
self.roku.forward()
|
'Mute the volume.'
| def mute_volume(self, mute):
| if (self.current_app is not None):
self.roku.volume_mute()
|
'Volume up media player.'
| def volume_up(self):
| if (self.current_app is not None):
self.roku.volume_up()
|
'Volume down media player.'
| def volume_down(self):
| if (self.current_app is not None):
self.roku.volume_down()
|
'Select input source.'
| def select_source(self, source):
| if (self.current_app is not None):
if (source == 'Home'):
self.roku.home()
else:
channel = self.roku[source]
channel.launch()
|
'Initialize the aquos device.'
| def __init__(self, name, remote, power_on_enabled=False):
| global SUPPORT_SHARPTV
self._power_on_enabled = power_on_enabled
if self._power_on_enabled:
SUPPORT_SHARPTV = (SUPPORT_SHARPTV | SUPPORT_TURN_ON)
self._name = name
self._muted = False
self._state = STATE_UNKNOWN
self._remote = remote
self._volume = 0
self._source = None
s... |
'Set TV state.'
| def set_state(self, state):
| self._state = state
|
'Retrieve the latest data.'
| @_retry
def update(self):
| if (self._remote.power() == 1):
self._state = STATE_ON
else:
self._state = STATE_OFF
if self._power_on_enabled:
self._remote.power_on_command_settings(2)
else:
self._remote.power_on_command_settings(0)
if (self._remote.mute() == 2):
self._muted = False
els... |
'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
|
'Return the current source.'
| @property
def source(self):
| return self._source
|
'Return the source list.'
| @property
def source_list(self):
| return self._source_list
|
'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_SHARPTV
|
'Turn off tvplayer.'
| @_retry
def turn_off(self):
| self._remote.power(0)
|
'Volume up the media player.'
| @_retry
def volume_up(self):
| self._remote.volume((int((self._volume * 60)) + 2))
|
'Volume down media player.'
| @_retry
def volume_down(self):
| self._remote.volume((int((self._volume * 60)) - 2))
|
'Set Volume media player.'
| @_retry
def set_volume_level(self, level):
| self._remote.volume(int((level * 60)))
|
'Send mute command.'
| @_retry
def mute_volume(self, mute):
| self._remote.mute(0)
|
'Turn the media player on.'
| @_retry
def turn_on(self):
| self._remote.power(1)
|
'Simulate play pause media player.'
| @_retry
def media_play_pause(self):
| self._remote.remote_button(40)
|
'Send play command.'
| @_retry
def media_play(self):
| self._remote.remote_button(16)
|
'Send pause command.'
| @_retry
def media_pause(self):
| self._remote.remote_button(16)
|
'Send next track command.'
| @_retry
def media_next_track(self):
| self._remote.remote_button(21)
|
'Send the previous track command.'
| @_retry
def media_previous_track(self):
| self._remote.remote_button(19)
|
'Set the input source.'
| def select_source(self, source):
| for (key, value) in SOURCES.items():
if (source == value):
self._remote.input(key)
|
'Initialize the amplifier.'
| def __init__(self, nad_device, name, min_volume, max_volume, volume_step):
| self._name = name
self.nad_device = nad_device
self._min_vol = ((min_volume + 90) * 2)
self._max_vol = ((max_volume + 90) * 2)
self._volume_step = volume_step
self._state = None
self._mute = None
self._nad_volume = None
self._volume = None
self._source = None
self._source_lis... |
'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
|
'Get the latest details from the device.'
| def update(self):
| try:
nad_status = self.nad_device.status()
except OSError:
return
if (nad_status is None):
return
if nad_status['power']:
self._state = STATE_ON
else:
self._state = STATE_OFF
self._volume = self.nad_vol_to_internal_vol(nad_status['volume'])
self._nad_v... |
'Convert nad volume range (0-200) to internal volume range.
Takes into account configured min and max volume.'
| def nad_vol_to_internal_vol(self, nad_volume):
| if (nad_volume < self._min_vol):
volume_internal = 0.0
if (nad_volume > self._max_vol):
volume_internal = 1.0
else:
volume_internal = ((nad_volume - self._min_vol) / (self._max_vol - self._min_vol))
return volume_internal
|
'Flag media player features that are supported.'
| @property
def supported_features(self):
| return SUPPORT_NAD
|
'Turn the media player off.'
| def turn_off(self):
| self.nad_device.power_off()
|
'Turn the media player on.'
| def turn_on(self):
| self.nad_device.power_on()
|
'Step volume up in the configured increments.'
| def volume_up(self):
| self.nad_device.set_volume((self._nad_volume + (2 * self._volume_step)))
|
'Step volume down in the configured increments.'
| def volume_down(self):
| self.nad_device.set_volume((self._nad_volume - (2 * self._volume_step)))
|
'Set volume level, range 0..1.'
| def set_volume_level(self, volume):
| nad_volume_to_set = int(round(((volume * (self._max_vol - self._min_vol)) + self._min_vol)))
self.nad_device.set_volume(nad_volume_to_set)
|
'Mute (true) or unmute (false) media player.'
| def mute_volume(self, mute):
| if mute:
self.nad_device.mute()
else:
self.nad_device.unmute()
|
'Select input source.'
| def select_source(self, source):
| self.nad_device.select_source(source)
|
'Name of the current input source.'
| @property
def source(self):
| return self._source
|
'List of available input sources.'
| @property
def source_list(self):
| return self.nad_device.available_sources()
|
'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._mute
|
'Initialize the Plex device.'
| def __init__(self, config, device, session, plex_sessions, update_devices, update_sessions):
| from plexapi.utils import NA
self._app_name = ''
self._device = None
self._device_protocol_capabilities = None
self._is_player_active = False
self._is_player_available = False
self._machine_identifier = None
self._make = ''
self._media_content_id = None
self._media_content_rating... |
'Refresh key device data.'
| def refresh(self, device, session):
| if session:
self._session = session
if device:
self._device = device
self._session = None
if self._device:
self._machine_identifier = self._convert_na_to_none(self._device.machineIdentifier)
self._name = (self._convert_na_to_none(self._device.title) or DEVICE_DEFAULT_... |
'Return full URL (if exists) for a thumbnail property.'
| def _get_thumbnail_url(self, property_value):
| if (self._convert_na_to_none(property_value) is None):
return None
if ((self._session is None) or (self._session.server is None)):
return None
url = self._session.server.url(property_value)
response = requests.get(url, verify=False)
if (response and (response.status_code == 200)):
... |
'Force client to idle.'
| def force_idle(self):
| self._state = STATE_IDLE
self._session = None
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.