pydocstyle

pytube/__init__.py

@@ -2,12 +2,11 @@
 # flake8: noqa
 # noreorder
 """
-pytube.__init__
-~~~~~~~~~~~~~~~
+Pytube is a Python library for downloading YouTube Videos.
+
+Pytube aims to be lightweight, dependency-free, extensively documented and
+follows best practice patterns.
 
-A lightweight, dependency-free Python library (and command-line utility) for
-downloading YouTube Videos. It's extensively documented and follows best
-practice patterns.
 """
 __title__ = 'pytube'
 __version__ = '6.4.3'

pytube/__main__.py

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
 """
-pytube.__main__
-~~~~~~~~~~~~~~~
+This module implements the core developer interface for pytube.
 
-This module implements the core developer interface for pytube. This class does
-minimal heavy lifting and instead relies on many small (mostly pure) functions
-to handle the extraction, pattern matching, etc. to make testing easier.
+The problem domain of the :class:`YouTube <YouTube> class focuses almost
+exclusively on the developer interface. Pytube offloads the heavy lifting to
+smaller peripheral modules and functions.
 
 """
 from __future__ import absolute_import
@@ -27,12 +26,13 @@ logger = logging.getLogger(__name__)
 
 
 class YouTube(object):
+    """Core developer interface for pytube."""
 
     def __init__(
         self, url=None, defer_init=False, on_progress_callback=None,
         on_complete_callback=None,
     ):
-        """Constructs a :class:`YouTube <YouTube>`.
+        """Construct a :class:`YouTube <YouTube>`.
 
         :param str url:
             A valid YouTube watch URL.
@@ -69,7 +69,7 @@ class YouTube(object):
         # A dictionary shared between all instances of :class:`Stream <Stream>`
         # (Borg pattern).
         self.stream_monostate = {
-            # user defined callback functions
+            # user defined callback functions.
             'on_progress': on_progress_callback,
             'on_complete': on_complete_callback,
         }
@@ -78,9 +78,12 @@ class YouTube(object):
             self.init()
 
     def init(self):
-        """Makes all necessary network requests, data transforms, and popluates
-        the instances of :class:`Stream <Stream>`.
+        """Download data, descramble it, and build Stream instances.
 
+        The initialization process takes advantage of Python's
+        "call-by-reference evaluation," which allows dictionary transforms to
+        be applied in-place, instead of holding references to mutations at each
+        interstitial step.
         """
         logger.info('init started')
         self.prefetch()
@@ -111,7 +114,9 @@ class YouTube(object):
         logger.info('init finished successfully')
 
     def prefetch(self):
-        """Eagerly executes all necessary network requests so all other
+        """Eagerly download all necessary data.
+
+        Eagerly executes all necessary network requests so all other
         operations don't does need to make calls outside of the interpreter
         which blocks for long periods of time.
 
@@ -129,7 +134,9 @@ class YouTube(object):
         ])
 
     def initialize_stream_objects(self, fmt):
-        """Takes the unscrambled stream data and uses it to initialize
+        """Convert manifest data to instances of :class:`Stream <Stream>`.
+
+        Take the unscrambled stream data and uses it to initialize
         instances of :class:`Stream <Stream>` for each media stream.
 
         :param str fmt:
@@ -166,8 +173,7 @@ class YouTube(object):
         return StreamQuery([s for s in self.fmt_streams])
 
     def register_on_progress_callback(self, func):
-        """Registers an on download progess callback function after object
-        initialization.
+        """Register a download progess callback function post initialization.
 
         :param callable func:
             A callback function that takes ``stream``, ``chunk``,
@@ -176,8 +182,7 @@ class YouTube(object):
         self._monostate['on_progress'] = func
 
     def register_on_complete_callback(self, func):
-        """Registers an on download complete callback function after object
-        initialization.
+        """Register a download complete callback function post initialization.
 
         :param callable func:
             A callback function that takes ``stream`` and  ``file_handle``.

pytube/cipher.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-pytube.cipher
-~~~~~~~~~~~~~
+This module countains all logic necessary to decipher the signature.
 
 YouTube's strategy to restrict downloading videos is to send a ciphered version
 of the signature to the client, along with the decryption algorithm obfuscated
@@ -14,6 +13,7 @@ signature sent in the GET parameters is valid, and then returns the content
 This module is responsible for (1) finding and extracting those "transform
 functions" (2) maps them to Python equivalents and (3) taking the ciphered
 signature and decoding it.
+
 """
 from __future__ import absolute_import
 
@@ -31,7 +31,7 @@ logger = logging.getLogger(__name__)
 
 
 def get_initial_function_name(js):
-    """Extracts the name of the function responsible for computing the signature.
+    """Extract the name of the function responsible for computing the signature.
 
     :param str js:
         The contents of the base.js asset file.
@@ -44,8 +44,10 @@ def get_initial_function_name(js):
 
 
 def get_transform_plan(js):
-    """Extracts the "transform plan", that is, the functions the original
-    signature is passed through to decode the actual signature.
+    """Extract the "transform plan".
+
+    The "transform plan" is the functions the ciphered signature is passed
+    through to obtain the actual signature.
 
     :param str js:
         The contents of the base.js asset file.
@@ -69,11 +71,12 @@ def get_transform_plan(js):
 
 
 def get_transform_object(js, var):
-    """Extracts the "transform object" which contains the function definitions
-    referenced in the "transform plan". The ``var`` argument is the obfuscated
-    variable name which contains these functions, for example, given the
-    function call ``DE.AJ(a,15)`` returned by the transform plan, "DE" would be
-    the var.
+    """Extract the "transform object".
+
+    The "transform object" contains the function definitions referenced in the
+    "transform plan". The ``var`` argument is the obfuscated variable name
+    which contains these functions, for example, given the function call
+    ``DE.AJ(a,15)`` returned by the transform plan, "DE" would be the var.
 
     :param str js:
         The contents of the base.js asset file.
@@ -99,7 +102,9 @@ def get_transform_object(js, var):
 
 @memoize
 def get_transform_map(js, var):
-    """Builds a lookup table of obfuscated JavaScript function names to the
+    """Build a transform function lookup.
+
+    Build a lookup table of obfuscated JavaScript function names to the
     Python equivalents.
 
     :param str js:
@@ -120,9 +125,12 @@ def get_transform_map(js, var):
 
 
 def reverse(arr, b):
-    """Immutable equivalent to function(a, b) { a.reverse() }. This method
-    takes an unused ``b`` variable as their transform functions universally
-    sent two arguments.
+    """Reverse elements in a list.
+
+    This function is equivalent to: function(a, b) { a.reverse() }.
+
+    This method takes an unused ``b`` variable as their transform functions
+    universally sent two arguments.
 
     Example usage:
     ~~~~~~~~~~~~~~
@@ -133,7 +141,9 @@ def reverse(arr, b):
 
 
 def splice(arr, b):
-    """Immutable equivalent to function(a, b) { a.splice(0, b) }.
+    """Add/remove items to/from a list.
+
+    This function is equivalent to: function(a, b) { a.splice(0, b) }.
 
     Example usage:
     ~~~~~~~~~~~~~~
@@ -144,7 +154,9 @@ def splice(arr, b):
 
 
 def swap(arr, b):
-    """Immutable equivalent to:
+    """Swap positions at b modulus the list length.
+
+    This function is equivalent to:
     function(a, b) { var c=a[0];a[0]=a[b%a.length];a[b]=c }.
 
     Example usage:
@@ -182,7 +194,9 @@ def map_functions(js_func):
 
 
 def parse_function(js_func):
-    """Breaks a JavaScript transform function down into a two element tuple
+    """Parse the Javascript transform function.
+
+    Break a JavaScript transform function down into a two element tuple
     containing the function name and some integer-based argument.
 
     Sample Input:
@@ -204,7 +218,9 @@ def parse_function(js_func):
 
 @memoize
 def get_signature(js, ciphered_signature):
-    """Taking the ciphered signature, applies the transform functions and
+    """Decipher the signature.
+
+    Taking the ciphered signature, applies the transform functions and
     returns the decrypted version.
 
     :param str js:

pytube/cli.py

@@ -1,11 +1,5 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.cli
-~~~~~~~~~~
-
-A simple command line application to download youtube videos.
-
-"""
+"""A simple command line application to download youtube videos."""
 from __future__ import print_function
 
 import argparse
@@ -16,7 +10,7 @@ from pytube import YouTube
 
 
 def main():
-    """A simple command line application to download youtube videos."""
+    """Command line application to download youtube videos."""
     parser = argparse.ArgumentParser(description=main.__doc__)
     parser.add_argument('url', help='The YouTube /watch url', nargs='?')
     parser.add_argument(
@@ -41,13 +35,13 @@ def main():
 
 
 def get_terminal_size():
-    """Returns the terminal size in rows and columns."""
+    """Return the terminal size in rows and columns."""
     rows, columns = os.popen('stty size', 'r').read().split()
     return int(rows), int(columns)
 
 
 def display_progress_bar(bytes_received, filesize, ch='█', scale=0.55):
-    """Displays a simple, pretty progress bar.
+    """Display a simple, pretty progress bar.
 
     Example:
     ~~~~~~~~
@@ -94,7 +88,7 @@ def on_progress(stream, file_handle, bytes_remaining):
 
 
 def download(url, itag):
-    """Begin downloading a YouTube video.
+    """Start downloading a YouTube video.
 
     :param str url:
         A valid YouTube watch URL.
@@ -115,7 +109,7 @@ def download(url, itag):
 
 
 def display_streams(url):
-    """Probes YouTube video and lists its available formats.
+    """Probe YouTube video and lists its available formats.
 
     :param str url:
         A valid YouTube watch URL.

pytube/compat.py

@@ -1,12 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # flake8: noqa
-"""
-pytube.compat
-~~~~~~~~~~~~~
-
-Some py2/py3 compatibility support.
-"""
+"""Python 2/3 compatibility support."""
 import sys
 
 python_version = sys.version_info[0]

pytube/exceptions.py

@@ -1,10 +1,5 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.exceptions
-~~~~~~~~~~~~~~~~~
-
-pytube specific exception definitions.
-"""
+"""Library specific exception definitions."""
 import socket
 import sys
 from traceback import format_tb
@@ -13,9 +8,11 @@ from pytube.compat import URLError
 
 
 class PytubeError(Exception):
-    """Base pytube exception that all others inherent. This is done to not
-    pollute the built-in exceptions, which *could* result in unintended errors
-    being unexpectedly and incorrectly handled within implementers code.
+    """Base pytube exception that all others inherent.
+
+    This is done to not pollute the built-in exceptions, which *could* result
+    in unintended errors being unexpectedly and incorrectly handled within
+    implementers code.
     """
 
 
@@ -23,8 +20,7 @@ class ExtractError(PytubeError):
     """Data extraction based exception."""
 
     def __init__(self, msg, tb=None, expected=False, video_id=None):
-        """Constructs an instance of a :class:`ExtractError <ExtractError>`
-        exception.
+        """Construct an instance of a :class:`ExtractError <ExtractError>`.
 
         :param str msg:
             User defined error message.
@@ -56,7 +52,7 @@ class ExtractError(PytubeError):
         self.video_id = video_id
 
     def format_traceback(self):
-        """Pretty-print traceback"""
+        """Pretty-print the traceback."""
         if self.traceback:
             return ''.join(format_tb(self.traceback))
 

pytube/extract.py

@@ -1,11 +1,5 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.extract
-~~~~~~~~~~~~~~
-
-This module is responsible for all non-cipher related data extraction
-(primarily used during data pre-fetching).
-"""
+"""This module contains all non-cipher related data extraction logic."""
 import json
 
 from pytube.compat import quote
@@ -15,7 +9,7 @@ from pytube.helpers import regex_search
 
 
 def video_id(url):
-    """The ``video_id`` part of /watch?v=<video_id>.
+    """Extract the ``video_id`` part of /watch?v=<video_id>.
 
     :param str url:
         A url YouTube id containing a video_id.
@@ -25,7 +19,7 @@ def video_id(url):
 
 
 def watch_url(video_id):
-    """Constructs a YouTube Watch url, given a video id.
+    """Construct a YouTube watch url, given a video id.
 
     :param str video_id:
         A YouTube video identifer.
@@ -35,7 +29,7 @@ def watch_url(video_id):
 
 
 def video_info_url(video_id, watch_url, watch_html):
-    """Contructs the video_info URL.
+    """Contruct the video_info url.
 
     :param str video_id:
         A YouTube video identifer.
@@ -61,8 +55,10 @@ def video_info_url(video_id, watch_url, watch_html):
 
 
 def js_url(watch_html):
-    """Constructs the base JavaScript url, which contains the decipher
-    transforms.
+    """Get the base JavaScript url.
+
+    Construct the base JavaScript url, which contains the decipher
+    "transforms".
 
     :param str watch_html:
         The html contents of the watch page.
@@ -74,9 +70,11 @@ def js_url(watch_html):
 
 
 def mime_type_codec(mime_type_codec):
-    """Parses the type data, which contains mime type and codecs serialized
-    together (e.g.: 'audio/webm; codecs="opus"'), and splits them into
-    separate elements. (e.g.: 'audio/webm', ['opus'])
+    """Parse the type data.
+
+    Breaks up the data in the ``type`` key of the manifest, which contains mime
+    type and codecs serialized together (e.g.: 'audio/webm; codecs="opus"'),
+    and splits them into separate elements. (e.g.: 'audio/webm', ['opus'])
 
     :param str mime_type_codec:
         String containing mime type and codecs.
@@ -89,8 +87,11 @@ def mime_type_codec(mime_type_codec):
 
 @memoize
 def get_ytplayer_config(watch_html):
-    """The ``ytplayer_config`` is json data embedded within the watch html and
-    serves as the primary source of obtaining the stream manifest data.
+    """Get the YouTube player configuration data from the watch html.
+
+    Extract the ``ytplayer_config``, which is json data embedded within the
+    watch html and serves as the primary source of obtaining the stream
+    manifest data.
 
     :param str watch_html:
         The html contents of the watch page.

pytube/helpers.py

@@ -1,11 +1,5 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.helpers
-~~~~~~~~~~~~~~
-
-Various helper functions implemented by pytube.
-
-"""
+"""Various helper functions implemented by pytube."""
 from __future__ import absolute_import
 
 import functools
@@ -57,7 +51,7 @@ def regex_search(pattern, string, groups=False, group=None, flags=0):
 
 
 def apply_mixin(dct, key, func, *args, **kwargs):
-    """Applies an in-place data mutation to a dictionary.
+    r"""Apply in-place data mutation to a dictionary.
 
     :param dict dct:
         Dictionary to apply mixin function to.
@@ -74,15 +68,16 @@ def apply_mixin(dct, key, func, *args, **kwargs):
 
 
 def safe_filename(s, max_length=255):
-    """Attempts to sanitize an arbitrary string making it safe to use as a
-    filename (see: https://en.wikipedia.org/wiki/Filename).
+    """Sanitize a string making it safe to use as a filename.
+
+    This function was based off the limitations outlined here:
+    https://en.wikipedia.org/wiki/Filename.
 
     :param str text:
         A string to make safe for use as a file name.
     :param int max_length:
         The maximum filename character length.
     """
-
     # Characters in range 0-31 (0x00-0x1F) are not allowed in NTFS filenames.
     ntfs_chrs = [chr(i) for i in range(0, 31)]
     chrs = [
@@ -96,9 +91,7 @@ def safe_filename(s, max_length=255):
 
 
 def memoize(func):
-    """A function decorator that caches input arguments for return values, to
-    avoid recomputation on repeat calls.
-    """
+    """Decorate that caches input arguments for return values."""
     cache = func.cache = {}
 
     @functools.wraps(func)

pytube/itags.py

@@ -1,11 +1,5 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.itags
-~~~~~~~~~~~~
-
-This module contains a lookup table of YouTube's format identifier codes
-(itags) to some additional meta data not specified in the media manifest.
-"""
+"""This module contains a lookup table of YouTube's itag values."""
 
 ITAGS = {
     5: ('240p', '64kbps'),
@@ -97,7 +91,7 @@ LIVE = [91, 92, 93, 94, 95, 96, 132, 151]
 
 
 def get_format_profile(itag):
-    """Returns additional format information for a given itag.
+    """Get dditional format information for a given itag.
 
     :param str itag:
         YouTube format identifier code.

pytube/logging.py

@@ -1,16 +1,16 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.logging
-~~~~~~~~~~~~~~
-
-This module implements a log factory.
-"""
+"""This module implements a log factory."""
 from __future__ import absolute_import
 
 import logging
 
 
 def create_logger(level=logging.DEBUG):
+    """Create a configured instance of logger.
+
+    :param int level:
+        Describe the severity level of the logs to handle.
+    """
     fmt = '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
     date_fmt = '%H:%M:%S'
     formatter = logging.Formatter(fmt, datefmt=date_fmt)

pytube/mixins.py

@@ -1,11 +1,5 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.mixins
-~~~~~~~~~~~~~
-
-Applies in-place data mutations.
-
-"""
+"""Applies in-place data mutations."""
 from __future__ import absolute_import
 
 import logging
@@ -20,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 
 def apply_signature(config_args, fmt, js):
-    """Applies the decrypted signature to the stream manifest.
+    """Apply the decrypted signature to the stream manifest.
 
     :param dict config_args:
         Details of the media streams available.
@@ -57,7 +51,7 @@ def apply_signature(config_args, fmt, js):
 
 
 def apply_descrambler(stream_data, key):
-    """Applies various in-place transforms to YouTube's media stream data.
+    """Apply various in-place transforms to YouTube's media stream data.
 
     :param dict dct:
         Dictionary containing query string encoded values.

pytube/query.py

@@ -1,19 +1,12 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.query
-~~~~~~~~~~~~
-
-The :class:`StreamQuery <StreamQuery>` class provides an interface for querying
-the available media streams.
-"""
+"""This module provides a query interface for media streams."""
 
 
 class StreamQuery:
+    """Interface for querying the available media streams."""
 
     def __init__(self, fmt_streams):
-        """Constructs a :class:`StreamQuery <StreamQuery>`.
-        """
-
+        """Construct a :class:`StreamQuery <StreamQuery>`."""
         # list of :class:`Stream <Stream>` instances.
         self.fmt_streams = fmt_streams
         self.itag_index = {int(s.itag): s for s in fmt_streams}
@@ -24,8 +17,7 @@ class StreamQuery:
             bitrate=None, video_codec=None, audio_codec=None,
             custom_filter_functions=None,
     ):
-        """Apply the given filtering criterion to a copy of this
-        :class:`StreamQuery <StreamQuery>`.
+        """Apply the given filtering criterion.
 
         :param int fps:
             (optional) The frames per second (30 or 60)
@@ -54,6 +46,7 @@ class StreamQuery:
         :param list custom_filter_functions:
             (optional) Interface for defining complex filters without
             subclassing.
+
         """
         filters = []
         if res or resolution:
@@ -90,10 +83,11 @@ class StreamQuery:
         return StreamQuery(fmt_streams)
 
     def get_by_itag(self, itag):
-        """Return an instance based on the given itag, or None if not found.
+        """Get a :class:`Stream <Stream>` for an itag, or None if not found.
 
         :param str itag:
             YouTube format identifier code.
+
         """
         try:
             return self.itag_index[itag]
@@ -101,7 +95,9 @@ class StreamQuery:
             pass
 
     def first(self):
-        """Return the first result of this query or None if the result doesn't
+        """Get the first element in the results.
+
+        Return the first result of this query or None if the result doesn't
         contain any streams.
 
         """
@@ -111,7 +107,9 @@ class StreamQuery:
             pass
 
     def last(self):
-        """Return the last result of this query or None if the result doesn't
+        """Get the last element in the results.
+
+        Return the last result of this query or None if the result doesn't
         contain any streams.
 
         """
@@ -121,9 +119,9 @@ class StreamQuery:
             pass
 
     def count(self):
-        """Return the count the query would return."""
+        """Get the count the query would return."""
         return len(self.fmt_streams)
 
     def all(self):
-        """Return the results represented by this query as a list."""
+        """Get all the results represented by this query as a list."""
         return self.fmt_streams

pytube/request.py

@@ -1,10 +1,5 @@
 # -*- coding: utf-8 -*-
-"""
-pytube.request
-~~~~~~~~~~~~~~
-
-Implements a simple wrapper around urlopen.
-"""
+"""Implements a simple wrapper around urlopen."""
 import multiprocessing
 
 from pytube.compat import urlopen
@@ -14,7 +9,7 @@ def get(
     url=None, urls=[], processes=2, headers=False,
     streaming=False, chunk_size=8 * 1024,
 ):
-    """Sends an http GET request.
+    """Send an http GET request.
 
     :param str url:
         The URL to perform the GET request for.
@@ -46,7 +41,7 @@ def get(
 
 
 def stream_response(response, chunk_size=8 * 1024):
-    """Reads the :module:`urlopen` response in chunks."""
+    """Read the :module:`urlopen` response in chunks."""
     while True:
         buf = response.read(chunk_size)
         if not buf:

pytube/streams.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-pytube.streams
-~~~~~~~~~~~~~~
+This module contrains a container for stream manifest data.
 
 A container object for the media stream (video only / audio only / video+audio
 combined). This was referred to as ``Video`` in the legacy pytube version, but
@@ -25,9 +24,10 @@ logger = logging.getLogger(__name__)
 
 
 class Stream(object):
+    """Container for stream manifest data."""
 
     def __init__(self, stream, player_config, monostate):
-        """Constructs a :class:`Stream <Stream>`.
+        """Construct a :class:`Stream <Stream>`.
 
         :param dict stream:
             The unscrambled data extracted from YouTube.
@@ -83,7 +83,7 @@ class Stream(object):
         self.video_codec, self.audio_codec = self.parse_codecs()
 
     def set_attributes_from_dict(self, dct):
-        """Sets class attributes from dictionary items."""
+        """Set class attributes from dictionary items."""
         for key, val in dct.items():
             setattr(self, key, val)
 
@@ -105,7 +105,9 @@ class Stream(object):
         return self.type == 'video'
 
     def parse_codecs(self):
-        """Parses a variable length sized list of codecs and returns a
+        """Get the video/audio codecs from list of codecs.
+
+        Parse a variable length sized list of codecs and returns a
         consitant two element tuple, with the video codec as the first element
         and audio as the second. Returns ``None`` if one is not available
         (adaptive only).
@@ -124,15 +126,13 @@ class Stream(object):
     @property
     @memoize
     def filesize(self):
-        """The file size of the media stream in bytes."""
+        """File size of the media stream in bytes."""
         headers = request.get(self.url, headers=True)
         return int(headers['Content-Length'])
 
     @property
     def default_filename(self):
-        """A generated filename based on the video title, but sanitized for the
-        filesystem.
-        """
+        """Generate filename based on the video title."""
         title = self.player_config['args']['title']
         filename = safe_filename(title)
         return '{filename}.{s.subtype}'.format(filename=filename, s=self)
@@ -145,7 +145,6 @@ class Stream(object):
             specified, defaults to the current working directory.
 
         """
-
         # TODO(nficano): allow a filename to specified.
         output_path = output_path or os.getcwd()
 
@@ -165,10 +164,11 @@ class Stream(object):
                 self.on_progress(chunk, fh, bytes_remaining)
 
     def on_progress(self, chunk, file_handler, bytes_remaining):
-        """The on progress callback. This function writes the binary data to
-        the file, then checks if an additional callback is defined in the
-        monostate. This is exposed to allow things like displaying a progress
-        bar.
+        """On progress callback function.
+
+        This function writes the binary data to the file, then checks if an
+        additional callback is defined in the monostate. This is exposed to
+        allow things like displaying a progress bar.
 
         :param str chunk:
             Segment of media file binary data, not yet written to disk.

setup.cfg

@@ -4,20 +4,11 @@ tag = True
 current_version = 6.4.3
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?
 serialize =
-	{major}.{minor}.{patch}
+    {major}.{minor}.{patch}
 
 [metadata]
 description-file = README.md
 
-[nosetests]
-verbosity = 1
-detailed-errors = 1
-with-coverage = 1
-cover-package = pytube
-debug = nose.loader
-pdb = 0
-pdb-failures = 0
-
 [bumpversion:file:setup.py]
 
 [bumpversion:file:pytube/__init__.py]