apply black

17 files changed, 1338 insertions, 954 deletions

diff --git a/src/click/__init__.py b/src/click/__init__.py
index caddd63..ac53908 100644
--- a/src/click/__init__.py
+++ b/src/click/__init__.py
@@ -76,4 +76,4 @@ from .utils import open_file
 # literals.
 disable_unicode_literals_warning = False
 
-__version__ = '7.1.dev'
+__version__ = "7.1.dev"
diff --git a/src/click/_bashcomplete.py b/src/click/_bashcomplete.py
index ebcf44f..bbd45a0 100644
--- a/src/click/_bashcomplete.py
+++ b/src/click/_bashcomplete.py
@@ -14,10 +14,10 @@ try:
 except ImportError:
     import collections as abc
 
-WORDBREAK = '='
+WORDBREAK = "="
 
 # Note, only BASH version 4.4 and later have the nosort option.
-COMPLETION_SCRIPT_BASH = '''
+COMPLETION_SCRIPT_BASH = """
 %(complete_func)s() {
     local IFS=$'\n'
     COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \\
@@ -38,9 +38,9 @@ COMPLETION_SCRIPT_BASH = '''
 }
 
 %(complete_func)setup
-'''
+"""
 
-COMPLETION_SCRIPT_ZSH = '''
+COMPLETION_SCRIPT_ZSH = """
 #compdef %(script_names)s
 
 %(complete_func)s() {
@@ -73,11 +73,11 @@ COMPLETION_SCRIPT_ZSH = '''
 }
 
 compdef %(complete_func)s %(script_names)s
-'''
+"""
 
-COMPLETION_SCRIPT_FISH = '''
+COMPLETION_SCRIPT_FISH = """
 complete --no-files --command %(script_names)s --arguments "(env %(autocomplete_var)s=complete_fish COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) %(script_names)s)"
-'''
+"""
 
 _completion_scripts = {
     "bash": COMPLETION_SCRIPT_BASH,
@@ -85,17 +85,20 @@ _completion_scripts = {
     "fish": COMPLETION_SCRIPT_FISH,
 }
 
-_invalid_ident_char_re = re.compile(r'[^a-zA-Z0-9_]')
+_invalid_ident_char_re = re.compile(r"[^a-zA-Z0-9_]")
 
 
 def get_completion_script(prog_name, complete_var, shell):
-    cf_name = _invalid_ident_char_re.sub('', prog_name.replace('-', '_'))
+    cf_name = _invalid_ident_char_re.sub("", prog_name.replace("-", "_"))
     script = _completion_scripts.get(shell, COMPLETION_SCRIPT_BASH)
-    return (script % {
-        'complete_func': '_%s_completion' % cf_name,
-        'script_names': prog_name,
-        'autocomplete_var': complete_var,
-    }).strip() + ';'
+    return (
+        script
+        % {
+            "complete_func": "_%s_completion" % cf_name,
+            "script_names": prog_name,
+            "autocomplete_var": complete_var,
+        }
+    ).strip() + ";"
 
 
 def resolve_ctx(cli, prog_name, args):
@@ -114,8 +117,9 @@ def resolve_ctx(cli, prog_name, args):
                 cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
                 if cmd is None:
                     return ctx
-                ctx = cmd.make_context(cmd_name, args, parent=ctx,
-                                       resilient_parsing=True)
+                ctx = cmd.make_context(
+                    cmd_name, args, parent=ctx, resilient_parsing=True
+                )
                 args = ctx.protected_args + ctx.args
             else:
                 # Walk chained subcommand contexts saving the last one.
@@ -123,10 +127,14 @@ def resolve_ctx(cli, prog_name, args):
                     cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
                     if cmd is None:
                         return ctx
-                    sub_ctx = cmd.make_context(cmd_name, args, parent=ctx,
-                                               allow_extra_args=True,
-                                               allow_interspersed_args=False,
-                                               resilient_parsing=True)
+                    sub_ctx = cmd.make_context(
+                        cmd_name,
+                        args,
+                        parent=ctx,
+                        allow_extra_args=True,
+                        allow_interspersed_args=False,
+                        resilient_parsing=True,
+                    )
                     args = sub_ctx.args
                 ctx = sub_ctx
                 args = sub_ctx.protected_args + sub_ctx.args
@@ -140,7 +148,7 @@ def start_of_option(param_str):
     :param param_str: param_str to check
     :return: whether or not this is the start of an option declaration (i.e. starts "-" or "--")
     """
-    return param_str and param_str[:1] == '-'
+    return param_str and param_str[:1] == "-"
 
 
 def is_incomplete_option(all_args, cmd_param):
@@ -156,7 +164,9 @@ def is_incomplete_option(all_args, cmd_param):
     if cmd_param.is_flag:
         return False
     last_option = None
-    for index, arg_str in enumerate(reversed([arg for arg in all_args if arg != WORDBREAK])):
+    for index, arg_str in enumerate(
+        reversed([arg for arg in all_args if arg != WORDBREAK])
+    ):
         if index + 1 > cmd_param.nargs:
             break
         if start_of_option(arg_str):
@@ -179,8 +189,11 @@ def is_incomplete_argument(current_params, cmd_param):
         return True
     if cmd_param.nargs == -1:
         return True
-    if isinstance(current_param_values, abc.Iterable) \
-            and cmd_param.nargs > 1 and len(current_param_values) < cmd_param.nargs:
+    if (
+        isinstance(current_param_values, abc.Iterable)
+        and cmd_param.nargs > 1
+        and len(current_param_values) < cmd_param.nargs
+    ):
         return True
     return False
 
@@ -196,14 +209,16 @@ def get_user_autocompletions(ctx, args, incomplete, cmd_param):
     results = []
     if isinstance(cmd_param.type, Choice):
         # Choices don't support descriptions.
-        results = [(c, None)
-                   for c in cmd_param.type.choices if str(c).startswith(incomplete)]
+        results = [
+            (c, None) for c in cmd_param.type.choices if str(c).startswith(incomplete)
+        ]
     elif cmd_param.autocompletion is not None:
-        dynamic_completions = cmd_param.autocompletion(ctx=ctx,
-                                                       args=args,
-                                                       incomplete=incomplete)
-        results = [c if isinstance(c, tuple) else (c, None)
-                   for c in dynamic_completions]
+        dynamic_completions = cmd_param.autocompletion(
+            ctx=ctx, args=args, incomplete=incomplete
+        )
+        results = [
+            c if isinstance(c, tuple) else (c, None) for c in dynamic_completions
+        ]
     return results
 
 
@@ -224,15 +239,24 @@ def add_subcommand_completions(ctx, incomplete, completions_out):
     # Add subcommand completions.
     if isinstance(ctx.command, MultiCommand):
         completions_out.extend(
-            [(c.name, c.get_short_help_str()) for c in get_visible_commands_starting_with(ctx, incomplete)])
+            [
+                (c.name, c.get_short_help_str())
+                for c in get_visible_commands_starting_with(ctx, incomplete)
+            ]
+        )
 
     # Walk up the context list and add any other completion possibilities from chained commands
     while ctx.parent is not None:
         ctx = ctx.parent
         if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
-            remaining_commands = [c for c in get_visible_commands_starting_with(ctx, incomplete)
-                                  if c.name not in ctx.protected_args]
-            completions_out.extend([(c.name, c.get_short_help_str()) for c in remaining_commands])
+            remaining_commands = [
+                c
+                for c in get_visible_commands_starting_with(ctx, incomplete)
+                if c.name not in ctx.protected_args
+            ]
+            completions_out.extend(
+                [(c.name, c.get_short_help_str()) for c in remaining_commands]
+            )
 
 
 def get_choices(cli, prog_name, args, incomplete):
@@ -258,16 +282,21 @@ def get_choices(cli, prog_name, args, incomplete):
         all_args.append(partition_incomplete[0])
         incomplete = partition_incomplete[2]
     elif incomplete == WORDBREAK:
-        incomplete = ''
+        incomplete = ""
 
     completions = []
     if not has_double_dash and start_of_option(incomplete):
         # completions for partial options
         for param in ctx.command.params:
             if isinstance(param, Option) and not param.hidden:
-                param_opts = [param_opt for param_opt in param.opts +
-                              param.secondary_opts if param_opt not in all_args or param.multiple]
-                completions.extend([(o, param.help) for o in param_opts if o.startswith(incomplete)])
+                param_opts = [
+                    param_opt
+                    for param_opt in param.opts + param.secondary_opts
+                    if param_opt not in all_args or param.multiple
+                ]
+                completions.extend(
+                    [(o, param.help) for o in param_opts if o.startswith(incomplete)]
+                )
         return completions
     # completion for option values from user supplied values
     for param in ctx.command.params:
@@ -284,13 +313,13 @@ def get_choices(cli, prog_name, args, incomplete):
 
 
 def do_complete(cli, prog_name, include_descriptions):
-    cwords = split_arg_string(os.environ['COMP_WORDS'])
-    cword = int(os.environ['COMP_CWORD'])
+    cwords = split_arg_string(os.environ["COMP_WORDS"])
+    cword = int(os.environ["COMP_CWORD"])
     args = cwords[1:cword]
     try:
         incomplete = cwords[cword]
     except IndexError:
-        incomplete = ''
+        incomplete = ""
 
     for item in get_choices(cli, prog_name, args, incomplete):
         echo(item[0])
@@ -298,7 +327,7 @@ def do_complete(cli, prog_name, include_descriptions):
             # ZSH has trouble dealing with empty array parameters when
             # returned from commands, use '_' to indicate no description
             # is present.
-            echo(item[1] if item[1] else '_')
+            echo(item[1] if item[1] else "_")
 
     return True
 
diff --git a/src/click/_compat.py b/src/click/_compat.py
index 7b7a55f..6431fc2 100644
--- a/src/click/_compat.py
+++ b/src/click/_compat.py
@@ -6,12 +6,13 @@ import sys
 from weakref import WeakKeyDictionary
 
 PY2 = sys.version_info[0] == 2
-CYGWIN = sys.platform.startswith('cygwin')
-MSYS2 = sys.platform.startswith('win') and ('GCC' in sys.version)
+CYGWIN = sys.platform.startswith("cygwin")
+MSYS2 = sys.platform.startswith("win") and ("GCC" in sys.version)
 # Determine local App Engine environment, per Google's own suggestion
-APP_ENGINE = ('APPENGINE_RUNTIME' in os.environ and
-              'Development/' in os.environ.get('SERVER_SOFTWARE', ''))
-WIN = sys.platform.startswith('win') and not APP_ENGINE and not MSYS2
+APP_ENGINE = "APPENGINE_RUNTIME" in os.environ and "Development/" in os.environ.get(
+    "SERVER_SOFTWARE", ""
+)
+WIN = sys.platform.startswith("win") and not APP_ENGINE and not MSYS2
 DEFAULT_COLUMNS = 80
 
 
@@ -22,46 +23,57 @@ def get_filesystem_encoding():
     return sys.getfilesystemencoding() or sys.getdefaultencoding()
 
 
-def _make_text_stream(stream, encoding, errors,
-                      force_readable=False, force_writable=False):
+def _make_text_stream(
+    stream, encoding, errors, force_readable=False, force_writable=False
+):
     if encoding is None:
         encoding = get_best_encoding(stream)
     if errors is None:
-        errors = 'replace'
-    return _NonClosingTextIOWrapper(stream, encoding, errors,
-                                    line_buffering=True,
-                                    force_readable=force_readable,
-                                    force_writable=force_writable)
+        errors = "replace"
+    return _NonClosingTextIOWrapper(
+        stream,
+        encoding,
+        errors,
+        line_buffering=True,
+        force_readable=force_readable,
+        force_writable=force_writable,
+    )
 
 
 def is_ascii_encoding(encoding):
     """Checks if a given encoding is ascii."""
     try:
-        return codecs.lookup(encoding).name == 'ascii'
+        return codecs.lookup(encoding).name == "ascii"
     except LookupError:
         return False
 
 
 def get_best_encoding(stream):
     """Returns the default stream encoding if not found."""
-    rv = getattr(stream, 'encoding', None) or sys.getdefaultencoding()
+    rv = getattr(stream, "encoding", None) or sys.getdefaultencoding()
     if is_ascii_encoding(rv):
-        return 'utf-8'
+        return "utf-8"
     return rv
 
 
 class _NonClosingTextIOWrapper(io.TextIOWrapper):
-
-    def __init__(self, stream, encoding, errors,
-                 force_readable=False, force_writable=False, **extra):
-        self._stream = stream = _FixupStream(stream, force_readable,
-                                             force_writable)
+    def __init__(
+        self,
+        stream,
+        encoding,
+        errors,
+        force_readable=False,
+        force_writable=False,
+        **extra
+    ):
+        self._stream = stream = _FixupStream(stream, force_readable, force_writable)
         io.TextIOWrapper.__init__(self, stream, encoding, errors, **extra)
 
     # The io module is a place where the Python 3 text behavior
     # was forced upon Python 2, so we need to unbreak
     # it to look like Python 2.
     if PY2:
+
         def write(self, x):
             if isinstance(x, str) or is_bytes(x):
                 try:
@@ -105,7 +117,7 @@ class _FixupStream(object):
         return getattr(self._stream, name)
 
     def read1(self, size):
-        f = getattr(self._stream, 'read1', None)
+        f = getattr(self._stream, "read1", None)
         if f is not None:
             return f(size)
         # We only dispatch to readline instead of read in Python 2 as we
@@ -118,7 +130,7 @@ class _FixupStream(object):
     def readable(self):
         if self._force_readable:
             return True
-        x = getattr(self._stream, 'readable', None)
+        x = getattr(self._stream, "readable", None)
         if x is not None:
             return x()
         try:
@@ -130,20 +142,20 @@ class _FixupStream(object):
     def writable(self):
         if self._force_writable:
             return True
-        x = getattr(self._stream, 'writable', None)
+        x = getattr(self._stream, "writable", None)
         if x is not None:
             return x()
         try:
-            self._stream.write('')
+            self._stream.write("")
         except Exception:
             try:
-                self._stream.write(b'')
+                self._stream.write(b"")
             except Exception:
                 return False
         return True
 
     def seekable(self):
-        x = getattr(self._stream, 'seekable', None)
+        x = getattr(self._stream, "seekable", None)
         if x is not None:
             return x()
         try:
@@ -166,7 +178,7 @@ if PY2:
     def is_bytes(x):
         return isinstance(x, (buffer, bytearray))
 
-    _identifier_re = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_]*$')
+    _identifier_re = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
 
     # For Windows, we need to force stdout/stdin/stderr to binary if it's
     # fetched for that.  This obviously is not the most correct way to do
@@ -194,6 +206,7 @@ if PY2:
     except ImportError:
         pass
     else:
+
         def set_binary_mode(f):
             try:
                 fileno = f.fileno()
@@ -208,6 +221,7 @@ if PY2:
     except ImportError:
         pass
     else:
+
         def set_binary_mode(f):
             try:
                 fileno = f.fileno()
@@ -225,42 +239,42 @@ if PY2:
         return set_binary_mode(sys.stdin)
 
     def get_binary_stdout():
-        _wrap_std_stream('stdout')
+        _wrap_std_stream("stdout")
         return set_binary_mode(sys.stdout)
 
     def get_binary_stderr():
-        _wrap_std_stream('stderr')
+        _wrap_std_stream("stderr")
         return set_binary_mode(sys.stderr)
 
     def get_text_stdin(encoding=None, errors=None):
         rv = _get_windows_console_stream(sys.stdin, encoding, errors)
         if rv is not None:
             return rv
-        return _make_text_stream(sys.stdin, encoding, errors,
-                                 force_readable=True)
+        return _make_text_stream(sys.stdin, encoding, errors, force_readable=True)
 
     def get_text_stdout(encoding=None, errors=None):
-        _wrap_std_stream('stdout')
+        _wrap_std_stream("stdout")
         rv = _get_windows_console_stream(sys.stdout, encoding, errors)
         if rv is not None:
             return rv
-        return _make_text_stream(sys.stdout, encoding, errors,
-                                 force_writable=True)
+        return _make_text_stream(sys.stdout, encoding, errors, force_writable=True)
 
     def get_text_stderr(encoding=None, errors=None):
-        _wrap_std_stream('stderr')
+        _wrap_std_stream("stderr")
         rv = _get_windows_console_stream(sys.stderr, encoding, errors)
         if rv is not None:
             return rv
-        return _make_text_stream(sys.stderr, encoding, errors,
-                                 force_writable=True)
+        return _make_text_stream(sys.stderr, encoding, errors, force_writable=True)
 
     def filename_to_ui(value):
         if isinstance(value, bytes):
-            value = value.decode(get_filesystem_encoding(), 'replace')
+            value = value.decode(get_filesystem_encoding(), "replace")
         return value
+
+
 else:
     import io
+
     text_type = str
     raw_input = input
     string_types = (str,)
@@ -284,10 +298,10 @@ else:
 
     def _is_binary_writer(stream, default=False):
         try:
-            stream.write(b'')
+            stream.write(b"")
         except Exception:
             try:
-                stream.write('')
+                stream.write("")
                 return False
             except Exception:
                 pass
@@ -302,7 +316,7 @@ else:
         if _is_binary_reader(stream, False):
             return stream
 
-        buf = getattr(stream, 'buffer', None)
+        buf = getattr(stream, "buffer", None)
 
         # Same situation here; this time we assume that the buffer is
         # actually binary in case it's closed.
@@ -317,7 +331,7 @@ else:
         if _is_binary_writer(stream, False):
             return stream
 
-        buf = getattr(stream, 'buffer', None)
+        buf = getattr(stream, "buffer", None)
 
         # Same situation here; this time we assume that the buffer is
         # actually binary in case it's closed.
@@ -330,7 +344,7 @@ else:
         # to ASCII.  This appears to happen in certain unittest
         # environments.  It's not quite clear what the correct behavior is
         # but this at least will force Click to recover somehow.
-        return is_ascii_encoding(getattr(stream, 'encoding', None) or 'ascii')
+        return is_ascii_encoding(getattr(stream, "encoding", None) or "ascii")
 
     def _is_compat_stream_attr(stream, attr, value):
         """A stream attribute is compatible if it is equal to the
@@ -344,10 +358,9 @@ else:
         """Check if a stream's encoding and errors attributes are
         compatible with the desired values.
         """
-        return (
-            _is_compat_stream_attr(stream, "encoding", encoding)
-            and _is_compat_stream_attr(stream, "errors", errors)
-        )
+        return _is_compat_stream_attr(
+            stream, "encoding", encoding
+        ) and _is_compat_stream_attr(stream, "errors", errors)
 
     def _force_correct_text_stream(
         text_stream,
@@ -363,12 +376,8 @@ else:
         else:
             # If the stream looks compatible, and won't default to a
             # misconfigured ascii encoding, return it as-is.
-            if (
-                _is_compatible_text_stream(text_stream, encoding, errors)
-                and not (
-                    encoding is None
-                    and _stream_is_misconfigured(text_stream)
-                )
+            if _is_compatible_text_stream(text_stream, encoding, errors) and not (
+                encoding is None and _stream_is_misconfigured(text_stream)
             ):
                 return text_stream
 
@@ -418,56 +427,61 @@ else:
     def get_binary_stdin():
         reader = _find_binary_reader(sys.stdin)
         if reader is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stdin.')
+            raise RuntimeError(
+                "Was not able to determine binary stream for sys.stdin."
+            )
         return reader
 
     def get_binary_stdout():
         writer = _find_binary_writer(sys.stdout)
         if writer is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stdout.')
+            raise RuntimeError(
+                "Was not able to determine binary stream for sys.stdout."
+            )
         return writer
 
     def get_binary_stderr():
         writer = _find_binary_writer(sys.stderr)
         if writer is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stderr.')
+            raise RuntimeError(
+                "Was not able to determine binary stream for sys.stderr."
+            )
         return writer
 
     def get_text_stdin(encoding=None, errors=None):
         rv = _get_windows_console_stream(sys.stdin, encoding, errors)
         if rv is not None:
             return rv
-        return _force_correct_text_reader(sys.stdin, encoding, errors,
-                                          force_readable=True)
+        return _force_correct_text_reader(
+            sys.stdin, encoding, errors, force_readable=True
+        )
 
     def get_text_stdout(encoding=None, errors=None):
         rv = _get_windows_console_stream(sys.stdout, encoding, errors)
         if rv is not None:
             return rv
-        return _force_correct_text_writer(sys.stdout, encoding, errors,
-                                          force_writable=True)
+        return _force_correct_text_writer(
+            sys.stdout, encoding, errors, force_writable=True
+        )
 
     def get_text_stderr(encoding=None, errors=None):
         rv = _get_windows_console_stream(sys.stderr, encoding, errors)
         if rv is not None:
             return rv
-        return _force_correct_text_writer(sys.stderr, encoding, errors,
-                                          force_writable=True)
+        return _force_correct_text_writer(
+            sys.stderr, encoding, errors, force_writable=True
+        )
 
     def filename_to_ui(value):
         if isinstance(value, bytes):
-            value = value.decode(get_filesystem_encoding(), 'replace')
+            value = value.decode(get_filesystem_encoding(), "replace")
         else:
-            value = value.encode('utf-8', 'surrogateescape') \
-                .decode('utf-8', 'replace')
+            value = value.encode("utf-8", "surrogateescape").decode("utf-8", "replace")
         return value
 
 
 def get_streerror(e, default=None):
-    if hasattr(e, 'strerror'):
+    if hasattr(e, "strerror"):
         msg = e.strerror
     else:
         if default is not None:
@@ -475,7 +489,7 @@ def get_streerror(e, default=None):
         else:
             msg = str(e)
     if isinstance(msg, bytes):
-        msg = msg.decode('utf-8', 'replace')
+        msg = msg.decode("utf-8", "replace")
     return msg
 
 
@@ -501,13 +515,13 @@ def _wrap_io_open(file, mode, encoding, errors):
     return _make_text_stream(f, **kwargs)
 
 
-def open_stream(filename, mode='r', encoding=None, errors='strict', atomic=False):
+def open_stream(filename, mode="r", encoding=None, errors="strict", atomic=False):
     binary = "b" in mode
 
     # Standard streams first.  These are simple because they don't need
     # special handling for the atomic flag.  It's entirely ignored.
-    if filename == '-':
-        if any(m in mode for m in ['w', 'a', 'x']):
+    if filename == "-":
+        if any(m in mode for m in ["w", "a", "x"]):
             if binary:
                 return get_binary_stdout(), False
             return get_text_stdout(encoding=encoding, errors=errors), False
@@ -520,17 +534,17 @@ def open_stream(filename, mode='r', encoding=None, errors='strict', atomic=False
         return _wrap_io_open(filename, mode, encoding, errors), True
 
     # Some usability stuff for atomic writes
-    if 'a' in mode:
+    if "a" in mode:
         raise ValueError(
-            'Appending to an existing file is not supported, because that '
-            'would involve an expensive `copy`-operation to a temporary '
-            'file. Open the file in normal `w`-mode and copy explicitly '
-            'if that\'s what you\'re after.'
+            "Appending to an existing file is not supported, because that "
+            "would involve an expensive `copy`-operation to a temporary "
+            "file. Open the file in normal `w`-mode and copy explicitly "
+            "if that's what you're after."
         )
-    if 'x' in mode:
-        raise ValueError('Use the `overwrite`-parameter instead.')
-    if 'w' not in mode:
-        raise ValueError('Atomic writes only make sense with `w`-mode.')
+    if "x" in mode:
+        raise ValueError("Use the `overwrite`-parameter instead.")
+    if "w" not in mode:
+        raise ValueError("Atomic writes only make sense with `w`-mode.")
 
     # Atomic writes are more complicated.  They work by opening a file
     # as a proxy in the same folder and then using the fdopen
@@ -547,12 +561,12 @@ def open_stream(filename, mode='r', encoding=None, errors='strict', atomic=False
     flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
 
     if binary:
-        flags |= getattr(os, 'O_BINARY', 0)
+        flags |= getattr(os, "O_BINARY", 0)
 
     while True:
         tmp_filename = os.path.join(
             os.path.dirname(filename),
-            '.__atomic-write%08x' % (random.randrange(1 << 32),),
+            ".__atomic-write%08x" % (random.randrange(1 << 32),),
         )
         try:
             fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm)
@@ -575,7 +589,7 @@ def open_stream(filename, mode='r', encoding=None, errors='strict', atomic=False
 
 
 # Used in a destructor call, needs extra protection from interpreter cleanup.
-if hasattr(os, 'replace'):
+if hasattr(os, "replace"):
     _replace = os.replace
     _can_replace = True
 else:
@@ -584,7 +598,6 @@ else:
 
 
 class _AtomicFile(object):
-
     def __init__(self, f, tmp_filename, real_filename):
         self._f = f
         self._tmp_filename = tmp_filename
@@ -626,7 +639,7 @@ get_winterm_size = None
 
 
 def strip_ansi(value):
-    return _ansi_re.sub('', value)
+    return _ansi_re.sub("", value)
 
 
 def _is_jupyter_kernel_output(stream):
@@ -660,16 +673,18 @@ if WIN:
 
     def _get_argv_encoding():
         import locale
+
         return locale.getpreferredencoding()
 
     if PY2:
-        def raw_input(prompt=''):
+
+        def raw_input(prompt=""):
             sys.stderr.flush()
             if prompt:
                 stdout = _default_text_stdout()
                 stdout.write(prompt)
             stdin = _default_text_stdin()
-            return stdin.readline().rstrip('\r\n')
+            return stdin.readline().rstrip("\r\n")
 
     try:
         import colorama
@@ -711,11 +726,15 @@ if WIN:
 
         def get_winterm_size():
             win = colorama.win32.GetConsoleScreenBufferInfo(
-                colorama.win32.STDOUT).srWindow
+                colorama.win32.STDOUT
+            ).srWindow
             return win.Right - win.Left, win.Bottom - win.Top
+
+
 else:
+
     def _get_argv_encoding():
-        return getattr(sys.stdin, 'encoding', None) or get_filesystem_encoding()
+        return getattr(sys.stdin, "encoding", None) or get_filesystem_encoding()
 
     _get_windows_console_stream = lambda *x: None
     _wrap_std_stream = lambda *x: None
@@ -734,6 +753,7 @@ def isatty(stream):
 
 def _make_cached_stream_func(src_func, wrapper_func):
     cache = WeakKeyDictionary()
+
     def func():
         stream = src_func()
         try:
@@ -749,25 +769,23 @@ def _make_cached_stream_func(src_func, wrapper_func):
         except Exception:
             pass
         return rv
+
     return func
 
 
-_default_text_stdin = _make_cached_stream_func(
-    lambda: sys.stdin, get_text_stdin)
-_default_text_stdout = _make_cached_stream_func(
-    lambda: sys.stdout, get_text_stdout)
-_default_text_stderr = _make_cached_stream_func(
-    lambda: sys.stderr, get_text_stderr)
+_default_text_stdin = _make_cached_stream_func(lambda: sys.stdin, get_text_stdin)
+_default_text_stdout = _make_cached_stream_func(lambda: sys.stdout, get_text_stdout)
+_default_text_stderr = _make_cached_stream_func(lambda: sys.stderr, get_text_stderr)
 
 
 binary_streams = {
-    'stdin': get_binary_stdin,
-    'stdout': get_binary_stdout,
-    'stderr': get_binary_stderr,
+    "stdin": get_binary_stdin,
+    "stdout": get_binary_stdout,
+    "stderr": get_binary_stderr,
 }
 
 text_streams = {
-    'stdin': get_text_stdin,
-    'stdout': get_text_stdout,
-    'stderr': get_text_stderr,
+    "stdin": get_text_stdin,
+    "stdout": get_text_stdout,
+    "stderr": get_text_stderr,
 }
diff --git a/src/click/_termui_impl.py b/src/click/_termui_impl.py
index e6974a7..784c64b 100644
--- a/src/click/_termui_impl.py
+++ b/src/click/_termui_impl.py
@@ -24,12 +24,12 @@ from ._compat import WIN
 from .exceptions import ClickException
 from .utils import echo
 
-if os.name == 'nt':
-    BEFORE_BAR = '\r'
-    AFTER_BAR = '\n'
+if os.name == "nt":
+    BEFORE_BAR = "\r"
+    AFTER_BAR = "\n"
 else:
-    BEFORE_BAR = '\r\033[?25l'
-    AFTER_BAR = '\033[?25h\n'
+    BEFORE_BAR = "\r\033[?25l"
+    AFTER_BAR = "\033[?25h\n"
 
 
 def _length_hint(obj):
@@ -45,19 +45,29 @@ def _length_hint(obj):
             hint = get_hint(obj)
         except TypeError:
             return None
-        if hint is NotImplemented or \
-           not isinstance(hint, int_types) or \
-           hint < 0:
+        if hint is NotImplemented or not isinstance(hint, int_types) or hint < 0:
             return None
         return hint
 
 
 class ProgressBar(object):
-
-    def __init__(self, iterable, length=None, fill_char='#', empty_char=' ',
-                 bar_template='%(bar)s', info_sep='  ', show_eta=True,
-                 show_percent=None, show_pos=False, item_show_func=None,
-                 label=None, file=None, color=None, width=30):
+    def __init__(
+        self,
+        iterable,
+        length=None,
+        fill_char="#",
+        empty_char=" ",
+        bar_template="%(bar)s",
+        info_sep="  ",
+        show_eta=True,
+        show_percent=None,
+        show_pos=False,
+        item_show_func=None,
+        label=None,
+        file=None,
+        color=None,
+        width=30,
+    ):
         self.fill_char = fill_char
         self.empty_char = empty_char
         self.bar_template = bar_template
@@ -66,7 +76,7 @@ class ProgressBar(object):
         self.show_percent = show_percent
         self.show_pos = show_pos
         self.item_show_func = item_show_func
-        self.label = label or ''
+        self.label = label or ""
         if file is None:
             file = _default_text_stdout()
         self.file = file
@@ -78,7 +88,7 @@ class ProgressBar(object):
             length = _length_hint(iterable)
         if iterable is None:
             if length is None:
-                raise TypeError('iterable or length is required')
+                raise TypeError("iterable or length is required")
             iterable = range_type(length)
         self.iter = iter(iterable)
         self.length = length
@@ -105,7 +115,7 @@ class ProgressBar(object):
 
     def __iter__(self):
         if not self.entered:
-            raise RuntimeError('You need to use progress bars in a with block.')
+            raise RuntimeError("You need to use progress bars in a with block.")
         self.render_progress()
         return self.generator()
 
@@ -158,19 +168,19 @@ class ProgressBar(object):
             t //= 24
             if t > 0:
                 days = t
-                return '%dd %02d:%02d:%02d' % (days, hours, minutes, seconds)
+                return "%dd %02d:%02d:%02d" % (days, hours, minutes, seconds)
             else:
-                return '%02d:%02d:%02d' % (hours, minutes, seconds)
-        return ''
+                return "%02d:%02d:%02d" % (hours, minutes, seconds)
+        return ""
 
     def format_pos(self):
         pos = str(self.pos)
         if self.length_known:
-            pos += '/%s' % self.length
+            pos += "/%s" % self.length
         return pos
 
     def format_pct(self):
-        return ('% 4d%%' % int(self.pct * 100))[1:]
+        return ("% 4d%%" % int(self.pct * 100))[1:]
 
     def format_bar(self):
         if self.length_known:
@@ -182,9 +192,13 @@ class ProgressBar(object):
         else:
             bar = list(self.empty_char * (self.width or 1))
             if self.time_per_iteration != 0:
-                bar[int((math.cos(self.pos * self.time_per_iteration)
-                    / 2.0 + 0.5) * self.width)] = self.fill_char
-            bar = ''.join(bar)
+                bar[
+                    int(
+                        (math.cos(self.pos * self.time_per_iteration) / 2.0 + 0.5)
+                        * self.width
+                    )
+                ] = self.fill_char
+            bar = "".join(bar)
         return bar
 
     def format_progress_line(self):
@@ -205,11 +219,14 @@ class ProgressBar(object):
             if item_info is not None:
                 info_bits.append(item_info)
 
-        return (self.bar_template % {
-            'label': self.label,
-            'bar': self.format_bar(),
-            'info': self.info_sep.join(info_bits)
-        }).rstrip()
+        return (
+            self.bar_template
+            % {
+                "label": self.label,
+                "bar": self.format_bar(),
+                "info": self.info_sep.join(info_bits),
+            }
+        ).rstrip()
 
     def render_progress(self):
         from .termui import get_terminal_size
@@ -226,7 +243,7 @@ class ProgressBar(object):
             new_width = max(0, get_terminal_size()[0] - clutter_length)
             if new_width < old_width:
                 buf.append(BEFORE_BAR)
-                buf.append(' ' * self.max_width)
+                buf.append(" " * self.max_width)
                 self.max_width = new_width
             self.width = new_width
 
@@ -241,8 +258,8 @@ class ProgressBar(object):
             self.max_width = line_len
 
         buf.append(line)
-        buf.append(' ' * (clear_width - line_len))
-        line = ''.join(buf)
+        buf.append(" " * (clear_width - line_len))
+        line = "".join(buf)
         # Render the line only if it changed.
 
         if line != self._last_line and not self.is_fast():
@@ -294,7 +311,7 @@ class ProgressBar(object):
         # `self.generator()` repeatedly, and this must remain safe in
         # order for that interface to work.
         if not self.entered:
-            raise RuntimeError('You need to use progress bars in a with block.')
+            raise RuntimeError("You need to use progress bars in a with block.")
 
         if self.is_hidden:
             for rv in self.iter:
@@ -313,24 +330,25 @@ def pager(generator, color=None):
     stdout = _default_text_stdout()
     if not isatty(sys.stdin) or not isatty(stdout):
         return _nullpager(stdout, generator, color)
-    pager_cmd = (os.environ.get('PAGER', None) or '').strip()
+    pager_cmd = (os.environ.get("PAGER", None) or "").strip()
     if pager_cmd:
         if WIN:
             return _tempfilepager(generator, pager_cmd, color)
         return _pipepager(generator, pager_cmd, color)
-    if os.environ.get('TERM') in ('dumb', 'emacs'):
+    if os.environ.get("TERM") in ("dumb", "emacs"):
         return _nullpager(stdout, generator, color)
-    if WIN or sys.platform.startswith('os2'):
-        return _tempfilepager(generator, 'more <', color)
-    if hasattr(os, 'system') and os.system('(less) 2>/dev/null') == 0:
-        return _pipepager(generator, 'less', color)
+    if WIN or sys.platform.startswith("os2"):
+        return _tempfilepager(generator, "more <", color)
+    if hasattr(os, "system") and os.system("(less) 2>/dev/null") == 0:
+        return _pipepager(generator, "less", color)
 
     import tempfile
+
     fd, filename = tempfile.mkstemp()
     os.close(fd)
     try:
-        if hasattr(os, 'system') and os.system("more %s" % shlex_quote(filename)) == 0:
-            return _pipepager(generator, 'more', color)
+        if hasattr(os, "system") and os.system("more %s" % shlex_quote(filename)) == 0:
+            return _pipepager(generator, "more", color)
         return _nullpager(stdout, generator, color)
     finally:
         os.unlink(filename)
@@ -341,28 +359,28 @@ def _pipepager(generator, cmd, color):
     pager through this might support colors.
     """
     import subprocess
+
     env = dict(os.environ)
 
     # If we're piping to less we might support colors under the
     # condition that
-    cmd_detail = cmd.rsplit('/', 1)[-1].split()
-    if color is None and cmd_detail[0] == 'less':
-        less_flags = os.environ.get('LESS', '') + ' '.join(cmd_detail[1:])
+    cmd_detail = cmd.rsplit("/", 1)[-1].split()
+    if color is None and cmd_detail[0] == "less":
+        less_flags = os.environ.get("LESS", "") + " ".join(cmd_detail[1:])
         if not less_flags:
-            env['LESS'] = '-R'
+            env["LESS"] = "-R"
             color = True
-        elif 'r' in less_flags or 'R' in less_flags:
+        elif "r" in less_flags or "R" in less_flags:
             color = True
 
-    c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
-                         env=env)
+    c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, env=env)
     encoding = get_best_encoding(c.stdin)
     try:
         for text in generator:
             if not color:
                 text = strip_ansi(text)
 
-            c.stdin.write(text.encode(encoding, 'replace'))
+            c.stdin.write(text.encode(encoding, "replace"))
     except (IOError, KeyboardInterrupt):
         pass
     else:
@@ -388,13 +406,14 @@ def _pipepager(generator, cmd, color):
 def _tempfilepager(generator, cmd, color):
     """Page through text by invoking a program on a temporary file."""
     import tempfile
+
     filename = tempfile.mktemp()
     # TODO: This never terminates if the passed generator never terminates.
     text = "".join(generator)
     if not color:
         text = strip_ansi(text)
     encoding = get_best_encoding(sys.stdout)
-    with open_stream(filename, 'wb')[0] as f:
+    with open_stream(filename, "wb")[0] as f:
         f.write(text.encode(encoding))
     try:
         os.system("%s %s" % (shlex_quote(cmd), shlex_quote(filename)))
@@ -411,9 +430,7 @@ def _nullpager(stream, generator, color):
 
 
 class Editor(object):
-
-    def __init__(self, editor=None, env=None, require_save=True,
-                 extension='.txt'):
+    def __init__(self, editor=None, env=None, require_save=True, extension=".txt"):
         self.editor = editor
         self.env = env
         self.require_save = require_save
@@ -422,19 +439,20 @@ class Editor(object):
     def get_editor(self):
         if self.editor is not None:
             return self.editor
-        for key in 'VISUAL', 'EDITOR':
+        for key in "VISUAL", "EDITOR":
             rv = os.environ.get(key)
             if rv:
                 return rv
         if WIN:
-            return 'notepad'
-        for editor in 'sensible-editor', 'vim', 'nano':
-            if os.system('which %s >/dev/null 2>&1' % editor) == 0:
+            return "notepad"
+        for editor in "sensible-editor", "vim", "nano":
+            if os.system("which %s >/dev/null 2>&1" % editor) == 0:
                 return editor
-        return 'vi'
+        return "vi"
 
     def edit_file(self, filename):
         import subprocess
+
         editor = self.get_editor()
         if self.env:
             environ = os.environ.copy()
@@ -445,47 +463,46 @@ class Editor(object):
             c = subprocess.Popen(
                 "%s %s" % (shlex_quote(editor), shlex_quote(filename)),
                 env=environ,
-                shell=True
+                shell=True,
             )
             exit_code = c.wait()
             if exit_code != 0:
-                raise ClickException('%s: Editing failed!' % editor)
+                raise ClickException("%s: Editing failed!" % editor)
         except OSError as e:
-            raise ClickException('%s: Editing failed: %s' % (editor, e))
+            raise ClickException("%s: Editing failed: %s" % (editor, e))
 
     def edit(self, text):
         import tempfile
 
-        text = text or ''
-        if text and not text.endswith('\n'):
-            text += '\n'
+        text = text or ""
+        if text and not text.endswith("\n"):
+            text += "\n"
 
-        fd, name = tempfile.mkstemp(prefix='editor-', suffix=self.extension)
+        fd, name = tempfile.mkstemp(prefix="editor-", suffix=self.extension)
         try:
             if WIN:
-                encoding = 'utf-8-sig'
-                text = text.replace('\n', '\r\n')
+                encoding = "utf-8-sig"
+                text = text.replace("\n", "\r\n")
             else:
-                encoding = 'utf-8'
+                encoding = "utf-8"
             text = text.encode(encoding)
 
-            f = os.fdopen(fd, 'wb')
+            f = os.fdopen(fd, "wb")
             f.write(text)
             f.close()
             timestamp = os.path.getmtime(name)
 
             self.edit_file(name)
 
-            if self.require_save \
-               and os.path.getmtime(name) == timestamp:
+            if self.require_save and os.path.getmtime(name) == timestamp:
                 return None
 
-            f = open(name, 'rb')
+            f = open(name, "rb")
             try:
                 rv = f.read()
             finally:
                 f.close()
-            return rv.decode('utf-8-sig').replace('\r\n', '\n')
+            return rv.decode("utf-8-sig").replace("\r\n", "\n")
         finally:
             os.unlink(name)
 
@@ -498,18 +515,18 @@ def open_url(url, wait=False, locate=False):
             import urllib
         except ImportError:
             import urllib
-        if url.startswith('file://'):
+        if url.startswith("file://"):
             url = urllib.unquote(url[7:])
         return url
 
-    if sys.platform == 'darwin':
-        args = ['open']
+    if sys.platform == "darwin":
+        args = ["open"]
         if wait:
-            args.append('-W')
+            args.append("-W")
         if locate:
-            args.append('-R')
+            args.append("-R")
         args.append(_unquote_file(url))
-        null = open('/dev/null', 'w')
+        null = open("/dev/null", "w")
         try:
             return subprocess.Popen(args, stderr=null).wait()
         finally:
@@ -531,27 +548,28 @@ def open_url(url, wait=False, locate=False):
 
     try:
         if locate:
-            url = os.path.dirname(_unquote_file(url)) or '.'
+            url = os.path.dirname(_unquote_file(url)) or "."
         else:
             url = _unquote_file(url)
-        c = subprocess.Popen(['xdg-open', url])
+        c = subprocess.Popen(["xdg-open", url])
         if wait:
             return c.wait()
         return 0
     except OSError:
-        if url.startswith(('http://', 'https://')) and not locate and not wait:
+        if url.startswith(("http://", "https://")) and not locate and not wait:
             import webbrowser
+
             webbrowser.open(url)
             return 0
         return 1
 
 
 def _translate_ch_to_exc(ch):
-    if ch == u'\x03':
+    if ch == u"\x03":
         raise KeyboardInterrupt()
-    if ch == u'\x04' and not WIN:  # Unix-like, Ctrl+D
+    if ch == u"\x04" and not WIN:  # Unix-like, Ctrl+D
         raise EOFError()
-    if ch == u'\x1a' and WIN:      # Windows, Ctrl+Z
+    if ch == u"\x1a" and WIN:  # Windows, Ctrl+Z
         raise EOFError()
 
 
@@ -598,12 +616,14 @@ if WIN:
             func = msvcrt.getwch
 
         rv = func()
-        if rv in (u'\x00', u'\xe0'):
+        if rv in (u"\x00", u"\xe0"):
             # \x00 and \xe0 are control characters that indicate special key,
             # see above.
             rv += func()
         _translate_ch_to_exc(rv)
         return rv
+
+
 else:
     import tty
     import termios
@@ -611,7 +631,7 @@ else:
     @contextlib.contextmanager
     def raw_terminal():
         if not isatty(sys.stdin):
-            f = open('/dev/tty')
+            f = open("/dev/tty")
             fd = f.fileno()
         else:
             fd = sys.stdin.fileno()
@@ -632,7 +652,7 @@ else:
     def getchar(echo):
         with raw_terminal() as fd:
             ch = os.read(fd, 32)
-            ch = ch.decode(get_best_encoding(sys.stdin), 'replace')
+            ch = ch.decode(get_best_encoding(sys.stdin), "replace")
             if echo and isatty(sys.stdout):
                 sys.stdout.write(ch)
             _translate_ch_to_exc(ch)
diff --git a/src/click/_textwrap.py b/src/click/_textwrap.py
index 7e77603..6959087 100644
--- a/src/click/_textwrap.py
+++ b/src/click/_textwrap.py
@@ -3,7 +3,6 @@ from contextlib import contextmanager
 
 
 class TextWrapper(textwrap.TextWrapper):
-
     def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
         space_left = max(width - cur_len, 1)
 
@@ -35,4 +34,4 @@ class TextWrapper(textwrap.TextWrapper):
             if idx > 0:
                 indent = self.subsequent_indent
             rv.append(indent + line)
-        return '\n'.join(rv)
+        return "\n".join(rv)
diff --git a/src/click/_unicodefun.py b/src/click/_unicodefun.py
index c0e9a27..4d0a169 100644
--- a/src/click/_unicodefun.py
+++ b/src/click/_unicodefun.py
@@ -8,17 +8,18 @@ from ._compat import PY2
 # correct package is discovered.  Ideally we could use a
 # relative import here but unfortunately Python does not
 # support that.
-click = sys.modules[__name__.rsplit('.', 1)[0]]
+click = sys.modules[__name__.rsplit(".", 1)[0]]
 
 
 def _find_unicode_literals_frame():
     import __future__
-    if not hasattr(sys, '_getframe'):  # not all Python implementations have it
+
+    if not hasattr(sys, "_getframe"):  # not all Python implementations have it
         return 0
     frm = sys._getframe(1)
     idx = 1
     while frm is not None:
-        if frm.f_globals.get('__name__', '').startswith('click.'):
+        if frm.f_globals.get("__name__", "").startswith("click."):
             frm = frm.f_back
             idx += 1
         elif frm.f_code.co_flags & __future__.unicode_literals.compiler_flag:
@@ -37,13 +38,18 @@ def _check_for_unicode_literals():
     if bad_frame <= 0:
         return
     from warnings import warn
-    warn(Warning('Click detected the use of the unicode_literals '
-                 '__future__ import.  This is heavily discouraged '
-                 'because it can introduce subtle bugs in your '
-                 'code.  You should instead use explicit u"" literals '
-                 'for your unicode strings.  For more information see '
-                 'https://click.palletsprojects.com/en/7.x/python3/'),
-         stacklevel=bad_frame)
+
+    warn(
+        Warning(
+            "Click detected the use of the unicode_literals "
+            "__future__ import.  This is heavily discouraged "
+            "because it can introduce subtle bugs in your "
+            'code.  You should instead use explicit u"" literals '
+            "for your unicode strings.  For more information see "
+            "https://click.palletsprojects.com/en/7.x/python3/"
+        ),
+        stacklevel=bad_frame,
+    )
 
 
 def _verify_python3_env():
@@ -52,73 +58,76 @@ def _verify_python3_env():
         return
     try:
         import locale
+
         fs_enc = codecs.lookup(locale.getpreferredencoding()).name
     except Exception:
-        fs_enc = 'ascii'
-    if fs_enc != 'ascii':
+        fs_enc = "ascii"
+    if fs_enc != "ascii":
         return
 
-    extra = ''
-    if os.name == 'posix':
+    extra = ""
+    if os.name == "posix":
         import subprocess
+
         try:
-            rv = subprocess.Popen(['locale', '-a'], stdout=subprocess.PIPE,
-                                  stderr=subprocess.PIPE).communicate()[0]
+            rv = subprocess.Popen(
+                ["locale", "-a"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            ).communicate()[0]
         except OSError:
-            rv = b''
+            rv = b""
         good_locales = set()
         has_c_utf8 = False
 
         # Make sure we're operating on text here.
         if isinstance(rv, bytes):
-            rv = rv.decode('ascii', 'replace')
+            rv = rv.decode("ascii", "replace")
 
         for line in rv.splitlines():
             locale = line.strip()
-            if locale.lower().endswith(('.utf-8', '.utf8')):
+            if locale.lower().endswith((".utf-8", ".utf8")):
                 good_locales.add(locale)
-                if locale.lower() in ('c.utf8', 'c.utf-8'):
+                if locale.lower() in ("c.utf8", "c.utf-8"):
                     has_c_utf8 = True
 
-        extra += '\n\n'
+        extra += "\n\n"
         if not good_locales:
             extra += (
-                'Additional information: on this system no suitable UTF-8\n'
-                'locales were discovered.  This most likely requires resolving\n'
-                'by reconfiguring the locale system.'
+                "Additional information: on this system no suitable UTF-8\n"
+                "locales were discovered.  This most likely requires resolving\n"
+                "by reconfiguring the locale system."
             )
         elif has_c_utf8:
             extra += (
-                'This system supports the C.UTF-8 locale which is recommended.\n'
-                'You might be able to resolve your issue by exporting the\n'
-                'following environment variables:\n\n'
-                '    export LC_ALL=C.UTF-8\n'
-                '    export LANG=C.UTF-8'
+                "This system supports the C.UTF-8 locale which is recommended.\n"
+                "You might be able to resolve your issue by exporting the\n"
+                "following environment variables:\n\n"
+                "    export LC_ALL=C.UTF-8\n"
+                "    export LANG=C.UTF-8"
             )
         else:
             extra += (
-                'This system lists a couple of UTF-8 supporting locales that\n'
-                'you can pick from.  The following suitable locales were\n'
-                'discovered: %s'
-            ) % ', '.join(sorted(good_locales))
+                "This system lists a couple of UTF-8 supporting locales that\n"
+                "you can pick from.  The following suitable locales were\n"
+                "discovered: %s"
+            ) % ", ".join(sorted(good_locales))
 
         bad_locale = None
-        for locale in os.environ.get('LC_ALL'), os.environ.get('LANG'):
-            if locale and locale.lower().endswith(('.utf-8', '.utf8')):
+        for locale in os.environ.get("LC_ALL"), os.environ.get("LANG"):
+            if locale and locale.lower().endswith((".utf-8", ".utf8")):
                 bad_locale = locale
             if locale is not None:
                 break
         if bad_locale is not None:
             extra += (
-                '\n\nClick discovered that you exported a UTF-8 locale\n'
-                'but the locale system could not pick up from it because\n'
+                "\n\nClick discovered that you exported a UTF-8 locale\n"
+                "but the locale system could not pick up from it because\n"
                 'it does not exist.  The exported locale is "%s" but it\n'
-                'is not supported'
+                "is not supported"
             ) % bad_locale
 
     raise RuntimeError(
-        'Click will abort further execution because Python 3 was'
-        ' configured to use ASCII as encoding for the environment.'
-        ' Consult https://click.palletsprojects.com/en/7.x/python3/ for'
-        ' mitigation steps.' + extra
+        "Click will abort further execution because Python 3 was"
+        " configured to use ASCII as encoding for the environment."
+        " Consult https://click.palletsprojects.com/en/7.x/python3/ for"
+        " mitigation steps." + extra
     )
diff --git a/src/click/_winconsole.py b/src/click/_winconsole.py
index 686a239..ca43502 100644
--- a/src/click/_winconsole.py
+++ b/src/click/_winconsole.py
@@ -38,6 +38,7 @@ from ._compat import text_type
 
 try:
     from ctypes import pythonapi
+
     PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
     PyBuffer_Release = pythonapi.PyBuffer_Release
 except ImportError:
@@ -52,13 +53,13 @@ ReadConsoleW = kernel32.ReadConsoleW
 WriteConsoleW = kernel32.WriteConsoleW
 GetConsoleMode = kernel32.GetConsoleMode
 GetLastError = kernel32.GetLastError
-GetCommandLineW = WINFUNCTYPE(LPWSTR)(
-    ('GetCommandLineW', windll.kernel32))
-CommandLineToArgvW = WINFUNCTYPE(
-    POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
-        ('CommandLineToArgvW', windll.shell32))
+GetCommandLineW = WINFUNCTYPE(LPWSTR)(("GetCommandLineW", windll.kernel32))
+CommandLineToArgvW = WINFUNCTYPE(POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
+    ("CommandLineToArgvW", windll.shell32)
+)
 LocalFree = WINFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)(
-    ('LocalFree', windll.kernel32))
+    ("LocalFree", windll.kernel32)
+)
 
 
 STDIN_HANDLE = GetStdHandle(-10)
@@ -77,27 +78,27 @@ STDIN_FILENO = 0
 STDOUT_FILENO = 1
 STDERR_FILENO = 2
 
-EOF = b'\x1a'
+EOF = b"\x1a"
 MAX_BYTES_WRITTEN = 32767
 
 
 class Py_buffer(ctypes.Structure):
     _fields_ = [
-        ('buf', c_void_p),
-        ('obj', py_object),
-        ('len', c_ssize_t),
-        ('itemsize', c_ssize_t),
-        ('readonly', c_int),
-        ('ndim', c_int),
-        ('format', c_char_p),
-        ('shape', c_ssize_p),
-        ('strides', c_ssize_p),
-        ('suboffsets', c_ssize_p),
-        ('internal', c_void_p)
+        ("buf", c_void_p),
+        ("obj", py_object),
+        ("len", c_ssize_t),
+        ("itemsize", c_ssize_t),
+        ("readonly", c_int),
+        ("ndim", c_int),
+        ("format", c_char_p),
+        ("shape", c_ssize_p),
+        ("strides", c_ssize_p),
+        ("suboffsets", c_ssize_p),
+        ("internal", c_void_p),
     ]
 
     if PY2:
-        _fields_.insert(-1, ('smalltable', c_ssize_t * 2))
+        _fields_.insert(-1, ("smalltable", c_ssize_t * 2))
 
 
 # On PyPy we cannot get buffers so our ability to operate here is
@@ -105,6 +106,7 @@ class Py_buffer(ctypes.Structure):
 if pythonapi is None:
     get_buffer = None
 else:
+
     def get_buffer(obj, writable=False):
         buf = Py_buffer()
         flags = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
@@ -117,7 +119,6 @@ else:
 
 
 class _WindowsConsoleRawIOBase(io.RawIOBase):
-
     def __init__(self, handle):
         self.handle = handle
 
@@ -127,7 +128,6 @@ class _WindowsConsoleRawIOBase(io.RawIOBase):
 
 
 class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
-
     def readable(self):
         return True
 
@@ -136,20 +136,26 @@ class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
         if not bytes_to_be_read:
             return 0
         elif bytes_to_be_read % 2:
-            raise ValueError('cannot read odd number of bytes from '
-                             'UTF-16-LE encoded console')
+            raise ValueError(
+                "cannot read odd number of bytes from UTF-16-LE encoded console"
+            )
 
         buffer = get_buffer(b, writable=True)
         code_units_to_be_read = bytes_to_be_read // 2
         code_units_read = c_ulong()
 
-        rv = ReadConsoleW(HANDLE(self.handle), buffer, code_units_to_be_read,
-                          byref(code_units_read), None)
+        rv = ReadConsoleW(
+            HANDLE(self.handle),
+            buffer,
+            code_units_to_be_read,
+            byref(code_units_read),
+            None,
+        )
         if GetLastError() == ERROR_OPERATION_ABORTED:
             # wait for KeyboardInterrupt
             time.sleep(0.1)
         if not rv:
-            raise OSError('Windows error: %s' % GetLastError())
+            raise OSError("Windows error: %s" % GetLastError())
 
         if buffer[0] == EOF:
             return 0
@@ -157,27 +163,30 @@ class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
 
 
 class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
-
     def writable(self):
         return True
 
     @staticmethod
     def _get_error_message(errno):
         if errno == ERROR_SUCCESS:
-            return 'ERROR_SUCCESS'
+            return "ERROR_SUCCESS"
         elif errno == ERROR_NOT_ENOUGH_MEMORY:
-            return 'ERROR_NOT_ENOUGH_MEMORY'
-        return 'Windows error %s' % errno
+            return "ERROR_NOT_ENOUGH_MEMORY"
+        return "Windows error %s" % errno
 
     def write(self, b):
         bytes_to_be_written = len(b)
         buf = get_buffer(b)
-        code_units_to_be_written = min(bytes_to_be_written,
-                                       MAX_BYTES_WRITTEN) // 2
+        code_units_to_be_written = min(bytes_to_be_written, MAX_BYTES_WRITTEN) // 2
         code_units_written = c_ulong()
 
-        WriteConsoleW(HANDLE(self.handle), buf, code_units_to_be_written,
-                      byref(code_units_written), None)
+        WriteConsoleW(
+            HANDLE(self.handle),
+            buf,
+            code_units_to_be_written,
+            byref(code_units_written),
+            None,
+        )
         bytes_written = 2 * code_units_written.value
 
         if bytes_written == 0 and bytes_to_be_written > 0:
@@ -186,7 +195,6 @@ class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
 
 
 class ConsoleStream(object):
-
     def __init__(self, text_stream, byte_stream):
         self._text_stream = text_stream
         self.buffer = byte_stream
@@ -215,10 +223,7 @@ class ConsoleStream(object):
         return self.buffer.isatty()
 
     def __repr__(self):
-        return '<ConsoleStream name=%r encoding=%r>' % (
-            self.name,
-            self.encoding,
-        )
+        return "<ConsoleStream name=%r encoding=%r>" % (self.name, self.encoding,)
 
 
 class WindowsChunkedWriter(object):
@@ -227,6 +232,7 @@ class WindowsChunkedWriter(object):
     attribute access apart from method 'write()' which we wrap to write in
     limited chunks due to a Windows limitation on binary console streams.
     """
+
     def __init__(self, wrapped):
         # double-underscore everything to prevent clashes with names of
         # attributes on the wrapped stream object.
@@ -241,7 +247,7 @@ class WindowsChunkedWriter(object):
 
         while written < total_to_write:
             to_write = min(total_to_write - written, MAX_BYTES_WRITTEN)
-            self.__wrapped.write(text[written:written+to_write])
+            self.__wrapped.write(text[written : written + to_write])
             written += to_write
 
 
@@ -250,7 +256,11 @@ _wrapped_std_streams = set()
 
 def _wrap_std_stream(name):
     # Python 2 & Windows 7 and below
-    if PY2 and sys.getwindowsversion()[:2] <= (6, 1) and name not in _wrapped_std_streams:
+    if (
+        PY2
+        and sys.getwindowsversion()[:2] <= (6, 1)
+        and name not in _wrapped_std_streams
+    ):
         setattr(sys, name, WindowsChunkedWriter(getattr(sys, name)))
         _wrapped_std_streams.add(name)
 
@@ -258,27 +268,37 @@ def _wrap_std_stream(name):
 def _get_text_stdin(buffer_stream):
     text_stream = _NonClosingTextIOWrapper(
         io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
-        'utf-16-le', 'strict', line_buffering=True)
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
     return ConsoleStream(text_stream, buffer_stream)
 
 
 def _get_text_stdout(buffer_stream):
     text_stream = _NonClosingTextIOWrapper(
         io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
-        'utf-16-le', 'strict', line_buffering=True)
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
     return ConsoleStream(text_stream, buffer_stream)
 
 
 def _get_text_stderr(buffer_stream):
     text_stream = _NonClosingTextIOWrapper(
         io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
-        'utf-16-le', 'strict', line_buffering=True)
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
     return ConsoleStream(text_stream, buffer_stream)
 
 
 if PY2:
+
     def _hash_py_argv():
-        return zlib.crc32('\x00'.join(sys.argv[1:]))
+        return zlib.crc32("\x00".join(sys.argv[1:]))
 
     _initial_argv_hash = _hash_py_argv()
 
@@ -293,14 +313,14 @@ if PY2:
             LocalFree(argv_unicode)
             del argv_unicode
 
-        if not hasattr(sys, 'frozen'):
+        if not hasattr(sys, "frozen"):
             argv = argv[1:]
             while len(argv) > 0:
                 arg = argv[0]
-                if not arg.startswith('-') or arg == '-':
+                if not arg.startswith("-") or arg == "-":
                     break
                 argv = argv[1:]
-                if arg.startswith(('-c', '-m')):
+                if arg.startswith(("-c", "-m")):
                     break
 
         return argv[1:]
@@ -314,7 +334,7 @@ _stream_factories = {
 
 
 def _is_console(f):
-    if not hasattr(f, 'fileno'):
+    if not hasattr(f, "fileno"):
         return False
 
     try:
@@ -327,14 +347,16 @@ def _is_console(f):
 
 
 def _get_windows_console_stream(f, encoding, errors):
-    if get_buffer is not None and \
-       encoding in ('utf-16-le', None) \
-       and errors in ('strict', None) and \
-       _is_console(f):
+    if (
+        get_buffer is not None
+        and encoding in ("utf-16-le", None)
+        and errors in ("strict", None)
+        and _is_console(f)
+    ):
         func = _stream_factories.get(f.fileno())
         if func is not None:
             if not PY2:
-                f = getattr(f, 'buffer', None)
+                f = getattr(f, "buffer", None)
                 if f is None:
                     return None
             else:
diff --git a/src/click/core.py b/src/click/core.py
index 96c3ebc..ea46e86 100644
--- a/src/click/core.py
+++ b/src/click/core.py
@@ -38,17 +38,18 @@ from .utils import PacifyFlushWrapper
 
 _missing = object()
 
-SUBCOMMAND_METAVAR = 'COMMAND [ARGS]...'
-SUBCOMMANDS_METAVAR = 'COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...'
+SUBCOMMAND_METAVAR = "COMMAND [ARGS]..."
+SUBCOMMANDS_METAVAR = "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..."
 
-DEPRECATED_HELP_NOTICE = ' (DEPRECATED)'
-DEPRECATED_INVOKE_NOTICE = 'DeprecationWarning: ' + \
-                           'The command %(name)s is deprecated.'
+DEPRECATED_HELP_NOTICE = " (DEPRECATED)"
+DEPRECATED_INVOKE_NOTICE = (
+    "DeprecationWarning: " + "The command %(name)s is deprecated."
+)
 
 
 def _maybe_show_deprecated_notice(cmd):
     if cmd.deprecated:
-        echo(style(DEPRECATED_INVOKE_NOTICE % {'name': cmd.name}, fg='red'), err=True)
+        echo(style(DEPRECATED_INVOKE_NOTICE % {"name": cmd.name}, fg="red"), err=True)
 
 
 def fast_exit(code):
@@ -63,12 +64,13 @@ def fast_exit(code):
 def _bashcomplete(cmd, prog_name, complete_var=None):
     """Internal handler for the bash completion support."""
     if complete_var is None:
-        complete_var = '_%s_COMPLETE' % (prog_name.replace('-', '_')).upper()
+        complete_var = "_%s_COMPLETE" % (prog_name.replace("-", "_")).upper()
     complete_instr = os.environ.get(complete_var)
     if not complete_instr:
         return
 
     from ._bashcomplete import bashcomplete
+
     if bashcomplete(cmd, prog_name, complete_var, complete_instr):
         fast_exit(1)
 
@@ -77,19 +79,30 @@ def _check_multicommand(base_command, cmd_name, cmd, register=False):
     if not base_command.chain or not isinstance(cmd, MultiCommand):
         return
     if register:
-        hint = 'It is not possible to add multi commands as children to ' \
-               'another multi command that is in chain mode'
+        hint = (
+            "It is not possible to add multi commands as children to "
+            "another multi command that is in chain mode"
+        )
     else:
-        hint = 'Found a multi command as subcommand to a multi command ' \
-               'that is in chain mode.  This is not supported'
-    raise RuntimeError('%s.  Command "%s" is set to chain and "%s" was '
-                       'added as subcommand but it in itself is a '
-                       'multi command.  ("%s" is a %s within a chained '
-                       '%s named "%s").' % (
-                           hint, base_command.name, cmd_name,
-                           cmd_name, cmd.__class__.__name__,
-                           base_command.__class__.__name__,
-                           base_command.name))
+        hint = (
+            "Found a multi command as subcommand to a multi command "
+            "that is in chain mode.  This is not supported"
+        )
+    raise RuntimeError(
+        '%s.  Command "%s" is set to chain and "%s" was '
+        "added as subcommand but it in itself is a "
+        'multi command.  ("%s" is a %s within a chained '
+        '%s named "%s").'
+        % (
+            hint,
+            base_command.name,
+            cmd_name,
+            cmd_name,
+            cmd.__class__.__name__,
+            base_command.__class__.__name__,
+            base_command.name,
+        )
+    )
 
 
 def batch(iterable, batch_size):
@@ -97,16 +110,21 @@ def batch(iterable, batch_size):
 
 
 def invoke_param_callback(callback, ctx, param, value):
-    code = getattr(callback, '__code__', None)
-    args = getattr(code, 'co_argcount', 3)
+    code = getattr(callback, "__code__", None)
+    args = getattr(code, "co_argcount", 3)
 
     if args < 3:
         # This will become a warning in Click 3.0:
         from warnings import warn
-        warn(Warning('Invoked legacy parameter callback "%s".  The new '
-                     'signature for such callbacks starting with '
-                     'click 2.0 is (ctx, param, value).'
-                     % callback), stacklevel=3)
+
+        warn(
+            Warning(
+                'Invoked legacy parameter callback "%s".  The new '
+                "signature for such callbacks starting with "
+                "click 2.0 is (ctx, param, value)." % callback
+            ),
+            stacklevel=3,
+        )
         return callback(ctx, value)
     return callback(ctx, param, value)
 
@@ -135,11 +153,12 @@ def iter_params_for_processing(invocation_order, declaration_order):
     for processing and an iterable of parameters that exist, this returns
     a list in the correct order as they should be processed.
     """
+
     def sort_key(item):
         try:
             idx = invocation_order.index(item)
         except ValueError:
-            idx = float('inf')
+            idx = float("inf")
         return (not item.is_eager, idx)
 
     return sorted(declaration_order, key=sort_key)
@@ -231,13 +250,25 @@ class Context(object):
                     this command-level setting overrides it.
     """
 
-    def __init__(self, command, parent=None, info_name=None, obj=None,
-                 auto_envvar_prefix=None, default_map=None,
-                 terminal_width=None, max_content_width=None,
-                 resilient_parsing=False, allow_extra_args=None,
-                 allow_interspersed_args=None,
-                 ignore_unknown_options=None, help_option_names=None,
-                 token_normalize_func=None, color=None, show_default=None):
+    def __init__(
+        self,
+        command,
+        parent=None,
+        info_name=None,
+        obj=None,
+        auto_envvar_prefix=None,
+        default_map=None,
+        terminal_width=None,
+        max_content_width=None,
+        resilient_parsing=False,
+        allow_extra_args=None,
+        allow_interspersed_args=None,
+        ignore_unknown_options=None,
+        help_option_names=None,
+        token_normalize_func=None,
+        color=None,
+        show_default=None,
+    ):
         #: the parent context or `None` if none exists.
         self.parent = parent
         #: the :class:`Command` for this context.
@@ -258,12 +289,14 @@ class Context(object):
             obj = parent.obj
         #: the user object stored.
         self.obj = obj
-        self._meta = getattr(parent, 'meta', {})
+        self._meta = getattr(parent, "meta", {})
 
         #: A dictionary (-like object) with defaults for parameters.
-        if default_map is None \
-           and parent is not None \
-           and parent.default_map is not None:
+        if (
+            default_map is None
+            and parent is not None
+            and parent.default_map is not None
+        ):
             default_map = parent.default_map.get(info_name)
         self.default_map = default_map
 
@@ -322,7 +355,7 @@ class Context(object):
             if parent is not None:
                 help_option_names = parent.help_option_names
             else:
-                help_option_names = ['--help']
+                help_option_names = ["--help"]
 
         #: The names for the help options.
         self.help_option_names = help_option_names
@@ -343,11 +376,15 @@ class Context(object):
         # the command on this level has a name, we can expand the envvar
         # prefix automatically.
         if auto_envvar_prefix is None:
-            if parent is not None \
-               and parent.auto_envvar_prefix is not None and \
-               self.info_name is not None:
-                auto_envvar_prefix = '%s_%s' % (parent.auto_envvar_prefix,
-                                           self.info_name.upper())
+            if (
+                parent is not None
+                and parent.auto_envvar_prefix is not None
+                and self.info_name is not None
+            ):
+                auto_envvar_prefix = "%s_%s" % (
+                    parent.auto_envvar_prefix,
+                    self.info_name.upper(),
+                )
         else:
             auto_envvar_prefix = auto_envvar_prefix.upper()
         if auto_envvar_prefix is not None:
@@ -444,8 +481,9 @@ class Context(object):
 
     def make_formatter(self):
         """Creates the formatter for the help and usage output."""
-        return HelpFormatter(width=self.terminal_width,
-                             max_width=self.max_content_width)
+        return HelpFormatter(
+            width=self.terminal_width, max_width=self.max_content_width
+        )
 
     def call_on_close(self, f):
         """This decorator remembers a function as callback that should be
@@ -471,11 +509,11 @@ class Context(object):
         information on the help page.  It's automatically created by
         combining the info names of the chain of contexts to the root.
         """
-        rv = ''
+        rv = ""
         if self.info_name is not None:
             rv = self.info_name
         if self.parent is not None:
-            rv = self.parent.command_path + ' ' + rv
+            rv = self.parent.command_path + " " + rv
         return rv.lstrip()
 
     def find_root(self):
@@ -567,8 +605,9 @@ class Context(object):
             callback = other_cmd.callback
             ctx = Context(other_cmd, info_name=other_cmd.name, parent=self)
             if callback is None:
-                raise TypeError('The given command does not have a '
-                                'callback that can be invoked.')
+                raise TypeError(
+                    "The given command does not have a callback that can be invoked."
+                )
 
             for param in other_cmd.params:
                 if param.name not in kwargs and param.expose_value:
@@ -589,7 +628,7 @@ class Context(object):
         # It's also possible to invoke another command which might or
         # might not have a callback.
         if not isinstance(cmd, Command):
-            raise TypeError('Callback is not a command.')
+            raise TypeError("Callback is not a command.")
 
         for param in self.params:
             if param not in kwargs:
@@ -619,6 +658,7 @@ class BaseCommand(object):
     :param context_settings: an optional dictionary with defaults that are
                              passed to the context object.
     """
+
     #: the default for the :attr:`Context.allow_extra_args` flag.
     allow_extra_args = False
     #: the default for the :attr:`Context.allow_interspersed_args` flag.
@@ -641,10 +681,10 @@ class BaseCommand(object):
         return "<%s %s>" % (self.__class__.__name__, self.name)
 
     def get_usage(self, ctx):
-        raise NotImplementedError('Base commands cannot get usage')
+        raise NotImplementedError("Base commands cannot get usage")
 
     def get_help(self, ctx):
-        raise NotImplementedError('Base commands cannot get help')
+        raise NotImplementedError("Base commands cannot get help")
 
     def make_context(self, info_name, args, parent=None, **extra):
         """This function when given an info name and arguments will kick
@@ -674,17 +714,24 @@ class BaseCommand(object):
         and parses the arguments, then modifies the context as necessary.
         This is automatically invoked by :meth:`make_context`.
         """
-        raise NotImplementedError('Base commands do not know how to parse '
-                                  'arguments.')
+        raise NotImplementedError(
+            "Base commands do not know how to parse arguments."
+        )
 
     def invoke(self, ctx):
         """Given a context, this invokes the command.  The default
         implementation is raising a not implemented error.
         """
-        raise NotImplementedError('Base commands are not invokable by default')
-
-    def main(self, args=None, prog_name=None, complete_var=None,
-             standalone_mode=True, **extra):
+        raise NotImplementedError("Base commands are not invokable by default")
+
+    def main(
+        self,
+        args=None,
+        prog_name=None,
+        complete_var=None,
+        standalone_mode=True,
+        **extra
+    ):
         """This is the way to invoke a script with all the bells and
         whistles as a command line application.  This will always terminate
         the application after a call.  If this is not wanted, ``SystemExit``
@@ -731,8 +778,7 @@ class BaseCommand(object):
             args = list(args)
 
         if prog_name is None:
-            prog_name = make_str(os.path.basename(
-                sys.argv and sys.argv[0] or __file__))
+            prog_name = make_str(os.path.basename(sys.argv and sys.argv[0] or __file__))
 
         # Hook for the Bash completion.  This only activates if the Bash
         # completion is actually enabled, otherwise this is quite a fast
@@ -784,7 +830,7 @@ class BaseCommand(object):
         except Abort:
             if not standalone_mode:
                 raise
-            echo('Aborted!', file=sys.stderr)
+            echo("Aborted!", file=sys.stderr)
             sys.exit(1)
 
     def __call__(self, *args, **kwargs):
@@ -825,10 +871,21 @@ class Command(BaseCommand):
                              the command is deprecated.
     """
 
-    def __init__(self, name, context_settings=None, callback=None,
-                 params=None, help=None, epilog=None, short_help=None,
-                 options_metavar='[OPTIONS]', add_help_option=True,
-                 no_args_is_help=False, hidden=False, deprecated=False):
+    def __init__(
+        self,
+        name,
+        context_settings=None,
+        callback=None,
+        params=None,
+        help=None,
+        epilog=None,
+        short_help=None,
+        options_metavar="[OPTIONS]",
+        add_help_option=True,
+        no_args_is_help=False,
+        hidden=False,
+        deprecated=False,
+    ):
         BaseCommand.__init__(self, name, context_settings)
         #: the callback to execute when the command fires.  This might be
         #: `None` in which case nothing happens.
@@ -839,8 +896,8 @@ class Command(BaseCommand):
         self.params = params or []
         # if a form feed (page break) is found in the help text, truncate help
         # text to the content preceding the first form feed
-        if help and '\f' in help:
-            help = help.split('\f', 1)[0]
+        if help and "\f" in help:
+            help = help.split("\f", 1)[0]
         self.help = help
         self.epilog = epilog
         self.options_metavar = options_metavar
@@ -857,7 +914,7 @@ class Command(BaseCommand):
         """
         formatter = ctx.make_formatter()
         self.format_usage(ctx, formatter)
-        return formatter.getvalue().rstrip('\n')
+        return formatter.getvalue().rstrip("\n")
 
     def get_params(self, ctx):
         rv = self.params
@@ -872,7 +929,7 @@ class Command(BaseCommand):
         This is a low-level method called by :meth:`get_usage`.
         """
         pieces = self.collect_usage_pieces(ctx)
-        formatter.write_usage(ctx.command_path, ' '.join(pieces))
+        formatter.write_usage(ctx.command_path, " ".join(pieces))
 
     def collect_usage_pieces(self, ctx):
         """Returns all the pieces that go into the usage line and returns
@@ -901,10 +958,15 @@ class Command(BaseCommand):
             if value and not ctx.resilient_parsing:
                 echo(ctx.get_help(), color=ctx.color)
                 ctx.exit()
-        return Option(help_options, is_flag=True,
-                      is_eager=True, expose_value=False,
-                      callback=show_help,
-                      help='Show this message and exit.')
+
+        return Option(
+            help_options,
+            is_flag=True,
+            is_eager=True,
+            expose_value=False,
+            callback=show_help,
+            help="Show this message and exit.",
+        )
 
     def make_parser(self, ctx):
         """Creates the underlying option parser for this command."""
@@ -920,11 +982,16 @@ class Command(BaseCommand):
         """
         formatter = ctx.make_formatter()
         self.format_help(ctx, formatter)
-        return formatter.getvalue().rstrip('\n')
+        return formatter.getvalue().rstrip("\n")
 
     def get_short_help_str(self, limit=45):
         """Gets short help for the command or makes it by shortening the long help string."""
-        return self.short_help or self.help and make_default_short_help(self.help, limit) or ''
+        return (
+            self.short_help
+            or self.help
+            and make_default_short_help(self.help, limit)
+            or ""
+        )
 
     def format_help(self, ctx, formatter):
         """Writes the help into the formatter if it exists.
@@ -966,7 +1033,7 @@ class Command(BaseCommand):
                 opts.append(rv)
 
         if opts:
-            with formatter.section('Options'):
+            with formatter.section("Options"):
                 formatter.write_dl(opts)
 
     def format_epilog(self, ctx, formatter):
@@ -984,14 +1051,14 @@ class Command(BaseCommand):
         parser = self.make_parser(ctx)
         opts, args, param_order = parser.parse_args(args=args)
 
-        for param in iter_params_for_processing(
-                param_order, self.get_params(ctx)):
+        for param in iter_params_for_processing(param_order, self.get_params(ctx)):
             value, args = param.handle_parse_result(ctx, opts, args)
 
         if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
-            ctx.fail('Got unexpected extra argument%s (%s)'
-                     % (len(args) != 1 and 's' or '',
-                        ' '.join(map(make_str, args))))
+            ctx.fail(
+                "Got unexpected extra argument%s (%s)"
+                % (len(args) != 1 and "s" or "", " ".join(map(make_str, args)))
+            )
 
         ctx.args = args
         return args
@@ -1028,12 +1095,20 @@ class MultiCommand(Command):
     :param result_callback: the result callback to attach to this multi
                             command.
     """
+
     allow_extra_args = True
     allow_interspersed_args = False
 
-    def __init__(self, name=None, invoke_without_command=False,
-                 no_args_is_help=None, subcommand_metavar=None,
-                 chain=False, result_callback=None, **attrs):
+    def __init__(
+        self,
+        name=None,
+        invoke_without_command=False,
+        no_args_is_help=None,
+        subcommand_metavar=None,
+        chain=False,
+        result_callback=None,
+        **attrs
+    ):
         Command.__init__(self, name, **attrs)
         if no_args_is_help is None:
             no_args_is_help = not invoke_without_command
@@ -1053,8 +1128,10 @@ class MultiCommand(Command):
         if self.chain:
             for param in self.params:
                 if isinstance(param, Argument) and not param.required:
-                    raise RuntimeError('Multi commands in chain mode cannot '
-                                       'have optional arguments.')
+                    raise RuntimeError(
+                        "Multi commands in chain mode cannot "
+                        "have optional arguments."
+                    )
 
     def collect_usage_pieces(self, ctx):
         rv = Command.collect_usage_pieces(self, ctx)
@@ -1090,16 +1167,19 @@ class MultiCommand(Command):
         :param replace: if set to `True` an already existing result
                         callback will be removed.
         """
+
         def decorator(f):
             old_callback = self.result_callback
             if old_callback is None or replace:
                 self.result_callback = f
                 return f
+
             def function(__value, *args, **kwargs):
-                return f(old_callback(__value, *args, **kwargs),
-                         *args, **kwargs)
+                return f(old_callback(__value, *args, **kwargs), *args, **kwargs)
+
             self.result_callback = rv = update_wrapper(function, f)
             return rv
+
         return decorator
 
     def format_commands(self, ctx, formatter):
@@ -1127,7 +1207,7 @@ class MultiCommand(Command):
                 rows.append((subcommand, help))
 
             if rows:
-                with formatter.section('Commands'):
+                with formatter.section("Commands"):
                     formatter.write_dl(rows)
 
     def parse_args(self, ctx, args):
@@ -1147,8 +1227,7 @@ class MultiCommand(Command):
     def invoke(self, ctx):
         def _process_result(value):
             if self.result_callback is not None:
-                value = ctx.invoke(self.result_callback, value,
-                                   **ctx.params)
+                value = ctx.invoke(self.result_callback, value, **ctx.params)
             return value
 
         if not ctx.protected_args:
@@ -1164,7 +1243,7 @@ class MultiCommand(Command):
                 with ctx:
                     Command.invoke(self, ctx)
                     return _process_result([])
-            ctx.fail('Missing command.')
+            ctx.fail("Missing command.")
 
         # Fetch args back out
         args = ctx.protected_args + ctx.args
@@ -1191,7 +1270,7 @@ class MultiCommand(Command):
         # set to ``*`` to inform the command that subcommands are executed
         # but nothing else.
         with ctx:
-            ctx.invoked_subcommand = args and '*' or None
+            ctx.invoked_subcommand = args and "*" or None
             Command.invoke(self, ctx)
 
             # Otherwise we make every single context and invoke them in a
@@ -1200,9 +1279,13 @@ class MultiCommand(Command):
             contexts = []
             while args:
                 cmd_name, cmd, args = self.resolve_command(ctx, args)
-                sub_ctx = cmd.make_context(cmd_name, args, parent=ctx,
-                                           allow_extra_args=True,
-                                           allow_interspersed_args=False)
+                sub_ctx = cmd.make_context(
+                    cmd_name,
+                    args,
+                    parent=ctx,
+                    allow_extra_args=True,
+                    allow_interspersed_args=False,
+                )
                 contexts.append(sub_ctx)
                 args, sub_ctx.args = sub_ctx.args, []
 
@@ -1269,7 +1352,7 @@ class Group(MultiCommand):
         """
         name = name or cmd.name
         if name is None:
-            raise TypeError('Command has no name.')
+            raise TypeError("Command has no name.")
         _check_multicommand(self, name, cmd, register=True)
         self.commands[name] = cmd
 
@@ -1279,10 +1362,12 @@ class Group(MultiCommand):
         immediately registers the created command with this instance by
         calling into :meth:`add_command`.
         """
+
         def decorator(f):
             cmd = command(*args, **kwargs)(f)
             self.add_command(cmd)
             return cmd
+
         return decorator
 
     def group(self, *args, **kwargs):
@@ -1291,10 +1376,12 @@ class Group(MultiCommand):
         immediately registers the created command with this instance by
         calling into :meth:`add_command`.
         """
+
         def decorator(f):
             cmd = group(*args, **kwargs)(f)
             self.add_command(cmd)
             return cmd
+
         return decorator
 
     def get_command(self, ctx, cmd_name):
@@ -1381,14 +1468,25 @@ class Parameter(object):
         parameter. The old callback format will still work, but it will
         raise a warning to give you a chance to migrate the code easier.
     """
-    param_type_name = 'parameter'
-
-    def __init__(self, param_decls=None, type=None, required=False,
-                 default=None, callback=None, nargs=None, metavar=None,
-                 expose_value=True, is_eager=False, envvar=None,
-                 autocompletion=None):
-        self.name, self.opts, self.secondary_opts = \
-            self._parse_decls(param_decls or (), expose_value)
+    param_type_name = "parameter"
+
+    def __init__(
+        self,
+        param_decls=None,
+        type=None,
+        required=False,
+        default=None,
+        callback=None,
+        nargs=None,
+        metavar=None,
+        expose_value=True,
+        is_eager=False,
+        envvar=None,
+        autocompletion=None,
+    ):
+        self.name, self.opts, self.secondary_opts = self._parse_decls(
+            param_decls or (), expose_value
+        )
 
         self.type = convert_type(type, default)
 
@@ -1428,7 +1526,7 @@ class Parameter(object):
         if metavar is None:
             metavar = self.type.name.upper()
         if self.nargs != 1:
-            metavar += '...'
+            metavar += "..."
         return metavar
 
     def get_default(self, ctx):
@@ -1458,10 +1556,12 @@ class Parameter(object):
         """
         if self.type.is_composite:
             if self.nargs <= 1:
-                raise TypeError('Attempted to invoke composite type '
-                                'but nargs has been set to %s.  This is '
-                                'not supported; nargs needs to be set to '
-                                'a fixed value > 1.' % self.nargs)
+                raise TypeError(
+                    "Attempted to invoke composite type "
+                    "but nargs has been set to %s.  This is "
+                    "not supported; nargs needs to be set to "
+                    "a fixed value > 1." % self.nargs
+                )
             if self.multiple:
                 return tuple(self.type(x or (), self, ctx) for x in value or ())
             return self.type(value or (), self, ctx)
@@ -1470,6 +1570,7 @@ class Parameter(object):
             if level == 0:
                 return self.type(value, self, ctx)
             return tuple(_convert(x, level - 1) for x in value or ())
+
         return _convert(value, (self.nargs != 1) + bool(self.multiple))
 
     def process_value(self, ctx, value):
@@ -1532,8 +1633,7 @@ class Parameter(object):
                 value = None
             if self.callback is not None:
                 try:
-                    value = invoke_param_callback(
-                        self.callback, ctx, self, value)
+                    value = invoke_param_callback(self.callback, ctx, self, value)
                 except Exception:
                     if not ctx.resilient_parsing:
                         raise
@@ -1553,7 +1653,7 @@ class Parameter(object):
         indicate which param caused the error.
         """
         hint_list = self.opts or [self.human_readable_name]
-        return ' / '.join('"%s"' % x for x in hint_list)
+        return " / ".join('"%s"' % x for x in hint_list)
 
 
 class Option(Parameter):
@@ -1594,19 +1694,33 @@ class Option(Parameter):
     :param help: the help string.
     :param hidden: hide this option from help outputs.
     """
-    param_type_name = 'option'
-
-    def __init__(self, param_decls=None, show_default=False,
-                 prompt=False, confirmation_prompt=False,
-                 hide_input=False, is_flag=None, flag_value=None,
-                 multiple=False, count=False, allow_from_autoenv=True,
-                 type=None, help=None, hidden=False, show_choices=True,
-                 show_envvar=False, **attrs):
-        default_is_missing = attrs.get('default', _missing) is _missing
+
+    param_type_name = "option"
+
+    def __init__(
+        self,
+        param_decls=None,
+        show_default=False,
+        prompt=False,
+        confirmation_prompt=False,
+        hide_input=False,
+        is_flag=None,
+        flag_value=None,
+        multiple=False,
+        count=False,
+        allow_from_autoenv=True,
+        type=None,
+        help=None,
+        hidden=False,
+        show_choices=True,
+        show_envvar=False,
+        **attrs
+    ):
+        default_is_missing = attrs.get("default", _missing) is _missing
         Parameter.__init__(self, param_decls, type=type, **attrs)
 
         if prompt is True:
-            prompt_text = self.name.replace('_', ' ').capitalize()
+            prompt_text = self.name.replace("_", " ").capitalize()
         elif prompt is False:
             prompt_text = None
         else:
@@ -1628,8 +1742,7 @@ class Option(Parameter):
             flag_value = not self.default
         self.is_flag = is_flag
         self.flag_value = flag_value
-        if self.is_flag and isinstance(self.flag_value, bool) \
-           and type in [None, bool]:
+        if self.is_flag and isinstance(self.flag_value, bool) and type in [None, bool]:
             self.type = BOOL
             self.is_bool_flag = True
         else:
@@ -1653,22 +1766,24 @@ class Option(Parameter):
         # Sanity check for stuff we don't support
         if __debug__:
             if self.nargs < 0:
-                raise TypeError('Options cannot have nargs < 0')
+                raise TypeError("Options cannot have nargs < 0")
             if self.prompt and self.is_flag and not self.is_bool_flag:
-                raise TypeError('Cannot prompt for flags that are not bools.')
+                raise TypeError("Cannot prompt for flags that are not bools.")
             if not self.is_bool_flag and self.secondary_opts:
-                raise TypeError('Got secondary option for non boolean flag.')
-            if self.is_bool_flag and self.hide_input \
-               and self.prompt is not None:
-                raise TypeError('Hidden input does not work with boolean '
-                                'flag prompts.')
+                raise TypeError("Got secondary option for non boolean flag.")
+            if self.is_bool_flag and self.hide_input and self.prompt is not None:
+                raise TypeError(
+                    "Hidden input does not work with boolean flag prompts."
+                )
             if self.count:
                 if self.multiple:
-                    raise TypeError('Options cannot be multiple and count '
-                                    'at the same time.')
+                    raise TypeError(
+                        "Options cannot be multiple and count at the same time."
+                    )
                 elif self.is_flag:
-                    raise TypeError('Options cannot be count and flags at '
-                                    'the same time.')
+                    raise TypeError(
+                        "Options cannot be count and flags at the same time."
+                    )
 
     def _parse_decls(self, decls, expose_value):
         opts = []
@@ -1679,10 +1794,10 @@ class Option(Parameter):
         for decl in decls:
             if isidentifier(decl):
                 if name is not None:
-                    raise TypeError('Name defined twice')
+                    raise TypeError("Name defined twice")
                 name = decl
             else:
-                split_char = decl[:1] == '/' and ';' or '/'
+                split_char = decl[:1] == "/" and ";" or "/"
                 if split_char in decl:
                     first, second = decl.split(split_char, 1)
                     first = first.rstrip()
@@ -1698,49 +1813,53 @@ class Option(Parameter):
 
         if name is None and possible_names:
             possible_names.sort(key=lambda x: -len(x[0]))  # group long options first
-            name = possible_names[0][1].replace('-', '_').lower()
+            name = possible_names[0][1].replace("-", "_").lower()
             if not isidentifier(name):
                 name = None
 
         if name is None:
             if not expose_value:
                 return None, opts, secondary_opts
-            raise TypeError('Could not determine name for option')
+            raise TypeError("Could not determine name for option")
 
         if not opts and not secondary_opts:
-            raise TypeError('No options defined but a name was passed (%s). '
-                            'Did you mean to declare an argument instead '
-                            'of an option?' % name)
+            raise TypeError(
+                "No options defined but a name was passed (%s). "
+                "Did you mean to declare an argument instead "
+                "of an option?" % name
+            )
 
         return name, opts, secondary_opts
 
     def add_to_parser(self, parser, ctx):
         kwargs = {
-            'dest': self.name,
-            'nargs': self.nargs,
-            'obj': self,
+            "dest": self.name,
+            "nargs": self.nargs,
+            "obj": self,
         }
 
         if self.multiple:
-            action = 'append'
+            action = "append"
         elif self.count:
-            action = 'count'
+            action = "count"
         else:
-            action = 'store'
+            action = "store"
 
         if self.is_flag:
-            kwargs.pop('nargs', None)
+            kwargs.pop("nargs", None)
             if self.is_bool_flag and self.secondary_opts:
-                parser.add_option(self.opts, action=action + '_const',
-                                  const=True, **kwargs)
-                parser.add_option(self.secondary_opts, action=action +
-                                  '_const', const=False, **kwargs)
+                parser.add_option(
+                    self.opts, action=action + "_const", const=True, **kwargs
+                )
+                parser.add_option(
+                    self.secondary_opts, action=action + "_const", const=False, **kwargs
+                )
             else:
-                parser.add_option(self.opts, action=action + '_const',
-                                  const=self.flag_value,
-                                  **kwargs)
+                parser.add_option(
+                    self.opts, action=action + "_const", const=self.flag_value, **kwargs
+                )
         else:
-            kwargs['action'] = action
+            kwargs["action"] = action
             parser.add_option(self.opts, **kwargs)
 
     def get_help_record(self, ctx):
@@ -1753,44 +1872,46 @@ class Option(Parameter):
             if any_slashes:
                 any_prefix_is_slash[:] = [True]
             if not self.is_flag and not self.count:
-                rv += ' ' + self.make_metavar()
+                rv += " " + self.make_metavar()
             return rv
 
         rv = [_write_opts(self.opts)]
         if self.secondary_opts:
             rv.append(_write_opts(self.secondary_opts))
 
-        help = self.help or ''
+        help = self.help or ""
         extra = []
         if self.show_envvar:
             envvar = self.envvar
             if envvar is None:
-                if self.allow_from_autoenv and \
-                    ctx.auto_envvar_prefix is not None:
-                    envvar = '%s_%s' % (ctx.auto_envvar_prefix, self.name.upper())
+                if self.allow_from_autoenv and ctx.auto_envvar_prefix is not None:
+                    envvar = "%s_%s" % (ctx.auto_envvar_prefix, self.name.upper())
             if envvar is not None:
-              extra.append('env var: %s' % (
-                           ', '.join('%s' % d for d in envvar)
-                           if isinstance(envvar, (list, tuple))
-                           else envvar, ))
-        if self.default is not None and \
-            (self.show_default or ctx.show_default):
+                extra.append(
+                    "env var: %s"
+                    % (
+                        ", ".join("%s" % d for d in envvar)
+                        if isinstance(envvar, (list, tuple))
+                        else envvar,
+                    )
+                )
+        if self.default is not None and (self.show_default or ctx.show_default):
             if isinstance(self.show_default, string_types):
-                default_string = '({})'.format(self.show_default)
+                default_string = "({})".format(self.show_default)
             elif isinstance(self.default, (list, tuple)):
-                default_string = ', '.join('%s' % d for d in self.default)
+                default_string = ", ".join("%s" % d for d in self.default)
             elif inspect.isfunction(self.default):
                 default_string = "(dynamic)"
             else:
                 default_string = self.default
-            extra.append('default: {}'.format(default_string))
+            extra.append("default: {}".format(default_string))
 
         if self.required:
-            extra.append('required')
+            extra.append("required")
         if extra:
-            help = '%s[%s]' % (help and help + '  ' or '', '; '.join(extra))
+            help = "%s[%s]" % (help and help + "  " or "", "; ".join(extra))
 
-        return ((any_prefix_is_slash and '; ' or ' / ').join(rv), help)
+        return ((any_prefix_is_slash and "; " or " / ").join(rv), help)
 
     def get_default(self, ctx):
         # If we're a non boolean flag our default is more complex because
@@ -1818,18 +1939,22 @@ class Option(Parameter):
         if self.is_bool_flag:
             return confirm(self.prompt, default)
 
-        return prompt(self.prompt, default=default, type=self.type,
-                      hide_input=self.hide_input, show_choices=self.show_choices,
-                      confirmation_prompt=self.confirmation_prompt,
-                      value_proc=lambda x: self.process_value(ctx, x))
+        return prompt(
+            self.prompt,
+            default=default,
+            type=self.type,
+            hide_input=self.hide_input,
+            show_choices=self.show_choices,
+            confirmation_prompt=self.confirmation_prompt,
+            value_proc=lambda x: self.process_value(ctx, x),
+        )
 
     def resolve_envvar_value(self, ctx):
         rv = Parameter.resolve_envvar_value(self, ctx)
         if rv is not None:
             return rv
-        if self.allow_from_autoenv and \
-           ctx.auto_envvar_prefix is not None:
-            envvar = '%s_%s' % (ctx.auto_envvar_prefix, self.name.upper())
+        if self.allow_from_autoenv and ctx.auto_envvar_prefix is not None:
+            envvar = "%s_%s" % (ctx.auto_envvar_prefix, self.name.upper())
             return os.environ.get(envvar)
 
     def value_from_envvar(self, ctx):
@@ -1844,8 +1969,7 @@ class Option(Parameter):
         return rv
 
     def full_process_value(self, ctx, value):
-        if value is None and self.prompt is not None \
-           and not ctx.resilient_parsing:
+        if value is None and self.prompt is not None and not ctx.resilient_parsing:
             return self.prompt_for_value(ctx)
         return Parameter.full_process_value(self, ctx, value)
 
@@ -1857,18 +1981,20 @@ class Argument(Parameter):
 
     All parameters are passed onwards to the parameter constructor.
     """
-    param_type_name = 'argument'
+
+    param_type_name = "argument"
 
     def __init__(self, param_decls, required=None, **attrs):
         if required is None:
-            if attrs.get('default') is not None:
+            if attrs.get("default") is not None:
                 required = False
             else:
-                required = attrs.get('nargs', 1) > 0
+                required = attrs.get("nargs", 1) > 0
         Parameter.__init__(self, param_decls, required=required, **attrs)
         if self.default is not None and self.nargs < 0:
-            raise TypeError('nargs=-1 in combination with a default value '
-                            'is not supported.')
+            raise TypeError(
+                "nargs=-1 in combination with a default value is not supported."
+            )
 
     @property
     def human_readable_name(self):
@@ -1883,22 +2009,24 @@ class Argument(Parameter):
         if not var:
             var = self.name.upper()
         if not self.required:
-            var = '[%s]' % var
+            var = "[%s]" % var
         if self.nargs != 1:
-            var += '...'
+            var += "..."
         return var
 
     def _parse_decls(self, decls, expose_value):
         if not decls:
             if not expose_value:
                 return None, [], []
-            raise TypeError('Could not determine name for argument')
+            raise TypeError("Could not determine name for argument")
         if len(decls) == 1:
             name = arg = decls[0]
-            name = name.replace('-', '_').lower()
+            name = name.replace("-", "_").lower()
         else:
-            raise TypeError('Arguments take exactly one '
-                            'parameter declaration, got %d' % len(decls))
+            raise TypeError(
+                "Arguments take exactly one "
+                "parameter declaration, got %d" % len(decls)
+            )
         return name, [arg], []
 
     def get_usage_pieces(self, ctx):
@@ -1908,8 +2036,7 @@ class Argument(Parameter):
         return '"%s"' % self.make_metavar()
 
     def add_to_parser(self, parser, ctx):
-        parser.add_argument(dest=self.name, nargs=self.nargs,
-                            obj=self)
+        parser.add_argument(dest=self.name, nargs=self.nargs, obj=self)
 
 
 # Circular dependency between decorators and core
diff --git a/src/click/decorators.py b/src/click/decorators.py
index bb5a8bc..5f556e2 100644
--- a/src/click/decorators.py
+++ b/src/click/decorators.py
@@ -12,8 +12,10 @@ def pass_context(f):
     """Marks a callback as wanting to receive the current context
     object as first argument.
     """
+
     def new_func(*args, **kwargs):
         return f(get_current_context(), *args, **kwargs)
+
     return update_wrapper(new_func, f)
 
 
@@ -22,8 +24,10 @@ def pass_obj(f):
     context onwards (:attr:`Context.obj`).  This is useful if that object
     represents the state of a nested system.
     """
+
     def new_func(*args, **kwargs):
         return f(get_current_context().obj, *args, **kwargs)
+
     return update_wrapper(new_func, f)
 
 
@@ -49,6 +53,7 @@ def make_pass_decorator(object_type, ensure=False):
     :param ensure: if set to `True`, a new object will be created and
                    remembered on the context if it's not there yet.
     """
+
     def decorator(f):
         def new_func(*args, **kwargs):
             ctx = get_current_context()
@@ -57,35 +62,41 @@ def make_pass_decorator(object_type, ensure=False):
             else:
                 obj = ctx.find_object(object_type)
             if obj is None:
-                raise RuntimeError('Managed to invoke callback without a '
-                                   'context object of type %r existing'
-                                   % object_type.__name__)
+                raise RuntimeError(
+                    "Managed to invoke callback without a "
+                    "context object of type %r existing" % object_type.__name__
+                )
             return ctx.invoke(f, obj, *args, **kwargs)
+
         return update_wrapper(new_func, f)
+
     return decorator
 
 
 def _make_command(f, name, attrs, cls):
     if isinstance(f, Command):
-        raise TypeError('Attempted to convert a callback into a '
-                        'command twice.')
+        raise TypeError("Attempted to convert a callback into a command twice.")
     try:
         params = f.__click_params__
         params.reverse()
         del f.__click_params__
     except AttributeError:
         params = []
-    help = attrs.get('help')
+    help = attrs.get("help")
     if help is None:
         help = inspect.getdoc(f)
         if isinstance(help, bytes):
-            help = help.decode('utf-8')
+            help = help.decode("utf-8")
     else:
         help = inspect.cleandoc(help)
-    attrs['help'] = help
+    attrs["help"] = help
     _check_for_unicode_literals()
-    return cls(name=name or f.__name__.lower().replace('_', '-'),
-               callback=f, params=params, **attrs)
+    return cls(
+        name=name or f.__name__.lower().replace("_", "-"),
+        callback=f,
+        params=params,
+        **attrs
+    )
 
 
 def command(name=None, cls=None, **attrs):
@@ -110,10 +121,12 @@ def command(name=None, cls=None, **attrs):
     """
     if cls is None:
         cls = Command
+
     def decorator(f):
         cmd = _make_command(f, name, attrs, cls)
         cmd.__doc__ = f.__doc__
         return cmd
+
     return decorator
 
 
@@ -122,7 +135,7 @@ def group(name=None, **attrs):
     works otherwise the same as :func:`command` just that the `cls`
     parameter is set to :class:`Group`.
     """
-    attrs.setdefault('cls', Group)
+    attrs.setdefault("cls", Group)
     return command(name, **attrs)
 
 
@@ -130,7 +143,7 @@ def _param_memo(f, param):
     if isinstance(f, Command):
         f.params.append(param)
     else:
-        if not hasattr(f, '__click_params__'):
+        if not hasattr(f, "__click_params__"):
             f.__click_params__ = []
         f.__click_params__.append(param)
 
@@ -145,10 +158,12 @@ def argument(*param_decls, **attrs):
     :param cls: the argument class to instantiate.  This defaults to
                 :class:`Argument`.
     """
+
     def decorator(f):
-        ArgumentClass = attrs.pop('cls', Argument)
+        ArgumentClass = attrs.pop("cls", Argument)
         _param_memo(f, ArgumentClass(param_decls, **attrs))
         return f
+
     return decorator
 
 
@@ -162,15 +177,17 @@ def option(*param_decls, **attrs):
     :param cls: the option class to instantiate.  This defaults to
                 :class:`Option`.
     """
+
     def decorator(f):
         # Issue 926, copy attrs, so pre-defined options can re-use the same cls=
         option_attrs = attrs.copy()
 
-        if 'help' in option_attrs:
-            option_attrs['help'] = inspect.cleandoc(option_attrs['help'])
-        OptionClass = option_attrs.pop('cls', Option)
+        if "help" in option_attrs:
+            option_attrs["help"] = inspect.cleandoc(option_attrs["help"])
+        OptionClass = option_attrs.pop("cls", Option)
         _param_memo(f, OptionClass(param_decls, **option_attrs))
         return f
+
     return decorator
 
 
@@ -191,16 +208,19 @@ def confirmation_option(*param_decls, **attrs):
         def dropdb():
             pass
     """
+
     def decorator(f):
         def callback(ctx, param, value):
             if not value:
                 ctx.abort()
-        attrs.setdefault('is_flag', True)
-        attrs.setdefault('callback', callback)
-        attrs.setdefault('expose_value', False)
-        attrs.setdefault('prompt', 'Do you want to continue?')
-        attrs.setdefault('help', 'Confirm the action without prompting.')
-        return option(*(param_decls or ('--yes',)), **attrs)(f)
+
+        attrs.setdefault("is_flag", True)
+        attrs.setdefault("callback", callback)
+        attrs.setdefault("expose_value", False)
+        attrs.setdefault("prompt", "Do you want to continue?")
+        attrs.setdefault("help", "Confirm the action without prompting.")
+        return option(*(param_decls or ("--yes",)), **attrs)(f)
+
     return decorator
 
 
@@ -216,11 +236,13 @@ def password_option(*param_decls, **attrs):
         def changeadmin(password):
             pass
     """
+
     def decorator(f):
-        attrs.setdefault('prompt', True)
-        attrs.setdefault('confirmation_prompt', True)
-        attrs.setdefault('hide_input', True)
-        return option(*(param_decls or ('--password',)), **attrs)(f)
+        attrs.setdefault("prompt", True)
+        attrs.setdefault("confirmation_prompt", True)
+        attrs.setdefault("hide_input", True)
+        return option(*(param_decls or ("--password",)), **attrs)(f)
+
     return decorator
 
 
@@ -237,14 +259,14 @@ def version_option(version=None, *param_decls, **attrs):
     :param others: everything else is forwarded to :func:`option`.
     """
     if version is None:
-        if hasattr(sys, '_getframe'):
-            module = sys._getframe(1).f_globals.get('__name__')
+        if hasattr(sys, "_getframe"):
+            module = sys._getframe(1).f_globals.get("__name__")
         else:
-            module = ''
+            module = ""
 
     def decorator(f):
-        prog_name = attrs.pop('prog_name', None)
-        message = attrs.pop('message', '%(prog)s, version %(version)s')
+        prog_name = attrs.pop("prog_name", None)
+        message = attrs.pop("message", "%(prog)s, version %(version)s")
 
         def callback(ctx, param, value):
             if not value or ctx.resilient_parsing:
@@ -260,25 +282,23 @@ def version_option(version=None, *param_decls, **attrs):
                     pass
                 else:
                     for dist in pkg_resources.working_set:
-                        scripts = dist.get_entry_map().get('console_scripts') or {}
+                        scripts = dist.get_entry_map().get("console_scripts") or {}
                         for script_name, entry_point in iteritems(scripts):
                             if entry_point.module_name == module:
                                 ver = dist.version
                                 break
                 if ver is None:
-                    raise RuntimeError('Could not determine version')
-            echo(message % {
-                'prog': prog,
-                'version': ver,
-            }, color=ctx.color)
+                    raise RuntimeError("Could not determine version")
+            echo(message % {"prog": prog, "version": ver,}, color=ctx.color)
             ctx.exit()
 
-        attrs.setdefault('is_flag', True)
-        attrs.setdefault('expose_value', False)
-        attrs.setdefault('is_eager', True)
-        attrs.setdefault('help', 'Show the version and exit.')
-        attrs['callback'] = callback
-        return option(*(param_decls or ('--version',)), **attrs)(f)
+        attrs.setdefault("is_flag", True)
+        attrs.setdefault("expose_value", False)
+        attrs.setdefault("is_eager", True)
+        attrs.setdefault("help", "Show the version and exit.")
+        attrs["callback"] = callback
+        return option(*(param_decls or ("--version",)), **attrs)(f)
+
     return decorator
 
 
@@ -292,17 +312,20 @@ def help_option(*param_decls, **attrs):
 
     All arguments are forwarded to :func:`option`.
     """
+
     def decorator(f):
         def callback(ctx, param, value):
             if value and not ctx.resilient_parsing:
                 echo(ctx.get_help(), color=ctx.color)
                 ctx.exit()
-        attrs.setdefault('is_flag', True)
-        attrs.setdefault('expose_value', False)
-        attrs.setdefault('help', 'Show this message and exit.')
-        attrs.setdefault('is_eager', True)
-        attrs['callback'] = callback
-        return option(*(param_decls or ('--help',)), **attrs)(f)
+
+        attrs.setdefault("is_flag", True)
+        attrs.setdefault("expose_value", False)
+        attrs.setdefault("help", "Show this message and exit.")
+        attrs.setdefault("is_eager", True)
+        attrs["callback"] = callback
+        return option(*(param_decls or ("--help",)), **attrs)(f)
+
     return decorator
 
 
diff --git a/src/click/exceptions.py b/src/click/exceptions.py
index 4aea4f8..a06400b 100644
--- a/src/click/exceptions.py
+++ b/src/click/exceptions.py
@@ -6,7 +6,7 @@ from .utils import echo
 
 def _join_param_hints(param_hint):
     if isinstance(param_hint, (tuple, list)):
-        return ' / '.join('"%s"' % x for x in param_hint)
+        return " / ".join('"%s"' % x for x in param_hint)
     return param_hint
 
 
@@ -20,7 +20,7 @@ class ClickException(Exception):
         ctor_msg = message
         if PY2:
             if ctor_msg is not None:
-                ctor_msg = ctor_msg.encode('utf-8')
+                ctor_msg = ctor_msg.encode("utf-8")
         Exception.__init__(self, ctor_msg)
         self.message = message
 
@@ -34,12 +34,12 @@ class ClickException(Exception):
         __unicode__ = __str__
 
         def __str__(self):
-            return self.message.encode('utf-8')
+            return self.message.encode("utf-8")
 
     def show(self, file=None):
         if file is None:
             file = get_text_stderr()
-        echo('Error: %s' % self.format_message(), file=file)
+        echo("Error: %s" % self.format_message(), file=file)
 
 
 class UsageError(ClickException):
@@ -50,6 +50,7 @@ class UsageError(ClickException):
     :param ctx: optionally the context that caused this error.  Click will
                 fill in the context automatically in some situations.
     """
+
     exit_code = 2
 
     def __init__(self, message, ctx=None):
@@ -61,15 +62,16 @@ class UsageError(ClickException):
         if file is None:
             file = get_text_stderr()
         color = None
-        hint = ''
-        if (self.cmd is not None and
-                self.cmd.get_help_option(self.ctx) is not None):
-            hint = ('Try "%s %s" for help.\n'
-                    % (self.ctx.command_path, self.ctx.help_option_names[0]))
+        hint = ""
+        if self.cmd is not None and self.cmd.get_help_option(self.ctx) is not None:
+            hint = 'Try "%s %s" for help.\n' % (
+                self.ctx.command_path,
+                self.ctx.help_option_names[0],
+            )
         if self.ctx is not None:
             color = self.ctx.color
-            echo(self.ctx.get_usage() + '\n%s' % hint, file=file, color=color)
-        echo('Error: %s' % self.format_message(), file=file, color=color)
+            echo(self.ctx.get_usage() + "\n%s" % hint, file=file, color=color)
+        echo("Error: %s" % self.format_message(), file=file, color=color)
 
 
 class BadParameter(UsageError):
@@ -90,8 +92,7 @@ class BadParameter(UsageError):
                        each item is quoted and separated.
     """
 
-    def __init__(self, message, ctx=None, param=None,
-                 param_hint=None):
+    def __init__(self, message, ctx=None, param=None, param_hint=None):
         UsageError.__init__(self, message, ctx)
         self.param = param
         self.param_hint = param_hint
@@ -102,10 +103,10 @@ class BadParameter(UsageError):
         elif self.param is not None:
             param_hint = self.param.get_error_hint(self.ctx)
         else:
-            return 'Invalid value: %s' % self.message
+            return "Invalid value: %s" % self.message
         param_hint = _join_param_hints(param_hint)
 
-        return 'Invalid value for %s: %s' % (param_hint, self.message)
+        return "Invalid value for %s: %s" % (param_hint, self.message)
 
 
 class MissingParameter(BadParameter):
@@ -120,8 +121,9 @@ class MissingParameter(BadParameter):
                        ``'option'`` or ``'argument'``.
     """
 
-    def __init__(self, message=None, ctx=None, param=None,
-                 param_hint=None, param_type=None):
+    def __init__(
+        self, message=None, ctx=None, param=None, param_hint=None, param_type=None
+    ):
         BadParameter.__init__(self, message, ctx, param, param_hint)
         self.param_type = param_type
 
@@ -143,15 +145,15 @@ class MissingParameter(BadParameter):
             msg_extra = self.param.type.get_missing_message(self.param)
             if msg_extra:
                 if msg:
-                    msg += '.  ' + msg_extra
+                    msg += ".  " + msg_extra
                 else:
                     msg = msg_extra
 
-        return 'Missing %s%s%s%s' % (
+        return "Missing %s%s%s%s" % (
             param_type,
-            param_hint and ' %s' % param_hint or '',
-            msg and '.  ' or '.',
-            msg or '',
+            param_hint and " %s" % param_hint or "",
+            msg and ".  " or ".",
+            msg or "",
         )
 
     def __str__(self):
@@ -175,10 +177,9 @@ class NoSuchOption(UsageError):
     .. versionadded:: 4.0
     """
 
-    def __init__(self, option_name, message=None, possibilities=None,
-                 ctx=None):
+    def __init__(self, option_name, message=None, possibilities=None, ctx=None):
         if message is None:
-            message = 'no such option: %s' % option_name
+            message = "no such option: %s" % option_name
         UsageError.__init__(self, message, ctx)
         self.option_name = option_name
         self.possibilities = possibilities
@@ -187,11 +188,11 @@ class NoSuchOption(UsageError):
         bits = [self.message]
         if self.possibilities:
             if len(self.possibilities) == 1:
-                bits.append('Did you mean %s?' % self.possibilities[0])
+                bits.append("Did you mean %s?" % self.possibilities[0])
             else:
                 possibilities = sorted(self.possibilities)
-                bits.append('(Possible options: %s)' % ', '.join(possibilities))
-        return '  '.join(bits)
+                bits.append("(Possible options: %s)" % ", ".join(possibilities))
+        return "  ".join(bits)
 
 
 class BadOptionUsage(UsageError):
@@ -227,13 +228,13 @@ class FileError(ClickException):
     def __init__(self, filename, hint=None):
         ui_filename = filename_to_ui(filename)
         if hint is None:
-            hint = 'unknown error'
+            hint = "unknown error"
         ClickException.__init__(self, hint)
         self.ui_filename = ui_filename
         self.filename = filename
 
     def format_message(self):
-        return 'Could not open file %s: %s' % (self.ui_filename, self.message)
+        return "Could not open file %s: %s" % (self.ui_filename, self.message)
 
 
 class Abort(RuntimeError):
@@ -246,5 +247,6 @@ class Exit(RuntimeError):
 
     :param code: the status code to exit with.
     """
+
     def __init__(self, code=0):
         self.exit_code = code
diff --git a/src/click/formatting.py b/src/click/formatting.py
index 4426d9c..de90d6b 100644
--- a/src/click/formatting.py
+++ b/src/click/formatting.py
@@ -19,11 +19,12 @@ def measure_table(rows):
 def iter_rows(rows, col_count):
     for row in rows:
         row = tuple(row)
-        yield row + ('',) * (col_count - len(row))
+        yield row + ("",) * (col_count - len(row))
 
 
-def wrap_text(text, width=78, initial_indent='', subsequent_indent='',
-              preserve_paragraphs=False):
+def wrap_text(
+    text, width=78, initial_indent="", subsequent_indent="", preserve_paragraphs=False
+):
     """A helper function that intelligently wraps text.  By default, it
     assumes that it operates on a single paragraph of text but if the
     `preserve_paragraphs` parameter is provided it will intelligently
@@ -43,10 +44,14 @@ def wrap_text(text, width=78, initial_indent='', subsequent_indent='',
                                 intelligently handle paragraphs.
     """
     from ._textwrap import TextWrapper
+
     text = text.expandtabs()
-    wrapper = TextWrapper(width, initial_indent=initial_indent,
-                          subsequent_indent=subsequent_indent,
-                          replace_whitespace=False)
+    wrapper = TextWrapper(
+        width,
+        initial_indent=initial_indent,
+        subsequent_indent=subsequent_indent,
+        replace_whitespace=False,
+    )
     if not preserve_paragraphs:
         return wrapper.fill(text)
 
@@ -57,10 +62,10 @@ def wrap_text(text, width=78, initial_indent='', subsequent_indent='',
     def _flush_par():
         if not buf:
             return
-        if buf[0].strip() == '\b':
-            p.append((indent or 0, True, '\n'.join(buf[1:])))
+        if buf[0].strip() == "\b":
+            p.append((indent or 0, True, "\n".join(buf[1:])))
         else:
-            p.append((indent or 0, False, ' '.join(buf)))
+            p.append((indent or 0, False, " ".join(buf)))
         del buf[:]
 
     for line in text.splitlines():
@@ -77,13 +82,13 @@ def wrap_text(text, width=78, initial_indent='', subsequent_indent='',
 
     rv = []
     for indent, raw, text in p:
-        with wrapper.extra_indent(' ' * indent):
+        with wrapper.extra_indent(" " * indent):
             if raw:
                 rv.append(wrapper.indent_only(text))
             else:
                 rv.append(wrapper.fill(text))
 
-    return '\n\n'.join(rv)
+    return "\n\n".join(rv)
 
 
 class HelpFormatter(object):
@@ -122,53 +127,65 @@ class HelpFormatter(object):
         """Decreases the indentation."""
         self.current_indent -= self.indent_increment
 
-    def write_usage(self, prog, args='', prefix='Usage: '):
+    def write_usage(self, prog, args="", prefix="Usage: "):
         """Writes a usage line into the buffer.
 
         :param prog: the program name.
         :param args: whitespace separated list of arguments.
         :param prefix: the prefix for the first line.
         """
-        usage_prefix = '%*s%s ' % (self.current_indent, prefix, prog)
+        usage_prefix = "%*s%s " % (self.current_indent, prefix, prog)
         text_width = self.width - self.current_indent
 
         if text_width >= (term_len(usage_prefix) + 20):
             # The arguments will fit to the right of the prefix.
-            indent = ' ' * term_len(usage_prefix)
-            self.write(wrap_text(args, text_width,
-                                 initial_indent=usage_prefix,
-                                 subsequent_indent=indent))
+            indent = " " * term_len(usage_prefix)
+            self.write(
+                wrap_text(
+                    args,
+                    text_width,
+                    initial_indent=usage_prefix,
+                    subsequent_indent=indent,
+                )
+            )
         else:
             # The prefix is too long, put the arguments on the next line.
             self.write(usage_prefix)
-            self.write('\n')
-            indent = ' ' * (max(self.current_indent, term_len(prefix)) + 4)
-            self.write(wrap_text(args, text_width,
-                                 initial_indent=indent,
-                                 subsequent_indent=indent))
+            self.write("\n")
+            indent = " " * (max(self.current_indent, term_len(prefix)) + 4)
+            self.write(
+                wrap_text(
+                    args, text_width, initial_indent=indent, subsequent_indent=indent
+                )
+            )
 
-        self.write('\n')
+        self.write("\n")
 
     def write_heading(self, heading):
         """Writes a heading into the buffer."""
-        self.write('%*s%s:\n' % (self.current_indent, '', heading))
+        self.write("%*s%s:\n" % (self.current_indent, "", heading))
 
     def write_paragraph(self):
         """Writes a paragraph into the buffer."""
         if self.buffer:
-            self.write('\n')
+            self.write("\n")
 
     def write_text(self, text):
         """Writes re-indented text into the buffer.  This rewraps and
         preserves paragraphs.
         """
         text_width = max(self.width - self.current_indent, 11)
-        indent = ' ' * self.current_indent
-        self.write(wrap_text(text, text_width,
-                             initial_indent=indent,
-                             subsequent_indent=indent,
-                             preserve_paragraphs=True))
-        self.write('\n')
+        indent = " " * self.current_indent
+        self.write(
+            wrap_text(
+                text,
+                text_width,
+                initial_indent=indent,
+                subsequent_indent=indent,
+                preserve_paragraphs=True,
+            )
+        )
+        self.write("\n")
 
     def write_dl(self, rows, col_max=30, col_spacing=2):
         """Writes a definition list into the buffer.  This is how options
@@ -182,36 +199,36 @@ class HelpFormatter(object):
         rows = list(rows)
         widths = measure_table(rows)
         if len(widths) != 2:
-            raise TypeError('Expected two columns for definition list')
+            raise TypeError("Expected two columns for definition list")
 
         first_col = min(widths[0], col_max) + col_spacing
 
         for first, second in iter_rows(rows, len(widths)):
-            self.write('%*s%s' % (self.current_indent, '', first))
+            self.write("%*s%s" % (self.current_indent, "", first))
             if not second:
-                self.write('\n')
+                self.write("\n")
                 continue
             if term_len(first) <= first_col - col_spacing:
-                self.write(' ' * (first_col - term_len(first)))
+                self.write(" " * (first_col - term_len(first)))
             else:
-                self.write('\n')
-                self.write(' ' * (first_col + self.current_indent))
+                self.write("\n")
+                self.write(" " * (first_col + self.current_indent))
 
             text_width = max(self.width - first_col - 2, 10)
             wrapped_text = wrap_text(second, text_width, preserve_paragraphs=True)
             lines = wrapped_text.splitlines()
 
             if lines:
-                self.write(lines[0] + '\n')
+                self.write(lines[0] + "\n")
 
                 for line in lines[1:]:
-                    self.write('%*s%s\n' % (first_col + self.current_indent, '', line))
+                    self.write("%*s%s\n" % (first_col + self.current_indent, "", line))
 
                 if len(lines) > 1:
                     # separate long help from next option
                     self.write("\n")
             else:
-                self.write('\n')
+                self.write("\n")
 
     @contextmanager
     def section(self, name):
@@ -239,7 +256,7 @@ class HelpFormatter(object):
 
     def getvalue(self):
         """Returns the buffer contents."""
-        return ''.join(self.buffer)
+        return "".join(self.buffer)
 
 
 def join_options(options):
@@ -252,11 +269,11 @@ def join_options(options):
     any_prefix_is_slash = False
     for opt in options:
         prefix = split_opt(opt)[0]
-        if prefix == '/':
+        if prefix == "/":
             any_prefix_is_slash = True
         rv.append((len(prefix), opt))
 
     rv.sort(key=lambda x: x[0])
 
-    rv = ', '.join(x[1] for x in rv)
+    rv = ", ".join(x[1] for x in rv)
     return rv, any_prefix_is_slash
diff --git a/src/click/globals.py b/src/click/globals.py
index e5b88d3..a0157fc 100644
--- a/src/click/globals.py
+++ b/src/click/globals.py
@@ -19,15 +19,15 @@ def get_current_context(silent=False):
                    :exc:`RuntimeError`.
     """
     try:
-        return getattr(_local, 'stack')[-1]
+        return getattr(_local, "stack")[-1]
     except (AttributeError, IndexError):
         if not silent:
-            raise RuntimeError('There is no active click context.')
+            raise RuntimeError("There is no active click context.")
 
 
 def push_context(ctx):
     """Pushes a new context to the current stack."""
-    _local.__dict__.setdefault('stack', []).append(ctx)
+    _local.__dict__.setdefault("stack", []).append(ctx)
 
 
 def pop_context():
diff --git a/src/click/parser.py b/src/click/parser.py
index c060313..16a41eb 100644
--- a/src/click/parser.py
+++ b/src/click/parser.py
@@ -64,7 +64,7 @@ def _unpack_args(args, nargs_spec):
             rv.append(tuple(x))
         elif nargs < 0:
             if spos is not None:
-                raise TypeError('Cannot have two nargs < 0')
+                raise TypeError("Cannot have two nargs < 0")
             spos = len(rv)
             rv.append(None)
 
@@ -73,21 +73,21 @@ def _unpack_args(args, nargs_spec):
     if spos is not None:
         rv[spos] = tuple(args)
         args = []
-        rv[spos + 1:] = reversed(rv[spos + 1:])
+        rv[spos + 1 :] = reversed(rv[spos + 1 :])
 
     return tuple(rv), list(args)
 
 
 def _error_opt_args(nargs, opt):
     if nargs == 1:
-        raise BadOptionUsage(opt, '%s option requires an argument' % opt)
-    raise BadOptionUsage(opt, '%s option requires %d arguments' % (opt, nargs))
+        raise BadOptionUsage(opt, "%s option requires an argument" % opt)
+    raise BadOptionUsage(opt, "%s option requires %d arguments" % (opt, nargs))
 
 
 def split_opt(opt):
     first = opt[:1]
     if first.isalnum():
-        return '', opt
+        return "", opt
     if opt[1:2] == first:
         return opt[:2], opt[2:]
     return first, opt[1:]
@@ -103,13 +103,14 @@ def normalize_opt(opt, ctx):
 def split_arg_string(string):
     """Given an argument string this attempts to split it into small parts."""
     rv = []
-    for match in re.finditer(r"('([^'\\]*(?:\\.[^'\\]*)*)'"
-                             r'|"([^"\\]*(?:\\.[^"\\]*)*)"'
-                             r'|\S+)\s*', string, re.S):
+    for match in re.finditer(
+        r"('([^'\\]*(?:\\.[^'\\]*)*)'|\"([^\"\\]*(?:\\.[^\"\\]*)*)\"|\S+)\s*",
+        string,
+        re.S,
+    ):
         arg = match.group().strip()
-        if arg[:1] == arg[-1:] and arg[:1] in '"\'':
-            arg = arg[1:-1].encode('ascii', 'backslashreplace') \
-                .decode('unicode-escape')
+        if arg[:1] == arg[-1:] and arg[:1] in "\"'":
+            arg = arg[1:-1].encode("ascii", "backslashreplace").decode("unicode-escape")
         try:
             arg = type(string)(arg)
         except UnicodeError:
@@ -119,7 +120,6 @@ def split_arg_string(string):
 
 
 class Option(object):
-
     def __init__(self, opts, dest, action=None, nargs=1, const=None, obj=None):
         self._short_opts = []
         self._long_opts = []
@@ -128,8 +128,7 @@ class Option(object):
         for opt in opts:
             prefix, value = split_opt(opt)
             if not prefix:
-                raise ValueError('Invalid start character for option (%s)'
-                                 % opt)
+                raise ValueError("Invalid start character for option (%s)" % opt)
             self.prefixes.add(prefix[0])
             if len(prefix) == 1 and len(value) == 1:
                 self._short_opts.append(opt)
@@ -138,7 +137,7 @@ class Option(object):
                 self.prefixes.add(prefix)
 
         if action is None:
-            action = 'store'
+            action = "store"
 
         self.dest = dest
         self.action = action
@@ -148,26 +147,25 @@ class Option(object):
 
     @property
     def takes_value(self):
-        return self.action in ('store', 'append')
+        return self.action in ("store", "append")
 
     def process(self, value, state):
-        if self.action == 'store':
+        if self.action == "store":
             state.opts[self.dest] = value
-        elif self.action == 'store_const':
+        elif self.action == "store_const":
             state.opts[self.dest] = self.const
-        elif self.action == 'append':
+        elif self.action == "append":
             state.opts.setdefault(self.dest, []).append(value)
-        elif self.action == 'append_const':
+        elif self.action == "append_const":
             state.opts.setdefault(self.dest, []).append(self.const)
-        elif self.action == 'count':
+        elif self.action == "count":
             state.opts[self.dest] = state.opts.get(self.dest, 0) + 1
         else:
-            raise ValueError('unknown action %r' % self.action)
+            raise ValueError("unknown action %r" % self.action)
         state.order.append(self.obj)
 
 
 class Argument(object):
-
     def __init__(self, dest, nargs=1, obj=None):
         self.dest = dest
         self.nargs = nargs
@@ -179,14 +177,14 @@ class Argument(object):
             if holes == len(value):
                 value = None
             elif holes != 0:
-                raise BadArgumentUsage('argument %s takes %d values'
-                                       % (self.dest, self.nargs))
+                raise BadArgumentUsage(
+                    "argument %s takes %d values" % (self.dest, self.nargs)
+                )
         state.opts[self.dest] = value
         state.order.append(self.obj)
 
 
 class ParsingState(object):
-
     def __init__(self, rargs):
         self.opts = {}
         self.largs = []
@@ -227,11 +225,10 @@ class OptionParser(object):
             self.ignore_unknown_options = ctx.ignore_unknown_options
         self._short_opt = {}
         self._long_opt = {}
-        self._opt_prefixes = set(['-', '--'])
+        self._opt_prefixes = set(["-", "--"])
         self._args = []
 
-    def add_option(self, opts, dest, action=None, nargs=1, const=None,
-                   obj=None):
+    def add_option(self, opts, dest, action=None, nargs=1, const=None, obj=None):
         """Adds a new option named `dest` to the parser.  The destination
         is not inferred (unlike with optparse) and needs to be explicitly
         provided.  Action can be any of ``store``, ``store_const``,
@@ -243,8 +240,7 @@ class OptionParser(object):
         if obj is None:
             obj = dest
         opts = [normalize_opt(opt, self.ctx) for opt in opts]
-        option = Option(opts, dest, action=action, nargs=nargs,
-                        const=const, obj=obj)
+        option = Option(opts, dest, action=action, nargs=nargs, const=const, obj=obj)
         self._opt_prefixes.update(option.prefixes)
         for opt in option._short_opts:
             self._short_opt[opt] = option
@@ -278,8 +274,9 @@ class OptionParser(object):
         return state.opts, state.largs, state.order
 
     def _process_args_for_args(self, state):
-        pargs, args = _unpack_args(state.largs + state.rargs,
-                                   [x.nargs for x in self._args])
+        pargs, args = _unpack_args(
+            state.largs + state.rargs, [x.nargs for x in self._args]
+        )
 
         for idx, arg in enumerate(self._args):
             arg.process(pargs[idx], state)
@@ -293,7 +290,7 @@ class OptionParser(object):
             arglen = len(arg)
             # Double dashes always handled explicitly regardless of what
             # prefixes are valid.
-            if arg == '--':
+            if arg == "--":
                 return
             elif arg[:1] in self._opt_prefixes and arglen > 1:
                 self._process_opts(arg, state)
@@ -325,8 +322,7 @@ class OptionParser(object):
 
     def _match_long_opt(self, opt, explicit_value, state):
         if opt not in self._long_opt:
-            possibilities = [word for word in self._long_opt
-                             if word.startswith(opt)]
+            possibilities = [word for word in self._long_opt if word.startswith(opt)]
             raise NoSuchOption(opt, possibilities=possibilities, ctx=self.ctx)
 
         option = self._long_opt[opt]
@@ -348,7 +344,7 @@ class OptionParser(object):
                 del state.rargs[:nargs]
 
         elif explicit_value is not None:
-            raise BadOptionUsage(opt, '%s option does not take a value' % opt)
+            raise BadOptionUsage(opt, "%s option does not take a value" % opt)
 
         else:
             value = None
@@ -400,15 +396,15 @@ class OptionParser(object):
         # to the state as new larg.  This way there is basic combinatorics
         # that can be achieved while still ignoring unknown arguments.
         if self.ignore_unknown_options and unknown_options:
-            state.largs.append(prefix + ''.join(unknown_options))
+            state.largs.append(prefix + "".join(unknown_options))
 
     def _process_opts(self, arg, state):
         explicit_value = None
         # Long option handling happens in two parts.  The first part is
         # supporting explicitly attached values.  In any case, we will try
         # to long match the option first.
-        if '=' in arg:
-            long_opt, explicit_value = arg.split('=', 1)
+        if "=" in arg:
+            long_opt, explicit_value = arg.split("=", 1)
         else:
             long_opt = arg
         norm_long_opt = normalize_opt(long_opt, self.ctx)
diff --git a/src/click/termui.py b/src/click/termui.py
index 5448b80..eb1baa8 100644
--- a/src/click/termui.py
+++ b/src/click/termui.py
@@ -27,38 +27,41 @@ from .utils import LazyFile
 visible_prompt_func = raw_input
 
 _ansi_colors = {
-    'black': 30,
-    'red': 31,
-    'green': 32,
-    'yellow': 33,
-    'blue': 34,
-    'magenta': 35,
-    'cyan': 36,
-    'white': 37,
-    'reset': 39,
-    'bright_black': 90,
-    'bright_red': 91,
-    'bright_green': 92,
-    'bright_yellow': 93,
-    'bright_blue': 94,
-    'bright_magenta': 95,
-    'bright_cyan': 96,
-    'bright_white': 97,
+    "black": 30,
+    "red": 31,
+    "green": 32,
+    "yellow": 33,
+    "blue": 34,
+    "magenta": 35,
+    "cyan": 36,
+    "white": 37,
+    "reset": 39,
+    "bright_black": 90,
+    "bright_red": 91,
+    "bright_green": 92,
+    "bright_yellow": 93,
+    "bright_blue": 94,
+    "bright_magenta": 95,
+    "bright_cyan": 96,
+    "bright_white": 97,
 }
-_ansi_reset_all = '\033[0m'
+_ansi_reset_all = "\033[0m"
 
 
 def hidden_prompt_func(prompt):
     import getpass
+
     return getpass.getpass(prompt)
 
 
-def _build_prompt(text, suffix, show_default=False, default=None, show_choices=True, type=None):
+def _build_prompt(
+    text, suffix, show_default=False, default=None, show_choices=True, type=None
+):
     prompt = text
     if type is not None and show_choices and isinstance(type, Choice):
-        prompt += ' (' + ", ".join(map(str, type.choices)) + ')'
+        prompt += " (" + ", ".join(map(str, type.choices)) + ")"
     if default is not None and show_default:
-        prompt = '%s [%s]' % (prompt, _format_default(default))
+        prompt = "%s [%s]" % (prompt, _format_default(default))
     return prompt + suffix
 
 
@@ -69,9 +72,18 @@ def _format_default(default):
     return default
 
 
-def prompt(text, default=None, hide_input=False, confirmation_prompt=False,
-           type=None, value_proc=None, prompt_suffix=': ', show_default=True,
-           err=False, show_choices=True):
+def prompt(
+    text,
+    default=None,
+    hide_input=False,
+    confirmation_prompt=False,
+    type=None,
+    value_proc=None,
+    prompt_suffix=": ",
+    show_default=True,
+    err=False,
+    show_choices=True,
+):
     """Prompts a user for input.  This is a convenience function that can
     be used to prompt a user for input later.
 
@@ -114,7 +126,7 @@ def prompt(text, default=None, hide_input=False, confirmation_prompt=False,
             # Write the prompt separately so that we get nice
             # coloring through colorama on Windows
             echo(text, nl=False, err=err)
-            return f('')
+            return f("")
         except (KeyboardInterrupt, EOFError):
             # getpass doesn't print a newline if the user aborts input with ^C.
             # Allegedly this behavior is inherited from getpass(3).
@@ -126,7 +138,9 @@ def prompt(text, default=None, hide_input=False, confirmation_prompt=False,
     if value_proc is None:
         value_proc = convert_type(type, default)
 
-    prompt = _build_prompt(text, prompt_suffix, show_default, default, show_choices, type)
+    prompt = _build_prompt(
+        text, prompt_suffix, show_default, default, show_choices, type
+    )
 
     while 1:
         while 1:
@@ -142,21 +156,22 @@ def prompt(text, default=None, hide_input=False, confirmation_prompt=False,
         try:
             result = value_proc(value)
         except UsageError as e:
-            echo('Error: %s' % e.message, err=err)
+            echo("Error: %s" % e.message, err=err)
             continue
         if not confirmation_prompt:
             return result
         while 1:
-            value2 = prompt_func('Repeat for confirmation: ')
+            value2 = prompt_func("Repeat for confirmation: ")
             if value2:
                 break
         if value == value2:
             return result
-        echo('Error: the two entered values do not match', err=err)
+        echo("Error: the two entered values do not match", err=err)
 
 
-def confirm(text, default=False, abort=False, prompt_suffix=': ',
-            show_default=True, err=False):
+def confirm(
+    text, default=False, abort=False, prompt_suffix=": ", show_default=True, err=False
+):
     """Prompts for confirmation (yes/no question).
 
     If the user aborts the input by sending a interrupt signal this
@@ -174,24 +189,25 @@ def confirm(text, default=False, abort=False, prompt_suffix=': ',
     :param err: if set to true the file defaults to ``stderr`` instead of
                 ``stdout``, the same as with echo.
     """
-    prompt = _build_prompt(text, prompt_suffix, show_default,
-                           default and 'Y/n' or 'y/N')
+    prompt = _build_prompt(
+        text, prompt_suffix, show_default, default and "Y/n" or "y/N"
+    )
     while 1:
         try:
             # Write the prompt separately so that we get nice
             # coloring through colorama on Windows
             echo(prompt, nl=False, err=err)
-            value = visible_prompt_func('').lower().strip()
+            value = visible_prompt_func("").lower().strip()
         except (KeyboardInterrupt, EOFError):
             raise Abort()
-        if value in ('y', 'yes'):
+        if value in ("y", "yes"):
             rv = True
-        elif value in ('n', 'no'):
+        elif value in ("n", "no"):
             rv = False
-        elif value == '':
+        elif value == "":
             rv = default
         else:
-            echo('Error: invalid input', err=err)
+            echo("Error: invalid input", err=err)
             continue
         break
     if abort and not rv:
@@ -206,7 +222,8 @@ def get_terminal_size():
     # If shutil has get_terminal_size() (Python 3.3 and later) use that
     if sys.version_info >= (3, 3):
         import shutil
-        shutil_get_terminal_size = getattr(shutil, 'get_terminal_size', None)
+
+        shutil_get_terminal_size = getattr(shutil, "get_terminal_size", None)
         if shutil_get_terminal_size:
             sz = shutil_get_terminal_size()
             return sz.columns, sz.lines
@@ -224,8 +241,8 @@ def get_terminal_size():
         try:
             import fcntl
             import termios
-            cr = struct.unpack(
-                'hh', fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'))
+
+            cr = struct.unpack("hh", fcntl.ioctl(fd, termios.TIOCGWINSZ, "1234"))
         except Exception:
             return
         return cr
@@ -241,8 +258,7 @@ def get_terminal_size():
         except Exception:
             pass
     if not cr or not cr[0] or not cr[1]:
-        cr = (os.environ.get('LINES', 25),
-              os.environ.get('COLUMNS', DEFAULT_COLUMNS))
+        cr = (os.environ.get("LINES", 25), os.environ.get("COLUMNS", DEFAULT_COLUMNS))
     return int(cr[1]), int(cr[0])
 
 
@@ -268,18 +284,29 @@ def echo_via_pager(text_or_generator, color=None):
         i = iter(text_or_generator)
 
     # convert every element of i to a text type if necessary
-    text_generator = (el if isinstance(el, string_types) else text_type(el)
-                      for el in i)
+    text_generator = (el if isinstance(el, string_types) else text_type(el) for el in i)
 
     from ._termui_impl import pager
+
     return pager(itertools.chain(text_generator, "\n"), color)
 
 
-def progressbar(iterable=None, length=None, label=None, show_eta=True,
-                show_percent=None, show_pos=False,
-                item_show_func=None, fill_char='#', empty_char='-',
-                bar_template='%(label)s  [%(bar)s]  %(info)s',
-                info_sep='  ', width=36, file=None, color=None):
+def progressbar(
+    iterable=None,
+    length=None,
+    label=None,
+    show_eta=True,
+    show_percent=None,
+    show_pos=False,
+    item_show_func=None,
+    fill_char="#",
+    empty_char="-",
+    bar_template="%(label)s  [%(bar)s]  %(info)s",
+    info_sep="  ",
+    width=36,
+    file=None,
+    color=None,
+):
     """This function creates an iterable context manager that can be used
     to iterate over something while showing a progress bar.  It will
     either iterate over the `iterable` or `length` items (that are counted
@@ -365,13 +392,24 @@ def progressbar(iterable=None, length=None, label=None, show_eta=True,
                   which is not the case by default.
     """
     from ._termui_impl import ProgressBar
+
     color = resolve_color_default(color)
-    return ProgressBar(iterable=iterable, length=length, show_eta=show_eta,
-                       show_percent=show_percent, show_pos=show_pos,
-                       item_show_func=item_show_func, fill_char=fill_char,
-                       empty_char=empty_char, bar_template=bar_template,
-                       info_sep=info_sep, file=file, label=label,
-                       width=width, color=color)
+    return ProgressBar(
+        iterable=iterable,
+        length=length,
+        show_eta=show_eta,
+        show_percent=show_percent,
+        show_pos=show_pos,
+        item_show_func=item_show_func,
+        fill_char=fill_char,
+        empty_char=empty_char,
+        bar_template=bar_template,
+        info_sep=info_sep,
+        file=file,
+        label=label,
+        width=width,
+        color=color,
+    )
 
 
 def clear():
@@ -387,13 +425,22 @@ def clear():
     # clear the screen by shelling out.  Otherwise we can use an escape
     # sequence.
     if WIN:
-        os.system('cls')
+        os.system("cls")
     else:
-        sys.stdout.write('\033[2J\033[1;1H')
-
-
-def style(text, fg=None, bg=None, bold=None, dim=None, underline=None,
-          blink=None, reverse=None, reset=True):
+        sys.stdout.write("\033[2J\033[1;1H")
+
+
+def style(
+    text,
+    fg=None,
+    bg=None,
+    bold=None,
+    dim=None,
+    underline=None,
+    blink=None,
+    reverse=None,
+    reset=True,
+):
     """Styles a text with ANSI styles and returns the new string.  By
     default the styling is self contained which means that at the end
     of the string a reset code is issued.  This can be prevented by
@@ -448,28 +495,28 @@ def style(text, fg=None, bg=None, bold=None, dim=None, underline=None,
     bits = []
     if fg:
         try:
-            bits.append('\033[%dm' % (_ansi_colors[fg]))
+            bits.append("\033[%dm" % (_ansi_colors[fg]))
         except KeyError:
-            raise TypeError('Unknown color %r' % fg)
+            raise TypeError("Unknown color %r" % fg)
     if bg:
         try:
-            bits.append('\033[%dm' % (_ansi_colors[bg] + 10))
+            bits.append("\033[%dm" % (_ansi_colors[bg] + 10))
         except KeyError:
-            raise TypeError('Unknown color %r' % bg)
+            raise TypeError("Unknown color %r" % bg)
     if bold is not None:
-        bits.append('\033[%dm' % (1 if bold else 22))
+        bits.append("\033[%dm" % (1 if bold else 22))
     if dim is not None:
-        bits.append('\033[%dm' % (2 if dim else 22))
+        bits.append("\033[%dm" % (2 if dim else 22))
     if underline is not None:
-        bits.append('\033[%dm' % (4 if underline else 24))
+        bits.append("\033[%dm" % (4 if underline else 24))
     if blink is not None:
-        bits.append('\033[%dm' % (5 if blink else 25))
+        bits.append("\033[%dm" % (5 if blink else 25))
     if reverse is not None:
-        bits.append('\033[%dm' % (7 if reverse else 27))
+        bits.append("\033[%dm" % (7 if reverse else 27))
     bits.append(text)
     if reset:
         bits.append(_ansi_reset_all)
-    return ''.join(bits)
+    return "".join(bits)
 
 
 def unstyle(text):
@@ -501,8 +548,9 @@ def secho(message=None, file=None, nl=True, err=False, color=None, **styles):
     return echo(message, file=file, nl=nl, err=err, color=color)
 
 
-def edit(text=None, editor=None, env=None, require_save=True,
-         extension='.txt', filename=None):
+def edit(
+    text=None, editor=None, env=None, require_save=True, extension=".txt", filename=None
+):
     r"""Edits the given text in the defined editor.  If an editor is given
     (should be the full path to the executable but the regular operating
     system search path is used for finding the executable) it overrides
@@ -531,8 +579,10 @@ def edit(text=None, editor=None, env=None, require_save=True,
                      file as an indirection in that case.
     """
     from ._termui_impl import Editor
-    editor = Editor(editor=editor, env=env, require_save=require_save,
-                    extension=extension)
+
+    editor = Editor(
+        editor=editor, env=env, require_save=require_save, extension=extension
+    )
     if filename is None:
         return editor.edit(text)
     editor.edit_file(filename)
@@ -561,6 +611,7 @@ def launch(url, wait=False, locate=False):
                    the filesystem.
     """
     from ._termui_impl import open_url
+
     return open_url(url, wait=wait, locate=locate)
 
 
@@ -597,10 +648,11 @@ def getchar(echo=False):
 
 def raw_terminal():
     from ._termui_impl import raw_terminal as f
+
     return f()
 
 
-def pause(info='Press any key to continue ...', err=False):
+def pause(info="Press any key to continue ...", err=False):
     """This command stops execution and waits for the user to press any
     key to continue.  This is similar to the Windows batch "pause"
     command.  If the program is not run through a terminal, this command
diff --git a/src/click/testing.py b/src/click/testing.py
index 16cf42c..c50418f 100644
--- a/src/click/testing.py
+++ b/src/click/testing.py
@@ -13,7 +13,7 @@ from ._compat import string_types
 # correct package is discovered.  Ideally we could use a
 # relative import here but unfortunately Python does not
 # support that.
-clickpkg = sys.modules[__name__.rsplit('.', 1)[0]]
+clickpkg = sys.modules[__name__.rsplit(".", 1)[0]]
 
 
 if PY2:
@@ -24,7 +24,6 @@ else:
 
 
 class EchoingStdin(object):
-
     def __init__(self, input, output):
         self._input = input
         self._output = output
@@ -54,16 +53,16 @@ class EchoingStdin(object):
 
 def make_input_stream(input, charset):
     # Is already an input stream.
-    if hasattr(input, 'read'):
+    if hasattr(input, "read"):
         if PY2:
             return input
         rv = _find_binary_reader(input)
         if rv is not None:
             return rv
-        raise TypeError('Could not find binary reader for input stream.')
+        raise TypeError("Could not find binary reader for input stream.")
 
     if input is None:
-        input = b''
+        input = b""
     elif not isinstance(input, bytes):
         input = input.encode(charset)
     if PY2:
@@ -74,8 +73,9 @@ def make_input_stream(input, charset):
 class Result(object):
     """Holds the captured result of an invoked CLI script."""
 
-    def __init__(self, runner, stdout_bytes, stderr_bytes, exit_code,
-                 exception, exc_info=None):
+    def __init__(
+        self, runner, stdout_bytes, stderr_bytes, exit_code, exception, exc_info=None
+    ):
         #: The runner that created the result
         self.runner = runner
         #: The standard output as bytes.
@@ -97,22 +97,23 @@ class Result(object):
     @property
     def stdout(self):
         """The standard output as unicode string."""
-        return self.stdout_bytes.decode(self.runner.charset, 'replace') \
-            .replace('\r\n', '\n')
+        return self.stdout_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
 
     @property
     def stderr(self):
         """The standard error as unicode string."""
         if self.stderr_bytes is None:
             raise ValueError("stderr not separately captured")
-        return self.stderr_bytes.decode(self.runner.charset, 'replace') \
-            .replace('\r\n', '\n')
-
+        return self.stderr_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
 
     def __repr__(self):
-        return '<%s %s>' % (
+        return "<%s %s>" % (
             type(self).__name__,
-            self.exception and repr(self.exception) or 'okay',
+            self.exception and repr(self.exception) or "okay",
         )
 
 
@@ -137,10 +138,9 @@ class CliRunner(object):
                        independently
     """
 
-    def __init__(self, charset=None, env=None, echo_stdin=False,
-                 mix_stderr=True):
+    def __init__(self, charset=None, env=None, echo_stdin=False, mix_stderr=True):
         if charset is None:
-            charset = 'utf-8'
+            charset = "utf-8"
         self.charset = charset
         self.env = env or {}
         self.echo_stdin = echo_stdin
@@ -151,7 +151,7 @@ class CliRunner(object):
         for it.  The default is the `name` attribute or ``"root"`` if not
         set.
         """
-        return cli.name or 'root'
+        return cli.name or "root"
 
     def make_env(self, overrides=None):
         """Returns the environment overrides for invoking a script."""
@@ -201,12 +201,10 @@ class CliRunner(object):
             if self.echo_stdin:
                 input = EchoingStdin(input, bytes_output)
             input = io.TextIOWrapper(input, encoding=self.charset)
-            sys.stdout = io.TextIOWrapper(
-                bytes_output, encoding=self.charset)
+            sys.stdout = io.TextIOWrapper(bytes_output, encoding=self.charset)
             if not self.mix_stderr:
                 bytes_error = io.BytesIO()
-                sys.stderr = io.TextIOWrapper(
-                    bytes_error, encoding=self.charset)
+                sys.stderr = io.TextIOWrapper(bytes_error, encoding=self.charset)
 
         if self.mix_stderr:
             sys.stderr = sys.stdout
@@ -214,16 +212,16 @@ class CliRunner(object):
         sys.stdin = input
 
         def visible_input(prompt=None):
-            sys.stdout.write(prompt or '')
-            val = input.readline().rstrip('\r\n')
-            sys.stdout.write(val + '\n')
+            sys.stdout.write(prompt or "")
+            val = input.readline().rstrip("\r\n")
+            sys.stdout.write(val + "\n")
             sys.stdout.flush()
             return val
 
         def hidden_input(prompt=None):
-            sys.stdout.write((prompt or '') + '\n')
+            sys.stdout.write((prompt or "") + "\n")
             sys.stdout.flush()
-            return input.readline().rstrip('\r\n')
+            return input.readline().rstrip("\r\n")
 
         def _getchar(echo):
             char = sys.stdin.read(1)
@@ -278,8 +276,16 @@ class CliRunner(object):
             clickpkg.utils.should_strip_ansi = old_should_strip_ansi
             clickpkg.formatting.FORCED_WIDTH = old_forced_width
 
-    def invoke(self, cli, args=None, input=None, env=None,
-               catch_exceptions=True, color=False, **extra):
+    def invoke(
+        self,
+        cli,
+        args=None,
+        input=None,
+        env=None,
+        catch_exceptions=True,
+        color=False,
+        **extra
+    ):
         """Invokes a command in an isolated environment.  The arguments are
         forwarded directly to the command line script, the `extra` keyword
         arguments are passed to the :meth:`~clickpkg.Command.main` function of
@@ -336,7 +342,7 @@ class CliRunner(object):
 
                 if not isinstance(exit_code, int):
                     sys.stdout.write(str(exit_code))
-                    sys.stdout.write('\n')
+                    sys.stdout.write("\n")
                     exit_code = 1
 
             except Exception as e:
@@ -353,12 +359,14 @@ class CliRunner(object):
                 else:
                     stderr = outstreams[1].getvalue()
 
-        return Result(runner=self,
-                      stdout_bytes=stdout,
-                      stderr_bytes=stderr,
-                      exit_code=exit_code,
-                      exception=exception,
-                      exc_info=exc_info)
+        return Result(
+            runner=self,
+            stdout_bytes=stdout,
+            stderr_bytes=stderr,
+            exit_code=exit_code,
+            exception=exception,
+            exc_info=exc_info,
+        )
 
     @contextlib.contextmanager
     def isolated_filesystem(self):
diff --git a/src/click/types.py b/src/click/types.py
index 6bb69f0..1d3d5b3 100644
--- a/src/click/types.py
+++ b/src/click/types.py
@@ -27,6 +27,7 @@ class ParamType(object):
         This can be the case when the object is used with prompt
         inputs.
     """
+
     is_composite = False
 
     #: the descriptive name of this type
@@ -68,7 +69,7 @@ class ParamType(object):
         then leading and trailing whitespace is ignored.  Otherwise, leading
         and trailing splitters usually lead to empty items being included.
         """
-        return (rv or '').split(self.envvar_list_splitter)
+        return (rv or "").split(self.envvar_list_splitter)
 
     def fail(self, message, param=None, ctx=None):
         """Helper method to fail with an invalid value message."""
@@ -84,7 +85,6 @@ class CompositeParamType(ParamType):
 
 
 class FuncParamType(ParamType):
-
     def __init__(self, func):
         self.name = func.__name__
         self.func = func
@@ -96,22 +96,22 @@ class FuncParamType(ParamType):
             try:
                 value = text_type(value)
             except UnicodeError:
-                value = str(value).decode('utf-8', 'replace')
+                value = str(value).decode("utf-8", "replace")
             self.fail(value, param, ctx)
 
 
 class UnprocessedParamType(ParamType):
-    name = 'text'
+    name = "text"
 
     def convert(self, value, param, ctx):
         return value
 
     def __repr__(self):
-        return 'UNPROCESSED'
+        return "UNPROCESSED"
 
 
 class StringParamType(ParamType):
-    name = 'text'
+    name = "text"
 
     def convert(self, value, param, ctx):
         if isinstance(value, bytes):
@@ -124,14 +124,14 @@ class StringParamType(ParamType):
                     try:
                         value = value.decode(fs_enc)
                     except UnicodeError:
-                        value = value.decode('utf-8', 'replace')
+                        value = value.decode("utf-8", "replace")
                 else:
-                    value = value.decode('utf-8', 'replace')
+                    value = value.decode("utf-8", "replace")
             return value
         return value
 
     def __repr__(self):
-        return 'STRING'
+        return "STRING"
 
 
 class Choice(ParamType):
@@ -151,17 +151,17 @@ class Choice(ParamType):
         insensitive. Defaults to true.
     """
 
-    name = 'choice'
+    name = "choice"
 
     def __init__(self, choices, case_sensitive=True):
         self.choices = choices
         self.case_sensitive = case_sensitive
 
     def get_metavar(self, param):
-        return '[%s]' % '|'.join(self.choices)
+        return "[%s]" % "|".join(self.choices)
 
     def get_missing_message(self, param):
-        return 'Choose from:\n\t%s.' % ',\n\t'.join(self.choices)
+        return "Choose from:\n\t%s." % ",\n\t".join(self.choices)
 
     def convert(self, value, param, ctx):
         # Match through normalization and case sensitivity
@@ -193,11 +193,14 @@ class Choice(ParamType):
         if normed_value in normed_choices:
             return normed_choices[normed_value]
 
-        self.fail('invalid choice: %s. (choose from %s)' %
-                  (value, ', '.join(self.choices)), param, ctx)
+        self.fail(
+            "invalid choice: %s. (choose from %s)" % (value, ", ".join(self.choices)),
+            param,
+            ctx,
+        )
 
     def __repr__(self):
-        return 'Choice(%r)' % list(self.choices)
+        return "Choice(%r)" % list(self.choices)
 
 
 class DateTime(ParamType):
@@ -220,17 +223,14 @@ class DateTime(ParamType):
                     ``'%Y-%m-%d'``, ``'%Y-%m-%dT%H:%M:%S'``,
                     ``'%Y-%m-%d %H:%M:%S'``.
     """
-    name = 'datetime'
+
+    name = "datetime"
 
     def __init__(self, formats=None):
-        self.formats = formats or [
-            '%Y-%m-%d',
-            '%Y-%m-%dT%H:%M:%S',
-            '%Y-%m-%d %H:%M:%S'
-        ]
+        self.formats = formats or ["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d %H:%M:%S"]
 
     def get_metavar(self, param):
-        return '[{}]'.format('|'.join(self.formats))
+        return "[{}]".format("|".join(self.formats))
 
     def _try_to_convert_date(self, value, format):
         try:
@@ -246,24 +246,26 @@ class DateTime(ParamType):
                 return dtime
 
         self.fail(
-            'invalid datetime format: {}. (choose from {})'.format(
-                value, ', '.join(self.formats)))
+            "invalid datetime format: {}. (choose from {})".format(
+                value, ", ".join(self.formats)
+            )
+        )
 
     def __repr__(self):
-        return 'DateTime'
+        return "DateTime"
 
 
 class IntParamType(ParamType):
-    name = 'integer'
+    name = "integer"
 
     def convert(self, value, param, ctx):
         try:
             return int(value)
         except (ValueError, UnicodeError):
-            self.fail('%s is not a valid integer' % value, param, ctx)
+            self.fail("%s is not a valid integer" % value, param, ctx)
 
     def __repr__(self):
-        return 'INT'
+        return "INT"
 
 
 class IntRange(IntParamType):
@@ -274,7 +276,8 @@ class IntRange(IntParamType):
 
     See :ref:`ranges` for an example.
     """
-    name = 'integer range'
+
+    name = "integer range"
 
     def __init__(self, min=None, max=None, clamp=False):
         self.min = min
@@ -288,35 +291,49 @@ class IntRange(IntParamType):
                 return self.min
             if self.max is not None and rv > self.max:
                 return self.max
-        if self.min is not None and rv < self.min or \
-           self.max is not None and rv > self.max:
+        if (
+            self.min is not None
+            and rv < self.min
+            or self.max is not None
+            and rv > self.max
+        ):
             if self.min is None:
-                self.fail('%s is bigger than the maximum valid value '
-                          '%s.' % (rv, self.max), param, ctx)
+                self.fail(
+                    "%s is bigger than the maximum valid value %s." % (rv, self.max),
+                    param,
+                    ctx,
+                )
             elif self.max is None:
-                self.fail('%s is smaller than the minimum valid value '
-                          '%s.' % (rv, self.min), param, ctx)
+                self.fail(
+                    "%s is smaller than the minimum valid value "
+                    "%s." % (rv, self.min),
+                    param,
+                    ctx,
+                )
             else:
-                self.fail('%s is not in the valid range of %s to %s.'
-                          % (rv, self.min, self.max), param, ctx)
+                self.fail(
+                    "%s is not in the valid range of %s to %s."
+                    % (rv, self.min, self.max),
+                    param,
+                    ctx,
+                )
         return rv
 
     def __repr__(self):
-        return 'IntRange(%r, %r)' % (self.min, self.max)
+        return "IntRange(%r, %r)" % (self.min, self.max)
 
 
 class FloatParamType(ParamType):
-    name = 'float'
+    name = "float"
 
     def convert(self, value, param, ctx):
         try:
             return float(value)
         except (UnicodeError, ValueError):
-            self.fail('%s is not a valid floating point value' %
-                      value, param, ctx)
+            self.fail("%s is not a valid floating point value" % value, param, ctx)
 
     def __repr__(self):
-        return 'FLOAT'
+        return "FLOAT"
 
 
 class FloatRange(FloatParamType):
@@ -327,7 +344,8 @@ class FloatRange(FloatParamType):
 
     See :ref:`ranges` for an example.
     """
-    name = 'float range'
+
+    name = "float range"
 
     def __init__(self, min=None, max=None, clamp=False):
         self.min = min
@@ -341,54 +359,70 @@ class FloatRange(FloatParamType):
                 return self.min
             if self.max is not None and rv > self.max:
                 return self.max
-        if self.min is not None and rv < self.min or \
-           self.max is not None and rv > self.max:
+        if (
+            self.min is not None
+            and rv < self.min
+            or self.max is not None
+            and rv > self.max
+        ):
             if self.min is None:
-                self.fail('%s is bigger than the maximum valid value '
-                          '%s.' % (rv, self.max), param, ctx)
+                self.fail(
+                    "%s is bigger than the maximum valid value %s." % (rv, self.max),
+                    param,
+                    ctx,
+                )
             elif self.max is None:
-                self.fail('%s is smaller than the minimum valid value '
-                          '%s.' % (rv, self.min), param, ctx)
+                self.fail(
+                    "%s is smaller than the minimum valid value "
+                    "%s." % (rv, self.min),
+                    param,
+                    ctx,
+                )
             else:
-                self.fail('%s is not in the valid range of %s to %s.'
-                          % (rv, self.min, self.max), param, ctx)
+                self.fail(
+                    "%s is not in the valid range of %s to %s."
+                    % (rv, self.min, self.max),
+                    param,
+                    ctx,
+                )
         return rv
 
     def __repr__(self):
-        return 'FloatRange(%r, %r)' % (self.min, self.max)
+        return "FloatRange(%r, %r)" % (self.min, self.max)
 
 
 class BoolParamType(ParamType):
-    name = 'boolean'
+    name = "boolean"
 
     def convert(self, value, param, ctx):
         if isinstance(value, bool):
             return bool(value)
         value = value.lower()
-        if value in ('true', 't', '1', 'yes', 'y'):
+        if value in ("true", "t", "1", "yes", "y"):
             return True
-        elif value in ('false', 'f', '0', 'no', 'n'):
+        elif value in ("false", "f", "0", "no", "n"):
             return False
-        self.fail('%s is not a valid boolean' % value, param, ctx)
+        self.fail("%s is not a valid boolean" % value, param, ctx)
 
     def __repr__(self):
-        return 'BOOL'
+        return "BOOL"
 
 
 class UUIDParameterType(ParamType):
-    name = 'uuid'
+    name = "uuid"
 
     def convert(self, value, param, ctx):
         import uuid
+
         try:
             if PY2 and isinstance(value, text_type):
-                value = value.encode('ascii')
+                value = value.encode("ascii")
             return uuid.UUID(value)
         except (UnicodeError, ValueError):
-            self.fail('%s is not a valid UUID value' % value, param, ctx)
+            self.fail("%s is not a valid UUID value" % value, param, ctx)
 
     def __repr__(self):
-        return 'UUID'
+        return "UUID"
 
 
 class File(ParamType):
@@ -417,11 +451,13 @@ class File(ParamType):
 
     See :ref:`file-args` for more information.
     """
-    name = 'filename'
+
+    name = "filename"
     envvar_list_splitter = os.path.pathsep
 
-    def __init__(self, mode='r', encoding=None, errors='strict', lazy=None,
-                 atomic=False):
+    def __init__(
+        self, mode="r", encoding=None, errors="strict", lazy=None, atomic=False
+    ):
         self.mode = mode
         self.encoding = encoding
         self.errors = errors
@@ -431,29 +467,30 @@ class File(ParamType):
     def resolve_lazy_flag(self, value):
         if self.lazy is not None:
             return self.lazy
-        if value == '-':
+        if value == "-":
             return False
-        elif 'w' in self.mode:
+        elif "w" in self.mode:
             return True
         return False
 
     def convert(self, value, param, ctx):
         try:
-            if hasattr(value, 'read') or hasattr(value, 'write'):
+            if hasattr(value, "read") or hasattr(value, "write"):
                 return value
 
             lazy = self.resolve_lazy_flag(value)
 
             if lazy:
-                f = LazyFile(value, self.mode, self.encoding, self.errors,
-                             atomic=self.atomic)
+                f = LazyFile(
+                    value, self.mode, self.encoding, self.errors, atomic=self.atomic
+                )
                 if ctx is not None:
                     ctx.call_on_close(f.close_intelligently)
                 return f
 
-            f, should_close = open_stream(value, self.mode,
-                                          self.encoding, self.errors,
-                                          atomic=self.atomic)
+            f, should_close = open_stream(
+                value, self.mode, self.encoding, self.errors, atomic=self.atomic
+            )
             # If a context is provided, we automatically close the file
             # at the end of the context execution (or flush out).  If a
             # context does not exist, it's the caller's responsibility to
@@ -466,10 +503,12 @@ class File(ParamType):
                     ctx.call_on_close(safecall(f.flush))
             return f
         except (IOError, OSError) as e:
-            self.fail('Could not open file: %s: %s' % (
-                filename_to_ui(value),
-                get_streerror(e),
-            ), param, ctx)
+            self.fail(
+                "Could not open file: %s: %s"
+                % (filename_to_ui(value), get_streerror(e),),
+                param,
+                ctx,
+            )
 
 
 class Path(ParamType):
@@ -502,11 +541,20 @@ class Path(ParamType):
                       unicode depending on what makes most sense given the
                       input data Click deals with.
     """
+
     envvar_list_splitter = os.path.pathsep
 
-    def __init__(self, exists=False, file_okay=True, dir_okay=True,
-                 writable=False, readable=True, resolve_path=False,
-                 allow_dash=False, path_type=None):
+    def __init__(
+        self,
+        exists=False,
+        file_okay=True,
+        dir_okay=True,
+        writable=False,
+        readable=True,
+        resolve_path=False,
+        allow_dash=False,
+        path_type=None,
+    ):
         self.exists = exists
         self.file_okay = file_okay
         self.dir_okay = dir_okay
@@ -517,14 +565,14 @@ class Path(ParamType):
         self.type = path_type
 
         if self.file_okay and not self.dir_okay:
-            self.name = 'file'
-            self.path_type = 'File'
+            self.name = "file"
+            self.path_type = "File"
         elif self.dir_okay and not self.file_okay:
-            self.name = 'directory'
-            self.path_type = 'Directory'
+            self.name = "directory"
+            self.path_type = "Directory"
         else:
-            self.name = 'path'
-            self.path_type = 'Path'
+            self.name = "path"
+            self.path_type = "Path"
 
     def coerce_path_result(self, rv):
         if self.type is not None and not isinstance(rv, self.type):
@@ -537,7 +585,7 @@ class Path(ParamType):
     def convert(self, value, param, ctx):
         rv = value
 
-        is_dash = self.file_okay and self.allow_dash and rv in (b'-', '-')
+        is_dash = self.file_okay and self.allow_dash and rv in (b"-", "-")
 
         if not is_dash:
             if self.resolve_path:
@@ -548,31 +596,38 @@ class Path(ParamType):
             except OSError:
                 if not self.exists:
                     return self.coerce_path_result(rv)
-                self.fail('%s "%s" does not exist.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
+                self.fail(
+                    '%s "%s" does not exist.' % (self.path_type, filename_to_ui(value)),
+                    param,
+                    ctx,
+                )
 
             if not self.file_okay and stat.S_ISREG(st.st_mode):
-                self.fail('%s "%s" is a file.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
+                self.fail(
+                    '%s "%s" is a file.' % (self.path_type, filename_to_ui(value)),
+                    param,
+                    ctx,
+                )
             if not self.dir_okay and stat.S_ISDIR(st.st_mode):
-                self.fail('%s "%s" is a directory.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
+                self.fail(
+                    '%s "%s" is a directory.' % (self.path_type, filename_to_ui(value)),
+                    param,
+                    ctx,
+                )
             if self.writable and not os.access(value, os.W_OK):
-                self.fail('%s "%s" is not writable.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
+                self.fail(
+                    '%s "%s" is not writable.'
+                    % (self.path_type, filename_to_ui(value)),
+                    param,
+                    ctx,
+                )
             if self.readable and not os.access(value, os.R_OK):
-                self.fail('%s "%s" is not readable.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
+                self.fail(
+                    '%s "%s" is not readable.'
+                    % (self.path_type, filename_to_ui(value)),
+                    param,
+                    ctx,
+                )
 
         return self.coerce_path_result(rv)
 
@@ -604,8 +659,10 @@ class Tuple(CompositeParamType):
 
     def convert(self, value, param, ctx):
         if len(value) != len(self.types):
-            raise TypeError('It would appear that nargs is set to conflict '
-                            'with the composite type arity.')
+            raise TypeError(
+                "It would appear that nargs is set to conflict "
+                "with the composite type arity."
+            )
         return tuple(ty(x, param, ctx) for ty, x in zip(self.types, value))
 
 
@@ -644,8 +701,9 @@ def convert_type(ty, default=None):
     if __debug__:
         try:
             if issubclass(ty, ParamType):
-                raise AssertionError('Attempted to use an uninstantiated '
-                                     'parameter type (%s).' % ty)
+                raise AssertionError(
+                    "Attempted to use an uninstantiated parameter type (%s)." % ty
+                )
         except TypeError:
             pass
     return FuncParamType(ty)
diff --git a/src/click/utils.py b/src/click/utils.py
index 3c436a4..210bbe4 100644
--- a/src/click/utils.py
+++ b/src/click/utils.py
@@ -30,16 +30,18 @@ echo_native_types = string_types + (bytes, bytearray)
 
 
 def _posixify(name):
-    return '-'.join(name.split()).lower()
+    return "-".join(name.split()).lower()
 
 
 def safecall(func):
     """Wraps a function so that it swallows exceptions."""
+
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
         except Exception:
             pass
+
     return wrapper
 
 
@@ -49,7 +51,7 @@ def make_str(value):
         try:
             return value.decode(get_filesystem_encoding())
         except UnicodeError:
-            return value.decode('utf-8', 'replace')
+            return value.decode("utf-8", "replace")
     return text_type(value)
 
 
@@ -61,21 +63,21 @@ def make_default_short_help(help, max_length=45):
     done = False
 
     for word in words:
-        if word[-1:] == '.':
+        if word[-1:] == ".":
             done = True
         new_length = result and 1 + len(word) or len(word)
         if total_length + new_length > max_length:
-            result.append('...')
+            result.append("...")
             done = True
         else:
             if result:
-                result.append(' ')
+                result.append(" ")
             result.append(word)
         if done:
             break
         total_length += new_length
 
-    return ''.join(result)
+    return "".join(result)
 
 
 class LazyFile(object):
@@ -85,19 +87,19 @@ class LazyFile(object):
     files for writing.
     """
 
-    def __init__(self, filename, mode='r', encoding=None, errors='strict',
-                 atomic=False):
+    def __init__(
+        self, filename, mode="r", encoding=None, errors="strict", atomic=False
+    ):
         self.name = filename
         self.mode = mode
         self.encoding = encoding
         self.errors = errors
         self.atomic = atomic
 
-        if filename == '-':
-            self._f, self.should_close = open_stream(filename, mode,
-                                                     encoding, errors)
+        if filename == "-":
+            self._f, self.should_close = open_stream(filename, mode, encoding, errors)
         else:
-            if 'r' in mode:
+            if "r" in mode:
                 # Open and close the file in case we're opening it for
                 # reading so that we can catch at least some errors in
                 # some cases early.
@@ -111,7 +113,7 @@ class LazyFile(object):
     def __repr__(self):
         if self._f is not None:
             return repr(self._f)
-        return '<unopened file %r %s>' % (self.name, self.mode)
+        return "<unopened file %r %s>" % (self.name, self.mode)
 
     def open(self):
         """Opens the file if it's not yet open.  This call might fail with
@@ -121,12 +123,12 @@ class LazyFile(object):
         if self._f is not None:
             return self._f
         try:
-            rv, self.should_close = open_stream(self.name, self.mode,
-                                                self.encoding,
-                                                self.errors,
-                                                atomic=self.atomic)
+            rv, self.should_close = open_stream(
+                self.name, self.mode, self.encoding, self.errors, atomic=self.atomic
+            )
         except (IOError, OSError) as e:
             from .exceptions import FileError
+
             raise FileError(self.name, hint=get_streerror(e))
         self._f = rv
         return rv
@@ -155,7 +157,6 @@ class LazyFile(object):
 
 
 class KeepOpenFile(object):
-
     def __init__(self, file):
         self._file = file
 
@@ -233,11 +234,11 @@ def echo(message=None, file=None, nl=True, err=False, color=None):
         message = text_type(message)
 
     if nl:
-        message = message or u''
+        message = message or u""
         if isinstance(message, text_type):
-            message += u'\n'
+            message += u"\n"
         else:
-            message += b'\n'
+            message += b"\n"
 
     # If there is a message, and we're in Python 3, and the value looks
     # like bytes, we manually need to find the binary stream and write the
@@ -284,11 +285,11 @@ def get_binary_stream(name):
     """
     opener = binary_streams.get(name)
     if opener is None:
-        raise TypeError('Unknown standard stream %r' % name)
+        raise TypeError("Unknown standard stream %r" % name)
     return opener()
 
 
-def get_text_stream(name, encoding=None, errors='strict'):
+def get_text_stream(name, encoding=None, errors="strict"):
     """Returns a system stream for text processing.  This usually returns
     a wrapped stream around a binary stream returned from
     :func:`get_binary_stream` but it also can take shortcuts on Python 3
@@ -301,12 +302,13 @@ def get_text_stream(name, encoding=None, errors='strict'):
     """
     opener = text_streams.get(name)
     if opener is None:
-        raise TypeError('Unknown standard stream %r' % name)
+        raise TypeError("Unknown standard stream %r" % name)
     return opener(encoding, errors)
 
 
-def open_file(filename, mode='r', encoding=None, errors='strict',
-              lazy=False, atomic=False):
+def open_file(
+    filename, mode="r", encoding=None, errors="strict", lazy=False, atomic=False
+):
     """This is similar to how the :class:`File` works but for manual
     usage.  Files are opened non lazy by default.  This can open regular
     files as well as stdin/stdout if ``'-'`` is passed.
@@ -331,8 +333,7 @@ def open_file(filename, mode='r', encoding=None, errors='strict',
     """
     if lazy:
         return LazyFile(filename, mode, encoding, errors, atomic=atomic)
-    f, should_close = open_stream(filename, mode, encoding, errors,
-                                  atomic=atomic)
+    f, should_close = open_stream(filename, mode, encoding, errors, atomic=atomic)
     if not should_close:
         f = KeepOpenFile(f)
     return f
@@ -412,19 +413,21 @@ def get_app_dir(app_name, roaming=True, force_posix=False):
                         application support folder.
     """
     if WIN:
-        key = roaming and 'APPDATA' or 'LOCALAPPDATA'
+        key = roaming and "APPDATA" or "LOCALAPPDATA"
         folder = os.environ.get(key)
         if folder is None:
-            folder = os.path.expanduser('~')
+            folder = os.path.expanduser("~")
         return os.path.join(folder, app_name)
     if force_posix:
-        return os.path.join(os.path.expanduser('~/.' + _posixify(app_name)))
-    if sys.platform == 'darwin':
-        return os.path.join(os.path.expanduser(
-            '~/Library/Application Support'), app_name)
+        return os.path.join(os.path.expanduser("~/." + _posixify(app_name)))
+    if sys.platform == "darwin":
+        return os.path.join(
+            os.path.expanduser("~/Library/Application Support"), app_name
+        )
     return os.path.join(
-        os.environ.get('XDG_CONFIG_HOME', os.path.expanduser('~/.config')),
-        _posixify(app_name))
+        os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")),
+        _posixify(app_name),
+    )
 
 
 class PacifyFlushWrapper(object):
@@ -444,6 +447,7 @@ class PacifyFlushWrapper(object):
             self.wrapped.flush()
         except IOError as e:
             import errno
+
             if e.errno != errno.EPIPE:
                 raise