Run ruff format

Author: sderev

youtube_transcript_api/_cli.py

@@ -65,14 +65,10 @@ def run(self) -> str:
         print_sections = [str(exception) for exception in exceptions]
         if transcripts:
             if parsed_args.list_transcripts:
-                print_sections.extend(
-                    str(transcript_list) for transcript_list in transcripts
-                )
+                print_sections.extend(str(transcript_list) for transcript_list in transcripts)
             else:
                 print_sections.append(
-                    FormatterLoader()
-                    .load(parsed_args.format)
-                    .format_transcripts(transcripts)
+                    FormatterLoader().load(parsed_args.format).format_transcripts(transcripts)
                 )
 
         return "\n\n".join(print_sections)
@@ -83,13 +79,9 @@ def _fetch_transcript(
         transcript_list: TranscriptList,
     ) -> FetchedTranscript:
         if parsed_args.exclude_manually_created:
-            transcript = transcript_list.find_generated_transcript(
-                parsed_args.languages
-            )
+            transcript = transcript_list.find_generated_transcript(parsed_args.languages)
         elif parsed_args.exclude_generated:
-            transcript = transcript_list.find_manually_created_transcript(
-                parsed_args.languages
-            )
+            transcript = transcript_list.find_manually_created_transcript(parsed_args.languages)
         else:
             transcript = transcript_list.find_transcript(parsed_args.languages)
 
@@ -116,9 +108,7 @@ def _parse_args(self):
             default=False,
             help="This will list the languages in which the given videos are available in.",
         )
-        parser.add_argument(
-            "video_ids", nargs="+", type=str, help="List of YouTube video IDs."
-        )
+        parser.add_argument("video_ids", nargs="+", type=str, help="List of YouTube video IDs.")
         parser.add_argument(
             "--languages",
             nargs="*",

youtube_transcript_api/_errors.py

@@ -26,9 +26,7 @@ class CookieInvalid(CookieError):
     def __init__(
         self, cookie_path: Path
     ):  # pragma: no cover until cookie authentication is re-implemented
-        super().__init__(
-            f"The cookies provided are not valid (may have expired): {cookie_path}"
-        )
+        super().__init__(f"The cookies provided are not valid (may have expired): {cookie_path}")
 
 
 class CouldNotRetrieveTranscript(YouTubeTranscriptApiException):
@@ -59,9 +57,7 @@ def _build_error_message(self) -> str:
 
         cause = self.cause
         if cause:
-            error_message += (
-                self.CAUSE_MESSAGE_INTRO.format(cause=cause) + self.GITHUB_REFERRAL
-            )
+            error_message += self.CAUSE_MESSAGE_INTRO.format(cause=cause) + self.GITHUB_REFERRAL
 
         return error_message
 
@@ -107,9 +103,7 @@ def __init__(self, video_id: str, reason: Optional[str], sub_reasons: List[str])
     def cause(self):
         reason = "No reason specified!" if self.reason is None else self.reason
         if self.sub_reasons:
-            sub_reasons = "\n".join(
-                f" - {sub_reason}" for sub_reason in self.sub_reasons
-            )
+            sub_reasons = "\n".join(f" - {sub_reason}" for sub_reason in self.sub_reasons)
             reason = f"{reason}{self.SUBREASON_MESSAGE.format(sub_reasons=sub_reasons)}"
         return self.CAUSE_MESSAGE.format(
             reason=reason,
@@ -183,9 +177,7 @@ def __init__(self, video_id: str):
         self._proxy_config = None
         super().__init__(video_id)
 
-    def with_proxy_config(
-        self, proxy_config: Optional[ProxyConfig]
-    ) -> "RequestBlocked":
+    def with_proxy_config(self, proxy_config: Optional[ProxyConfig]) -> "RequestBlocked":
         self._proxy_config = proxy_config
         return self
 

youtube_transcript_api/_transcripts.py

@@ -167,9 +167,7 @@ def translate(self, language_code: str) -> "Transcript":
         return Transcript(
             self._http_client,
             self.video_id,
-            "{url}&tlang={language_code}".format(
-                url=self._url, language_code=language_code
-            ),
+            "{url}&tlang={language_code}".format(url=self._url, language_code=language_code),
             self._translation_languages_dict[language_code],
             language_code,
             True,
@@ -204,9 +202,7 @@ def __init__(
         self._translation_languages = translation_languages
 
     @staticmethod
-    def build(
-        http_client: Session, video_id: str, captions_json: Dict
-    ) -> "TranscriptList":
+    def build(http_client: Session, video_id: str, captions_json: Dict) -> "TranscriptList":
         """
         Factory method for TranscriptList.
 
@@ -282,9 +278,7 @@ def find_generated_transcript(self, language_codes: Iterable[str]) -> Transcript
         """
         return self._find_transcript(language_codes, [self._generated_transcripts])
 
-    def find_manually_created_transcript(
-        self, language_codes: Iterable[str]
-    ) -> Transcript:
+    def find_manually_created_transcript(self, language_codes: Iterable[str]) -> Transcript:
         """
         Finds a manually created transcript for a given language code.
 
@@ -293,9 +287,7 @@ def find_manually_created_transcript(
         it fails to do so.
         :return: the found Transcript
         """
-        return self._find_transcript(
-            language_codes, [self._manually_created_transcripts]
-        )
+        return self._find_transcript(language_codes, [self._manually_created_transcripts])
 
     def _find_transcript(
         self,
@@ -321,8 +313,7 @@ def __str__(self) -> str:
         ).format(
             video_id=self.video_id,
             available_manually_created_transcript_languages=self._get_language_description(
-                str(transcript)
-                for transcript in self._manually_created_transcripts.values()
+                str(transcript) for transcript in self._manually_created_transcripts.values()
             ),
             available_generated_transcripts=self._get_language_description(
                 str(transcript) for transcript in self._generated_transcripts.values()
@@ -338,8 +329,7 @@ def __str__(self) -> str:
 
     def _get_language_description(self, transcript_strings: Iterable[str]) -> str:
         description = "\n".join(
-            " - {transcript}".format(transcript=transcript)
-            for transcript in transcript_strings
+            " - {transcript}".format(transcript=transcript) for transcript in transcript_strings
         )
         return description if description else "None"
 
@@ -363,11 +353,7 @@ def _fetch_captions_json(self, video_id: str, try_number: int = 0) -> Dict:
             innertube_data = self._fetch_innertube_data(video_id, api_key)
             return self._extract_captions_json(innertube_data, video_id)
         except RequestBlocked as exception:
-            retries = (
-                0
-                if self._proxy_config is None
-                else self._proxy_config.retries_when_blocked
-            )
+            retries = 0 if self._proxy_config is None else self._proxy_config.retries_when_blocked
             if try_number + 1 < retries:
                 return self._fetch_captions_json(video_id, try_number=try_number + 1)
             raise exception.with_proxy_config(self._proxy_config)
@@ -384,20 +370,15 @@ def _extract_innertube_api_key(self, html: str, video_id: str) -> str:
     def _extract_captions_json(self, innertube_data: Dict, video_id: str) -> Dict:
         self._assert_playability(innertube_data.get("playabilityStatus"), video_id)
 
-        captions_json = innertube_data.get("captions", {}).get(
-            "playerCaptionsTracklistRenderer"
-        )
+        captions_json = innertube_data.get("captions", {}).get("playerCaptionsTracklistRenderer")
         if captions_json is None or "captionTracks" not in captions_json:
             raise TranscriptsDisabled(video_id)
 
         return captions_json
 
     def _assert_playability(self, playability_status_data: Dict, video_id: str) -> None:
         playability_status = playability_status_data.get("status")
-        if (
-            playability_status != _PlayabilityStatus.OK.value
-            and playability_status is not None
-        ):
+        if playability_status != _PlayabilityStatus.OK.value and playability_status is not None:
             reason = playability_status_data.get("reason")
             if playability_status == _PlayabilityStatus.LOGIN_REQUIRED.value:
                 if reason == _PlayabilityFailedReason.BOT_DETECTED.value:
@@ -417,17 +398,13 @@ def _assert_playability(self, playability_status_data: Dict, video_id: str) -> N
                 .get("subreason", {})
                 .get("runs", [])
             )
-            raise VideoUnplayable(
-                video_id, reason, [run.get("text", "") for run in subreasons]
-            )
+            raise VideoUnplayable(video_id, reason, [run.get("text", "") for run in subreasons])
 
     def _create_consent_cookie(self, html: str, video_id: str) -> None:
         match = re.search('name="v" value="(.*?)"', html)
         if match is None:
             raise FailedToCreateConsentCookie(video_id)
-        self._http_client.cookies.set(
-            "CONSENT", "YES+" + match.group(1), domain=".youtube.com"
-        )
+        self._http_client.cookies.set("CONSENT", "YES+" + match.group(1), domain=".youtube.com")
 
     def _fetch_video_html(self, video_id: str) -> str:
         html = self._fetch_html(video_id)

youtube_transcript_api/formatters.py

@@ -16,14 +16,12 @@ class Formatter:
 
     def format_transcript(self, transcript: FetchedTranscript, **kwargs) -> str:
         raise NotImplementedError(
-            "A subclass of Formatter must implement "
-            "their own .format_transcript() method."
+            "A subclass of Formatter must implement their own .format_transcript() method."
         )
 
     def format_transcripts(self, transcripts: List[FetchedTranscript], **kwargs):
         raise NotImplementedError(
-            "A subclass of Formatter must implement "
-            "their own .format_transcripts() method."
+            "A subclass of Formatter must implement their own .format_transcripts() method."
         )
 
 
@@ -42,9 +40,7 @@ def format_transcripts(self, transcripts: List[FetchedTranscript], **kwargs) ->
         :param transcripts:
         :return: A JSON string representation of the transcript.
         """
-        return pprint.pformat(
-            [transcript.to_raw_data() for transcript in transcripts], **kwargs
-        )
+        return pprint.pformat([transcript.to_raw_data() for transcript in transcripts], **kwargs)
 
 
 class JSONFormatter(Formatter):
@@ -62,9 +58,7 @@ def format_transcripts(self, transcripts: List[FetchedTranscript], **kwargs) ->
         :param transcripts:
         :return: A JSON string representation of the transcript.
         """
-        return json.dumps(
-            [transcript.to_raw_data() for transcript in transcripts], **kwargs
-        )
+        return json.dumps([transcript.to_raw_data() for transcript in transcripts], **kwargs)
 
 
 class TextFormatter(Formatter):
@@ -90,8 +84,7 @@ def format_transcripts(self, transcripts: List[FetchedTranscript], **kwargs) ->
 class _TextBasedFormatter(TextFormatter):
     def _format_timestamp(self, hours: int, mins: int, secs: int, ms: int) -> str:
         raise NotImplementedError(
-            "A subclass of _TextBasedFormatter must implement "
-            "their own .format_timestamp() method."
+            "A subclass of _TextBasedFormatter must implement their own .format_timestamp() method."
         )
 
     def _format_transcript_header(self, lines: Iterable[str]) -> str:

youtube_transcript_api/proxies.py

@@ -75,8 +75,7 @@ def __init__(self, http_url: Optional[str] = None, https_url: Optional[str] = No
         """
         if not http_url and not https_url:
             raise InvalidProxyConfig(
-                "GenericProxyConfig requires you to define at least one of the two: "
-                "http or https"
+                "GenericProxyConfig requires you to define at least one of the two: http or https"
             )
         self.http_url = http_url
         self.https_url = https_url

youtube_transcript_api/test/test_api.py

@@ -33,9 +33,7 @@
 
 def get_asset_path(filename: str) -> Path:
     return Path(
-        "{dirname}/assets/{filename}".format(
-            dirname=os.path.dirname(__file__), filename=filename
-        )
+        "{dirname}/assets/{filename}".format(dirname=os.path.dirname(__file__), filename=filename)
     )
 
 
@@ -100,9 +98,7 @@ def test_fetch(self):
         )
 
     def test_fetch_formatted(self):
-        transcript = YouTubeTranscriptApi().fetch(
-            "GJLlxj_dtq8", preserve_formatting=True
-        )
+        transcript = YouTubeTranscriptApi().fetch("GJLlxj_dtq8", preserve_formatting=True)
 
         self.ref_transcript[1].text = "this is <i>not</i> the original transcript"
 
@@ -130,9 +126,7 @@ def test_list(self):
 
         language_codes = {transcript.language_code for transcript in transcript_list}
 
-        self.assertEqual(
-            language_codes, {"zh", "de", "en", "hi", "ja", "ko", "es", "cs", "en"}
-        )
+        self.assertEqual(language_codes, {"zh", "de", "en", "hi", "ja", "ko", "es", "cs", "en"})
 
     def test_list__find_manually_created(self):
         transcript_list = YouTubeTranscriptApi().list("GJLlxj_dtq8")
@@ -158,9 +152,7 @@ def test_list__url_as_video_id(self):
         )
 
         with self.assertRaises(InvalidVideoId):
-            YouTubeTranscriptApi().list(
-                "https://www.youtube.com/youtubei/v1/player?v=GJLlxj_dtq8"
-            )
+            YouTubeTranscriptApi().list("https://www.youtube.com/youtubei/v1/player?v=GJLlxj_dtq8")
 
     def test_translate_transcript(self):
         transcript = YouTubeTranscriptApi().list("GJLlxj_dtq8").find_transcript(["en"])
@@ -215,9 +207,7 @@ def test_fetch__create_consent_cookie_if_needed(self):
         YouTubeTranscriptApi().fetch("F1xioXWb8CY")
         self.assertEqual(len(httpretty.latest_requests()), 4)
         for request in httpretty.latest_requests()[1:]:
-            self.assertEqual(
-                request.headers["cookie"], "CONSENT=YES+cb.20210328-17-p0.de+FX+119"
-            )
+            self.assertEqual(request.headers["cookie"], "CONSENT=YES+cb.20210328-17-p0.de+FX+119")
 
     def test_fetch__exception_if_create_consent_cookie_failed(self):
         for _ in range(2):
@@ -370,9 +360,7 @@ def test_fetch__with_proxy(self, to_requests_dict):
             http_url="http://localhost:8080",
             https_url="http://localhost:8080",
         )
-        transcript = YouTubeTranscriptApi(proxy_config=proxy_config).fetch(
-            "GJLlxj_dtq8"
-        )
+        transcript = YouTubeTranscriptApi(proxy_config=proxy_config).fetch("GJLlxj_dtq8")
         self.assertEqual(
             transcript,
             self.ref_transcript,
@@ -381,9 +369,7 @@ def test_fetch__with_proxy(self, to_requests_dict):
 
     @patch("youtube_transcript_api.proxies.GenericProxyConfig.to_requests_dict")
     def test_fetch__with_proxy_prevent_alive_connections(self, to_requests_dict):
-        proxy_config = WebshareProxyConfig(
-            proxy_username="username", proxy_password="password"
-        )
+        proxy_config = WebshareProxyConfig(proxy_username="username", proxy_password="password")
 
         YouTubeTranscriptApi(proxy_config=proxy_config).fetch("GJLlxj_dtq8")