def get_servers():
username = session[USERNAME]
password = session[PASSWORD]
plex_server = Plex(username, password)
servers = plex_server.get_plex_server_resources()
names = [server.name for server in servers]
return jsonify(names)
def add_movies():
data = request.json
if (not data):
return {
"error": "You need to include movies, playlist name and users"
}, 400
movie_list = data["movies"]
name = data["name"]
users = data["users"]
if (not movie_list or not name or not users):
return {
"error": "You need to include movies, playlist name and users"
}, 400
username = session[USERNAME]
password = session[PASSWORD]
server = session[SERVER]
imdb_id = session[IMDB_ID]
if (not username or not password or not server or not imdb_id):
return {"error": "Could not find session data"}, 500
plex_server = Plex(username, password)
plex_server.add_resource_by_name(server)
plex_server.connect()
playlist, failed_movies = plex_server.add_playlist(name, movie_list)
if (len(users) > 0 and playlist is not None):
plex_server.copy_to_users(playlist, users)
return jsonify(failed_movies)
def scrape_imdb():
data = request.json
if (not data):
return {"error": "You need to include an IMDb id"}, 400
imdb_id = data[IMDB_ID]
if (not imdb_id):
return {"error": "You need to include an IMDb id"}, 400
username = session[USERNAME]
password = session[PASSWORD]
server = session[SERVER]
if (not username or not password or not server):
return {"error": "Could not find session data"}, 500
plex_server = Plex(username, password)
plex_server.add_resource_by_name(server)
plex_server.connect()
movies = plex_server.scrape_imdb("https://www.imdb.com/list/" + imdb_id)
if (not movies):
return {"error": "You need to include a valid IMDb id"}, 400
session[IMDB_ID] = imdb_id
return jsonify(movies)
def get_users():
username = session[USERNAME]
password = session[PASSWORD]
server = session[SERVER]
if (not username or not password or not server):
return {"error": "Could not find session data"}, 500
plex_server = Plex(username, password)
plex_server.add_resource_by_name(server)
plex_server.connect()
users = plex_server.get_users()
return jsonify(users)
def main():
app = QApplication([])
engine = QQmlApplicationEngine()
# Instances of Objects
plex = Plex(os.environ['USERNAME'], os.environ['PASSWORD'],
os.environ['SERVER_NAME'])
# Expose instances
context = engine.rootContext()
context.setContextProperty("plex", plex)
# Load the view
view_path = join(dirname(__file__), 'views/view.qml')
engine.load(abspath(view_path))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec_())
def sign_in():
data = request.json
if (not data):
return {"error": "You need to include username and password"}, 400
username = data[USERNAME]
password = data[PASSWORD]
if (not username or not password):
return {"error": "You need to include username and password"}, 400
try:
plex_server = Plex(username, password)
except SignInError:
return {"error": "Wrong username or password"}, 401
session[USERNAME] = username
session[PASSWORD] = password
return {"message": "Success"}, 200
def choose_server():
data = request.json
if (not data):
return {"error": "You need to include a server name"}, 400
server = data[SERVER]
if (not server):
return {"error": "You need to include a server name"}, 400
username = session[USERNAME]
password = session[PASSWORD]
plex_server = Plex(username, password)
try:
plex_server.add_resource_by_name(server)
except NotMediaServerError:
return {"error": "Not a plex server"}, 400
except NoServerError:
return {"error": "No server with that name"}, 400
session[SERVER] = server
return {"message": "Success"}, 200
def setup_logger():
formatter = logging.Formatter('%(asctime)s %(message)s')
handler = logging.FileHandler('failed-lookup.log')
handler.setFormatter(formatter)
logger.addHandler(handler)
logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))
logger.setLevel(logging.INFO)
if __name__ == '__main__':
config_parser.read('settings.ini')
plex = PlexServer(config_parser.get('Plex', 'url'),
config_parser.get('Plex', 'token'))
plex_interface = Plex()
min_weight = int(config_parser.get('AniDB', 'min_tag_weight'))
setup_logger()
titles = []
anime_library = plex.library.section(
config_parser.get('Plex', 'anime_library'))
plex_interface.set_library(anime_library)
for video in anime_library.search():
titles.append(AniDBTitle(video.title))
#plex_interface.add_show(video.title, video)
for anime in titles:
print('Processing "{}"'.format(anime.title))
anime.anidb_id = anidb.find_id(anime)
def get_synced_items(self, machine_id=None, client_id_filter=None, user_id_filter=None,
rating_key_filter=None, sync_id_filter=None):
if not machine_id:
machine_id = plexpy.CONFIG.PMS_IDENTIFIER
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)]
sync_list = self.get_plextv_sync_lists(machine_id, output_format='xml')
user_data = users.Users()
synced_items = []
try:
xml_head = sync_list.getElementsByTagName('SyncList')
except Exception as e:
logger.warn("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:
sync_media_type = None
rating_key = None
for location in item.getElementsByTagName('Location'):
location_uri = unquote(helpers.get_xml_attr(location, 'uri'))
if location_uri.startswith('library://'):
if 'collection' in location_uri:
sync_media_type = 'collection'
clean_uri = location_uri.split('/')
rating_key = next((j for i, j in zip(clean_uri[:-1], clean_uri[1:])
if i in ('metadata', 'collections')), None)
elif location_uri.startswith('playlist://'):
sync_media_type = 'playlist'
tokens = users.Users().get_tokens(user_id=device_user_id)
if tokens['server_token']:
plex = Plex(token=tokens['server_token'])
for playlist in plex.PlexServer.playlists():
if location_uri.endswith(playlist.guid):
rating_key = str(playlist.ratingKey) # String for backwards consistency
# 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": device_name,
"platform": device_platform,
"user_id": device_user_id,
"user": device_friendly_name,
"username": device_username,
"root_title": sync_root_title,
"sync_title": 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,
"sync_media_type": sync_media_type
}
synced_items.append(sync_details)
return session.filter_session_info(synced_items, filter_key='user_id')
