async def add_to_plex(plexname, discordId, note, serverNumber=None):
if settings.ENABLE_BLACKLIST:
if db.check_blacklist(plexname):
return ['blacklist', 'username']
if db.check_blacklist(discordId):
return ['blacklist', 'id']
tempPlex = plex
if serverNumber is not None:
tempPlex = PlexServer(settings.PLEX_SERVER_URL[serverNumber],
settings.PLEX_SERVER_TOKEN[serverNumber])
try:
if db.add_user_to_db(discordId=discordId,
username=plexname,
note=note,
serverNumber=serverNumber):
tempPlex.myPlexAccount().inviteFriend(user=plexname,
server=tempPlex,
sections=None,
allowSync=False,
allowCameraUpload=False,
allowChannels=False,
filterMovies=None,
filterTelevision=None,
filterMusic=None)
await asyncio.sleep(30)
px.add_to_tautulli(serverNumber)
if note != 't': # Trial members do not have access to Ombi
px.add_to_ombi()
return [True, None]
else:
print("{} could not be added to the database.".format(plexname))
return [False, None]
except Exception as e:
print(e)
return [False, None]
def full_check():
from_profile = sdr.get_profile_id('Hold')
to_profile = sdr.get_profile_id('Best')
plex = PlexServer(conf['plex']['host'], conf['plex']['api'])
users = [user.title for user in plex.myPlexAccount().users()]
users.insert(0, plex.myPlexAccount().username)
series = sdr.get_series()
for show in series:
try:
try:
tag_id = show['tags'][0]
except:
tag_id = 0
if tag_id == 2:
logger.info("Starting %s" % show['title'])
remaining_episodes = show['totalEpisodeCount'] - (
show['seasons'][0]['statistics']['totalEpisodeCount']
if show['seasons'][0]['seasonNumber'] == 0 else
0) - show['episodeCount']
if remaining_episodes > 0:
(last_watched, highest_season,
season_count) = find_last_watched(show, users)
update_show(show, highest_season, season_count,
last_watched)
else:
logger.info("Monitoring All Episodes for %s" %
show['title'])
except Exception as e:
logger.error('Error on line {}, {}. {}'.format(
sys.exc_info()[-1].tb_lineno,
type(e).__name__, e))
def delete_from_plex(id):
tempPlex = plex
serverNumber = 0
try:
results = db.find_user_in_db("Plex", id)
plexname = results[0]
note = results[1]
if settings.MULTI_PLEX:
serverNumber = results[2]
tempPlex = PlexServer(settings.PLEX_SERVER_URL[serverNumber],
settings.PLEX_SERVER_TOKEN[serverNumber])
if plexname is not None:
tempPlex.myPlexAccount().removeFriend(user=plexname)
if note != 't':
px.delete_from_ombi(
plexname
) # Error if trying to remove trial user that doesn't exist in Ombi?
px.delete_from_tautulli(plexname, serverNumber)
db.remove_user_from_db(id)
return True, serverNumber
else:
return False, serverNumber
except plexapi.exceptions.NotFound:
# print("Not found")
return False, serverNumber
def getPlexUsers(serverNumber=None):
"""
Returns all usernames (lowercase for comparison)
"""
users = []
tempPlex = plex
tempServerName = settings.PLEX_SERVER_NAME
tempServerAltName = settings.PLEX_SERVER_ALT_NAME
if settings.MULTI_PLEX:
if serverNumber: # from specific server
tempPlex = PlexServer(settings.PLEX_SERVER_URL[serverNumber],
settings.PLEX_SERVER_TOKEN[serverNumber])
tempServerName = settings.PLEX_SERVER_NAME[serverNumber]
tempServerAltName = settings.PLEX_SERVER_ALT_NAME[serverNumber]
for u in tempPlex.myPlexAccount().users():
for s in u.servers:
if s.name == tempServerName or s.name == tempServerAltName:
users.append(u.username.lower())
else: # from all servers
for serverNumber in range(len(settings.PLEX_SERVER_URL)):
tempPlex = PlexServer(settings.PLEX_SERVER_URL[serverNumber],
settings.PLEX_SERVER_TOKEN[serverNumber])
tempServerName = settings.PLEX_SERVER_NAME[serverNumber]
tempServerAltName = settings.PLEX_SERVER_ALT_NAME[serverNumber]
for u in tempPlex.myPlexAccount().users():
for s in u.servers:
if s.name == tempServerName or s.name == tempServerAltName:
users.append(u.username.lower())
else: # from the single server
for u in tempPlex.myPlexAccount().users():
for s in u.servers:
if s.name == tempServerName or s.name == tempServerAltName:
users.append(u.username.lower())
return users
def delete_from_plex(self, plexname, serverNumber = None):
tempPlex = plex;
if serverNumber != None:
tempPlex = PlexServer(PLEX_SERVER_URLS_LIST[serverNumber],PLEX_SERVER_TOKENS_LIST[serverNumber])
try:
tempPlex.myPlexAccount().removeFriend(user=plexname)
self.delete_from_ombi(plexname) # Error if trying to remove trial user that doesn't exist in Ombi?
self.delete_from_tautulli(plexname, serverNumber)
return True
except plexapi.exceptions.NotFound:
#print("Not found")
return False
async def add_to_plex(self, plexname, note, serverNumber = None):
tempPlex = plex;
if serverNumber != None:
tempPlex = PlexServer(PLEX_SERVER_URLS_LIST[serverNumber],PLEX_SERVER_TOKENS_LIST[serverNumber])
try:
tempPlex.myPlexAccount().inviteFriend(user=plexname,server=plex,sections=None, allowSync=False, allowCameraUpload=False, allowChannels=False, filterMovies=None, filterTelevision=None, filterMusic=None)
await asyncio.sleep(60)
self.add_to_tautulli(plexname, serverNumber)
if note != 't': # Trial members do not have access to Ombi
self.add_to_ombi(plexname)
return True
except Exception as e:
print(e)
return False
def delete_from_plex(plexname, serverNumber=None):
tempPlex = plex
if serverNumber:
tempPlex = PlexServer(settings.PLEX_SERVER_URL[serverNumber],
settings.PLEX_SERVER_TOKEN[serverNumber])
try:
tempPlex.myPlexAccount().removeFriend(user=plexname)
px.delete_from_ombi(
plexname
) # Error if trying to remove trial user that doesn't exist in Ombi?
px.delete_from_tautulli(plexname, serverNumber)
return True
except plexapi.exceptions.NotFound:
print("Couldn't delete user {}".format(plexname))
return False
async def pm_access(self, ctx: commands.Context, PlexUsername: str):
"""
Check if you or another user has access to the Plex server
"""
hasAccess = False
name = PlexUsername
serverNumber = 0
if name != None:
if MULTI_PLEX:
for i in range(0,len(PLEX_SERVER_URLS_LIST)):
tempPlex = PlexServer(PLEX_SERVER_URLS_LIST[i],PLEX_SERVER_TOKENS_LIST[i])
for u in tempPlex.myPlexAccount().users():
if u.username == name:
for s in u.servers:
if s.name == PLEX_SERVER_NAMES_LIST[i]:
hasAccess = True
serverNumber = i
break
break
break
else:
for u in plex.myPlexAccount().users():
if u.username == name:
for s in u.servers:
if s.name == PLEX_SERVER_NAME or s.name == PLEX_SERVER_ALT_NAME:
hasAccess = True
break
break
if hasAccess:
await ctx.send(("You have" if PlexUsername is None else name + " has") + " access to " + (PLEX_SERVER_NAMES_LIST[serverNumber] if MULTI_PLEX else PLEX_SERVER_NAME))
else:
await ctx.send(("You do not have" if PlexUsername is None else name + " does not have") + " access to " + ("any of the Plex servers" if MULTI_PLEX else PLEX_SERVER_NAME))
else:
await ctx.send("User not found.")
def get_episode(series_title, season_number, episode_number, user):
try:
pause = 0
while True:
pause += 1
try:
plex_temp = PlexServer(conf['plex']['host'],
conf['plex']['api'])
if user != plex_temp.myPlexAccount().username:
plex_users = get_user_tokens(plex_temp.machineIdentifier)
token = plex_users[user]
plex_temp = PlexServer(conf['plex']['host'], token)
with DisableLogger():
episode = plex_temp.library.section(
'TV Shows').searchShows(title=series_title)[0].episode(
season=season_number, episode=episode_number)
return episode
except plexapi.exceptions.NotFound:
return False
except:
time.sleep(pause)
continue
except plexapi.exceptions.NotFound:
return False
except Exception as e:
logger.error('Error on line {}, {}, {}'.format(
sys.exc_info()[-1].tb_lineno,
type(e).__name__, e))
logger.error('Error! Code: {c}, Message, {m}'.format(
c=type(e).__name__, m=str(e)))
return None
def hello():
baseurl = 'http://' + SERVER_IP + ':' + PORT
plex = PlexServer(baseurl, TOKEN)
account = plex.myPlexAccount()
art = None
showTitle = None
title = None
username = None
sessions = []
for i in plex.sessions():
art = i.artUrl
if i.type == 'episode':
showTitle = i.grandparentTitle
else:
showTitle = ''
title = i.title
username = i.usernames[0]
session = {
'art': art,
'showTitle': showTitle,
'title': title,
'username': username
}
sessions.append(session)
return render_template('index.html', sessions=sessions)
def signInLocally():
""" Returns a :class:`~plexapi.server.PlexServer` by connecting through
the local network.
"""
# Get URL and token from config.ini
plexURL = ""
plexToken = ""
config = configparser.ConfigParser()
try:
config.read('config.ini')
plexURL = config['LOGIN']['PLEX_URL']
plexToken = config['LOGIN']['PLEX_TOKEN']
except KeyError:
copyfile("./resources/config_template.ini", "config.ini")
print("Error reading config.ini. New file created.")
# Attempt to sign in
isSignedIn = False
while not isSignedIn:
if plexURL == '' or plexToken == '':
# Get URL and token from user
plexURL = input("Input server URL [Ex. "
"https://192.168.1.50:32400]: ")
plexToken = input("Input Plex access token [Info here: "
"https://bit.ly/2p7RtOu]: ")
# Sign in
print("Signing in...")
try:
requests.packages.urllib3.disable_warnings()
session = requests.Session()
session.verify = False
plexServer = PlexServer(plexURL, plexToken, session=session)
account = plexServer.myPlexAccount()
isSignedIn = True
except (requests.ConnectionError, requests.exceptions.MissingSchema,
BadRequest) as error:
# Connection failed
if (isinstance(error, requests.ConnectionError)
or isinstance(error, requests.exceptions.MissingSchema)):
print("Error: No server found at the given URL.")
else:
print("Error: Invalid API token.")
# Clear info and try again
plexURL = ''
plexToken = ''
# Give option to sign in as Managed User if server has them
if account.subscriptionActive and account.homeSize > 1:
# Sign in as managed user?
useManagedUser = getYesOrNoFromUser("Sign in as managed user? [Y/n]: ")
# If yes, sign in as managed user
if useManagedUser == 'y':
plexServer = signInManagedUser(plexServer)
return plexServer
def delete_from_plex(id):
"""
Remove a Discord user from Plex
Returns:
200 - user found and removed successfully
400 - user found in database, but not found on Plex
600 - user found, but not removed
700 - user not found in database
500 - unknown error
"""
tempPlex = plex
serverNumber = 0
try:
results = db.find_user_in_db(ServerOrDiscord="Plex", data=id)
if not results:
return 700, serverNumber # user not found
plexname = results[0]
note = results[1]
if settings.MULTI_PLEX:
serverNumber = results[2]
tempPlex = PlexServer(settings.PLEX_SERVER_URL[serverNumber],
settings.PLEX_SERVER_TOKEN[serverNumber])
if not plexname:
return 700, serverNumber # user not found
else:
try:
tempPlex.myPlexAccount().removeFriend(user=plexname)
if note != 't':
px.delete_from_ombi(
plexname
) # Error if trying to remove trial user that doesn't exist in Ombi?
px.delete_from_tautulli(plexname, serverNumber)
db.remove_user_from_db(id)
return 200, serverNumber
except plexapi.exceptions.NotFound:
return 500, serverNumber # user not found on Plex
except Exception as e:
print(e)
return 400, serverNumber # user not removed completely
except plexapi.exceptions.NotFound:
# print("Not found")
return 400, serverNumber # user not found on Plex
except Exception as e:
print(e)
return 500, serverNumber # unknown error
def countServerSubs(self, serverNumber):
tempPlex = PlexServer(PLEX_SERVER_URLS_LIST[serverNumber],PLEX_SERVER_TOKENS_LIST[serverNumber])
tempServerName = PLEX_SERVER_NAMES_LIST[serverNumber]
count = 0
for u in tempPlex.myPlexAccount().users():
for s in u.servers:
if s.name == tempServerName:
count+=1
return count
async def pm_access(self, ctx: commands.Context, PlexUsername: str = None):
"""
Check if you or another user has access to the Plex server
"""
hasAccess = False
serverNumber = 0
if PlexUsername is None:
name = db.find_user_in_db(ServerOrDiscord="Plex",
data=ctx.message.author.id)[0]
else:
name = PlexUsername
if name is not None:
if settings.MULTI_PLEX:
for i in range(0, len(settings.PLEX_SERVER_URL)):
tempPlex = PlexServer(settings.PLEX_SERVER_URL[i],
settings.PLEX_SERVER_TOKEN[i])
for u in tempPlex.myPlexAccount().users():
if u.username == name:
for s in u.servers:
if s.name == settings.PLEX_SERVER_NAME[
i] or s.name == settings.PLEX_SERVER_ALT_NAME[
i]:
hasAccess = True
serverNumber = i
break
break
break
else:
for u in plex.myPlexAccount().users():
if u.username == name:
for s in u.servers:
if s.name == settings.PLEX_SERVER_NAME[
0] or s.name == settings.PLEX_SERVER_ALT_NAME[
0]:
hasAccess = True
break
break
if hasAccess:
await ctx.send(
("You have" if PlexUsername is None else name + " has") +
" access to " +
(settings.PLEX_SERVER_NAME[serverNumber] if settings.
MULTI_PLEX else settings.PLEX_SERVER_NAME[0]))
else:
await ctx.send(
("You do not have" if PlexUsername is None else name +
" does not have") + " access to " +
("any of the Plex servers" if settings.
MULTI_PLEX else settings.PLEX_SERVER_NAME[0]))
else:
await ctx.send("User not found.")
def full_check():
plex = PlexServer(config.plex_host, config.plex_api)
users = [user.title for user in plex.myPlexAccount().users()]
users.insert(0, plex.myPlexAccount().username)
series = sdr.get_series()
for show in random.sample(series, len(series)):
try:
try:
tag_id = show['tags'][0]
except:
tag_id = 0 #NEED TAG CONFIG
if tag_id == 2: #NEED TAG CONFIG
logger.info("Starting %s" % show['title'])
try:
remaining_episodes = show['totalEpisodeCount'] - (
show['seasons'][0]['statistics']['totalEpisodeCount']
if show['seasons'][0]['seasonNumber'] == 0 else
0) - show['episodeCount']
except:
remaining_episodes = 0
if remaining_episodes > 0:
(last_watched, highest_season,
season_count) = find_last_watched(show, users)
update_show(show, highest_season, season_count,
last_watched)
else:
logger.info("Monitoring All Episodes for %s" %
show['title'])
except Exception as e:
logger.error('Error on line {}, {}. {}'.format(
sys.exc_info()[-1].tb_lineno,
type(e).__name__, e))
else:
if len(series) == 0: logger.info("Not Shows Found")
def getPlexFriends(serverNumber=None):
"""
# Returns all usernames of Plex Friends (access in + access out)
(lowercase for comparison)
"""
if settings.MULTI_PLEX:
if serverNumber: # from a specific server
tempPlex = PlexServer(settings.PLEX_SERVER_URL[serverNumber],
settings.PLEX_SERVER_TOKEN[serverNumber])
return [
u.username.lower() for u in tempPlex.myPlexAccount().users()
]
else: # from all servers
users = []
for i in range(len(settings.PLEX_SERVER_URL)):
tempPlex = PlexServer(settings.PLEX_SERVER_URL[i],
settings.PLEX_SERVER_TOKEN[i])
for u in tempPlex.myPlexAccount().users():
users.append(u.username.lower())
return users
else: # from the one server
tempPlex = PlexServer(settings.PLEX_SERVER_URL[0],
settings.PLEX_SERVER_TOKEN[0])
return [u.username.lower() for u in tempPlex.myPlexAccount().users()]
def countServerSubs(serverNumber=None):
tempPlex = plex
tempServerName = settings.PLEX_SERVER_NAME[0]
tempServerAltName = settings.PLEX_SERVER_ALT_NAME[0]
if serverNumber and serverNumber >= 0:
tempPlex = PlexServer(settings.PLEX_SERVER_URL[serverNumber],
settings.PLEX_SERVER_TOKEN[serverNumber])
tempServerName = settings.PLEX_SERVER_NAME[serverNumber]
tempServerAltName = settings.PLEX_SERVER_ALT_NAME[serverNumber]
count = 0
for u in tempPlex.myPlexAccount().users():
for s in u.servers:
if s.name == tempServerName or s.name == tempServerAltName:
count += 1
return count
def data():
baseurl = 'http://' + SERVER_IP + ':' + PORT
plex = PlexServer(baseurl, TOKEN)
account = plex.myPlexAccount()
player = request.form.get('player')
for client in plex.clients():
if (player == client.name):
media = plex.search(request.form.get('title'))
player.playMedia(media)
return render_template('success.html',
art=request.form.get('art'),
player=player,
title=request.form.get('title'))
return render_template('notfound.html', art=request.form.get('art'))
def main():
"""Main script"""
plex = PlexServer(PLEX_URL, PLEX_TOKEN)
PLAYLISTS = [x.title for x in plex.playlists()]
USERS = [x.title for x in plex.myPlexAccount().users()]
plex_users = get_user_tokens(plex.machineIdentifier)
plex_playlists = {playlist.title: playlist.items() for playlist in plex.playlists()}
for playlist in PLAYLISTS:
playlist_items = plex_playlists.get(playlist)
if not playlist_items:
print("Playlist '{playlist}' not found on the server. Skipping.".format(playlist=playlist))
continue
print("Cloning the '{title}' playlist...".format(title=playlist))
for user in USERS:
user_token = plex_users.get(user)
if not user_token:
print("...User '{user}' not found in shared users. Skipping.".format(user=user))
continue
user_plex = PlexServer(PLEX_URL, user_token)
# Delete the old playlist
try:
user_playlist = user_plex.playlist(playlist)
user_playlist.delete()
except:
pass
# Create a new playlist
user_plex.createPlaylist(playlist, playlist_items)
print("...Created playlist for '{user}'.".format(user=user))
return
class Plex:
def __init__(self, url, token, server_name):
self.url = url
self.token = token
self.server_name = server_name
self.server = PlexServer(url, token)
def get_users(self):
return self.server.myPlexAccount().users()
def user_has_server_access(self, user):
for s in user.servers:
if s.name == self.server_name:
return True
return False
def get_playlists(self):
return self.server.playlists()
def get_library_sections(self):
return self.server.library.sections()
def get_all_section_items(self, section):
return section.all()
DAYS = 30
TOP = 5
sess = requests.Session()
# Ignore verifying the SSL certificate
sess.verify = False # '/path/to/certfile'
# If verify is set to a path to a directory,
# the directory must have been processed using the c_rehash utility supplied
# with OpenSSL.
if sess.verify is False:
# Disable the warning that the request is insecure, we know that...
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=sess)
account = plex.myPlexAccount()
user_lst = [x.title for x in plex.myPlexAccount().users() if x.servers and x.friend]
sections = plex.library.sections()
sections_dict = {x.key: x.title for x in sections}
filters_lst = list(set([y for x in sections if x.type != 'photo' for y in x.ALLOWED_FILTERS]))
playlist_lst = [x.title for x in plex.playlists()]
today = datetime.datetime.now().date()
weeknum = datetime.date(today.year, today.month, today.day).isocalendar()[1]
def actions():
"""
add - create new playlist for admin or users
remove - remove playlist type or name from admin or users
update - remove playlist type and create new playlist type for admin or users
sess = requests.Session()
# Ignore verifying the SSL certificate
sess.verify = False # '/path/to/certfile'
# If verify is set to a path to a directory,
# the directory must have been processed using the c_rehash utility supplied
# with OpenSSL.
if sess.verify is False:
# Disable the warning that the request is insecure, we know that...
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=sess)
user_lst = [x.title for x in plex.myPlexAccount().users()]
sections_lst = [x.title for x in plex.library.sections()]
movies_keys = [x.key for x in plex.library.sections() if x.type == 'movie']
show_keys = [x.key for x in plex.library.sections() if x.type == 'show']
def get_ratings_lst(section_id):
headers = {'Accept': 'application/json'}
params = {'X-Plex-Token': PLEX_TOKEN}
content = requests.get("{}/library/sections/{}/contentRating".format(PLEX_URL, section_id),
headers=headers, params=params)
# print(json.dumps(content.json(), indent=4, sort_keys=True))
ratings_keys = content.json()['MediaContainer']['Directory']
ratings_lst = [x['title'] for x in ratings_keys]
return ratings_lst
TAUTULLI_URL = TAUTULLI_URL or CONFIG.data['auth'].get('tautulli_baseurl')
TAUTULLI_APIKEY = TAUTULLI_APIKEY or CONFIG.data['auth'].get('tautulli_apikey')
USERNAME_IGNORE = [username.lower() for username in USERNAME_IGNORE]
SESSION = Session()
# Ignore verifying the SSL certificate
SESSION.verify = False # '/path/to/certfile'
# If verify is set to a path to a directory,
# the directory must have been processed using the c_rehash utility supplied with OpenSSL.
if not SESSION.verify:
# Disable the warning that the request is insecure, we know that...
from urllib3 import disable_warnings
from urllib3.exceptions import InsecureRequestWarning
disable_warnings(InsecureRequestWarning)
SERVER = PlexServer(baseurl=PLEX_URL, token=PLEX_TOKEN, session=SESSION)
ACCOUNT = SERVER.myPlexAccount()
SECTIONS = [section.title for section in SERVER.library.sections()]
PLEX_USERS = {user.id: user.title for user in ACCOUNT.users()}
PLEX_USERS.update({int(ACCOUNT.id): ACCOUNT.title})
IGNORED_UIDS = [uid for uid, username in PLEX_USERS.items() if username.lower() in USERNAME_IGNORE]
IGNORED_UIDS.extend((int(ACCOUNT.id), 0))
# Get the Tautulli history.
PARAMS = {
'cmd': 'get_users_table',
'order_column': 'last_seen',
'order_dir': 'asc',
'length': 200,
'apikey': TAUTULLI_APIKEY
}
TAUTULLI_USERS = []
try:
# Ignore verifying the SSL certificate
sess.verify = False # '/path/to/certfile'
# If verify is set to a path to a directory,
# the directory must have been processed using the c_rehash utility supplied
# with OpenSSL.
if sess.verify is False:
# Disable the warning that the request is insecure, we know that...
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=sess)
user_lst = {
x.title: x.email if x.email else x.title
for x in plex.myPlexAccount().users() if x.title
}
user_choices = list(set(user_lst.values())) + list(user_lst.keys())
sections_lst = [x.title for x in plex.library.sections()]
movies_keys = [x.key for x in plex.library.sections() if x.type == 'movie']
show_keys = [x.key for x in plex.library.sections() if x.type == 'show']
json_check = sorted([
f for f in os.listdir('.') if os.path.isfile(f) and f.endswith(".json")
and f.startswith(plex.friendlyName)
],
key=os.path.getmtime)
my_server_names = []
# Find all owners server names. For owners with multiple servers.
for res in plex.myPlexAccount().resources():
sess = requests.Session()
# Ignore verifying the SSL certificate
sess.verify = False # '/path/to/certfile'
# If verify is set to a path to a directory,
# the directory must have been processed using the c_rehash utility supplied
# with OpenSSL.
if sess.verify is False:
# Disable the warning that the request is insecure, we know that...
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=sess)
user_lst = [x.title for x in plex.myPlexAccount().users()]
sections_lst = [x.title for x in plex.library.sections()]
movies_keys = [x.key for x in plex.library.sections() if x.type == 'movie']
show_keys = [x.key for x in plex.library.sections() if x.type == 'show']
json_check = sorted([
f for f in os.listdir('.') if os.path.isfile(f) and f.endswith(".json")
and f.startswith(plex.friendlyName)
],
key=os.path.getmtime)
my_server_names = []
# Find all owners server names. For owners with multiple servers.
for res in plex.myPlexAccount().resources():
if res.provides == 'server' and res.owned == True:
my_server_names.append(res.name)
import requests
import argparse
from plexapi.server import PlexServer, CONFIG
# Using CONFIG file
PLEX_URL = ''
PLEX_TOKEN = ''
PLEX_URL = CONFIG.data['auth'].get('server_baseurl', PLEX_URL)
PLEX_TOKEN = CONFIG.data['auth'].get('server_token', PLEX_TOKEN)
sess = requests.Session()
sess.verify = False
plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=sess)
sections_lst = [x.title for x in plex.library.sections()]
user_lst = [x.title for x in plex.myPlexAccount().users()]
# Adding admin account name to list
user_lst.append(plex.myPlexAccount().title)
def get_account(user):
if user == plex.myPlexAccount().title:
server = plex
else:
# Access Plex User's Account
userAccount = plex.myPlexAccount().user(user)
token = userAccount.get_token(plex.machineIdentifier)
server = PlexServer(PLEX_URL, token)
return server
if not PLEX_TOKEN:
PLEX_TOKEN = CONFIG.data['auth'].get('server_token', '')
sess = requests.Session()
# Ignore verifying the SSL certificate
sess.verify = False # '/path/to/certfile'
# If verify is set to a path to a directory,
# the directory must have been processed using the c_rehash utility supplied
# with OpenSSL.
if sess.verify is False:
# Disable the warning that the request is insecure, we know that...
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=sess)
account = plex.myPlexAccount()
def actions():
"""
deck - Items that are On Deck
watch - Items that are Continue Watching
"""
return ['deck', 'watch']
def get_con_watch(server, off_deck=None):
"""
Parameters
----------
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Remove current Plex Server and a Client from MyPlex account. Useful when running tests in CI.
"""
from plexapi.myplex import MyPlexAccount
from plexapi.server import PlexServer
from plexapi import X_PLEX_IDENTIFIER
if __name__ == '__main__':
myplex = MyPlexAccount()
plex = PlexServer(token=myplex.authenticationToken)
for device in plex.myPlexAccount().devices():
if device.clientIdentifier == plex.machineIdentifier:
print('Removing device "%s", with id "%s"' %
(device.name, device.clientIdentifier))
device.delete()
# If we suddenly remove the client first we wouldn't be able to authenticate to delete the server
for device in plex.myPlexAccount().devices():
if device.clientIdentifier == X_PLEX_IDENTIFIER:
print('Removing device "%s", with id "%s"' %
(device.name, device.clientIdentifier))
device.delete()
break
sess = requests.Session()
# Ignore verifying the SSL certificate
sess.verify = False # '/path/to/certfile'
# If verify is set to a path to a directory,
# the directory must have been processed using the c_rehash utility supplied
# with OpenSSL.
if sess.verify is False:
# Disable the warning that the request is insecure, we know that...
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=sess)
sections_lst = [x.title for x in plex.library.sections()]
admin = {plex.myPlexAccount().id: plex.myPlexAccount().title}
users_dict = {x.id: x.title for x in plex.myPlexAccount().users() if x.servers}
users_dict.update(admin)
today = time.mktime(datetime.datetime.today().timetuple())
def get_users_table():
# Get the Tautulli history.
payload = {
'apikey': TAUTULLI_APIKEY,
'cmd': 'get_users_table',
'order_column': 'last_seen',
'order_dir': 'asc'
}
try:
if _meta:
metadata = Metadata(_meta)
metadata.transcode_count = transcode_count
transcoding_lst.append(metadata)
else:
print("Metadata error found with rating_key: ({})".format(
rating_key))
return transcoding_lst
if __name__ == '__main__':
session = Connection().session
plex = PlexServer(PLEX_URL, PLEX_TOKEN, session=session)
all_users = plex.myPlexAccount().users()
all_users.append(plex.myPlexAccount())
users = {
user.title: User(name=user.title, email=user.email, userid=user.id)
for user in all_users
}
user_choices = []
for user in users.values():
if user.email:
user_choices.append(user.email)
user_choices.append(user.userid)
user_choices.append(user.name)
sections_lst = [x.title for x in plex.library.sections()]
parser = argparse.ArgumentParser(