Improveme unavailable video handling (#835)

* Added new exception for videos only available to members of a channel.
* Added functionality for extracting and parsing ytInitialData.
* Account for changes in YouTube Playability API causing change in data for private videos.

pytube/__main__.py

@@ -20,6 +20,7 @@ from pytube import extract
 from pytube import request
 from pytube import Stream
 from pytube import StreamQuery
+from pytube.exceptions import MembersOnly
 from pytube.exceptions import RecordingUnavailable
 from pytube.exceptions import VideoUnavailable
 from pytube.exceptions import VideoPrivate
@@ -101,6 +102,34 @@ class YouTube:
             self.prefetch()
             self.descramble()
 
+    def check_availability(self):
+        """Check whether the video is available.
+        Raises different exceptions based on why the video is unavailable,
+        otherwise does nothing.
+
+        """
+        if self.watch_html is None:
+            raise VideoUnavailable(video_id=self.video_id)
+
+        status, messages = extract.playability_status(self.watch_html)
+        for reason in messages:
+            if status == 'UNPLAYABLE':
+                if reason == (
+                    'Join this channel to get access to members-only content '
+                    'like this video, and other exclusive perks.'
+                ):
+                    raise MembersOnly(video_id=self.video_id)
+                elif reason == 'This live stream recording is not available.':
+                    raise RecordingUnavailable(video_id=self.video_id)
+                else:
+                    raise VideoUnavailable(video_id=self.video_id)
+            elif status == 'LOGIN_REQUIRED':
+                if reason == (
+                    'This is a private video. '
+                    'Please sign in to verify that you may see it.'
+                ):
+                    raise VideoPrivate(video_id=self.video_id)
+
     def descramble(self) -> None:
         """Descramble the stream data and build Stream instances.
 
@@ -168,16 +197,9 @@ class YouTube:
         :rtype: None
         """
         self.watch_html = request.get(url=self.watch_url)
-        if self.watch_html is None:
-            raise VideoUnavailable(video_id=self.video_id)
+        self.check_availability()
         self.age_restricted = extract.is_age_restricted(self.watch_html)
 
-        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:
                 self.embed_html = request.get(url=self.embed_url)

pytube/exceptions.py

@@ -80,5 +80,21 @@ class RecordingUnavailable(ExtractError):
         self.video_id = video_id
 
 
+class MembersOnly(PytubeError):
+    """Video is members-only.
+
+    YouTube has special videos that are only viewable to users who have
+    subscribed to a content creator.
+    ref: https://support.google.com/youtube/answer/7544492?hl=en
+    """
+    def __init__(self, video_id: str):
+        """
+        :param str video_id:
+            A YouTube video identifier.
+        """
+        super().__init__('%s is a members-only video' % video_id)
+        self.video_id = video_id
+
+
 class HTMLParseError(PytubeError):
     """HTML could not be parsed"""

pytube/extract.py

@@ -100,6 +100,30 @@ def is_age_restricted(watch_html: str) -> bool:
     return True
 
 
+def playability_status(watch_html: str) -> (str, str):
+    """Return the playability status and status explanation of a video.
+
+    For example, a video may have a status of LOGIN_REQUIRED, and an explanation
+    of "This is a private video. Please sign in to verify that you may see it."
+
+    This explanation is what gets incorporated into the media player overlay.
+
+    :param str watch_html:
+        The html contents of the watch page.
+    :rtype: bool
+    :returns:
+        Playability status and reason of the video.
+    """
+    player_response = json.loads(initial_player_response(watch_html))
+    status_dict = player_response.get('playabilityStatus', {})
+    if 'status' in status_dict:
+        if 'reason' in status_dict:
+            return status_dict['status'], [status_dict['reason']]
+        if 'messages' in status_dict:
+            return status_dict['status'], status_dict['messages']
+    return None, [None]
+
+
 def video_id(url: str) -> str:
     """Extract the ``video_id`` from a YouTube url.
 
@@ -438,6 +462,22 @@ def initial_data(watch_html: str) -> str:
         return {}
 
 
+def initial_player_response(watch_html: str) -> str:
+    """Extract the ytInitialPlayerResponse json from the watch_html page.
+
+    This mostly contains metadata necessary for rendering the page on-load,
+    such as video information, copyright notices, etc.
+
+    @param watch_html: Html of the watch page
+    @return:
+    """
+    pattern = r"window\[['\"]ytInitialPlayerResponse['\"]]\s*=\s*({[^\n]+});"
+    try:
+        return regex_search(pattern, watch_html, 1)
+    except RegexMatchError:
+        return "{}"
+
+
 def metadata(initial_data) -> Optional[YouTubeMetadata]:
     """Get the informational metadata for the video.
 

tests/test_exceptions.py

@@ -43,10 +43,10 @@ def test_recording_unavailable():
 
 def test_private_error():
     try:
-        raise VideoPrivate('mRe-514tGMg')
+        raise VideoPrivate('m8uHb5jIGN8')
     except VideoPrivate as e:
-        assert e.video_id == 'mRe-514tGMg'  # noqa: PT017
-        assert str(e) == 'mRe-514tGMg is a private video'
+        assert e.video_id == 'm8uHb5jIGN8'  # noqa: PT017
+        assert str(e) == 'm8uHb5jIGN8 is a private video'
 
 
 def test_raises_video_private(private):
@@ -58,7 +58,7 @@ def test_raises_video_private(private):
         ]
         mock_url_open.return_value = mock_url_open_object
         with pytest.raises(VideoPrivate):
-            YouTube('https://youtube.com/watch?v=mRe-514tGMg')
+            YouTube('https://youtube.com/watch?v=m8uHb5jIGN8')
 
 
 def test_raises_recording_unavailable(missing_recording):