def __init__(self, username=None, password=None):
self.protocol = 'HTTPS'
self.username = username
self.password = password
self.request_handler = http_handler.HTTPHandler(host='plex.tv',
port=443,
token=plexpy.CONFIG.PMS_TOKEN)
def delete_plextv_sync(self, client_id='', sync_id='', output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
uri = '/devices/%s/sync_items/%s' % (client_id, sync_id)
request = request_handler.make_request(uri=uri,
request_type='DELETE',
output_format=output_format)
return request
def cloud_server_status(self, output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
uri = '/api/v2/cloud_server'
request = request_handler.make_request(uri=uri,
request_type='GET',
output_format=output_format)
return request
def get_plextv_sync_lists(self, machine_id='', output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
uri = '/servers/%s/sync_lists' % machine_id
request = request_handler.make_request(uri=uri,
request_type='GET',
output_format=output_format)
return request
def delete_plextv_device(self, device_id='', output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
uri = '/devices/%s.xml' % device_id
request = request_handler.make_request(uri=uri,
request_type='DELETE',
output_format=output_format)
return request
def get_plextv_server_list(self, output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
uri = '/pms/servers.xml'
request = request_handler.make_request(uri=uri,
request_type='GET',
output_format=output_format)
return request
def get_plextv_user_details(self, output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
uri = '/users/account'
request = request_handler.make_request(uri=uri,
request_type='GET',
output_format=output_format)
return request
def get_plextv_downloads(self, plexpass=False, output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
if plexpass:
uri = '/api/downloads/5.json?channel=plexpass'
else:
uri = '/api/downloads/1.json'
request = request_handler.make_request(uri=uri,
request_type='GET',
output_format=output_format)
return request
def get_plextv_resources(self, include_https=False, output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
if include_https:
uri = '/api/resources?includeHttps=1'
else:
uri = '/api/resources'
request = request_handler.make_request(uri=uri,
request_type='GET',
output_format=output_format)
return request
def get_plextv_pin(self, pin='', output_format=''):
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
if pin:
uri = '/api/v2/pins/' + pin
request = request_handler.make_request(uri=uri,
request_type='GET',
output_format=output_format,
no_token=True)
else:
uri = '/api/v2/pins?strong=true'
request = request_handler.make_request(uri=uri,
request_type='POST',
output_format=output_format,
no_token=True)
return request
def get_plex_auth(self, output_format='raw'):
uri = '/users/sign_in.xml'
base64string = base64.b64encode(
('%s:%s' % (self.username, self.password)).encode('utf-8'))
headers = {
'Content-Type': 'application/xml; charset=utf-8',
'Authorization': 'Basic %s' % base64string
}
request_handler = http_handler.HTTPHandler(urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
request = request_handler.make_request(uri=uri,
request_type='POST',
headers=headers,
output_format=output_format,
no_token=True)
return request
def __init__(self, username=None, password=None, token=None, headers=None):
self.username = username
self.password = password
self.token = token
self.headers = headers
self.urls = 'https://plex.tv'
self.timeout = plexpy.CONFIG.PMS_TIMEOUT
self.ssl_verify = plexpy.CONFIG.VERIFY_SSL_CERT
if self.username is None and self.password is None:
if not self.token:
# Check if we should use the admin token, or the guest server token
if session.get_session_user_id():
user_data = users.Users()
user_tokens = user_data.get_tokens(
user_id=session.get_session_user_id())
self.token = user_tokens['server_token']
else:
self.token = plexpy.CONFIG.PMS_TOKEN
if not self.token:
logger.error(
u"Tautulli PlexTV :: PlexTV called, but no token provided."
)
return
self.http_handler = http_handler.HTTPHandler(
urls=self.urls,
token=self.token,
timeout=self.timeout,
ssl_verify=self.ssl_verify,
headers=self.headers)
plexpass = self.get_plexpass_status()
plexpy.CONFIG.PMS_PLEXPASS = plexpass
plexpy.CONFIG.write()
def get_servers_list(self, include_cloud=True, all_servers=False):
""" Query plex for all servers online. Returns the ones you own in a selectize format """
# Try to discover localhost server
local_server = {
'pms_ssl': '0',
'pms_ip': '127.0.0.1',
'pms_port': '32400',
'pms_name': 'Local',
'pms_url': 'http://127.0.0.1:32400',
'pms_is_remote': '0',
'pms_is_cloud': '0',
'pms_token': plexpy.CONFIG.PMS_TOKEN,
}
local_machine_identifier = None
request_handler = http_handler.HTTPHandler(
urls='http://127.0.0.1:32400',
timeout=1,
ssl_verify=False,
silent=True)
request = request_handler.make_request(uri='/identity',
request_type='GET',
output_format='xml')
if request:
xml_head = request.getElementsByTagName('MediaContainer')[0]
local_machine_identifier = xml_head.getAttribute(
'machineIdentifier')
server = self.get_server_connections(
pms_identifier=local_machine_identifier)
if server:
server.pop('pms_presence')
conn = server.pop('connections')
local_server['pms_uri'] = conn[0]['uri']
local_server.update(server)
servers = self.get_plextv_resources(include_https=True,
output_format='xml')
clean_servers = []
try:
xml_head = servers.getElementsByTagName('MediaContainer')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Failed to get servers from plex: %s." % e)
return []
for a in xml_head:
if a.getAttribute('size'):
if a.getAttribute('size') == '0':
return []
if a.getElementsByTagName('Device'):
devices = a.getElementsByTagName('Device')
for d in devices:
if helpers.get_xml_attr(d, 'presence') == '1' and \
helpers.get_xml_attr(d, 'owned') == '1' and \
helpers.get_xml_attr(d, 'provides') == 'server':
is_cloud = (helpers.get_xml_attr(
d, 'platform').lower() == 'cloud')
if not include_cloud and is_cloud:
continue
connections = d.getElementsByTagName('Connection')
for c in connections:
if not all_servers:
# If this is a remote server don't show any local IPs.
if helpers.get_xml_attr(d, 'publicAddressMatches') == '0' and \
helpers.get_xml_attr(c, 'local') == '1':
continue
# If this is a local server don't show any remote IPs.
if helpers.get_xml_attr(d, 'publicAddressMatches') == '1' and \
helpers.get_xml_attr(c, 'local') == '0':
continue
server = {
'pms_ssl':
1 if is_cloud else int(
helpers.get_xml_attr(d, 'httpsRequired')
or 0),
'pms_identifier':
helpers.get_xml_attr(d, 'clientIdentifier'),
'pms_name':
helpers.get_xml_attr(d, 'name'),
'pms_ip':
helpers.get_xml_attr(c, 'address'),
'pms_port':
helpers.get_xml_attr(c, 'port'),
'pms_uri':
helpers.get_xml_attr(c, 'uri'),
'pms_is_remote':
int(not int(
helpers.get_xml_attr(c, 'local') or 0)),
'pms_platform':
helpers.get_xml_attr(d, 'platform'),
'pms_version':
helpers.get_xml_attr(d, 'productVersion'),
'pms_is_cloud':
int(is_cloud or 0),
'pms_token':
plexpy.CONFIG.PMS_TOKEN,
}
pms_connect = pmsconnect.PmsConnect(
url=server['pms_uri'],
serverName=server['pms_name'])
pms_ssl_pref = pms_connect.get_server_pref(
'secureConnections')
if pms_ssl_pref:
server['pms_ssl_pref'] = int(pms_ssl_pref)
pms_url = 'http://{hostname}:{port}'.format(
hostname=helpers.get_xml_attr(c, 'address'),
port=helpers.get_xml_attr(c, 'port'))
if server['pms_ssl']:
server['pms_url'] = server['pms_uri']
else:
server['pms_url'] = pms_url
clean_servers.append(server)
if local_machine_identifier:
found = False
for server in clean_servers:
if server['pms_identifier'] == local_machine_identifier:
local_server.pop('pms_name')
server.update(local_server)
found = True
break
if not found:
local_server['pms_identifier'] = local_machine_identifier
clean_servers.append(local_server)
clean_servers.sort(key=lambda s: (s['pms_name'], -int(s[
'pms_is_remote']), s['pms_ip']))
return clean_servers
def __init__(self):
self.protocol = 'HTTPS'
self.request_handler = http_handler.HTTPHandler(host=plexpy.CONFIG.PMS_IP,
port=plexpy.CONFIG.PMS_PORT,
token=plexpy.CONFIG.PMS_TOKEN)