def fetch_metadata(self, key):
assert isinstance(key, int)
logger = get_logger(self, 'fetch_metadata')
if not self.enabled:
raise PlexServerException(
'Unable to query metadata, media connection disabled')
if key in self.metadata_cache:
return self.metadata_cache[key]
metadata_req = requests.get((
'http://{host}:{port}/library/metadata/{key}').format(
host=self.host, port=self.port, key=key))
if metadata_req.status_code != 200:
raise PlexServerException((
'Unable to query metadata for {key}:'
' [{status_code}] - {reason}').format(
key=key,
status_code=metadata_req.status_code,
reason=metadata_req.reason))
self.metadata_cache[key] = metadata_req.text
return self.metadata_cache[key]
def check_connection(self):
# Check if medialookup is enabled, and test the connection if so
logger = get_logger(self, 'check_connection')
logger.debug("Called check_connection")
try:
check_req = requests.get('http://{host}:{port}/servers'.format(
host=self.host, port=self.port))
check_soup = BeautifulSoup(check_req.text)
server_info = check_soup('server')[0]
self.server_info = {}
self.server_info['name'] = server_info['name']
self.server_info['host'] = server_info['host']
self.server_info['port'] = server_info['port']
self.server_info['address'] = server_info['address']
self.server_info['id'] = server_info['machineidentifier']
self.server_info['version'] = server_info['version']
self.enabled = True
logger.info("Media connection enabled!")
except requests.ConnectionError as err:
logger.error('Error checking media server: ' + str(err))
self.enabled = False
logger.warning("Media connection disabled!")
def parse_file(self, real_file_name):
logger = get_logger(self, "parse_file")
logger.debug("Called parse_file with: {0}".format(real_file_name))
lines = []
with open(real_file_name, "rU") as file_handle:
for line_body in self._parse_base(real_file_name, file_handle):
if not self.line_body_filter(line_body):
continue
lines.append(line_body)
return lines
def plex_media_object_batch(conn, keys, batch_size=20):
"""
Batch fetch metadata from media server. :)
Can be used with episodes to get more info by passing the series_key as an
object to get.
"""
if not isinstance(keys, (list, tuple)):
raise TypeError("Required argument 'keys' must be a list or tuple.")
if conn is None:
raise TypeError("Argument 'conn' must not be None")
logger = get_logger('plex_media_object_batch')
logger.debug("Fetching {0} media objects".format(len(keys)))
results = {}
all_keys = keys[:]
while len(all_keys) > 0:
working_keys = all_keys[:batch_size]
all_keys = all_keys[batch_size:]
req = 'library/metadata/' + ','.join(map(str, working_keys))
logger.debug("-> {0}".format(', '.join(map(str, working_keys))))
xml = conn.fetch(req)
soup = BeautifulSoup(xml)
for container_tag in soup.find_all(ratingkey=True):
container_key = container_tag['ratingkey']
if container_key in results:
continue
try:
## --TODO--: Extract the soup object, suitable for passing down
## to plex_media_object
## FIX: Just send it all, the media objects are smarter...
results[container_key] = plex_media_object(
conn, int(container_key), xml, soup)
except PlexMediaException:
pass
logger.debug("Fetched {0} media objects".format(len(results)))
return results
def fetch(self, path):
logger = get_logger(self, 'fetch')
if not self.enabled:
raise PlexServerException(
'Unable to fetch data, media connection disabled')
if path in self.page_cache:
return self.page_cache[path]
page_req = requests.get('http://{host}:{port}/{path}'.format(
host=self.host, port=self.port, path=path))
if page_req.status_code != 200:
raise PlexServerException((
'Unable to query path {path}:'
' [{status_code}] - {reason}').format(
path=path, status_code=page_req.status_code,
reason=page_req.reason))
self.page_cache[path] = page_req.text
return self.page_cache[path]
