def validate_password(self, field, value): if not value: return value try: MyPlexUser.signin(self.fields.username.value, value) return value except Unauthorized: raise ValidationError('Invalid username or password.')
def __init__(self): self.config = get_config() self.config.verify() self._logger = get_logger(self.__class__.__name__) self.c_info = ClientInfo.from_config(self.config) self._monitor = ThreadMonitor() # self._monitor.start() self.registration_thread = ClientRegistration(self.c_info) # this call will block if XBMC is unresponsive, will resume when XBMC is UP self._xbmc_rpc = XbmcJSONRPC(self.config['xbmc_host'], self.config['xbmc_port']).wait() self._xbmc = XBMCPlexPlayer(self._xbmc_rpc, self) self.xbmc.notify('Plex', 'PlexMyXBMC Connected') self._user = MyPlexUser(self.config['plex_username'], self.config['plex_password']) self.xbmc.notify('Plex', 'Logged in as "%s"' % self.config['plex_username']) self.xbmc.notify('Plex', 'Master server is {0}'.format(self.config['plex_server'])) try: self._server = self.get_coolest_server() self.xbmc.notify('Plex', 'using PMS %s' % self._server.friendlyName) except: self.xbmc.notify('Plex', 'failed to connect to master server') raise self.sub_mgr = PlexSubManager(self) self.event_mgr = PlexEventsManager(self) self.httpd = ThreadedAPIServer(self, ('', self.config['port']), PlexClientHandler) self.httpd.allow_reuse_address = True self.storage_mgr = PlexStorageManager(self, self.config['local_sync_cache']) self.sync_mgr = PlexSyncManager(self, self.storage_mgr) self._keep_running = Event() self._keep_running.clear() self._lock = Lock()
def main(): config = __import__('config') user = MyPlexUser.signin(config.username, config.password) with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: for resource in user.resources(): executor.submit(parse_resource, user, resource) print('Servers data parsed') paris = pytz.timezone('Europe/Paris') ordered = reversed(sorted(data, key=lambda x: paris.localize(x.addedAt))) print('Media sorted') fg = FeedGenerator() fg.id('http://satreix.fr/feeds/plex.rss') fg.generator('plex-feed') fg.title('PLEX feed') fg.subtitle('Newly added media content') fg.author({'name': 'satreix', 'email': '*****@*****.**'}) fg.link(href='http://satreix.fr', rel='alternate') fg.logo('https://plex.tv/assets/img/googleplus-photo-cb6f717c8cfd8b48df6dbb09aa369198.png') fg.link(href='http://satreix.fr/feeds/plex.rss', rel='self') fg.language('en') for elt in list(ordered)[:50]: fe = fg.add_entry() fe.id(elt.getStreamUrl()) fe.title('{} - {}'.format(elt.title, elt.server.friendlyName)) fe.pubdate(paris.localize(elt.addedAt)) fe.description(elt.summary, True) fg.rss_file('plex.rss', pretty=True) print('File written')
def _connect_plex(self): """ Attempts to authenticate to the Plex API and returns the resulting MyPlexUser object :return: plexapi.MyPlexUser """ try: return MyPlexUser.signin(self.plex_user, self.plex_password) except (Unauthorized, BadRequest) as error: sys.exit("Failed to authenticate to the Plex API: " + str(error))
def fetch_plex_instance(pkmeter, username=None, password=None, host=None): username = username or pkmeter.config.get('plexserver', 'username', from_keyring=True) password = password or pkmeter.config.get('plexserver', 'password', from_keyring=True) host = host or pkmeter.config.get('plexserver', 'host', '') if username: log.info('Logging into MyPlex with user %s', username) user = MyPlexUser.signin(username, password) return user.getResource(host).connect() log.info('Connecting to Plex host: %s', host) return PlexServer(host)
def fetch_server(args): if args.resource and args.username and args.password: log(0, 'Signing in as MyPlex user %s..' % args.username) user = MyPlexUser.signin(args.username, args.password) log(0, 'Connecting to Plex server %s..' % args.resource) return user.resource(args.resource).connect(), user elif args.baseurl and args.token: log(0, 'Connecting to Plex server %s..' % args.baseurl) return server.PlexServer(args.baseurl, args.token), None return server.PlexServer(), None
def myPlex(servercfg): logger = logging.getLogger(__name__) from plexapi.myplex import MyPlexUser from plexapi.server import PlexServer user = MyPlexUser(servercfg['username'], servercfg['password']) for key in user.keys(): logger.debug("\tKey: %s\tValue: %s" % (key, user[key])) server = user.getServer(servercfg['server']).connect for server in user.servers(): logger.info("Server: %s" % (server)) plex = PlexServer(servercfg['host'], servercfg['port'], user['authenticationToken']) for section in plex.library.sections(): logger.info("Section: %s" % (section.title))
def setup_platform(hass, config, add_devices, discovery_info=None): """ Sets up the plex platform. """ from plexapi.myplex import MyPlexUser from plexapi.exceptions import BadRequest name = config.get('name', '') user = config.get('user', '') password = config.get('password', '') plexuser = MyPlexUser.signin(user, password) plexserver = plexuser.getResource(name).connect() plex_clients = {} plex_sessions = {} @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS) def update_devices(): """ Updates the devices objects. """ try: devices = plexuser.devices() except BadRequest: _LOGGER.exception("Error listing plex devices") return new_plex_clients = [] for device in devices: if (all(x not in ['client', 'player'] for x in device.provides) or 'PlexAPI' == device.product): continue if device.clientIdentifier not in plex_clients: new_client = PlexClient(device, plex_sessions, update_devices, update_sessions) plex_clients[device.clientIdentifier] = new_client new_plex_clients.append(new_client) else: plex_clients[device.clientIdentifier].set_device(device) if new_plex_clients: add_devices(new_plex_clients) @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS) def update_sessions(): """ Updates the sessions objects. """ try: sessions = plexserver.sessions() except BadRequest: _LOGGER.exception("Error listing plex sessions") return plex_sessions.clear() for session in sessions: plex_sessions[session.player.machineIdentifier] = session update_devices() update_sessions()
def setup_platform(hass, config, add_devices, discovery_info=None): """ Sets up the plex platform. """ from plexapi.myplex import MyPlexUser from plexapi.exceptions import BadRequest name = config.get('name', '') user = config.get('user', '') password = config.get('password', '') plexuser = MyPlexUser.signin(user, password) plexserver = plexuser.getResource(name).connect() plex_clients = {} plex_sessions = {} @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS) def update_devices(): """ Updates the devices objects """ try: devices = plexuser.devices() except BadRequest: _LOGGER.exception("Error listing plex devices") return new_plex_clients = [] for device in devices: if (all(x not in ['client', 'player'] for x in device.provides) or 'PlexAPI' == device.product): continue if device.clientIdentifier not in plex_clients: new_client = PlexClient(device, plex_sessions, update_devices, update_sessions) plex_clients[device.clientIdentifier] = new_client new_plex_clients.append(new_client) else: plex_clients[device.clientIdentifier].set_device(device) if new_plex_clients: add_devices(new_plex_clients) @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS) def update_sessions(): """ Updates the sessions objects """ try: sessions = plexserver.sessions() except BadRequest: _LOGGER.exception("Error listing plex sessions") return plex_sessions.clear() for session in sessions: plex_sessions[session.player.machineIdentifier] = session update_devices() update_sessions()
def fetch_plex_instance(pkmeter, username=None, password=None, host=None): username = username or pkmeter.config.get( 'plexserver', 'username', from_keyring=True) password = password or pkmeter.config.get( 'plexserver', 'password', from_keyring=True) host = host or pkmeter.config.get('plexserver', 'host', '') if username: log.info('Logging into MyPlex with user %s', username) user = MyPlexUser.signin(username, password) return user.getResource(host).connect() log.info('Connecting to Plex host: %s', host) return PlexServer(host)
def __init__(self, name, plex_url, plex_user, plex_password, plex_server): """Initialize the sensor.""" self._name = name self._state = 0 self._now_playing = [] if plex_user and plex_password: from plexapi.myplex import MyPlexUser user = MyPlexUser.signin(plex_user, plex_password) server = plex_server if plex_server else user.resources()[0].name self._server = user.getResource(server).connect() else: from plexapi.server import PlexServer self._server = PlexServer(plex_url) self.update()
def get_server(uri=DEFAULT_URI, username=None, password=None, servername=None): """ Get Plex server object for further processing. :param uri: Server URI. Expects "http://IP-ADDRESS:PORT", where IP-ADDRESS can be a hostname, and PORT is usually 32400 :param username: Plex username. Needed if uri fails. User is prompted if parameter is not provided. $PLEX_USERNAME :param password: Plex password. Recommended practice is to leave this as None and respond to the prompt. $PLEX_PASSWORD :param servername: Server name. User is prompted with a list of servers available to their username if parameter is not provided :returns: Server object :rtype: plexapi.server.PlexServer """ try: return PlexServer(uri) except NotFound: pass if not username and not password: info("Could not get server object, maybe you need to be authenticated?") username = username if username else os.environ.get("PLEX_USERNAME", None) or prompt("Plex username: "******"PLEX_PASSWORD", None) or getpass("Plex password: "******"Servers: " + ", ".join(a.name for a in user.resources())) servername = prompt("Please enter server name (or specify with --servername). If you don't know it, press enter and I'll (very slowly!) search for the correct server: ") or None if servername: return user.getResource(servername).connect() else: info("OK, beginning the search process.") # necessary to match correct server if uri.count(":") >= 2: ip = ":".join(urlparse(uri).netloc.split(":")[:-1]) else: ip = urlparse(uri).netloc info("Getting IP for {}".format(ip)) ip = gethostbyname(ip) info("Got IP from hostname: {}".format(ip) if ip not in uri else "Searching for {}".format(ip)) for srv in user.resources(): try: server = srv.connect() if ip in server.baseuri: info("Found server: {}".format(srv.name)) return server except NotFound: info("Couldn't connect to {}".format(srv.name)) info("Couldn't find server in your user's server list.") return 10
async def invite_member(member): server_id = '503c85f2d47514dbfc3260c2a29ccb9cb113b071' account = plex.signin(environ.get('PLEX_EMAIL'), environ.get('PLEX_PASSWORD')) headers = plexapi.BASE_HEADERS headers['X-Plex-Token'] = account.authenticationToken print(account.authenticationToken) headers['Content-Type'] = 'application/json' data = { 'server_id': server_id, 'shared_server': { 'library_section_ids': [], 'invited_email': member }, 'shared_settings': [] } res = await post('https://plex.tv/api/servers/%s/shared_servers' % server_id, headers=headers, data=dumps(data)) data = await res.text()
def _findUser(self, data): elem = data.find('User') if elem is not None: from plexapi.myplex import MyPlexUser return MyPlexUser(elem, self.initpath) return None
from __future__ import print_function import logging import dotenv from getenv import env from plexapi.myplex import MyPlexUser from alexa import Response dotenv.read_dotenv() logger = logging.getLogger(__name__) APP_ID = 'amzn1.echo-sdk-ams.app.{}'.format(env('ALEXA_APP_ID')) PLEX_USER = MyPlexUser.signin(env('PMS_USERNAME'), env('PMS_PASSWORD')) PLEX_SERVER = PLEX_USER.getResource(env('PMS_SERVERNAME')).connect() PLEX_CLIENT = PLEX_SERVER.client(env('PMS_CLIENT')) def get_welcome_response(): ''' Get the welcome response when waiting for more. ''' return Response( 'Plex is listening..', 'Welcome', should_end_session=False, ).to_dict()
class PlexClient(object): def __init__(self): self.config = get_config() self.config.verify() self._logger = get_logger(self.__class__.__name__) self.c_info = ClientInfo.from_config(self.config) self._monitor = ThreadMonitor() # self._monitor.start() self.registration_thread = ClientRegistration(self.c_info) # this call will block if XBMC is unresponsive, will resume when XBMC is UP self._xbmc_rpc = XbmcJSONRPC(self.config['xbmc_host'], self.config['xbmc_port']).wait() self._xbmc = XBMCPlexPlayer(self._xbmc_rpc, self) self.xbmc.notify('Plex', 'PlexMyXBMC Connected') self._user = MyPlexUser(self.config['plex_username'], self.config['plex_password']) self.xbmc.notify('Plex', 'Logged in as "%s"' % self.config['plex_username']) self.xbmc.notify('Plex', 'Master server is {0}'.format(self.config['plex_server'])) try: self._server = self.get_coolest_server() self.xbmc.notify('Plex', 'using PMS %s' % self._server.friendlyName) except: self.xbmc.notify('Plex', 'failed to connect to master server') raise self.sub_mgr = PlexSubManager(self) self.event_mgr = PlexEventsManager(self) self.httpd = ThreadedAPIServer(self, ('', self.config['port']), PlexClientHandler) self.httpd.allow_reuse_address = True self.storage_mgr = PlexStorageManager(self, self.config['local_sync_cache']) self.sync_mgr = PlexSyncManager(self, self.storage_mgr) self._keep_running = Event() self._keep_running.clear() self._lock = Lock() def __del__(self): self.stop() self.join() def _serve_loop(self): while self._keep_running.is_set() is True: self.httpd.handle_request() def serve(self): self.registration_thread.start() self.event_mgr.start() self.sync_mgr.start() self.publish_resources() self._keep_running.set() try: self._serve_loop() except KeyboardInterrupt: self._keep_running.clear() def stop(self): self._keep_running.clear() self.registration_thread.stop() self.event_mgr.stop() self._xbmc_rpc.stop() self.sync_mgr.stop() # self._monitor.stop() def join(self): if self.registration_thread.isAlive(): self.registration_thread.join() if self._monitor.isAlive(): self._monitor.join() if self.event_mgr.isAlive(): self.event_mgr.join() if self.sync_mgr.isAlive(): self.sync_mgr.join() def get_coolest_server(self): servers = self._user.servers() self._logger.info('MyPlex registered servers: %s', ', '.join(map(lambda x: x.name, servers))) master_server = self.config.get('plex_server', '') for server in servers: if server.name != master_server: continue return MyPlexServer(server).connect() raise NotFound('could not find master server {0}'.format(master_server)) def authenticated_url(self, url): """ :type url: str """ url = self._server.url(url) if url.startswith('/') else url token = 'X-Plex-Token=' + self._user.authenticationToken return url + ('&' if '?' in url else '?') + token @property def headers(self): plex_headers = { "Content-Type": "application/x-www-form-urlencoded", 'Access-Control-Expose-Headers': 'X-Plex-Client-Identifier', "Access-Control-Allow-Origin": "*", "X-Plex-Device": "PC", "X-Plex-Username": self._user.username, "X-Plex-Token": self._user.authenticationToken, } plex_headers.update(plexapi.BASE_HEADERS) return plex_headers @property def server(self): return self._server @property def user(self): return self._user @property def xbmc(self): return self._xbmc @property def local_address(self): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(('www.google.com', 80)) addr, port = s.getsockname() s.close() return addr, self.config['port'] def publish_resources(self): addr, port = self.local_address connection = 'http://{0}:{1}/'.format(addr, port) data = {'Connection[][uri]': connection} url = 'https://plex.tv/devices/{0}'.format(self.config['uuid']) resp = requests.put(url, data=data, headers=self.headers) if resp.status_code == 200: self._logger.info('published device resources to plex.tv successfully') else: self._logger.warn('failed to publish devices resources to plex.tv')
def fetch_server(args): if args.resource: user = MyPlexUser.signin(args.username, args.password) return user.getResource(args.resource).connect(), user return server.PlexServer(), None
def _find_user(self, data): elem = data.find('User') if elem is not None: return MyPlexUser(elem, self.initpath) return None
from plexapi.myplex import MyPlexUser import argparse from sort import Sorter if __name__ == '__main__': parser = argparse.ArgumentParser(description='Run demo script') parser.add_argument('-u', '--username', help='Username for the Plex server.') parser.add_argument('-p', '--password', help='Password for the Plex server.') args = parser.parse_args() user = MyPlexUser.signin(args.username, args.password) server_name = user.servers()[0].name server = user.getServer(server_name).connect() media_center = server.client('420-MediaCenter') up = server.library.section('Movies').get('Up') avatar = server.library.section('Movies').get('Avatar') bobs = server.library.section('TV Shows').search('Bob\'s Burgers')[0] sorter = Sorter() eps = bobs.episodes() sorter.sort(eps) queue = media_center.server.createPlayQueue(eps[0]) queue.addList(eps[1:]) media_center.playPlayQueue(queue, eps[0])
def fetch_server(args): if args.server: user = MyPlexUser.signin(args.username, args.password) return user.getServer(args.server).connect(), user return server.PlexServer(), None
def main(): tvdb = tvdb_api.Tvdb() username = os.environ.get('plex_user') or raw_input("Plex username? ") password = os.environ.get('plex_pass') or getpass.getpass("{0} password? ".format(username)) user = MyPlexUser(username, password) servers = user.servers() for i, server in enumerate(servers): print i, server.name server_id = int(os.environ.get('plex_server') or raw_input("Server ID? ")) print server = servers[server_id].connect() sections = server.library.sections() for i, section in enumerate(sections): print i, section.title section_id = int(os.environ.get('plex_section') or raw_input("Section ID? ")) print section = sections[section_id] shows = {} for show in section.all(): seasons = {} for season in show.seasons(): ep_list = [] for episode in season.episodes(): ep_list.append(episode.index) seasons[season.index] = ep_list shows[show.title] = seasons # break missing = [] for show in sorted(shows): seasons = shows[show] try: tvdb_show = tvdb[show] except: print "Show named \"" + show + "\" not found on TVDB" continue for season in tvdb_show: if season == 0: continue for episode in tvdb_show[season].values(): e = episode['episodenumber'] s = episode['seasonnumber'] fa = episode['firstaired'] # print episode.keys(), episode.values() try: aired = datetime.strptime(fa, "%Y-%m-%d %H:%M:%S") except: try: aired = datetime.strptime(fa, "%Y-%m-%d") except: aired = datetime(3000,1,1) if aired > datetime.today(): continue if not e in seasons.get(s, []): missing.append((show, s.zfill(2), e.zfill(2), )) if len(missing): print "Missing episodes:" missing.append(('',0,0),) i = 0 while i < len(missing) - 1: miss = missing[i] missing_end = missing[i+1:] last_inner_miss = None succession = 0 for j, inner_miss in enumerate(missing_end): if miss[0] == inner_miss[0] and miss[1] == inner_miss[1] and \ (int(miss[2]) + j + 1) == int(inner_miss[2]): succession += 1 else: if succession > 0: i += succession + 1 print u"{0} S{1}E{2} - S{1}E{3}".format(miss[0], miss[1], miss[2], last_inner_miss[2]) break last_inner_miss = inner_miss else: print u"{0} S{1}E{2}".format(*miss) i += 1 else: print "No missing episodes found!"