bel
/
JellyPlex-Watched
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use async for jellyfin (#23) 

* Use async

* Massive jellyfin watched speedup

Co-authored-by: Luigi311 <luigi311.lg@gmail.com>
pull/26/head
Luigi311 2022-07-10 01:30:12 -06:00 committed by GitHub
parent 1efb4d8543
commit 88a7526721
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 2623 additions and 2530 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
requirements.txt
View File

@ -1,3 +1,4 @@
plexapi
requests
python-dotenv
aiohttp

11
src/functions.py
View File

@ -133,6 +133,17 @@ def generate_library_guids_dict(user_list: dict):
return show_output_dict, episode_output_dict, movies_output_dict
def combine_watched_dicts(dicts: list):
combined_dict = {}
for dict in dicts:
for key, value in dict.items():
if key not in combined_dict:
combined_dict[key] = {}
for subkey, subvalue in value.items():
combined_dict[key][subkey] = subvalue
return combined_dict
def future_thread_executor(args: list, workers: int = -1):
futures_list = []
results = []

188
src/jellyfin.py
View File

@ -1,11 +1,10 @@
import requests
from src.functions import logger, search_mapping, str_to_bool, check_skip_logic, generate_library_guids_dict, future_thread_executor
import asyncio, aiohttp
from src.functions import logger, search_mapping, str_to_bool, check_skip_logic, generate_library_guids_dict, future_thread_executor, combine_watched_dicts
class Jellyfin():
def __init__(self, baseurl, token):
self.baseurl = baseurl
self.token = token
self.session = requests.Session()
if not self.baseurl:
raise Exception("Jellyfin baseurl not set")
@ -13,21 +12,16 @@ class Jellyfin():
if not self.token:
raise Exception("Jellyfin token not set")
self.users = self.get_users()
self.users = asyncio.run(self.get_users())
def query(self, query, query_type):
async def query(self, query, query_type, session, identifiers=None):
try:
response = None
results = None
headers = {
"Accept": "application/json",
"X-Emby-Token": self.token
}
if query_type == "get":
response = self.session.get(self.baseurl + query, headers=headers)
elif query_type == "post":
authorization = (
'MediaBrowser , '
'Client="other", '
@ -36,20 +30,32 @@ class Jellyfin():
'Version="0.0.0"'
)
headers["X-Emby-Authorization"] = authorization
response = self.session.post(self.baseurl + query, headers=headers)
return response.json()
if query_type == "get":
async with session.get(self.baseurl + query, headers=headers) as response:
results = await response.json()
elif query_type == "post":
async with session.post(self.baseurl + query, headers=headers) as response:
results = await response.json()
# append identifiers to results
if identifiers:
results["Identifiers"] = identifiers
return results
except Exception as e:
logger(f"Jellyfin: Query failed {e}", 2)
raise Exception(e)
def get_users(self):
async def get_users(self):
try:
users = {}
query = "/Users"
response = self.query(query, "get")
query_string = "/Users"
async with aiohttp.ClientSession() as session:
response = await self.query(query_string, "get", session)
# If reponse is not empty
if response:
@ -61,7 +67,8 @@ class Jellyfin():
logger(f"Jellyfin: Get users failed {e}", 2)
raise Exception(e)
def get_user_watched(self, user_name, user_id, library_type, library_id, library_title):
async def get_user_watched(self, user_name, user_id, library_type, library_id, library_title):
try:
user_name = user_name.lower()
user_watched = {}
@ -69,51 +76,84 @@ class Jellyfin():
logger(f"Jellyfin: Generating watched for {user_name} in library {library_title}", 0)
# Movies
async with aiohttp.ClientSession() as session:
if library_type == "Movie":
user_watched[user_name][library_title] = []
watched = self.query(f"/Users/{user_id}/Items?SortBy=SortName&SortOrder=Ascending&Recursive=true&ParentId={library_id}&Filters=IsPlayed&Fields=ItemCounts,ProviderIds,MediaSources", "get")
watched = await self.query(f"/Users/{user_id}/Items?ParentId={library_id}&Filters=IsPlayed&Fields=ItemCounts,ProviderIds,MediaSources", "get", session)
for movie in watched["Items"]:
if movie["UserData"]["Played"] == True:
movie_guids = {}
movie_guids["title"] = movie["Name"]
if movie["ProviderIds"]:
if "ProviderIds" in movie:
# Lowercase movie["ProviderIds"] keys
movie_guids = {k.lower(): v for k, v in movie["ProviderIds"].items()}
if movie["MediaSources"]:
if "MediaSources" in movie:
movie_guids["locations"] = tuple([x["Path"].split("/")[-1] for x in movie["MediaSources"]])
user_watched[user_name][library_title].append(movie_guids)
# TV Shows
if library_type == "Episode":
if library_type == "Series":
user_watched[user_name][library_title] = {}
watched = self.query(f"/Users/{user_id}/Items?SortBy=SortName&SortOrder=Ascending&Recursive=true&ParentId={library_id}&Fields=ItemCounts,ProviderIds,Path", "get")
watched_shows = [x for x in watched["Items"] if x["Type"] == "Series"]
for show in watched_shows:
watched_shows = await self.query(f"/Users/{user_id}/Items?ParentId={library_id}&isPlaceHolder=false&Fields=ProviderIds,Path,RecursiveItemCount", "get", session)
watched_shows_filtered = []
for show in watched_shows["Items"]:
if "PlayedPercentage" in show["UserData"]:
if show["UserData"]["PlayedPercentage"] > 0:
watched_shows_filtered.append(show)
seasons_tasks = []
for show in watched_shows_filtered:
show_guids = {k.lower(): v for k, v in show["ProviderIds"].items()}
show_guids["title"] = show["Name"]
show_guids["locations"] = tuple([show["Path"].split("/")[-1]])
show_guids = frozenset(show_guids.items())
seasons = self.query(f"/Shows/{show['Id']}/Seasons?userId={user_id}&Fields=ItemCounts,ProviderIds", "get")
identifiers = {"show_guids": show_guids, "show_id": show["Id"]}
task = asyncio.ensure_future(self.query(f"/Shows/{show['Id']}/Seasons?userId={user_id}&isPlaceHolder=false&Fields=ProviderIds,RecursiveItemCount", "get", session, frozenset(identifiers.items())))
seasons_tasks.append(task)
seasons_watched = await asyncio.gather(*seasons_tasks)
seasons_watched_filtered = []
for seasons in seasons_watched:
seasons_watched_filtered_dict = {}
seasons_watched_filtered_dict["Identifiers"] = seasons["Identifiers"]
seasons_watched_filtered_dict["Items"] = []
for season in seasons["Items"]:
if "PlayedPercentage" in season["UserData"]:
if season["UserData"]["PlayedPercentage"] > 0:
seasons_watched_filtered_dict["Items"].append(season)
if seasons_watched_filtered_dict["Items"]:
seasons_watched_filtered.append(seasons_watched_filtered_dict)
episodes_tasks = []
for seasons in seasons_watched_filtered:
if len(seasons["Items"]) > 0:
for season in seasons["Items"]:
episodes = self.query(f"/Shows/{show['Id']}/Episodes?seasonId={season['Id']}&userId={user_id}&Fields=ItemCounts,ProviderIds,MediaSources", "get")
season_identifiers = dict(seasons["Identifiers"])
season_identifiers["season_id"] = season["Id"]
season_identifiers["season_name"] = season["Name"]
task = asyncio.ensure_future(self.query(f"/Shows/{season_identifiers['show_id']}/Episodes?seasonId={season['Id']}&userId={user_id}&isPlaceHolder=false&isPlayed=true&Fields=ProviderIds,MediaSources", "get", session, frozenset(season_identifiers.items())))
episodes_tasks.append(task)
watched_episodes = await asyncio.gather(*episodes_tasks)
for episodes in watched_episodes:
if len(episodes["Items"]) > 0:
for episode in episodes["Items"]:
if episode["UserData"]["Played"] == True:
if episode["ProviderIds"] or episode["MediaSources"]:
if "ProviderIds" in episode or "MediaSources" in episode:
episode_identifiers = dict(episodes["Identifiers"])
show_guids = episode_identifiers["show_guids"]
if show_guids not in user_watched[user_name][library_title]:
user_watched[user_name][library_title][show_guids] = {}
if season["Name"] not in user_watched[user_name][library_title][show_guids]:
user_watched[user_name][library_title][show_guids][season["Name"]] = []
if episode_identifiers["season_name"] not in user_watched[user_name][library_title][show_guids]:
user_watched[user_name][library_title][show_guids][episode_identifiers["season_name"]] = []
# Lowercase episode["ProviderIds"] keys
episode_guids = {}
if episode["ProviderIds"]:
if "ProviderIds" in episode:
episode_guids = {k.lower(): v for k, v in episode["ProviderIds"].items()}
if episode["MediaSources"]:
if "MediaSources" in episode:
episode_guids["locations"] = tuple([x["Path"].split("/")[-1] for x in episode["MediaSources"]])
user_watched[user_name][library_title][show_guids][season["Name"]].append(episode_guids)
user_watched[user_name][library_title][show_guids][episode_identifiers["season_name"]].append(episode_guids)
return user_watched
except Exception as e:
@ -121,26 +161,30 @@ class Jellyfin():
raise Exception(e)
def get_watched(self, users, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping=None):
async def get_users_watched(self, user_name, user_id, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping):
try:
users_watched = {}
args = []
for user_name, user_id in users.items():
# Get all libraries
user_name = user_name.lower()
tasks_watched = []
libraries = self.query(f"/Users/{user_id}/Views", "get")["Items"]
for library in libraries:
library_title = library["Name"]
tasks_libraries = []
async with aiohttp.ClientSession() as session:
libraries = await self.query(f"/Users/{user_id}/Views", "get", session)
for library in libraries["Items"]:
library_id = library["Id"]
watched = self.query(f"/Users/{user_id}/Items?SortBy=SortName&SortOrder=Ascending&Recursive=true&ParentId={library_id}&Filters=IsPlayed&limit=1", "get")
library_title = library["Name"]
identifiers = {"library_id": library_id, "library_title": library_title}
task = asyncio.ensure_future(self.query(f"/Users/{user_id}/Items?ParentId={library_id}&Filters=IsPlayed&limit=1", "get", session, identifiers=identifiers))
tasks_libraries.append(task)
libraries = await asyncio.gather(*tasks_libraries, return_exceptions=True)
for watched in libraries:
if len(watched["Items"]) == 0:
logger(f"Jellyfin: No watched items found in library {library_title}", 1)
continue
else:
library_id = watched["Identifiers"]["library_id"]
library_title = watched["Identifiers"]["library_title"]
library_type = watched["Items"][0]["Type"]
skip_reason = check_skip_logic(library_title, library_type, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping)
@ -149,10 +193,28 @@ class Jellyfin():
logger(f"Jellyfin: Skipping library {library_title} {skip_reason}", 1)
continue
args.append([self.get_user_watched, user_name, user_id, library_type, library_id, library_title])
# Get watched for user
task = asyncio.ensure_future(self.get_user_watched(user_name, user_id, library_type, library_id, library_title))
tasks_watched.append(task)
for user_watched in future_thread_executor(args):
for user, user_watched_temp in user_watched.items():
watched = await asyncio.gather(*tasks_watched, return_exceptions=True)
return watched
except Exception as e:
logger(f"Jellyfin: Failed to get users watched, Error: {e}", 2)
raise Exception(e)
async def get_watched(self, users, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping=None):
try:
users_watched = {}
watched = []
for user_name, user_id in users.items():
watched.append(await self.get_users_watched(user_name, user_id, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping))
for user_watched in watched:
user_watched_temp = combine_watched_dicts(user_watched)
for user, user_watched_temp in user_watched_temp.items():
if user not in users_watched:
users_watched[user] = {}
users_watched[user].update(user_watched_temp)
@ -162,15 +224,16 @@ class Jellyfin():
logger(f"Jellyfin: Failed to get watched, Error: {e}", 2)
raise Exception(e)
def update_user_watched(self, user_name, user_id, library, library_id, videos, dryrun):
async def update_user_watched(self, user_name, user_id, library, library_id, videos, dryrun):
try:
logger(f"Jellyfin: Updating watched for {user_name} in library {library}", 1)
videos_shows_ids, videos_episodes_ids, videos_movies_ids = generate_library_guids_dict(videos)
logger(f"Jellyfin: mark list\nShows: {videos_shows_ids}\nEpisodes: {videos_episodes_ids}\nMovies: {videos_movies_ids}", 1)
async with aiohttp.ClientSession() as session:
if videos_movies_ids:
jellyfin_search = self.query(f"/Users/{user_id}/Items?SortBy=SortName&SortOrder=Ascending&Recursive=false&ParentId={library_id}&isPlayed=false&Fields=ItemCounts,ProviderIds,MediaSources", "get")
jellyfin_search = await self.query(f"/Users/{user_id}/Items?SortBy=SortName&SortOrder=Ascending&Recursive=false&ParentId={library_id}&isPlayed=false&Fields=ItemCounts,ProviderIds,MediaSources", "get", session)
for jellyfin_video in jellyfin_search["Items"]:
movie_found = False
@ -192,7 +255,7 @@ class Jellyfin():
msg = f"{jellyfin_video['Name']} as watched for {user_name} in {library} for Jellyfin"
if not dryrun:
logger(f"Marking {msg}", 0)
self.query(f"/Users/{user_id}/PlayedItems/{jellyfin_video_id}", "post")
await self.query(f"/Users/{user_id}/PlayedItems/{jellyfin_video_id}", "post", session)
else:
logger(f"Dryrun {msg}", 0)
else:
@ -202,7 +265,7 @@ class Jellyfin():
# TV Shows
if videos_shows_ids and videos_episodes_ids:
jellyfin_search = self.query(f"/Users/{user_id}/Items?SortBy=SortName&SortOrder=Ascending&Recursive=false&ParentId={library_id}&isPlayed=false&Fields=ItemCounts,ProviderIds,Path", "get")
jellyfin_search = await self.query(f"/Users/{user_id}/Items?SortBy=SortName&SortOrder=Ascending&Recursive=false&ParentId={library_id}&isPlayed=false&Fields=ItemCounts,ProviderIds,Path", "get", session)
jellyfin_shows = [x for x in jellyfin_search["Items"]]
for jellyfin_show in jellyfin_shows:
@ -222,7 +285,7 @@ class Jellyfin():
if show_found:
logger(f"Jellyfin: Updating watched for {user_name} in library {library} for show {jellyfin_show['Name']}", 1)
jellyfin_show_id = jellyfin_show["Id"]
jellyfin_episodes = self.query(f"/Shows/{jellyfin_show_id}/Episodes?userId={user_id}&Fields=ItemCounts,ProviderIds,MediaSources", "get")
jellyfin_episodes = await self.query(f"/Shows/{jellyfin_show_id}/Episodes?userId={user_id}&Fields=ItemCounts,ProviderIds,MediaSources", "get", session)
for jellyfin_episode in jellyfin_episodes["Items"]:
episode_found = False
@ -245,7 +308,7 @@ class Jellyfin():
msg = f"{jellyfin_episode['SeriesName']} {jellyfin_episode['SeasonName']} Episode {jellyfin_episode['Name']} as watched for {user_name} in {library} for Jellyfin"
if not dryrun:
logger(f"Marked {msg}", 0)
self.query(f"/Users/{user_id}/PlayedItems/{jellyfin_episode_id}", "post")
await self.query(f"/Users/{user_id}/PlayedItems/{jellyfin_episode_id}", "post", session)
else:
logger(f"Dryrun {msg}", 0)
else:
@ -261,9 +324,10 @@ class Jellyfin():
raise Exception(e)
def update_watched(self, watched_list, user_mapping=None, library_mapping=None, dryrun=False):
async def update_watched(self, watched_list, user_mapping=None, library_mapping=None, dryrun=False):
try:
args = []
tasks = []
async with aiohttp.ClientSession() as session:
for user, libraries in watched_list.items():
logger(f"Jellyfin: Updating for entry {user}, {libraries}", 1)
user_other = None
@ -289,7 +353,8 @@ class Jellyfin():
logger(f"{user} {user_other} not found in Jellyfin", 2)
continue
jellyfin_libraries = self.query(f"/Users/{user_id}/Views", "get")["Items"]
jellyfin_libraries = await self.query(f"/Users/{user_id}/Views", "get", session)
jellyfin_libraries = [x for x in jellyfin_libraries["Items"]]
for library, videos in libraries.items():
library_other = None
@ -319,9 +384,10 @@ class Jellyfin():
continue
if library_id:
args.append([self.update_user_watched, user_name, user_id, library, library_id, videos, dryrun])
task = self.update_user_watched(user_name, user_id, library, library_id, videos, dryrun)
tasks.append(task)
future_thread_executor(args)
await asyncio.gather(*tasks, return_exceptions=True)
except Exception as e:
logger(f"Jellyfin: Error updating watched", 2)
raise Exception(e)

47
src/main.py
View File

@ -1,6 +1,6 @@
import copy, os, traceback, json
import copy, os, traceback, json, asyncio
from dotenv import load_dotenv
from time import sleep
from time import sleep, perf_counter
from src.functions import logger, str_to_bool, search_mapping, generate_library_guids_dict, future_thread_executor
from src.plex import Plex
@ -38,13 +38,15 @@ def cleanup_watched(watched_list_1, watched_list_2, user_mapping=None, library_m
logger(f"library {library_1} and {library_other} not found in watched list 2", 1)
continue
_, episode_watched_list_2_keys_dict, movies_watched_list_2_keys_dict = generate_library_guids_dict(watched_list_2[user_2][library_2])
# Movies
if isinstance(watched_list_1[user_1][library_1], list):
_, _, movies_watched_list_2_keys_dict = generate_library_guids_dict(watched_list_2[user_2][library_2])
for movie in watched_list_1[user_1][library_1]:
movie_found = False
for movie_key, movie_value in movie.items():
if movie_key == "locations":
if "locations" in movies_watched_list_2_keys_dict.keys():
for location in movie_value:
if location in movies_watched_list_2_keys_dict["locations"]:
movie_found = True
@ -63,7 +65,6 @@ def cleanup_watched(watched_list_1, watched_list_2, user_mapping=None, library_m
# TV Shows
elif isinstance(watched_list_1[user_1][library_1], dict):
# Generate full list of provider ids for episodes in watch_list_2 to easily compare if they exist in watch_list_1
_, episode_watched_list_2_keys_dict, _ = generate_library_guids_dict(watched_list_2[user_2][library_2])
for show_key_1 in watched_list_1[user_1][library_1].keys():
show_key_dict = dict(show_key_1)
@ -73,6 +74,7 @@ def cleanup_watched(watched_list_1, watched_list_2, user_mapping=None, library_m
for episode_key, episode_value in episode.items():
# If episode_key and episode_value are in episode_watched_list_2_keys_dict exactly, then remove from watch_list_1
if episode_key == "locations":
if "locations" in episode_watched_list_2_keys_dict.keys():
for location in episode_value:
if location in episode_watched_list_2_keys_dict["locations"]:
episode_found = True
@ -209,6 +211,8 @@ def setup_users(server_1, server_2, blacklist_users, whitelist_users, user_mappi
server_1_connection = server_1[1]
server_2_type = server_2[0]
server_2_connection = server_2[1]
print(f"Server 1: {server_1_type} {server_1_connection}")
print(f"Server 2: {server_2_type} {server_2_connection}")
server_1_users = []
if server_1_type == "plex":
@ -302,6 +306,7 @@ def generate_server_connections():
plex_username = os.getenv("PLEX_USERNAME", None)
plex_password = os.getenv("PLEX_PASSWORD", None)
plex_servername = os.getenv("PLEX_SERVERNAME", None)
ssl_bypass = str_to_bool(os.getenv("SSL_BYPASS", "False"))
if plex_baseurl and plex_token:
plex_baseurl = plex_baseurl.split(",")
@ -311,7 +316,7 @@ def generate_server_connections():
raise Exception("PLEX_BASEURL and PLEX_TOKEN must have the same number of entries")
for i, url in enumerate(plex_baseurl):
servers.append(("plex", Plex(baseurl=url.strip(), token=plex_token[i].strip(), username=None, password=None, servername=None)))
servers.append(("plex", Plex(baseurl=url.strip(), token=plex_token[i].strip(), username=None, password=None, servername=None, ssl_bypass=ssl_bypass)))
if plex_username and plex_password and plex_servername:
plex_username = plex_username.split(",")
@ -322,7 +327,7 @@ def generate_server_connections():
raise Exception("PLEX_USERNAME, PLEX_PASSWORD and PLEX_SERVERNAME must have the same number of entries")
for i, username in enumerate(plex_username):
servers.append(("plex", Plex(baseurl=None, token=None, username=username.strip(), password=plex_password[i].strip(), servername=plex_servername[i].strip())))
servers.append(("plex", Plex(baseurl=None, token=None, username=username.strip(), password=plex_password[i].strip(), servername=plex_servername[i].strip(), ssl_bypass=ssl_bypass)))
jellyfin_baseurl = os.getenv("JELLYFIN_BASEURL", None)
jellyfin_token = os.getenv("JELLYFIN_TOKEN", None)
@ -339,11 +344,12 @@ def generate_server_connections():
return servers
def main_loop():
logfile = os.getenv("LOGFILE","log.log")
# Delete logfile if it exists
if os.path.exists(logfile):
os.remove(logfile)
#if os.path.exists(logfile):
# os.remove(logfile)
dryrun = str_to_bool(os.getenv("DRYRUN", "False"))
logger(f"Dryrun: {dryrun}", 1)
@ -389,12 +395,10 @@ def main_loop():
server_1_users, server_2_users = setup_users(server_1, server_2, blacklist_users, whitelist_users, user_mapping)
logger("Creating watched lists", 1)
args = [[server_1_connection.get_watched, server_1_users, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping]
, [server_2_connection.get_watched, server_2_users, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping]]
results = future_thread_executor(args)
server_1_watched = results[0]
server_2_watched = results[1]
server_1_watched = server_1_connection.get_watched(server_1_users, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping)
logger("Finished creating watched list server 1", 0)
server_2_watched = asyncio.run(server_2_connection.get_watched(server_2_users, blacklist_library, whitelist_library, blacklist_library_type, whitelist_library_type, library_mapping))
logger("Finished creating watched list server 2", 0)
logger(f"Server 1 watched: {server_1_watched}", 3)
logger(f"Server 2 watched: {server_2_watched}", 3)
@ -411,19 +415,22 @@ def main_loop():
logger(f"server 1 watched that needs to be synced to server 2:\n{server_1_watched_filtered}", 1)
logger(f"server 2 watched that needs to be synced to server 1:\n{server_2_watched_filtered}", 1)
args= [[server_1_connection.update_watched, server_2_watched_filtered, user_mapping, library_mapping, dryrun]
, [server_2_connection.update_watched, server_1_watched_filtered, user_mapping, library_mapping, dryrun]]
future_thread_executor(args)
server_1_connection.update_watched(server_2_watched_filtered, user_mapping, library_mapping, dryrun)
asyncio.run(server_2_connection.update_watched(server_1_watched_filtered, user_mapping, library_mapping, dryrun))
def main():
sleep_duration = float(os.getenv("SLEEP_DURATION", "3600"))
times = []
while(True):
try:
start = perf_counter()
main_loop()
end = perf_counter()
times.append(end - start)
logger(f"Looping in {sleep_duration}")
sleep(sleep_duration)
except Exception as error:
if isinstance(error, list):
for message in error:
@ -437,5 +444,7 @@ def main():
sleep(sleep_duration)
except KeyboardInterrupt:
if len(times) > 0:
logger(f"Average time: {sum(times) / len(times)}", 0)
logger("Exiting", log_type=0)
os._exit(0)

10
src/plex.py
View File

@ -14,14 +14,19 @@ class Plex:
self.username = username
self.password = password
self.servername = servername
self.plex = self.login()
self.plex = self.login(ssl_bypass)
self.admin_user = self.plex.myPlexAccount()
self.users = self.get_users()
def login(self):
def login(self, ssl_bypass=False):
try:
if self.baseurl and self.token:
# Login via token
if ssl_bypass:
session = requests.Session()
session.verify = False
plex = PlexServer(self.baseurl, self.token, session=session)
else:
plex = PlexServer(self.baseurl, self.token)
elif self.username and self.password and self.servername:
# Login via plex account
@ -52,6 +57,7 @@ class Plex:
logger(f"Plex: Failed to get users, Error: {e}", 2)
raise Exception(e)
def get_user_watched(self, user, user_plex, library):
try:
user_name = user.title.lower()