mirror of
https://github.com/pkkid/python-plexapi
synced 2024-11-22 19:53:17 +00:00
248 lines
10 KiB
Python
248 lines
10 KiB
Python
# -*- coding: utf-8 -*-
|
|
from urllib.parse import quote_plus
|
|
|
|
from plexapi import utils
|
|
from plexapi.base import PlexObject
|
|
from plexapi.exceptions import BadRequest, Unsupported
|
|
|
|
|
|
class PlayQueue(PlexObject):
|
|
"""Control a PlayQueue.
|
|
|
|
Attributes:
|
|
TAG (str): 'PlayQueue'
|
|
TYPE (str): 'playqueue'
|
|
identifier (str): com.plexapp.plugins.library
|
|
items (list): List of :class:`~plexapi.media.Media` or :class:`~plexapi.playlist.Playlist`
|
|
mediaTagPrefix (str): Fx /system/bundle/media/flags/
|
|
mediaTagVersion (int): Fx 1485957738
|
|
playQueueID (int): ID of the PlayQueue.
|
|
playQueueLastAddedItemID (int):
|
|
Defines where the "Up Next" region starts. Empty unless PlayQueue is modified after creation.
|
|
playQueueSelectedItemID (int): The queue item ID of the currently selected item.
|
|
playQueueSelectedItemOffset (int):
|
|
The offset of the selected item in the PlayQueue, from the beginning of the queue.
|
|
playQueueSelectedMetadataItemID (int): ID of the currently selected item, matches ratingKey.
|
|
playQueueShuffled (bool): True if shuffled.
|
|
playQueueSourceURI (str): Original URI used to create the PlayQueue.
|
|
playQueueTotalCount (int): How many items in the PlayQueue.
|
|
playQueueVersion (int): Version of the PlayQueue. Increments every time a change is made to the PlayQueue.
|
|
selectedItem (:class:`~plexapi.media.Media`): Media object for the currently selected item.
|
|
_server (:class:`~plexapi.server.PlexServer`): PlexServer associated with the PlayQueue.
|
|
size (int): Alias for playQueueTotalCount.
|
|
"""
|
|
|
|
TAG = "PlayQueue"
|
|
TYPE = "playqueue"
|
|
|
|
def _loadData(self, data):
|
|
self._data = data
|
|
self.identifier = data.attrib.get("identifier")
|
|
self.mediaTagPrefix = data.attrib.get("mediaTagPrefix")
|
|
self.mediaTagVersion = utils.cast(int, data.attrib.get("mediaTagVersion"))
|
|
self.playQueueID = utils.cast(int, data.attrib.get("playQueueID"))
|
|
self.playQueueLastAddedItemID = utils.cast(
|
|
int, data.attrib.get("playQueueLastAddedItemID")
|
|
)
|
|
self.playQueueSelectedItemID = utils.cast(
|
|
int, data.attrib.get("playQueueSelectedItemID")
|
|
)
|
|
self.playQueueSelectedItemOffset = utils.cast(
|
|
int, data.attrib.get("playQueueSelectedItemOffset")
|
|
)
|
|
self.playQueueSelectedMetadataItemID = utils.cast(
|
|
int, data.attrib.get("playQueueSelectedMetadataItemID")
|
|
)
|
|
self.playQueueShuffled = utils.cast(
|
|
bool, data.attrib.get("playQueueShuffled", 0)
|
|
)
|
|
self.playQueueSourceURI = data.attrib.get("playQueueSourceURI")
|
|
self.playQueueTotalCount = utils.cast(
|
|
int, data.attrib.get("playQueueTotalCount")
|
|
)
|
|
self.playQueueVersion = utils.cast(int, data.attrib.get("playQueueVersion"))
|
|
self.size = utils.cast(int, data.attrib.get("size", 0))
|
|
self.items = self.findItems(data)
|
|
self.selectedItem = self[self.playQueueSelectedItemOffset]
|
|
|
|
def __getitem__(self, key):
|
|
return self.items[key]
|
|
|
|
def __len__(self):
|
|
return self.playQueueTotalCount
|
|
|
|
def __iter__(self):
|
|
yield from self.items
|
|
|
|
def __contains__(self, media):
|
|
"""Returns True if the PlayQueue contains the provided media item."""
|
|
return any(x.playQueueItemID == media.playQueueItemID for x in self.items)
|
|
|
|
def getQueueItem(self, item):
|
|
"""
|
|
Accepts a media item and returns a similar object from this PlayQueue.
|
|
Useful for looking up playQueueItemIDs using items obtained from the Library.
|
|
"""
|
|
matches = [x for x in self.items if x == item]
|
|
if len(matches) == 1:
|
|
return matches[0]
|
|
elif len(matches) > 1:
|
|
raise BadRequest(
|
|
"{item} occurs multiple times in this PlayQueue, provide exact item".format(item=item)
|
|
)
|
|
else:
|
|
raise BadRequest("{item} not valid for this PlayQueue".format(item=item))
|
|
|
|
@classmethod
|
|
def create(
|
|
cls,
|
|
server,
|
|
items,
|
|
startItem=None,
|
|
shuffle=0,
|
|
repeat=0,
|
|
includeChapters=1,
|
|
includeRelated=1,
|
|
continuous=0,
|
|
):
|
|
"""Create and return a new :class:`~plexapi.playqueue.PlayQueue`.
|
|
|
|
Parameters:
|
|
server (:class:`~plexapi.server.PlexServer`): Server you are connected to.
|
|
items (:class:`~plexapi.media.Media` or :class:`~plexapi.playlist.Playlist`):
|
|
A media item, list of media items, or Playlist.
|
|
startItem (:class:`~plexapi.media.Media`, optional):
|
|
Media item in the PlayQueue where playback should begin.
|
|
shuffle (int, optional): Start the playqueue shuffled.
|
|
repeat (int, optional): Start the playqueue shuffled.
|
|
includeChapters (int, optional): include Chapters.
|
|
includeRelated (int, optional): include Related.
|
|
continuous (int, optional): include additional items after the initial item.
|
|
For a show this would be the next episodes, for a movie it does nothing.
|
|
"""
|
|
args = {
|
|
"includeChapters": includeChapters,
|
|
"includeRelated": includeRelated,
|
|
"repeat": repeat,
|
|
"shuffle": shuffle,
|
|
"continuous": continuous,
|
|
}
|
|
|
|
if isinstance(items, list):
|
|
item_keys = ",".join([str(x.ratingKey) for x in items])
|
|
uri_args = quote_plus("/library/metadata/{item_keys}".format(item_keys=item_keys))
|
|
args["uri"] = "library:///directory/{uri_args}".format(uri_args=uri_args)
|
|
args["type"] = items[0].listType
|
|
elif items.type == "playlist":
|
|
args["playlistID"] = items.ratingKey
|
|
args["type"] = items.playlistType
|
|
else:
|
|
uuid = items.section().uuid
|
|
args["type"] = items.listType
|
|
args["uri"] = "library://{uuid}/item/{key}".format(uuid=uuid, key=items.key)
|
|
|
|
if startItem:
|
|
args["key"] = startItem.key
|
|
|
|
path = "/playQueues{args}".format(args=utils.joinArgs(args))
|
|
data = server.query(path, method=server._session.post)
|
|
c = cls(server, data, initpath=path)
|
|
c.playQueueType = args["type"]
|
|
c._server = server
|
|
return c
|
|
|
|
def addItem(self, item, playNext=False, refresh=True):
|
|
"""
|
|
Append the provided item to the "Up Next" section of the PlayQueue.
|
|
Items can only be added to the section immediately following the current playing item.
|
|
|
|
Parameters:
|
|
item (:class:`~plexapi.media.Media` or :class:`~plexapi.playlist.Playlist`): Single media item or Playlist.
|
|
playNext (bool, optional): If True, add this item to the front of the "Up Next" section.
|
|
If False, the item will be appended to the end of the "Up Next" section.
|
|
Only has an effect if an item has already been added to the "Up Next" section.
|
|
See https://support.plex.tv/articles/202188298-play-queues/ for more details.
|
|
refresh (bool, optional): Refresh the PlayQueue from the server before updating.
|
|
"""
|
|
if refresh:
|
|
self.refresh()
|
|
|
|
args = {}
|
|
if item.type == "playlist":
|
|
args["playlistID"] = item.ratingKey
|
|
itemType = item.playlistType
|
|
else:
|
|
uuid = item.section().uuid
|
|
itemType = item.listType
|
|
args["uri"] = "library://{uuid}/item{key}".format(uuid=uuid, key=item.key)
|
|
|
|
if itemType != self.playQueueType:
|
|
raise Unsupported("Item type does not match PlayQueue type")
|
|
|
|
if playNext:
|
|
args["next"] = 1
|
|
|
|
path = "/playQueues/{playQueueID}{args}".format(playQueueID=self.playQueueID, args=utils.joinArgs(args))
|
|
data = self._server.query(path, method=self._server._session.put)
|
|
self._loadData(data)
|
|
|
|
def moveItem(self, item, after=None, refresh=True):
|
|
"""
|
|
Moves an item to the beginning of the PlayQueue. If `after` is provided,
|
|
the item will be placed immediately after the specified item.
|
|
|
|
Parameters:
|
|
item (:class:`~plexapi.base.Playable`): An existing item in the PlayQueue to move.
|
|
afterItemID (:class:`~plexapi.base.Playable`, optional): A different item in the PlayQueue.
|
|
If provided, `item` will be placed in the PlayQueue after this item.
|
|
refresh (bool, optional): Refresh the PlayQueue from the server before updating.
|
|
"""
|
|
args = {}
|
|
|
|
if refresh:
|
|
self.refresh()
|
|
|
|
if item not in self:
|
|
item = self.getQueueItem(item)
|
|
|
|
if after:
|
|
if after not in self:
|
|
after = self.getQueueItem(after)
|
|
args["after"] = after.playQueueItemID
|
|
|
|
path = "/playQueues/{playQueueID}/items/{playQueueItemID}/move{args}".format(
|
|
playQueueID=self.playQueueID, playQueueItemID=item.playQueueItemID, args=utils.joinArgs(args)
|
|
)
|
|
data = self._server.query(path, method=self._server._session.put)
|
|
self._loadData(data)
|
|
|
|
def removeItem(self, item, refresh=True):
|
|
"""Remove an item from the PlayQueue.
|
|
|
|
Parameters:
|
|
item (:class:`~plexapi.base.Playable`): An existing item in the PlayQueue to move.
|
|
refresh (bool, optional): Refresh the PlayQueue from the server before updating.
|
|
"""
|
|
if refresh:
|
|
self.refresh()
|
|
|
|
if item not in self:
|
|
item = self.getQueueItem(item)
|
|
|
|
path = "/playQueues/{playQueueID}/items/{playQueueItemID}".format(
|
|
playQueueID=self.playQueueID, playQueueItemID=item.playQueueItemID
|
|
)
|
|
data = self._server.query(path, method=self._server._session.delete)
|
|
self._loadData(data)
|
|
|
|
def clear(self):
|
|
"""Remove all items from the PlayQueue."""
|
|
path = "/playQueues/{playQueueID}/items".format(playQueueID=self.playQueueID)
|
|
data = self._server.query(path, method=self._server._session.delete)
|
|
self._loadData(data)
|
|
|
|
def refresh(self):
|
|
"""Refresh the PlayQueue from the Plex server."""
|
|
path = "/playQueues/{playQueueID}".format(playQueueID=self.playQueueID)
|
|
data = self._server.query(path, method=self._server._session.get)
|
|
self._loadData(data)
|