Consolidate import sections (#952)

* Squashes some import lines to reduce clutter at the top of files

pytube/__init__.py

@@ -12,7 +12,6 @@ __js_url__ = None
 from pytube.version import __version__
 from pytube.streams import Stream
 from pytube.captions import Caption
-from pytube.query import CaptionQuery
-from pytube.query import StreamQuery
+from pytube.query import CaptionQuery, StreamQuery
 from pytube.__main__ import YouTube
 from pytube.contrib.playlist import Playlist

pytube/__main__.py

@@ -9,28 +9,13 @@ smaller peripheral modules and functions.
 """
 import json
 import logging
-from typing import Any
-from typing import Callable
-from typing import Dict
-from typing import List
-from typing import Optional
+from typing import Any, Callable, Dict, List, Optional
 from urllib.parse import parse_qsl
 
 import pytube
-from pytube import Caption
-from pytube import CaptionQuery
-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
-from pytube.exceptions import VideoRegionBlocked
-from pytube.extract import apply_descrambler
-from pytube.extract import apply_signature
-from pytube.extract import get_ytplayer_config
+import pytube.exceptions as exceptions
+from pytube import extract, request
+from pytube import Stream, StreamQuery
 from pytube.helpers import install_proxy
 from pytube.metadata import YouTubeMetadata
 from pytube.monostate import Monostate
@@ -204,7 +189,7 @@ class YouTube:
         # On pre-signed videos, we need to use get_ytplayer_config to fix
         #  the player_response item
         if 'streamingData' not in self.player_config_args['player_response']:
-            config_response = get_ytplayer_config(self.watch_html)
+            config_response = extract.get_ytplayer_config(self.watch_html)
             if 'args' in config_response:
                 self.player_config_args['player_response'] = config_response['args']['player_response']  # noqa: E501
             else:
@@ -232,10 +217,10 @@ class YouTube:
         # unscramble the progressive and adaptive stream manifests.
         for fmt in stream_maps:
             if not self.age_restricted and fmt in self.vid_info:
-                apply_descrambler(self.vid_info, fmt)
-            apply_descrambler(self.player_config_args, fmt)
+                extract.apply_descrambler(self.vid_info, fmt)
+            extract.apply_descrambler(self.player_config_args, fmt)
 
-            apply_signature(self.player_config_args, fmt, self.js)
+            extract.apply_signature(self.player_config_args, fmt, self.js)
 
             # build instances of :class:`Stream <Stream>`
             # Initialize stream objects
@@ -267,23 +252,23 @@ class YouTube:
                     'Join this channel to get access to members-only content '
                     'like this video, and other exclusive perks.'
                 ):
-                    raise MembersOnly(video_id=self.video_id)
+                    raise exceptions.MembersOnly(video_id=self.video_id)
                 elif reason == 'This live stream recording is not available.':
-                    raise RecordingUnavailable(video_id=self.video_id)
+                    raise exceptions.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)
+                            raise exceptions.VideoRegionBlocked(video_id=self.video_id)
+                    raise exceptions.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)
+                    raise exceptions.VideoPrivate(video_id=self.video_id)
             elif status == 'ERROR':
                 if reason == 'Video unavailable':
-                    raise VideoUnavailable(video_id=self.video_id)
+                    raise exceptions.VideoUnavailable(video_id=self.video_id)
 
     @property
     def vid_info(self):
@@ -294,7 +279,7 @@ class YouTube:
         return dict(parse_qsl(self.vid_info_raw))
 
     @property
-    def caption_tracks(self) -> List[Caption]:
+    def caption_tracks(self) -> List[pytube.Caption]:
         """Get a list of :class:`Caption <Caption>`.
 
         :rtype: List[Caption]
@@ -304,15 +289,15 @@ class YouTube:
             .get("playerCaptionsTracklistRenderer", {})
             .get("captionTracks", [])
         )
-        return [Caption(track) for track in raw_tracks]
+        return [pytube.Caption(track) for track in raw_tracks]
 
     @property
-    def captions(self) -> CaptionQuery:
+    def captions(self) -> pytube.CaptionQuery:
         """Interface to query caption tracks.
 
         :rtype: :class:`CaptionQuery <CaptionQuery>`.
         """
-        return CaptionQuery(self.caption_tracks)
+        return pytube.CaptionQuery(self.caption_tracks)
 
     @property
     def streams(self) -> StreamQuery:

pytube/captions.py

@@ -4,12 +4,10 @@ import os
 import time
 import xml.etree.ElementTree as ElementTree
 from html import unescape
-from typing import Dict
-from typing import Optional
+from typing import Dict, Optional
 
 from pytube import request
-from pytube.helpers import safe_filename
-from pytube.helpers import target_directory
+from pytube.helpers import safe_filename, target_directory
 
 
 class Caption:

pytube/cipher.py

@@ -16,16 +16,10 @@ signature and decoding it.
 import logging
 import re
 from itertools import chain
-from typing import Any
-from typing import Callable
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from pytube.exceptions import RegexMatchError
-from pytube.helpers import cache
-from pytube.helpers import regex_search
+from pytube.helpers import cache, regex_search
 
 logger = logging.getLogger(__name__)
 

pytube/cli.py

@@ -2,25 +2,20 @@
 # -*- coding: utf-8 -*-
 """A simple command line application to download youtube videos."""
 import argparse
-import datetime as dt
 import gzip
 import json
 import logging
 import os
 import shutil
-import subprocess  # nosec
 import sys
-from typing import List
-from typing import Optional
+import datetime as dt
+import subprocess  # nosec
+from typing import List, Optional
 
+import pytube.exceptions as exceptions
 from pytube import __version__
-from pytube import CaptionQuery
-from pytube import Playlist
-from pytube import Stream
-from pytube import YouTube
-from pytube.exceptions import PytubeError, VideoUnavailable
-from pytube.helpers import safe_filename
-from pytube.helpers import setup_logger
+from pytube import CaptionQuery, Playlist, Stream, YouTube
+from pytube.helpers import safe_filename, setup_logger
 
 
 def main():
@@ -47,7 +42,7 @@ def main():
         for youtube_video in playlist.videos:
             try:
                 _perform_args_on_youtube(youtube_video, args)
-            except PytubeError as e:
+            except exceptions.PytubeError as e:
                 print(f"There was an error with video: {youtube_video}")
                 print(e)
     else:
@@ -476,7 +471,7 @@ def download_highest_resolution_progressive(
     youtube.register_on_progress_callback(on_progress)
     try:
         stream = youtube.streams.get_highest_resolution()
-    except VideoUnavailable as err:
+    except exceptions.VideoUnavailable as err:
         print(f"No video streams available: {err}")
     else:
         try:

pytube/contrib/playlist.py

@@ -4,21 +4,11 @@ import json
 import logging
 import re
 from collections.abc import Sequence
-from datetime import date
-from datetime import datetime
-from typing import Dict, Tuple
-from typing import Iterable
-from typing import List
-from typing import Optional
-from typing import Union
-
-from pytube import extract
-from pytube import request
-from pytube import YouTube
-from pytube.helpers import cache
-from pytube.helpers import install_proxy
-from pytube.helpers import regex_search
-from pytube.helpers import uniqueify
+from datetime import date, datetime
+from typing import Dict, Iterable, List, Optional, Tuple, Union
+
+from pytube import extract, request, YouTube
+from pytube.helpers import cache, install_proxy, regex_search, uniqueify
 
 logger = logging.getLogger(__name__)
 

pytube/exceptions.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 """Library specific exception definitions."""
-from typing import Pattern
-from typing import Union
+from typing import Pattern, Union
 
 
 class PytubeError(Exception):

pytube/extract.py

@@ -6,25 +6,15 @@ import urllib.parse
 import re
 from collections import OrderedDict
 from datetime import datetime
-from typing import Any
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
-from urllib.parse import parse_qs
-from urllib.parse import parse_qsl
-from urllib.parse import quote
-from urllib.parse import unquote
-from urllib.parse import urlencode
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import parse_qs, parse_qsl, quote, unquote, urlencode
 
 from pytube.cipher import Cipher
-from pytube.exceptions import HTMLParseError
-from pytube.exceptions import LiveStreamError
-from pytube.exceptions import RegexMatchError
+from pytube.exceptions import HTMLParseError, LiveStreamError, RegexMatchError
 from pytube.helpers import regex_search
 from pytube.metadata import YouTubeMetadata
-from pytube.parser import parse_for_object
-from pytube.parser import parse_for_all_objects
+from pytube.parser import parse_for_object, parse_for_all_objects
+
 
 logger = logging.getLogger(__name__)
 

pytube/helpers.py

@@ -7,12 +7,7 @@ import logging
 import os
 import re
 import warnings
-from typing import Any
-from typing import Callable
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import TypeVar
+from typing import Any, Callable, Dict, List, Optional, TypeVar
 from urllib import request
 
 from pytube.exceptions import RegexMatchError

pytube/metadata.py

@@ -1,9 +1,7 @@
 # -*- coding: utf-8 -*-
 """This module contains the YouTubeMetadata class."""
 import json
-from typing import Dict
-from typing import List
-from typing import Optional
+from typing import Dict, List, Optional
 
 
 class YouTubeMetadata:

pytube/monostate.py

@@ -1,7 +1,5 @@
 # -*- coding: utf-8 -*-
-from typing import Any
-from typing import Callable
-from typing import Optional
+from typing import Any, Callable, Optional
 
 
 class Monostate:

pytube/query.py

@@ -1,14 +1,9 @@
 # -*- coding: utf-8 -*-
 """This module provides a query interface for media streams and captions."""
-from collections.abc import Mapping
-from collections.abc import Sequence
-from typing import Callable
-from typing import List
-from typing import Optional
-from typing import Union
-
-from pytube import Caption
-from pytube import Stream
+from collections.abc import Mapping, Sequence
+from typing import Callable, List, Optional, Union
+
+from pytube import Caption, Stream
 from pytube.helpers import deprecated
 
 

pytube/request.py

@@ -2,13 +2,12 @@
 """Implements a simple wrapper around urlopen."""
 import json
 import logging
-from functools import lru_cache
 import re
 import socket
+from functools import lru_cache
 from urllib import parse
 from urllib.error import URLError
-from urllib.request import Request
-from urllib.request import urlopen
+from urllib.request import Request, urlopen
 
 from pytube.exceptions import RegexMatchError, MaxRetriesExceeded
 from pytube.helpers import regex_search

pytube/streams.py

@@ -10,17 +10,12 @@ separately).
 import logging
 import os
 from datetime import datetime
-from typing import BinaryIO
-from typing import Dict
-from typing import Optional
-from typing import Tuple
+from typing import BinaryIO, Dict, Optional, Tuple
 from urllib.error import HTTPError
 from urllib.parse import parse_qs
 
-from pytube import extract
-from pytube import request
-from pytube.helpers import safe_filename
-from pytube.helpers import target_directory
+from pytube import extract, request
+from pytube.helpers import safe_filename, target_directory
 from pytube.itags import get_format_profile
 from pytube.monostate import Monostate
 

tests/conftest.py

@@ -3,9 +3,8 @@
 import gzip
 import json
 import os
-from unittest import mock
-
 import pytest
+from unittest import mock
 
 from pytube import YouTube
 

tests/test_captions.py

@@ -1,15 +1,10 @@
 # -*- coding: utf-8 -*-
 import os
-from unittest import mock
-from unittest.mock import MagicMock
-from unittest.mock import mock_open
-from unittest.mock import patch
-
 import pytest
+from unittest import mock
+from unittest.mock import MagicMock, mock_open, patch
 
-from pytube import Caption
-from pytube import CaptionQuery
-from pytube import captions
+from pytube import Caption, CaptionQuery, captions
 
 
 def test_float_to_srt_time_format():

tests/test_cli.py

@@ -2,15 +2,11 @@
 import argparse
 import os
 from unittest import mock
-from unittest.mock import MagicMock
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import pytest
 
-from pytube import Caption
-from pytube import CaptionQuery
-from pytube import cli
-from pytube import StreamQuery
+from pytube import Caption, CaptionQuery, cli, StreamQuery
 from pytube.exceptions import PytubeError
 
 parse_args = cli._parse_args

tests/test_exceptions.py

@@ -2,70 +2,65 @@
 import pytest
 from unittest import mock
 
+import pytube.exceptions as exceptions
 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
-from pytube.exceptions import VideoRegionBlocked
 
 
 def test_video_unavailable():
     try:
-        raise VideoUnavailable(video_id="YLnZklYFe7E")
-    except VideoUnavailable as e:
+        raise exceptions.VideoUnavailable(video_id="YLnZklYFe7E")
+    except exceptions.VideoUnavailable as e:
         assert e.video_id == "YLnZklYFe7E"  # noqa: PT017
         assert str(e) == "YLnZklYFe7E is unavailable"
 
 
 def test_regex_match_error():
     try:
-        raise RegexMatchError(caller="hello", pattern="*")
-    except RegexMatchError as e:
+        raise exceptions.RegexMatchError(caller="hello", pattern="*")
+    except exceptions.RegexMatchError as e:
         assert str(e) == "hello: could not find match for *"
 
 
 def test_live_stream_error():
     # Ensure this can be caught as generic VideoUnavailable exception
-    with pytest.raises(VideoUnavailable):
-        raise LiveStreamError(video_id='YLnZklYFe7E')
+    with pytest.raises(exceptions.VideoUnavailable):
+        raise exceptions.LiveStreamError(video_id='YLnZklYFe7E')
     try:
-        raise LiveStreamError(video_id='YLnZklYFe7E')
-    except LiveStreamError as e:
+        raise exceptions.LiveStreamError(video_id='YLnZklYFe7E')
+    except exceptions.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_error():
     # Ensure this can be caught as generic VideoUnavailable exception
-    with pytest.raises(VideoUnavailable):
-        raise RecordingUnavailable(video_id='5YceQ8YqYMc')
+    with pytest.raises(exceptions.VideoUnavailable):
+        raise exceptions.RecordingUnavailable(video_id='5YceQ8YqYMc')
     try:
-        raise RecordingUnavailable(video_id='5YceQ8YqYMc')
-    except RecordingUnavailable as e:
+        raise exceptions.RecordingUnavailable(video_id='5YceQ8YqYMc')
+    except exceptions.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():
     # Ensure this can be caught as generic VideoUnavailable exception
-    with pytest.raises(VideoUnavailable):
-        raise VideoPrivate('m8uHb5jIGN8')
+    with pytest.raises(exceptions.VideoUnavailable):
+        raise exceptions.VideoPrivate('m8uHb5jIGN8')
     try:
-        raise VideoPrivate('m8uHb5jIGN8')
-    except VideoPrivate as e:
+        raise exceptions.VideoPrivate('m8uHb5jIGN8')
+    except exceptions.VideoPrivate as e:
         assert e.video_id == 'm8uHb5jIGN8'  # noqa: PT017
         assert str(e) == 'm8uHb5jIGN8 is a private video'
 
 
 def test_region_locked_error():
     # Ensure this can be caught as generic VideoUnavailable exception
-    with pytest.raises(VideoUnavailable):
-        raise VideoRegionBlocked('hZpzr8TbF08')
+    with pytest.raises(exceptions.VideoUnavailable):
+        raise exceptions.VideoRegionBlocked('hZpzr8TbF08')
     try:
-        raise VideoRegionBlocked('hZpzr8TbF08')
-    except VideoRegionBlocked as e:
+        raise exceptions.VideoRegionBlocked('hZpzr8TbF08')
+    except exceptions.VideoRegionBlocked as e:
         assert e.video_id == 'hZpzr8TbF08'  # noqa: PT017
         assert str(e) == 'hZpzr8TbF08 is not available in your region'
 
@@ -78,7 +73,7 @@ def test_raises_video_private(private):
             private['watch_html'].encode('utf-8'),
         ]
         mock_url_open.return_value = mock_url_open_object
-        with pytest.raises(VideoPrivate):
+        with pytest.raises(exceptions.VideoPrivate):
             YouTube('https://youtube.com/watch?v=m8uHb5jIGN8').streams
 
 
@@ -90,7 +85,7 @@ def test_raises_recording_unavailable(missing_recording):
             missing_recording['watch_html'].encode('utf-8'),
         ]
         mock_url_open.return_value = mock_url_open_object
-        with pytest.raises(RecordingUnavailable):
+        with pytest.raises(exceptions.RecordingUnavailable):
             YouTube('https://youtube.com/watch?v=5YceQ8YqYMc').streams
 
 
@@ -102,5 +97,5 @@ def test_raises_video_region_blocked(region_blocked):
             region_blocked['watch_html'].encode('utf-8')
         ]
         mock_url_open.return_value = mock_url_open_object
-        with pytest.raises(VideoRegionBlocked):
+        with pytest.raises(exceptions.VideoRegionBlocked):
             YouTube('https://youtube.com/watch?v=hZpzr8TbF08').streams

tests/test_helpers.py

@@ -3,18 +3,13 @@ import gzip
 import io
 import json
 import os
-from unittest import mock
-
 import pytest
+from unittest import mock
 
 from pytube import helpers
 from pytube.exceptions import RegexMatchError
-from pytube.helpers import cache
-from pytube.helpers import create_mock_html_json
-from pytube.helpers import deprecated
-from pytube.helpers import setup_logger
-from pytube.helpers import target_directory
-from pytube.helpers import uniqueify
+from pytube.helpers import cache, create_mock_html_json, deprecated, setup_logger
+from pytube.helpers import target_directory, uniqueify
 
 
 def test_regex_search_no_match():

tests/test_request.py

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
 import socket
 import os
+import pytest
 from unittest import mock
 from urllib.error import URLError
 
-import pytest
-
 from pytube import request
 from pytube.exceptions import MaxRetriesExceeded
 

tests/test_streams.py

@@ -1,14 +1,13 @@
 # -*- coding: utf-8 -*-
 import os
 import random
-from datetime import datetime
 import pytest
+from datetime import datetime
 from unittest import mock
 from unittest.mock import MagicMock, Mock
 from urllib.error import HTTPError
 
-from pytube import request
-from pytube import Stream
+from pytube import request, Stream
 
 
 @mock.patch("pytube.streams.request")