fixed cli logging

pytube/__main__.py

@@ -29,7 +29,7 @@ class YouTube(object):
     """Core developer interface for pytube."""
 
     def __init__(
-        self, url=None, defer_init=False, on_progress_callback=None,
+        self, url=None, defer_prefetch_init=False, on_progress_callback=None,
         on_complete_callback=None,
     ):
         """Construct a :class:`YouTube <YouTube>`.
@@ -74,11 +74,16 @@ class YouTube(object):
             'on_complete': on_complete_callback,
         }
 
-        if url and not defer_init:
-            self.init()
+        if url and not defer_prefetch_init:
+            self.prefetch_init()
+
+    def prefetch_init(self):
+        """Download data, descramble it, and build Stream instances."""
+        self.prefetch()
+        self.init()
 
     def init(self):
-        """Download data, descramble it, and build Stream instances.
+        """descramble the stream data and build Stream instances.
 
         The initialization process takes advantage of Python's
         "call-by-reference evaluation," which allows dictionary transforms to
@@ -86,7 +91,6 @@ class YouTube(object):
         interstitial step.
         """
         logger.info('init started')
-        self.prefetch()
 
         self.vid_info = {k: v for k, v in parse_qsl(self.vid_info)}
         self.player_config = extract.get_ytplayer_config(self.watch_html)

pytube/cli.py

@@ -4,12 +4,15 @@ from __future__ import absolute_import
 from __future__ import print_function
 
 import argparse
+import datetime as dt
+import gzip
 import json
 import logging
 import os
 import sys
 
 from pytube import __version__
+from pytube import request
 from pytube import YouTube
 
 
@@ -21,7 +24,7 @@ def main():
     parser = argparse.ArgumentParser(description=main.__doc__)
     parser.add_argument('url', help='The YouTube /watch url', nargs='?')
     parser.add_argument(
-        '-v', '--version', action='version',
+        '--version', action='version',
         version='%(prog)s ' + __version__,
     )
     parser.add_argument(
@@ -36,45 +39,59 @@ def main():
         ),
     )
     parser.add_argument(
-        '-v', '--verbose', action='count', default=0, dest='verbose_count',
+        '-v', '--verbose', action='count', default=0, dest='verbosity',
         help='Verbosity level',
     )
     parser.add_argument(
-        '--build-debug-report', action='store_true', help=(
+        '--build-playback-report', action='store_true', help=(
             'Save the html and js to disk'
         ),
     )
 
     args = parser.parse_args()
-    logger.setLevel(max(3 - args.verbose_count, 0) * 10)
+    logging.getLogger().setLevel(max(3 - args.verbosity, 0) * 10)
+
     if not args.url:
         parser.print_help()
         sys.exit(1)
+
     if args.list:
         display_streams(args.url)
-    elif args.build_debug_report:
-        build_debug_report(args.url)
+
+    elif args.build_playback_report:
+        build_playback_report(args.url)
+
     elif args.itag:
         download(args.url, args.itag)
 
 
-def build_debug_report(url):
+def build_playback_report(url):
     """Serialize the request data to json for offline debugging.
 
     :param str url:
         A valid YouTube watch URL.
     """
     yt = YouTube(url)
+    ts = int(dt.datetime.utcnow().timestamp())
     fp = os.path.join(
         os.getcwd(),
-        'yt-video-{yt.video_id}.json'.format(yt=yt),
+        'yt-video-{yt.video_id}-{ts}.json.tar.gz'.format(yt=yt, ts=ts),
     )
-    with open(fp, 'w') as fh:
-        fh.write(json.dumps({
-            'js': yt.js,
-            'watch_html': yt.watch_html,
-            'video_info': yt.vid_info,
-        }))
+    js, watch_html, vid_info = request.get(urls=[
+        yt.js_url,
+        yt.watch_url,
+        yt.vid_info_url,
+    ])
+    with gzip.open(fp, 'wb') as fh:
+        fh.write(
+            json.dumps({
+                'url': url,
+                'js': js,
+                'watch_html': watch_html,
+                'video_info': vid_info,
+            })
+            .encode('utf8'),
+        )
 
 
 def get_terminal_size():

pytube/helpers.py

@@ -29,7 +29,7 @@ def regex_search(pattern, string, groups=False, group=None, flags=0):
     results = regex.search(string)
     logger.debug(
         'finished regex search: %s',
-        pprint.pprint(
+        pprint.pformat(
             {
                 'pattern': pattern,
                 'results': results.group(0),

pytube/logging.py

@@ -5,7 +5,7 @@ from __future__ import absolute_import
 import logging
 
 
-def create_logger(level=logging.DEBUG):
+def create_logger(level=logging.ERROR):
     """Create a configured instance of logger.
 
     :param int level:

pytube/mixins.py

@@ -40,7 +40,7 @@ def apply_signature(config_args, fmt, js):
 
         logger.debug(
             'finished descrambling signature for itag=%s\n%s',
-            stream['itag'], pprint.pprint(
+            stream['itag'], pprint.pformat(
                 {
                     's': stream['s'],
                     'signature': signature,
@@ -63,4 +63,4 @@ def apply_descrambler(stream_data, key):
         {k: unquote(v) for k, v in parse_qsl(i)}
         for i in stream_data[key].split(',')
     ]
-    logger.debug('applying descrambler\n%s', pprint.pprint(stream_data[key]))
+    logger.debug('applying descrambler\n%s', pprint.pformat(stream_data[key]))

pytube/query.py

@@ -15,6 +15,8 @@ class StreamQuery:
             self, fps=None, res=None, resolution=None, mime_type=None,
             type=None, subtype=None, file_extension=None, abr=None,
             bitrate=None, video_codec=None, audio_codec=None,
+            only_audio=None, only_video=None,
+            progressive=None, adaptive=None,
             custom_filter_functions=None,
     ):
         """Apply the given filtering criterion.
@@ -43,6 +45,16 @@ class StreamQuery:
             (optional) Digital video compression format (e.g.: vp9, mp4v.20.3).
         :param str audio_codec:
             (optional) Digital audio compression format (e.g.: vorbis, mp4).
+        :param bool progressive:
+            Excludes adaptive streams (one file contains both audio and video
+            tracks).
+        :param bool adaptive:
+            Excludes progressive streams (audio and video are on separate
+            tracks).
+        :param bool only_audio:
+            Excludes streams with video tracks.
+        :param bool only_video:
+            Excludes streams with audio tracks.
         :param list custom_filter_functions:
             (optional) Interface for defining complex filters without
             subclassing.
@@ -73,6 +85,26 @@ class StreamQuery:
         if audio_codec:
             filters.append(lambda s: s.audio_codec == audio_codec)
 
+        if only_audio:
+            filters.append(
+                lambda s: (
+                    s.includes_audio_track and not s.includes_video_track
+                ),
+            )
+
+        if only_video:
+            filters.append(
+                lambda s: (
+                    s.includes_video_track and not s.includes_audio_track
+                ),
+            )
+
+        if progressive:
+            filters.append(lambda s: s.is_progressive)
+
+        if adaptive:
+            filters.append(lambda s: s.is_progressive)
+
         if custom_filter_functions:
             for fn in custom_filter_functions:
                 filters.append(fn)

pytube/streams.py

@@ -95,13 +95,22 @@ class Stream(object):
         return len(self.codecs) % 2
 
     @property
-    def is_audio(self):
-        """Whether the stream only contains audio (adaptive only)."""
+    def is_progressive(self):
+        """Whether the stream is progressive."""
+        return not self.is_adaptive
+
+    @property
+    def includes_audio_track(self):
+        """Whether the stream only contains audio."""
+        if self.is_progressive:
+            return True
         return self.type == 'audio'
 
     @property
-    def is_video(self):
-        """Whether the stream only contains video (adaptive only)."""
+    def includes_video_track(self):
+        """Whether the stream only contains video."""
+        if self.is_progressive:
+            return True
         return self.type == 'video'
 
     def parse_codecs(self):
@@ -117,9 +126,9 @@ class Stream(object):
         audio = None
         if not self.is_adaptive:
             video, audio = self.codecs
-        elif self.is_video:
+        elif self.includes_video_track:
             video = self.codecs[0]
-        elif self.is_audio:
+        elif self.includes_audio_track:
             audio = self.codecs[0]
         return video, audio
 
@@ -182,7 +191,7 @@ class Stream(object):
         file_handler.write(chunk)
         logger.debug(
             'download progress\n%s',
-            pprint.pprint(
+            pprint.pformat(
                 {
                     'chunk_size': len(chunk),
                     'bytes_remaining': bytes_remaining,
@@ -211,7 +220,7 @@ class Stream(object):
         """Printable object representation."""
         # TODO(nficano): this can probably be written better.
         parts = ['itag="{s.itag}"', 'mime_type="{s.mime_type}"']
-        if self.is_video:
+        if self.includes_video_track:
             parts.extend(['res="{s.resolution}"', 'fps="{s.fps}fps"'])
             if not self.is_adaptive:
                 parts.extend([

tests/conftest.py

@@ -18,7 +18,7 @@ def gangnam_style():
         video = json.loads(fh.read())
     yt = YouTube(
         url='https://www.youtube.com/watch?v=9bZkp7q19f0',
-        defer_init=True,
+        defer_prefetch_init=True,
     )
     yt.watch_html = video['watch_html']
     yt.js = video['js']