1310 lines
51 KiB
Python
1310 lines
51 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
Collection of functions associated with Kodi and Plex playlists and playqueues
|
|
"""
|
|
from __future__ import absolute_import, division, unicode_literals
|
|
from logging import getLogger
|
|
import threading
|
|
|
|
from .plex_api import API
|
|
from .plex_db import PlexDB
|
|
from . import plex_functions as PF
|
|
from .playutils import PlayUtils
|
|
from .kodi_db import kodiid_from_filename, KodiVideoDB
|
|
from .downloadutils import DownloadUtils as DU
|
|
from . import utils, json_rpc as js, variables as v, app, widgets
|
|
from .windows.resume import resume_dialog
|
|
|
|
###############################################################################
|
|
|
|
LOG = getLogger('PLEX.playlist_func')
|
|
|
|
###############################################################################
|
|
|
|
|
|
class PlaylistError(Exception):
|
|
"""
|
|
Exception for our playlist constructs
|
|
"""
|
|
pass
|
|
|
|
|
|
class PlayQueue(object):
|
|
"""
|
|
PKC object to represent PMS playQueues and Kodi playlist for queueing
|
|
|
|
playlistid = None [int] Kodi playlist id (0, 1, 2)
|
|
type = None [str] Kodi type: 'audio', 'video', 'picture'
|
|
kodi_pl = None Kodi xbmc.PlayList object
|
|
items = [] [list] of PlaylistItem
|
|
id = None [str] Plex playQueueID, unique Plex identifier
|
|
version = None [int] Plex version of the playQueue
|
|
selectedItemID = None
|
|
[str] Plex selectedItemID, playing element in queue
|
|
selectedItemOffset = None
|
|
[str] Offset of the playing element in queue
|
|
shuffled = 0 [int] 0: not shuffled, 1: ??? 2: ???
|
|
repeat = 0 [int] 0: not repeated, 1: ??? 2: ???
|
|
|
|
If Companion playback is initiated by another user:
|
|
plex_transient_token = None
|
|
"""
|
|
kind = 'playQueue'
|
|
|
|
def __init__(self):
|
|
self.id = None
|
|
self.type = None
|
|
self.playlistid = None
|
|
self.kodi_pl = None
|
|
self.items = []
|
|
self.version = None
|
|
self.selectedItemID = None
|
|
self.selectedItemOffset = None
|
|
self.shuffled = 0
|
|
self.repeat = 0
|
|
self.plex_transient_token = None
|
|
# Need a hack for detecting swaps of elements
|
|
self.old_kodi_pl = []
|
|
# Did PKC itself just change the playqueue so the PKC playqueue monitor
|
|
# should not pick up any changes?
|
|
self.pkc_edit = False
|
|
# Workaround to avoid endless loops of detecting PL clears
|
|
self._clear_list = []
|
|
# To keep track if Kodi playback was initiated from a Kodi playlist
|
|
# There are a couple of pitfalls, unfortunately...
|
|
self.kodi_playlist_playback = False
|
|
# Playlist position/index used when initiating the playqueue
|
|
self.index = None
|
|
self.force_transcode = None
|
|
|
|
def __unicode__(self):
|
|
return ("{{"
|
|
"'playlistid': {self.playlistid}, "
|
|
"'id': {self.id}, "
|
|
"'version': {self.version}, "
|
|
"'type': '{self.type}', "
|
|
"'items': {items}, "
|
|
"'selectedItemID': {self.selectedItemID}, "
|
|
"'selectedItemOffset': {self.selectedItemOffset}, "
|
|
"'shuffled': {self.shuffled}, "
|
|
"'repeat': {self.repeat}, "
|
|
"'kodi_playlist_playback': {self.kodi_playlist_playback}, "
|
|
"'pkc_edit': {self.pkc_edit}, "
|
|
"}}").format(**{
|
|
'items': ['%s/%s: %s' % (x.plex_id, x.id, x.name)
|
|
for x in self.items],
|
|
'self': self
|
|
})
|
|
|
|
def __str__(self):
|
|
return unicode(self).encode('utf-8')
|
|
__repr__ = __str__
|
|
|
|
def is_pkc_clear(self):
|
|
"""
|
|
Returns True if PKC has cleared the Kodi playqueue just recently.
|
|
Then this clear will be ignored from now on
|
|
"""
|
|
try:
|
|
self._clear_list.pop()
|
|
except IndexError:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def clear(self, kodi=True):
|
|
"""
|
|
Resets the playlist object to an empty playlist.
|
|
|
|
Pass kodi=False in order to NOT clear the Kodi playqueue
|
|
"""
|
|
# kodi monitor's on_clear method will only be called if there were some
|
|
# items to begin with
|
|
if kodi and self.kodi_pl.size() != 0:
|
|
self._clear_list.append(None)
|
|
self.kodi_pl.clear() # Clear Kodi playlist object
|
|
self.items = []
|
|
self.id = None
|
|
self.version = None
|
|
self.selectedItemID = None
|
|
self.selectedItemOffset = None
|
|
self.shuffled = 0
|
|
self.repeat = 0
|
|
self.plex_transient_token = None
|
|
self.old_kodi_pl = []
|
|
self.kodi_playlist_playback = False
|
|
self.index = None
|
|
self.force_transcode = None
|
|
LOG.debug('Playlist cleared: %s', self)
|
|
|
|
def play(self, plex_id, plex_type=None, startpos=None, position=None,
|
|
synched=True, force_transcode=None):
|
|
"""
|
|
Initializes the playQueue with e.g. trailers and additional file parts
|
|
Pass synched=False if you're sure that this item has not been synched
|
|
to Kodi
|
|
|
|
Or resolves webservice paths to actual paths
|
|
"""
|
|
LOG.debug('Play called with plex_id %s, plex_type %s, position %s, '
|
|
'synched %s, force_transcode %s, startpos %s', plex_id,
|
|
plex_type, position, synched, force_transcode, startpos)
|
|
resolve = False
|
|
try:
|
|
if plex_id == self.items[startpos].plex_id:
|
|
resolve = True
|
|
except IndexError:
|
|
pass
|
|
if resolve:
|
|
LOG.info('Resolving playback')
|
|
self._resolve(plex_id, startpos)
|
|
else:
|
|
LOG.info('Initializing playback')
|
|
self.init(plex_id,
|
|
plex_type,
|
|
startpos,
|
|
position,
|
|
synched,
|
|
force_transcode)
|
|
|
|
def _resolve(self, plex_id, startpos):
|
|
"""
|
|
The Plex playqueue has already been initialized. We resolve the path
|
|
from original webservice http://127.0.0.1 to the "correct" Plex one
|
|
"""
|
|
self.index = startpos + 1
|
|
xml = PF.GetPlexMetadata(plex_id)
|
|
if xml in (None, 401):
|
|
raise PlaylistError('Could not get Plex metadata %s for %s',
|
|
plex_id, self.items[startpos])
|
|
api = API(xml[0])
|
|
resume = self._resume_playback(None, xml[0])
|
|
self._kodi_add_xml(xml[0], api, resume)
|
|
# Add additional file parts, if any exist
|
|
self._add_additional_parts(xml)
|
|
|
|
def init(self, plex_id, plex_type=None, startpos=None, position=None,
|
|
synched=True, force_transcode=None):
|
|
"""
|
|
Initializes the Plex and PKC playqueue for playback
|
|
"""
|
|
self.index = position
|
|
while len(self.items) < self.kodi_pl.size():
|
|
# The original item that Kodi put into the playlist, e.g.
|
|
# {
|
|
# u'title': u'',
|
|
# u'type': u'unknown',
|
|
# u'file': u'http://127.0.0.1:57578/plex/kodi/....',
|
|
# u'label': u''
|
|
# }
|
|
# We CANNOT delete that item right now - so let's add a dummy
|
|
# on the PKC side to keep all indicees lined up.
|
|
# The failing item will be deleted in webservice.py
|
|
LOG.debug('Adding a dummy item to our playqueue')
|
|
self.items.insert(0, PlaylistItemDummy())
|
|
self.force_transcode = force_transcode
|
|
if synched:
|
|
with PlexDB(lock=False) as plexdb:
|
|
db_item = plexdb.item_by_id(plex_id, plex_type)
|
|
else:
|
|
db_item = None
|
|
if db_item:
|
|
xml = None
|
|
section_uuid = db_item['section_uuid']
|
|
plex_type = db_item['plex_type']
|
|
else:
|
|
xml = PF.GetPlexMetadata(plex_id)
|
|
if xml in (None, 401):
|
|
raise PlaylistError('Could not get Plex metadata %s', plex_id)
|
|
section_uuid = xml.get('librarySectionUUID')
|
|
api = API(xml[0])
|
|
plex_type = api.plex_type()
|
|
resume = self._resume_playback(db_item, xml)
|
|
trailers = False
|
|
if (not resume and plex_type == v.PLEX_TYPE_MOVIE and
|
|
utils.settings('enableCinema') == 'true'):
|
|
if utils.settings('askCinema') == "true":
|
|
# "Play trailers?"
|
|
trailers = utils.yesno_dialog(utils.lang(29999),
|
|
utils.lang(33016)) or False
|
|
else:
|
|
trailers = True
|
|
LOG.debug('Playing trailers: %s', trailers)
|
|
xml = PF.init_plex_playqueue(plex_id,
|
|
section_uuid,
|
|
plex_type=plex_type,
|
|
trailers=trailers)
|
|
if xml is None:
|
|
LOG.error('Could not get playqueue for plex_id %s UUID %s for %s',
|
|
plex_id, section_uuid, self)
|
|
raise PlaylistError('Could not get playqueue')
|
|
# See that we add trailers, if they exist in the xml return
|
|
self._add_intros(xml)
|
|
# Add the main item after the trailers
|
|
# Look at the LAST item
|
|
api = API(xml[-1])
|
|
self._kodi_add_xml(xml[-1], api, resume)
|
|
# Add additional file parts, if any exist
|
|
self._add_additional_parts(xml)
|
|
self.update_details_from_xml(xml)
|
|
|
|
@staticmethod
|
|
def _resume_playback(db_item=None, xml=None):
|
|
'''
|
|
Pass in either db_item or xml
|
|
Resume item if available. Returns bool or raise an PlayStrmException if
|
|
resume was cancelled by user.
|
|
'''
|
|
resume = app.PLAYSTATE.resume_playback
|
|
app.PLAYSTATE.resume_playback = None
|
|
if app.PLAYSTATE.autoplay:
|
|
resume = False
|
|
LOG.info('Skip resume for autoplay')
|
|
elif resume is None:
|
|
if db_item:
|
|
with KodiVideoDB(lock=False) as kodidb:
|
|
resume = kodidb.get_resume(db_item['kodi_fileid'])
|
|
else:
|
|
api = API(xml)
|
|
resume = api.resume_point()
|
|
if resume:
|
|
resume = resume_dialog(resume)
|
|
LOG.info('User chose resume: %s', resume)
|
|
if resume is None:
|
|
raise PlaylistError('User backed out of resume dialog')
|
|
app.PLAYSTATE.autoplay = True
|
|
return resume
|
|
|
|
def _add_intros(self, xml):
|
|
'''
|
|
if we have any play them when the movie/show is not being resumed.
|
|
'''
|
|
if not len(xml) > 1:
|
|
LOG.debug('No trailers returned from the PMS')
|
|
return
|
|
for i, intro in enumerate(xml):
|
|
if i + 1 == len(xml):
|
|
# The main item we're looking at - skip!
|
|
break
|
|
api = API(intro)
|
|
LOG.debug('Adding trailer: %s', api.title())
|
|
self._kodi_add_xml(intro, api)
|
|
|
|
def _add_additional_parts(self, xml):
|
|
''' Create listitems and add them to the stack of playlist.
|
|
'''
|
|
api = API(xml[0])
|
|
for part, _ in enumerate(xml[0][0]):
|
|
if part == 0:
|
|
# The first part that we've already added
|
|
continue
|
|
api.set_part_number(part)
|
|
LOG.debug('Adding addional part for %s: %s', api.title(), part)
|
|
self._kodi_add_xml(xml[0], api)
|
|
|
|
def _kodi_add_xml(self, xml, api, resume=False):
|
|
playlistitem = PlaylistItem(xml_video_element=xml)
|
|
playlistitem.part = api.part
|
|
playlistitem.force_transcode = self.force_transcode
|
|
listitem = widgets.get_listitem(xml, resume=True)
|
|
listitem.setSubtitles(api.cache_external_subs())
|
|
play = PlayUtils(api, playlistitem)
|
|
url = play.getPlayUrl()
|
|
listitem.setPath(url.encode('utf-8'))
|
|
self.kodi_add_item(playlistitem, self.index, listitem)
|
|
self.items.insert(self.index, playlistitem)
|
|
self.index += 1
|
|
|
|
def update_details_from_xml(self, xml):
|
|
"""
|
|
Updates the playlist details from the xml provided
|
|
"""
|
|
self.id = utils.cast(int, xml.get('%sID' % self.kind))
|
|
self.version = utils.cast(int, xml.get('%sVersion' % self.kind))
|
|
self.shuffled = utils.cast(int, xml.get('%sShuffled' % self.kind))
|
|
self.selectedItemID = utils.cast(int,
|
|
xml.get('%sSelectedItemID' % self.kind))
|
|
self.selectedItemOffset = utils.cast(int,
|
|
xml.get('%sSelectedItemOffset'
|
|
% self.kind))
|
|
LOG.debug('Updated playlist from xml: %s', self)
|
|
|
|
def add_item(self, item, pos, listitem=None):
|
|
"""
|
|
Adds a PlaylistItem to both Kodi and Plex at position pos [int]
|
|
Also changes self.items
|
|
Raises PlaylistError
|
|
"""
|
|
self.kodi_add_item(item, pos, listitem)
|
|
self.plex_add_item(item, pos)
|
|
|
|
def kodi_add_item(self, item, pos, listitem=None):
|
|
"""
|
|
Adds a PlaylistItem to Kodi only. Will not change self.items
|
|
Raises PlaylistError
|
|
"""
|
|
if not isinstance(item, PlaylistItem):
|
|
raise PlaylistError('Wrong item %s of type %s received'
|
|
% (item, type(item)))
|
|
if pos > len(self.items):
|
|
raise PlaylistError('Position %s too large for playlist length %s'
|
|
% (pos, len(self.items)))
|
|
LOG.debug('Adding item to Kodi playlist at position %s: %s', pos, item)
|
|
if listitem:
|
|
self.kodi_pl.add(url=listitem.getPath(),
|
|
listitem=listitem,
|
|
index=pos)
|
|
elif item.kodi_id is not None and item.kodi_type is not None:
|
|
# This method ensures we have full Kodi metadata, potentially
|
|
# with more artwork, for example, than Plex provides
|
|
if pos == len(self.items):
|
|
answ = js.playlist_add(self.playlistid,
|
|
{'%sid' % item.kodi_type: item.kodi_id})
|
|
else:
|
|
answ = js.playlist_insert({'playlistid': self.playlistid,
|
|
'position': pos,
|
|
'item': {'%sid' % item.kodi_type: item.kodi_id}})
|
|
if 'error' in answ:
|
|
raise PlaylistError('Kodi did not add item to playlist: %s',
|
|
answ)
|
|
else:
|
|
if item.xml is None:
|
|
LOG.debug('Need to get metadata for item %s', item)
|
|
item.xml = PF.GetPlexMetadata(item.plex_id)
|
|
if item.xml in (None, 401):
|
|
raise PlaylistError('Could not get metadata for %s', item)
|
|
api = API(item.xml[0])
|
|
listitem = widgets.get_listitem(item.xml, resume=True)
|
|
url = 'http://127.0.0.1:%s/plex/play/file.strm' % v.WEBSERVICE_PORT
|
|
args = {
|
|
'plex_id': item.plex_id,
|
|
'plex_type': api.plex_type()
|
|
}
|
|
if item.force_transcode:
|
|
args['transcode'] = 'true'
|
|
url = utils.extend_url(url, args)
|
|
item.file = url
|
|
listitem.setPath(url.encode('utf-8'))
|
|
self.kodi_pl.add(url=url.encode('utf-8'),
|
|
listitem=listitem,
|
|
index=pos)
|
|
|
|
def plex_add_item(self, item, pos):
|
|
"""
|
|
Adds a new PlaylistItem to the playlist at position pos [int] only on
|
|
the Plex side of things. Also changes self.items
|
|
Raises PlaylistError
|
|
"""
|
|
if not isinstance(item, PlaylistItem) or not item.uri:
|
|
raise PlaylistError('Wrong item %s of type %s received'
|
|
% (item, type(item)))
|
|
if pos > len(self.items):
|
|
raise PlaylistError('Position %s too large for playlist length %s'
|
|
% (pos, len(self.items)))
|
|
LOG.debug('Adding item to Plex playlist at position %s: %s', pos, item)
|
|
url = '{server}/%ss/%s?uri=%s' % (self.kind, self.id, item.uri)
|
|
# Will usually put the new item at the end of the Plex playlist
|
|
xml = DU().downloadUrl(url, action_type='PUT')
|
|
try:
|
|
xml[0].attrib
|
|
except (TypeError, AttributeError, KeyError, IndexError):
|
|
raise PlaylistError('Could not add item %s to playlist %s'
|
|
% (item, self))
|
|
for actual_pos, xml_video_element in enumerate(xml):
|
|
api = API(xml_video_element)
|
|
if api.plex_id() == item.plex_id:
|
|
break
|
|
else:
|
|
raise PlaylistError('Something went wrong - Plex id not found')
|
|
item.from_xml(xml[actual_pos])
|
|
self.items.insert(actual_pos, item)
|
|
self.update_details_from_xml(xml)
|
|
if actual_pos != pos:
|
|
self.plex_move_item(actual_pos, pos)
|
|
LOG.debug('Added item %s on Plex side: %s', item, self)
|
|
|
|
def kodi_remove_item(self, pos):
|
|
"""
|
|
Only manipulates the Kodi playlist. Won't change self.items
|
|
"""
|
|
LOG.debug('Removing position %s on the Kodi side for %s', pos, self)
|
|
answ = js.playlist_remove(self.playlistid, pos)
|
|
if 'error' in answ:
|
|
raise PlaylistError('Could not remove item: %s' % answ['error'])
|
|
|
|
def plex_move_item(self, before, after):
|
|
"""
|
|
Moves playlist item from before [int] to after [int] for Plex only.
|
|
|
|
Will also change self.items
|
|
"""
|
|
if before > len(self.items) or after > len(self.items) or after == before:
|
|
raise PlaylistError('Illegal original position %s and/or desired '
|
|
'position %s for playlist length %s' %
|
|
(before, after, len(self.items)))
|
|
LOG.debug('Moving item from %s to %s on the Plex side for %s',
|
|
before, after, self)
|
|
if after == 0:
|
|
url = "{server}/%ss/%s/items/%s/move?after=0" % \
|
|
(self.kind,
|
|
self.id,
|
|
self.items[before].id)
|
|
elif after > before:
|
|
url = "{server}/%ss/%s/items/%s/move?after=%s" % \
|
|
(self.kind,
|
|
self.id,
|
|
self.items[before].id,
|
|
self.items[after].id)
|
|
else:
|
|
url = "{server}/%ss/%s/items/%s/move?after=%s" % \
|
|
(self.kind,
|
|
self.id,
|
|
self.items[before].id,
|
|
self.items[after - 1].id)
|
|
xml = DU().downloadUrl(url, action_type="PUT")
|
|
try:
|
|
xml[0].attrib
|
|
except (TypeError, IndexError, AttributeError):
|
|
raise PlaylistError('Could not move playlist item from %s to %s '
|
|
'for %s' % (before, after, self))
|
|
self.update_details_from_xml(xml)
|
|
self.items.insert(after, self.items.pop(before))
|
|
LOG.debug('Done moving items for %s', self)
|
|
|
|
def init_from_xml(self, xml, offset=None, start_plex_id=None, repeat=None,
|
|
transient_token=None):
|
|
"""
|
|
Play all items contained in the xml passed in. Called by Plex Companion.
|
|
Either supply the ratingKey of the starting Plex element. Or set
|
|
playqueue.selectedItemID
|
|
|
|
offset [float]: will seek to position offset after playback start
|
|
start_plex_id [int]: the plex_id of the element that should be
|
|
played
|
|
repeat [int]: 0: don't repear
|
|
1: repeat item
|
|
2: repeat everything
|
|
transient_token [unicode]: temporary token received from the PMS
|
|
|
|
Will stop current playback and start playback at the end
|
|
"""
|
|
LOG.debug("init_from_xml called with offset %s, start_plex_id %s",
|
|
offset, start_plex_id)
|
|
app.APP.player.stop()
|
|
self.clear()
|
|
self.update_details_from_xml(xml)
|
|
self.repeat = 0 if not repeat else repeat
|
|
self.plex_transient_token = transient_token
|
|
for pos, xml_video_element in enumerate(xml):
|
|
playlistitem = PlaylistItem(xml_video_element=xml_video_element)
|
|
self.kodi_add_item(playlistitem, pos)
|
|
self.items.append(playlistitem)
|
|
# Where do we start playback?
|
|
if start_plex_id is not None:
|
|
for startpos, item in enumerate(self.items):
|
|
if item.plex_id == start_plex_id:
|
|
break
|
|
else:
|
|
startpos = 0
|
|
else:
|
|
for startpos, item in enumerate(self.items):
|
|
if item.id == self.selectedItemID:
|
|
break
|
|
else:
|
|
startpos = 0
|
|
self.start_playback(pos=startpos, offset=offset)
|
|
|
|
def start_playback(self, pos=0, offset=0):
|
|
"""
|
|
Seek immediately after kicking off playback is not reliable.
|
|
Threaded, since we need to return BEFORE seeking
|
|
"""
|
|
LOG.info('Starting playback at %s offset %s for %s', pos, offset, self)
|
|
thread = threading.Thread(target=self._threaded_playback,
|
|
args=(self.kodi_pl, pos, offset))
|
|
thread.start()
|
|
|
|
@staticmethod
|
|
def _threaded_playback(kodi_playlist, pos, offset):
|
|
app.APP.player.play(kodi_playlist, startpos=pos, windowed=False)
|
|
if offset:
|
|
i = 0
|
|
while not app.APP.is_playing:
|
|
app.APP.monitor.waitForAbort(0.1)
|
|
i += 1
|
|
if i > 50:
|
|
LOG.warn('Could not seek to %s', offset)
|
|
return
|
|
js.seek_to(offset)
|
|
|
|
|
|
class PlaylistItem(object):
|
|
"""
|
|
Object to fill our playqueues and playlists with.
|
|
|
|
id = None [int] Plex playlist/playqueue id, e.g. playQueueItemID
|
|
plex_id = None [int] Plex unique item id, "ratingKey"
|
|
plex_type = None [str] Plex type, e.g. 'movie', 'clip'
|
|
plex_uuid = None [str] Plex librarySectionUUID
|
|
kodi_id = None [int] Kodi unique kodi id (unique only within type!)
|
|
kodi_type = None [str] Kodi type: 'movie'
|
|
file = None [str] Path to the item's file. STRING!!
|
|
uri = None [str] Weird Plex uri path involving plex_uuid. STRING!
|
|
guid = None [str] Weird Plex guid
|
|
xml = None [etree] XML from PMS, 1 lvl below <MediaContainer>
|
|
playmethod = None [str] either 'DirectPlay', 'DirectStream', 'Transcode'
|
|
playcount = None [int] how many times the item has already been played
|
|
offset = None [int] the item's view offset UPON START in Plex time
|
|
part = 0 [int] part number if Plex video consists of mult. parts
|
|
force_transcode [bool] defaults to False
|
|
|
|
PlaylistItem compare as equal, if they
|
|
- have the same plex_id
|
|
- OR: have the same kodi_id AND kodi_type
|
|
- OR: have the same file
|
|
"""
|
|
def __init__(self, plex_id=None, plex_type=None, xml_video_element=None,
|
|
kodi_id=None, kodi_type=None, grab_xml=False,
|
|
lookup_kodi=True):
|
|
"""
|
|
Pass grab_xml=True in order to get Plex metadata from the PMS while
|
|
passing a plex_id.
|
|
Pass lookup_kodi=False to NOT check the plex.db for kodi_id and
|
|
kodi_type if they're missing (won't be done for clips anyway)
|
|
"""
|
|
self.name = None
|
|
self.id = None
|
|
self.plex_id = plex_id
|
|
self.plex_type = plex_type
|
|
self.plex_uuid = None
|
|
self.kodi_id = kodi_id
|
|
self.kodi_type = kodi_type
|
|
self.file = None
|
|
self.uri = None
|
|
self.guid = None
|
|
self.xml = None
|
|
self.playmethod = None
|
|
self.playcount = None
|
|
self.offset = None
|
|
self.part = 0
|
|
self.force_transcode = False
|
|
if grab_xml and plex_id is not None and xml_video_element is None:
|
|
xml_video_element = PF.GetPlexMetadata(plex_id)
|
|
try:
|
|
xml_video_element = xml_video_element[0]
|
|
except (TypeError, IndexError):
|
|
xml_video_element = None
|
|
if xml_video_element is not None:
|
|
self.from_xml(xml_video_element)
|
|
if (lookup_kodi and (kodi_id is None or kodi_type is None) and
|
|
self.plex_type != v.PLEX_TYPE_CLIP):
|
|
with PlexDB(lock=False) as plexdb:
|
|
db_item = plexdb.item_by_id(self.plex_id, self.plex_type)
|
|
if db_item is not None:
|
|
self.kodi_id = db_item['kodi_id']
|
|
self.kodi_type = db_item['kodi_type']
|
|
self.plex_uuid = db_item['section_uuid']
|
|
self.set_uri()
|
|
|
|
def __eq__(self, other):
|
|
if self.plex_id is not None and other.plex_id is not None:
|
|
return self.plex_id == other.plex_id
|
|
elif (self.kodi_id is not None and other.kodi_id is not None and
|
|
self.kodi_type and other.kodi_type):
|
|
return (self.kodi_id == other.kodi_id and
|
|
self.kodi_type == other.kodi_type)
|
|
elif self.file and other.file:
|
|
return self.file == other.file
|
|
raise RuntimeError('PlaylistItems not fully defined: %s, %s' %
|
|
(self, other))
|
|
|
|
def __ne__(self, other):
|
|
return not self == other
|
|
|
|
def __unicode__(self):
|
|
return ("{{"
|
|
"'name': '{self.name}', "
|
|
"'id': {self.id}, "
|
|
"'plex_id': {self.plex_id}, "
|
|
"'plex_type': '{self.plex_type}', "
|
|
"'kodi_id': {self.kodi_id}, "
|
|
"'kodi_type': '{self.kodi_type}', "
|
|
"'file': '{self.file}', "
|
|
"'uri': '{self.uri}', "
|
|
"'guid': '{self.guid}', "
|
|
"'playmethod': '{self.playmethod}', "
|
|
"'playcount': {self.playcount}, "
|
|
"'offset': {self.offset}, "
|
|
"'force_transcode': {self.force_transcode}, "
|
|
"'part': {self.part}"
|
|
"}}".format(self=self))
|
|
|
|
def __str__(self):
|
|
return unicode(self).encode('utf-8')
|
|
__repr__ = __str__
|
|
|
|
def from_xml(self, xml_video_element):
|
|
"""
|
|
xml_video_element: etree xml piece 1 level underneath <MediaContainer>
|
|
item.id will only be set if you passed in an xml_video_element from
|
|
e.g. a playQueue
|
|
"""
|
|
api = API(xml_video_element)
|
|
self.name = api.title()
|
|
self.plex_id = api.plex_id()
|
|
self.plex_type = api.plex_type()
|
|
self.id = api.item_id()
|
|
self.guid = api.guid_html_escaped()
|
|
self.playcount = api.viewcount()
|
|
self.offset = api.resume_point()
|
|
self.xml = xml_video_element
|
|
|
|
def from_kodi(self, playlist_item):
|
|
"""
|
|
playlist_item: dict contains keys 'id', 'type', 'file' (if applicable)
|
|
|
|
Will thus set the attributes kodi_id, kodi_type, file, if applicable
|
|
If kodi_id & kodi_type are provided, plex_id and plex_type will be
|
|
looked up (if not already set)
|
|
"""
|
|
self.kodi_id = playlist_item.get('id')
|
|
self.kodi_type = playlist_item.get('type')
|
|
self.file = playlist_item.get('file')
|
|
if self.plex_id is None and self.kodi_id is not None and self.kodi_type:
|
|
with PlexDB(lock=False) as plexdb:
|
|
db_item = plexdb.item_by_kodi_id(self.kodi_id, self.kodi_type)
|
|
if db_item:
|
|
self.plex_id = db_item['plex_id']
|
|
self.plex_type = db_item['plex_type']
|
|
self.plex_uuid = db_item['section_uuid']
|
|
if self.plex_id is None and self.file is not None:
|
|
try:
|
|
query = self.file.split('?', 1)[1]
|
|
except IndexError:
|
|
query = ''
|
|
query = dict(utils.parse_qsl(query))
|
|
self.plex_id = utils.cast(int, query.get('plex_id'))
|
|
self.plex_type = query.get('itemType')
|
|
self.set_uri()
|
|
LOG.debug('Made playlist item from Kodi: %s', self)
|
|
|
|
def set_uri(self):
|
|
if self.plex_id is None and self.file is not None:
|
|
self.uri = ('library://whatever/item/%s'
|
|
% utils.quote(self.file, safe=''))
|
|
elif self.plex_id is not None and self.plex_uuid is not None:
|
|
# TO BE VERIFIED - PLEX DOESN'T LIKE PLAYLIST ADDS IN THIS MANNER
|
|
self.uri = ('library://%s/item/library%%2Fmetadata%%2F%s' %
|
|
(self.plex_uuid, self.plex_id))
|
|
elif self.plex_id is not None:
|
|
self.uri = ('library://%s/item/library%%2Fmetadata%%2F%s' %
|
|
(self.plex_id, self.plex_id))
|
|
else:
|
|
self.uri = None
|
|
|
|
def plex_stream_index(self, kodi_stream_index, stream_type):
|
|
"""
|
|
Pass in the kodi_stream_index [int] in order to receive the Plex stream
|
|
index.
|
|
|
|
stream_type: 'video', 'audio', 'subtitle'
|
|
|
|
Returns None if unsuccessful
|
|
"""
|
|
stream_type = v.PLEX_STREAM_TYPE_FROM_STREAM_TYPE[stream_type]
|
|
count = 0
|
|
if kodi_stream_index == -1:
|
|
# Kodi telling us "it's the last one"
|
|
iterator = list(reversed(self.xml[0][self.part]))
|
|
kodi_stream_index = 0
|
|
else:
|
|
iterator = self.xml[0][self.part]
|
|
# Kodi indexes differently than Plex
|
|
for stream in iterator:
|
|
if (stream.attrib['streamType'] == stream_type and
|
|
'key' in stream.attrib):
|
|
if count == kodi_stream_index:
|
|
return stream.attrib['id']
|
|
count += 1
|
|
for stream in iterator:
|
|
if (stream.attrib['streamType'] == stream_type and
|
|
'key' not in stream.attrib):
|
|
if count == kodi_stream_index:
|
|
return stream.attrib['id']
|
|
count += 1
|
|
|
|
def kodi_stream_index(self, plex_stream_index, stream_type):
|
|
"""
|
|
Pass in the kodi_stream_index [int] in order to receive the Plex stream
|
|
index.
|
|
|
|
stream_type: 'video', 'audio', 'subtitle'
|
|
|
|
Returns None if unsuccessful
|
|
"""
|
|
stream_type = v.PLEX_STREAM_TYPE_FROM_STREAM_TYPE[stream_type]
|
|
count = 0
|
|
for stream in self.xml[0][self.part]:
|
|
if (stream.attrib['streamType'] == stream_type and
|
|
'key' in stream.attrib):
|
|
if stream.attrib['id'] == plex_stream_index:
|
|
return count
|
|
count += 1
|
|
for stream in self.xml[0][self.part]:
|
|
if (stream.attrib['streamType'] == stream_type and
|
|
'key' not in stream.attrib):
|
|
if stream.attrib['id'] == plex_stream_index:
|
|
return count
|
|
count += 1
|
|
|
|
|
|
class PlaylistItemDummy(PlaylistItem):
|
|
"""
|
|
Let e.g. Kodimonitor detect that this is a dummy item
|
|
"""
|
|
def __init__(self, *args, **kwargs):
|
|
super(PlaylistItemDummy, self).__init__(*args, **kwargs)
|
|
self.name = 'dummy item'
|
|
self.id = 0
|
|
self.plex_id = 0
|
|
|
|
|
|
def playlist_item_from_kodi(kodi_item):
|
|
"""
|
|
Turns the JSON answer from Kodi into a playlist element
|
|
|
|
Supply with data['item'] as returned from Kodi JSON-RPC interface.
|
|
kodi_item dict contains keys 'id', 'type', 'file' (if applicable)
|
|
"""
|
|
item = PlaylistItem()
|
|
item.kodi_id = kodi_item.get('id')
|
|
item.kodi_type = kodi_item.get('type')
|
|
if item.kodi_id:
|
|
with PlexDB(lock=False) as plexdb:
|
|
db_item = plexdb.item_by_kodi_id(kodi_item['id'], kodi_item['type'])
|
|
if db_item:
|
|
item.plex_id = db_item['plex_id']
|
|
item.plex_type = db_item['plex_type']
|
|
item.plex_uuid = db_item['section_uuid']
|
|
item.file = kodi_item.get('file')
|
|
if item.plex_id is None and item.file is not None:
|
|
try:
|
|
query = item.file.split('?', 1)[1]
|
|
except IndexError:
|
|
query = ''
|
|
query = dict(utils.parse_qsl(query))
|
|
item.plex_id = utils.cast(int, query.get('plex_id'))
|
|
item.plex_type = query.get('itemType')
|
|
if item.plex_id is None and item.file is not None:
|
|
item.uri = ('library://whatever/item/%s'
|
|
% utils.quote(item.file, safe=''))
|
|
else:
|
|
# TO BE VERIFIED - PLEX DOESN'T LIKE PLAYLIST ADDS IN THIS MANNER
|
|
item.uri = ('library://%s/item/library%%2Fmetadata%%2F%s' %
|
|
(item.plex_uuid, item.plex_id))
|
|
LOG.debug('Made playlist item from Kodi: %s', item)
|
|
return item
|
|
|
|
|
|
def verify_kodi_item(plex_id, kodi_item):
|
|
"""
|
|
Tries to lookup kodi_id and kodi_type for kodi_item (with kodi_item['file']
|
|
supplied) - if and only if plex_id is None.
|
|
|
|
Returns the kodi_item with kodi_item['id'] and kodi_item['type'] possibly
|
|
set to None if unsuccessful.
|
|
|
|
Will raise a PlaylistError if plex_id is None and kodi_item['file'] starts
|
|
with either 'plugin' or 'http'
|
|
"""
|
|
if plex_id is not None or kodi_item.get('id') is not None:
|
|
# Got all the info we need
|
|
return kodi_item
|
|
# Special case playlist startup - got type but no id
|
|
if (not app.SYNC.direct_paths and app.SYNC.enable_music and
|
|
kodi_item.get('type') == v.KODI_TYPE_SONG and
|
|
kodi_item['file'].startswith('http')):
|
|
kodi_item['id'], _ = kodiid_from_filename(kodi_item['file'],
|
|
v.KODI_TYPE_SONG)
|
|
LOG.debug('Detected song. Research results: %s', kodi_item)
|
|
return kodi_item
|
|
# Need more info since we don't have kodi_id nor type. Use file path.
|
|
if ((kodi_item['file'].startswith('plugin') and
|
|
not kodi_item['file'].startswith('plugin://%s' % v.ADDON_ID)) or
|
|
kodi_item['file'].startswith('http')):
|
|
LOG.info('kodi_item %s cannot be used for Plex playback', kodi_item)
|
|
raise PlaylistError
|
|
LOG.debug('Starting research for Kodi id since we didnt get one: %s',
|
|
kodi_item)
|
|
# Try the VIDEO DB first - will find both movies and episodes
|
|
kodi_id, kodi_type = kodiid_from_filename(kodi_item['file'],
|
|
db_type='video')
|
|
if not kodi_id:
|
|
# No movie or episode found - try MUSIC DB now for songs
|
|
kodi_id, kodi_type = kodiid_from_filename(kodi_item['file'],
|
|
db_type='music')
|
|
kodi_item['id'] = kodi_id
|
|
kodi_item['type'] = None if kodi_id is None else kodi_type
|
|
LOG.debug('Research results for kodi_item: %s', kodi_item)
|
|
return kodi_item
|
|
|
|
|
|
def playlist_item_from_plex(plex_id):
|
|
"""
|
|
Returns a playlist element providing the plex_id ("ratingKey")
|
|
|
|
Returns a Playlist_Item
|
|
"""
|
|
item = PlaylistItem()
|
|
item.plex_id = plex_id
|
|
with PlexDB(lock=False) as plexdb:
|
|
db_item = plexdb.item_by_id(plex_id)
|
|
if db_item:
|
|
item.plex_type = db_item['plex_type']
|
|
item.kodi_id = db_item['kodi_id']
|
|
item.kodi_type = db_item['kodi_type']
|
|
else:
|
|
raise KeyError('Could not find plex_id %s in database' % plex_id)
|
|
item.plex_uuid = plex_id
|
|
item.uri = ('library://%s/item/library%%2Fmetadata%%2F%s' %
|
|
(item.plex_uuid, plex_id))
|
|
LOG.debug('Made playlist item from plex: %s', item)
|
|
return item
|
|
|
|
|
|
def playlist_item_from_xml(xml_video_element, kodi_id=None, kodi_type=None):
|
|
"""
|
|
Returns a playlist element for the playqueue using the Plex xml
|
|
|
|
xml_video_element: etree xml piece 1 level underneath <MediaContainer>
|
|
"""
|
|
item = PlaylistItem()
|
|
api = API(xml_video_element)
|
|
item.plex_id = api.plex_id()
|
|
item.plex_type = api.plex_type()
|
|
# item.id will only be set if you passed in an xml_video_element from e.g.
|
|
# a playQueue
|
|
item.id = api.item_id()
|
|
if kodi_id is not None and kodi_type is not None:
|
|
item.kodi_id = kodi_id
|
|
item.kodi_type = kodi_type
|
|
item.guid = api.guid_html_escaped()
|
|
item.playcount = api.viewcount()
|
|
item.offset = api.resume_point()
|
|
item.xml = xml_video_element
|
|
LOG.debug('Created new playlist item from xml: %s', item)
|
|
return item
|
|
|
|
|
|
def _get_playListVersion_from_xml(playlist, xml):
|
|
"""
|
|
Takes a PMS xml as input to overwrite the playlist version (e.g. Plex
|
|
playQueueVersion).
|
|
|
|
Raises PlaylistError if unsuccessful
|
|
"""
|
|
playlist.version = utils.cast(int,
|
|
xml.get('%sVersion' % playlist.kind))
|
|
if playlist.version is None:
|
|
raise PlaylistError('Could not get new playlist Version for playlist '
|
|
'%s' % playlist)
|
|
|
|
|
|
def get_playlist_details_from_xml(playlist, xml):
|
|
"""
|
|
Takes a PMS xml as input and overwrites all the playlist's details, e.g.
|
|
playlist.id with the XML's playQueueID
|
|
|
|
Raises PlaylistError if something went wrong.
|
|
"""
|
|
playlist.id = utils.cast(int,
|
|
xml.get('%sID' % playlist.kind))
|
|
playlist.version = utils.cast(int,
|
|
xml.get('%sVersion' % playlist.kind))
|
|
playlist.shuffled = utils.cast(int,
|
|
xml.get('%sShuffled' % playlist.kind))
|
|
playlist.selectedItemID = utils.cast(int,
|
|
xml.get('%sSelectedItemID'
|
|
% playlist.kind))
|
|
playlist.selectedItemOffset = utils.cast(int,
|
|
xml.get('%sSelectedItemOffset'
|
|
% playlist.kind))
|
|
LOG.debug('Updated playlist from xml: %s', playlist)
|
|
|
|
|
|
def update_playlist_from_PMS(playlist, playlist_id=None, xml=None):
|
|
"""
|
|
Updates Kodi playlist using a new PMS playlist. Pass in playlist_id if we
|
|
need to fetch a new playqueue
|
|
|
|
If an xml is passed in, the playlist will be overwritten with its info
|
|
"""
|
|
if xml is None:
|
|
xml = get_PMS_playlist(playlist, playlist_id)
|
|
# Clear our existing playlist and the associated Kodi playlist
|
|
playlist.clear()
|
|
# Set new values
|
|
get_playlist_details_from_xml(playlist, xml)
|
|
for plex_item in xml:
|
|
playlist_item = add_to_Kodi_playlist(playlist, plex_item)
|
|
if playlist_item is not None:
|
|
playlist.items.append(playlist_item)
|
|
|
|
|
|
def init_plex_playqueue(playlist, plex_id=None, kodi_item=None):
|
|
"""
|
|
Initializes the Plex side without changing the Kodi playlists
|
|
WILL ALSO UPDATE OUR PLAYLISTS.
|
|
|
|
Returns the first PKC playlist item or raises PlaylistError
|
|
"""
|
|
LOG.debug('Initializing the playqueue on the Plex side: %s', playlist)
|
|
playlist.clear(kodi=False)
|
|
verify_kodi_item(plex_id, kodi_item)
|
|
try:
|
|
if plex_id:
|
|
item = playlist_item_from_plex(plex_id)
|
|
else:
|
|
item = playlist_item_from_kodi(kodi_item)
|
|
params = {
|
|
'next': 0,
|
|
'type': playlist.type,
|
|
'uri': item.uri
|
|
}
|
|
xml = DU().downloadUrl(url="{server}/%ss" % playlist.kind,
|
|
action_type="POST",
|
|
parameters=params)
|
|
get_playlist_details_from_xml(playlist, xml)
|
|
# Need to get the details for the playlist item
|
|
item = playlist_item_from_xml(xml[0])
|
|
except (KeyError, IndexError, TypeError):
|
|
LOG.error('Could not init Plex playlist: plex_id %s, kodi_item %s',
|
|
plex_id, kodi_item)
|
|
raise PlaylistError
|
|
playlist.items.append(item)
|
|
LOG.debug('Initialized the playqueue on the Plex side: %s', playlist)
|
|
return item
|
|
|
|
|
|
def add_listitem_to_playlist(playlist, pos, listitem, kodi_id=None,
|
|
kodi_type=None, plex_id=None, file=None):
|
|
"""
|
|
Adds a listitem to both the Kodi and Plex playlist at position pos [int].
|
|
|
|
If file is not None, file will overrule kodi_id!
|
|
|
|
file: str!!
|
|
"""
|
|
LOG.debug('add_listitem_to_playlist at position %s. Playlist before add: '
|
|
'%s', pos, playlist)
|
|
kodi_item = {'id': kodi_id, 'type': kodi_type, 'file': file}
|
|
if playlist.id is None:
|
|
init_plex_playqueue(playlist, plex_id, kodi_item)
|
|
else:
|
|
add_item_to_plex_playqueue(playlist, pos, plex_id, kodi_item)
|
|
if kodi_id is None and playlist.items[pos].kodi_id:
|
|
kodi_id = playlist.items[pos].kodi_id
|
|
kodi_type = playlist.items[pos].kodi_type
|
|
if file is None:
|
|
file = playlist.items[pos].file
|
|
# Otherwise we double the item!
|
|
del playlist.items[pos]
|
|
kodi_item = {'id': kodi_id, 'type': kodi_type, 'file': file}
|
|
add_listitem_to_Kodi_playlist(playlist,
|
|
pos,
|
|
listitem,
|
|
file,
|
|
kodi_item=kodi_item)
|
|
|
|
|
|
def add_item_to_playlist(playlist, pos, kodi_id=None, kodi_type=None,
|
|
plex_id=None, file=None):
|
|
"""
|
|
Adds an item to BOTH the Kodi and Plex playlist at position pos [int]
|
|
file: str!
|
|
|
|
Raises PlaylistError if something went wrong
|
|
"""
|
|
LOG.debug('add_item_to_playlist. Playlist before adding: %s', playlist)
|
|
kodi_item = {'id': kodi_id, 'type': kodi_type, 'file': file}
|
|
if playlist.id is None:
|
|
item = init_plex_playqueue(playlist, plex_id, kodi_item)
|
|
else:
|
|
item = add_item_to_plex_playqueue(playlist, pos, plex_id, kodi_item)
|
|
params = {
|
|
'playlistid': playlist.playlistid,
|
|
'position': pos
|
|
}
|
|
if item.kodi_id is not None:
|
|
params['item'] = {'%sid' % item.kodi_type: int(item.kodi_id)}
|
|
else:
|
|
params['item'] = {'file': item.file}
|
|
reply = js.playlist_insert(params)
|
|
if reply.get('error') is not None:
|
|
raise PlaylistError('Could not add item to playlist. Kodi reply. %s'
|
|
% reply)
|
|
return item
|
|
|
|
|
|
def add_item_to_plex_playqueue(playlist, pos, plex_id=None, kodi_item=None):
|
|
"""
|
|
Adds a new item to the playlist at position pos [int] only on the Plex
|
|
side of things (e.g. because the user changed the Kodi side)
|
|
WILL ALSO UPDATE OUR PLAYLISTS
|
|
|
|
Returns the PKC PlayList item or raises PlaylistError
|
|
"""
|
|
LOG.debug('Adding item to Plex playqueue with plex id %s, kodi_item %s at '
|
|
'position %s', plex_id, kodi_item, pos)
|
|
verify_kodi_item(plex_id, kodi_item)
|
|
if plex_id:
|
|
item = playlist_item_from_plex(plex_id)
|
|
else:
|
|
item = playlist_item_from_kodi(kodi_item)
|
|
url = '{server}/%ss/%s?uri=%s' % (playlist.kind, playlist.id, item.uri)
|
|
# Will always put the new item at the end of the Plex playlist
|
|
xml = DU().downloadUrl(url, action_type="PUT")
|
|
try:
|
|
xml[-1].attrib
|
|
except (TypeError, AttributeError, KeyError, IndexError):
|
|
raise PlaylistError('Could not add item %s to playlist %s'
|
|
% (kodi_item, playlist))
|
|
if len(xml) != len(playlist.items) + 1:
|
|
raise PlaylistError('Couldnt add item %s to playlist %s - wrong length'
|
|
% (kodi_item, playlist))
|
|
for actual_pos, xml_video_element in enumerate(xml):
|
|
api = API(xml_video_element)
|
|
if api.plex_id() == item.plex_id:
|
|
break
|
|
else:
|
|
raise PlaylistError('Something went terribly wrong!')
|
|
utils.dump_xml(xml)
|
|
LOG.debug('Plex added the new item at position %s', actual_pos)
|
|
item.xml = xml[actual_pos]
|
|
item.id = api.item_id()
|
|
item.guid = api.guid_html_escaped()
|
|
item.offset = api.resume_point()
|
|
item.playcount = api.viewcount()
|
|
playlist.items.insert(actual_pos, item)
|
|
_get_playListVersion_from_xml(playlist, xml)
|
|
if actual_pos != pos:
|
|
# Move the new item to the correct position
|
|
move_playlist_item(playlist, actual_pos, pos)
|
|
LOG.debug('Successfully added item on the Plex side: %s', playlist)
|
|
return item
|
|
|
|
|
|
def add_item_to_kodi_playlist(playlist, pos, kodi_id=None, kodi_type=None,
|
|
file=None, xml_video_element=None):
|
|
"""
|
|
Adds an item to the KODI playlist only. WILL ALSO UPDATE OUR PLAYLISTS
|
|
|
|
Returns the playlist item that was just added or raises PlaylistError
|
|
|
|
file: str!
|
|
"""
|
|
LOG.debug('Adding new item kodi_id: %s, kodi_type: %s, file: %s to Kodi '
|
|
'only at position %s for %s',
|
|
kodi_id, kodi_type, file, pos, playlist)
|
|
params = {
|
|
'playlistid': playlist.playlistid,
|
|
'position': pos
|
|
}
|
|
if kodi_id is not None:
|
|
params['item'] = {'%sid' % kodi_type: int(kodi_id)}
|
|
else:
|
|
params['item'] = {'file': file}
|
|
reply = js.playlist_insert(params)
|
|
if reply.get('error') is not None:
|
|
raise PlaylistError('Could not add item to playlist. Kodi reply. %s',
|
|
reply)
|
|
if xml_video_element is not None:
|
|
item = playlist_item_from_xml(xml_video_element)
|
|
item.kodi_id = kodi_id
|
|
item.kodi_type = kodi_type
|
|
item.file = file
|
|
elif kodi_id is not None:
|
|
item = playlist_item_from_kodi(
|
|
{'id': kodi_id, 'type': kodi_type, 'file': file})
|
|
if item.plex_id is not None:
|
|
xml = PF.GetPlexMetadata(item.plex_id)
|
|
item.xml = xml[-1]
|
|
playlist.items.insert(pos, item)
|
|
return item
|
|
|
|
|
|
def move_playlist_item(playlist, before_pos, after_pos):
|
|
"""
|
|
Moves playlist item from before_pos [int] to after_pos [int] for Plex only.
|
|
|
|
WILL ALSO CHANGE OUR PLAYLISTS.
|
|
"""
|
|
LOG.debug('Moving item from %s to %s on the Plex side for %s',
|
|
before_pos, after_pos, playlist)
|
|
if after_pos == 0:
|
|
url = "{server}/%ss/%s/items/%s/move?after=0" % \
|
|
(playlist.kind,
|
|
playlist.id,
|
|
playlist.items[before_pos].id)
|
|
else:
|
|
url = "{server}/%ss/%s/items/%s/move?after=%s" % \
|
|
(playlist.kind,
|
|
playlist.id,
|
|
playlist.items[before_pos].id,
|
|
playlist.items[after_pos - 1].id)
|
|
# We need to increment the playlistVersion
|
|
xml = DU().downloadUrl(url, action_type="PUT")
|
|
try:
|
|
xml[0].attrib
|
|
except (TypeError, IndexError, AttributeError):
|
|
LOG.error('Could not move playlist item')
|
|
return
|
|
_get_playListVersion_from_xml(playlist, xml)
|
|
utils.dump_xml(xml)
|
|
# Move our item's position in our internal playlist
|
|
playlist.items.insert(after_pos, playlist.items.pop(before_pos))
|
|
LOG.debug('Done moving for %s', playlist)
|
|
|
|
|
|
def get_PMS_playlist(playlist=None, playlist_id=None):
|
|
"""
|
|
Fetches the PMS playlist/playqueue as an XML. Pass in playlist_id if we
|
|
need to fetch a new playlist
|
|
|
|
Returns None if something went wrong
|
|
"""
|
|
playlist_id = playlist_id if playlist_id else playlist.id
|
|
if playlist and playlist.kind == 'playList':
|
|
xml = DU().downloadUrl("{server}/playlists/%s/items" % playlist_id)
|
|
else:
|
|
xml = DU().downloadUrl("{server}/playQueues/%s" % playlist_id)
|
|
try:
|
|
xml.attrib
|
|
except AttributeError:
|
|
xml = None
|
|
return xml
|
|
|
|
|
|
def refresh_playlist_from_PMS(playlist):
|
|
"""
|
|
Only updates the selected item from the PMS side (e.g.
|
|
playQueueSelectedItemID). Will NOT check whether items still make sense.
|
|
"""
|
|
get_playlist_details_from_xml(playlist, get_PMS_playlist(playlist))
|
|
|
|
|
|
def delete_playlist_item_from_PMS(playlist, pos):
|
|
"""
|
|
Delete the item at position pos [int] on the Plex side and our playlists
|
|
"""
|
|
LOG.debug('Deleting position %s for %s on the Plex side', pos, playlist)
|
|
xml = DU().downloadUrl("{server}/%ss/%s/items/%s?repeat=%s" %
|
|
(playlist.kind,
|
|
playlist.id,
|
|
playlist.items[pos].id,
|
|
playlist.repeat),
|
|
action_type="DELETE")
|
|
_get_playListVersion_from_xml(playlist, xml)
|
|
del playlist.items[pos]
|
|
|
|
|
|
# Functions operating on the Kodi playlist objects ##########
|
|
|
|
def add_to_Kodi_playlist(playlist, xml_video_element):
|
|
"""
|
|
Adds a new item to the Kodi playlist via JSON (at the end of the playlist).
|
|
Pass in the PMS xml's video element (one level underneath MediaContainer).
|
|
|
|
Returns a Playlist_Item or raises PlaylistError
|
|
"""
|
|
item = playlist_item_from_xml(xml_video_element)
|
|
if item.kodi_id:
|
|
json_item = {'%sid' % item.kodi_type: item.kodi_id}
|
|
else:
|
|
json_item = {'file': item.file}
|
|
reply = js.playlist_add(playlist.playlistid, json_item)
|
|
if reply.get('error') is not None:
|
|
raise PlaylistError('Could not add item %s to Kodi playlist. Error: '
|
|
'%s', xml_video_element, reply)
|
|
return item
|
|
|
|
|
|
def add_listitem_to_Kodi_playlist(playlist, pos, listitem, file,
|
|
xml_video_element=None, kodi_item=None):
|
|
"""
|
|
Adds an xbmc listitem to the Kodi playlist.xml_video_element
|
|
|
|
WILL NOT UPDATE THE PLEX SIDE, BUT WILL UPDATE OUR PLAYLISTS
|
|
|
|
file: string!
|
|
"""
|
|
LOG.debug('Insert listitem at position %s for Kodi only for %s',
|
|
pos, playlist)
|
|
# Add the item into Kodi playlist
|
|
playlist.kodi_pl.add(url=file, listitem=listitem, index=pos)
|
|
# We need to add this to our internal queue as well
|
|
if xml_video_element is not None:
|
|
item = playlist_item_from_xml(xml_video_element)
|
|
else:
|
|
item = playlist_item_from_kodi(kodi_item)
|
|
if file is not None:
|
|
item.file = file
|
|
playlist.items.insert(pos, item)
|
|
LOG.debug('Done inserting for %s', playlist)
|
|
return item
|
|
|
|
|
|
def remove_from_kodi_playlist(playlist, pos):
|
|
"""
|
|
Removes the item at position pos from the Kodi playlist using JSON.
|
|
|
|
WILL NOT UPDATE THE PLEX SIDE, BUT WILL UPDATE OUR PLAYLISTS
|
|
"""
|
|
LOG.debug('Removing position %s from Kodi only from %s', pos, playlist)
|
|
reply = js.playlist_remove(playlist.playlistid, pos)
|
|
if reply.get('error') is not None:
|
|
LOG.error('Could not delete the item from the playlist. Error: %s',
|
|
reply)
|
|
return
|
|
try:
|
|
del playlist.items[pos]
|
|
except IndexError:
|
|
LOG.error('Cannot delete position %s for %s', pos, playlist)
|
|
|
|
|
|
def get_pms_playqueue(playqueue_id):
|
|
"""
|
|
Returns the Plex playqueue as an etree XML or None if unsuccessful
|
|
"""
|
|
xml = DU().downloadUrl(
|
|
"{server}/playQueues/%s" % playqueue_id,
|
|
headerOptions={'Accept': 'application/xml'})
|
|
try:
|
|
xml.attrib
|
|
except AttributeError:
|
|
LOG.error('Could not download Plex playqueue %s', playqueue_id)
|
|
xml = None
|
|
return xml
|
|
|
|
|
|
def get_plextype_from_xml(xml):
|
|
"""
|
|
Needed if PMS returns an empty playqueue. Will get the Plex type from the
|
|
empty playlist playQueueSourceURI. Feed with (empty) etree xml
|
|
|
|
returns None if unsuccessful
|
|
"""
|
|
try:
|
|
plex_id = utils.REGEX_PLEX_ID_FROM_URL.findall(
|
|
xml.attrib['playQueueSourceURI'])[0]
|
|
except IndexError:
|
|
LOG.error('Could not get plex_id from xml: %s', xml.attrib)
|
|
return
|
|
new_xml = PF.GetPlexMetadata(plex_id)
|
|
try:
|
|
new_xml[0].attrib
|
|
except (TypeError, IndexError, AttributeError):
|
|
LOG.error('Could not get plex metadata for plex id %s', plex_id)
|
|
return
|
|
return new_xml[0].attrib.get('type').decode('utf-8')
|