Merge pull request #49 from hbmartin/added-tests-cli

.flake8

@@ -1,5 +1,5 @@
 [flake8]
 ignore = E231,E203,W503,Q000,WPS111,WPS305,WPS348,WPS602,D400,DAR201,S101,DAR101,C812,D104,I001,WPS306,WPS214,D401,WPS229,WPS420,WPS230,WPS414,WPS114,WPS226,WPS442,C819,WPS601,T001,RST304,WPS410,WPS428,A003,A002,I003,WPS221,WPS326,WPS201,S405,DAR301,WPS210,WPS202,WPS213,WPS301,P103,WPS407,WPS432,WPS211,S314,S310,S001,IF100,PT001
-max-line-length = 89
+max-line-length = 95
 
 [isort]

pytube/cli.py

@@ -222,14 +222,12 @@ def _download(
     stream: Stream, target: Optional[str] = None, filename: Optional[str] = None
 ) -> None:
     filesize_megabytes = stream.filesize // 1048576
-    print(f"{stream.default_filename} | {filesize_megabytes} MB")
+    print(f"{filename or stream.default_filename} | {filesize_megabytes} MB")
     stream.download(output_path=target, filename=filename)
     sys.stdout.write("\n")
 
 
-def unique_name(
-    base: str, subtype: Optional[str], video_audio: str, target: str
-) -> str:
+def _unique_name(base: str, subtype: str, media_type: str, target: str) -> str:
     """
     Given a base name, the file format, and the target directory, will generate
     a filename unique for that directory and file format.
@@ -237,15 +235,17 @@ def unique_name(
         The given base-name.
     :param str subtype:
         The filetype of the video which will be downloaded.
+    :param str media_type:
+        The media_type of the file, ie. "audio" or "video"
     :param Path target:
         Target directory for download.
     """
     counter = 0
     while True:
-        name = f"{base}_{video_audio}_{counter}"
-        unique = os.path.join(target, f"{name}.{subtype}")
-        if not os.path.exists(unique):
-            return str(name)
+        file_name = f"{base}_{media_type}_{counter}"
+        file_path = os.path.join(target, f"{file_name}.{subtype}")
+        if not os.path.exists(file_path):
+            return file_name
         counter += 1
 
 
@@ -253,7 +253,7 @@ def ffmpeg_process(
     youtube: YouTube, resolution: str, target: Optional[str] = None
 ) -> None:
     """
-    Decides the correct video stream to download, then calls ffmpeg_downloader.
+    Decides the correct video stream to download, then calls _ffmpeg_downloader.
 
     :param YouTube youtube:
         A valid YouTube object.
@@ -263,91 +263,78 @@ def ffmpeg_process(
         Target directory for download
     """
     youtube.register_on_progress_callback(on_progress)
-    if target is None:
-        target = os.getcwd()
+    target = target or os.getcwd()
 
     if resolution == "best":
-        highest_quality = (
-            youtube.streams.filter(progressive=False)
-            .order_by("resolution")
-            .desc()
-            .first()
+        highest_quality_stream = (
+            youtube.streams.filter(progressive=False).order_by("resolution").last()
         )
-
-        video_stream = (
+        mp4_stream = (
             youtube.streams.filter(progressive=False, subtype="mp4")
             .order_by("resolution")
-            .desc()
-            .first()
+            .last()
         )
-
-        if highest_quality.resolution == video_stream.resolution:
-            ffmpeg_downloader(youtube=youtube, stream=video_stream, target=target)
+        if highest_quality_stream.resolution == mp4_stream.resolution:
+            video_stream = mp4_stream
         else:
-            ffmpeg_downloader(youtube=youtube, stream=highest_quality, target=target)
+            video_stream = highest_quality_stream
     else:
         video_stream = youtube.streams.filter(
             progressive=False, resolution=resolution, subtype="mp4"
         ).first()
-        if video_stream is not None:
-            ffmpeg_downloader(youtube=youtube, stream=video_stream, target=target)
-        else:
+        if not video_stream:
             video_stream = youtube.streams.filter(
                 progressive=False, resolution=resolution
             ).first()
-            if video_stream is None:
-                print(f"Could not find a stream with resolution: {resolution}")
-                print("Try one of these:")
-                display_streams(youtube)
-                sys.exit()
-            ffmpeg_downloader(youtube=youtube, stream=video_stream, target=target)
+    if video_stream is None:
+        print(f"Could not find a stream with resolution: {resolution}")
+        print("Try one of these:")
+        display_streams(youtube)
+        sys.exit()
+
+    audio_stream = youtube.streams.get_audio_only(video_stream.subtype)
+    if not audio_stream:
+        audio_stream = youtube.streams.filter(only_audio=True).order_by("abr").last()
+    if not audio_stream:
+        print("Could not find an audio only stream")
+        sys.exit()
+    _ffmpeg_downloader(
+        audio_stream=audio_stream, video_stream=video_stream, target=target
+    )
 
 
-def ffmpeg_downloader(youtube: YouTube, stream: Stream, target: str) -> None:
+def _ffmpeg_downloader(audio_stream: Stream, video_stream: Stream, target: str) -> None:
     """
     Given a YouTube Stream object, finds the correct audio stream, downloads them both
     giving them a unique name, them uses ffmpeg to create a new file with the audio
     and video from the previously downloaded files. Then deletes the original adaptive
     streams, leaving the combination.
 
-    :param YouTube youtube:
-        A valid YouTube object
-    :param Stream stream:
-        A valid Stream object
+    :param Stream audio_stream:
+        A valid Stream object representing the audio to download
+    :param Stream video_stream:
+        A valid Stream object representing the video to download
     :param Path target:
         A valid Path object
     """
-    audio_stream = (
-        youtube.streams.filter(only_audio=True, subtype=stream.subtype)
-        .order_by("abr")
-        .desc()
-        .first()
-    )
-
-    video_unique_name = unique_name(
-        safe_filename(stream.title), stream.subtype, "video", target=target
+    video_unique_name = _unique_name(
+        safe_filename(video_stream.title), video_stream.subtype, "video", target=target
     )
-    audio_unique_name = unique_name(
-        safe_filename(stream.title), stream.subtype, "audio", target=target
+    audio_unique_name = _unique_name(
+        safe_filename(video_stream.title), audio_stream.subtype, "audio", target=target
     )
-    _download(stream=stream, target=target, filename=video_unique_name)
+    _download(stream=video_stream, target=target, filename=video_unique_name)
+    print("Loading audio...")
     _download(stream=audio_stream, target=target, filename=audio_unique_name)
 
-    video_path = os.path.join(target, f"{video_unique_name}.{stream.subtype}")
-    audio_path = os.path.join(target, f"{audio_unique_name}.{stream.subtype}")
-    final_path = os.path.join(target, f"{safe_filename(stream.title)}.{stream.subtype}")
+    video_path = os.path.join(target, f"{video_unique_name}.{video_stream.subtype}")
+    audio_path = os.path.join(target, f"{audio_unique_name}.{audio_stream.subtype}")
+    final_path = os.path.join(
+        target, f"{safe_filename(video_stream.title)}.{video_stream.subtype}"
+    )
 
     subprocess.run(  # nosec
-        [
-            "ffmpeg",
-            "-i",
-            f"{video_path}",
-            "-i",
-            f"{audio_path}",
-            "-codec",
-            "copy",
-            f"{final_path}",
-        ]
+        ["ffmpeg", "-i", video_path, "-i", audio_path, "-codec", "copy", final_path,]
     )
     os.unlink(video_path)
     os.unlink(audio_path)
@@ -439,11 +426,11 @@ def download_caption(
         _print_available_captions(youtube.captions)
         return
 
-    caption = youtube.captions.get_by_language_code(lang_code=lang_code)
-    if caption:
+    try:
+        caption = youtube.captions[lang_code]
         downloaded_path = caption.download(title=youtube.title, output_path=target)
         print(f"Saved caption file to: {downloaded_path}")
-    else:
+    except KeyError:
         print(f"Unable to find caption with code: {lang_code}")
         _print_available_captions(youtube.captions)
 
@@ -463,10 +450,7 @@ def download_audio(
         Target directory for download
     """
     audio = (
-        youtube.streams.filter(only_audio=True, subtype=filetype)
-        .order_by("abr")
-        .desc()
-        .first()
+        youtube.streams.filter(only_audio=True, subtype=filetype).order_by("abr").last()
     )
 
     if audio is None:

pytube/query.py

@@ -369,7 +369,9 @@ class CaptionQuery(Mapping):
         self.lang_code_index = {c.code: c for c in captions}
 
     @deprecated("This object can be treated as a dictionary, i.e. captions['en']")
-    def get_by_language_code(self, lang_code: str) -> Optional[Caption]:
+    def get_by_language_code(
+        self, lang_code: str
+    ) -> Optional[Caption]:  # pragma: no cover
         """Get the :class:`Caption <Caption>` for a given ``lang_code``.
 
         :param str lang_code:
@@ -397,7 +399,7 @@ class CaptionQuery(Mapping):
         return len(self.lang_code_index)
 
     def __iter__(self):
-        return iter(self.lang_code_index)
+        return iter(self.lang_code_index.values())
 
     def __repr__(self) -> str:
         return f"{self.lang_code_index}"

tests/test_captions.py

@@ -26,7 +26,8 @@ def test_caption_query_sequence():
     assert caption_query["en"] == caption1
     assert caption_query["fr"] == caption2
     with pytest.raises(KeyError):
-        caption_query["nada"]
+        not_exists = caption_query["nada"]
+        assert not_exists is not None  # should never reach this
 
 
 def test_caption_query_get_by_language_code_when_exists():
@@ -37,7 +38,7 @@ def test_caption_query_get_by_language_code_when_exists():
         {"url": "url2", "name": {"simpleText": "name2"}, "languageCode": "fr"}
     )
     caption_query = CaptionQuery(captions=[caption1, caption2])
-    assert caption_query.get_by_language_code("en") == caption1
+    assert caption_query["en"] == caption1
 
 
 def test_caption_query_get_by_language_code_when_not_exists():
@@ -48,7 +49,9 @@ def test_caption_query_get_by_language_code_when_not_exists():
         {"url": "url2", "name": {"simpleText": "name2"}, "languageCode": "fr"}
     )
     caption_query = CaptionQuery(captions=[caption1, caption2])
-    assert caption_query.get_by_language_code("hello") is None
+    with pytest.raises(KeyError):
+        not_found = caption_query["hello"]
+        assert not_found is not None  # should never reach here
 
 
 @mock.patch("pytube.captions.Caption.generate_srt_captions")
@@ -118,3 +121,24 @@ def test_xml_captions(request_get):
         {"url": "url1", "name": {"simpleText": "name1"}, "languageCode": "en"}
     )
     assert caption.xml_captions == "test"
+
+
+@mock.patch("pytube.captions.request")
+def test_generate_srt_captions(request):
+    request.get.return_value = (
+        '<?xml version="1.0" encoding="utf-8" ?><transcript><text start="6.5" dur="1.7">['
+        'Herb, Software Engineer]\n本影片包含隱藏式字幕。</text><text start="8.3" dur="2.7">'
+        "如要啓動字幕，請按一下這裡的圖示。</text></transcript>"
+    )
+    caption = Caption(
+        {"url": "url1", "name": {"simpleText": "name1"}, "languageCode": "en"}
+    )
+    assert caption.generate_srt_captions() == (
+        "1\n"
+        "00:00:06,500 --> 00:00:08,200\n"
+        "[Herb, Software Engineer] 本影片包含隱藏式字幕。\n"
+        "\n"
+        "2\n"
+        "00:00:08,300 --> 00:00:11,000\n"
+        "如要啓動字幕，請按一下這裡的圖示。"
+    )

tests/test_cli.py

@@ -6,10 +6,20 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 from pytube import cli, StreamQuery, Caption, CaptionQuery
+from pytube.exceptions import PytubeError
 
 parse_args = cli._parse_args
 
 
+@mock.patch("pytube.cli._parse_args")
+def test_main_invalid_url(_parse_args):
+    parser = argparse.ArgumentParser()
+    args = parse_args(parser, ["crikey",],)
+    _parse_args.return_value = args
+    with pytest.raises(SystemExit):
+        cli.main()
+
+
 @mock.patch("pytube.cli.display_streams")
 @mock.patch("pytube.cli.YouTube")
 def test_download_when_itag_not_found(youtube, display_streams):
@@ -91,6 +101,22 @@ def test_download_caption_with_lang_not_found(youtube, print_available):
     print_available.assert_called_with(youtube.captions)
 
 
+def test_print_available_captions(capsys):
+    # Given
+    caption1 = Caption(
+        {"url": "url1", "name": {"simpleText": "name1"}, "languageCode": "en"}
+    )
+    caption2 = Caption(
+        {"url": "url2", "name": {"simpleText": "name2"}, "languageCode": "fr"}
+    )
+    query = CaptionQuery([caption1, caption2])
+    # When
+    cli._print_available_captions(query)
+    # Then
+    captured = capsys.readouterr()
+    assert captured.out == "Available caption codes are: en, fr\n"
+
+
 def test_display_progress_bar(capsys):
     cli.display_progress_bar(bytes_received=25, filesize=100, scale=0.55)
     out, _ = capsys.readouterr()
@@ -192,14 +218,46 @@ def test_download_by_resolution_flag(youtube, download_by_resolution):
     download_by_resolution.assert_called()
 
 
+@mock.patch("pytube.cli.YouTube")
 @mock.patch("pytube.cli.Playlist")
-def test_download_with_playlist(playlist):
+@mock.patch("pytube.cli._perform_args_on_youtube")
+def test_download_with_playlist(perform_args_on_youtube, playlist, youtube):
+    # Given
     cli.safe_filename = MagicMock(return_value="safe_title")
     parser = argparse.ArgumentParser()
     args = parse_args(parser, ["https://www.youtube.com/playlist?list=PLyn"])
     cli._parse_args = MagicMock(return_value=args)
+    videos = [youtube]
+    playlist_instance = playlist.return_value
+    playlist_instance.videos = videos
+    # When
     cli.main()
+    # Then
     playlist.assert_called()
+    perform_args_on_youtube.assert_called_with(youtube, args)
+
+
+@mock.patch("pytube.cli.YouTube")
+@mock.patch("pytube.cli.Playlist")
+@mock.patch("pytube.cli._perform_args_on_youtube")
+def test_download_with_playlist_video_error(
+    perform_args_on_youtube, playlist, youtube, capsys
+):
+    # Given
+    cli.safe_filename = MagicMock(return_value="safe_title")
+    parser = argparse.ArgumentParser()
+    args = parse_args(parser, ["https://www.youtube.com/playlist?list=PLyn"])
+    cli._parse_args = MagicMock(return_value=args)
+    videos = [youtube]
+    playlist_instance = playlist.return_value
+    playlist_instance.videos = videos
+    perform_args_on_youtube.side_effect = PytubeError()
+    # When
+    cli.main()
+    # Then
+    playlist.assert_called()
+    captured = capsys.readouterr()
+    assert "There was an error with video" in captured.out
 
 
 @mock.patch("pytube.cli.YouTube")
@@ -227,39 +285,191 @@ def test_download_by_resolution_not_exists(youtube, stream_query):
 
 
 @mock.patch("pytube.cli.YouTube")
-@mock.patch("pytube.cli.Stream")
-def test_ffmpeg_downloader(youtube, stream):
+@mock.patch("pytube.cli.ffmpeg_process")
+def test_perform_args_should_ffmpeg_process(ffmpeg_process, youtube):
+    # Given
     parser = argparse.ArgumentParser()
     args = parse_args(parser, ["http://youtube.com/watch?v=9bZkp7q19f0", "-f", "best"])
     cli._parse_args = MagicMock(return_value=args)
-    cli.safe_filename = MagicMock(return_value="PSY - GANGNAM STYLE(강남스타일) MV")
-    cli.subprocess.run = MagicMock()
-    cli.os.unlink = MagicMock()
-    cli.ffmpeg_downloader = MagicMock()
-    cli.main()
-    cli.ffmpeg_downloader.assert_called()
+    # When
+    cli._perform_args_on_youtube(youtube, args)
+    # Then
+    ffmpeg_process.assert_called_with(youtube=youtube, resolution="best", target=None)
+
+
+@mock.patch("pytube.cli.YouTube")
+@mock.patch("pytube.cli._ffmpeg_downloader")
+def test_ffmpeg_process_best_should_download(_ffmpeg_downloader, youtube):
+    # Given
+    target = "/target"
+    streams = MagicMock()
+    youtube.streams = streams
+    video_stream = MagicMock()
+    streams.filter.return_value.order_by.return_value.last.return_value = video_stream
+    audio_stream = MagicMock()
+    streams.get_audio_only.return_value = audio_stream
+    # When
+    cli.ffmpeg_process(youtube, "best", target)
+    # Then
+    _ffmpeg_downloader.assert_called_with(
+        audio_stream=audio_stream, video_stream=video_stream, target=target
+    )
+
+
+@mock.patch("pytube.cli.YouTube")
+@mock.patch("pytube.cli._ffmpeg_downloader")
+def test_ffmpeg_process_res_should_download(_ffmpeg_downloader, youtube):
+    # Given
+    target = "/target"
+    streams = MagicMock()
+    youtube.streams = streams
+    video_stream = MagicMock()
+    streams.filter.return_value.first.return_value = video_stream
+    audio_stream = MagicMock()
+    streams.get_audio_only.return_value = audio_stream
+    # When
+    cli.ffmpeg_process(youtube, "XYZp", target)
+    # Then
+    _ffmpeg_downloader.assert_called_with(
+        audio_stream=audio_stream, video_stream=video_stream, target=target
+    )
+
+
+@mock.patch("pytube.cli.YouTube")
+@mock.patch("pytube.cli._ffmpeg_downloader")
+def test_ffmpeg_process_res_none_should_not_download(_ffmpeg_downloader, youtube):
+    # Given
+    target = "/target"
+    streams = MagicMock()
+    youtube.streams = streams
+    streams.filter.return_value.first.return_value = None
+    audio_stream = MagicMock()
+    streams.get_audio_only.return_value = audio_stream
+    # When
+    with pytest.raises(SystemExit):
+        cli.ffmpeg_process(youtube, "XYZp", target)
+    # Then
+    _ffmpeg_downloader.assert_not_called()
+
+
+@mock.patch("pytube.cli.YouTube")
+@mock.patch("pytube.cli._ffmpeg_downloader")
+def test_ffmpeg_process_audio_none_should_fallback_download(
+    _ffmpeg_downloader, youtube
+):
+    # Given
+    target = "/target"
+    streams = MagicMock()
+    youtube.streams = streams
+    stream = MagicMock()
+    streams.filter.return_value.order_by.return_value.last.return_value = stream
+    streams.get_audio_only.return_value = None
+    # When
+    cli.ffmpeg_process(youtube, "best", target)
+    # Then
+    _ffmpeg_downloader.assert_called_with(
+        audio_stream=stream, video_stream=stream, target=target
+    )
+
+
+@mock.patch("pytube.cli.YouTube")
+@mock.patch("pytube.cli._ffmpeg_downloader")
+def test_ffmpeg_process_audio_fallback_none_should_exit(_ffmpeg_downloader, youtube):
+    # Given
+    target = "/target"
+    streams = MagicMock()
+    youtube.streams = streams
+    stream = MagicMock()
+    streams.filter.return_value.order_by.return_value.last.side_effect = [
+        stream,
+        stream,
+        None,
+    ]
+    streams.get_audio_only.return_value = None
+    # When
+    with pytest.raises(SystemExit):
+        cli.ffmpeg_process(youtube, "best", target)
+    # Then
+    _ffmpeg_downloader.assert_not_called()
+
+
+@mock.patch("pytube.cli.os.unlink", return_value=None)
+@mock.patch("pytube.cli.subprocess.run", return_value=None)
+@mock.patch("pytube.cli._download", return_value=None)
+@mock.patch("pytube.cli._unique_name", return_value=None)
+def test_ffmpeg_downloader(unique_name, download, run, unlink):
+    # Given
+    target = "target"
+    audio_stream = MagicMock()
+    video_stream = MagicMock()
+    video_stream.id = "video_id"
+    audio_stream.subtype = "audio_subtype"
+    video_stream.subtype = "video_subtype"
+    unique_name.side_effect = ["video_name", "audio_name"]
+
+    # When
+    cli._ffmpeg_downloader(
+        audio_stream=audio_stream, video_stream=video_stream, target=target
+    )
+    # Then
+    download.assert_called()
+    run.assert_called_with(
+        [
+            "ffmpeg",
+            "-i",
+            "target/video_name.video_subtype",
+            "-i",
+            "target/audio_name.audio_subtype",
+            "-codec",
+            "copy",
+            "target/safe_title.video_subtype",
+        ]
+    )
+    unlink.assert_called()
 
 
+@mock.patch("pytube.cli.download_audio")
 @mock.patch("pytube.cli.YouTube.__init__", return_value=None)
-def test_download_audio(youtube):
+def test_download_audio_args(youtube, download_audio):
+    # Given
     parser = argparse.ArgumentParser()
     args = parse_args(parser, ["http://youtube.com/watch?v=9bZkp7q19f0", "-a", "mp4"])
     cli._parse_args = MagicMock(return_value=args)
-    cli.download_audio = MagicMock()
+    # When
     cli.main()
+    # Then
     youtube.assert_called()
-    cli.download_audio.assert_called()
+    download_audio.assert_called()
 
 
-@mock.patch("pytube.cli.YouTube.__init__", return_value=None)
-def test_ffmpeg_process(youtube):
-    parser = argparse.ArgumentParser()
-    args = parse_args(parser, ["http://youtube.com/watch?v=9bZkp7q19f0", "-f", "2160p"])
-    cli._parse_args = MagicMock(return_value=args)
-    cli.ffmpeg_process = MagicMock()
-    cli.main()
-    youtube.assert_called()
-    cli.ffmpeg_process.assert_called()
+@mock.patch("pytube.cli._download")
+@mock.patch("pytube.cli.YouTube")
+def test_download_audio(youtube, download):
+    # Given
+    youtube_instance = youtube.return_value
+    audio_stream = MagicMock()
+    youtube_instance.streams.filter.return_value.order_by.return_value.last.return_value = (
+        audio_stream
+    )
+    # When
+    cli.download_audio(youtube_instance, "filetype", "target")
+    # Then
+    download.assert_called_with(audio_stream, target="target")
+
+
+@mock.patch("pytube.cli._download")
+@mock.patch("pytube.cli.YouTube")
+def test_download_audio_none(youtube, download):
+    # Given
+    youtube_instance = youtube.return_value
+    youtube_instance.streams.filter.return_value.order_by.return_value.last.return_value = (
+        None
+    )
+    # When
+    with pytest.raises(SystemExit):
+        cli.download_audio(youtube_instance, "filetype", "target")
+    # Then
+    download.assert_not_called()
 
 
 @mock.patch("pytube.cli.YouTube.__init__", return_value=None)
@@ -271,3 +481,14 @@ def test_perform_args_on_youtube(youtube):
     cli.main()
     youtube.assert_called()
     cli._perform_args_on_youtube.assert_called()
+
+
+@mock.patch("pytube.cli.os.path.exists", return_value=False)
+def test_unique_name(path_exists):
+    assert cli._unique_name("base", "subtype", "video", "target") == "base_video_0"
+
+
+@mock.patch("pytube.cli.os.path.exists")
+def test_unique_name_counter(path_exists):
+    path_exists.side_effect = [True, False]
+    assert cli._unique_name("base", "subtype", "video", "target") == "base_video_1"

tests/test_query.py

@@ -44,14 +44,14 @@ def test_get_last(cipher_signature):
     """Ensure :meth:`~pytube.StreamQuery.last` returns the expected
     :class:`Stream <Stream>`.
     """
-    assert cipher_signature.streams.last().itag == 251
+    assert cipher_signature.streams[-1].itag == 251
 
 
 def test_get_first(cipher_signature):
     """Ensure :meth:`~pytube.StreamQuery.first` returns the expected
     :class:`Stream <Stream>`.
     """
-    assert cipher_signature.streams.first().itag == 18
+    assert cipher_signature.streams[0].itag == 18
 
 
 def test_order_by(cipher_signature):
@@ -154,10 +154,10 @@ def test_sequence(cipher_signature):
 
 
 def test_otf(cipher_signature):
-    non_otf = cipher_signature.streams.otf().all()
+    non_otf = cipher_signature.streams.otf()
     assert len(non_otf) == 22
 
-    otf = cipher_signature.streams.otf(True).all()
+    otf = cipher_signature.streams.otf(True)
     assert len(otf) == 0
 
 

tests/test_streams.py

@@ -11,13 +11,13 @@ from pytube import Stream, streams
 def test_filesize(cipher_signature, mocker):
     mocker.patch.object(request, "head")
     request.head.return_value = {"content-length": "6796391"}
-    assert cipher_signature.streams.first().filesize == 6796391
+    assert cipher_signature.streams[0].filesize == 6796391
 
 
 def test_filesize_approx(cipher_signature, mocker):
     mocker.patch.object(request, "head")
     request.head.return_value = {"content-length": "123"}
-    stream = cipher_signature.streams.first()
+    stream = cipher_signature.streams[0]
     assert stream.filesize_approx == 22350604
     stream.bitrate = None
     assert stream.filesize_approx == 123
@@ -25,7 +25,7 @@ def test_filesize_approx(cipher_signature, mocker):
 
 def test_default_filename(cipher_signature):
     expected = "PSY - GANGNAM STYLE(강남스타일) MV.mp4"
-    stream = cipher_signature.streams.first()
+    stream = cipher_signature.streams[0]
     assert stream.default_filename == expected
 
 
@@ -103,7 +103,7 @@ def test_download(cipher_signature, mocker):
     mocker.patch.object(request, "stream")
     request.stream.return_value = iter([str(random.getrandbits(8 * 1024))])
     with mock.patch("pytube.streams.open", mock.mock_open(), create=True):
-        stream = cipher_signature.streams.first()
+        stream = cipher_signature.streams[0]
         stream.download()
 
 
@@ -114,7 +114,7 @@ def test_download_with_prefix(cipher_signature, mocker):
     request.stream.return_value = iter([str(random.getrandbits(8 * 1024))])
     streams.target_directory = MagicMock(return_value="/target")
     with mock.patch("pytube.streams.open", mock.mock_open(), create=True):
-        stream = cipher_signature.streams.first()
+        stream = cipher_signature.streams[0]
         file_path = stream.download(filename_prefix="prefix")
         assert file_path == "/target/prefixPSY - GANGNAM STYLE(강남스타일) MV.mp4"
 
@@ -126,7 +126,7 @@ def test_download_with_filename(cipher_signature, mocker):
     request.stream.return_value = iter([str(random.getrandbits(8 * 1024))])
     streams.target_directory = MagicMock(return_value="/target")
     with mock.patch("pytube.streams.open", mock.mock_open(), create=True):
-        stream = cipher_signature.streams.first()
+        stream = cipher_signature.streams[0]
         file_path = stream.download(filename="cool name bro")
         assert file_path == "/target/cool name bro.mp4"
 
@@ -139,7 +139,7 @@ def test_download_with_existing(cipher_signature, mocker):
     mocker.patch.object(os.path, "isfile")
     os.path.isfile.return_value = True
     with mock.patch("pytube.streams.open", mock.mock_open(), create=True):
-        stream = cipher_signature.streams.first()
+        stream = cipher_signature.streams[0]
         mocker.patch.object(os.path, "getsize")
         os.path.getsize.return_value = stream.filesize
         file_path = stream.download()
@@ -156,7 +156,7 @@ def test_download_with_existing_no_skip(cipher_signature, mocker):
     mocker.patch.object(os.path, "isfile")
     os.path.isfile.return_value = True
     with mock.patch("pytube.streams.open", mock.mock_open(), create=True):
-        stream = cipher_signature.streams.first()
+        stream = cipher_signature.streams[0]
         mocker.patch.object(os.path, "getsize")
         os.path.getsize.return_value = stream.filesize
         file_path = stream.download(skip_existing=False)
@@ -165,12 +165,12 @@ def test_download_with_existing_no_skip(cipher_signature, mocker):
 
 
 def test_progressive_streams_return_includes_audio_track(cipher_signature):
-    stream = cipher_signature.streams.filter(progressive=True).first()
+    stream = cipher_signature.streams.filter(progressive=True)[0]
     assert stream.includes_audio_track
 
 
 def test_progressive_streams_return_includes_video_track(cipher_signature):
-    stream = cipher_signature.streams.filter(progressive=True).first()
+    stream = cipher_signature.streams.filter(progressive=True)[0]
     assert stream.includes_video_track
 
 
@@ -184,7 +184,7 @@ def test_on_progress_hook(cipher_signature, mocker):
     request.stream.return_value = iter([str(random.getrandbits(8 * 1024))])
 
     with mock.patch("pytube.streams.open", mock.mock_open(), create=True):
-        stream = cipher_signature.streams.first()
+        stream = cipher_signature.streams[0]
         stream.download()
     assert callback_fn.called
     args, _ = callback_fn.call_args
@@ -203,7 +203,7 @@ def test_on_complete_hook(cipher_signature, mocker):
     request.stream.return_value = iter([str(random.getrandbits(8 * 1024))])
 
     with mock.patch("pytube.streams.open", mock.mock_open(), create=True):
-        stream = cipher_signature.streams.first()
+        stream = cipher_signature.streams[0]
         stream.download()
     assert callback_fn.called
 
@@ -233,7 +233,7 @@ def test_thumbnail_when_not_in_details(cipher_signature):
 
 
 def test_repr_for_audio_streams(cipher_signature):
-    stream = str(cipher_signature.streams.filter(only_audio=True).first())
+    stream = str(cipher_signature.streams.filter(only_audio=True)[0])
     expected = (
         '<Stream: itag="140" mime_type="audio/mp4" abr="128kbps" '
         'acodec="mp4a.40.2" progressive="False" type="audio">'
@@ -242,7 +242,7 @@ def test_repr_for_audio_streams(cipher_signature):
 
 
 def test_repr_for_video_streams(cipher_signature):
-    stream = str(cipher_signature.streams.filter(only_video=True).first())
+    stream = str(cipher_signature.streams.filter(only_video=True)[0])
     expected = (
         '<Stream: itag="137" mime_type="video/mp4" res="1080p" fps="30fps" '
         'vcodec="avc1.640028" progressive="False" type="video">'
@@ -251,7 +251,7 @@ def test_repr_for_video_streams(cipher_signature):
 
 
 def test_repr_for_progressive_streams(cipher_signature):
-    stream = str(cipher_signature.streams.filter(progressive=True).first())
+    stream = str(cipher_signature.streams.filter(progressive=True)[0])
     expected = (
         '<Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" '
         'vcodec="avc1.42001E" acodec="mp4a.40.2" progressive="True" type="video">'
@@ -260,7 +260,7 @@ def test_repr_for_progressive_streams(cipher_signature):
 
 
 def test_repr_for_adaptive_streams(cipher_signature):
-    stream = str(cipher_signature.streams.filter(adaptive=True).first())
+    stream = str(cipher_signature.streams.filter(adaptive=True)[0])
     expected = (
         '<Stream: itag="137" mime_type="video/mp4" res="1080p" fps="30fps" '
         'vcodec="avc1.640028" progressive="False" type="video">'