async def connect(self) -> None:
while True:
try:
if self.token:
self.plex_account = MyPlexAccount(self.username,
token=self.token)
else:
self.plex_account = MyPlexAccount(self.username,
self.password)
log.info(f'Logged into Plex as {self.username}.')
self.plex_server = self.plex_account.resource(
self.server).connect()
log.info(f'Connected to Plex {self.server} server.')
break
except Exception as err:
log.error(f'Failed to connect to Plex: {err}')
log.debug('Attempting reconnection in 10 seconds..')
await asyncio.sleep(10)
log.debug('Attempting to open IPC connection to Discord..')
await super().connect()
log.info('IPC connection established to Discord.')
self.connected.set()
def getMyPlexAccount(opts=None): # pragma: no cover
""" Helper function tries to get a MyPlex Account instance by checking
the the following locations for a username and password. This is
useful to create user-friendly command line tools.
1. command-line options (opts).
2. environment variables and config.ini
3. Prompt on the command line.
"""
from plexapi import CONFIG
from plexapi.myplex import MyPlexAccount
# 1. Check command-line options
if opts and opts.username and opts.password:
print('Authenticating with Plex.tv as %s..' % opts.username)
return MyPlexAccount(opts.username, opts.password)
# 2. Check Plexconfig (environment variables and config.ini)
config_username = CONFIG.get('auth.myplex_username')
config_password = CONFIG.get('auth.myplex_password')
if config_username and config_password:
print('Authenticating with Plex.tv as %s..' % config_username)
return MyPlexAccount(config_username, config_password)
config_token = CONFIG.get('auth.server_token')
if config_token:
print('Authenticating with Plex.tv with token')
return MyPlexAccount(token=config_token)
# 3. Prompt for username and password on the command line
username = input('What is your plex.tv username: '******'What is your plex.tv password: '******'Authenticating with Plex.tv as %s..' % username)
return MyPlexAccount(username, password)
def connect(self, server, username, password='', token=''):
self.logger.info(f'Connecting to the Plex Server {server} with username {username}.')
connection_attempts_left = self.maximum_connection_attempts
while connection_attempts_left > 0:
time.sleep(1) # important. Otherwise, the above print statement can be flushed after
if (not password) & (not token):
password = getpass.getpass()
try:
if (password):
self.account = MyPlexAccount(username=username, password=password)
elif (token):
self.account = MyPlexAccount(username=username, token=token)
break
except NotFound:
print(f'Username {username}, password or token wrong for server {server}.')
password = ''
connection_attempts_left -= 1
except BadRequest as error:
self.logger.warning('Failed to connect: {}'.format(error))
connection_attempts_left -= 1
if connection_attempts_left == 0 or self.account is None:
self.logger.error('Exiting after {} failed attempts ...'.format(self.maximum_connection_attempts))
exit(1)
self.logger.info('Connecting to remote player {} on the server {}'.format(self.name(), server))
try:
self.plex_api_connection = self.account.resource(server).connect(timeout=5)
self.logger.info('Successfully connected')
except NotFound:
# This also happens if the user is not the owner of the server
self.logger.error('Error: Unable to connect')
exit(1)
self.logger.info('Looking for music libraries')
music_libraries = {
section.key:
section for section
in self.plex_api_connection.library.sections()
if section.type == 'artist'}
if len(music_libraries) == 0:
self.logger.error('No music library found')
exit(1)
elif len(music_libraries) == 1:
self.music_library = list(music_libraries.values())[0]
self.logger.debug('Found 1 music library')
else:
print('Found multiple music libraries:')
for key, library in music_libraries.items():
print('\t[{}]: {}'.format(key, library.title))
choice = input('Select the library to sync with: ')
self.music_library = music_libraries[int(choice)]
def get_plex():
if settings.PLEX_CONFIG.get('baseurl'):
return PlexServer(**settings.PLEX_CONFIG)
elif settings.MYPLEX_CONFIG.get('token'):
account = MyPlexAccount(settings.MYPLEX_CONFIG.get('token'))
elif settings.MYPLEX_CONFIG.get('username'):
account = MyPlexAccount(settings.MYPLEX_CONFIG.get('username'),
settings.MYPLEX_CONFIG.get('password'))
plex = account.resource(settings.MYPLEX_CONFIG.get('server')).connect()
logger.debug("Using Plex account auth token {}".format(
account.authenticationToken))
return plex
def __init__(self, settings):
self.__settings = settings
try:
account = MyPlexAccount(settings.plex["user"], settings.plex["password"])
self.__plex = account.resource(settings.plex["servername"]).connect()
except:
print("Could not connect to Plex API")
def signInOnline():
""" Returns a :class:`~plexapi.server.PlexServer` by connecting online
through MyPlex.
"""
# Attempt to sign on
isSignedIn = False
while not isSignedIn:
# Get login info from user
username = input("Plex username: "******"Plex password: "******"Plex server name: ")
# Sign in via MyPlex
print("Signing in (this may take awhile)...")
try:
account = MyPlexAccount(username, password)
plexServer = account.resource(serverName).connect()
isSignedIn = True
except BadRequest:
print("Error: Login failed. Are your credentials correct?")
except NotFound:
print("Error: Server '%s' not found linked to your account." %
serverName)
return plexServer
def build_config():
if not os.path.exists(config_path):
print("Dumping default config to: %s" % config_path)
configs = dict(url='', token='', auto_delete=False)
# Get URL
configs['url'] = input("Plex Server URL: ")
# Get Credentials for plex.tv
user = input("Plex Username: ")
password = getpass('Plex Password: '******'token'] = account.authenticationToken
with open(config_path, 'w') as fp:
json.dump(prefilled_default_config(configs),
fp,
sort_keys=True,
indent=2)
return True
else:
return False
def cli(debug, username, password, servername, url, token, config):
""" Entry point for the CLI."""
global PMS
# click.echo('debug %s' % debug)
# click.echo('username %s' % username)
# click.echo('password %s' % password)
# click.echo('servername %s' % servername)
# click.echo('url %s' % url)
# click.echo('token %s' % token)
# click.echo('config %s' % config)
if debug:
LOG.setLevel(logging.DEBUG)
else:
LOG.setLevel(logging.INFO)
if username and password and servername:
from plexapi.myplex import MyPlexAccount
acc = MyPlexAccount(username, password)
PMS = acc.resource(servername).connect()
elif url and token:
PMS = PlexServer(url, token)
else:
PMS = PlexServer('', '') # plexapi will pull config file..
# CONFIG is unused atm.
click.echo('Watching for media on %s' % PMS.friendlyName)
def get_plex_server():
PlexMethod = MyPlexAccount
if fpssConfig['plexmethod'] == 'MyPlexAccount':
# Use the My Plex Account method of connecting
#account = MyPlexAccount(fpssConfig['plexusername'], fpssConfig['plexpassword'], token=fpssConfig['plexauthtoken'], timeout=5)
account = MyPlexAccount(fpssConfig['plexusername'],
fpssConfig['plexpassword'],
timeout=5)
cons = account.resource(fpssConfig['plexserver']).connections
print("Connections available:", len(cons), "Access Token:",
account.resource(fpssConfig['plexserver']).accessToken)
for r in range(0, len(cons)):
conr = cons[r]
#print(dir(conr))
print(conr.address, conr.httpuri, conr.protocol, conr.key,
conr.uri, conr.local)
#print(cons[r])
#exit()
try:
pms = account.resource(fpssConfig['plexserver']).connect()
except plexapi.exceptions.NotFound:
print("Could not connect to plex")
exit(-1)
else:
baseurl = fpssConfig['plexmethod']
pms = PlexServer(baseurl, fpssConfig['plexauthtoken'])
return pms
def __init__(self, opts):
self.opts = opts # command line options
self.clsnames = [c for c in opts.clsnames.split(',') if c] # list of clsnames to report (blank=all)
self.account = MyPlexAccount() # MyPlexAccount instance
self.plex = PlexServer() # PlexServer instance
self.total = 0 # Total objects parsed
self.attrs = defaultdict(dict) # Attrs result set
def _list_devices(account, servers):
print('\nDevices:')
for d in MyPlexAccount(username, password).devices():
if d.token:
for conn in d.connections:
print(FORMAT % (d.product, d.name, d.token, conn))
servers[conn] = d.token
def inviteFriend():
request_data = request.get_json()
username = request_data['username']
password = request_data['password']
friend_username = request_data['friendusername']
print(username)
print(password)
print(friend_username)
try:
a = MyPlexAccount(username=f"{username}",
password=f"{password}",
token=token,
session=None,
timeout=None)
a.inviteFriend(user=f"{friend_username}",
server=plex,
sections=None,
allowSync=False,
allowCameraUpload=False,
allowChannels=False,
filterMovies=None,
filterTelevision=None,
filterMusic=None)
return "invited successfully"
except:
return "you aleady requested or username is wrong"
def _connect_server(self, user, password, server):
print("Connecting to plex server {server} with user: {user}...".format(
server=server, user=user))
self.account = MyPlexAccount(user, password)
self.server = self.account.resource(server).connect()
self.token = self.account.resource(server).accessToken
def authenticate():
method = plex_settings['authentication_method'].lower()
try:
# Direct connection
if method == 'direct':
base_url = plex_settings['base_url']
token = plex_settings['token']
plex = PlexServer(base_url, token)
# Myplex connection
elif method == 'myplex':
plex_server = plex_settings['server']
plex_user = plex_settings['myplex_user']
plex_password = plex_settings['myplex_password']
account = MyPlexAccount(plex_user, plex_password)
plex = account.resource(plex_server).connect()
else:
logger.critical(
'[PLEX] Failed to authenticate due to invalid settings or authentication info, exiting...')
sys.exit()
return plex
except Exception as e:
logger.error(
'Unable to authenticate to Plex Media Server, traceback: %s' %
(e))
return None
def __init__(self, name, plex_url, plex_user, plex_password, plex_server,
plex_token):
"""Initialize the sensor."""
from plexapi.myplex import MyPlexAccount
from plexapi.server import PlexServer
self._name = name
self._state = 0
self._media_attrs = {}
self._sessions = None
self._session = None
self._sessioncount = 0
self._session_type = None
self._plex_url = plex_url
self._plex_token = plex_token
"""Set all Media Items to None."""
# General
self._media_content_type = None
self._media_title = None
# TV Show
self._media_episode = None
self._media_season = None
self._media_series_title = None
if plex_token:
self._server = PlexServer(plex_url, plex_token)
elif plex_user and plex_password:
user = MyPlexAccount(plex_user, plex_password)
server = plex_server if plex_server else user.resources()[0].name
self._server = user.resource(server).connect()
else:
self._server = PlexServer(plex_url)
def get_pms(url=None,
token=None,
username=None,
password=None,
servername=None,
verify_ssl=None): # pragma: no cover
url = url or CONFIG['server'].get('url')
token = token or CONFIG['server'].get('token')
verify_ssl = verify_ssl or CONFIG['server'].get('verify_ssl', False)
servername = servername or CONFIG['server'].get('name')
if url and token:
url = url.rstrip('/')
sess = requests.Session()
if not verify_ssl:
# Disable the urllib3 warning as the user
# has choosen to not verify the http request.
# why the f**k isnt this default?
requests.packages.urllib3.disable_warnings()
sess.verify = False
PMS = PlexServer(url, token, sess)
elif username and password and servername:
acc = MyPlexAccount(username, password)
PMS = acc.resource(servername).connect()
assert PMS is not None, 'You need to add a url and token or username password and servername'
LOG.debug('Getting server %s', PMS.friendlyName)
return PMS
def get_pms(url=None,
token=None,
username=None,
password=None,
servername=None,
verify_ssl=None):
from plexapi.myplex import MyPlexAccount
from plexapi.server import PlexServer
url = url or CONFIG.get('url')
token = token or CONFIG.get('token')
verify_ssl = verify_ssl or CONFIG.get('verify_ssl', False)
if url and token:
sess = requests.Session()
if not verify_ssl:
sess.verify = False
PMS = PlexServer(url, token, sess)
elif username and password and servername:
acc = MyPlexAccount(username, password)
PMS = acc.resource(servername).connect()
LOG.debug('Getting server %s', PMS.friendlyName)
return PMS
def get_plex_account(opts):
""" Authenitcate with Plex using the command line options. """
if not opts.unclaimed:
if opts.token:
return MyPlexAccount(token=opts.token)
return plexapi.utils.getMyPlexAccount(opts)
return None
def connect_to_plex(username, password, server_name):
"""Connect to Plex"""
account = MyPlexAccount(username, password)
plex = account.resource(server_name).connect()
return plex
def dub(username: str = username,
password: str = password,
servername: str = servername,
show: str = show,
lang: str = lang):
"""Set the default dubs for every episode of the show."""
account = MyPlexAccount(username, password)
plex: PlexServer = account.resource(servername).connect()
try:
not_found_dubs_count = 0
for part in _get_media_parts(plex, show):
is_found = False
for audio in part.audioStreams():
if audio.languageCode == lang:
part.setDefaultAudioStream(audio)
is_found = True
break
if not is_found:
not_found_dubs_count += 1
if GLOBAL_OPTIONS['verbose']:
typer.echo(
f'Audio for "{lang}" not found for file: {part.file}',
err=True)
if not_found_dubs_count != 0:
typer.echo(f'{not_found_dubs_count} dubs were not found', err=True)
raise typer.Abort()
except NotFound as e:
typer.echo("Show, media item, or device is not found.", err=True)
typer.echo(e, err=True)
raise typer.Abort()
typer.echo('Success!')
def main():
args = get_args()
if args.debug:
logger.setLevel(logging.DEBUG)
if args.account:
# ## Connect via Account
account = MyPlexAccount(args.username, args.password)
plex = account.resource(args.resource).connect()
elif args.server:
# ## Connect via Direct URL
baseurl = args.baseurl
token = args.token
plex = PlexServer(baseurl, token)
else:
exit(1)
all_shows = plex.library.section('TV Shows')
# shows = get_unwatched_shows(all_shows.all())
episodes = get_random_episodes(all_shows, n=args.number)
for episode in episodes:
season_episode = episode.seasonEpisode
# skipped = skipped_missing(all_shows.get(title=episode.grandparentTitle), episode)
# playlist = Playlist(plex, )
plex.playlist(title=args.name).delete()
Playlist.create(server=plex, title=args.name, items=episodes)
def __init__(self):
MycroftSkill.__init__(self)
# List of services. Names in config must match API names.
self.services = self.settings.get('services').lower().split(',')
# Some titles are only available in certain countries
self.country = self.settings.get('country').lower()
# RapidAPI keys for Utelly API and IMDB API
self.header_apiKey = self.settings.get('x-rapidapi-key')
# Plex info
self.plexAccount = MyPlexAccount(self.settings.get('plexUsername'), self.settings.get('plexPassword'))
self.plexServers = []
# Service host info - from Rapid API
self.header_utellyHost = self.settings.get('utellyHost')
self.header_imdbHost = self.settings.get('imdbHost')
# URLs for each service - from Rapid API
self.utellyUrl = f'https://{self.header_utellyHost}/idlookup'
self.imdbUrl = f'https://{self.header_imdbHost}/title/find'
# If this is set to true, then the skill will offer to download a title if it can't be found.
# Is there a way for this skill to just check if the other skill is loaded?
self.couchPotato = self.settings.get('couchPotato')
def get_pms(url=None,
token=None,
username=None,
password=None,
servername=None,
verify_ssl=None): # pragma: no cover
url = url or CONFIG['server'].get('url')
token = token or CONFIG['server'].get('token')
verify_ssl = verify_ssl or CONFIG['server'].get('verify_ssl', False)
servername = servername or CONFIG['server'].get('name')
if url and token:
sess = requests.Session()
if not verify_ssl:
sess.verify = False
PMS = PlexServer(url, token, sess)
elif username and password and servername:
acc = MyPlexAccount(username, password)
PMS = acc.resource(servername).connect()
assert PMS is not None, 'You need to add a url and token or username password and servername'
LOG.debug('Getting server %s', PMS.friendlyName)
return PMS
def __init__(self, name, plex_url, plex_user, plex_password, plex_server,
plex_token, verify_ssl):
"""Initialize the sensor."""
from plexapi.myplex import MyPlexAccount
from plexapi.server import PlexServer
from requests import Session
self._name = name
self._state = 0
self._now_playing = []
cert_session = None
if not verify_ssl:
_LOGGER.info("Ignoring SSL verification")
cert_session = Session()
cert_session.verify = False
if plex_token:
self._server = PlexServer(plex_url, plex_token, cert_session)
elif plex_user and plex_password:
user = MyPlexAccount(plex_user, plex_password)
server = plex_server if plex_server else user.resources()[0].name
self._server = user.resource(server).connect()
else:
self._server = PlexServer(plex_url, None, cert_session)
def build_config():
if not os.path.exists(config_path):
print("Dumping default config to: %s" % config_path)
configs = dict(url='', token='', auto_delete=False)
# Get URL
configs['url'] = input("Plex Server URL: ")
# Get Credentials for plex.tv
user = input("Plex Username: "******"Auto Delete duplicates? [y/n]: ")
if auto_del.strip().lower() == 'y':
configs['auto_delete'] = True
elif auto_del.strip().lower() == 'n':
configs['auto_delete'] = False
account = MyPlexAccount(user, password)
configs['token'] = account.authenticationToken
with open(config_path, 'w') as fp:
json.dump(prefilled_default_config(configs),
fp,
sort_keys=True,
indent=2)
return True
else:
return False
def login(self, username, password):
try:
self._account = MyPlexAccount(username, password)
self.set_token(self._account._token, self._account.username,
self._account.email, self._account.uuid)
self.emit('login-status', True, '')
except:
self.emit('login-status', False, 'Login failed')
def plex_account_test(servername, username, password):
account = MyPlexAccount(username, password)
# returns a PlexServer instance
plex_server = account.resource(servername).connect()
playlists = plex_server.playlists()
for playlist in playlists:
print("Playlist Title: {}".format(playlist.title))
print("Playlist Items: {}".format(playlist.items))
def get_friends(config):
token = config['plex']['token']
account = MyPlexAccount(token)
columns = ['email', 'cleaned_email']
friends = [(user.email, clean_email(user.email))
for user in account.users() if user.friend]
frame = pd.DataFrame(friends, columns=columns)
return frame
def connect_to_plex(username, password, server):
"""
Takes the plex username, password and server name in order to
establish a connection and retrieve data.
"""
account = MyPlexAccount(username, password)
my_plex = account.resource(server).connect()
return my_plex
def plex(request, sess):
assert SERVER_BASEURL, "Required SERVER_BASEURL not specified."
if request.param == TEST_AUTHENTICATED:
token = MyPlexAccount(session=sess).authenticationToken
else:
token = None
return PlexServer(SERVER_BASEURL, token, session=sess)
