def get_connections(device):
conn = []
connections = device.getElementsByTagName('Connection')
for c in connections:
server_details = {"protocol": helpers.get_xml_attr(c, 'protocol'),
"address": helpers.get_xml_attr(c, 'address'),
"port": helpers.get_xml_attr(c, 'port'),
"uri": helpers.get_xml_attr(c, 'uri'),
"local": helpers.get_xml_attr(c, 'local')
}
conn.append(server_details)
return conn
def get_server_identity(self):
identity = self.get_local_server_identity(output_format='xml')
xml_head = identity.getElementsByTagName('MediaContainer')
if not xml_head:
logger.warn("Error parsing XML for Plex server identity.")
return None
server_identity = {}
for a in xml_head:
server_identity = {"machine_identifier": helpers.get_xml_attr(a, 'machineIdentifier'),
"version": helpers.get_xml_attr(a, 'version')
}
return server_identity
def get_connections(device):
conn = []
connections = device.getElementsByTagName('Connection')
for c in connections:
server_details = {
"protocol": helpers.get_xml_attr(c, 'protocol'),
"address": helpers.get_xml_attr(c, 'address'),
"port": helpers.get_xml_attr(c, 'port'),
"uri": helpers.get_xml_attr(c, 'uri'),
"local": helpers.get_xml_attr(c, 'local')
}
conn.append(server_details)
return conn
def get_server_identity(self):
identity = self.get_local_server_identity(output_format='xml')
try:
xml_head = identity.getElementsByTagName('MediaContainer')
except:
logger.warn("Unable to parse XML for get_local_server_identity.")
return []
server_identity = {}
for a in xml_head:
server_identity = {"machine_identifier": helpers.get_xml_attr(a, 'machineIdentifier'),
"version": helpers.get_xml_attr(a, 'version')
}
return server_identity
def get_current_activity(self):
session_data = self.get_sessions(output_format="xml")
try:
xml_head = session_data.getElementsByTagName("MediaContainer")
except:
logger.warn("Unable to parse XML for get_sessions.")
return []
session_list = []
for a in xml_head:
if a.getAttribute("size"):
if a.getAttribute("size") == "0":
session_list = {"stream_count": "0", "sessions": []}
return session_list
if a.getElementsByTagName("Track"):
session_data = a.getElementsByTagName("Track")
session_type = "track"
for session in session_data:
session_output = self.get_session_each(session_type, session)
session_list.append(session_output)
if a.getElementsByTagName("Video"):
session_data = a.getElementsByTagName("Video")
session_type = "video"
for session in session_data:
session_output = self.get_session_each(session_type, session)
session_list.append(session_output)
output = {"stream_count": helpers.get_xml_attr(xml_head[0], "size"), "sessions": session_list}
return output
def get_current_activity(self):
session_data = self.get_sessions(output_format='xml')
session_list = []
xml_head = session_data.getElementsByTagName('MediaContainer')
if not xml_head:
logger.warn("Error parsing XML for Plex session data.")
return None
for a in xml_head:
if a.getAttribute('size'):
if a.getAttribute('size') == '0':
session_list = {'stream_count': '0',
'sessions': []
}
return session_list
if a.getElementsByTagName('Track'):
session_data = a.getElementsByTagName('Track')
session_type = 'track'
for session in session_data:
session_output = self.get_session_each(session_type, session)
session_list.append(session_output)
if a.getElementsByTagName('Video'):
session_data = a.getElementsByTagName('Video')
session_type = 'video'
for session in session_data:
session_output = self.get_session_each(session_type, session)
session_list.append(session_output)
output = {'stream_count': helpers.get_xml_attr(xml_head[0], 'size'),
'sessions': session_list
}
return output
def get_server_times(self):
servers = self.get_plextv_server_list(output_format='xml')
server_times = []
try:
xml_head = servers.getElementsByTagName('Server')
except:
logger.warn("Error parsing XML for Plex servers.")
return []
for a in xml_head:
if helpers.get_xml_attr(a, 'machineIdentifier') == plexpy.CONFIG.PMS_IDENTIFIER:
server_times.append({"created_at": helpers.get_xml_attr(a, 'createdAt'),
"updated_at": helpers.get_xml_attr(a, 'updatedAt')
})
break
return server_times
def get_server_times(self):
servers = self.get_plextv_server_list(output_format='xml')
server_times = []
try:
xml_head = servers.getElementsByTagName('Server')
except Exception as e:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_server_times: %s." % e)
return []
for a in xml_head:
if helpers.get_xml_attr(a, 'machineIdentifier') == plexpy.CONFIG.PMS_IDENTIFIER:
server_times.append({"created_at": helpers.get_xml_attr(a, 'createdAt'),
"updated_at": helpers.get_xml_attr(a, 'updatedAt')
})
break
return server_times
def get_server_times(self):
servers = self.get_plextv_server_list(output_format='xml')
server_times = []
try:
xml_head = servers.getElementsByTagName('Server')
except:
logger.warn("Error parsing XML for Plex servers.")
return []
for a in xml_head:
if helpers.get_xml_attr(a, 'machineIdentifier') == plexpy.CONFIG.PMS_IDENTIFIER:
server_times.append({"created_at": helpers.get_xml_attr(a, 'createdAt'),
"updated_at": helpers.get_xml_attr(a, 'updatedAt')
})
break
return server_times
def get_cloud_server_status(self, server):
cloud_status = self.cloud_server_status(output_format='xml')
try:
status_info = cloud_status.getElementsByTagName('info')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_cloud_server_status: %s."
% e)
return False
for info in status_info:
servers = info.getElementsByTagName('server')
for s in servers:
if helpers.get_xml_attr(s, 'address') == server.CONFIG.PMS_IP:
if helpers.get_xml_attr(info, 'running') == '1':
return True
else:
return False
def get_server_pref(self, pref=None):
if pref:
prefs = self.get_server_prefs(output_format="xml")
try:
xml_head = prefs.getElementsByTagName("Setting")
except:
logger.warn("Unable to parse XML for get_local_server_name.")
return ""
pref_value = "None"
for a in xml_head:
if helpers.get_xml_attr(a, "id") == pref:
pref_value = helpers.get_xml_attr(a, "value")
break
return pref_value
else:
logger.debug(u"Server preferences queried but no parameter received.")
return None
def get_server_pref(self, pref=None):
if pref:
prefs = self.get_server_prefs(output_format='xml')
try:
xml_head = prefs.getElementsByTagName('Setting')
except:
logger.warn("Unable to parse XML for get_local_server_name.")
return ''
pref_value = 'None'
for a in xml_head:
if helpers.get_xml_attr(a, 'id') == pref:
pref_value = helpers.get_xml_attr(a, 'value')
break
return pref_value
else:
logger.debug(u"Server preferences queried but no parameter received.")
return None
def get_servers_info(self):
recent = self.get_server_list(output_format='xml')
xml_head = recent.getElementsByTagName('Server')
if not xml_head:
logger.warn("Error parsing XML for Plex server prefs.")
return None
server_info = []
for a in xml_head:
output = {"name": helpers.get_xml_attr(a, 'name'),
"machine_identifier": helpers.get_xml_attr(a, 'machineIdentifier'),
"host": helpers.get_xml_attr(a, 'host'),
"port": helpers.get_xml_attr(a, 'port'),
"version": helpers.get_xml_attr(a, 'version')
}
server_info.append(output)
return server_info
def get_servers_info(self):
recent = self.get_server_list(output_format='xml')
try:
xml_head = recent.getElementsByTagName('Server')
except:
logger.warn("Unable to parse XML for get_server_list.")
return []
server_info = []
for a in xml_head:
output = {"name": helpers.get_xml_attr(a, 'name'),
"machine_identifier": helpers.get_xml_attr(a, 'machineIdentifier'),
"host": helpers.get_xml_attr(a, 'host'),
"port": helpers.get_xml_attr(a, 'port'),
"version": helpers.get_xml_attr(a, 'version')
}
server_info.append(output)
return server_info
def get_season_children(self, rating_key=''):
episode_data = self.get_episode_list(rating_key, output_format='xml')
episode_list = []
xml_head = episode_data.getElementsByTagName('MediaContainer')
if not xml_head:
logger.warn("Error parsing XML for Plex session data.")
return None
for a in xml_head:
if a.getAttribute('size'):
if a.getAttribute('size') == '0':
logger.debug(u"No episode data.")
episode_list = {'episode_count': '0',
'episode_list': []
}
return episode_list
if a.getElementsByTagName('Video'):
result_data = a.getElementsByTagName('Video')
for result in result_data:
episode_output = {'rating_key': helpers.get_xml_attr(result, 'ratingKey'),
'index': helpers.get_xml_attr(result, 'index'),
'title': helpers.get_xml_attr(result, 'title'),
'thumb': helpers.get_xml_attr(result, 'thumb')
}
episode_list.append(episode_output)
output = {'episode_count': helpers.get_xml_attr(xml_head[0], 'size'),
'title': helpers.get_xml_attr(xml_head[0], 'title2'),
'episode_list': episode_list
}
return output
def get_server_times(self):
servers = self.get_plextv_server_list(output_format='xml')
server_times = {}
try:
xml_head = servers.getElementsByTagName('Server')
except Exception as e:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_server_times: %s."
% e)
return {}
for a in xml_head:
if helpers.get_xml_attr(
a, 'machineIdentifier') == plexpy.CONFIG.PMS_IDENTIFIER:
server_times = {
"created_at": helpers.get_xml_attr(a, 'createdAt'),
"updated_at": helpers.get_xml_attr(a, 'updatedAt'),
"version": helpers.get_xml_attr(a, 'version')
}
break
return server_times
def get_server_token(self):
servers = self.get_plextv_resources(output_format='xml')
try:
xml_head = servers.getElementsByTagName('Device')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_server_token: %s."
% e)
return None
server_tokens = {}
for a in xml_head:
if 'server' in helpers.get_xml_attr(a, 'provides'):
server_identifier = helpers.get_xml_attr(a, 'clientIdentifier')
server_token = helpers.get_xml_attr(a, 'accessToken')
server = plexpy.PMS_SERVERS.get_server_by_identifier(
server_identifier)
if server:
server_id = server.CONFIG.ID
server_tokens[server_id] = server_token
return server_tokens
def discover(self):
""" Query plex for all servers online. Returns the ones you own in a selectize format """
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"PlexPy 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':
connections = d.getElementsByTagName('Connection')
for c in connections:
server = {'httpsRequired': helpers.get_xml_attr(d, 'httpsRequired'),
'clientIdentifier': helpers.get_xml_attr(d, 'clientIdentifier'),
'label': helpers.get_xml_attr(d, 'name'),
'ip': helpers.get_xml_attr(c, 'address'),
'port': helpers.get_xml_attr(c, 'port'),
'local': helpers.get_xml_attr(c, 'local'),
'value': helpers.get_xml_attr(c, 'address')
}
clean_servers.append(server)
return clean_servers
def get_server_times(self):
servers = self.get_plextv_server_list(output_format='xml')
try:
xml_head = servers.getElementsByTagName('Server')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_server_times: %s."
% e)
return {}
server_list = {}
for a in xml_head:
server_times = {
"created_at": helpers.get_xml_attr(a, 'createdAt'),
"updated_at": helpers.get_xml_attr(a, 'updatedAt'),
"version": helpers.get_xml_attr(a, 'version')
}
pms_identifier = helpers.get_xml_attr(a, 'machineIdentifier')
pms_name = plexpy.PMS_SERVERS.get_server_by_identifier(
pms_identifier=pms_identifier)
server_list[pms_name] = server_times
return server_list
def get_plexpass_status(self):
account_data = self.get_plextv_user_details(output_format='xml')
try:
subscription = account_data.getElementsByTagName('subscription')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_plexpass_status: %s."
% e)
return False
if subscription and helpers.get_xml_attr(subscription[0],
'active') == '1':
return True
else:
logger.debug(
u"Tautulli PlexTV :: Plex Pass subscription not found.")
return False
def get_season_children(self, rating_key=""):
episode_data = self.get_episode_list(rating_key, output_format="xml")
try:
xml_head = episode_data.getElementsByTagName("MediaContainer")
except:
logger.warn("Unable to parse XML for get_episode_list.")
return []
episode_list = []
for a in xml_head:
if a.getAttribute("size"):
if a.getAttribute("size") == "0":
logger.debug(u"No episode data.")
episode_list = {"episode_count": "0", "episode_list": []}
return episode_list
if a.getElementsByTagName("Video"):
result_data = a.getElementsByTagName("Video")
for result in result_data:
episode_output = {
"rating_key": helpers.get_xml_attr(result, "ratingKey"),
"index": helpers.get_xml_attr(result, "index"),
"title": helpers.get_xml_attr(result, "title"),
"thumb": helpers.get_xml_attr(result, "thumb"),
}
episode_list.append(episode_output)
output = {
"episode_count": helpers.get_xml_attr(xml_head[0], "size"),
"title": helpers.get_xml_attr(xml_head[0], "title2"),
"episode_list": episode_list,
}
return output
def get_full_users_list(self):
friends_list = self.get_plextv_friends()
own_account = self.get_plextv_user_details()
users_list = []
try:
xml_parse = minidom.parseString(own_account)
except Exception as e:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list own account: %s"
% e)
return []
except:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list own account."
)
return []
xml_head = xml_parse.getElementsByTagName('user')
if not xml_head:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list."
)
else:
for a in xml_head:
own_details = {
"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'username'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_allow_sync": None,
"is_restricted": helpers.get_xml_attr(a, 'restricted')
}
users_list.append(own_details)
try:
xml_parse = minidom.parseString(friends_list)
except Exception as e:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list friends list: %s"
% e)
return []
except:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list friends list."
)
return []
xml_head = xml_parse.getElementsByTagName('User')
if not xml_head:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list."
)
else:
for a in xml_head:
friend = {
"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'title'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_allow_sync": helpers.get_xml_attr(a, 'allowSync'),
"is_restricted": helpers.get_xml_attr(a, 'restricted')
}
users_list.append(friend)
return users_list
def get_synced_items(self, machine_id=None, user_id=None):
sync_list = self.get_plextv_sync_lists(machine_id)
user_data = users.Users()
synced_items = []
try:
xml_parse = minidom.parseString(sync_list)
except Exception as e:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_synced_items: %s"
% e)
return []
except:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_synced_items.")
return []
xml_head = xml_parse.getElementsByTagName('SyncList')
if not xml_head:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_synced_items.")
else:
for a in xml_head:
client_id = helpers.get_xml_attr(a, 'id')
sync_device = a.getElementsByTagName('Device')
for device in sync_device:
device_user_id = helpers.get_xml_attr(device, 'userID')
try:
device_username = user_data.get_details(
user_id=device_user_id)['username']
device_friendly_name = user_data.get_details(
user_id=device_user_id)['friendly_name']
except:
device_username = ''
device_friendly_name = ''
device_name = helpers.get_xml_attr(device, 'name')
device_product = helpers.get_xml_attr(device, 'product')
device_product_version = helpers.get_xml_attr(
device, 'productVersion')
device_platform = helpers.get_xml_attr(device, 'platform')
device_platform_version = helpers.get_xml_attr(
device, 'platformVersion')
device_type = helpers.get_xml_attr(device, 'device')
device_model = helpers.get_xml_attr(device, 'model')
device_last_seen = helpers.get_xml_attr(
device, 'lastSeenAt')
# Filter by user_id
if user_id and user_id != device_user_id:
continue
for synced in a.getElementsByTagName('SyncItems'):
sync_item = synced.getElementsByTagName('SyncItem')
for item in sync_item:
sync_id = helpers.get_xml_attr(item, 'id')
sync_version = helpers.get_xml_attr(item, 'version')
sync_root_title = helpers.get_xml_attr(
item, 'rootTitle')
sync_title = helpers.get_xml_attr(item, 'title')
sync_metadata_type = helpers.get_xml_attr(
item, 'metadataType')
sync_content_type = helpers.get_xml_attr(
item, 'contentType')
for status in item.getElementsByTagName('Status'):
status_failure_code = helpers.get_xml_attr(
status, 'failureCode')
status_failure = helpers.get_xml_attr(
status, 'failure')
status_state = helpers.get_xml_attr(
status, 'state')
status_item_count = helpers.get_xml_attr(
status, 'itemsCount')
status_item_complete_count = helpers.get_xml_attr(
status, 'itemsCompleteCount')
status_item_downloaded_count = helpers.get_xml_attr(
status, 'itemsDownloadedCount')
status_item_ready_count = helpers.get_xml_attr(
status, 'itemsReadyCount')
status_item_successful_count = helpers.get_xml_attr(
status, 'itemsSuccessfulCount')
status_total_size = helpers.get_xml_attr(
status, 'totalSize')
status_item_download_percent_complete = helpers.get_percent(
status_item_downloaded_count,
status_item_count)
for settings in item.getElementsByTagName(
'MediaSettings'):
settings_audio_boost = helpers.get_xml_attr(
settings, 'audioBoost')
settings_music_bitrate = helpers.get_xml_attr(
settings, 'musicBitrate')
settings_photo_quality = helpers.get_xml_attr(
settings, 'photoQuality')
settings_photo_resolution = helpers.get_xml_attr(
settings, 'photoResolution')
settings_video_quality = helpers.get_xml_attr(
settings, 'videoQuality')
settings_video_resolution = helpers.get_xml_attr(
settings, 'videoResolution')
for location in item.getElementsByTagName('Location'):
clean_uri = helpers.get_xml_attr(
location, 'uri').split('%2F')
rating_key = next(
(clean_uri[(idx + 1) % len(clean_uri)]
for idx, item in enumerate(clean_uri)
if item == 'metadata'), None)
sync_details = {
"device_name": helpers.sanitize(device_name),
"platform": helpers.sanitize(device_platform),
"username": helpers.sanitize(device_username),
"friendly_name":
helpers.sanitize(device_friendly_name),
"user_id": device_user_id,
"root_title": helpers.sanitize(sync_root_title),
"title": helpers.sanitize(sync_title),
"metadata_type": sync_metadata_type,
"content_type": sync_content_type,
"rating_key": rating_key,
"state": status_state,
"item_count": status_item_count,
"item_complete_count": status_item_complete_count,
"item_downloaded_count":
status_item_downloaded_count,
"item_downloaded_percent_complete":
status_item_download_percent_complete,
"music_bitrate": settings_music_bitrate,
"photo_quality": settings_photo_quality,
"video_quality": settings_video_quality,
"total_size": status_total_size,
"failure": status_failure,
"sync_id": sync_id
}
synced_items.append(sync_details)
return synced_items
def get_plex_account_details(self):
account_data = self.get_plextv_user_details(output_format='xml')
try:
xml_head = account_data.getElementsByTagName('user')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_plex_account_details: %s."
% e)
return None
for a in xml_head:
account_details = {
"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'username'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_restricted": helpers.get_xml_attr(a, 'restricted'),
"filter_all": helpers.get_xml_attr(a, 'filterAll'),
"filter_movies": helpers.get_xml_attr(a, 'filterMovies'),
"filter_tv": helpers.get_xml_attr(a, 'filterTelevision'),
"filter_music": helpers.get_xml_attr(a, 'filterMusic'),
"filter_photos": helpers.get_xml_attr(a, 'filterPhotos'),
"user_token": helpers.get_xml_attr(a, 'authToken')
}
return account_details
def get_metadata_details(self, rating_key=''):
metadata = self.get_metadata(rating_key, output_format='xml')
metadata_list = []
xml_head = metadata.getElementsByTagName('MediaContainer')
if not xml_head:
logger.warn("Error parsing XML for Plex metadata.")
return None
for a in xml_head:
if a.getAttribute('size'):
if a.getAttribute('size') != '1':
metadata_list = {'metadata': None}
return metadata_list
if a.getElementsByTagName('Directory'):
metadata_main = a.getElementsByTagName('Directory')[0]
metadata_type = helpers.get_xml_attr(metadata_main, 'type')
elif a.getElementsByTagName('Video'):
metadata_main = a.getElementsByTagName('Video')[0]
metadata_type = helpers.get_xml_attr(metadata_main, 'type')
else:
logger.debug(u"Metadata failed")
genres = []
actors = []
writers = []
directors = []
if metadata_main.getElementsByTagName('Genre'):
for genre in metadata_main.getElementsByTagName('Genre'):
genres.append(helpers.get_xml_attr(genre, 'tag'))
if metadata_main.getElementsByTagName('Role'):
for actor in metadata_main.getElementsByTagName('Role'):
actors.append(helpers.get_xml_attr(actor, 'tag'))
if metadata_main.getElementsByTagName('Writer'):
for writer in metadata_main.getElementsByTagName('Writer'):
writers.append(helpers.get_xml_attr(writer, 'tag'))
if metadata_main.getElementsByTagName('Director'):
for director in metadata_main.getElementsByTagName('Director'):
directors.append(helpers.get_xml_attr(director, 'tag'))
if metadata_type == 'show':
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': helpers.get_xml_attr(metadata_main, 'summary'),
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': helpers.convert_milliseconds_to_minutes(helpers.get_xml_attr(metadata_main, 'duration')),
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'writers': writers,
'directors': directors,
'genres': genres,
'actors': actors
}
metadata_list = {'metadata': metadata}
elif metadata_type == 'episode':
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': helpers.get_xml_attr(metadata_main, 'summary'),
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': helpers.convert_milliseconds_to_minutes(helpers.get_xml_attr(metadata_main, 'duration')),
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'writers': writers,
'directors': directors,
'genres': genres,
'actors': actors
}
metadata_list = {'metadata': metadata}
elif metadata_type == 'movie':
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': helpers.get_xml_attr(metadata_main, 'summary'),
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': helpers.convert_milliseconds_to_minutes(helpers.get_xml_attr(metadata_main, 'duration')),
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'genres': genres,
'actors': actors,
'writers': writers,
'directors': directors
}
metadata_list = {'metadata': metadata}
elif metadata_type == 'season':
parent_rating_key = helpers.get_xml_attr(metadata_main, 'parentRatingKey')
show_details = self.get_metadata_details(parent_rating_key)
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': show_details['metadata']['summary'],
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': show_details['metadata']['duration'],
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'genres': genres,
'actors': actors,
'writers': writers,
'directors': directors
}
metadata_list = {'metadata': metadata}
else:
return None
return metadata_list
def get_session_each(self, stream_type='', session=None):
session_output = None
data_factory = datafactory.DataFactory()
if stream_type == 'track':
media_info = session.getElementsByTagName('Media')[0]
audio_decision = 'direct play'
audio_channels = helpers.get_xml_attr(media_info, 'audioChannels')
audio_codec = helpers.get_xml_attr(media_info, 'audioCodec')
container = helpers.get_xml_attr(media_info, 'container')
bitrate = helpers.get_xml_attr(media_info, 'bitrate')
duration = helpers.get_xml_attr(media_info, 'duration')
progress = helpers.get_xml_attr(session, 'viewOffset')
if session.getElementsByTagName('TranscodeSession'):
transcode_session = session.getElementsByTagName('TranscodeSession')[0]
audio_decision = helpers.get_xml_attr(transcode_session, 'audioDecision')
transcode_audio_channels = helpers.get_xml_attr(transcode_session, 'audioChannels')
transcode_audio_codec = helpers.get_xml_attr(transcode_session, 'audioCodec')
transcode_container = helpers.get_xml_attr(transcode_session, 'container')
transcode_protocol = helpers.get_xml_attr(transcode_session, 'protocol')
duration = helpers.get_xml_attr(transcode_session, 'duration')
else:
transcode_audio_channels = ''
transcode_audio_codec = ''
transcode_container = ''
transcode_protocol = ''
user_details = data_factory.get_user_details(
user=helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'))
if helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'machineIdentifier').endswith('_Track'):
machine_id = helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'machineIdentifier')[:-6]
else:
machine_id = helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'machineIdentifier')
session_output = {'session_key': helpers.get_xml_attr(session, 'sessionKey'),
'media_index': helpers.get_xml_attr(session, 'index'),
'parent_media_index': helpers.get_xml_attr(session, 'parentIndex'),
'art': helpers.get_xml_attr(session, 'art'),
'parent_thumb': helpers.get_xml_attr(session, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(session, 'grandparentThumb'),
'thumb': helpers.get_xml_attr(session, 'thumb'),
'bif_thumb': '',
'user': helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'),
'user_id': user_details['user_id'],
'friendly_name': user_details['friendly_name'],
'player': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'title'),
'platform': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'platform'),
'machine_id': machine_id,
'state': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'state'),
'grandparent_title': helpers.get_xml_attr(session, 'grandparentTitle'),
'parent_title': helpers.get_xml_attr(session, 'parentTitle'),
'title': helpers.get_xml_attr(session, 'title'),
'rating_key': helpers.get_xml_attr(session, 'ratingKey'),
'parent_rating_key': helpers.get_xml_attr(session, 'parentRatingKey'),
'grandparent_rating_key': helpers.get_xml_attr(session, 'grandparentRatingKey'),
'audio_decision': audio_decision,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'video_decision': '',
'video_codec': '',
'height': '',
'width': '',
'container': container,
'bitrate': bitrate,
'video_resolution': '',
'video_framerate': '',
'aspect_ratio': '',
'transcode_audio_channels': transcode_audio_channels,
'transcode_audio_codec': transcode_audio_codec,
'transcode_video_codec': '',
'transcode_width': '',
'transcode_height': '',
'transcode_container': transcode_container,
'transcode_protocol': transcode_protocol,
'duration': duration,
'progress': progress,
'progress_percent': str(helpers.get_percent(progress, duration)),
'type': 'track',
'indexes': 0
}
elif stream_type == 'video':
media_info = session.getElementsByTagName('Media')[0]
audio_decision = 'direct play'
audio_channels = helpers.get_xml_attr(media_info, 'audioChannels')
audio_codec = helpers.get_xml_attr(media_info, 'audioCodec')
video_decision = 'direct play'
video_codec = helpers.get_xml_attr(media_info, 'videoCodec')
container = helpers.get_xml_attr(media_info, 'container')
bitrate = helpers.get_xml_attr(media_info, 'bitrate')
video_resolution = helpers.get_xml_attr(media_info, 'videoResolution')
video_framerate = helpers.get_xml_attr(media_info, 'videoFrameRate')
aspect_ratio = helpers.get_xml_attr(media_info, 'aspectRatio')
width = helpers.get_xml_attr(media_info, 'width')
height = helpers.get_xml_attr(media_info, 'height')
duration = helpers.get_xml_attr(media_info, 'duration')
progress = helpers.get_xml_attr(session, 'viewOffset')
if session.getElementsByTagName('TranscodeSession'):
transcode_session = session.getElementsByTagName('TranscodeSession')[0]
audio_decision = helpers.get_xml_attr(transcode_session, 'audioDecision')
transcode_audio_channels = helpers.get_xml_attr(transcode_session, 'audioChannels')
transcode_audio_codec = helpers.get_xml_attr(transcode_session, 'audioCodec')
video_decision = helpers.get_xml_attr(transcode_session, 'videoDecision')
transcode_video_codec = helpers.get_xml_attr(transcode_session, 'videoCodec')
transcode_width = helpers.get_xml_attr(transcode_session, 'width')
transcode_height = helpers.get_xml_attr(transcode_session, 'height')
transcode_container = helpers.get_xml_attr(transcode_session, 'container')
transcode_protocol = helpers.get_xml_attr(transcode_session, 'protocol')
else:
transcode_audio_channels = ''
transcode_audio_codec = ''
transcode_video_codec = ''
transcode_width = ''
transcode_height = ''
transcode_container = ''
transcode_protocol = ''
media_info = session.getElementsByTagName('Media')[0]
if media_info.getElementsByTagName('Part'):
indexes = helpers.get_xml_attr(media_info.getElementsByTagName('Part')[0], 'indexes')
part_id = helpers.get_xml_attr(media_info.getElementsByTagName('Part')[0], 'id')
if indexes == 'sd':
bif_thumb = '/library/parts/' + part_id + '/indexes/sd/' + progress
else:
bif_thumb = ''
else:
indexes = ''
bif_thumb = ''
if plexpy.CONFIG.PMS_USE_BIF and indexes == 'sd':
use_indexes = 1
else:
use_indexes = 0
user_details = data_factory.get_user_details(
user=helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'))
if helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'machineIdentifier').endswith('_Video'):
machine_id = helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'machineIdentifier')[:-6]
else:
machine_id = helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'machineIdentifier')
if helpers.get_xml_attr(session, 'type') == 'episode':
session_output = {'session_key': helpers.get_xml_attr(session, 'sessionKey'),
'media_index': helpers.get_xml_attr(session, 'index'),
'parent_media_index': helpers.get_xml_attr(session, 'parentIndex'),
'art': helpers.get_xml_attr(session, 'art'),
'parent_thumb': helpers.get_xml_attr(session, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(session, 'grandparentThumb'),
'thumb': helpers.get_xml_attr(session, 'thumb'),
'bif_thumb': bif_thumb,
'user': helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'),
'user_id': user_details['user_id'],
'friendly_name': user_details['friendly_name'],
'player': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'title'),
'platform': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'platform'),
'machine_id': machine_id,
'state': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'state'),
'grandparent_title': helpers.get_xml_attr(session, 'grandparentTitle'),
'parent_title': helpers.get_xml_attr(session, 'parentTitle'),
'title': helpers.get_xml_attr(session, 'title'),
'rating_key': helpers.get_xml_attr(session, 'ratingKey'),
'parent_rating_key': helpers.get_xml_attr(session, 'parentRatingKey'),
'grandparent_rating_key': helpers.get_xml_attr(session, 'grandparentRatingKey'),
'audio_decision': audio_decision,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'video_decision': video_decision,
'video_codec': video_codec,
'height': height,
'width': width,
'container': container,
'bitrate': bitrate,
'video_resolution': video_resolution,
'video_framerate': video_framerate,
'aspect_ratio': aspect_ratio,
'transcode_audio_channels': transcode_audio_channels,
'transcode_audio_codec': transcode_audio_codec,
'transcode_video_codec': transcode_video_codec,
'transcode_width': transcode_width,
'transcode_height': transcode_height,
'transcode_container': transcode_container,
'transcode_protocol': transcode_protocol,
'duration': duration,
'progress': progress,
'progress_percent': str(helpers.get_percent(progress, duration)),
'type': helpers.get_xml_attr(session, 'type'),
'indexes': use_indexes
}
elif helpers.get_xml_attr(session, 'type') == 'movie':
session_output = {'session_key': helpers.get_xml_attr(session, 'sessionKey'),
'media_index': helpers.get_xml_attr(session, 'index'),
'parent_media_index': helpers.get_xml_attr(session, 'parentIndex'),
'art': helpers.get_xml_attr(session, 'art'),
'thumb': helpers.get_xml_attr(session, 'thumb'),
'bif_thumb': bif_thumb,
'parent_thumb': helpers.get_xml_attr(session, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(session, 'grandparentThumb'),
'user': helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'),
'user_id': user_details['user_id'],
'friendly_name': user_details['friendly_name'],
'player': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'title'),
'platform': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'platform'),
'machine_id': machine_id,
'state': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'state'),
'grandparent_title': helpers.get_xml_attr(session, 'grandparentTitle'),
'parent_title': helpers.get_xml_attr(session, 'parentTitle'),
'title': helpers.get_xml_attr(session, 'title'),
'rating_key': helpers.get_xml_attr(session, 'ratingKey'),
'parent_rating_key': helpers.get_xml_attr(session, 'parentRatingKey'),
'grandparent_rating_key': helpers.get_xml_attr(session, 'grandparentRatingKey'),
'audio_decision': audio_decision,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'video_decision': video_decision,
'video_codec': video_codec,
'height': height,
'width': width,
'container': container,
'bitrate': bitrate,
'video_resolution': video_resolution,
'video_framerate': video_framerate,
'aspect_ratio': aspect_ratio,
'transcode_audio_channels': transcode_audio_channels,
'transcode_audio_codec': transcode_audio_codec,
'transcode_video_codec': transcode_video_codec,
'transcode_width': transcode_width,
'transcode_height': transcode_height,
'transcode_container': transcode_container,
'transcode_protocol': transcode_protocol,
'duration': duration,
'progress': progress,
'progress_percent': str(helpers.get_percent(progress, duration)),
'type': helpers.get_xml_attr(session, 'type'),
'indexes': use_indexes
}
elif helpers.get_xml_attr(session, 'type') == 'clip':
session_output = {'session_key': helpers.get_xml_attr(session, 'sessionKey'),
'media_index': helpers.get_xml_attr(session, 'index'),
'parent_media_index': helpers.get_xml_attr(session, 'parentIndex'),
'art': helpers.get_xml_attr(session, 'art'),
'thumb': helpers.get_xml_attr(session, 'thumb'),
'bif_thumb': bif_thumb,
'parent_thumb': helpers.get_xml_attr(session, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(session, 'grandparentThumb'),
'user': helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'),
'user_id': user_details['user_id'],
'friendly_name': user_details['friendly_name'],
'player': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'title'),
'platform': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'platform'),
'machine_id': machine_id,
'state': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'state'),
'grandparent_title': helpers.get_xml_attr(session, 'grandparentTitle'),
'parent_title': helpers.get_xml_attr(session, 'parentTitle'),
'title': helpers.get_xml_attr(session, 'title'),
'rating_key': helpers.get_xml_attr(session, 'ratingKey'),
'parent_rating_key': helpers.get_xml_attr(session, 'parentRatingKey'),
'grandparent_rating_key': helpers.get_xml_attr(session, 'grandparentRatingKey'),
'audio_decision': audio_decision,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'video_decision': video_decision,
'video_codec': video_codec,
'height': height,
'width': width,
'container': container,
'bitrate': bitrate,
'video_resolution': video_resolution,
'video_framerate': video_framerate,
'aspect_ratio': aspect_ratio,
'transcode_audio_channels': transcode_audio_channels,
'transcode_audio_codec': transcode_audio_codec,
'transcode_video_codec': transcode_video_codec,
'transcode_width': transcode_width,
'transcode_height': transcode_height,
'transcode_container': transcode_container,
'transcode_protocol': transcode_protocol,
'duration': duration,
'progress': progress,
'progress_percent': str(helpers.get_percent(progress, duration)),
'type': helpers.get_xml_attr(session, 'type'),
'indexes': 0
}
else:
logger.warn(u"No known stream types found in session list.")
return session_output
def get_full_users_list(self):
own_account = self.get_plextv_user_details(output_format='xml')
friends_list = self.get_plextv_friends(output_format='xml')
users_list = []
try:
xml_head = own_account.getElementsByTagName('user')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse own account XML for get_full_users_list: %s."
% e)
return []
for a in xml_head:
own_details = {
"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'username'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_admin": 1,
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_allow_sync": 1,
"is_restricted": helpers.get_xml_attr(a, 'restricted'),
"filter_all": helpers.get_xml_attr(a, 'filterAll'),
"filter_movies": helpers.get_xml_attr(a, 'filterMovies'),
"filter_tv": helpers.get_xml_attr(a, 'filterTelevision'),
"filter_music": helpers.get_xml_attr(a, 'filterMusic'),
"filter_photos": helpers.get_xml_attr(a, 'filterPhotos'),
"shared_libraries": [],
}
for server in plexpy.PMS_SERVERS:
own_details["shared_libraries"].append({
"server_id":
server.CONFIG.ID,
"user_token":
helpers.get_xml_attr(a, 'authToken'),
"server_token":
helpers.get_xml_attr(a, 'authToken'),
})
users_list.append(own_details)
try:
xml_head = friends_list.getElementsByTagName('User')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse friends list XML for get_full_users_list: %s."
% e)
return []
for a in xml_head:
friend = {
"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'title'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_admin": 0,
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_allow_sync": helpers.get_xml_attr(a, 'allowSync'),
"is_restricted": helpers.get_xml_attr(a, 'restricted'),
"filter_all": helpers.get_xml_attr(a, 'filterAll'),
"filter_movies": helpers.get_xml_attr(a, 'filterMovies'),
"filter_tv": helpers.get_xml_attr(a, 'filterTelevision'),
"filter_music": helpers.get_xml_attr(a, 'filterMusic'),
"filter_photos": helpers.get_xml_attr(a, 'filterPhotos')
}
users_list.append(friend)
user_map = {}
for server in plexpy.PMS_SERVERS:
if server.CONFIG.PMS_IS_ENABLED:
shared_servers = self.get_plextv_shared_servers(
machine_id=server.CONFIG.PMS_IDENTIFIER,
output_format='xml')
try:
xml_head = shared_servers.getElementsByTagName(
'SharedServer')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: %s: Unable to parse shared server list XML for get_full_users_list: %s."
% (server.CONFIG.PMS_NAME, e))
return []
for a in xml_head:
user_id = helpers.get_xml_attr(a, 'userID')
server_token = helpers.get_xml_attr(a, 'accessToken')
sections = a.getElementsByTagName('Section')
shared_libraries = [
helpers.get_xml_attr(s, 'key') for s in sections
if helpers.get_xml_attr(s, 'shared') == '1'
]
if user_id not in user_map:
user_map[user_id] = {'shared_libraries': []}
user_map[user_id]['shared_libraries'].append({
'server_token':
server_token,
'server_id':
server.CONFIG.ID,
'shared_libraries':
shared_libraries
})
for u in users_list:
d = user_map.get(u['user_id'], {})
u.update(d)
return users_list
try:
xml_parse = minidom.parseString(own_account)
except Exception, e:
logger.warn("Error parsing XML for Plex account details: %s" % e)
return []
except:
logger.warn("Error parsing XML for Plex account details.")
return []
xml_head = xml_parse.getElementsByTagName('user')
if not xml_head:
logger.warn("Error parsing XML for Plex account details.")
else:
for a in xml_head:
own_details = {
"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'username'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_allow_sync": None,
"is_restricted": helpers.get_xml_attr(a, 'restricted')
}
users_list.append(own_details)
try:
xml_parse = minidom.parseString(friends_list)
except Exception, e:
logger.warn("Error parsing XML for Plex friends list: %s" % e)
except:
def get_connections(device):
conn = []
connections = device.getElementsByTagName('Connection')
server = {
'pms_identifier':
helpers.get_xml_attr(device, 'clientIdentifier'),
'pms_name':
helpers.get_xml_attr(device, 'name'),
'pms_version':
helpers.get_xml_attr(device, 'productVersion'),
'pms_platform':
helpers.get_xml_attr(device, 'platform'),
'pms_presence':
helpers.get_xml_attr(device, 'presence'),
'pms_is_cloud':
1 if helpers.get_xml_attr(device, 'platform') == 'Cloud' else 0
}
for c in connections:
server_details = {
'protocol': helpers.get_xml_attr(c, 'protocol'),
'address': helpers.get_xml_attr(c, 'address'),
'port': helpers.get_xml_attr(c, 'port'),
'uri': helpers.get_xml_attr(c, 'uri'),
'local': helpers.get_xml_attr(c, 'local')
}
conn.append(server_details)
server['connections'] = conn
return server
def get_synced_items(self, machine_id=None, user_id=None):
sync_list = self.get_plextv_sync_lists(machine_id)
user_data = users.Users()
synced_items = []
try:
xml_parse = minidom.parseString(sync_list)
except Exception as e:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_synced_items: %s" % e)
return []
except:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_synced_items.")
return []
xml_head = xml_parse.getElementsByTagName('SyncList')
if not xml_head:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_synced_items.")
else:
for a in xml_head:
client_id = helpers.get_xml_attr(a, 'id')
sync_device = a.getElementsByTagName('Device')
for device in sync_device:
device_user_id = helpers.get_xml_attr(device, 'userID')
try:
device_username = user_data.get_details(user_id=device_user_id)['username']
device_friendly_name = user_data.get_details(user_id=device_user_id)['friendly_name']
except:
device_username = ''
device_friendly_name = ''
device_name = helpers.get_xml_attr(device, 'name')
device_product = helpers.get_xml_attr(device, 'product')
device_product_version = helpers.get_xml_attr(device, 'productVersion')
device_platform = helpers.get_xml_attr(device, 'platform')
device_platform_version = helpers.get_xml_attr(device, 'platformVersion')
device_type = helpers.get_xml_attr(device, 'device')
device_model = helpers.get_xml_attr(device, 'model')
device_last_seen = helpers.get_xml_attr(device, 'lastSeenAt')
# Filter by user_id
if user_id and user_id != device_user_id:
continue
for synced in a.getElementsByTagName('SyncItems'):
sync_item = synced.getElementsByTagName('SyncItem')
for item in sync_item:
sync_id = helpers.get_xml_attr(item, 'id')
sync_version = helpers.get_xml_attr(item, 'version')
sync_root_title = helpers.get_xml_attr(item, 'rootTitle')
sync_title = helpers.get_xml_attr(item, 'title')
sync_metadata_type = helpers.get_xml_attr(item, 'metadataType')
sync_content_type = helpers.get_xml_attr(item, 'contentType')
for status in item.getElementsByTagName('Status'):
status_failure_code = helpers.get_xml_attr(status, 'failureCode')
status_failure = helpers.get_xml_attr(status, 'failure')
status_state = helpers.get_xml_attr(status, 'state')
status_item_count = helpers.get_xml_attr(status, 'itemsCount')
status_item_complete_count = helpers.get_xml_attr(status, 'itemsCompleteCount')
status_item_downloaded_count = helpers.get_xml_attr(status, 'itemsDownloadedCount')
status_item_ready_count = helpers.get_xml_attr(status, 'itemsReadyCount')
status_item_successful_count = helpers.get_xml_attr(status, 'itemsSuccessfulCount')
status_total_size = helpers.get_xml_attr(status, 'totalSize')
status_item_download_percent_complete = helpers.get_percent(
status_item_downloaded_count, status_item_count)
for settings in item.getElementsByTagName('MediaSettings'):
settings_audio_boost = helpers.get_xml_attr(settings, 'audioBoost')
settings_music_bitrate = helpers.get_xml_attr(settings, 'musicBitrate')
settings_photo_quality = helpers.get_xml_attr(settings, 'photoQuality')
settings_photo_resolution = helpers.get_xml_attr(settings, 'photoResolution')
settings_video_quality = helpers.get_xml_attr(settings, 'videoQuality')
settings_video_resolution = helpers.get_xml_attr(settings, 'videoResolution')
for location in item.getElementsByTagName('Location'):
clean_uri = helpers.get_xml_attr(location, 'uri').split('%2F')
rating_key = next((clean_uri[(idx + 1) % len(clean_uri)]
for idx, item in enumerate(clean_uri) if item == 'metadata'), None)
sync_details = {"device_name": helpers.sanitize(device_name),
"platform": helpers.sanitize(device_platform),
"username": helpers.sanitize(device_username),
"friendly_name": helpers.sanitize(device_friendly_name),
"user_id": device_user_id,
"root_title": helpers.sanitize(sync_root_title),
"title": helpers.sanitize(sync_title),
"metadata_type": sync_metadata_type,
"content_type": sync_content_type,
"rating_key": rating_key,
"state": status_state,
"item_count": status_item_count,
"item_complete_count": status_item_complete_count,
"item_downloaded_count": status_item_downloaded_count,
"item_downloaded_percent_complete": status_item_download_percent_complete,
"music_bitrate": settings_music_bitrate,
"photo_quality": settings_photo_quality,
"video_quality": settings_video_quality,
"total_size": status_total_size,
"failure": status_failure,
"sync_id": sync_id
}
synced_items.append(sync_details)
return synced_items
def get_session_each(self, stream_type="", session=None):
session_output = None
data_factory = datafactory.DataFactory()
if stream_type == "track":
media_info = session.getElementsByTagName("Media")[0]
audio_decision = "direct play"
audio_channels = helpers.get_xml_attr(media_info, "audioChannels")
audio_codec = helpers.get_xml_attr(media_info, "audioCodec")
container = helpers.get_xml_attr(media_info, "container")
bitrate = helpers.get_xml_attr(media_info, "bitrate")
duration = helpers.get_xml_attr(media_info, "duration")
progress = helpers.get_xml_attr(session, "viewOffset")
if session.getElementsByTagName("TranscodeSession"):
transcode_session = session.getElementsByTagName("TranscodeSession")[0]
audio_decision = helpers.get_xml_attr(transcode_session, "audioDecision")
transcode_audio_channels = helpers.get_xml_attr(transcode_session, "audioChannels")
transcode_audio_codec = helpers.get_xml_attr(transcode_session, "audioCodec")
transcode_container = helpers.get_xml_attr(transcode_session, "container")
transcode_protocol = helpers.get_xml_attr(transcode_session, "protocol")
duration = helpers.get_xml_attr(transcode_session, "duration")
else:
transcode_audio_channels = ""
transcode_audio_codec = ""
transcode_container = ""
transcode_protocol = ""
user_details = data_factory.get_user_details(
user=helpers.get_xml_attr(session.getElementsByTagName("User")[0], "title")
)
if helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "machineIdentifier").endswith("_Track"):
machine_id = helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "machineIdentifier")[:-6]
else:
machine_id = helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "machineIdentifier")
session_output = {
"session_key": helpers.get_xml_attr(session, "sessionKey"),
"media_index": helpers.get_xml_attr(session, "index"),
"parent_media_index": helpers.get_xml_attr(session, "parentIndex"),
"art": helpers.get_xml_attr(session, "art"),
"parent_thumb": helpers.get_xml_attr(session, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(session, "grandparentThumb"),
"thumb": helpers.get_xml_attr(session, "thumb"),
"bif_thumb": "",
"user": helpers.get_xml_attr(session.getElementsByTagName("User")[0], "title"),
"user_id": user_details["user_id"],
"friendly_name": user_details["friendly_name"],
"player": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "title"),
"platform": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "platform"),
"machine_id": machine_id,
"state": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "state"),
"grandparent_title": helpers.get_xml_attr(session, "grandparentTitle"),
"parent_title": helpers.get_xml_attr(session, "parentTitle"),
"title": helpers.get_xml_attr(session, "title"),
"rating_key": helpers.get_xml_attr(session, "ratingKey"),
"parent_rating_key": helpers.get_xml_attr(session, "parentRatingKey"),
"grandparent_rating_key": helpers.get_xml_attr(session, "grandparentRatingKey"),
"audio_decision": audio_decision,
"audio_channels": audio_channels,
"audio_codec": audio_codec,
"video_decision": "",
"video_codec": "",
"height": "",
"width": "",
"container": container,
"bitrate": bitrate,
"video_resolution": "",
"video_framerate": "",
"aspect_ratio": "",
"transcode_audio_channels": transcode_audio_channels,
"transcode_audio_codec": transcode_audio_codec,
"transcode_video_codec": "",
"transcode_width": "",
"transcode_height": "",
"transcode_container": transcode_container,
"transcode_protocol": transcode_protocol,
"duration": duration,
"progress": progress,
"progress_percent": str(helpers.get_percent(progress, duration)),
"type": "track",
"indexes": 0,
}
elif stream_type == "video":
media_info = session.getElementsByTagName("Media")[0]
audio_decision = "direct play"
audio_channels = helpers.get_xml_attr(media_info, "audioChannels")
audio_codec = helpers.get_xml_attr(media_info, "audioCodec")
video_decision = "direct play"
video_codec = helpers.get_xml_attr(media_info, "videoCodec")
container = helpers.get_xml_attr(media_info, "container")
bitrate = helpers.get_xml_attr(media_info, "bitrate")
video_resolution = helpers.get_xml_attr(media_info, "videoResolution")
video_framerate = helpers.get_xml_attr(media_info, "videoFrameRate")
aspect_ratio = helpers.get_xml_attr(media_info, "aspectRatio")
width = helpers.get_xml_attr(media_info, "width")
height = helpers.get_xml_attr(media_info, "height")
duration = helpers.get_xml_attr(media_info, "duration")
progress = helpers.get_xml_attr(session, "viewOffset")
if session.getElementsByTagName("TranscodeSession"):
transcode_session = session.getElementsByTagName("TranscodeSession")[0]
audio_decision = helpers.get_xml_attr(transcode_session, "audioDecision")
transcode_audio_channels = helpers.get_xml_attr(transcode_session, "audioChannels")
transcode_audio_codec = helpers.get_xml_attr(transcode_session, "audioCodec")
video_decision = helpers.get_xml_attr(transcode_session, "videoDecision")
transcode_video_codec = helpers.get_xml_attr(transcode_session, "videoCodec")
transcode_width = helpers.get_xml_attr(transcode_session, "width")
transcode_height = helpers.get_xml_attr(transcode_session, "height")
transcode_container = helpers.get_xml_attr(transcode_session, "container")
transcode_protocol = helpers.get_xml_attr(transcode_session, "protocol")
else:
transcode_audio_channels = ""
transcode_audio_codec = ""
transcode_video_codec = ""
transcode_width = ""
transcode_height = ""
transcode_container = ""
transcode_protocol = ""
media_info = session.getElementsByTagName("Media")[0]
if media_info.getElementsByTagName("Part"):
indexes = helpers.get_xml_attr(media_info.getElementsByTagName("Part")[0], "indexes")
part_id = helpers.get_xml_attr(media_info.getElementsByTagName("Part")[0], "id")
if indexes == "sd":
bif_thumb = "/library/parts/" + part_id + "/indexes/sd/" + progress
else:
bif_thumb = ""
else:
indexes = ""
bif_thumb = ""
if plexpy.CONFIG.PMS_USE_BIF and indexes == "sd":
use_indexes = 1
else:
use_indexes = 0
user_details = data_factory.get_user_details(
user=helpers.get_xml_attr(session.getElementsByTagName("User")[0], "title")
)
if helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "machineIdentifier").endswith("_Video"):
machine_id = helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "machineIdentifier")[:-6]
else:
machine_id = helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "machineIdentifier")
if helpers.get_xml_attr(session, "type") == "episode":
session_output = {
"session_key": helpers.get_xml_attr(session, "sessionKey"),
"media_index": helpers.get_xml_attr(session, "index"),
"parent_media_index": helpers.get_xml_attr(session, "parentIndex"),
"art": helpers.get_xml_attr(session, "art"),
"parent_thumb": helpers.get_xml_attr(session, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(session, "grandparentThumb"),
"thumb": helpers.get_xml_attr(session, "thumb"),
"bif_thumb": bif_thumb,
"user": helpers.get_xml_attr(session.getElementsByTagName("User")[0], "title"),
"user_id": user_details["user_id"],
"friendly_name": user_details["friendly_name"],
"player": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "title"),
"platform": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "platform"),
"machine_id": machine_id,
"state": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "state"),
"grandparent_title": helpers.get_xml_attr(session, "grandparentTitle"),
"parent_title": helpers.get_xml_attr(session, "parentTitle"),
"title": helpers.get_xml_attr(session, "title"),
"rating_key": helpers.get_xml_attr(session, "ratingKey"),
"parent_rating_key": helpers.get_xml_attr(session, "parentRatingKey"),
"grandparent_rating_key": helpers.get_xml_attr(session, "grandparentRatingKey"),
"audio_decision": audio_decision,
"audio_channels": audio_channels,
"audio_codec": audio_codec,
"video_decision": video_decision,
"video_codec": video_codec,
"height": height,
"width": width,
"container": container,
"bitrate": bitrate,
"video_resolution": video_resolution,
"video_framerate": video_framerate,
"aspect_ratio": aspect_ratio,
"transcode_audio_channels": transcode_audio_channels,
"transcode_audio_codec": transcode_audio_codec,
"transcode_video_codec": transcode_video_codec,
"transcode_width": transcode_width,
"transcode_height": transcode_height,
"transcode_container": transcode_container,
"transcode_protocol": transcode_protocol,
"duration": duration,
"progress": progress,
"progress_percent": str(helpers.get_percent(progress, duration)),
"type": helpers.get_xml_attr(session, "type"),
"indexes": use_indexes,
}
elif helpers.get_xml_attr(session, "type") == "movie":
session_output = {
"session_key": helpers.get_xml_attr(session, "sessionKey"),
"media_index": helpers.get_xml_attr(session, "index"),
"parent_media_index": helpers.get_xml_attr(session, "parentIndex"),
"art": helpers.get_xml_attr(session, "art"),
"thumb": helpers.get_xml_attr(session, "thumb"),
"bif_thumb": bif_thumb,
"parent_thumb": helpers.get_xml_attr(session, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(session, "grandparentThumb"),
"user": helpers.get_xml_attr(session.getElementsByTagName("User")[0], "title"),
"user_id": user_details["user_id"],
"friendly_name": user_details["friendly_name"],
"player": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "title"),
"platform": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "platform"),
"machine_id": machine_id,
"state": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "state"),
"grandparent_title": helpers.get_xml_attr(session, "grandparentTitle"),
"parent_title": helpers.get_xml_attr(session, "parentTitle"),
"title": helpers.get_xml_attr(session, "title"),
"rating_key": helpers.get_xml_attr(session, "ratingKey"),
"parent_rating_key": helpers.get_xml_attr(session, "parentRatingKey"),
"grandparent_rating_key": helpers.get_xml_attr(session, "grandparentRatingKey"),
"audio_decision": audio_decision,
"audio_channels": audio_channels,
"audio_codec": audio_codec,
"video_decision": video_decision,
"video_codec": video_codec,
"height": height,
"width": width,
"container": container,
"bitrate": bitrate,
"video_resolution": video_resolution,
"video_framerate": video_framerate,
"aspect_ratio": aspect_ratio,
"transcode_audio_channels": transcode_audio_channels,
"transcode_audio_codec": transcode_audio_codec,
"transcode_video_codec": transcode_video_codec,
"transcode_width": transcode_width,
"transcode_height": transcode_height,
"transcode_container": transcode_container,
"transcode_protocol": transcode_protocol,
"duration": duration,
"progress": progress,
"progress_percent": str(helpers.get_percent(progress, duration)),
"type": helpers.get_xml_attr(session, "type"),
"indexes": use_indexes,
}
elif helpers.get_xml_attr(session, "type") == "clip":
session_output = {
"session_key": helpers.get_xml_attr(session, "sessionKey"),
"media_index": helpers.get_xml_attr(session, "index"),
"parent_media_index": helpers.get_xml_attr(session, "parentIndex"),
"art": helpers.get_xml_attr(session, "art"),
"thumb": helpers.get_xml_attr(session, "thumb"),
"bif_thumb": bif_thumb,
"parent_thumb": helpers.get_xml_attr(session, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(session, "grandparentThumb"),
"user": helpers.get_xml_attr(session.getElementsByTagName("User")[0], "title"),
"user_id": user_details["user_id"],
"friendly_name": user_details["friendly_name"],
"player": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "title"),
"platform": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "platform"),
"machine_id": machine_id,
"state": helpers.get_xml_attr(session.getElementsByTagName("Player")[0], "state"),
"grandparent_title": helpers.get_xml_attr(session, "grandparentTitle"),
"parent_title": helpers.get_xml_attr(session, "parentTitle"),
"title": helpers.get_xml_attr(session, "title"),
"rating_key": helpers.get_xml_attr(session, "ratingKey"),
"parent_rating_key": helpers.get_xml_attr(session, "parentRatingKey"),
"grandparent_rating_key": helpers.get_xml_attr(session, "grandparentRatingKey"),
"audio_decision": audio_decision,
"audio_channels": audio_channels,
"audio_codec": audio_codec,
"video_decision": video_decision,
"video_codec": video_codec,
"height": height,
"width": width,
"container": container,
"bitrate": bitrate,
"video_resolution": video_resolution,
"video_framerate": video_framerate,
"aspect_ratio": aspect_ratio,
"transcode_audio_channels": transcode_audio_channels,
"transcode_audio_codec": transcode_audio_codec,
"transcode_video_codec": transcode_video_codec,
"transcode_width": transcode_width,
"transcode_height": transcode_height,
"transcode_container": transcode_container,
"transcode_protocol": transcode_protocol,
"duration": duration,
"progress": progress,
"progress_percent": str(helpers.get_percent(progress, duration)),
"type": helpers.get_xml_attr(session, "type"),
"indexes": 0,
}
else:
logger.warn(u"No known stream types found in session list.")
return session_output
def extract_plexwatch_xml(xml=None):
output = {}
clean_xml = helpers.latinToAscii(xml)
try:
xml_parse = minidom.parseString(clean_xml)
except:
logger.warn(u"PlexPy Importer :: Error parsing XML for Plexwatch database.")
return None
xml_head = xml_parse.getElementsByTagName('opt')
if not xml_head:
logger.warn(u"PlexPy Importer :: Error parsing XML for Plexwatch database.")
return None
for a in xml_head:
added_at = helpers.get_xml_attr(a, 'addedAt')
art = helpers.get_xml_attr(a, 'art')
duration = helpers.get_xml_attr(a, 'duration')
grandparent_thumb = helpers.get_xml_attr(a, 'grandparentThumb')
grandparent_title = helpers.get_xml_attr(a, 'grandparentTitle')
guid = helpers.get_xml_attr(a, 'guid')
section_id = helpers.get_xml_attr(a, 'librarySectionID')
media_index = helpers.get_xml_attr(a, 'index')
originally_available_at = helpers.get_xml_attr(a, 'originallyAvailableAt')
last_viewed_at = helpers.get_xml_attr(a, 'lastViewedAt')
parent_media_index = helpers.get_xml_attr(a, 'parentIndex')
parent_thumb = helpers.get_xml_attr(a, 'parentThumb')
rating = helpers.get_xml_attr(a, 'rating')
thumb = helpers.get_xml_attr(a, 'thumb')
media_type = helpers.get_xml_attr(a, 'type')
updated_at = helpers.get_xml_attr(a, 'updatedAt')
view_offset = helpers.get_xml_attr(a, 'viewOffset')
year = helpers.get_xml_attr(a, 'year')
parent_title = helpers.get_xml_attr(a, 'parentTitle')
studio = helpers.get_xml_attr(a, 'studio')
title = helpers.get_xml_attr(a, 'title')
tagline = helpers.get_xml_attr(a, 'tagline')
directors = []
if a.getElementsByTagName('Director'):
director_elem = a.getElementsByTagName('Director')
for b in director_elem:
directors.append(helpers.get_xml_attr(b, 'tag'))
aspect_ratio = ''
audio_channels = None
audio_codec = ''
bitrate = None
container = ''
height = None
video_codec = ''
video_framerate = ''
video_resolution = ''
width = None
if a.getElementsByTagName('Media'):
media_elem = a.getElementsByTagName('Media')
for c in media_elem:
aspect_ratio = helpers.get_xml_attr(c, 'aspectRatio')
audio_channels = helpers.get_xml_attr(c, 'audioChannels')
audio_codec = helpers.get_xml_attr(c, 'audioCodec')
bitrate = helpers.get_xml_attr(c, 'bitrate')
container = helpers.get_xml_attr(c, 'container')
height = helpers.get_xml_attr(c, 'height')
video_codec = helpers.get_xml_attr(c, 'videoCodec')
video_framerate = helpers.get_xml_attr(c, 'videoFrameRate')
video_resolution = helpers.get_xml_attr(c, 'videoResolution')
width = helpers.get_xml_attr(c, 'width')
machine_id = ''
platform = ''
player = ''
if a.getElementsByTagName('Player'):
player_elem = a.getElementsByTagName('Player')
for d in player_elem:
machine_id = helpers.get_xml_attr(d, 'machineIdentifier')
platform = helpers.get_xml_attr(d, 'platform')
player = helpers.get_xml_attr(d, 'title')
transcode_audio_channels = None
transcode_audio_codec = ''
audio_decision = 'direct play'
transcode_container = ''
transcode_height = None
transcode_protocol = ''
transcode_video_codec = ''
video_decision = 'direct play'
transcode_width = None
if a.getElementsByTagName('TranscodeSession'):
transcode_elem = a.getElementsByTagName('TranscodeSession')
for e in transcode_elem:
transcode_audio_channels = helpers.get_xml_attr(e, 'audioChannels')
transcode_audio_codec = helpers.get_xml_attr(e, 'audioCodec')
audio_decision = helpers.get_xml_attr(e, 'audioDecision')
transcode_container = helpers.get_xml_attr(e, 'container')
transcode_height = helpers.get_xml_attr(e, 'height')
transcode_protocol = helpers.get_xml_attr(e, 'protocol')
transcode_video_codec = helpers.get_xml_attr(e, 'videoCodec')
video_decision = helpers.get_xml_attr(e, 'videoDecision')
transcode_width = helpers.get_xml_attr(e, 'width')
user_id = None
if a.getElementsByTagName('User'):
user_elem = a.getElementsByTagName('User')
for f in user_elem:
user_id = helpers.get_xml_attr(f, 'id')
writers = []
if a.getElementsByTagName('Writer'):
writer_elem = a.getElementsByTagName('Writer')
for g in writer_elem:
writers.append(helpers.get_xml_attr(g, 'tag'))
actors = []
if a.getElementsByTagName('Role'):
actor_elem = a.getElementsByTagName('Role')
for h in actor_elem:
actors.append(helpers.get_xml_attr(h, 'tag'))
genres = []
if a.getElementsByTagName('Genre'):
genre_elem = a.getElementsByTagName('Genre')
for i in genre_elem:
genres.append(helpers.get_xml_attr(i, 'tag'))
output = {'added_at': added_at,
'art': art,
'duration': duration,
'grandparent_thumb': grandparent_thumb,
'grandparent_title': grandparent_title,
'parent_title': parent_title,
'title': title,
'tagline': tagline,
'guid': guid,
'section_id': section_id,
'media_index': media_index,
'originally_available_at': originally_available_at,
'last_viewed_at': last_viewed_at,
'parent_media_index': parent_media_index,
'parent_thumb': parent_thumb,
'rating': rating,
'thumb': thumb,
'media_type': media_type,
'updated_at': updated_at,
'view_offset': view_offset,
'year': year,
'directors': directors,
'aspect_ratio': aspect_ratio,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'bitrate': bitrate,
'container': container,
'height': height,
'video_codec': video_codec,
'video_framerate': video_framerate,
'video_resolution': video_resolution,
'width': width,
'machine_id': machine_id,
'platform': platform,
'player': player,
'transcode_audio_channels': transcode_audio_channels,
'transcode_audio_codec': transcode_audio_codec,
'audio_decision': audio_decision,
'transcode_container': transcode_container,
'transcode_height': transcode_height,
'transcode_protocol': transcode_protocol,
'transcode_video_codec': transcode_video_codec,
'video_decision': video_decision,
'transcode_width': transcode_width,
'user_id': user_id,
'writers': writers,
'actors': actors,
'genres': genres,
'studio': studio
}
return output
def get_server_connections(self,
pms_identifier='',
pms_ip='',
pms_port=32400,
include_https=True):
if not pms_identifier:
logger.error(
u"Tautulli PlexTV :: Unable to retrieve server connections: no pms_identifier provided."
)
return {}
plextv_resources = self.get_plextv_resources(
include_https=include_https, output_format='xml')
try:
xml_head = plextv_resources.getElementsByTagName('Device')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_server_urls: %s."
% e)
return {}
# Function to get all connections for a device
def get_connections(device):
conn = []
connections = device.getElementsByTagName('Connection')
server = {
'pms_identifier':
helpers.get_xml_attr(device, 'clientIdentifier'),
'pms_name':
helpers.get_xml_attr(device, 'name'),
'pms_version':
helpers.get_xml_attr(device, 'productVersion'),
'pms_platform':
helpers.get_xml_attr(device, 'platform'),
'pms_presence':
helpers.get_xml_attr(device, 'presence'),
'pms_is_cloud':
1 if helpers.get_xml_attr(device, 'platform') == 'Cloud' else 0
}
for c in connections:
server_details = {
'protocol': helpers.get_xml_attr(c, 'protocol'),
'address': helpers.get_xml_attr(c, 'address'),
'port': helpers.get_xml_attr(c, 'port'),
'uri': helpers.get_xml_attr(c, 'uri'),
'local': helpers.get_xml_attr(c, 'local')
}
conn.append(server_details)
server['connections'] = conn
return server
server = {}
# Try to match the device
for a in xml_head:
if helpers.get_xml_attr(a, 'clientIdentifier') == pms_identifier:
server = get_connections(a)
break
# Else no device match found
if not server:
# Try to match the PMS_IP and PMS_PORT
for a in xml_head:
if helpers.get_xml_attr(a, 'provides') == 'server':
connections = a.getElementsByTagName('Connection')
for connection in connections:
if helpers.get_xml_attr(connection, 'address') == pms_ip and \
helpers.get_xml_attr(connection, 'port') == str(pms_port):
server = get_connections(a)
break
if server.get('connections'):
break
return server
def get_devices_list(self):
devices = self.get_plextv_devices_list(output_format='xml')
try:
xml_head = devices.getElementsByTagName('Device')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_devices_list: %s."
% e)
return []
devices_list = []
for a in xml_head:
device = {
"device_name": helpers.get_xml_attr(a, 'name'),
"product": helpers.get_xml_attr(a, 'product'),
"product_version": helpers.get_xml_attr(a, 'productVersion'),
"platform": helpers.get_xml_attr(a, 'platform'),
"platform_version": helpers.get_xml_attr(a, 'platformVersion'),
"device": helpers.get_xml_attr(a, 'device'),
"model": helpers.get_xml_attr(a, 'model'),
"vendor": helpers.get_xml_attr(a, 'vendor'),
"provides": helpers.get_xml_attr(a, 'provides'),
"device_identifier":
helpers.get_xml_attr(a, 'clientIdentifier'),
"device_id": helpers.get_xml_attr(a, 'id'),
"token": helpers.get_xml_attr(a, 'token')
}
devices_list.append(device)
return devices_list
def get_server_urls(self, include_https=True):
if plexpy.CONFIG.PMS_IDENTIFIER:
server_id = plexpy.CONFIG.PMS_IDENTIFIER
else:
logger.error(
u"PlexPy PlexTV :: Unable to retrieve server identity.")
return []
plextv_resources = self.get_plextv_resources(
include_https=include_https)
try:
xml_parse = minidom.parseString(plextv_resources)
except Exception as e:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_server_urls: %s"
% e)
return []
except:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_server_urls.")
return []
try:
xml_head = xml_parse.getElementsByTagName('Device')
except Exception as e:
logger.warn(
u"PlexPy PlexTV :: Unable to parse XML for get_server_urls: %s."
% e)
return []
# Function to get all connections for a device
def get_connections(device):
conn = []
connections = device.getElementsByTagName('Connection')
for c in connections:
server_details = {
"protocol": helpers.get_xml_attr(c, 'protocol'),
"address": helpers.get_xml_attr(c, 'address'),
"port": helpers.get_xml_attr(c, 'port'),
"uri": helpers.get_xml_attr(c, 'uri'),
"local": helpers.get_xml_attr(c, 'local')
}
conn.append(server_details)
return conn
server_urls = []
# Try to match the device
for a in xml_head:
if helpers.get_xml_attr(a, 'clientIdentifier') == server_id:
server_urls = get_connections(a)
break
# Else no device match found
if not server_urls:
# Try to match the PMS_IP and PMS_PORT
for a in xml_head:
if helpers.get_xml_attr(a, 'provides') == 'server':
connections = a.getElementsByTagName('Connection')
for connection in connections:
if helpers.get_xml_attr(connection, 'address') == plexpy.CONFIG.PMS_IP and \
int(helpers.get_xml_attr(connection, 'port')) == plexpy.CONFIG.PMS_PORT:
plexpy.CONFIG.PMS_IDENTIFIER = helpers.get_xml_attr(
a, 'clientIdentifier')
plexpy.CONFIG.write()
logger.info(u"PlexPy PlexTV :: PMS identifier changed from %s to %s." % \
(server_id, plexpy.CONFIG.PMS_IDENTIFIER))
server_urls = get_connections(a)
break
if server_urls:
break
return server_urls
def get_synced_items(self,
machine_id=None,
client_id_filter=None,
user_id_filter=None,
rating_key_filter=None,
sync_id_filter=None,
server_id_filter=None):
if isinstance(rating_key_filter, list):
rating_key_filter = [str(k) for k in rating_key_filter]
elif rating_key_filter:
rating_key_filter = [str(rating_key_filter)]
if isinstance(user_id_filter, list):
user_id_filter = [str(k) for k in user_id_filter]
elif user_id_filter:
user_id_filter = [str(user_id_filter)]
user_data = users.Users()
synced_items = []
for server in plexpy.PMS_SERVERS:
if server_id_filter and int(server_id_filter) != server.CONFIG.ID:
continue
if not session.allow_session_server(server.CONFIG.ID):
continue
machine_id = server.CONFIG.PMS_IDENTIFIER
sync_list = self.get_plextv_sync_lists(machine_id,
output_format='xml')
try:
xml_head = sync_list.getElementsByTagName('SyncList')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_synced_items: %s."
% e)
return {}
for a in xml_head:
client_id = helpers.get_xml_attr(a, 'clientIdentifier')
# Filter by client_id
if client_id_filter and str(client_id_filter) != client_id:
continue
sync_list_id = helpers.get_xml_attr(a, 'id')
sync_device = a.getElementsByTagName('Device')
for device in sync_device:
device_user_id = helpers.get_xml_attr(device, 'userID')
try:
device_username = user_data.get_details(
user_id=device_user_id)['username']
device_friendly_name = user_data.get_details(
user_id=device_user_id)['friendly_name']
except:
device_username = ''
device_friendly_name = ''
device_name = helpers.get_xml_attr(device, 'name')
device_product = helpers.get_xml_attr(device, 'product')
device_product_version = helpers.get_xml_attr(
device, 'productVersion')
device_platform = helpers.get_xml_attr(device, 'platform')
device_platform_version = helpers.get_xml_attr(
device, 'platformVersion')
device_type = helpers.get_xml_attr(device, 'device')
device_model = helpers.get_xml_attr(device, 'model')
device_last_seen = helpers.get_xml_attr(
device, 'lastSeenAt')
# Filter by user_id
if user_id_filter and device_user_id not in user_id_filter:
continue
for synced in a.getElementsByTagName('SyncItems'):
sync_item = synced.getElementsByTagName('SyncItem')
for item in sync_item:
for location in item.getElementsByTagName('Location'):
clean_uri = helpers.get_xml_attr(
location, 'uri').split('%2F')
rating_key = next(
(clean_uri[(idx + 1) % len(clean_uri)]
for idx, item in enumerate(clean_uri)
if item == 'metadata'), None)
# Filter by rating_key
if rating_key_filter and rating_key not in rating_key_filter:
continue
sync_id = helpers.get_xml_attr(item, 'id')
# Filter by sync_id
if sync_id_filter and str(sync_id_filter) != sync_id:
continue
sync_version = helpers.get_xml_attr(item, 'version')
sync_root_title = helpers.get_xml_attr(
item, 'rootTitle')
sync_title = helpers.get_xml_attr(item, 'title')
sync_metadata_type = helpers.get_xml_attr(
item, 'metadataType')
sync_content_type = helpers.get_xml_attr(
item, 'contentType')
for status in item.getElementsByTagName('Status'):
status_failure_code = helpers.get_xml_attr(
status, 'failureCode')
status_failure = helpers.get_xml_attr(
status, 'failure')
status_state = helpers.get_xml_attr(
status, 'state')
status_item_count = helpers.get_xml_attr(
status, 'itemsCount')
status_item_complete_count = helpers.get_xml_attr(
status, 'itemsCompleteCount')
status_item_downloaded_count = helpers.get_xml_attr(
status, 'itemsDownloadedCount')
status_item_ready_count = helpers.get_xml_attr(
status, 'itemsReadyCount')
status_item_successful_count = helpers.get_xml_attr(
status, 'itemsSuccessfulCount')
status_total_size = helpers.get_xml_attr(
status, 'totalSize')
status_item_download_percent_complete = helpers.get_percent(
status_item_downloaded_count,
status_item_count)
for settings in item.getElementsByTagName(
'MediaSettings'):
settings_video_bitrate = helpers.get_xml_attr(
settings, 'maxVideoBitrate')
settings_video_quality = helpers.get_xml_attr(
settings, 'videoQuality')
settings_video_resolution = helpers.get_xml_attr(
settings, 'videoResolution')
settings_audio_boost = helpers.get_xml_attr(
settings, 'audioBoost')
settings_audio_bitrate = helpers.get_xml_attr(
settings, 'musicBitrate')
settings_photo_quality = helpers.get_xml_attr(
settings, 'photoQuality')
settings_photo_resolution = helpers.get_xml_attr(
settings, 'photoResolution')
sync_details = {
"device_name": helpers.sanitize(device_name),
"server_id": server.CONFIG.ID,
"server_name": server.CONFIG.PMS_NAME,
"platform": helpers.sanitize(device_platform),
"user_id": device_user_id,
"user": helpers.sanitize(device_friendly_name),
"username": helpers.sanitize(device_username),
"root_title": helpers.sanitize(sync_root_title),
"sync_title": helpers.sanitize(sync_title),
"metadata_type": sync_metadata_type,
"content_type": sync_content_type,
"rating_key": rating_key,
"state": status_state,
"item_count": status_item_count,
"item_complete_count": status_item_complete_count,
"item_downloaded_count":
status_item_downloaded_count,
"item_downloaded_percent_complete":
status_item_download_percent_complete,
"video_bitrate": settings_video_bitrate,
"audio_bitrate": settings_audio_bitrate,
"photo_quality": settings_photo_quality,
"video_quality": settings_video_quality,
"total_size": status_total_size,
"failure": status_failure,
"client_id": client_id,
"sync_id": sync_id
}
synced_items.append(sync_details)
return session.filter_session_info(synced_items, filter_key='user_id')
try:
xml_parse = minidom.parseString(own_account)
except Exception, e:
logger.warn("Error parsing XML for Plex account details: %s" % e)
return []
except:
logger.warn("Error parsing XML for Plex account details.")
return []
xml_head = xml_parse.getElementsByTagName("user")
if not xml_head:
logger.warn("Error parsing XML for Plex account details.")
else:
for a in xml_head:
own_details = {
"user_id": helpers.get_xml_attr(a, "id"),
"username": helpers.get_xml_attr(a, "username"),
"thumb": helpers.get_xml_attr(a, "thumb"),
"email": helpers.get_xml_attr(a, "email"),
"is_home_user": helpers.get_xml_attr(a, "home"),
"is_allow_sync": None,
"is_restricted": helpers.get_xml_attr(a, "restricted"),
}
users_list.append(own_details)
try:
xml_parse = minidom.parseString(friends_list)
except Exception, e:
logger.warn("Error parsing XML for Plex friends list: %s" % e)
except:
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 discover(self):
""" Query plex for all servers online. Returns the ones you own in a selectize format """
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"PlexPy 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':
connections = d.getElementsByTagName('Connection')
for c in connections:
# 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 = {
'httpsRequired':
helpers.get_xml_attr(d, 'httpsRequired'),
'clientIdentifier':
helpers.get_xml_attr(d, 'clientIdentifier'),
'label':
helpers.get_xml_attr(d, 'name'),
'ip':
helpers.get_xml_attr(c, 'address'),
'port':
helpers.get_xml_attr(c, 'port'),
'local':
helpers.get_xml_attr(c, 'local'),
'value':
helpers.get_xml_attr(c, 'address')
}
clean_servers.append(server)
return clean_servers
def get_metadata_details(self, rating_key=""):
metadata = self.get_metadata(rating_key, output_format="xml")
try:
xml_head = metadata.getElementsByTagName("MediaContainer")
except:
logger.warn("Unable to parse XML for get_metadata.")
return []
metadata_list = []
for a in xml_head:
if a.getAttribute("size"):
if a.getAttribute("size") != "1":
metadata_list = {"metadata": None}
return metadata_list
if a.getElementsByTagName("Directory"):
metadata_main = a.getElementsByTagName("Directory")[0]
metadata_type = helpers.get_xml_attr(metadata_main, "type")
elif a.getElementsByTagName("Video"):
metadata_main = a.getElementsByTagName("Video")[0]
metadata_type = helpers.get_xml_attr(metadata_main, "type")
elif a.getElementsByTagName("Track"):
metadata_main = a.getElementsByTagName("Track")[0]
metadata_type = helpers.get_xml_attr(metadata_main, "type")
else:
logger.debug(u"Metadata failed")
genres = []
actors = []
writers = []
directors = []
if metadata_main.getElementsByTagName("Genre"):
for genre in metadata_main.getElementsByTagName("Genre"):
genres.append(helpers.get_xml_attr(genre, "tag"))
if metadata_main.getElementsByTagName("Role"):
for actor in metadata_main.getElementsByTagName("Role"):
actors.append(helpers.get_xml_attr(actor, "tag"))
if metadata_main.getElementsByTagName("Writer"):
for writer in metadata_main.getElementsByTagName("Writer"):
writers.append(helpers.get_xml_attr(writer, "tag"))
if metadata_main.getElementsByTagName("Director"):
for director in metadata_main.getElementsByTagName("Director"):
directors.append(helpers.get_xml_attr(director, "tag"))
if metadata_type == "show":
metadata = {
"type": metadata_type,
"rating_key": helpers.get_xml_attr(metadata_main, "ratingKey"),
"grandparent_title": helpers.get_xml_attr(metadata_main, "grandparentTitle"),
"parent_index": helpers.get_xml_attr(metadata_main, "parentIndex"),
"parent_title": helpers.get_xml_attr(metadata_main, "parentTitle"),
"index": helpers.get_xml_attr(metadata_main, "index"),
"studio": helpers.get_xml_attr(metadata_main, "studio"),
"title": helpers.get_xml_attr(metadata_main, "title"),
"content_rating": helpers.get_xml_attr(metadata_main, "contentRating"),
"summary": helpers.get_xml_attr(metadata_main, "summary"),
"rating": helpers.get_xml_attr(metadata_main, "rating"),
"duration": helpers.get_xml_attr(metadata_main, "duration"),
"year": helpers.get_xml_attr(metadata_main, "year"),
"thumb": helpers.get_xml_attr(metadata_main, "thumb"),
"parent_thumb": helpers.get_xml_attr(metadata_main, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(metadata_main, "grandparentThumb"),
"art": helpers.get_xml_attr(metadata_main, "art"),
"originally_available_at": helpers.get_xml_attr(metadata_main, "originallyAvailableAt"),
"added_at": helpers.get_xml_attr(metadata_main, "addedAt"),
"updated_at": helpers.get_xml_attr(metadata_main, "updatedAt"),
"last_viewed_at": helpers.get_xml_attr(metadata_main, "lastViewedAt"),
"guid": helpers.get_xml_attr(metadata_main, "guid"),
"writers": writers,
"directors": directors,
"genres": genres,
"actors": actors,
}
metadata_list = {"metadata": metadata}
elif metadata_type == "episode":
metadata = {
"type": metadata_type,
"rating_key": helpers.get_xml_attr(metadata_main, "ratingKey"),
"grandparent_title": helpers.get_xml_attr(metadata_main, "grandparentTitle"),
"parent_index": helpers.get_xml_attr(metadata_main, "parentIndex"),
"parent_title": helpers.get_xml_attr(metadata_main, "parentTitle"),
"index": helpers.get_xml_attr(metadata_main, "index"),
"studio": helpers.get_xml_attr(metadata_main, "studio"),
"title": helpers.get_xml_attr(metadata_main, "title"),
"content_rating": helpers.get_xml_attr(metadata_main, "contentRating"),
"summary": helpers.get_xml_attr(metadata_main, "summary"),
"rating": helpers.get_xml_attr(metadata_main, "rating"),
"duration": helpers.get_xml_attr(metadata_main, "duration"),
"year": helpers.get_xml_attr(metadata_main, "year"),
"thumb": helpers.get_xml_attr(metadata_main, "thumb"),
"parent_thumb": helpers.get_xml_attr(metadata_main, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(metadata_main, "grandparentThumb"),
"art": helpers.get_xml_attr(metadata_main, "art"),
"originally_available_at": helpers.get_xml_attr(metadata_main, "originallyAvailableAt"),
"added_at": helpers.get_xml_attr(metadata_main, "addedAt"),
"updated_at": helpers.get_xml_attr(metadata_main, "updatedAt"),
"last_viewed_at": helpers.get_xml_attr(metadata_main, "lastViewedAt"),
"guid": helpers.get_xml_attr(metadata_main, "guid"),
"writers": writers,
"directors": directors,
"genres": genres,
"actors": actors,
}
metadata_list = {"metadata": metadata}
elif metadata_type == "movie":
metadata = {
"type": metadata_type,
"rating_key": helpers.get_xml_attr(metadata_main, "ratingKey"),
"grandparent_title": helpers.get_xml_attr(metadata_main, "grandparentTitle"),
"parent_index": helpers.get_xml_attr(metadata_main, "parentIndex"),
"parent_title": helpers.get_xml_attr(metadata_main, "parentTitle"),
"index": helpers.get_xml_attr(metadata_main, "index"),
"studio": helpers.get_xml_attr(metadata_main, "studio"),
"title": helpers.get_xml_attr(metadata_main, "title"),
"content_rating": helpers.get_xml_attr(metadata_main, "contentRating"),
"summary": helpers.get_xml_attr(metadata_main, "summary"),
"rating": helpers.get_xml_attr(metadata_main, "rating"),
"duration": helpers.get_xml_attr(metadata_main, "duration"),
"year": helpers.get_xml_attr(metadata_main, "year"),
"thumb": helpers.get_xml_attr(metadata_main, "thumb"),
"parent_thumb": helpers.get_xml_attr(metadata_main, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(metadata_main, "grandparentThumb"),
"art": helpers.get_xml_attr(metadata_main, "art"),
"originally_available_at": helpers.get_xml_attr(metadata_main, "originallyAvailableAt"),
"added_at": helpers.get_xml_attr(metadata_main, "addedAt"),
"updated_at": helpers.get_xml_attr(metadata_main, "updatedAt"),
"last_viewed_at": helpers.get_xml_attr(metadata_main, "lastViewedAt"),
"guid": helpers.get_xml_attr(metadata_main, "guid"),
"genres": genres,
"actors": actors,
"writers": writers,
"directors": directors,
}
metadata_list = {"metadata": metadata}
elif metadata_type == "season":
parent_rating_key = helpers.get_xml_attr(metadata_main, "parentRatingKey")
show_details = self.get_metadata_details(parent_rating_key)
metadata = {
"type": metadata_type,
"rating_key": helpers.get_xml_attr(metadata_main, "ratingKey"),
"grandparent_title": helpers.get_xml_attr(metadata_main, "grandparentTitle"),
"parent_index": helpers.get_xml_attr(metadata_main, "parentIndex"),
"parent_title": helpers.get_xml_attr(metadata_main, "parentTitle"),
"index": helpers.get_xml_attr(metadata_main, "index"),
"studio": helpers.get_xml_attr(metadata_main, "studio"),
"title": helpers.get_xml_attr(metadata_main, "title"),
"content_rating": helpers.get_xml_attr(metadata_main, "contentRating"),
"summary": show_details["metadata"]["summary"],
"rating": helpers.get_xml_attr(metadata_main, "rating"),
"duration": show_details["metadata"]["duration"],
"year": helpers.get_xml_attr(metadata_main, "year"),
"thumb": helpers.get_xml_attr(metadata_main, "thumb"),
"parent_thumb": helpers.get_xml_attr(metadata_main, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(metadata_main, "grandparentThumb"),
"art": helpers.get_xml_attr(metadata_main, "art"),
"originally_available_at": helpers.get_xml_attr(metadata_main, "originallyAvailableAt"),
"added_at": helpers.get_xml_attr(metadata_main, "addedAt"),
"updated_at": helpers.get_xml_attr(metadata_main, "updatedAt"),
"last_viewed_at": helpers.get_xml_attr(metadata_main, "lastViewedAt"),
"guid": helpers.get_xml_attr(metadata_main, "guid"),
"genres": genres,
"actors": actors,
"writers": writers,
"directors": directors,
}
metadata_list = {"metadata": metadata}
elif metadata_type == "track":
metadata = {
"type": metadata_type,
"rating_key": helpers.get_xml_attr(metadata_main, "ratingKey"),
"grandparent_title": helpers.get_xml_attr(metadata_main, "grandparentTitle"),
"parent_index": helpers.get_xml_attr(metadata_main, "parentIndex"),
"parent_title": helpers.get_xml_attr(metadata_main, "parentTitle"),
"index": helpers.get_xml_attr(metadata_main, "index"),
"studio": helpers.get_xml_attr(metadata_main, "studio"),
"title": helpers.get_xml_attr(metadata_main, "title"),
"content_rating": helpers.get_xml_attr(metadata_main, "contentRating"),
"summary": helpers.get_xml_attr(metadata_main, "summary"),
"rating": helpers.get_xml_attr(metadata_main, "rating"),
"duration": helpers.get_xml_attr(metadata_main, "duration"),
"year": helpers.get_xml_attr(metadata_main, "year"),
"thumb": helpers.get_xml_attr(metadata_main, "thumb"),
"parent_thumb": helpers.get_xml_attr(metadata_main, "parentThumb"),
"grandparent_thumb": helpers.get_xml_attr(metadata_main, "grandparentThumb"),
"art": helpers.get_xml_attr(metadata_main, "art"),
"originally_available_at": helpers.get_xml_attr(metadata_main, "originallyAvailableAt"),
"added_at": helpers.get_xml_attr(metadata_main, "addedAt"),
"updated_at": helpers.get_xml_attr(metadata_main, "updatedAt"),
"last_viewed_at": helpers.get_xml_attr(metadata_main, "lastViewedAt"),
"guid": helpers.get_xml_attr(metadata_main, "guid"),
"genres": genres,
"actors": actors,
"writers": writers,
"directors": directors,
}
metadata_list = {"metadata": metadata}
else:
return None
return metadata_list
def get_full_users_list(self):
friends_list = self.get_plextv_friends()
own_account = self.get_plextv_user_details()
users_list = []
try:
xml_parse = minidom.parseString(own_account)
except Exception as e:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list own account: %s" % e)
return []
except:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list own account.")
return []
xml_head = xml_parse.getElementsByTagName('user')
if not xml_head:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list.")
else:
for a in xml_head:
own_details = {"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'username'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_allow_sync": None,
"is_restricted": helpers.get_xml_attr(a, 'restricted')
}
users_list.append(own_details)
try:
xml_parse = minidom.parseString(friends_list)
except Exception as e:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list friends list: %s" % e)
return []
except:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list friends list.")
return []
xml_head = xml_parse.getElementsByTagName('User')
if not xml_head:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_full_users_list.")
else:
for a in xml_head:
friend = {"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'title'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_allow_sync": helpers.get_xml_attr(a, 'allowSync'),
"is_restricted": helpers.get_xml_attr(a, 'restricted')
}
users_list.append(friend)
return users_list
def get_recently_added_details(self, count='0'):
recent = self.get_recently_added(count, output_format='xml')
recents_list = []
xml_head = recent.getElementsByTagName('MediaContainer')
if not xml_head:
logger.warn("Error parsing XML for Plex recently added.")
return None
for a in xml_head:
if a.getAttribute('size'):
if a.getAttribute('size') == '0':
output = {'recently_added': None}
return output
if a.getElementsByTagName('Directory'):
recents_main = a.getElementsByTagName('Directory')
for item in recents_main:
recent_type = helpers.get_xml_attr(item, 'type')
if recent_type == 'season':
recent_items = {'type': recent_type,
'ratingKey': helpers.get_xml_attr(item, 'ratingKey'),
'title': helpers.get_xml_attr(item, 'title'),
'thumb': helpers.get_xml_attr(item, 'thumb'),
'addedAt': helpers.get_xml_attr(item, 'addedAt')
}
recents_list.append(recent_items)
else:
recent_items = {}
recents_list.append(recent_items)
if a.getElementsByTagName('Video'):
recents_main = a.getElementsByTagName('Video')
for item in recents_main:
recent_type = helpers.get_xml_attr(item, 'type')
if recent_type == 'movie':
recent_items = {'type': recent_type,
'ratingKey': helpers.get_xml_attr(item, 'ratingKey'),
'title': helpers.get_xml_attr(item, 'title'),
'year': helpers.get_xml_attr(item, 'year'),
'thumb': helpers.get_xml_attr(item, 'thumb'),
'addedAt': helpers.get_xml_attr(item, 'addedAt')
}
recents_list.append(recent_items)
else:
recent_items = {}
recents_list.append(recent_items)
output = {'recently_added': sorted(recents_list, key=lambda k: k['addedAt'], reverse=True)}
return output
def get_server_urls(self, include_https=True):
if plexpy.CONFIG.PMS_IDENTIFIER:
server_id = plexpy.CONFIG.PMS_IDENTIFIER
else:
logger.error(u"PlexPy PlexTV :: Unable to retrieve server identity.")
return []
plextv_resources = self.get_plextv_resources(include_https=include_https)
server_urls = []
try:
xml_parse = minidom.parseString(plextv_resources)
except Exception as e:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_server_urls: %s" % e)
return []
except:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_server_urls.")
return []
try:
xml_head = xml_parse.getElementsByTagName('Device')
except Exception as e:
logger.warn(u"PlexPy PlexTV :: Unable to parse XML for get_server_urls: %s." % e)
return []
for a in xml_head:
if helpers.get_xml_attr(a, 'clientIdentifier') == server_id:
connections = a.getElementsByTagName('Connection')
for connection in connections:
server_details = {"protocol": helpers.get_xml_attr(connection, 'protocol'),
"address": helpers.get_xml_attr(connection, 'address'),
"port": helpers.get_xml_attr(connection, 'port'),
"uri": helpers.get_xml_attr(connection, 'uri'),
"local": helpers.get_xml_attr(connection, 'local')
}
server_urls.append(server_details)
# Else try to match the PMS_IP and PMS_PORT
else:
connections = a.getElementsByTagName('Connection')
for connection in connections:
if helpers.get_xml_attr(connection, 'address') == plexpy.CONFIG.PMS_IP and \
int(helpers.get_xml_attr(connection, 'port')) == plexpy.CONFIG.PMS_PORT:
plexpy.CONFIG.PMS_IDENTIFIER = helpers.get_xml_attr(a, 'clientIdentifier')
logger.info(u"PlexPy PlexTV :: PMS identifier changed from %s to %s." % \
(server_id, plexpy.CONFIG.PMS_IDENTIFIER))
server_details = {"protocol": helpers.get_xml_attr(connection, 'protocol'),
"address": helpers.get_xml_attr(connection, 'address'),
"port": helpers.get_xml_attr(connection, 'port'),
"uri": helpers.get_xml_attr(connection, 'uri'),
"local": helpers.get_xml_attr(connection, 'local')
}
break
return server_urls
def extract_plexwatch_xml(xml=None):
output = {}
clean_xml = helpers.latinToAscii(xml)
try:
xml_parse = minidom.parseString(clean_xml)
except:
logger.warn("Error parsing XML for Plexwatch database.")
return None
xml_head = xml_parse.getElementsByTagName("opt")
if not xml_head:
logger.warn("Error parsing XML for Plexwatch database.")
return None
for a in xml_head:
added_at = helpers.get_xml_attr(a, "addedAt")
art = helpers.get_xml_attr(a, "art")
duration = helpers.get_xml_attr(a, "duration")
grandparent_thumb = helpers.get_xml_attr(a, "grandparentThumb")
grandparent_title = helpers.get_xml_attr(a, "grandparentTitle")
guid = helpers.get_xml_attr(a, "guid")
media_index = helpers.get_xml_attr(a, "index")
originally_available_at = helpers.get_xml_attr(a, "originallyAvailableAt")
last_viewed_at = helpers.get_xml_attr(a, "lastViewedAt")
parent_media_index = helpers.get_xml_attr(a, "parentIndex")
parent_thumb = helpers.get_xml_attr(a, "parentThumb")
rating = helpers.get_xml_attr(a, "rating")
thumb = helpers.get_xml_attr(a, "thumb")
media_type = helpers.get_xml_attr(a, "type")
updated_at = helpers.get_xml_attr(a, "updatedAt")
view_offset = helpers.get_xml_attr(a, "viewOffset")
year = helpers.get_xml_attr(a, "year")
parent_title = helpers.get_xml_attr(a, "parentTitle")
studio = helpers.get_xml_attr(a, "studio")
title = helpers.get_xml_attr(a, "title")
tagline = helpers.get_xml_attr(a, "tagline")
directors = []
if a.getElementsByTagName("Director"):
director_elem = a.getElementsByTagName("Director")
for b in director_elem:
directors.append(helpers.get_xml_attr(b, "tag"))
aspect_ratio = ""
audio_channels = None
audio_codec = ""
bitrate = None
container = ""
height = None
video_codec = ""
video_framerate = ""
video_resolution = ""
width = None
if a.getElementsByTagName("Media"):
media_elem = a.getElementsByTagName("Media")
for c in media_elem:
aspect_ratio = helpers.get_xml_attr(c, "aspectRatio")
audio_channels = helpers.get_xml_attr(c, "audioChannels")
audio_codec = helpers.get_xml_attr(c, "audioCodec")
bitrate = helpers.get_xml_attr(c, "bitrate")
container = helpers.get_xml_attr(c, "container")
height = helpers.get_xml_attr(c, "height")
video_codec = helpers.get_xml_attr(c, "videoCodec")
video_framerate = helpers.get_xml_attr(c, "videoFrameRate")
video_resolution = helpers.get_xml_attr(c, "videoResolution")
width = helpers.get_xml_attr(c, "width")
machine_id = ""
platform = ""
player = ""
if a.getElementsByTagName("Player"):
player_elem = a.getElementsByTagName("Player")
for d in player_elem:
machine_id = helpers.get_xml_attr(d, "machineIdentifier")
platform = helpers.get_xml_attr(d, "platform")
player = helpers.get_xml_attr(d, "title")
transcode_audio_channels = None
transcode_audio_codec = ""
audio_decision = "direct play"
transcode_container = ""
transcode_height = None
transcode_protocol = ""
transcode_video_codec = ""
video_decision = "direct play"
transcode_width = None
if a.getElementsByTagName("TranscodeSession"):
transcode_elem = a.getElementsByTagName("TranscodeSession")
for e in transcode_elem:
transcode_audio_channels = helpers.get_xml_attr(e, "audioChannels")
transcode_audio_codec = helpers.get_xml_attr(e, "audioCodec")
audio_decision = helpers.get_xml_attr(e, "audioDecision")
transcode_container = helpers.get_xml_attr(e, "container")
transcode_height = helpers.get_xml_attr(e, "height")
transcode_protocol = helpers.get_xml_attr(e, "protocol")
transcode_video_codec = helpers.get_xml_attr(e, "videoCodec")
video_decision = helpers.get_xml_attr(e, "videoDecision")
transcode_width = helpers.get_xml_attr(e, "width")
user_id = None
if a.getElementsByTagName("User"):
user_elem = a.getElementsByTagName("User")
for f in user_elem:
user_id = helpers.get_xml_attr(f, "id")
writers = []
if a.getElementsByTagName("Writer"):
writer_elem = a.getElementsByTagName("Writer")
for g in writer_elem:
writers.append(helpers.get_xml_attr(g, "tag"))
actors = []
if a.getElementsByTagName("Role"):
actor_elem = a.getElementsByTagName("Role")
for h in actor_elem:
actors.append(helpers.get_xml_attr(h, "tag"))
genres = []
if a.getElementsByTagName("Genre"):
genre_elem = a.getElementsByTagName("Genre")
for i in genre_elem:
genres.append(helpers.get_xml_attr(i, "tag"))
output = {
"added_at": added_at,
"art": art,
"duration": duration,
"grandparent_thumb": grandparent_thumb,
"grandparent_title": grandparent_title,
"parent_title": parent_title,
"title": title,
"tagline": tagline,
"guid": guid,
"media_index": media_index,
"originally_available_at": originally_available_at,
"last_viewed_at": last_viewed_at,
"parent_media_index": parent_media_index,
"parent_thumb": parent_thumb,
"rating": rating,
"thumb": thumb,
"media_type": media_type,
"updated_at": updated_at,
"view_offset": view_offset,
"year": year,
"directors": directors,
"aspect_ratio": aspect_ratio,
"audio_channels": audio_channels,
"audio_codec": audio_codec,
"bitrate": bitrate,
"container": container,
"height": height,
"video_codec": video_codec,
"video_framerate": video_framerate,
"video_resolution": video_resolution,
"width": width,
"machine_id": machine_id,
"platform": platform,
"player": player,
"transcode_audio_channels": transcode_audio_channels,
"transcode_audio_codec": transcode_audio_codec,
"audio_decision": audio_decision,
"transcode_container": transcode_container,
"transcode_height": transcode_height,
"transcode_protocol": transcode_protocol,
"transcode_video_codec": transcode_video_codec,
"video_decision": video_decision,
"transcode_width": transcode_width,
"user_id": user_id,
"writers": writers,
"actors": actors,
"genres": genres,
"studio": studio,
}
return output
def get_recently_added_details(self, count='0'):
recent = self.get_recently_added(count, output_format='xml')
try:
xml_head = recent.getElementsByTagName('MediaContainer')
except:
logger.warn("Unable to parse XML for get_recently_added.")
return []
recents_list = []
for a in xml_head:
if a.getAttribute('size'):
if a.getAttribute('size') == '0':
output = {'recently_added': []}
return output
if a.getElementsByTagName('Directory'):
recents_main = a.getElementsByTagName('Directory')
for item in recents_main:
recent_type = helpers.get_xml_attr(item, 'type')
recent_items = {'type': recent_type,
'rating_key': helpers.get_xml_attr(item, 'ratingKey'),
'title': helpers.get_xml_attr(item, 'title'),
'thumb': helpers.get_xml_attr(item, 'thumb'),
'added_at': helpers.get_xml_attr(item, 'addedAt')
}
recents_list.append(recent_items)
if a.getElementsByTagName('Video'):
recents_main = a.getElementsByTagName('Video')
for item in recents_main:
recent_type = helpers.get_xml_attr(item, 'type')
if recent_type == 'movie':
recent_items = {'type': recent_type,
'rating_key': helpers.get_xml_attr(item, 'ratingKey'),
'title': helpers.get_xml_attr(item, 'title'),
'year': helpers.get_xml_attr(item, 'year'),
'thumb': helpers.get_xml_attr(item, 'thumb'),
'added_at': helpers.get_xml_attr(item, 'addedAt')
}
recents_list.append(recent_items)
else:
pass
output = {'recently_added': sorted(recents_list, key=lambda k: k['added_at'], reverse=True)}
return output
def get_metadata_details(self, rating_key=''):
metadata = self.get_metadata(rating_key, output_format='xml')
try:
xml_head = metadata.getElementsByTagName('MediaContainer')
except:
logger.warn("Unable to parse XML for get_metadata.")
return []
metadata_list = []
for a in xml_head:
if a.getAttribute('size'):
if a.getAttribute('size') != '1':
metadata_list = {'metadata': None}
return metadata_list
if a.getElementsByTagName('Directory'):
metadata_main = a.getElementsByTagName('Directory')[0]
metadata_type = helpers.get_xml_attr(metadata_main, 'type')
elif a.getElementsByTagName('Video'):
metadata_main = a.getElementsByTagName('Video')[0]
metadata_type = helpers.get_xml_attr(metadata_main, 'type')
elif a.getElementsByTagName('Track'):
metadata_main = a.getElementsByTagName('Track')[0]
metadata_type = helpers.get_xml_attr(metadata_main, 'type')
else:
logger.debug(u"Metadata failed")
genres = []
actors = []
writers = []
directors = []
if metadata_main.getElementsByTagName('Genre'):
for genre in metadata_main.getElementsByTagName('Genre'):
genres.append(helpers.get_xml_attr(genre, 'tag'))
if metadata_main.getElementsByTagName('Role'):
for actor in metadata_main.getElementsByTagName('Role'):
actors.append(helpers.get_xml_attr(actor, 'tag'))
if metadata_main.getElementsByTagName('Writer'):
for writer in metadata_main.getElementsByTagName('Writer'):
writers.append(helpers.get_xml_attr(writer, 'tag'))
if metadata_main.getElementsByTagName('Director'):
for director in metadata_main.getElementsByTagName('Director'):
directors.append(helpers.get_xml_attr(director, 'tag'))
if metadata_type == 'show':
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': helpers.get_xml_attr(metadata_main, 'summary'),
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': helpers.get_xml_attr(metadata_main, 'duration'),
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(metadata_main, 'grandparentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'added_at': helpers.get_xml_attr(metadata_main, 'addedAt'),
'updated_at': helpers.get_xml_attr(metadata_main, 'updatedAt'),
'last_viewed_at': helpers.get_xml_attr(metadata_main, 'lastViewedAt'),
'guid': helpers.get_xml_attr(metadata_main, 'guid'),
'writers': writers,
'directors': directors,
'genres': genres,
'actors': actors
}
metadata_list = {'metadata': metadata}
elif metadata_type == 'episode':
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': helpers.get_xml_attr(metadata_main, 'summary'),
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': helpers.get_xml_attr(metadata_main, 'duration'),
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(metadata_main, 'grandparentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'added_at': helpers.get_xml_attr(metadata_main, 'addedAt'),
'updated_at': helpers.get_xml_attr(metadata_main, 'updatedAt'),
'last_viewed_at': helpers.get_xml_attr(metadata_main, 'lastViewedAt'),
'guid': helpers.get_xml_attr(metadata_main, 'guid'),
'writers': writers,
'directors': directors,
'genres': genres,
'actors': actors
}
metadata_list = {'metadata': metadata}
elif metadata_type == 'movie':
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': helpers.get_xml_attr(metadata_main, 'summary'),
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': helpers.get_xml_attr(metadata_main, 'duration'),
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(metadata_main, 'grandparentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'added_at': helpers.get_xml_attr(metadata_main, 'addedAt'),
'updated_at': helpers.get_xml_attr(metadata_main, 'updatedAt'),
'last_viewed_at': helpers.get_xml_attr(metadata_main, 'lastViewedAt'),
'guid': helpers.get_xml_attr(metadata_main, 'guid'),
'genres': genres,
'actors': actors,
'writers': writers,
'directors': directors
}
metadata_list = {'metadata': metadata}
elif metadata_type == 'season':
parent_rating_key = helpers.get_xml_attr(metadata_main, 'parentRatingKey')
show_details = self.get_metadata_details(parent_rating_key)
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': show_details['metadata']['summary'],
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': show_details['metadata']['duration'],
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(metadata_main, 'grandparentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'added_at': helpers.get_xml_attr(metadata_main, 'addedAt'),
'updated_at': helpers.get_xml_attr(metadata_main, 'updatedAt'),
'last_viewed_at': helpers.get_xml_attr(metadata_main, 'lastViewedAt'),
'guid': helpers.get_xml_attr(metadata_main, 'guid'),
'genres': genres,
'actors': actors,
'writers': writers,
'directors': directors
}
metadata_list = {'metadata': metadata}
elif metadata_type == 'track':
metadata = {'type': metadata_type,
'rating_key': helpers.get_xml_attr(metadata_main, 'ratingKey'),
'grandparent_title': helpers.get_xml_attr(metadata_main, 'grandparentTitle'),
'parent_index': helpers.get_xml_attr(metadata_main, 'parentIndex'),
'parent_title': helpers.get_xml_attr(metadata_main, 'parentTitle'),
'index': helpers.get_xml_attr(metadata_main, 'index'),
'studio': helpers.get_xml_attr(metadata_main, 'studio'),
'title': helpers.get_xml_attr(metadata_main, 'title'),
'content_rating': helpers.get_xml_attr(metadata_main, 'contentRating'),
'summary': helpers.get_xml_attr(metadata_main, 'summary'),
'rating': helpers.get_xml_attr(metadata_main, 'rating'),
'duration': helpers.get_xml_attr(metadata_main, 'duration'),
'year': helpers.get_xml_attr(metadata_main, 'year'),
'thumb': helpers.get_xml_attr(metadata_main, 'thumb'),
'parent_thumb': helpers.get_xml_attr(metadata_main, 'parentThumb'),
'grandparent_thumb': helpers.get_xml_attr(metadata_main, 'grandparentThumb'),
'art': helpers.get_xml_attr(metadata_main, 'art'),
'originally_available_at': helpers.get_xml_attr(metadata_main, 'originallyAvailableAt'),
'added_at': helpers.get_xml_attr(metadata_main, 'addedAt'),
'updated_at': helpers.get_xml_attr(metadata_main, 'updatedAt'),
'last_viewed_at': helpers.get_xml_attr(metadata_main, 'lastViewedAt'),
'guid': helpers.get_xml_attr(metadata_main, 'guid'),
'genres': genres,
'actors': actors,
'writers': writers,
'directors': directors
}
metadata_list = {'metadata': metadata}
else:
return None
return metadata_list
try:
xml_parse = minidom.parseString(own_account)
except Exception, e:
logger.warn("Error parsing XML for Plex account details: %s" % e)
return []
except:
logger.warn("Error parsing XML for Plex account details.")
return []
xml_head = xml_parse.getElementsByTagName('user')
if not xml_head:
logger.warn("Error parsing XML for Plex account details.")
else:
for a in xml_head:
own_details = {"user_id": helpers.get_xml_attr(a, 'id'),
"username": helpers.get_xml_attr(a, 'username'),
"thumb": helpers.get_xml_attr(a, 'thumb'),
"email": helpers.get_xml_attr(a, 'email'),
"is_home_user": helpers.get_xml_attr(a, 'home'),
"is_allow_sync": None,
"is_restricted": helpers.get_xml_attr(a, 'restricted')
}
users_list.append(own_details)
try:
xml_parse = minidom.parseString(friends_list)
except Exception, e:
logger.warn("Error parsing XML for Plex friends list: %s" % e)
except:
def get_session_each(self, stream_type='', session=None):
session_output = None
plex_watch = plexwatch.PlexWatch()
if stream_type == 'track':
if session.getElementsByTagName('TranscodeSession'):
transcode_session = session.getElementsByTagName('TranscodeSession')[0]
audio_decision = helpers.get_xml_attr(transcode_session, 'audioDecision')
audio_channels = helpers.get_xml_attr(transcode_session, 'audioChannels')
audio_codec = helpers.get_xml_attr(transcode_session, 'audioCodec')
duration = helpers.get_xml_attr(transcode_session, 'duration')
progress = helpers.get_xml_attr(session, 'viewOffset')
else:
media_info = session.getElementsByTagName('Media')[0]
audio_decision = 'direct play'
audio_channels = helpers.get_xml_attr(media_info, 'audioChannels')
audio_codec = helpers.get_xml_attr(media_info, 'audioCodec')
duration = helpers.get_xml_attr(media_info, 'duration')
progress = helpers.get_xml_attr(session, 'viewOffset')
session_output = {'session_key': helpers.get_xml_attr(session, 'sessionKey'),
'art': helpers.get_xml_attr(session, 'art'),
'parent_thumb': helpers.get_xml_attr(session, 'parentThumb'),
'thumb': helpers.get_xml_attr(session, 'thumb'),
'user': helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'),
'friendly_name': plex_watch.get_user_friendly_name(
helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title')),
'player': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'platform'),
'state': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'state'),
'grandparent_title': helpers.get_xml_attr(session, 'grandparentTitle'),
'parent_title': helpers.get_xml_attr(session, 'parentTitle'),
'title': helpers.get_xml_attr(session, 'title'),
'rating_key': helpers.get_xml_attr(session, 'ratingKey'),
'audio_decision': audio_decision,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'video_decision': '',
'video_codec': '',
'height': '',
'width': '',
'duration': duration,
'progress': progress,
'progress_percent': str(helpers.get_percent(progress, duration)),
'type': 'track',
'indexes': 0
}
elif stream_type == 'video':
if session.getElementsByTagName('TranscodeSession'):
transcode_session = session.getElementsByTagName('TranscodeSession')[0]
audio_decision = helpers.get_xml_attr(transcode_session, 'audioDecision')
audio_channels = helpers.get_xml_attr(transcode_session, 'audioChannels')
audio_codec = helpers.get_xml_attr(transcode_session, 'audioCodec')
video_decision = helpers.get_xml_attr(transcode_session, 'videoDecision')
video_codec = helpers.get_xml_attr(transcode_session, 'videoCodec')
width = helpers.get_xml_attr(transcode_session, 'width')
height = helpers.get_xml_attr(transcode_session, 'height')
duration = helpers.get_xml_attr(session, 'duration')
progress = helpers.get_xml_attr(session, 'viewOffset')
else:
media_info = session.getElementsByTagName('Media')[0]
audio_decision = 'direct play'
audio_channels = helpers.get_xml_attr(media_info, 'audioChannels')
audio_codec = helpers.get_xml_attr(media_info, 'audioCodec')
video_decision = 'direct play'
video_codec = helpers.get_xml_attr(media_info, 'videoCodec')
width = helpers.get_xml_attr(media_info, 'width')
height = helpers.get_xml_attr(media_info, 'height')
duration = helpers.get_xml_attr(media_info, 'duration')
progress = helpers.get_xml_attr(session, 'viewOffset')
media_info = session.getElementsByTagName('Media')[0]
if media_info.getElementsByTagName('Part'):
indexes = helpers.get_xml_attr(media_info.getElementsByTagName('Part')[0], 'indexes')
part_id = helpers.get_xml_attr(media_info.getElementsByTagName('Part')[0], 'id')
if indexes == 'sd':
bif_thumb = '/library/parts/' + part_id + '/indexes/sd/' + progress
else:
bif_thumb = ''
else:
indexes = ''
bif_thumb = ''
if plexpy.CONFIG.PMS_USE_BIF and indexes == 'sd':
thumb = bif_thumb
use_indexes = 1
else:
thumb = helpers.get_xml_attr(session, 'thumb')
use_indexes = 0
if helpers.get_xml_attr(session, 'type') == 'episode':
session_output = {'session_key': helpers.get_xml_attr(session, 'sessionKey'),
'art': helpers.get_xml_attr(session, 'art'),
'parent_thumb': helpers.get_xml_attr(session, 'parentThumb'),
'thumb': thumb,
'user': helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'),
'friendly_name': plex_watch.get_user_friendly_name(
helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title')),
'player': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'platform'),
'state': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'state'),
'grandparent_title': helpers.get_xml_attr(session, 'grandparentTitle'),
'parent_title': helpers.get_xml_attr(session, 'parentTitle'),
'title': helpers.get_xml_attr(session, 'title'),
'rating_key': helpers.get_xml_attr(session, 'ratingKey'),
'audio_decision': audio_decision,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'video_decision': video_decision,
'video_codec': video_codec,
'height': height,
'width': width,
'duration': duration,
'progress': progress,
'progress_percent': str(helpers.get_percent(progress, duration)),
'type': helpers.get_xml_attr(session, 'type'),
'indexes': use_indexes
}
elif helpers.get_xml_attr(session, 'type') == 'movie':
session_output = {'session_key': helpers.get_xml_attr(session, 'sessionKey'),
'art': helpers.get_xml_attr(session, 'art'),
'thumb': thumb,
'parent_thumb': helpers.get_xml_attr(session, 'parentThumb'),
'user': helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'),
'friendly_name': plex_watch.get_user_friendly_name(
helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title')),
'player': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'platform'),
'state': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'state'),
'grandparent_title': helpers.get_xml_attr(session, 'grandparentTitle'),
'parent_title': helpers.get_xml_attr(session, 'parentTitle'),
'title': helpers.get_xml_attr(session, 'title'),
'rating_key': helpers.get_xml_attr(session, 'ratingKey'),
'audio_decision': audio_decision,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'video_decision': video_decision,
'video_codec': video_codec,
'height': height,
'width': width,
'duration': duration,
'progress': progress,
'progress_percent': str(helpers.get_percent(progress, duration)),
'type': helpers.get_xml_attr(session, 'type'),
'indexes': use_indexes
}
elif helpers.get_xml_attr(session, 'type') == 'clip':
session_output = {'session_key': helpers.get_xml_attr(session, 'sessionKey'),
'art': helpers.get_xml_attr(session, 'art'),
'thumb': thumb,
'parent_thumb': helpers.get_xml_attr(session, 'parentThumb'),
'user': helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title'),
'friendly_name': plex_watch.get_user_friendly_name(
helpers.get_xml_attr(session.getElementsByTagName('User')[0], 'title')),
'player': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'platform'),
'state': helpers.get_xml_attr(session.getElementsByTagName('Player')[0], 'state'),
'grandparent_title': helpers.get_xml_attr(session, 'grandparentTitle'),
'parent_title': helpers.get_xml_attr(session, 'parentTitle'),
'title': helpers.get_xml_attr(session, 'title'),
'rating_key': helpers.get_xml_attr(session, 'ratingKey'),
'audio_decision': audio_decision,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'video_decision': video_decision,
'video_codec': video_codec,
'height': height,
'width': width,
'duration': duration,
'progress': progress,
'progress_percent': str(helpers.get_percent(progress, duration)),
'type': helpers.get_xml_attr(session, 'type'),
'indexes': 0
}
else:
logger.warn(u"No known stream types found in session list.")
return session_output
def extract_plexwatch_xml(xml=None):
output = {}
clean_xml = helpers.latinToAscii(xml)
try:
xml_parse = minidom.parseString(clean_xml)
except:
logger.warn(
u"PlexPy Importer :: Error parsing XML for Plexwatch database.")
return None
xml_head = xml_parse.getElementsByTagName('opt')
if not xml_head:
logger.warn(
u"PlexPy Importer :: Error parsing XML for Plexwatch database.")
return None
for a in xml_head:
added_at = helpers.get_xml_attr(a, 'addedAt')
art = helpers.get_xml_attr(a, 'art')
duration = helpers.get_xml_attr(a, 'duration')
grandparent_thumb = helpers.get_xml_attr(a, 'grandparentThumb')
grandparent_title = helpers.get_xml_attr(a, 'grandparentTitle')
guid = helpers.get_xml_attr(a, 'guid')
section_id = helpers.get_xml_attr(a, 'librarySectionID')
media_index = helpers.get_xml_attr(a, 'index')
originally_available_at = helpers.get_xml_attr(
a, 'originallyAvailableAt')
last_viewed_at = helpers.get_xml_attr(a, 'lastViewedAt')
parent_media_index = helpers.get_xml_attr(a, 'parentIndex')
parent_thumb = helpers.get_xml_attr(a, 'parentThumb')
rating = helpers.get_xml_attr(a, 'rating')
thumb = helpers.get_xml_attr(a, 'thumb')
media_type = helpers.get_xml_attr(a, 'type')
updated_at = helpers.get_xml_attr(a, 'updatedAt')
view_offset = helpers.get_xml_attr(a, 'viewOffset')
year = helpers.get_xml_attr(a, 'year')
parent_title = helpers.get_xml_attr(a, 'parentTitle')
studio = helpers.get_xml_attr(a, 'studio')
title = helpers.get_xml_attr(a, 'title')
tagline = helpers.get_xml_attr(a, 'tagline')
directors = []
if a.getElementsByTagName('Director'):
director_elem = a.getElementsByTagName('Director')
for b in director_elem:
directors.append(helpers.get_xml_attr(b, 'tag'))
aspect_ratio = ''
audio_channels = None
audio_codec = ''
bitrate = None
container = ''
height = None
video_codec = ''
video_framerate = ''
video_resolution = ''
width = None
if a.getElementsByTagName('Media'):
media_elem = a.getElementsByTagName('Media')
for c in media_elem:
aspect_ratio = helpers.get_xml_attr(c, 'aspectRatio')
audio_channels = helpers.get_xml_attr(c, 'audioChannels')
audio_codec = helpers.get_xml_attr(c, 'audioCodec')
bitrate = helpers.get_xml_attr(c, 'bitrate')
container = helpers.get_xml_attr(c, 'container')
height = helpers.get_xml_attr(c, 'height')
video_codec = helpers.get_xml_attr(c, 'videoCodec')
video_framerate = helpers.get_xml_attr(c, 'videoFrameRate')
video_resolution = helpers.get_xml_attr(c, 'videoResolution')
width = helpers.get_xml_attr(c, 'width')
machine_id = ''
platform = ''
player = ''
if a.getElementsByTagName('Player'):
player_elem = a.getElementsByTagName('Player')
for d in player_elem:
machine_id = helpers.get_xml_attr(d, 'machineIdentifier')
platform = helpers.get_xml_attr(d, 'platform')
player = helpers.get_xml_attr(d, 'title')
transcode_audio_channels = None
transcode_audio_codec = ''
audio_decision = 'direct play'
transcode_container = ''
transcode_height = None
transcode_protocol = ''
transcode_video_codec = ''
video_decision = 'direct play'
transcode_width = None
if a.getElementsByTagName('TranscodeSession'):
transcode_elem = a.getElementsByTagName('TranscodeSession')
for e in transcode_elem:
transcode_audio_channels = helpers.get_xml_attr(
e, 'audioChannels')
transcode_audio_codec = helpers.get_xml_attr(e, 'audioCodec')
audio_decision = helpers.get_xml_attr(e, 'audioDecision')
transcode_container = helpers.get_xml_attr(e, 'container')
transcode_height = helpers.get_xml_attr(e, 'height')
transcode_protocol = helpers.get_xml_attr(e, 'protocol')
transcode_video_codec = helpers.get_xml_attr(e, 'videoCodec')
video_decision = helpers.get_xml_attr(e, 'videoDecision')
transcode_width = helpers.get_xml_attr(e, 'width')
user_id = None
if a.getElementsByTagName('User'):
user_elem = a.getElementsByTagName('User')
for f in user_elem:
user_id = helpers.get_xml_attr(f, 'id')
writers = []
if a.getElementsByTagName('Writer'):
writer_elem = a.getElementsByTagName('Writer')
for g in writer_elem:
writers.append(helpers.get_xml_attr(g, 'tag'))
actors = []
if a.getElementsByTagName('Role'):
actor_elem = a.getElementsByTagName('Role')
for h in actor_elem:
actors.append(helpers.get_xml_attr(h, 'tag'))
genres = []
if a.getElementsByTagName('Genre'):
genre_elem = a.getElementsByTagName('Genre')
for i in genre_elem:
genres.append(helpers.get_xml_attr(i, 'tag'))
output = {
'added_at': added_at,
'art': art,
'duration': duration,
'grandparent_thumb': grandparent_thumb,
'grandparent_title': grandparent_title,
'parent_title': parent_title,
'title': title,
'tagline': tagline,
'guid': guid,
'section_id': section_id,
'media_index': media_index,
'originally_available_at': originally_available_at,
'last_viewed_at': last_viewed_at,
'parent_media_index': parent_media_index,
'parent_thumb': parent_thumb,
'rating': rating,
'thumb': thumb,
'media_type': media_type,
'updated_at': updated_at,
'view_offset': view_offset,
'year': year,
'directors': directors,
'aspect_ratio': aspect_ratio,
'audio_channels': audio_channels,
'audio_codec': audio_codec,
'bitrate': bitrate,
'container': container,
'height': height,
'video_codec': video_codec,
'video_framerate': video_framerate,
'video_resolution': video_resolution,
'width': width,
'machine_id': machine_id,
'platform': platform,
'player': player,
'transcode_audio_channels': transcode_audio_channels,
'transcode_audio_codec': transcode_audio_codec,
'audio_decision': audio_decision,
'transcode_container': transcode_container,
'transcode_height': transcode_height,
'transcode_protocol': transcode_protocol,
'transcode_video_codec': transcode_video_codec,
'video_decision': video_decision,
'transcode_width': transcode_width,
'user_id': user_id,
'writers': writers,
'actors': actors,
'genres': genres,
'studio': studio
}
return output
def get_recently_added_details(self, count="0"):
recent = self.get_recently_added(count, output_format="xml")
try:
xml_head = recent.getElementsByTagName("MediaContainer")
except:
logger.warn("Unable to parse XML for get_recently_added.")
return []
recents_list = []
for a in xml_head:
if a.getAttribute("size"):
if a.getAttribute("size") == "0":
output = {"recently_added": []}
return output
if a.getElementsByTagName("Directory"):
recents_main = a.getElementsByTagName("Directory")
for item in recents_main:
recent_type = helpers.get_xml_attr(item, "type")
recent_items = {
"type": recent_type,
"rating_key": helpers.get_xml_attr(item, "ratingKey"),
"title": helpers.get_xml_attr(item, "title"),
"thumb": helpers.get_xml_attr(item, "thumb"),
"added_at": helpers.get_xml_attr(item, "addedAt"),
}
recents_list.append(recent_items)
if a.getElementsByTagName("Video"):
recents_main = a.getElementsByTagName("Video")
for item in recents_main:
recent_type = helpers.get_xml_attr(item, "type")
if recent_type == "movie":
recent_items = {
"type": recent_type,
"rating_key": helpers.get_xml_attr(item, "ratingKey"),
"title": helpers.get_xml_attr(item, "title"),
"year": helpers.get_xml_attr(item, "year"),
"thumb": helpers.get_xml_attr(item, "thumb"),
"added_at": helpers.get_xml_attr(item, "addedAt"),
}
recents_list.append(recent_items)
else:
pass
output = {"recently_added": sorted(recents_list, key=lambda k: k["added_at"], reverse=True)}
return output
