Update PlexAPI to f-strings (#1000)

* Update plexapi to f-strings

* Update tests to f-strings

Author: JonnyWong16

plexapi/audio.py

@@ -120,7 +120,7 @@ def sync(self, bitrate, client=None, clientId=None, limit=None, title=None):
 
         section = self._server.library.sectionByID(self.librarySectionID)
 
-        sync_item.location = 'library://%s/item/%s' % (section.uuid, quote_plus(self.key))
+        sync_item.location = f'library://{section.uuid}/item/{quote_plus(self.key)}'
         sync_item.policy = Policy.create(limit)
         sync_item.mediaSettings = MediaSettings.createMusic(bitrate)
 
@@ -235,7 +235,7 @@ def download(self, savepath=None, keep_original_name=False, subfolders=False, **
 
     def station(self):
         """ Returns a :class:`~plexapi.playlist.Playlist` artist radio station or `None`. """
-        key = '%s?includeStations=1' % self.key
+        key = f'{self.key}?includeStations=1'
         return next(iter(self.fetchItems(key, cls=Playlist, rtag="Stations")), None)
 
 
@@ -356,7 +356,7 @@ def download(self, savepath=None, keep_original_name=False, **kwargs):
 
     def _defaultSyncTitle(self):
         """ Returns str, default title for a new syncItem. """
-        return '%s - %s' % (self.parentTitle, self.title)
+        return f'{self.parentTitle} - {self.title}'
 
 
 @utils.registerPlexObject
@@ -435,8 +435,7 @@ def _loadData(self, data):
 
     def _prettyfilename(self):
         """ Returns a filename for use in download. """
-        return '%s - %s - %s - %s' % (
-            self.grandparentTitle, self.parentTitle, str(self.trackNumber).zfill(2), self.title)
+        return f'{self.grandparentTitle} - {self.parentTitle} - {str(self.trackNumber).zfill(2)} - {self.title}'
 
     def album(self):
         """ Return the track's :class:`~plexapi.audio.Album`. """
@@ -463,7 +462,7 @@ def trackNumber(self):
 
     def _defaultSyncTitle(self):
         """ Returns str, default title for a new syncItem. """
-        return '%s - %s - %s' % (self.grandparentTitle, self.parentTitle, self.title)
+        return f'{self.grandparentTitle} - {self.parentTitle} - {self.title}'
 
     def _getWebURL(self, base=None):
         """ Get the Plex Web URL with the correct parameters. """

plexapi/base.py

@@ -59,7 +59,7 @@ def __init__(self, server, data, initpath=None, parent=None):
     def __repr__(self):
         uid = self._clean(self.firstAttr('_baseurl', 'ratingKey', 'id', 'key', 'playQueueID', 'uri'))
         name = self._clean(self.firstAttr('title', 'name', 'username', 'product', 'tag', 'value'))
-        return '<%s>' % ':'.join([p for p in [self.__class__.__name__, uid, name] if p])
+        return f"<{':'.join([p for p in [self.__class__.__name__, uid, name] if p])}>"
 
     def __setattr__(self, attr, value):
         overwriteNone = self.__dict__.get('_overwriteNone')
@@ -84,14 +84,14 @@ def _buildItem(self, elem, cls=None, initpath=None):
             return cls(self._server, elem, initpath, parent=self)
         # cls is not specified, try looking it up in PLEXOBJECTS
         etype = elem.attrib.get('streamType', elem.attrib.get('tagType', elem.attrib.get('type')))
-        ehash = '%s.%s' % (elem.tag, etype) if etype else elem.tag
+        ehash = f'{elem.tag}.{etype}' if etype else elem.tag
         if initpath == '/status/sessions':
-            ehash = '%s.%s' % (ehash, 'session')
+            ehash = f"{ehash}.{'session'}"
         ecls = utils.PLEXOBJECTS.get(ehash, utils.PLEXOBJECTS.get(elem.tag))
         # log.debug('Building %s as %s', elem.tag, ecls.__name__)
         if ecls is not None:
             return ecls(self._server, elem, initpath)
-        raise UnknownType("Unknown library type <%s type='%s'../>" % (elem.tag, etype))
+        raise UnknownType(f"Unknown library type <{elem.tag} type='{etype}'../>")
 
     def _buildItemOrNone(self, elem, cls=None, initpath=None):
         """ Calls :func:`~plexapi.base.PlexObject._buildItem` but returns
@@ -167,7 +167,7 @@ def fetchItem(self, ekey, cls=None, **kwargs):
         if ekey is None:
             raise BadRequest('ekey was not provided')
         if isinstance(ekey, int):
-            ekey = '/library/metadata/%s' % ekey
+            ekey = f'/library/metadata/{ekey}'
 
         data = self._server.query(ekey)
         item = self.findItem(data, cls, ekey, **kwargs)
@@ -179,7 +179,7 @@ def fetchItem(self, ekey, cls=None, **kwargs):
             return item
 
         clsname = cls.__name__ if cls else 'None'
-        raise NotFound('Unable to find elem: cls=%s, attrs=%s' % (clsname, kwargs))
+        raise NotFound(f'Unable to find elem: cls={clsname}, attrs={kwargs}')
 
     def fetchItems(self, ekey, cls=None, container_start=None, container_size=None, **kwargs):
         """ Load the specified key to find and build all items with the specified tag
@@ -328,7 +328,7 @@ def listAttrs(self, data, attr, rtag=None, **kwargs):
         if rtag:
             data = next(utils.iterXMLBFS(data, rtag), [])
         for elem in data:
-            kwargs['%s__exists' % attr] = True
+            kwargs[f'{attr}__exists'] = True
             if self._checkAttrs(elem, **kwargs):
                 results.append(elem.attrib.get(attr))
         return results
@@ -399,7 +399,7 @@ def _checkAttrs(self, elem, **kwargs):
 
     def _getAttrOperator(self, attr):
         for op, operator in OPERATORS.items():
-            if attr.endswith('__%s' % op):
+            if attr.endswith(f'__{op}'):
                 attr = attr.rsplit('__', 1)[0]
                 return attr, op, operator
         # default to exact match
@@ -496,7 +496,7 @@ def __getattribute__(self, attr):
         # Log the reload.
         clsname = self.__class__.__name__
         title = self.__dict__.get('title', self.__dict__.get('name'))
-        objname = "%s '%s'" % (clsname, title) if title else clsname
+        objname = f"{clsname} '{title}'" if title else clsname
         log.debug("Reloading %s for attr '%s'", objname, attr)
         # Reload and return the value
         self._reload(_overwriteNone=False)
@@ -521,7 +521,7 @@ def analyze(self):
             * Generate intro video markers: Detects show intros, exposing the
                 'Skip Intro' button in clients.
         """
-        key = '/%s/analyze' % self.key.lstrip('/')
+        key = f"/{self.key.lstrip('/')}/analyze"
         self._server.query(key, method=self._server._session.put)
 
     def isFullObject(self):
@@ -547,8 +547,7 @@ def _edit(self, **kwargs):
         if 'type' not in kwargs:
             kwargs['type'] = utils.searchType(self._searchType)
 
-        part = '/library/sections/%s/all%s' % (self.librarySectionID,
-                                               utils.joinArgs(kwargs))
+        part = f'/library/sections/{self.librarySectionID}/all{utils.joinArgs(kwargs)}'
         self._server.query(part, method=self._server._session.put)
         return self
 
@@ -627,7 +626,7 @@ def refresh(self):
                 the refresh process is interrupted (the Server is turned off, internet
                 connection dies, etc).
         """
-        key = '%s/refresh' % self.key
+        key = f'{self.key}/refresh'
         self._server.query(key, method=self._server._session.put)
 
     def section(self):
@@ -700,7 +699,7 @@ def getStreamURL(self, **params):
                 :exc:`~plexapi.exceptions.Unsupported`: When the item doesn't support fetching a stream URL.
         """
         if self.TYPE not in ('movie', 'episode', 'track', 'clip'):
-            raise Unsupported('Fetching stream URL for %s is unsupported.' % self.TYPE)
+            raise Unsupported(f'Fetching stream URL for {self.TYPE} is unsupported.')
         mvb = params.get('maxVideoBitrate')
         vr = params.get('videoResolution', '')
         params = {
@@ -718,8 +717,10 @@ def getStreamURL(self, **params):
         streamtype = 'audio' if self.TYPE in ('track', 'album') else 'video'
         # sort the keys since the randomness fucks with my tests..
         sorted_params = sorted(params.items(), key=lambda val: val[0])
-        return self._server.url('/%s/:/transcode/universal/start.m3u8?%s' %
-            (streamtype, urlencode(sorted_params)), includeToken=True)
+        return self._server.url(
+            f'/{streamtype}/:/transcode/universal/start.m3u8?{urlencode(sorted_params)}',
+            includeToken=True
+        )
 
     def iterParts(self):
         """ Iterates over the parts of this media item. """
@@ -759,15 +760,15 @@ def download(self, savepath=None, keep_original_name=False, **kwargs):
 
         for part in parts:
             if not keep_original_name:
-                filename = utils.cleanFilename('%s.%s' % (self._prettyfilename(), part.container))
+                filename = utils.cleanFilename(f'{self._prettyfilename()}.{part.container}')
             else:
                 filename = part.file
 
             if kwargs:
                 # So this seems to be a a lot slower but allows transcode.
                 download_url = self.getStreamURL(**kwargs)
             else:
-                download_url = self._server.url('%s?download=1' % part.key)
+                download_url = self._server.url(f'{part.key}?download=1')
 
             filepath = utils.download(
                 download_url,
@@ -794,8 +795,7 @@ def updateProgress(self, time, state='stopped'):
                 time (int): milliseconds watched
                 state (string): state of the video, default 'stopped'
         """
-        key = '/:/progress?key=%s&identifier=com.plexapp.plugins.library&time=%d&state=%s' % (self.ratingKey,
-                                                                                              time, state)
+        key = f'/:/progress?key={self.ratingKey}&identifier=com.plexapp.plugins.library&time={time}&state={state}'
         self._server.query(key)
         self._reload(_overwriteNone=False)
 

plexapi/client.py

@@ -94,7 +94,7 @@ def connect(self, timeout=None):
         self._initpath = self.key
         data = self.query(self.key, timeout=timeout)
         if not data:
-            raise NotFound("Client not found at %s" % self._baseurl)
+            raise NotFound(f"Client not found at {self._baseurl}")
         if self._clientIdentifier:
             client = next(
                 (
@@ -106,8 +106,7 @@ def connect(self, timeout=None):
             )
             if client is None:
                 raise NotFound(
-                    "Client with identifier %s not found at %s"
-                    % (self._clientIdentifier, self._baseurl)
+                    f"Client with identifier {self._clientIdentifier} not found at {self._baseurl}"
                 )
         else:
             client = data[0]
@@ -186,7 +185,7 @@ def query(self, path, method=None, headers=None, timeout=None, **kwargs):
         if response.status_code not in (200, 201, 204):
             codename = codes.get(response.status_code)[0]
             errtext = response.text.replace('\n', ' ')
-            message = '(%s) %s; %s %s' % (response.status_code, codename, response.url, errtext)
+            message = f'({response.status_code}) {codename}; {response.url} {errtext}'
             if response.status_code == 401:
                 raise Unauthorized(message)
             elif response.status_code == 404:
@@ -213,8 +212,7 @@ def sendCommand(self, command, proxy=None, **params):
         controller = command.split('/')[0]
         headers = {'X-Plex-Target-Client-Identifier': self.machineIdentifier}
         if controller not in self.protocolCapabilities:
-            log.debug("Client %s doesn't support %s controller."
-                      "What your trying might not work" % (self.title, controller))
+            log.debug(f"Client {self.title} doesn't support {controller} controller. What your trying might not work")
 
         proxy = self._proxyThroughServer if proxy is None else proxy
         query = self._server.query if proxy else self.query
@@ -228,7 +226,7 @@ def sendCommand(self, command, proxy=None, **params):
             self.sendCommand(ClientTimeline.key, wait=0)
 
         params['commandID'] = self._nextCommandId()
-        key = '/player/%s%s' % (command, utils.joinArgs(params))
+        key = f'/player/{command}{utils.joinArgs(params)}'
 
         try:
             return query(key, headers=headers)
@@ -253,8 +251,8 @@ def url(self, key, includeToken=False):
             raise BadRequest('PlexClient object missing baseurl.')
         if self._token and (includeToken or self._showSecrets):
             delim = '&' if '?' in key else '?'
-            return '%s%s%sX-Plex-Token=%s' % (self._baseurl, key, delim, self._token)
-        return '%s%s' % (self._baseurl, key)
+            return f'{self._baseurl}{key}{delim}X-Plex-Token={self._token}'
+        return f'{self._baseurl}{key}'
 
     # ---------------------
     # Navigation Commands
@@ -517,7 +515,7 @@ def playMedia(self, media, offset=0, **params):
             'offset': offset,
             'key': media.key or playqueue.selectedItem.key,
             'type': mediatype,
-            'containerKey': '/playQueues/%s?window=100&own=1' % playqueue.playQueueID,
+            'containerKey': f'/playQueues/{playqueue.playQueueID}?window=100&own=1',
             **params,
         }
         token = media._server.createToken()