def __init__(self, base_url, token):
self.base_url = base_url
self.queue = list()
self.queue_index = -1
self.play_queue_order = list()
self.play_modes = TizEnumeration(["NORMAL", "SHUFFLE"])
self.current_play_mode = self.play_modes.NORMAL
self.now_playing_track = None
self._plex = PlexServer(base_url, token)
self._music = self._plex.library.section('Music')
def list_libraries():
plex = PlexServer(CONFIG['plex_url'], CONFIG['plex_token'])
plex_sections = plex.library.sections()
for plex_section in plex_sections:
if plex_section.type != 'movie':
continue
print('ID: %s Name: %s' %
(str(plex_section.key).ljust(4, ' '), plex_section.title))
def plex_deletion(items, libraries, toggleDeletion):
"""
Parameters
----------
items (list): List of items to be deleted by Plex
libraries {list): List of libraries used
toggleDeletion (bool): Allow then disable Plex ability to delete media items
Returns
-------
"""
plex = PlexServer(PLEX_URL, PLEX_TOKEN)
if plex.allowMediaDeletion is None and toggleDeletion is None:
print("Allow Plex to delete media.")
exit()
elif plex.allowMediaDeletion is None and toggleDeletion:
print("Temporarily allowing Plex to delete media.")
plex._allowMediaDeletion(True)
time.sleep(1)
plex = PlexServer(PLEX_URL, PLEX_TOKEN)
print("The following items were added before {} and marked for deletion.".
format(opts.date))
for item in items:
try:
if isinstance(item, int):
plex_item = plex.fetchItem(item)
elif isinstance(item, str):
plex_item = plex.fetchItem(int(item))
else:
plex_item = plex.fetchItem(int(item.rating_key))
plex_item.delete()
print("Item: {} was deleted".format(plex_item.title))
except NotFound:
print("Item: {} may already have been deleted.".format(item))
for _library in libraries:
section = plex.library.sectionByID(_library.key)
print("Emptying Trash from library {}".format(_library.title))
section.emptyTrash()
if toggleDeletion:
print("Disabling Plex to delete media.")
plex._allowMediaDeletion(False)
def copyToUser(self, user):
""" Copy playlist to another user account. """
from plexapi.server import PlexServer
myplex = self._server.myPlexAccount()
user = myplex.user(user)
# Get the token for your machine.
token = user.get_token(self._server.machineIdentifier)
# Login to your server using your friends credentials.
user_server = PlexServer(self._server._baseurl, token)
return self.create(user_server, self.title, self.items())
def get_plex():
global _plex_instance
if not _plex_instance:
session = requests.Session()
if app.debug:
# When we are running in debug mode, disable the (default) gzip encoding so we can better
# observe the communicate with the Plex server
session.headers['Accept-Encoding'] = 'default'
_plex_instance = PlexServer(app.config['PLEX_URL'], app.config['PLEX_TOKEN'], session=session)
return _plex_instance
def migrate(plex_url: str, plex_token: str, jellyfin_url: str,
jellyfin_token: str, jellyfin_user: str,
secure: bool, debug: bool, no_skip: bool):
# Remove insecure request warnings
if not secure:
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
# Setup sessions
session = requests.Session()
session.verify = secure
plex = PlexServer(plex_url, plex_token, session=session)
jellyfin = JellyFinServer(
url=jellyfin_url, api_key=jellyfin_token, session=session)
# Watched list from Plex
plex_watched = []
# Get all Plex watched movies
plex_movies = plex.library.section('Films')
for m in plex_movies.search(unwatched=False):
info = _extract_provider(data=m.guid)
info['title'] = m.title
plex_watched.append(info)
# Get all Plex watched episodes
plex_tvshows = plex.library.section('TV Shows')
plex_watched_episodes = []
for show in plex_tvshows.search(unwatched=False):
for e in plex.library.section('TV Shows').get(show.title).episodes():
info = _extract_provider(data=m.guid)
info['title'] = f"{show.title} {e.seasonEpisode.capitalize()} {e.title}" # s01e03 > S01E03
plex_watched.append(info)
# This gets all jellyfin movies since filtering on provider id isn't supported:
# https://github.com/jellyfin/jellyfin/issues/1990
jf_uid = jellyfin.get_user_id(name=jellyfin_user)
jf_library = jellyfin.get_all(user_id=jf_uid)
for watched in plex_watched:
search_result = _search(jf_library, watched)
if search_result and not search_result['UserData']['Played']:
jellyfin.mark_watched(
user_id=jf_uid, item_id=search_result['Id'])
print(f"{bcolors.OKGREEN}Marked {watched['title']} as watched{bcolors.ENDC}")
elif not search_result:
print(f"{bcolors.WARNING}No matches for {watched['title']}{bcolors.ENDC}")
if not skip:
sys.exit(1)
else:
if debug:
print(f"{bcolors.OKBLUE}{watched['title']}{bcolors.ENDC}")
print(f"{bcolors.OKGREEN}Succesfully migrated {len(plex_watched)} items{bcolors.ENDC}")
def __init__(self, name, plex_url, plex_user, plex_password,
plex_server, plex_token, plex_machine_id):
"""Initialize the sensor."""
from plexapi.myplex import MyPlexAccount
from plexapi.server import PlexServer
self._name = name
self._media_attrs = {}
self._plex_machine_id = plex_machine_id
self._player_state = 'idle'
self._machineIdentifier = plex_machine_id
self._device = None
self._is_player_active = False
self._is_player_available = False
self._player = None
self._make = 'AppleTV'
self._session = None
self._session_type = None
self._session_username = None
self._state = STATE_IDLE
self._entity_picture = None
self._plex_url = plex_url
self._plex_token = plex_token
self._media_content_id = None
self._media_content_rating = None
self._media_content_type = None
self._media_duration = None
self._media_image_url = None
self._media_title = None
self._media_ratio = None
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 __init__(self, bot, **kwargs):
"""
Initializes Plex resources
Connects to Plex library and sets up
all asyncronous communications.
Args:
bot: discord.ext.command.Bot, bind for cogs
base_url: str url to Plex server
plex_token: str X-Token of Plex server
lib_name: str name of Plex library to search through
Raises:
plexapi.exceptions.Unauthorized: Invalid Plex token
Returns:
None
"""
self.bot = bot
self.base_url = kwargs["base_url"]
self.plex_token = kwargs["plex_token"]
self.library_name = kwargs["lib_name"]
self.bot_prefix = bot.command_prefix
if kwargs["lyrics_token"]:
self.genius = lyricsgenius.Genius(kwargs["lyrics_token"])
else:
plex_log.warning("No lyrics token specified, lyrics disabled")
self.genius = None
# Log fatal invalid plex token
try:
self.pms = PlexServer(self.base_url, self.plex_token)
except Unauthorized:
plex_log.fatal("Invalid Plex token, stopping...")
raise Unauthorized("Invalid Plex token")
self.music = self.pms.library.section(self.library_name)
plex_log.debug("Connected to plex library: %s", self.library_name)
# Initialize necessary vars
self.voice_channel = None
self.current_track = None
self.np_message_id = None
self.ctx = None
# Initialize events
self.play_queue = asyncio.Queue()
self.play_next_event = asyncio.Event()
bot_log.info("Started bot successfully")
self.bot.loop.create_task(self._audio_player_task())
def connect_plex_server_by_url(req):
try:
server_url = req.form['server_url']
server_token = req.form['server_token']
plex = PlexServer(server_url, server_token)
sections = plex.library.sections()
return len(sections)
except Exception as exception:
logger.error('Exception:%s', exception)
logger.error(traceback.format_exc())
return 'fail'
def __init__(self):
baseurl = os.environ.get("PLEX_BASE_URL")
token = os.environ.get("PLEX_TOKEN")
verify_ssl = os.environ.get("BYPASS_SSL_VERIFY", "0") != "1"
session = requests.Session()
session.verify = verify_ssl
self.plex = PlexServer(baseurl,
token,
session=session,
timeout=(60 * 60))
def execute():
plex = PlexServer(settings.PLEX_URL, settings.PLEX_TOKEN)
plex_sections = plex.library.sections()
for plex_section in plex_sections:
for collection in plex_section.collection():
if collection.childCount <= 1 and collection.title not in settings.IGNORE_SINGLE_VIDEO_COLLECTIONS:
print("Removing collection: {title}".format(
title=collection.title))
collection.delete()
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 connect(self):
baseurl = 'http://{0}:{1}'.format(self._servername, self._port)
try:
self._plex = PlexServer(baseurl, self._token)
except plexapi.exceptions.Unauthorized as e:
logging.error('Authorization error when connecting to plex')
raise e
self._music = self._plex.library.section("Music")
def fetch_plex_instance(pi_dash, username=None, password=None, host=None):
username = username or pi_dash.config.get('plexserver', 'username', from_keyring=True)
password = password or pi_dash.config.get('plexserver', 'password', from_keyring=True)
host = host or pi_dash.config.get('plexserver', 'host', '')
if username:
log.info('Logging into MyPlex with user %s', username)
user = MyPlexAccount.signin(username, password)
log.info('Connecting to Plex host: %s', host)
return user.resource(host).connect()
log.info('Connecting to Plex host: %s', host)
return PlexServer(host)
def __init__(self, url, host, token):
# Init Logger
self.__log = logging.getLogger(self.__class__.__name__)
# Init Client API
session = requests.Session() # TODO handle: session.verify = config.plex_verify_ssl
self.__connection = PlexServer(url, token, session=session)
self.__host = host
# Init Data Attributes
self.__active_streams = {}
def get_movie(movie, url, token):
results = PlexServer(url, token).search(movie["title"])
# return movie if it exists
for plex_movie in results:
if plex_movie.type == "movie" and str(plex_movie.year) in str(
movie["year"]):
return plex_movie
return False
def plexlogin():
global plex
global client
baseurl = "http://serverip:port"
from plexapi.server import PlexServer
plex = PlexServer(baseurl)
client = plex.client("clientnamegoeshere")
def auto_delete():
print('\n%s Starting plex-autodelete script..' % datestr())
plex = PlexServer()
for section in plex.library.sections():
if section.type in ('show',):
deleted = 0
for tag, keep in TAGS.items():
func = keep_season if keep == 'season' else keep_episodes
for show in section.search(collection=tag):
deleted += func(show, keep)
if deleted:
section.update()
def delete_from_plex(self, plexname, serverNumber = None):
tempPlex = plex;
if serverNumber != None:
tempPlex = PlexServer(PLEX_SERVER_URLS_LIST[serverNumber],PLEX_SERVER_TOKENS_LIST[serverNumber])
try:
tempPlex.myPlexAccount().removeFriend(user=plexname)
self.delete_from_ombi(plexname) # Error if trying to remove trial user that doesn't exist in Ombi?
self.delete_from_tautulli(plexname, serverNumber)
return True
except plexapi.exceptions.NotFound:
#print("Not found")
return False
def main():
logging.basicConfig(level=logging.INFO)
secondsToWait = int(os.environ.get('SECONDS_TO_WAIT', 1800))
baseurl = os.environ.get('PLEX_URL')
token = os.environ.get('PLEX_TOKEN')
while True:
plex = PlexServer(baseurl, token)
client_credentials_manager = SpotifyClientCredentials()
sp = spotipy.Spotify(
client_credentials_manager=client_credentials_manager)
runSync(plex, sp)
time.sleep(secondsToWait)
def __init__(self, config):
""" __init__ """
token = config["Plex"]["token"]
baseurl = "http://{0}:32400".format(config["Plex"]["ip"])
try:
self.plex = PlexServer(baseurl, token)
movie_continue = True
except ConnectionError:
print("Down")
movie_continue = False
if movie_continue:
self.get_avail_movies()
def test_server_Server_session(account):
# Mock Sesstion
class MySession(Session):
def __init__(self):
super(self.__class__, self).__init__()
self.plexapi_session_test = True
# Test Code
plex = PlexServer(utils.SERVER_BASEURL,
account.authenticationToken,
session=MySession())
assert hasattr(plex._session, "plexapi_session_test")
def get_playlist_movies(url, token, playlist):
movies = PlexServer(url, token).playlist(playlist)
movie_list = []
for movie in movies.items():
movie_list.append({"title": movie.title,
"guid": movie.guid[26:],
"year": movie.year,
"rating": movie.audienceRating})
return movie_list
def processEvent(payload):
if not payload:
logger.error("Empty payload. Early return.")
return
plex = PlexServer(os.environ["PLEXAPI_AUTH_SERVER_BASEURL"], os.environ["PLEXAPI_AUTH_SERVER_TOKEN"])
event_type = payload.get('event')
if not event_type or event_type == '':
logger.error("No event type")
return
logger.info(f'Processing {event_type} event.')
# Do your thing
def test_server_Server_session():
# Mock Sesstion
class MySession(Session):
def __init__(self):
super(self.__class__, self).__init__()
self.plexapi_session_test = True
# Test Code
plex = PlexServer(utils.SERVER_BASEURL,
utils.SERVER_TOKEN,
session=MySession())
assert hasattr(plex._session, 'plexapi_session_test')
def get_needed_data(self, data: dict, data_needed: list) -> (bool, dict):
server = PlexServer(
'http://{0}:{1}'.format(self.config.PLEX_HOST,
self.config.PLEX_PORT),
self.config.PLEX_TOKEN)
plex_data = server.search(data['title'])
if data['media_type'] == MediaType.FILMS:
result = self.check_film(plex_data, data)
else:
result = self.check_serials(plex_data, data)
return not len(result) == 0, {'media_in_plex': not len(result) == 0}
def main():
"""Main script"""
plex = PlexServer(PLEX_URL, PLEX_TOKEN)
plex_users = get_user_tokens(plex.machineIdentifier)
plex_playlists = {
playlist.title: playlist.items()
for playlist in plex.playlists()
}
for playlist in PLAYLISTS:
playlist_items = plex_playlists.get(playlist)
if not playlist_items:
print("Playlist '{playlist}' not found on the server. Skipping.".
format(playlist=playlist))
continue
print("Cloning the '{title}' playlist...".format(title=playlist))
for user in USERS:
user_token = plex_users.get(user)
if not user_token:
print("...User '{user}' not found in shared users. Skipping.".
format(user=user))
continue
user_plex = PlexServer(PLEX_URL, user_token)
# Delete the old playlist
try:
user_playlist = user_plex.playlist(playlist)
user_playlist.delete()
except:
pass
# Create a new playlist
user_plex.createPlaylist(playlist, playlist_items)
print("...Created playlist for '{user}'.".format(user=user))
return
def plex():
# Get info from config file
config = configparser.ConfigParser()
config.read('config.ini')
PLEX_URL = config['LOGIN']['PLEX_URL']
PLEX_TOKEN = config['LOGIN']['PLEX_TOKEN']
assert len(PLEX_URL) > 0, "Plex URL is not specified in config file."
assert len(PLEX_TOKEN) > 0, "Plex token is not specified in config file."
# Create PlexServer instance
session = requests.Session()
session.verify = False
return PlexServer(PLEX_URL, PLEX_TOKEN, session=session)
def main():
args = get_args()
mediaType = args.type
videoName = args.video
ccName = args.chromecast
baseurl = 'http://192.168.0.14:32400'
token = 'hdHPsyJ8ingKxpzmLcPn'
plex = PlexServer(baseurl, token)
video = plex.library.section(mediaType).get(videoName)
playOnChromecast(video.getStreamURL(), ccName)
def __init__(self) -> None:
super().__init__()
try:
self.config = json.loads(StorageUtil.read_file('config', 'plex.json'))
auth = json.loads(StorageUtil.read_file("auth", "credentials.json"))
self.plex = PlexServer(auth["url"], auth["token"])
except Exception as e:
EventLogHelper.log_error(
f"Encountered exception while initializing controller -> {e}",
self.__class__.__name__,
inspect.currentframe().f_code.co_name,
logging.CRITICAL
)
