add-trailing-comma

.pre-commit-config.yaml

@@ -20,3 +20,7 @@
     sha: v1.1.0
     hooks:
     -   id: python-safety-dependencies-check
+-   repo: https://github.com/asottile/add-trailing-comma
+    sha: v0.6.4
+    hooks:
+    -   id: add-trailing-comma

pytube/__main__.py

@@ -17,19 +17,19 @@ def main():
     parser = argparse.ArgumentParser(description='YouTube video downloader')
     parser.add_argument(
         'url',
-        help='The URL of the Video to be downloaded'
+        help='The URL of the Video to be downloaded',
     )
     parser.add_argument(
         '--extension',
         '-e',
         dest='ext',
-        help='The requested format of the video'
+        help='The requested format of the video',
     )
     parser.add_argument(
         '--resolution',
         '-r',
         dest='res',
-        help='The requested resolution'
+        help='The requested resolution',
     )
     parser.add_argument(
         '--path',
@@ -37,7 +37,7 @@ def main():
         action=FullPaths,
         default=os.getcwd(),
         dest='path',
-        help='The path to save the video to.'
+        help='The path to save the video to.',
     )
     parser.add_argument(
         '--filename',
@@ -50,7 +50,7 @@ def main():
         '-s',
         action='store_true',
         dest='show_available',
-        help='Prints a list of available formats for download.'
+        help='Prints a list of available formats for download.',
     )
 
     args = parser.parse_args()
@@ -75,8 +75,10 @@ def main():
 
     if args.ext or args.res:
         if not all([args.ext, args.res]):
-            print('Make sure you give either of the below specified '
-                  'format/resolution combination.')
+            print(
+                'Make sure you give either of the below specified '
+                'format/resolution combination.',
+            )
             print_available_vids(videos)
             sys.exit(1)
 
@@ -85,8 +87,10 @@ def main():
         vid = yt.get(args.ext, args.res)
         # Check if there's a video returned
         if not vid:
-            print("There's no video with the specified format/resolution "
-                  'combination.')
+            print(
+                "There's no video with the specified format/resolution "
+                'combination.',
+            )
             pprint(videos)
             sys.exit(1)
 
@@ -104,8 +108,10 @@ def main():
         videos = yt.filter(resolution=args.res)
         # Check if we have a video
         if not videos:
-            print('There are no videos in the specified in the specified '
-                  'resolution.')
+            print(
+                'There are no videos in the specified in the specified '
+                'resolution.',
+            )
             sys.exit(1)
         # Select the highest resolution one
         vid = max(videos)
@@ -134,8 +140,10 @@ def print_available_vids(videos):
     formatString = '{:<2} {:<15} {:<15}'
     print(formatString.format('', 'Resolution', 'Extension'))
     print('-' * 28)
-    print('\n'.join([formatString.format(index, *formatTuple)
-                     for index, formatTuple in enumerate(videos)]))
+    print('\n'.join([
+        formatString.format(index, *formatTuple)
+        for index, formatTuple in enumerate(videos)
+    ]))
 
 
 if __name__ == '__main__':

pytube/api.py

@@ -67,7 +67,7 @@ QUALITY_PROFILES = {
     303: ('webm', '1080p HFR', 'vp9', 'n/a', '5', '', ''),
     308: ('webm', '1440p HFR', 'vp9', 'n/a', '10', '', ''),
     313: ('webm', '2160p', 'vp9', 'n/a', '13-15', '', ''),
-    315: ('webm', '2160p HFR', 'vp9', 'n/a', '20-25', '', '')
+    315: ('webm', '2160p HFR', 'vp9', 'n/a', '20-25', '', ''),
 }
 
 # The keys corresponding to the quality/codec map above.
@@ -78,7 +78,7 @@ QUALITY_PROFILE_KEYS = (
     'profile',
     'video_bitrate',
     'audio_codec',
-    'audio_bitrate'
+    'audio_bitrate',
 )
 
 
@@ -112,8 +112,10 @@ class YouTube(object):
         :param str url:
             The url to the YouTube video.
         """
-        warnings.warn('url setter deprecated, use `from_url()` '
-                      'instead.', DeprecationWarning)
+        warnings.warn(
+            'url setter deprecated, use `from_url()` '
+            'instead.', DeprecationWarning,
+        )
         self.from_url(url)
 
     @property
@@ -144,8 +146,10 @@ class YouTube(object):
         :param str filename:
             The filename of the video.
         """
-        warnings.warn('filename setter deprecated. Use `set_filename()` '
-                      'instead.', DeprecationWarning)
+        warnings.warn(
+            'filename setter deprecated. Use `set_filename()` '
+            'instead.', DeprecationWarning,
+        )
         self.set_filename(filename)
 
     def set_filename(self, filename):
@@ -171,8 +175,10 @@ class YouTube(object):
         """Gets all videos. (This method is deprecated. Use `get_videos()`
         instead.
         """
-        warnings.warn('videos property deprecated. Use `get_videos()` '
-                      'instead.', DeprecationWarning)
+        warnings.warn(
+            'videos property deprecated. Use `get_videos()` '
+            'instead.', DeprecationWarning,
+        )
         return self._videos
 
     def from_url(self, url):
@@ -222,8 +228,10 @@ class YouTube(object):
             # Check if we have the signature, otherwise we'll need to get the
             # cipher from the js.
             if 'signature=' not in url:
-                log.debug('signature not in url, attempting to resolve the '
-                          'cipher.')
+                log.debug(
+                    'signature not in url, attempting to resolve the '
+                    'cipher.',
+                )
                 signature = self._get_cipher(stream_map['s'][i], js_url)
                 url = '{0}&signature={1}'.format(url, signature)
             self._add_video(url, self.filename, **quality_profile)
@@ -300,8 +308,10 @@ class YouTube(object):
             restriction_pattern = bytes('og:restrictions:age', 'utf-8')
 
         if restriction_pattern in html:
-            raise AgeRestricted('Age restricted video. Unable to download '
-                                'without being signed in.')
+            raise AgeRestricted(
+                'Age restricted video. Unable to download '
+                'without being signed in.',
+            )
 
         # Extract out the json data from the html response body.
         json_object = self._get_json_data(html)
@@ -309,9 +319,11 @@ class YouTube(object):
         # Here we decode the stream map and bundle it into the json object. We
         # do this just so we just can return one object for the video data.
         encoded_stream_map = json_object.get('args', {}).get(
-            'url_encoded_fmt_stream_map')
+            'url_encoded_fmt_stream_map',
+        )
         json_object['args']['stream_map'] = self._parse_stream_map(
-            encoded_stream_map)
+            encoded_stream_map,
+        )
         return json_object
 
     def _parse_stream_map(self, blob):
@@ -441,8 +453,10 @@ class YouTube(object):
             raise PytubeError('Unable to get encoding profile, no itag found.')
         elif len(itag) > 1:
             log.warn('Multiple itags found: %s', itag)
-            raise PytubeError('Unable to get encoding profile, multiple itags '
-                              'found.')
+            raise PytubeError(
+                'Unable to get encoding profile, multiple itags '
+                'found.',
+            )
         return False
 
     def _add_video(self, url, filename, **kwargs):

pytube/jsinterp.py

@@ -71,7 +71,8 @@ class JSInterpreter(object):
                     if parens_count == 0:
                         sub_expr = expr[1:m.start()]
                         sub_result = self.interpret_expression(
-                            sub_expr, local_vars, allow_recursion)
+                            sub_expr, local_vars, allow_recursion,
+                        )
                         remaining_expr = expr[m.end():].strip()
                         if not remaining_expr:
                             return sub_result
@@ -82,19 +83,23 @@ class JSInterpreter(object):
                 raise ExtractorError('Premature end of parens in %r' % expr)
 
         for op, opfunc in _ASSIGN_OPERATORS:
-            m = re.match(r'''(?x)
+            m = re.match(
+                r'''(?x)
                 (?P<out>%s)(?:\[(?P<index>[^\]]+?)\])?
                 \s*%s
-                (?P<expr>.*)$''' % (_NAME_RE, re.escape(op)), expr)
+                (?P<expr>.*)$''' % (_NAME_RE, re.escape(op)), expr,
+            )
             if not m:
                 continue
             right_val = self.interpret_expression(
-                m.group('expr'), local_vars, allow_recursion - 1)
+                m.group('expr'), local_vars, allow_recursion - 1,
+            )
 
             if m.groupdict().get('index'):
                 lvar = local_vars[m.group('out')]
                 idx = self.interpret_expression(
-                    m.group('index'), local_vars, allow_recursion)
+                    m.group('index'), local_vars, allow_recursion,
+                )
                 assert isinstance(idx, int)
                 cur = lvar[idx]
                 val = opfunc(cur, right_val)
@@ -111,7 +116,8 @@ class JSInterpreter(object):
 
         var_m = re.match(
             r'(?!if|return|true|false)(?P<name>%s)$' % _NAME_RE,
-            expr)
+            expr,
+        )
         if var_m:
             return local_vars[var_m.group('name')]
 
@@ -123,7 +129,8 @@ class JSInterpreter(object):
         m = re.match(
             r'(?P<var>%s)\.(?P<member>[^(]+)'
             '(?:\(+(?P<args>[^()]*)\))?$' % _NAME_RE,
-            expr)
+            expr,
+        )
         if m:
             variable = m.group('var')
             member = m.group('member')
@@ -149,7 +156,8 @@ class JSInterpreter(object):
             else:
                 argvals = tuple([
                     self.interpret_expression(v, local_vars, allow_recursion)
-                    for v in arg_str.split(',')])
+                    for v in arg_str.split(',')
+                ])
 
             if member == 'split':
                 assert argvals == ('',)
@@ -175,11 +183,13 @@ class JSInterpreter(object):
             return obj[member](argvals)
 
         m = re.match(
-            r'(?P<in>%s)\[(?P<idx>.+)\]$' % _NAME_RE, expr)
+            r'(?P<in>%s)\[(?P<idx>.+)\]$' % _NAME_RE, expr,
+        )
         if m:
             val = local_vars[m.group('in')]
             idx = self.interpret_expression(
-                m.group('idx'), local_vars, allow_recursion - 1)
+                m.group('idx'), local_vars, allow_recursion - 1,
+            )
             return val[idx]
 
         for op, opfunc in _OPERATORS:
@@ -187,24 +197,30 @@ class JSInterpreter(object):
             if not m:
                 continue
             x, abort = self.interpret_statement(
-                m.group('x'), local_vars, allow_recursion - 1)
+                m.group('x'), local_vars, allow_recursion - 1,
+            )
             if abort:
                 raise ExtractorError(
-                    'Premature left-side return of %s in %r' % (op, expr))
+                    'Premature left-side return of %s in %r' % (op, expr),
+                )
             y, abort = self.interpret_statement(
-                m.group('y'), local_vars, allow_recursion - 1)
+                m.group('y'), local_vars, allow_recursion - 1,
+            )
             if abort:
                 raise ExtractorError(
-                    'Premature right-side return of %s in %r' % (op, expr))
+                    'Premature right-side return of %s in %r' % (op, expr),
+                )
             return opfunc(x, y)
 
         m = re.match(
-            r'^(?P<func>%s)\((?P<args>[a-zA-Z0-9_$,]+)\)$' % _NAME_RE, expr)
+            r'^(?P<func>%s)\((?P<args>[a-zA-Z0-9_$,]+)\)$' % _NAME_RE, expr,
+        )
         if m:
             fname = m.group('func')
             argvals = tuple([
                 int(v) if v.isdigit() else local_vars[v]
-                for v in m.group('args').split(',')])
+                for v in m.group('args').split(',')
+            ])
             if fname not in self._functions:
                 self._functions[fname] = self.extract_function(fname)
             return self._functions[fname](argvals)
@@ -217,17 +233,20 @@ class JSInterpreter(object):
             (r'(?:var\s+)?%s\s*=\s*\{' % re.escape(objname)) +
             r'\s*(?P<fields>([a-zA-Z$0-9]+\s*:\s*function\(.*?\)\s*\{.*?\}'
             r'(?:,\s*)?)*)' + r'\}\s*;',
-            self.code)
+            self.code,
+        )
         fields = obj_m.group('fields')
         # Currently, it only supports function definitions
         fields_m = re.finditer(
             r'(?P<key>[a-zA-Z$0-9]+)\s*:\s*function'
             r'\((?P<args>[a-z,]+)\){(?P<code>[^}]+)}',
-            fields)
+            fields,
+        )
         for f in fields_m:
             argnames = f.group('args').split(',')
             obj[f.group('key')] = self.build_function(
-                argnames, f.group('code'))
+                argnames, f.group('code'),
+            )
 
         return obj
 
@@ -237,8 +256,10 @@ class JSInterpreter(object):
                 (?:function\s+%s|[{;,]\s*%s\s*=\s*function|var\s+%s\s*=\s*function)\s*
                 \((?P<args>[^)]*)\)\s*
                 \{(?P<code>[^}]+)\}''' % (
-                re.escape(funcname), re.escape(funcname), re.escape(funcname)),
-            self.code)
+                re.escape(funcname), re.escape(funcname), re.escape(funcname),
+            ),
+            self.code,
+        )
         if func_m is None:
             raise ExtractorError('Could not find JS function %r' % funcname)
         argnames = func_m.group('args').split(',')

pytube/models.py

@@ -15,9 +15,11 @@ class Video(object):
     """Class representation of a single instance of a YouTube video.
     """
 
-    def __init__(self, url, filename, extension, resolution=None,
-                 video_codec=None, profile=None, video_bitrate=None,
-                 audio_codec=None, audio_bitrate=None):
+    def __init__(
+        self, url, filename, extension, resolution=None,
+        video_codec=None, profile=None, video_bitrate=None,
+        audio_codec=None, audio_bitrate=None,
+    ):
         """Sets-up the video object.
 
         :param str url:
@@ -49,8 +51,10 @@ class Video(object):
         self.audio_codec = audio_codec
         self.audio_bitrate = audio_bitrate
 
-    def download(self, path, chunk_size=8 * 1024, on_progress=None,
-                 on_finish=None, force_overwrite=False):
+    def download(
+        self, path, chunk_size=8 * 1024, on_progress=None,
+        on_finish=None, force_overwrite=False,
+    ):
         """Downloads the video.
 
         :param str path:
@@ -110,7 +114,8 @@ class Video(object):
             # to disable this.
             os.remove(path)
             raise KeyboardInterrupt(
-                'Interrupt signal given. Deleting incomplete video.')
+                'Interrupt signal given. Deleting incomplete video.',
+            )
 
     def file_size(self, response):
         """Gets the file size from the response
@@ -125,7 +130,8 @@ class Video(object):
     def __repr__(self):
         """A clean representation of the class instance."""
         return '<Video: {0} (.{1}) - {2} - {3}>'.format(
-            self.video_codec, self.extension, self.resolution, self.profile)
+            self.video_codec, self.extension, self.resolution, self.profile,
+        )
 
     def __lt__(self, other):
         """The "less than" (lt) method is used for comparing video object to

pytube/utils.py

@@ -34,8 +34,10 @@ def safe_filename(text, max_length=200):
 
     # Removing these SHOULD make most filename safe for a wide range of
     # operating systems.
-    paranoid = ['\"', '\#', '\$', '\%', '\'', '\*', '\,', '\.', '\/', '\:',
-                '\;', '\<', '\>', '\?', '\\', '\^', '\|', '\~', '\\\\']
+    paranoid = [
+        '\"', '\#', '\$', '\%', '\'', '\*', '\,', '\.', '\/', '\:',
+        '\;', '\<', '\>', '\?', '\\', '\^', '\|', '\~', '\\\\',
+    ]
 
     blacklist = re.compile('|'.join(ntfs + paranoid), re.UNICODE)
     filename = blacklist.sub('', text)
@@ -73,6 +75,8 @@ def print_status(progress, file_size, start):
     dt = (clock() - start)
     if dt > 0:
         stdout.write('\r  [%s%s][%3.2f%%] %s at %s/s ' %
-                     ('=' * done, ' ' * (50 - done), percent_done,
-                      sizeof(file_size), sizeof(progress // dt)))
+                     (
+                         '=' * done, ' ' * (50 - done), percent_done,
+                         sizeof(file_size), sizeof(progress // dt),
+                     ))
     stdout.flush()