replace .format calls with f-strings

pytube/captions.py

@@ -49,7 +49,7 @@ class Caption:
         """
         fraction, whole = math.modf(d)
         time_fmt = time.strftime("%H:%M:%S,", time.gmtime(whole))
-        ms = "{:.3f}".format(fraction).replace("0.", "")
+        ms = f"{fraction:.3f}".replace("0.", "")
         return time_fmt + ms
 
     def xml_caption_to_srt(self, xml_captions: str) -> str:
@@ -113,13 +113,11 @@ class Caption:
             filename = title
 
         if filename_prefix:
-            filename = "{prefix}{filename}".format(
-                prefix=safe_filename(filename_prefix), filename=filename,
-            )
+            filename = f"{safe_filename(filename_prefix)}{filename}"
 
         filename = safe_filename(filename)
 
-        filename += " ({})".format(self.code)
+        filename += f" ({self.code})"
 
         if srt:
             filename += ".srt"

pytube/cipher.py

@@ -54,9 +54,7 @@ def get_initial_function_name(js: str) -> str:
         regex = re.compile(pattern)
         results = regex.search(js)
         if results:
-            logger.debug(
-                "finished regex search, matched: {pattern}".format(pattern=pattern)
-            )
+            logger.debug(f"finished regex search, matched: {pattern}")
             return results.group(1)
 
     raise RegexMatchError(caller="get_initial_function_name", pattern="multiple")

pytube/cli.py

@@ -130,9 +130,7 @@ def build_playback_report(youtube: YouTube) -> None:
         A YouTube object.
     """
     ts = int(dt.datetime.utcnow().timestamp())
-    fp = os.path.join(
-        os.getcwd(), "yt-video-{yt.video_id}-{ts}.json.gz".format(yt=youtube, ts=ts),
-    )
+    fp = os.path.join(os.getcwd(), f"yt-video-{youtube.video_id}-{ts}.json.gz")
 
     js = youtube.js
     watch_html = youtube.watch_html
@@ -179,9 +177,7 @@ def display_progress_bar(
     remaining = max_width - filled
     progress_bar = ch * filled + " " * remaining
     percent = round(100.0 * bytes_received / float(filesize), 1)
-    text = " ↳ |{progress_bar}| {percent}%\r".format(
-        progress_bar=progress_bar, percent=percent
-    )
+    text = f" ↳ |{progress_bar}| {percent}%\r"
     sys.stdout.write(text)
     sys.stdout.flush()
 
@@ -197,7 +193,7 @@ def on_progress(
 
 def _download(stream: Stream, target: Optional[str] = None) -> None:
     filesize_megabytes = stream.filesize // 1048576
-    print("{fn} | {fs} bytes".format(fn=stream.default_filename, fs=filesize_megabytes))
+    print(f"{stream.default_filename} | {filesize_megabytes} MB")
     stream.download(output_path=target)
     sys.stdout.write("\n")
 
@@ -214,7 +210,7 @@ def download_by_itag(youtube: YouTube, itag: int, target: Optional[str] = None)
     """
     stream = youtube.streams.get_by_itag(itag)
     if stream is None:
-        print("Could not find a stream with itag: {itag}".format(itag=itag))
+        print(f"Could not find a stream with itag: {itag}")
         print("Try one of these:")
         display_streams(youtube)
         sys.exit()
@@ -242,11 +238,7 @@ def download_by_resolution(
     # TODO(nficano): allow dash itags to be selected
     stream = youtube.streams.get_by_resolution(resolution)
     if stream is None:
-        print(
-            "Could not find a stream with resolution: {resolution}".format(
-                resolution=resolution
-            )
-        )
+        print(f"Could not find a stream with resolution: {resolution}")
         print("Try one of these:")
         display_streams(youtube)
         sys.exit()
@@ -271,11 +263,7 @@ def display_streams(youtube: YouTube) -> None:
 
 
 def _print_available_captions(captions: CaptionQuery) -> None:
-    print(
-        "Available caption codes are: {}".format(
-            ", ".join(c.code for c in captions.all())
-        )
-    )
+    print(f"Available caption codes are: {', '.join(c.code for c in captions.all())}")
 
 
 def download_caption(
@@ -299,9 +287,9 @@ def download_caption(
     caption = youtube.captions.get_by_language_code(lang_code=lang_code)
     if caption:
         downloaded_path = caption.download(title=youtube.title, output_path=target)
-        print("Saved caption file to: {}".format(downloaded_path))
+        print(f"Saved caption file to: {downloaded_path}")
     else:
-        print("Unable to find caption with code: {}".format(lang_code))
+        print(f"Unable to find caption with code: {lang_code}")
         _print_available_captions(youtube.captions)
 
 

pytube/exceptions.py

@@ -26,11 +26,7 @@ class RegexMatchError(ExtractError):
         :param str pattern:
             Pattern that failed to match
         """
-        super().__init__(
-            "{caller}: could not find match for {pattern}".format(
-                caller=caller, pattern=pattern
-            )
-        )
+        super().__init__(f"{caller}: could not find match for {pattern}")
         self.caller = caller
         self.pattern = pattern
 
@@ -47,7 +43,7 @@ class VideoUnavailable(PytubeError):
         :param str video_id:
             A YouTube video identifier.
         """
-        super().__init__("{video_id} is unavailable".format(video_id=video_id))
+        super().__init__(f"{video_id} is unavailable")
 
         self.video_id = video_id
 

pytube/extract.py

@@ -33,7 +33,7 @@ class PytubeHTMLParser(HTMLParser):
 
     def handle_data(self, data):
         if self.in_vid_descr_br:
-            self.vid_descr += "\n{}".format(data)
+            self.vid_descr += f"\n{data}"
             self.in_vid_descr_br = False
         elif self.in_vid_descr:
             self.vid_descr += data
@@ -89,11 +89,11 @@ def watch_url(video_id: str) -> str:
 
 
 def embed_url(video_id: str) -> str:
-    return "https://www.youtube.com/embed/{}".format(video_id)
+    return f"https://www.youtube.com/embed/{video_id}"
 
 
 def eurl(video_id: str) -> str:
-    return "https://youtube.googleapis.com/v/{}".format(video_id)
+    return f"https://youtube.googleapis.com/v/{video_id}"
 
 
 def video_info_url(

pytube/mixins.py

@@ -100,10 +100,10 @@ def apply_descrambler(stream_data: Dict, key: str) -> None:
         try:
             stream_data[key] = [
                 {
-                    u"url": format_item[u"url"],
-                    u"type": format_item[u"mimeType"],
-                    u"quality": format_item[u"quality"],
-                    u"itag": format_item[u"itag"],
+                    "url": format_item["url"],
+                    "type": format_item["mimeType"],
+                    "quality": format_item["quality"],
+                    "itag": format_item["itag"],
                 }
                 for format_item in formats
             ]
@@ -113,11 +113,11 @@ def apply_descrambler(stream_data: Dict, key: str) -> None:
             ]
             stream_data[key] = [
                 {
-                    u"url": cipher_url[i][u"url"][0],
-                    u"s": cipher_url[i][u"s"][0],
-                    u"type": format_item[u"mimeType"],
-                    u"quality": format_item[u"quality"],
-                    u"itag": format_item[u"itag"],
+                    "url": cipher_url[i]["url"][0],
+                    "s": cipher_url[i]["s"][0],
+                    "type": format_item["mimeType"],
+                    "quality": format_item["quality"],
+                    "itag": format_item["itag"],
                 }
                 for i, format_item in enumerate(formats)
             ]

pytube/monostate.py

@@ -13,44 +13,42 @@ class OnProgress(Protocol):
         file_handler: io.BufferedWriter,
         bytes_remaining: int,
     ) -> None:
+        """On download progress callback function.
+
+        :param stream:
+            An instance of :class:`Stream <Stream>` being downloaded.
+        :type stream:
+            :py:class:`pytube.Stream`
+        :param str chunk:
+            Segment of media file binary data, not yet written to disk.
+        :param file_handler:
+            The file handle where the media is being written to.
+        :type file_handler:
+            :py:class:`io.BufferedWriter`
+        :param int bytes_remaining:
+            How many bytes have been downloaded.
+
+        """
         ...
 
-    """On download progress callback function.
-
-    :param stream:
-        An instance of :class:`Stream <Stream>` being downloaded.
-    :type stream:
-        :py:class:`pytube.Stream`
-    :param str chunk:
-        Segment of media file binary data, not yet written to disk.
-    :param file_handler:
-        The file handle where the media is being written to.
-    :type file_handler:
-        :py:class:`io.BufferedWriter`
-    :param int bytes_remaining:
-        How many bytes have been downloaded.
-
-    """
-
 
 class OnComplete(Protocol):
     def __call__(self, stream: Any, file_handler: io.BufferedWriter) -> None:
+        """On download complete handler function.
+
+        :param stream:
+            An instance of :class:`Stream <Stream>` being downloaded.
+        :type stream:
+            :py:class:`pytube.Stream`
+        :param file_handler:
+            The file handle where the media is being written to.
+        :type file_handler:
+            :py:class:`io.BufferedWriter`
+
+        :rtype: None
+        """
         ...
 
-    """On download complete handler function.
-
-    :param stream:
-        An instance of :class:`Stream <Stream>` being downloaded.
-    :type stream:
-        :py:class:`pytube.Stream`
-    :param file_handler:
-        The file handle where the media is being written to.
-    :type file_handler:
-        :py:class:`io.BufferedWriter`
-
-    :rtype: None
-    """
-
 
 class Monostate:
     def __init__(

pytube/streams.py

@@ -191,7 +191,7 @@ class Stream:
         """
 
         filename = safe_filename(self.title)
-        return "{filename}.{s.subtype}".format(filename=filename, s=self)
+        return f"{filename}.{self.subtype}"
 
     def download(
         self,
@@ -226,16 +226,12 @@ class Stream:
 
         """
         if filename:
-            filename = "{filename}.{s.subtype}".format(
-                filename=safe_filename(filename), s=self
-            )
+            filename = f"{safe_filename(filename)}.{self.subtype}"
         else:
             filename = self.default_filename
 
         if filename_prefix:
-            filename = "{prefix}{filename}".format(
-                prefix=safe_filename(filename_prefix), filename=filename,
-            )
+            filename = f"{safe_filename(filename_prefix)}{filename}"
 
         file_path = os.path.join(target_directory(output_path), filename)
 
@@ -351,4 +347,4 @@ class Stream:
         else:
             parts.extend(['abr="{s.abr}"', 'acodec="{s.audio_codec}"'])
         parts.extend(['progressive="{s.is_progressive}"', 'type="{s.type}"'])
-        return "<Stream: {parts}>".format(parts=" ".join(parts).format(s=self))
+        return f"<Stream: {' '.join(parts).format(s=self)}>"