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 __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 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)
