Added new exception for region-locked videos. (#861)

pytube/__main__.py

@@ -25,6 +25,7 @@ from pytube.exceptions import MembersOnly
 from pytube.exceptions import RecordingUnavailable
 from pytube.exceptions import VideoUnavailable
 from pytube.exceptions import VideoPrivate
+from pytube.exceptions import VideoRegionBlocked
 from pytube.extract import apply_descrambler
 from pytube.extract import apply_signature
 from pytube.extract import get_ytplayer_config
@@ -113,6 +114,7 @@ class YouTube:
             raise VideoUnavailable(video_id=self.video_id)
 
         status, messages = extract.playability_status(self.watch_html)
+
         for reason in messages:
             if status == 'UNPLAYABLE':
                 if reason == (
@@ -123,6 +125,9 @@ class YouTube:
                 elif reason == 'This live stream recording is not available.':
                     raise RecordingUnavailable(video_id=self.video_id)
                 else:
+                    if reason == 'Video unavailable':
+                        if extract.is_region_blocked(self.watch_html):
+                            raise VideoRegionBlocked(video_id=self.video_id)
                     raise VideoUnavailable(video_id=self.video_id)
             elif status == 'LOGIN_REQUIRED':
                 if reason == (

pytube/exceptions.py

@@ -96,5 +96,17 @@ class MembersOnly(PytubeError):
         self.video_id = video_id
 
 
+class VideoRegionBlocked(ExtractError):
+    def __init__(self, video_id: str):
+        """
+        :param str video_id:
+            A YouTube video identifier.
+        """
+        super().__init__(
+            '%s is not available in your region' % video_id
+        )
+        self.video_id = video_id
+
+
 class HTMLParseError(PytubeError):
     """HTML could not be parsed"""

pytube/extract.py

@@ -100,6 +100,34 @@ def is_age_restricted(watch_html: str) -> bool:
     return True
 
 
+def is_region_blocked(watch_html: str) -> bool:
+    """Determine if a video is not available in the user's region.
+
+    :param str watch_html:
+        The html contents of the watch page.
+    :rtype: bool
+    :returns:
+        True if the video is blocked in the users region.
+        False if not, or if unknown.
+    """
+    player_response = initial_player_response(watch_html)
+    country_code_patterns = [
+        r"gl\s*=\s*['\"](\w{2})['\"]",  # gl="US"
+        r"['\"]gl['\"]\s*:\s*['\"](\w{2})['\"]"  # "gl":"US"
+    ]
+    for pattern in country_code_patterns:
+        try:
+            yt_detected_country = regex_search(pattern, watch_html, 1)
+            available_countries = player_response[
+                'microformat']['playerMicroformatRenderer']['availableCountries']
+        except (KeyError, RegexMatchError):
+            pass
+        else:
+            if yt_detected_country not in available_countries:
+                return True
+    return False
+
+
 def playability_status(watch_html: str) -> (str, str):
     """Return the playability status and status explanation of a video.
 
@@ -114,7 +142,7 @@ def playability_status(watch_html: str) -> (str, str):
     :returns:
         Playability status and reason of the video.
     """
-    player_response = json.loads(initial_player_response(watch_html))
+    player_response = initial_player_response(watch_html)
     status_dict = player_response.get('playabilityStatus', {})
     if 'status' in status_dict:
         if 'reason' in status_dict:
@@ -467,7 +495,7 @@ def initial_data(watch_html: str) -> str:
         except HTMLParseError:
             pass
 
-    raise RegexMatchError(caller="initial_data", pattern='initial_data_pattern')
+    raise RegexMatchError(caller='initial_data', pattern='initial_data_pattern')
 
 
 def initial_player_response(watch_html: str) -> str:
@@ -479,11 +507,20 @@ def initial_player_response(watch_html: str) -> str:
     @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 "{}"
+    patterns = [
+        r"window\[['\"]ytInitialPlayerResponse['\"]]\s*=\s*",
+        r"ytInitialPlayerResponse\s*=\s*"
+    ]
+    for pattern in patterns:
+        try:
+            return parse_for_object(watch_html, pattern)
+        except HTMLParseError:
+            pass
+
+    raise RegexMatchError(
+        caller='initial_player_response',
+        pattern='initial_player_response_pattern'
+    )
 
 
 def metadata(initial_data) -> Optional[YouTubeMetadata]:

tests/conftest.py

@@ -72,6 +72,13 @@ def missing_recording():
     return load_playback_file(filename)
 
 
+@pytest.fixture
+def region_blocked():
+    """Youtube instance initialized with video id hZpzr8TbF08."""
+    filename = "yt-video-hZpzr8TbF08-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

@@ -8,6 +8,7 @@ from pytube.exceptions import RecordingUnavailable
 from pytube.exceptions import RegexMatchError
 from pytube.exceptions import VideoUnavailable
 from pytube.exceptions import VideoPrivate
+from pytube.exceptions import VideoRegionBlocked
 
 
 def test_video_unavailable():
@@ -27,18 +28,18 @@ def test_regex_match_error():
 
 def test_live_stream_error():
     try:
-        raise LiveStreamError(video_id="YLnZklYFe7E")
+        raise LiveStreamError(video_id='YLnZklYFe7E')
     except LiveStreamError as e:
-        assert e.video_id == "YLnZklYFe7E"  # noqa: PT017
-        assert str(e) == "YLnZklYFe7E is streaming live and cannot be loaded"
+        assert e.video_id == 'YLnZklYFe7E'  # noqa: PT017
+        assert str(e) == 'YLnZklYFe7E is streaming live and cannot be loaded'
 
 
-def test_recording_unavailable():
+def test_recording_unavailable_error():
     try:
-        raise RecordingUnavailable(video_id="5YceQ8YqYMc")
+        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"
+        assert e.video_id == '5YceQ8YqYMc'  # noqa: PT017
+        assert str(e) == '5YceQ8YqYMc does not have a live stream recording available'
 
 
 def test_private_error():
@@ -49,6 +50,14 @@ def test_private_error():
         assert str(e) == 'm8uHb5jIGN8 is a private video'
 
 
+def test_region_locked_error():
+    try:
+        raise VideoRegionBlocked('hZpzr8TbF08')
+    except VideoRegionBlocked as e:
+        assert e.video_id == 'hZpzr8TbF08'  # noqa: PT017
+        assert str(e) == 'hZpzr8TbF08 is not available in your region'
+
+
 def test_raises_video_private(private):
     with mock.patch('pytube.request.urlopen') as mock_url_open:
         # Mock the responses to YouTube
@@ -71,3 +80,15 @@ def test_raises_recording_unavailable(missing_recording):
         mock_url_open.return_value = mock_url_open_object
         with pytest.raises(RecordingUnavailable):
             YouTube('https://youtube.com/watch?v=5YceQ8YqYMc')
+
+
+def test_raises_video_region_blocked(region_blocked):
+    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 = [
+            region_blocked['watch_html'].encode('utf-8')
+        ]
+        mock_url_open.return_value = mock_url_open_object
+        with pytest.raises(VideoRegionBlocked):
+            YouTube('https://youtube.com/watch?v=hZpzr8TbF08')

tests/test_helpers.py

@@ -121,7 +121,7 @@ def test_create_mock_html_json(mock_url_open, mock_open):
     # 2. vid_info_raw
     # 3. js
     mock_url_open_object.read.side_effect = [
-        (b'yt.setConfig({"PLAYER_CONFIG":{"args":[]}});ytInitialData = {}'
+        (b'yt.setConfig({"PLAYER_CONFIG":{"args":[]}});ytInitialData = {};ytInitialPlayerResponse = {};'  # noqa: E501
          b'"jsUrl":"/s/player/13371337/player_ias.vflset/en_US/base.js"'),
         b'vid_info_raw',
         b'js_result',