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 _signin(self, username, password, timeout): if self._token: return self.query(self.key), self.key username = username or CONFIG.get('auth.myplex_username') password = password or CONFIG.get('auth.myplex_password') data = self.query(self.SIGNIN, method=self._session.post, auth=(username, password), timeout=timeout) return data, self.SIGNIN
def __init__(self, server=None, data=None, initpath=None, baseurl=None, token=None, connect=True, session=None, timeout=None): super(PlexClient, self).__init__(server, data, initpath) self._baseurl = baseurl.strip('/') if baseurl else None self._token = logfilter.add_secret(token) self._showSecrets = CONFIG.get('log.show_secrets', '').lower() == 'true' server_session = server._session if server else None self._session = session or server_session or requests.Session() self._proxyThroughServer = False self._commandId = 0 self._last_call = 0 self._timeline_cache = [] self._timeline_cache_timestamp = 0 if not any([data is not None, initpath, baseurl, token]): self._baseurl = CONFIG.get('auth.client_baseurl', 'http://localhost:32433') self._token = logfilter.add_secret(CONFIG.get('auth.client_token')) if connect and self._baseurl: self.connect(timeout=timeout)
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) # 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 __init__(self, baseurl=None, token=None, session=None): self._baseurl = baseurl or CONFIG.get('auth.server_baseurl', 'http://localhost:32400') self._token = logfilter.add_secret(token or CONFIG.get('auth.server_token')) self._session = session or requests.Session() self._library = None # cached library self._settings = None # cached settings super(PlexServer, self).__init__(self, self.query(self.key), self.key)
def __init__(self, username=None, password=None, session=None): self._session = session or requests.Session() self._token = None username = username or CONFIG.get('auth.myplex_username') password = password or CONFIG.get('auth.myplex_password') data = self.query(self.SIGNIN, method=self._session.post, auth=(username, password)) super(MyPlexAccount, self).__init__(self, data, self.SIGNIN)
def __init__(self, baseurl=None, token=None, session=None, timeout=None): self._baseurl = baseurl or CONFIG.get('auth.server_baseurl', 'http://localhost:32400') self._token = logfilter.add_secret(token or CONFIG.get('auth.server_token')) self._showSecrets = CONFIG.get('log.show_secrets', '').lower() == 'true' self._session = session or requests.Session() self._library = None # cached library self._settings = None # cached settings self._myPlexAccount = None # cached myPlexAccount data = self.query(self.key, timeout=timeout) super(PlexServer, self).__init__(self, data, self.key)
def __init__(self, baseurl='http://localhost:32400', token=None, session=None): self.baseurl = baseurl or CONFIG.get('authentication.baseurl') self.token = token or CONFIG.get('authentication.token') if self.token: logfilter.add_secret(self.token) self.session = session or requests.Session() self._library = None # cached library self.reload()
def __init__(self, server=None, data=None, initpath=None, baseurl=None, token=None, connect=True, session=None, timeout=None): super(PlexClient, self).__init__(server, data, initpath) self._baseurl = baseurl.strip('/') if baseurl else None self._token = logfilter.add_secret(token) self._showSecrets = CONFIG.get('log.show_secrets', '').lower() == 'true' server_session = server._session if server else None self._session = session or server_session or requests.Session() self._proxyThroughServer = False self._commandId = 0 if not any([data, initpath, baseurl, token]): self._baseurl = CONFIG.get('auth.client_baseurl', 'http://localhost:32433') self._token = logfilter.add_secret(CONFIG.get('auth.client_token')) if connect and self._baseurl: self.connect(timeout=timeout)
def runtests(args): # Get username and password from environment username = args.username or CONFIG.get('authentication.username') password = args.password or CONFIG.get('authentication.password') resource = args.resource or CONFIG.get('authentication.resource') # Register known tests for loader, name, ispkg in pkgutil.iter_modules( [dirname(abspath(__file__))]): if name.startswith('test_'): log(0, 'Registering tests from %s.py' % name) loader.find_module(name).load_module(name) # Create Account and Plex objects log(0, 'Logging into MyPlex as %s' % username) account = MyPlexAccount.signin(username, password) log(0, 'Signed into MyPlex as %s (%s)' % (account.username, account.email)) if resource: plex = account.resource(resource).connect() log(0, 'Connected to PlexServer resource %s' % plex.friendlyName) else: plex = PlexServer(args.baseurl, args.token) log(0, 'Connected to PlexServer %s' % plex.friendlyName) log(0, '') # Run all specified tests tests = {'passed': 0, 'failed': 0} for test in itertests(args.query): starttime = time.time() log(0, test['name'], 'green') try: test['func'](account, plex) runtime = time.time() - starttime log(2, 'PASS! (runtime: %.3fs)' % runtime, 'blue') tests['passed'] += 1 except Exception as err: errstr = str(err) errstr += '\n%s' % traceback.format_exc() if args.verbose else '' log(2, 'FAIL: %s' % errstr, 'red') tests['failed'] += 1 log(0, '') # Log a final report log(0, 'Tests Run: %s' % sum(tests.values())) log(0, 'Tests Passed: %s' % tests['passed']) if tests['failed']: log(0, 'Tests Failed: %s' % tests['failed'], 'red') if not tests['failed']: log(0, '') log(0, 'EVERYTHING OK!! :)') raise SystemExit(tests['failed'])
def __init__(self, server=None, data=None, initpath=None, baseurl=None, token=None, session=None): super(PlexClient, self).__init__(server, data, initpath) self._baseurl = baseurl.strip('/') if baseurl else None self._token = logfilter.add_secret(token) server_session = server._session if server else None self._session = session or server_session or requests.Session() self._proxyThroughServer = False self._commandId = 0 if not any([data, initpath, baseurl, token]): self._baseurl = CONFIG.get('auth.client_baseurl', 'http://localhost:32433') self._token = logfilter.add_secret(CONFIG.get('auth.client_token')) if self._baseurl and self._token: self.connect()
def __init__(self, account, data): self._data = data self.deviceClass = data.attrib.get("deviceClass") self.machineIdentifier = data.attrib.get("machineIdentifier") self.product = data.attrib.get("product") self.platform = data.attrib.get("platform") self.platformVersion = data.attrib.get("platformVersion") self.protocol = data.attrib.get("protocol") self.protocolCapabilities = data.attrib.get("protocolCapabilities") self.lanIP = data.attrib.get("lanIP") self.title = data.attrib.get("title") self._baseurl = "https://sonos.plex.tv" self._commandId = 0 self._token = account._token self._session = account._session or requests.Session() # Dummy values for PlexClient inheritance self._last_call = 0 self._proxyThroughServer = False self._showSecrets = CONFIG.get("log.show_secrets", "").lower() == "true"
print('Applying %s differences to destination' % len(differences)) import pprint pprint.pprint(differences) if __name__ == '__main__': from plexapi import CONFIG parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('action', help='Action to perform: backup or restore', choices=('backup', 'restore')) parser.add_argument('filepath', help='File path to backup to or restore from') parser.add_argument('-u', '--username', default=CONFIG.get('auth.myplex_username'), help='Plex username') parser.add_argument('-p', '--password', default=CONFIG.get('auth.myplex_password'), help='Plex password') parser.add_argument('-s', '--servername', help='Plex server name') parser.add_argument('-w', '--watchedonly', default=False, action='store_true', help='Only backup or restore watched items.') parser.add_argument( '-l', '--libraries', help='Only backup or restore the specified libraries (comma seperated).'
clientid = clientid[0] key = unquote(key[0][0]) # Connect to the server and fetch the item servers = [r for r in account.resources() if r.clientIdentifier == clientid] if len(servers) != 1: raise SystemExit('Unknown or ambiguous client id: %s' % clientid) server = servers[0].connect() return server.fetchItem(key) if __name__ == '__main__': # Command line parser from plexapi import CONFIG from tqdm import tqdm parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('-u', '--username', help='Your Plex username', default=CONFIG.get('auth.myplex_username')) parser.add_argument('-p', '--password', help='Your Plex password', default=CONFIG.get('auth.myplex_password')) parser.add_argument('--url', default=None, help='Download from URL (only paste after !)') opts = parser.parse_args() # Search item to download account = utils.getMyPlexAccount(opts) items = search_for_item(opts.url) for item in items: for part in item.iterParts(): # We do this manually since we dont want to add a progress to Episode etc filename = '%s.%s' % (item._prettyfilename(), part.container) url = item._server.url('%s?download=1' % part.key) filepath = utils.download(url, token=account.authenticationToken, filename=filename, savepath=os.getcwd(), session=item._server._session, showstatus=True) #print(' %s' % filepath)