Better unavailable video handling (#791)

Added private video & unavailable recording checks, in order to have more descriptive errors.

pytube/__main__.py

@@ -20,7 +20,9 @@ from pytube import extract
 from pytube import request
 from pytube import Stream
 from pytube import StreamQuery
+from pytube.exceptions import RecordingUnavailable
 from pytube.exceptions import VideoUnavailable
+from pytube.exceptions import VideoPrivate
 from pytube.extract import apply_descrambler
 from pytube.extract import apply_signature
 from pytube.extract import get_ytplayer_config
@@ -168,11 +170,11 @@ class YouTube:
             raise VideoUnavailable(video_id=self.video_id)
         self.age_restricted = extract.is_age_restricted(self.watch_html)
 
-        if (
-            not self.age_restricted
-            and "This video is private" in self.watch_html
-        ):
-            raise VideoUnavailable(video_id=self.video_id)
+        if extract.is_private(self.watch_html):
+            raise VideoPrivate(video_id=self.video_id)
+
+        if not extract.recording_available(self.watch_html):
+            raise RecordingUnavailable(video_id=self.video_id)
 
         if self.age_restricted:
             if not self.embed_html:

pytube/exceptions.py

@@ -58,5 +58,27 @@ class VideoUnavailable(PytubeError):
         self.video_id = video_id
 
 
+class VideoPrivate(ExtractError):
+    def __init__(self, video_id: str):
+        """
+        :param str video_id:
+            A YouTube video identifier.
+        """
+        super().__init__('%s is a private video' % video_id)
+        self.video_id = video_id
+
+
+class RecordingUnavailable(ExtractError):
+    def __init__(self, video_id: str):
+        """
+        :param str video_id:
+            A YouTube video identifier.
+        """
+        super().__init__(
+            '%s does not have a live stream recording available' % video_id
+        )
+        self.video_id = video_id
+
+
 class HTMLParseError(PytubeError):
     """HTML could not be parsed"""

pytube/extract.py

@@ -22,6 +22,44 @@ from pytube.helpers import regex_search
 logger = logging.getLogger(__name__)
 
 
+def recording_available(watch_html):
+    """Check if live stream recording is available.
+
+    :param str watch_html:
+        The html contents of the watch page.
+    :rtype: bool
+    :returns:
+        Whether or not the content is private.
+    """
+    unavailable_strings = [
+        'This live stream recording is not available.'
+    ]
+    for string in unavailable_strings:
+        if string in watch_html:
+            return False
+    return True
+
+
+def is_private(watch_html):
+    """Check if content is private.
+
+    :param str watch_html:
+        The html contents of the watch page.
+    :rtype: bool
+    :returns:
+        Whether or not the content is private.
+    """
+    private_strings = [
+        "This is a private video. Please sign in to verify that you may see it.",
+        "\"simpleText\":\"Private video\"",
+        "This video is private."
+    ]
+    for string in private_strings:
+        if string in watch_html:
+            return True
+    return False
+
+
 def is_age_restricted(watch_html: str) -> bool:
     """Check if content is age restricted.
 

tests/conftest.py

@@ -58,6 +58,20 @@ def age_restricted():
     return load_playback_file(filename)
 
 
+@pytest.fixture
+def private():
+    """Youtube instance initialized with video id m8uHb5jIGN8."""
+    filename = "yt-video-m8uHb5jIGN8-html.json.gz"
+    return load_playback_file(filename)
+
+
+@pytest.fixture
+def missing_recording():
+    """Youtube instance initialized with video id 5YceQ8YqYMc."""
+    filename = "yt-video-5YceQ8YqYMc-html.json.gz"
+    return load_playback_file(filename)
+
+
 @pytest.fixture
 def playlist_html():
     """Youtube playlist HTML loaded on 2020-01-25 from

tests/test_exceptions.py

@@ -1,7 +1,13 @@
 # -*- coding: utf-8 -*-
+import pytest
+from unittest import mock
+
+from pytube import YouTube
 from pytube.exceptions import LiveStreamError
+from pytube.exceptions import RecordingUnavailable
 from pytube.exceptions import RegexMatchError
 from pytube.exceptions import VideoUnavailable
+from pytube.exceptions import VideoPrivate
 
 
 def test_video_unavailable():
@@ -25,3 +31,43 @@ def test_live_stream_error():
     except LiveStreamError as e:
         assert e.video_id == "YLnZklYFe7E"  # noqa: PT017
         assert str(e) == "YLnZklYFe7E is streaming live and cannot be loaded"
+
+
+def test_recording_unavailable():
+    try:
+        raise RecordingUnavailable(video_id="5YceQ8YqYMc")
+    except RecordingUnavailable as e:
+        assert e.video_id == "5YceQ8YqYMc"  # noqa: PT017
+        assert str(e) == "5YceQ8YqYMc does not have a live stream recording available"
+
+
+def test_private_error():
+    try:
+        raise VideoPrivate('mRe-514tGMg')
+    except VideoPrivate as e:
+        assert e.video_id == 'mRe-514tGMg'  # noqa: PT017
+        assert str(e) == 'mRe-514tGMg is a private video'
+
+
+def test_raises_video_private(private):
+    with mock.patch('pytube.request.urlopen') as mock_url_open:
+        # Mock the responses to YouTube
+        mock_url_open_object = mock.Mock()
+        mock_url_open_object.read.side_effect = [
+            private['watch_html'].encode('utf-8'),
+        ]
+        mock_url_open.return_value = mock_url_open_object
+        with pytest.raises(VideoPrivate):
+            YouTube('https://youtube.com/watch?v=mRe-514tGMg')
+
+
+def test_raises_recording_unavailable(missing_recording):
+    with mock.patch('pytube.request.urlopen') as mock_url_open:
+        # Mock the responses to YouTube
+        mock_url_open_object = mock.Mock()
+        mock_url_open_object.read.side_effect = [
+            missing_recording['watch_html'].encode('utf-8'),
+        ]
+        mock_url_open.return_value = mock_url_open_object
+        with pytest.raises(RecordingUnavailable):
+            YouTube('https://youtube.com/watch?v=5YceQ8YqYMc')

tests/test_extract.py

@@ -52,6 +52,22 @@ def test_non_age_restricted(cipher_signature):
     assert not extract.is_age_restricted(cipher_signature.watch_html)
 
 
+def test_is_private(private):
+    assert extract.is_private(private['watch_html'])
+
+
+def test_not_is_private(cipher_signature):
+    assert not extract.is_private(cipher_signature.watch_html)
+
+
+def test_recording_available(cipher_signature):
+    assert extract.recording_available(cipher_signature.watch_html)
+
+
+def test_not_recording_available(missing_recording):
+    assert not extract.recording_available(missing_recording['watch_html'])
+
+
 def test_mime_type_codec():
     mime_type, mime_subtype = extract.mime_type_codec(
         'audio/webm; codecs="opus"'

tests/test_streams.py

@@ -52,8 +52,7 @@ def test_default_filename(cipher_signature):
 
 
 def test_title(cipher_signature):
-    expected = "title"
-    cipher_signature.player_response = {"videoDetails": {"title": expected}}
+    expected = "YouTube Rewind 2019: For the Record | #YouTubeRewind"
     assert cipher_signature.title == expected