refactoring of exceptions

pytube/__main__.py

@@ -182,7 +182,8 @@ class YouTube(object):
             or '<img class="icon meh" src="/yts/img'  # noqa: W503
             not in self.watch_html  # noqa: W503
         ):
-            raise VideoUnavailable("This video is unavailable.")
+            raise VideoUnavailable(video_id=self.video_id)
+
         self.embed_html = request.get(url=self.embed_url)
         self.age_restricted = extract.is_age_restricted(self.watch_html)
         self.vid_info_url = extract.video_info_url(

pytube/cipher.py

@@ -56,7 +56,7 @@ def get_initial_function_name(js: str) -> str:
             logger.debug("finished regex search, matched: {pattern}".format(pattern=p))
             return results.group(1)
 
-    raise RegexMatchError("get_initial_function_name not found")
+    raise RegexMatchError(caller="get_initial_function_name", pattern="multiple")
 
 
 def get_transform_plan(js: str) -> List[str]:
@@ -113,9 +113,7 @@ def get_transform_object(js: str, var: str) -> List[str]:
     regex = re.compile(pattern, flags=re.DOTALL)
     results = regex.search(js)
     if not results:
-        raise RegexMatchError(
-            "regex pattern ({pattern}) had zero matches".format(pattern=pattern),
-        )
+        raise RegexMatchError(caller="get_transform_object", pattern=pattern)
 
     return results.group(1).replace("\n", " ").split(", ")
 
@@ -222,9 +220,7 @@ def map_functions(js_func: str) -> Callable:
     for pattern, fn in mapper:
         if re.search(pattern, js_func):
             return fn
-    raise RegexMatchError(
-        "could not find python equivalent function for: ", js_func,
-    )
+    raise RegexMatchError(caller="map_functions", pattern="multiple")
 
 
 def parse_function(js_func: str) -> Tuple[str, int]:
@@ -250,9 +246,7 @@ def parse_function(js_func: str) -> Tuple[str, int]:
     regex = re.compile(pattern)
     results = regex.search(js_func)
     if not results:
-        raise RegexMatchError(
-            "regex pattern ({pattern}) had zero matches".format(pattern=pattern),
-        )
+        raise RegexMatchError(caller="parse_function", pattern=pattern)
     fn_name, fn_arg = results.groups()
     return fn_name, int(fn_arg)
 

pytube/exceptions.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 """Library specific exception definitions."""
 import sys
+from typing import Union, Pattern
 
 
 class PytubeError(Exception):
@@ -15,26 +16,25 @@ class PytubeError(Exception):
 class ExtractError(PytubeError):
     """Data extraction based exception."""
 
-    def __init__(self, msg: str, video_id: str = "unknown id"):
-        """Construct an instance of a :class:`ExtractError <ExtractError>`.
-
-        :param str msg:
-            User defined error message.
-        :param str video_id:
-            A YouTube video identifier.
-        """
-        if video_id is not None:
-            msg = "{video_id}: {msg}".format(video_id=video_id, msg=msg)
-
-        super(ExtractError, self).__init__(msg)
-
-        self.exc_info = sys.exc_info()
-        self.video_id = video_id
-
 
 class RegexMatchError(ExtractError):
     """Regex pattern did not return any matches."""
 
+    def __init__(self, caller: str, pattern: Union[str, Pattern]):
+        """
+        :param str caller:
+            Calling function
+        :param str pattern:
+            Pattern that failed to match
+        """
+        super(ExtractError, self).__init__(
+            "{caller}: could not find match for {pattern}".format(
+                caller=caller, pattern=pattern
+            )
+        )
+        self.caller = caller
+        self.pattern = pattern
+
 
 class LiveStreamError(ExtractError):
     """Video is a live stream."""
@@ -43,6 +43,18 @@ class LiveStreamError(ExtractError):
 class VideoUnavailable(PytubeError):
     """Video is unavailable."""
 
+    def __init__(self, video_id: str):
+        """
+        :param str video_id:
+            A YouTube video identifier.
+        """
+        super(PytubeError, self).__init__(
+            "{video_id} is unavailable".format(video_id=video_id)
+        )
+
+        self.exc_info = sys.exc_info()
+        self.video_id = video_id
+
 
 class HTMLParseError(PytubeError):
     """HTML could not be parsed"""

pytube/extract.py

@@ -174,9 +174,7 @@ def mime_type_codec(mime_type_codec: str) -> Tuple[str, List[str]]:
     regex = re.compile(pattern)
     results = regex.search(mime_type_codec)
     if not results:
-        raise RegexMatchError(
-            "regex pattern ({pattern}) had zero matches".format(pattern=pattern),
-        )
+        raise RegexMatchError(caller="mime_type_codec", pattern=pattern)
     mime_type, codecs = results.groups()
     return mime_type, [c.strip() for c in codecs.split(",")]
 

pytube/helpers.py

@@ -27,9 +27,7 @@ def regex_search(pattern: str, string: str, group: int) -> str:
     regex = re.compile(pattern)
     results = regex.search(string)
     if not results:
-        raise RegexMatchError(
-            "regex pattern ({pattern}) had zero matches".format(pattern=pattern),
-        )
+        raise RegexMatchError(caller="regex_search", pattern=pattern)
 
     logger.debug(
         "finished regex search: %s",

pytube/request.py

@@ -3,12 +3,8 @@
 from urllib.request import Request
 from urllib.request import urlopen
 
-# 403 forbidden fix
 
-
-def get(
-    url=None, headers=False, streaming=False, chunk_size=8 * 1024,
-):
+def get(url, headers=False, streaming=False, chunk_size=8192):
     """Send an http GET request.
 
     :param str url:
@@ -18,7 +14,7 @@ def get(
     :param bool streaming:
         Returns the response body in chunks via a generator.
     :param int chunk_size:
-        The size in bytes of each chunk.
+        The size in bytes of each chunk. Defaults to 8*1024
     """
 
     # https://github.com/nficano/pytube/pull/465

tests/test_exceptions.py

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
-from pytube.exceptions import ExtractError
+from pytube.exceptions import VideoUnavailable
 
 
 def test_is_expected():
     try:
-        raise ExtractError("ppfff", video_id="YLnZklYFe7E")
-    except ExtractError as e:
+        raise VideoUnavailable("ppfff", video_id="YLnZklYFe7E")
+    except VideoUnavailable as e:
         assert e.video_id == "YLnZklYFe7E"