class HoodexPlexServer(object): account = None server = None token = "" def __init__(self, user, password, server): self._connect_server(user=user, password=password, server=server) 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 get_last_added(self, library_name): media_list = [] for media in self.server.library.section(library_name).recentlyAdded(): local_path = media.locations[0] file_name = os.path.basename(local_path) media_list.append({ "file_name": local_path, "name": file_name, "url": media.media[0].parts[0].key }) return media_list
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
class Plex: def __init__(self): f = open('config.json', 'r') self.config = json.load(f) try: self.account = MyPlexAccount(self.config.get("PS_USERNAME"), self.config.get("PS_PASSWORD")) except plexapi.exceptions.Unauthorized: print('Email/Username/Password for Plex Account is incorrect!') exit() self.server = self.account.resource( self.config.get("SERVER_NAME")).connect() def sections(self): section = self.server.library.section('My Music') artist = section.get('Various Artists') tracks = artist.tracks() for track in tracks: url = track.getStreamURL() print(url) async def searchServer(self, query): results = self.server.search(query, mediatype='track') tracks = [ track for track in results if isinstance(track, plexapi.audio.Track) ] return tracks async def searchLibrary(self, section, title): res = self.server.library.search(title=title) return res
class Plex(QObject): artistsChanged = Signal() currentAlbumsChanged = Signal() def __init__(self, username: str, password: str, server_name: str): QObject.__init__(self) self.account = MyPlexAccount(username, password) self.server = self.account.resource(server_name).connect() self._currentSection = None self._artists = [] self._currentArtist = None self._currentAlbums = [] @Slot() def refresh(self): #artists = ["Artic Monkey","X Ambassador"] #self.setArtists(artists) #return sections = [x for x in self.server.library.sections() if x.type == "artist"] if sections.__len__ != 0: self._currentSection = sections[0] artists = [x.title for x in self._currentSection.all()] self.setArtists(artists) @Slot(str) def loadAlbums(self, artist: str): #if artist == "Artic Monkey": # albums = ["AM", "The other one"] #else: # albums = ["VHS", "That one"] #return if self._currentSection == None: return artist = self._currentSection.get(artist) albums = [x.title for x in artist.albums()] self.setCurrentAlbums(albums) @Property('QVariantList', notify=currentAlbumsChanged) def currentAlbums(self): return self._currentAlbums def setCurrentAlbums(self, albums): if albums != self._currentAlbums: self._currentAlbums = albums self.currentAlbumsChanged.emit() @Property('QVariantList', notify=artistsChanged) def artists(self): return self._artists @artists.setter def setArtists(self, artists): if artists != self._artists: self._artists = artists self.artistsChanged.emit()
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, 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 __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)
class PlexAPI: def __init__(self): self.host_url = str(environ['PLEX_URL']) self.serverName = str(environ['PLEX_SERVER']) self.api_key = str(environ['PLEX_API_KEY']) self.username = str(environ['PLEX_USERNAME']) self.password = str(environ['PLEX_PASSWORD']) # make a method to handle either secrets or envars self.account = MyPlexAccount(self.username, self.password) self.plex = self.account.resource(self.serverName).connect() self.movieLibrary = self.getMovies() self.movies = self.plex.library.section(str(environ['PLEX_MOVIES'])) self.anime = self.plex.library.section(str(environ['PLEX_ANIME'])) self.tv = self.plex.library.section(str(environ['PLEX_SHOWS'])) print("THIS SEGMENTS FOR TESTING ONLY") try: print(self.plex._token) print(self.plex._baseurl) print(self.plex._session) except: print("failed to print session info from plex class object") self.setWatched() def getMovies(self): return self.plex.movies.search(unwatched=True) def setWatched(self): print( self.plex.library.section('TV Shows').movies_gets( "Game of Thrones")) print( self.plex.library.section('Movies: All').movies_gets( "Game of Thrones"))
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 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 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 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 __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 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)
class EntangledPOC: def __init__(self): username = '******' password = load_password() self.account = MyPlexAccount(username, password) self.resource: PlexClient = None def list_resources(self): resources = self.account.resources() print(resources) def connect_to(self, resource_name): self.resource = self.account.resource(resource_name).connect() def play(self): if not self.resource: return self.resource.play() def pause(self): if not self.resource: return self.resource.pause() def go_to_10_min_in_movie(self): ten_minutes_ms = 10 * 60 * 1000 self.resource.seekTo(ten_minutes_ms)
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 connect_to_plex(username, password, server_name): """Connect to Plex""" account = MyPlexAccount(username, password) plex = account.resource(server_name).connect() return plex
class PythonLibPlexApi(PlexApi): # TODO # Add a 'connect_to_account' and 'connect_to_resource' method # and call them both in 'Entangled' (test via outside-in testing # that it's been call during 'Entangled' '__init__') # Then in the 'list_all_resources' script, only call 'connect_to_account' # Boom lifecyle problem solved, and it's transparent to the higher level # using 'Entangled' def __init__(self) -> None: self.username = os.environ['PLEX_USER'] self.password = os.environ['PLEX_PASS'] self.resource_name = os.environ['PLEX_RESOURCE'] self._connect_to_resource() def _connect_to_resource(self): self.account = MyPlexAccount(self.username, self.password) if (self.resource_name): self.resource = self.account.resource(self.resource_name).connect() else: logger.info("DEBUG TEMP: Add resource to envvar") @ensure_connected_to_account def all_resources(self): return self.account.resources() @ensure_connected_to_resource def current_movie_time(self): logger.info('Getting current movie time') # TODO: Fix 'self.resource.timeline.time' can be None sometimes if the movie was paused. Find solution. print(self.resource.timeline.time) import math timestamp = math.floor(self.resource.timeline.time / 1000) hours = math.floor(timestamp/3600) min = math.floor(timestamp / 60) - hours * 60 secs = timestamp - hours*3600 - min*60 current_time = f"{hours}:{min:02}:{secs:02}" return current_time @ensure_connected_to_resource def seek_to(self, hour, minute, second): logger.info(f"Seeking to: '{hour}:{minute}:{second}") def seconds(seconds_num): return seconds_num * 1000 def minutes(minutes_num): return seconds(minutes_num * 60) def hours(hours_num): return minutes(hours_num * 60) self.resource.seekTo( hours(hour) + minutes(minute) + seconds(second) ) @ensure_connected_to_resource def play(self): logger.info('Playing') self.resource.play()
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 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 connect_to_plex(): print('\nConnecting to Plex...') try: account = MyPlexAccount(PLEX_USERNAME, PLEX_PASSWORD) plex = account.resource(PLEX_SERVER_NAME).connect() except Exception as e: print(str(e)) sys.exit(0) return plex
def __init__(self, plex_server_name, username, password, mqtt, update_freq): account = MyPlexAccount(username, password) print("PLEX: Connecting to server ", plex_server_name) self.plex = account.resource( plex_server_name).connect() # returns a PlexServer instance print("PLEX: Connected!") self.mqtt = mqtt self.update_freq = int(update_freq)
def plexAuth(): plex_auth_info = { "username": os.environ['PLEX_USERNAME'], "password": os.environ['PLEX_PASSWORD'], "server": os.environ['PLEX_SERVER_NAME'] } account = MyPlexAccount(plex_auth_info['username'], plex_auth_info['password']) plex = account.resource(plex_auth_info['server']).connect() return plex
def get_server(username, password, server_name): global SERVER, PREV_USERNAME, PREV_PASSWORD, PREV_SERVER_NAME if SERVER is None or not creds_are_same(username, password, server_name): account = MyPlexAccount(username, password) SERVER = account.resource(server_name).connect() PREV_USERNAME, PREV_PASSWORD, PREV_SERVER_NAME = username, password, server_name return SERVER
def get_plex_server(user, password, servername): """ :param user: username :param password: password :param servername: plex server name :return: API object representing server instance """ log.info("Getting Plex server instance") acc = MyPlexAccount(user, password) server = acc.resource(servername).connect() return server
def init_client(self, conf): """ Create a http client for plex based on a password or token depending on conf file. If both are set we use the password. """ if conf.password is not None: account = MyPlexAccount(conf.user, conf.password) return account.resource(conf.host).connect() else: return PlexServer(conf.host, conf.token)
def main(): config = load_config() account = MyPlexAccount(config.get('DEFAULT', 'username'), config.get('DEFAULT', 'password')) plex = account.resource(config.get('DEFAULT', 'server name')).connect() playlist = plex.playlist(config.get('DEFAULT', 'playlist name')) playlist.copyToUser(config.get('DEFAULT', 'user'))
def pause_then_play(): username = '******' password = load_password() session = Session() session.verify = 'charles-ssl-proxying-certificate.pem' account = MyPlexAccount(username, password, session=session) debug = account.resources() macbook_pro: PlexClient = account.resource('TheMacbookPro').connect() duration = int(input('How long to pause for: ')) macbook_pro.pause() sleep(duration) macbook_pro.play()
def connect_to_plex(): print('\nConnecting to Plex...') try: if PLEX_USERNAME is not None and PLEX_PASSWORD is not None and PLEX_SERVER_NAME is not None: account = MyPlexAccount(PLEX_USERNAME, PLEX_PASSWORD) plex = account.resource(PLEX_SERVER_NAME).connect() elif PLEX_BASE_URL is not None and PLEX_TOKEN is not None: plex = PlexServer(PLEX_BASE_URL, PLEX_TOKEN) else: raise Exception("No valid credentials found. See the README for more details.") except Exception as e: print(str(e)) sys.exit(0) return plex
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._now_playing = [] 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)