Sync support

plexapi/__init__.py

@@ -17,6 +17,7 @@
 VERSION = '3.0.6'
 TIMEOUT = CONFIG.get('plexapi.timeout', 30, int)
 X_PLEX_CONTAINER_SIZE = CONFIG.get('plexapi.container_size', 100, int)
+X_PLEX_ENABLE_FAST_CONNECT = CONFIG.get('plexapi.enable_fast_connect', False, bool)
 
 # Plex Header Configuation
 X_PLEX_PROVIDES = CONFIG.get('header.provides', 'controller')

plexapi/base.py

@@ -139,12 +139,12 @@ def fetchItem(self, ekey, cls=None, **kwargs):
         clsname = cls.__name__ if cls else 'None'
         raise NotFound('Unable to find elem: cls=%s, attrs=%s' % (clsname, kwargs))
 
-    def fetchItems(self, ekey, cls=None, **kwargs):
+    def fetchItems(self, ekey, cls=None, timeout=None, **kwargs):
         """ Load the specified key to find and build all items with the specified tag
             and attrs. See :func:`~plexapi.base.PlexObject.fetchItem` for more details
             on how this is used.
         """
-        data = self._server.query(ekey)
+        data = self._server.query(ekey, timeout=timeout)
         return self.findItems(data, cls, ekey, **kwargs)
 
     def findItems(self, data, cls=None, initpath=None, **kwargs):

plexapi/media.py

@@ -92,6 +92,11 @@ def _loadData(self, data):
         self.indexes = data.attrib.get('indexes')
         self.key = data.attrib.get('key')
         self.size = cast(int, data.attrib.get('size'))
+        self.decision = data.attrib.get('decision')
+        self.optimizedForStreaming = cast(bool, data.attrib.get('optimizedForStreaming'))
+        self.syncItemId = cast(int, data.attrib.get('syncItemId'))
+        self.syncState = data.attrib.get('syncState')
+        self.videoProfile = data.attrib.get('videoProfile')
         self.streams = self._buildStreams(data)
 
     def _buildStreams(self, data):

plexapi/myplex.py

@@ -3,14 +3,15 @@
 import requests
 import time
 from requests.status_codes import _codes as codes
-from plexapi import BASE_HEADERS, CONFIG, TIMEOUT
+from plexapi import BASE_HEADERS, CONFIG, TIMEOUT, X_PLEX_IDENTIFIER, X_PLEX_ENABLE_FAST_CONNECT
 from plexapi import log, logfilter, utils
 from plexapi.base import PlexObject
 from plexapi.exceptions import BadRequest, NotFound
 from plexapi.client import PlexClient
 from plexapi.compat import ElementTree
 from plexapi.library import LibrarySection
 from plexapi.server import PlexServer
+from plexapi.sync import SyncList
 from plexapi.utils import joinArgs
 
 
@@ -378,6 +379,14 @@ def optOut(self, playback=None, library=None):
         url = 'https://plex.tv/api/v2/user/privacy'
         return self.query(url, method=self._session.put, params=params)
 
+    def syncItems(self, clientId=None):
+        if clientId is None:
+            clientId = X_PLEX_IDENTIFIER
+
+        data = self.query(SyncList.key.format(clientId=clientId))
+
+        return SyncList(self, data)
+
 
 class MyPlexUser(PlexObject):
     """ This object represents non-signed in users such as friends and linked
@@ -698,7 +707,7 @@ def delete(self):
         self._server.query(key, self._server._session.delete)
 
 
-def _connect(cls, url, token, timeout, results, i):
+def _connect(cls, url, token, timeout, results, i, connected_event=None):
     """ Connects to the specified cls with url and token. Stores the connection
         information to results[i] in a threadsafe way.
     """
@@ -707,6 +716,8 @@ def _connect(cls, url, token, timeout, results, i):
         device = cls(baseurl=url, token=token, timeout=timeout)
         runtime = int(time.time() - starttime)
         results[i] = (url, token, device, runtime)
+        if X_PLEX_ENABLE_FAST_CONNECT and connected_event:
+            connected_event.set()
     except Exception as err:
         runtime = int(time.time() - starttime)
         log.error('%s: %s', url, err)

plexapi/sync.py

@@ -1,42 +1,103 @@
 # -*- coding: utf-8 -*-
 import requests
-from plexapi import utils
+import plexapi
 from plexapi.exceptions import NotFound
+from plexapi.base import PlexObject, Playable
 
 
-class SyncItem(object):
-    """ Sync Item. This doesn't current work. """
-    def __init__(self, device, data, servers=None):
-        self._device = device
-        self._servers = servers
-        self._loadData(data)
+def init(replace_provides=False):
+    if replace_provides or not plexapi.X_PLEX_PROVIDES:
+        plexapi.X_PLEX_PROVIDES = 'sync-target'
+    else:
+        plexapi.X_PLEX_PROVIDES += ',sync-target'
+
+    plexapi.BASE_HEADERS['X-Plex-Sync-Version'] = '2'
+    plexapi.BASE_HEADERS['X-Plex-Provides'] = plexapi.X_PLEX_PROVIDES
+
+    # mimic iPhone SE
+    plexapi.X_PLEX_PLATFORM = 'iOS'
+    plexapi.X_PLEX_PLATFORM_VERSION = '11.4.1'
+    plexapi.X_PLEX_DEVICE = 'iPhone'
+
+    plexapi.BASE_HEADERS['X-Plex-Platform'] = plexapi.X_PLEX_PLATFORM
+    plexapi.BASE_HEADERS['X-Plex-Platform-Version'] = plexapi.X_PLEX_PLATFORM_VERSION
+    plexapi.BASE_HEADERS['X-Plex-Device'] = plexapi.X_PLEX_DEVICE
+    plexapi.BASE_HEADERS['X-Plex-Model'] = '8,4'
+    plexapi.BASE_HEADERS['X-Plex-Vendor'] = 'Apple'
+
+
+class SyncItem(PlexObject):
+    TAG = 'SyncItem'
+
+    def __init__(self, server, data, initpath=None, clientIdentifier=None):
+        super().__init__(server, data, initpath)
+        self.clientIdentifier = clientIdentifier
 
     def _loadData(self, data):
         self._data = data
-        self.id = utils.cast(int, data.attrib.get('id'))
-        self.version = utils.cast(int, data.attrib.get('version'))
+        self.id = plexapi.utils.cast(int, data.attrib.get('id'))
+        self.version = plexapi.utils.cast(int, data.attrib.get('version'))
         self.rootTitle = data.attrib.get('rootTitle')
         self.title = data.attrib.get('title')
         self.metadataType = data.attrib.get('metadataType')
         self.machineIdentifier = data.find('Server').get('machineIdentifier')
-        self.status = data.find('Status').attrib.copy()
+        self.status = Status(self._server, data.find('Status'))
         self.MediaSettings = data.find('MediaSettings').attrib.copy()
         self.policy = data.find('Policy').attrib.copy()
         self.location = data.find('Location').attrib.copy()
 
     def server(self):
-        server = list(filter(lambda x: x.machineIdentifier == self.machineIdentifier, self._servers))
+        server = list(filter(lambda x: x.clientIdentifier == self.machineIdentifier, self._server.resources()))
         if 0 == len(server):
             raise NotFound('Unable to find server with uuid %s' % self.machineIdentifier)
         return server[0]
 
-    def getMedia(self):
+    def getMedia(self, timeout=None):
         server = self.server().connect()
         key = '/sync/items/%s' % self.id
-        return server.fetchItems(key)
+        return server.fetchItems(key, timeout=timeout)
 
-    def markAsDone(self, sync_id):
-        server = self.server().connect()
-        url = '/sync/%s/%s/files/%s/downloaded' % (
-            self._device.clientIdentifier, server.machineIdentifier, sync_id)
-        server.query(url, method=requests.put)
+    def markDownloaded(self, media: Playable):
+        url = '/sync/%s/item/%s/downloaded' % (self.clientIdentifier, media.ratingKey)
+        media._server.query(url, method=requests.put)
+
+
+class SyncList(PlexObject):
+    key = 'https://plex.tv/devices/{clientId}/sync_items'
+    TAG = 'SyncList'
+
+    def _loadData(self, data):
+        self._data = data
+        self.clientId = data.attrib.get('clientIdentifier')
+        self.items = []
+
+        for elem in data:
+            if elem.tag == 'SyncItems':
+                for sync_item in elem:
+                    item = SyncItem(self._server, sync_item, clientIdentifier=self.clientId)
+                    self.items.append(item)
+
+
+class Status(PlexObject):
+    TAG = 'Status'
+
+    def _loadData(self, data):
+        self._data = data
+        self.failureCode = data.attrib.get('failureCode')
+        self.failure = data.attrib.get('failure')
+        self.state = data.attrib.get('state')
+        self.itemsCount = plexapi.utils.cast(int, data.attrib.get('itemsCount'))
+        self.itemsCompleteCount = plexapi.utils.cast(int, data.attrib.get('itemsCompleteCount'))
+        self.totalSize = plexapi.utils.cast(int, data.attrib.get('totalSize'))
+        self.itemsDownloadedCount = plexapi.utils.cast(int, data.attrib.get('itemsDownloadedCount'))
+        self.itemsReadyCount = plexapi.utils.cast(int, data.attrib.get('itemsReadyCount'))
+        self.itemsSuccessfulCount = plexapi.utils.cast(int, data.attrib.get('itemsSuccessfulCount'))
+
+    def __repr__(self):
+        return str(dict(
+            itemsCount=self.itemsCount,
+            itemsCompleteCount=self.itemsCompleteCount,
+            itemsDownloadedCount=self.itemsDownloadedCount,
+            itemsReadyCount=self.itemsReadyCount,
+            itemsSuccessfulCount=self.itemsSuccessfulCount
+        ))

plexapi/utils.py

@@ -7,7 +7,7 @@
 import zipfile
 from datetime import datetime
 from getpass import getpass
-from threading import Thread
+import threading
 from tqdm import tqdm
 from plexapi import compat
 from plexapi.exceptions import NotFound
@@ -152,15 +152,18 @@ def threaded(callback, listargs):
             listargs (list): List of lists; \*args to pass each thread.
     """
     threads, results = [], []
+    connected_event = threading.Event()
     for args in listargs:
         args += [results, len(results)]
         results.append(None)
-        threads.append(Thread(target=callback, args=args))
+        threads.append(threading.Thread(target=callback, args=args, kwargs=dict(connected_event=connected_event)))
         threads[-1].setDaemon(True)
         threads[-1].start()
-    for thread in threads:
-        thread.join()
-    return results
+    while not connected_event.is_set():
+        if all([not t.is_alive() for t in threads]):
+            break
+        time.sleep(0.05)
+    return list(filter(lambda r: r is not None, results))
 
 
 def toDatetime(value, format=None):