Improvement/better exceptions (#896)

* Reworked the different unavailable video exceptions so they can be caught by a generic exception.

* Added handling for videos being unavailable due to error.

pytube/__main__.py

@@ -135,6 +135,9 @@ class YouTube:
                     'Please sign in to verify that you may see it.'
                 ):
                     raise VideoPrivate(video_id=self.video_id)
+            elif status == 'ERROR':
+                if reason == 'Video unavailable':
+                    raise VideoUnavailable(video_id=self.video_id)
 
     def descramble(self) -> None:
         """Descramble the stream data and build Stream instances.

pytube/exceptions.py

@@ -5,7 +5,7 @@ from typing import Union
 
 
 class PytubeError(Exception):
-    """Base pytube exception that all others inherent.
+    """Base pytube exception that all others inherit.
 
     This is done to not pollute the built-in exceptions, which *could* result
     in unintended errors being unexpectedly and incorrectly handled within
@@ -13,6 +13,10 @@ class PytubeError(Exception):
     """
 
 
+class HTMLParseError(PytubeError):
+    """HTML could not be parsed"""
+
+
 class ExtractError(PytubeError):
     """Data extraction based exception."""
 
@@ -32,55 +36,66 @@ class RegexMatchError(ExtractError):
         self.pattern = pattern
 
 
-class LiveStreamError(ExtractError):
-    """Video is a live stream."""
-
+class VideoUnavailable(PytubeError):
+    """Base video unavailable error."""
     def __init__(self, video_id: str):
         """
         :param str video_id:
             A YouTube video identifier.
         """
-        super().__init__(f"{video_id} is streaming live and cannot be loaded")
-
         self.video_id = video_id
+        super().__init__(self.error_string)
 
+    @property
+    def error_string(self):
+        return f'{self.video_id} is unavailable'
 
-class VideoUnavailable(PytubeError):
-    """Video is unavailable."""
+
+class LiveStreamError(VideoUnavailable):
+    """Video is a live stream."""
 
     def __init__(self, video_id: str):
         """
         :param str video_id:
             A YouTube video identifier.
         """
-        super().__init__(f"{video_id} is unavailable")
-
         self.video_id = video_id
+        super().__init__(self.video_id)
+
+    @property
+    def error_string(self):
+        return f'{self.video_id} is streaming live and cannot be loaded'
 
 
-class VideoPrivate(ExtractError):
+class VideoPrivate(VideoUnavailable):
     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
+        super().__init__(self.video_id)
 
+    @property
+    def error_string(self):
+        return f'{self.video_id} is a private video'
 
-class RecordingUnavailable(ExtractError):
+
+class RecordingUnavailable(VideoUnavailable):
     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
+        super().__init__(self.video_id)
+
+    @property
+    def error_string(self):
+        return f'{self.video_id} does not have a live stream recording available'
 
 
-class MembersOnly(PytubeError):
+class MembersOnly(VideoUnavailable):
     """Video is members-only.
 
     YouTube has special videos that are only viewable to users who have
@@ -92,21 +107,23 @@ class MembersOnly(PytubeError):
         :param str video_id:
             A YouTube video identifier.
         """
-        super().__init__('%s is a members-only video' % video_id)
         self.video_id = video_id
+        super().__init__(self.video_id)
 
+    @property
+    def error_string(self):
+        return f'{self.video_id} is a members-only video'
 
-class VideoRegionBlocked(ExtractError):
+
+class VideoRegionBlocked(VideoUnavailable):
     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
+        super().__init__(self.video_id)
 
-
-class HTMLParseError(PytubeError):
-    """HTML could not be parsed"""
+    @property
+    def error_string(self):
+        return f'{self.video_id} is not available in your region'

tests/test_exceptions.py

@@ -27,6 +27,9 @@ def test_regex_match_error():
 
 
 def test_live_stream_error():
+    # Ensure this can be caught as generic VideoUnavailable exception
+    with pytest.raises(VideoUnavailable):
+        raise LiveStreamError(video_id='YLnZklYFe7E')
     try:
         raise LiveStreamError(video_id='YLnZklYFe7E')
     except LiveStreamError as e:
@@ -35,6 +38,9 @@ def test_live_stream_error():
 
 
 def test_recording_unavailable_error():
+    # Ensure this can be caught as generic VideoUnavailable exception
+    with pytest.raises(VideoUnavailable):
+        raise RecordingUnavailable(video_id='5YceQ8YqYMc')
     try:
         raise RecordingUnavailable(video_id='5YceQ8YqYMc')
     except RecordingUnavailable as e:
@@ -43,6 +49,9 @@ def test_recording_unavailable_error():
 
 
 def test_private_error():
+    # Ensure this can be caught as generic VideoUnavailable exception
+    with pytest.raises(VideoUnavailable):
+        raise VideoPrivate('m8uHb5jIGN8')
     try:
         raise VideoPrivate('m8uHb5jIGN8')
     except VideoPrivate as e:
@@ -51,6 +60,9 @@ def test_private_error():
 
 
 def test_region_locked_error():
+    # Ensure this can be caught as generic VideoUnavailable exception
+    with pytest.raises(VideoUnavailable):
+        raise VideoRegionBlocked('hZpzr8TbF08')
     try:
         raise VideoRegionBlocked('hZpzr8TbF08')
     except VideoRegionBlocked as e: