�
o�Dac@srdd
lZdd
l
Z
dd
lZdd
lZddlmZ
ddlmZ
ddlm	Z	
ddl
mZ
ddl
mZ
ddl
m
Z

dd	l
mZ
dd
lmZ
ddlmZ
ddlmZ
dd
lmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlm Z 
ddlm!Z!
ddl"m#Z#
ddl"m$Z$
ddl"m%Z%
ddl&m'Z'
ddl&m(Z(
ddl&m)Z)
ddl*m+Z+
ddl*m,Z,
dd l*m-Z-
dd!l*m.Z.
dd"l*m/Z/
e0�Z1d#Z2d$Z3d%Z4d&Z5d'�Z6d(�Z7e8d)�
Z9e:d*�
Z;d+�Z<d,�Z=ee8d-�
�
Z>d.�Z?d/e0f
d0��YZ@d1e0f
d2��YZAd3eAf
d4��YZBd5eBf
d6��YZCd7eCf
d8��YZDd9eCf
d:��YZEd;e0f
d<��YZFd=eFf
d>��YZGd?eFf
d@��YZHd
S(Ai����N(
tcontextmanager(
tupdate_wrapper(
trepeati
(
tisidentifier(
t	iteritems(
tPY2(
tstring_types(
t_check_for_unicode_literals(
t_verify_python3_env(
tAbort(
tBadParameter(
tClickException(
tExit(
tMissingParameter(
t
UsageError(
t
HelpFormatter(
tjoin_options(
tpop_context(
tpush_context(
tOptionParser(
t	split_opt(
tconfirm(
tprompt(
tstyle(
tBOOL(
tconvert_type(
tIntRange(
techo(
tget_os_args(
tmake_default_short_help(
tmake_str(
tPacifyFlushWrappersCOMMAND [ARGS]...s*COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...s
 (DEPRECATED)s7DeprecationWarning: The command %(name)s is deprecated.c

Cs:|jr6t
tti
|jd
6dd�

dt�


ndS(Ntnametfgtredterr(t
deprecatedRRtDEPRECATED_INVOKE_NOTICER tTrue(
tcmd((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt_maybe_show_deprecated_notice0s
	
c

Cs+tj
j�
tjj�
tj|�

d
S(slExit without garbage collection, this speeds up exit by about 10ms for
    things like bash completion.
    N(tsyststdouttflushtstderrtost_exit(
tcode((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt	fast_exit5s



cCs�|dkr0d
j
|
jdd�j��
}ntjj|�
}|sLdSddlm}
|||
||�r~t	d�

ndS(s1Internal handler for the bash completion support.s_{}_COMPLETEt
-t
_Ni
(
tbashcomplete(
tNonetformattreplacetupperR-tenvirontgett
_bashcompleteR3R0(R't	prog_nametcomplete_vartcomplete_instrR3((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR:>s
$



c	Csp|jst
|t�rdS|r-d
}nd}tdj||j|
|
|jj|jj|j��
�
dS(NsdIt is not possible to add multi commands as children to another multi command that is in chain mode.sdFound a multi command as subcommand to a multi command that is in chain mode. This is not supported.s�{}. Command '{}' is set to chain and '{}' was added as subcommand but it in itself is a multi command. ('{}' is a {} within a chained {} named '{}').(tchaint
isinstancetMultiCommandtRuntimeErrorR5R t	__class__t__name__(tbase_commandtcmd_nameR'tregisterthint((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt_check_multicommandLs


	




	
	
cCstt
tt|�
|
���
S(
N(tlisttzipRtiter(titerablet
batch_size((s)/tmp/pip-build-W6Gm0N/click/click/core.pytbatchhs
cCsyt|d
d�}t|dd�}|dkriddlm}
|dj|�
tdd�

||
|�S||
||�S(Nt__code__tco_argcountii����(
twarnsoParameter callbacks take 3 args, (ctx, param, value). The 2-arg style is deprecated and will be removed in 8.0.t
stacklevel(tgetattrR4twarningsRQR5tDeprecationWarning(tcallbacktctxtparamtvalueR/targsRQ((s)/tmp/pip-build-W6Gm0N/click/click/core.pytinvoke_param_callbackls







ccs�y	d
V
Wn�tk
rc
}
|j
d
kr6||_
n|
d
k	r]|jd
kr]|
|_n�n1tk
r�
}
|j
d
kr�||_
n�n
Xd
S(s>Context manager that attaches extra information to exceptions.N(R
RWR4RXR(RWRXt
e((s)/tmp/pip-build-W6Gm0N/click/click/core.pytaugment_usage_errors~s
	









cs�f
d
�}t|
d|�

S(s�Given a sequence of parameters in the order as should be considered
    for processing and an iterable of parameters that exist, this returns
    a list in the correct order as they should be processed.
    c
sAy�j|�
}
Wnt
k
r2


td
�
}
n
X|j|
fS(Ntinf(tindext
ValueErrortfloattis_eager(titemtidx(
tinvocation_order(s)/tmp/pip-build-W6Gm0N/click/click/core.pytsort_key�s






tkey(
tsorted(Retdeclaration_orderRf((
Res)/tmp/pip-build-W6Gm0N/click/click/core.pytiter_params_for_processing�stContextcBs
eZ
dZdddddddedddddddd
�Zd�Zd�Zee	d�
�
Z
ed��
Zd�Z
d�Zd�Zed	��
Zd
�Zd�Zd�Zd
�Zd�Zd�Zdd�
Zd�Zd�Zd�Zd�ZRS(s�The context is a special internal object that holds state relevant
    for the script execution at every single level.  It's normally invisible
    to commands unless they opt-in to getting access to it.

    The context is useful as it can pass internal objects around and can
    control special execution features such as reading data from
    environment variables.

    A context can be used as context manager in which case it will call
    :meth:`close` on teardown.

    .. versionadded:: 2.0
       Added the `resilient_parsing`, `help_option_names`,
       `token_normalize_func` parameters.

    .. versionadded:: 3.0
       Added the `allow_extra_args` and `allow_interspersed_args`
       parameters.

    .. versionadded:: 4.0
       Added the `color`, `ignore_unknown_options`, and
       `max_content_width` parameters.

    .. versionadded:: 7.1
       Added the `show_default` parameter.

    :param command: the command class for this context.
    :param parent: the parent context.
    :param info_name: the info name for this invocation.  Generally this
                      is the most descriptive name for the script or
                      command.  For the toplevel script it is usually
                      the name of the script, for commands below it it's
                      the name of the script.
    :param obj: an arbitrary object of user data.
    :param auto_envvar_prefix: the prefix to use for automatic environment
                               variables.  If this is `None` then reading
                               from environment variables is disabled.  This
                               does not affect manually set environment
                               variables which are always read.
    :param default_map: a dictionary (like object) with default values
                        for parameters.
    :param terminal_width: the width of the terminal.  The default is
                           inherit from parent context.  If no context
                           defines the terminal width then auto
                           detection will be applied.
    :param max_content_width: the maximum width for content rendered by
                              Click (this currently only affects help
                              pages).  This defaults to 80 characters if
                              not overridden.  In other words: even if the
                              terminal is larger than that, Click will not
                              format things wider than 80 characters by
                              default.  In addition to that, formatters might
                              add some safety mapping on the right.
    :param resilient_parsing: if this flag is enabled then Click will
                              parse without any interactivity or callback
                              invocation.  Default values will also be
                              ignored.  This is useful for implementing
                              things such as completion support.
    :param allow_extra_args: if this is set to `True` then extra arguments
                             at the end will not raise an error and will be
                             kept on the context.  The default is to inherit
                             from the command.
    :param allow_interspersed_args: if this is set to `False` then options
                                    and arguments cannot be mixed.  The
                                    default is to inherit from the command.
    :param ignore_unknown_options: instructs click to ignore options it does
                                   not know and keeps them for later
                                   processing.
    :param help_option_names: optionally a list of strings that define how
                              the default help parameter is named.  The
                              default is ``['--help']``.
    :param token_normalize_func: an optional function that is used to
                                 normalize tokens (options, choices,
                                 etc.).  This for instance can be used to
                                 implement case insensitive behavior.
    :param color: controls if the terminal supports ANSI colors or not.  The
                  default is autodetection.  This is only needed if ANSI
                  codes are used in texts that Click prints which is by
                  default not the case.  This for instance would affect
                  help output.
    :param show_default: if True, shows defaults for all options.
                    Even if an option is later created with show_default=False,
                    this command-level setting overrides it.
    cCs�||_|
|_
||_i|_g|_g|_|dkrZ|dk	rZ|j}n||_t|d
i�|_	|dkr�|dk	r�|j
dk	r�|j
j|�
}n||_
d|_|dkr�|dk	r�|j
}n||_
|dkr
|dk	r
|j}n||_|
dkr8
|
j}
n|
|_|dkrY
|
j}n||_|dkrz
|
j}n||_|
dkr�
|dk	r�
|j}
q�
dg
}
n|
|_|dkr�
|dk	r�
|j}n||_|	|_|dkrL|dk	rX|jdk	rX|jdk	rXdj|j|jj��}qXn|j�}|dk	ry|jdd�}n||_|dkr�|dk	r�|j}n||_||_g|_d|_dS(Ntmetas--helps{}_{}R1R2i(tparenttcommandt	info_nametparamsRZtprotected_argsR4tobjRSt_metatdefault_mapR9tinvoked_subcommandtterminal_widthtmax_content_widthtallow_extra_argstallow_interspersed_argstignore_unknown_optionsthelp_option_namesttoken_normalize_functresilient_parsingtauto_envvar_prefixR5R7R6tcolortshow_defaultt_close_callbackst_depth(tselfRnRmRoRrR~RtRvRwR}RxRyRzR{R|RR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt__init__�sp						

	



		
	
	
	
	
		

	
		





	
			
c

Cs|jd
7_t
|�

|S(Ni
(R�R(
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt	__enter__�
s



cCs6|jd
8_|jdkr+|j
�
nt�
dS(Ni
i(R�tcloseR(R�texc_typet	exc_valuettb((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt__exit__�
s




ccsP|
s|jd
7_nz|�}|V
WdQXWd|
sK|jd
8_nXdS(sIThis helper method can be used with the context object to promote
        it to the current thread local (see :func:`get_current_context`).
        The default behavior of this is to invoke the cleanup functions which
        can be disabled by setting `cleanup` to `False`.  The cleanup
        functions are typically used for things such as closing file handles.

        If the cleanup is intended the context object can also be directly
        used as a context manager.

        Example usage::

            with ctx.scope():
                assert get_current_context() is ctx

        This is equivalent::

            with ctx:
                assert get_current_context() is ctx

        .. versionadded:: 5.0

        :param cleanup: controls if the cleanup functions should be run or
                        not.  The default is to run these functions.  In
                        some situations the context only wants to be
                        temporarily pushed in which case this can be disabled.
                        Nested pushes automatically defer the cleanup.
        i
N(
R�(R�tcleanuptrv((s)/tmp/pip-build-W6Gm0N/click/click/core.pytscope�
s


	

c


Cs|jS(
s�This is a dictionary which is shared with all the contexts
        that are nested.  It exists so that click utilities can store some
        state here if they need to.  It is however the responsibility of
        that code to manage this dictionary well.

        The keys are supposed to be unique dotted strings.  For instance
        module paths are a good choice for it.  What is stored in there is
        irrelevant for the operation of click.  However what is important is
        that code that places data here adheres to the general semantics of
        the system.

        Example usage::

            LANG_KEY = f'{__name__}.lang'

            def set_language(value):
                ctx = get_current_context()
                ctx.meta[LANG_KEY] = value

            def get_language():
                return get_current_context().meta.get(LANG_KEY, 'en_US')

        .. versionadded:: 5.0
        (
Rs(
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyRl�
sc

Cstd
|j
d|j�S(s4Creates the formatter for the help and usage output.twidtht	max_width(RRvRw(
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pytmake_formatter�
s
cCs|jj
|
�

|
S(
st
This decorator remembers a function as callback that should be
        executed when the context tears down.  This is most useful to bind
        resource handling to the script execution.  For instance, file objects
        opened by the :class:`File` type will register their close callbacks
        here.

        :param f: the function to execute on teardown.
        (R�tappend(R�t
f((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt
call_on_close�
s	
c
Cs(x|jD]
}
|
�
q
Wg|_d
S(sInvokes all close callbacks.N(
R�(R�tcb((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��
s

c
CsUd
}
|jdk	r!|j}
n|jdk	rKdj|jj|
�}
n|
j�S(s�The computed command path.  This is used for the ``usage``
        information on the help page.  It's automatically created by
        combining the info names of the chain of contexts to the root.
        ts{} {}N(RoR4RmR5tcommand_pathtlstrip(R�R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��
s




c
Cs)|}
x|
jd
k	r$|
j}
q	W|
S(sFinds the outermost context.N(RmR4(R�tnode((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt	find_root�
s



cCs?|}x2|d
k	r:t
|j|
�r.|jS|j}q	Wd
S(s)Finds the closest object of a given type.N(R4R?RrRm(R�tobject_typeR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pytfind_objects




cCs2|j|
�
}|d
kr.|
�|_}n|S(s�Like :meth:`find_object` but sets the innermost object to a
        new instance of `object_type` if it does not exist.
        N(R�R4Rr(R�R�R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt
ensure_object
s


cCsA|jd
k	r=|jj|
�
}t|�
r9|�}n|Sd
S(s}Looks up the default for a parameter name.  This by default
        looks into the :attr:`default_map` if available.
        N(RtR4R9tcallable(R�R R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pytlookup_defaults




cCst|
|��
d
S(s�Aborts the execution of the program with a specific error
        message.

        :param message: the error message to fail with.
        N(
R(R�tmessage((s)/tmp/pip-build-W6Gm0N/click/click/core.pytfail sc


Cs
t��
d
S(sAborts the script.N(
R	(
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pytabort(sicCst|
�
�
d
S(s-Exits the application with a given exit code.N(
R(R�R/((s)/tmp/pip-build-W6Gm0N/click/click/core.pytexit,sc

Cs|jj
|�
S(
saHelper method to get formatted usage string for the current
        context and command.
        (Rnt	get_usage(
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�0sc

Cs|jj
|�
S(
s^Helper method to get formatted help page for the current
        context and command.
        (Rntget_help(
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�6scOs�|d
 \}}|}t|t
�r�|}|j}t|d|jd|�
}|dkrjtd�
�
nxE|jD]7}|j|
krt|jrt|j	|�
|
|j<qtqtWn|d
}t
|�
�
|�
|||
�SWdQXWdQXdS(s"Invokes a command callback in exactly the way it expects.  There
        are two ways to invoke this method:

        1.  the first argument can be a callback and all other arguments and
            keyword arguments are forwarded directly to the function.
        2.  the first argument is a click command object.  In that case all
            arguments are forwarded as well but proper click parameters
            (options and click arguments) must be keyword arguments and Click
            will fill in defaults.

        Note that before Click 3.2 keyword arguments were not properly filled
        in against the intention of this code and no context was created.  For
        more information about this change and why it was done in a bugfix
        release see :ref:`upgrade-to-3.2`.
        iRoRms?The given command does not have a callback that can be invoked.N(R?tCommandRVRkR R4t	TypeErrorRptexpose_valuetget_defaultR](RZtkwargsR�RVRWt	other_cmdRX((s)/tmp/pip-build-W6Gm0N/click/click/core.pytinvoke<s 


	





 




cOsr|d
 \}}t|t
�s.td�
�
nx1|jD]&}||
kr8|j||
|<q8q8W|j||
�
S(s�Similar to :meth:`invoke` but fills in default keyword
        arguments from the current context if the other command expects
        it.  This cannot invoke callbacks directly, only other commands.
        isCallback is not a command.(R?R�R�RpR�(RZR�R�R'RX((s)/tmp/pip-build-W6Gm0N/click/click/core.pytforwardds


N(RCt
__module__t__doc__R4tFalseR�R�R�RR&R�tpropertyRlR�R�R�R�R�R�R�R�R�R�R�R�R�R�R�(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyRk�sHT













�		
%			
					
					(tBaseCommandcBs�eZ
dZeZeZeZd
d
�
Z	d�Z
d�Zd�Zd
d�
Z
d�Zd�Zd
d
d
ed�Zd	�ZRS(s�The base command implements the minimal API contract of commands.
    Most code will never use this as it does not implement a lot of useful
    functionality but it can act as the direct subclass of alternative
    parsing methods that do not depend on the Click parser.

    For instance, this can be used to bridge Click and other systems like
    argparse or docopt.

    Because base commands do not implement a lot of the API that other
    parts of Click take for granted, they are not supported for all
    operations.  For instance, they cannot be used with the decorators
    usually and they have no built-in callback system.

    .. versionchanged:: 2.0
       Added the `context_settings` parameter.

    :param name: the name of the command to use unless a group overrides it.
    :param context_settings: an optional dictionary with defaults that are
                             passed to the context object.
    cCs+|
|_|dkri}n||_dS(
N(R R4tcontext_settings(R�R R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s	

	c

Csd
j|j
j|j�S(Ns<{} {}>(R5RBRCR (
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt__repr__�s
cCstd
�
�
dS(NsBase commands cannot get usage(
tNotImplementedError(R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s
cCstd
�
�
dS(NsBase commands cannot get help(
R�(R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s
cKs�x6t|j
�
D]%\}}||kr|||<qqWt|d
|
d||�
}|jdt�
�
|j||�
WdQX|S(sThis function when given an info name and arguments will kick
        off the parsing and create a new :class:`Context`.  It does not
        invoke the actual command callback though.

        :param info_name: the info name for this invokation.  Generally this
                          is the most descriptive name for the script or
                          command.  For the toplevel script it's usually
                          the name of the script, for commands below it it's
                          the name of the script.
        :param args: the arguments to parse as list of strings.
        :param parent: the parent context if available.
        :param extra: extra keyword arguments forwarded to the context
                      constructor.
        RoRmR�N(RR�RkR�R�t
parse_args(R�RoRZRmtextraRgRYRW((s)/tmp/pip-build-W6Gm0N/click/click/core.pytmake_context�s





cCstd
�
�
dS(s�Given a context and a list of arguments this creates the parser
        and parses the arguments, then modifies the context as necessary.
        This is automatically invoked by :meth:`make_context`.
        s1Base commands do not know how to parse arguments.N(
R�(R�RWRZ((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��scCstd
�
�
dS(s{Given a context, this invokes the command.  The default
        implementation is raising a not implemented error.
        s*Base commands are not invokable by defaultN(
R�(R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��sc	Ks
tst
�
nt�
|
dkr/t�}
nt|
�
}
|dkrxttjj	t
jrit
jd
nt�
�
}nt
|||�
y
yE|j||
|��*}|j|�
}|s�|S|j�
WdQXWn�ttfk
r



tdt
j�

t��
n�tk
r:

}
|s
�n|j�
t
j|j�

n\tk
r�

}
|jtjkr�
tt
j�
t
_tt
j�
t
_t
jd�

q�
�n
XWnotk
r�

}
|r�
t
j|j�

q	|jSn=tk
r


|s�
�ntddt
j�


t
jd�

n
XdS(s1This 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``
        needs to be caught.

        This method is also available by directly calling the instance of
        a :class:`Command`.

        .. versionadded:: 3.0
           Added the `standalone_mode` flag to control the standalone mode.

        :param args: the arguments that should be used for parsing.  If not
                     provided, ``sys.argv[1:]`` is used.
        :param prog_name: the program name that should be used.  By default
                          the program name is constructed by taking the file
                          name from ``sys.argv[0]``.
        :param complete_var: the environment variable that controls the
                             bash completion support.  The default is
                             ``"_<prog_name>_COMPLETE"`` with prog_name in
                             uppercase.
        :param standalone_mode: the default behavior is to invoke the script
                                in standalone mode.  Click will then
                                handle exceptions and convert them into
                                error messages and the function will never
                                return but shut down the interpreter.  If
                                this is set to `False` they will be
                                propagated to the caller and the return
                                value of this function is the return value
                                of :meth:`invoke`.
        :param extra: extra keyword arguments are forwarded to the context
                      constructor.  See :class:`Context` for more information.
        iNtfilei
sAborted!(RRRR4RRIRR-tpathtbasenameR)targvt__file__R:R�R�R�tEOFErrortKeyboardInterruptRR,R	Rtshowt	exit_codetIOErrorterrnotEPIPERR*R(	R�RZR;R<tstandalone_modeR�RWR�R\((s)/tmp/pip-build-W6Gm0N/click/click/core.pytmain�sP+




.





























c
Os|j|
|�S(
sAlias for :meth:`main`.(
R�(R�RZR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt__call__;sN(RCR�R�R�RxR&RyRzR4R�R�R�R�R�R�R�R�R�(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�ws 					


jR�cBs�eZ
dZddddddd
eeeed�Zd�Zd�Zd�Z	d�Z
d�Zd�Zd	�Z
d
�Zdd�
Zd
�Zd�Zd�Zd�Zd�Zd�ZRS(s�Commands are the basic building block of command line interfaces in
    Click.  A basic command handles command line parsing and might dispatch
    more parsing to commands nested below it.

    .. versionchanged:: 2.0
       Added the `context_settings` parameter.
    .. versionchanged:: 7.1
       Added the `no_args_is_help` parameter.

    :param name: the name of the command to use unless a group overrides it.
    :param context_settings: an optional dictionary with defaults that are
                             passed to the context object.
    :param callback: the callback to invoke.  This is optional.
    :param params: the parameters to register with this command.  This can
                   be either :class:`Option` or :class:`Argument` objects.
    :param help: the help string to use for this command.
    :param epilog: like the help string but it's printed at the end of the
                   help page after everything else.
    :param short_help: the short help to use for this command.  This is
                       shown on the command listing of the parent command.
    :param add_help_option: by default each command registers a ``--help``
                            option.  This can be disabled by this parameter.
    :param no_args_is_help: this controls what happens if no arguments are
                            provided.  This option is disabled by default.
                            If enabled this will add ``--help`` as argument
                            if no arguments are passed
    :param hidden: hide this command from help outputs.

    :param deprecated: issues a message indicating that
                             the command is deprecated.
    s	[OPTIONS]c

Cs�tj
||
|�
||_|p%g|_|rVd
|krV|jd
d�d}n||_||_||_||_|	|_	|
|_
||_||_dS(Ns
i
i(
R�R�RVRptsplitthelptepilogtoptions_metavart
short_helptadd_help_optiontno_args_is_helpthiddenR$(
R�R R�RVRpR�R�R�R�R�R�R�R$((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�as	

	
	
	
	
	
	
	
cCs/|
j�}|j
|
|�
|j�jd
�
S(smFormats the usage line into a string and returns it.

        Calls :meth:`format_usage` internally.
        s

(R�tformat_usagetgetvaluetrstrip(R�RWt	formatter((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s

cCs8|j}|j
|
�
}|dk	r4||g
}n|S(
N(Rptget_help_optionR4(R�RWR�thelp_option((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt
get_params�s

	



cCs/|j|
�
}|j
|
jd
j|�
�
dS(ssWrites the usage line into the formatter.

        This is a low-level method called by :meth:`get_usage`.
        t
 N(tcollect_usage_piecestwrite_usageR�tjoin(R�RWR�tpieces((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s
cCs@|jg
}x-|j
|
�
D]}|j|j|
�
�

qW|S(
shReturns all the pieces that go into the usage line and returns
        it as a list of strings.
        (R�R�textendtget_usage_pieces(R�RWR�RX((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s


cCsGt|
j
�
}x1|jD]&}|j|j�

|j|j�

qW|S(
s&Returns the names for the help option.(tsetR{Rptdifference_updatetoptstsecondary_opts(R�RWt	all_namesRX((s)/tmp/pip-build-W6Gm0N/click/click/core.pytget_help_option_names�s




cCsU|j|
�
}|s |j
r$d
Sd�}t|dtdtdtd|dd�
S(	sReturns the help option object.NcSs:|r6|jr6t
|j�d
|j�


|j�
ndS(NR(R}RR�RR�(RWRXRY((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt	show_help�s


tis_flagRbR�RVR�sShow this message and exit.(R�R�tOptionR&R�(R�RWthelp_optionsR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s

	





cCs:t|
�
}x'|j
|
�
D]}|j||
�
qW|S(
s6Creates the underlying option parser for this command.(RR�t
add_to_parser(R�RWtparserRX((s)/tmp/pip-build-W6Gm0N/click/click/core.pytmake_parser�s


cCs/|
j�}|j
|
|�
|j�jd
�
S(sfFormats the help into a string and returns it.

        Calls :meth:`format_help` internally.
        s

(R�tformat_helpR�R�(R�RWR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s

i-cCs(|jp'|j
r$t|j
|
�p'd
S(s`Gets short help for the command or makes it by shortening the
        long help string.
        R�(R�R�R(R�tlimit((s)/tmp/pip-build-W6Gm0N/click/click/core.pytget_short_help_str�s	
	

cCsD|j|
|�
|j
|
|�
|j|
|�
|j|
|�
d
S(s0
Writes the help into the formatter if it exists.

        This is a low-level method called by :meth:`get_help`.

        This calls the following methods:

        -   :meth:`format_usage`
        -   :meth:`format_help_text`
        -   :meth:`format_options`
        -   :meth:`format_epilog`
        N(R�tformat_help_texttformat_optionst
format_epilog(R�RWR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s


cCs�|jrU|j
�
|j��1
|j}|jr?|t7}n|j|�

Wd
QXn6|jr�|j
�
|j��
|jt�

Wd
QXnd
S(s3Writes the help text to the formatter if it exists.N(R�twrite_paragraphtindentationR$tDEPRECATED_HELP_NOTICEt
write_text(R�RWR�t	help_text((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s	




	
	



	




cCs{g}xB|j|
�
D]1}|j
|
�
}|dk	r|j|�

qqW|rw|jd
�
�
|j|�

WdQXndS(s8Writes all the options into the formatter if they exist.tOptionsN(R�tget_help_recordR4R�tsectiontwrite_dl(R�RWR�R�RXR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s





cCs=|jr9|j
�
|j��
|j|j�

Wd
QXnd
S(s2Writes the epilog into the formatter if it exists.N(R�R�R�R�(R�RWR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�s	




cCs
|r@|jr@|
j
r@t|
j�d
|
j�


|
j�
n|j|
�
}|jd|�
\}}}x;t||j	|
�
�D]!}|j
|
||�\}}q�W|r
|
jr
|
j
r
|
jdj
t|�
dkr�dnddjtt|��
��

n||
_|S(NRRZs$Got unexpected extra argument{} ({})i
t
sR�R�(R�R}RR�RR�R�R�RjR�thandle_parse_resultRxR�R5tlenR�tmapRRZ(R�RWRZR�R�tparam_orderRXRY((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�s








:	
cCs3t|�

|j
d
k	r/|
j|j
|
j�
Sd
S(seGiven a context, this invokes the attached callback (if it exists)
        in the right way.
        N(R(RVR4R�Rp(R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�$s


N(RCR�R�R4R&R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�@s6









																R@cBs�eZ
dZeZeZdeddedd
�Zd�Z	d�Z
ed�
Zd�Zd�Z
d�Zd�Zd	�Zd
�ZRS(sA multi command is the basic implementation of a command that
    dispatches to subcommands.  The most common version is the
    :class:`Group`.

    :param invoke_without_command: this controls how the multi command itself
                                   is invoked.  By default it's only invoked
                                   if a subcommand is provided.
    :param no_args_is_help: this controls what happens if no arguments are
                            provided.  This option is enabled by default if
                            `invoke_without_command` is disabled or disabled
                            if it's enabled.  If enabled this will add
                            ``--help`` as argument if no arguments are
                            passed.
    :param subcommand_metavar: the string that is used in the documentation
                               to indicate the subcommand place.
    :param chain: if this is set to `True` chaining of multiple subcommands
                  is enabled.  This restricts the form of commands in that
                  they cannot have optional arguments but it allows
                  multiple commands to be chained together.
    :param result_callback: the result callback to attach to this multi
                            command.
    c	Ks�tj
||
|�
|dkr)|}n||_||_|dkr_|rVt}q_t}n||_||_||_	|jr�x<|j
D].}t|t�r�|j
r�td
�
�
q�q�WndS(Ns<Multi commands in chain mode cannot have optional arguments.(R�R�R4R�tinvoke_without_commandtSUBCOMMANDS_METAVARtSUBCOMMAND_METAVARtsubcommand_metavarR>tresult_callbackRpR?tArgumenttrequiredRA(	R�R R�R�R

R>R
tattrsRX((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�Hs"




	
	


		
	
			



cCs&tj
||
�}|j|j�

|S(
N(R�R�R�R

(R�RWR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�js


cCs'tj
||
|�
|j|
|�
dS(
N(R�R�tformat_commands(R�RWR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�os

cs��
fd
�}|S(smAdds a result callback to the chain command.  By default if a
        result callback is already registered this will chain them but
        this can be disabled with the `replace` parameter.  The result
        callback is invoked with the return value of the subcommand
        (or the list of return values from all subcommands if chaining
        is enabled) as well as the parameters as they would be passed
        to the main callback.

        Example::

            @click.group()
            @click.option('-i', '--input', default=23)
            def cli(input):
                return 42

            @cli.resultcallback()
            def process_result(result, input):
                return result + input

        .. versionadded:: 3.0

        :param replace: if set to `True` an already existing result
                        callback will be removed.
        c
sT�j�
�
dks�r(��_�S��
fd
�}
t|
���_}|S(Nc
s��
||
|�
|
|�
S(
N((t_MultiCommand__valueRZR�(R�told_callback(s)/tmp/pip-build-W6Gm0N/click/click/core.pytfunction�s
(R
R4R
(R�R	
R�(R6R�(R�R
s)/tmp/pip-build-W6Gm0N/click/click/core.pyt	decorator�s
	

	

((R�R6R

((R6R�s)/tmp/pip-build-W6Gm0N/click/click/core.pytresultcallbackssc	Cs
g}x]|j|
�
D]L}|j
|
|�}|dkr@qn|jrOqn|j||f�

qWt|�
r

|jd
td�|D�
�
}g}x6|D].\}}|j|�
}|j||f�

q�W|r

|j	d�
�
|j
|�

WdQXq

ndS(seExtra format methods for multi methods that adds all the commands
        after the options.
        ic
ss|]}
t|
d�
V
qd
S(iN(
R�(t.0R'((s)/tmp/pip-build-W6Gm0N/click/click/core.pys	<genexpr>�stCommandsN(t
list_commandstget_commandR4R�R�R�R�tmaxR�R�R�(	R�RWR�tcommandst
subcommandR'R�trowsR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
�s"



	

!




cCs�|r@|jr@|
j
r@t|
j�d
|
j�


|
j�
ntj||
|�}|jrs||
_	g|
_
n$|r�|d |d|
_	|
_
n|
j
S(NRi
(R�R}RR�RR�R�R�R>RqRZ(R�RWRZtrest((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s




	
	


c	s��
fd
�}�jsw�
j
rg�
js=tj�
��S��
tj�
��
|g�
SWdQXn�jd�

n�j�j}g�_g�_�
js!
��t
�
j�|�\}}}|�_tj�
��
|j	||d��
}|�
||j
j|�
�
SWdQXWdQXn���
|r4
dnd�_tj�
��
g}xi|r�
�
j�|�\}}}|j	||d�dtdt
�}|j|�

|jg}|_qV
Wg}x4|D],}|�
|j|j
j|�
�

WdQXq�
W||�
SWdQXdS(Nc

s1�
jdk	r-�j�
j|�j�}n|S(
N(R
R4R�Rp(
RY(RWR�(s)/tmp/pip-build-W6Gm0N/click/click/core.pyt_process_result�s


sMissing command.Rmt
*RxRy(RqR�R>R�R�R�RZtresolve_commandRuR�RnR4R&R�R�(	R�RWR
RZRER'tsub_ctxtcontextsR�((RWR�s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��sN
		
	





	
		

	



%


	






	





#
cCs�t|d
�
}|}|j
|
|�}|dkrg|
jdk	rg|
j|�
}|j
|
|�}n|dkr�|
jr�t|�
d
r�|j|
|
j�
n|
jdj	|�
�

n|||dfS(NisNo such command '{}'.i
(
RR
R4R|R}RR�RZR�R5(R�RWRZREtoriginal_cmd_nameR'((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
s






c
Cs
t��
d
S(s{Given a context and a command name, this returns a
        :class:`Command` object if it exists or returns `None`.
        N(
R�(R�RWRE((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
&sc
CsgS(
sTReturns a list of subcommand names in the order they should
        appear.
        ((R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
,sN(RCR�R�R&RxR�RyR4R�R�R�R
R
R�R�R
R
R
(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR@-s$





		(			G		tGroupcBsMeZ
dZddd
�Zdd�
Zd�Zd�Zd�Zd�Z	RS(s�A group allows a command to have subcommands attached.  This is the
    most common way to implement nesting in Click.

    :param commands: a dictionary of commands.
    cKs&tj
||
|�
|pi|_dS(
N(R@R�R
(R�R R
R
((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�:s
cCsQ|p|
j}|dkr*td
�
�
nt|||
dt�

|
|j|<dS(s�Registers another :class:`Command` with this group.  If the name
        is not provided, the name of the command is used.
        sCommand has no name.RFN(R R4R�RHR&R
(R�R'R ((s)/tmp/pip-build-W6Gm0N/click/click/core.pytadd_command?s




c
s,d
dlm
�

��
��fd�}|S(s

A shortcut decorator for declaring and attaching a command to
        the group.  This takes the same arguments as :func:`command` but
        immediately registers the created command with this instance by
        calling into :meth:`add_command`.
        i
(
Rnc
s&�
���|�
}
�j|
�

|
S(
N(
R
(R�R'(RZRnR�R�(s)/tmp/pip-build-W6Gm0N/click/click/core.pyR

Qs



(t
decoratorsRn(R�RZR�R

((RZRnR�R�s)/tmp/pip-build-W6Gm0N/click/click/core.pyRnIsc
s,d
dlm
�

��
��fd�}|S(s�A shortcut decorator for declaring and attaching a group to
        the group.  This takes the same arguments as :func:`group` but
        immediately registers the created command with this instance by
        calling into :meth:`add_command`.
        i
(
tgroupc
s&�
���|�
}
�j|
�

|
S(
N(
R
(R�R'(RZR
R�R�(s)/tmp/pip-build-W6Gm0N/click/click/core.pyR

`s



(R
R
(R�RZR�R

((RZR
R�R�s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
XscCs|jj
|�
S(
N(R
R9(R�RWRE((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
gs
cCs
t|j
�
S(
N(RhR
(R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
js
N(
RCR�R�R4R�R
RnR
R
R
(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
3s
			tCommandCollectioncBs8eZ
dZddd
�Zd�Zd�Zd�ZRS(s
A command collection is a multi command that merges multiple multi
    commands together into one.  This is a straightforward implementation
    that accepts a list of different multi commands as sources and
    provides all the commands for each of them.
    cKs&tj
||
|�
|pg|_dS(
N(R@R�tsources(R�R R 
R
((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�us
cCs|jj
|
�

d
S(s1Adds a new multi command to the chain dispatcher.N(R 
R�(R�t	multi_cmd((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt
add_sourcezscCsVxO|jD]D}|j
|
|�}|dk	r
|jrJt|||�
n|Sq
WdS(
N(R 
R
R4R>RH(R�RWREtsourceR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
~s



	

cCs=t�}x'|j
D]}|j|j|
�
�

qWt|�
S(
N(R�R 
tupdateR
Rh(R�RWR�R#
((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
�s
	


N(RCR�R�R4R�R"
R
R
(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
ns
		t	ParametercBs�eZ
dZd
Zddeddddeeddd�Zd�Ze	d��
Z
d�Zd�Zd�Z
d�Zd	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�ZRS(s�	A parameter to a command comes in two versions: they are either
    :class:`Option`\s or :class:`Argument`\s.  Other subclasses are currently
    not supported by design as some of the internals for parsing are
    intentionally not finalized.

    Some settings are supported by both options and arguments.

    :param param_decls: the parameter declarations for this option or
                        argument.  This is a list of flags or argument
                        names.
    :param type: the type that should be used.  Either a :class:`ParamType`
                 or a Python type.  The later is converted into the former
                 automatically if supported.
    :param required: controls if this is optional or not.
    :param default: the default value if omitted.  This can also be a callable,
                    in which case it's invoked when the default is needed
                    without any arguments.
    :param callback: a callback that should be executed after the parameter
                     was matched.  This is called as ``fn(ctx, param,
                     value)`` and needs to return the value.
    :param nargs: the number of arguments to match.  If not ``1`` the return
                  value is a tuple instead of single value.  The default for
                  nargs is ``1`` (except if the type is a tuple, then it's
                  the arity of the tuple).
    :param metavar: how the value is represented in the help page.
    :param expose_value: if this is `True` then the value is passed onwards
                         to the command callback and stored on the context,
                         otherwise it's skipped.
    :param is_eager: eager values are processed before non eager ones.  This
                     should not be set for arguments or it will inverse the
                     order of processing.
    :param envvar: a string or list of strings that are environment variables
                   that should be checked.

    .. versionchanged:: 7.1
        Empty environment variables are ignored rather than taking the
        empty string value. This makes it possible for scripts to clear
        variables if they can't unset them.

    .. versionchanged:: 2.0
        Changed signature for parameter callback to also be passed the
        parameter. The old callback format will still work, but it will
        raise a warning to give you a chance to migrate the code easier.
    t	parametercCs�|j|
pd|�\|_
|_|_t||�|_|dkrl|jjrc|jj}qld
}n||_	||_
||_t|_
||_||_|	|_||_|
|_||_dS(Ni
((t_parse_declsR R�R�RttypeR4tis_compositetarityR
RVtnargsR�tmultipleR�tdefaultRbtmetavartenvvartautocompletion(R�tparam_declsR(
R
R-
RVR+
R.
R�RbR/
R0
((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s"
$

		
	
	
	
	
	
	
	
	
c

Csd
j|j
j|j�S(Ns<{} {}>(R5RBRCR (
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s
c


Cs|jS(
s�Returns the human readable name of this parameter.  This is the
        same as the name for options, but the metavar for arguments.
        (
R (
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pythuman_readable_name�sc
Csi|jdk	r|jS|jj|�
}
|
dkrI|jjj�}
n|jd
kre|
d7}
n|
S(Ni
s...(R.
R4R(
tget_metavarR R7R+
(R�R.
((s)/tmp/pip-build-W6Gm0N/click/click/core.pytmake_metavar�s








cCs7t|j
�
r|j
�}n	|j
}|j|
|�S(
s;Given a context variable this calculates the default value.(R�R-
ttype_cast_value(R�RWR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s
	
c
CsdS(
N((R�R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�s
cCsU|j|j
�
}|dkr0|j|
�
}n|dkrQ|
j|j
�
}n|S(
N(R9R R4tvalue_from_envvarR�(R�RWR�RY((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt
consume_values





cs��jj
r{�jd
k
r6tdj�j�
�
�
n�jrbt�
�fd�|pZdD�
�
S�j|pqd��
�S��
�fd���|�jd
kt�j�
�S(s�Given a value this runs it properly through the type system.
        This automatically handles things like `nargs` and `multiple` as
        well as composite types.
        i
s�Attempted to invoke composite type but nargs has been set to {}. This is not supported; nargs needs to be set to a fixed value > 1.c
3s*|] }
�
j|
pd
�
��V
qdS(N((
R(
(R
t
x(RWR�(s)/tmp/pip-build-W6Gm0N/click/click/core.pys	<genexpr>scsB�d
kr�j|���St
�
�fd�|p:dD�
�
S(Nic
3s"|]}
�|
�
d�V
qd
S(i
N((R
R8
(t_converttlevel(s)/tmp/pip-build-W6Gm0N/click/click/core.pys	<genexpr>s((R(
ttuple(RYR:
(R9
RWR�(
R:
s)/tmp/pip-build-W6Gm0N/click/click/core.pyR9
s


(((R(
R)
R+
R�R5R,
R;
tbool(R�RWRY((R9
RWR�s)/tmp/pip-build-W6Gm0N/click/click/core.pyR5
s


	
#
cCs |d
k	r|j
|
|�Sd
S(saGiven a value and context this runs the logic to convert the
        value as necessary.
        N(R4R5
(R�RWRY((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt
process_value"s
cCs<|
dkrt
S|jd
ks(|jr8|
dkr8t
StS(Ni
((R4R&R+
R,
R�(R�RY((s)/tmp/pip-build-W6Gm0N/click/click/core.pytvalue_is_missing-s



$

cCsn|j|
|�}|dkr:|
jr:|j|
�
}n|jrj|j|�
rjtd
|
d|��
n|S(NRWRX(R=
R4R}R�R
R>
R
(R�RWRY((s)/tmp/pip-build-W6Gm0N/click/click/core.pytfull_process_value4s


cCs�|jdkrdSt|jttf�rdx[|jD](}tjj|�
}|dk	r5|Sq5Wn%tjj|j�
}|d
kr�|SdS(NR�(R/
R4R?R;
RIR-R8R9(R�RWR/
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pytresolve_envvar_value?s







cCsC|j|
�
}|dk	r?|jd
kr?|jj|�
}n|S(Ni
(R@
R4R+
R(
tsplit_envvar_value(R�RWR�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR6
Ms



c	Cs�t|
d
|�

��
|j
|
|�}y|j|
|�}Wn&tk
rc


|
jsZ�nd}n
X|jdk	r�yt|j|
||�}Wq�tk
r�


|
js��q�q�XnWdQX|jr�||
j	|j
<n||fS(NRX(R]R7
R?
t	ExceptionR}R4RVR[R�RpR (R�RWR�RZRY((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�Ss"






	








	
	

c
CsdS(
N((R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�gs
c
CsgS(
N((R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�js
cCs,|jp|j
g
}d
jd�|D�
�
S(s{Get a stringified version of the param for use in error messages to
        indicate which param caused the error.
        s / c
ss|]}
t|
�
V
qdS(
N(
trepr(R
R8
((s)/tmp/pip-build-W6Gm0N/click/click/core.pys	<genexpr>rs(R�R2
R�(R�RWt	hint_list((s)/tmp/pip-build-W6Gm0N/click/click/core.pytget_error_hintms
N(RCR�R�tparam_type_nameR4R�R&R�R�R�R2
R4
R�R�R7
R5
R=
R>
R?
R@
R6
R�R�R�RE
(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR%
�s:,










		
													R�cBs�eZ
dZd
Zdeeeeddeeeddeeed�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d	�Zd
�ZRS(s�Options are usually optional values on the command line and
    have some extra features that arguments don't have.

    All other parameters are passed onwards to the parameter constructor.

    :param show_default: controls if the default value should be shown on the
                         help page. Normally, defaults are not shown. If this
                         value is a string, it shows the string instead of the
                         value. This is particularly useful for dynamic options.
    :param show_envvar: controls if an environment variable should be shown on
                        the help page.  Normally, environment variables
                        are not shown.
    :param prompt: if set to `True` or a non empty string then the user will be
                   prompted for input.  If set to `True` the prompt will be the
                   option name capitalized.
    :param confirmation_prompt: if set then the value will need to be confirmed
                                if it was prompted for.
    :param hide_input: if this is `True` then the input on the prompt will be
                       hidden from the user.  This is useful for password
                       input.
    :param is_flag: forces this option to act as a flag.  The default is
                    auto detection.
    :param flag_value: which value should be used for this flag if it's
                       enabled.  This is set to a boolean automatically if
                       the option string contains a slash to mark two options.
    :param multiple: if this is set to `True` then the argument is accepted
                     multiple times and recorded.  This is similar to ``nargs``
                     in how it works but supports arbitrary number of
                     arguments.
    :param count: this flag makes an option increment an integer.
    :param allow_from_autoenv: if this is enabled then the value of this
                               parameter will be pulled from an environment
                               variable in case a prefix is defined on the
                               context.
    :param help: the help string.
    :param hidden: hide this option from help outputs.
    toptioncKs�|jd
t
�t
k}tj||
d||�

|tkr[|jjdd�j�}n|tkrpd}n|}||_
||_||_|
|_
|dkr�|dk	r�t}q�t|j�
}n|r�|r�t|_n|dkr�|j}n||_||_|jrR
t|jt�rR
|dtgkrR
t|_t|_n	t|_|	|_|	r�
|dkr�
tdd�
|_n|r�
d|_q�
n||_|
|_||_||_||_||_|jdkr�
t d�
�
n|j
r|jr|jrt d�
�
n|jrA|jrAt d	�
�
n|jrq|jrq|j
dk	rqt d
�
�
n|jr�|jr�t d�
�
q�|jr�t d�
�
q�ndS(
NR-
R(
R2R�tminisOptions cannot have nargs < 0s+Cannot prompt for flags that are not bools.s*Got secondary option for non boolean flag.s5Hidden input does not work with boolean flag prompts.s6Options cannot be multiple and count at the same time.s3Options cannot be count and flags at the same time.(!R9t_missingR%
R�R&R R6t
capitalizeR�R4Rtconfirmation_promptt
hide_inputR�R<
R�R-
R�t
flag_valueR?RR(
tis_bool_flagtcountRR,
tallow_from_autoenvR�R�tshow_choicestshow_envvarR+
R�(R�R1
R�RRK
RL
R�RM
R,
RO
RP
R(
R�R�RQ
RR
R
tdefault_is_missingtprompt_text((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��sh



	
	
	
	
	

	





	
	
-
	
		




	
	
	
	
	
	





!

	
	

	

cCs�
g}g}d}g}x�|
D]�}t
|�
rU|dk	rLtd
�
�
n|}q|d dkrkdnd}||kr�|j|d�\}	}
|	j�}	|	r�|jt|	�
�

|j|	�

n|
j�}
|
r
|j|
j��

q
q|jt|�
�

|j|�

qW|dkrv
|rv
|jdd��

|ddj	dd	�j
�}t
|�
sv
d}qv
n|dkr�
|s�
d||fStd
�
�
n|r�
|r�
tdj|�
�
�
n|||fS(NsName defined twicei
t
/t
;Rgc

Sst|d
�
S(Ni(
R�(
R8
((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt<lambda>R�iR1R2s#Could not determine name for optionshNo options defined but a name was passed ({}). Did you mean to declare an argument instead of an option?(R4RR�R�R�R�RR�tsortR6tlowerR5(R�tdeclsR�R�R�R tpossible_namestdeclt
split_chartfirsttsecond((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR'
�sF








	











 








cCs
i|jd
6|j
d6|d6}|jr3d}n|jrEd}nd}|jr�|jdd�
dj|�
}|jr�|j	r�|
j
|jd|d	t|�

|
j
|j	d|d	t
|�

q
|
j
|jd|d	|j|�

n||d<|
j
|j|�

dS(
NtdestR+
RrR�RO
tstores{}_consttactiontconst(R R+
R,
RO
R�tpopR4R5RN
R�t
add_optionR�R&R�RM
(R�R�RWR�Rb
taction_const((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�!s(






	
	
	
		








csK�
jr
dSg���
fd
�}|�
j
�
g
}�
jrY|j|�
j�
�

n�
jped}g}�
jr
�
j}|dkr��
jr�|
j	dk	r�dj
|
j	�
jj��}q�n|dk	r
|jdj
t
|ttf�r
djd�|D�
�
n|�
�

q
n�
jdk	r�
�
js?
|
jr�
t
�
jt�rf
dj
�
j�
}n[t
�
jttf�r�
djd��
jD�
�
}n$tj�
j�
r�
d	}n	�
j}|jd
j
|�
�

n�
jr�
|jd�

n|r,dj
|rd
j
|�
nddj|�
�}n�r8dndj|�
|fS(Nc
sYt|�
\}
}|r%t
g
�(n�
jrU�
jrU|
d
j�
j��
7}
n|
S(Ns {}(RR&R�RO
R5R4
(R�R�tany_slashes(tany_prefix_is_slashR�(s)/tmp/pip-build-W6Gm0N/click/click/core.pyt_write_optsDs






R�s{}_{}senv var: {}s, c
ss|]}
t|
�
V
qdS(
N(
tstr(R
t
d((s)/tmp/pip-build-W6Gm0N/click/click/core.pys	<genexpr>Zss({})c
ss|]}
t|
�
V
qdS(
N(
Rj
(R
Rk
((s)/tmp/pip-build-W6Gm0N/click/click/core.pys	<genexpr>css	(dynamic)sdefault: {}R
s{}[{}]s{}  s; s / (R�R�R�R�R�RR
R/
R4RP
R~R5R R7R?RIR;
R�R-
R�Rtinspectt
isfunctionR
(R�RWRi
R�R�R�R/
tdefault_string((Rh
R�s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�?sD
	


	


	
	


$


.
!





		
	



-cCs`|jrP|j
rPx6|
jjD](}|j|jkr |jr |jSq WdStj	||
�S(
N(
R�RN
RnRpR R-
RM
R4R%
R�(R�RWRX((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�ss




csq�
j��
}�
j
r(t�
j|�St�
jd
|d�
jd�
jd�
jd�
jd��
fd��
S(s�This is an alternative flow that can be activated in the full
        value processing if a value does not exist.  It will prompt the
        user until a valid value exists and then returns the processed
        value as result.
        R-
R(
RL
RQ
RK
t
value_procc

s�
j�|�S(
N(
R=
(
R8
(RWR�(s)/tmp/pip-build-W6Gm0N/click/click/core.pyRW
�R�(R�RN
RRR(
RL
RQ
RK
(R�RWR-
((RWR�s)/tmp/pip-build-W6Gm0N/click/click/core.pytprompt_for_values	

	

	
	
	
	
cCsltj
||
�}|dk	r"|S|jrh|
jdk	rhd
j|
j|jj��}tj	j
|�
SdS(Ns{}_{}(R%
R@
R4RP
R~R5R R7R-R8R9(R�RWR�R/
((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR@
�s





cCs�|j|
�
}|dkrdS|jd
kt|j�
}|dkr�|dk	r�|jj|�
}|jr�|jd
kr�t||j�}q�n|S(Ni
i(R@
R4R+
R<
R,
R(
RA
RN(R�RWR�tvalue_depth((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR6
�s








cCsE|dkr2|j
dk	r2|
jr2|j|
�
Stj||
|�S(
N(R4RR}Rp
R%
R?
(R�RWRY((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR?
�s
%


N(RCR�R�RF
R4R�R&R�R'
R�R�R�Rp
R@
R6
R?
(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR�us2%













F	-		4				R
cBs\eZ
dZd
Zd	d�
Zed��
Zd�Zd�Z	d�Z
d�Zd�ZRS(
s�Arguments are positional parameters to a command.  They generally
    provide fewer features than options but can have infinite ``nargs``
    and are required by default.

    All parameters are passed onwards to the parameter constructor.
    targumentcKs�|dkrE|j
d
�
dk	r*t}qE|j
dd�dk}ntj||
d||�

|jdk	r�|jdkr�td�
�
ndS(NR-
R+
i
iR
s>nargs=-1 in combination with a default value is not supported.(R4R9R�R%
R�R-
R+
R�(R�R1
R
R
((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s


	



c

Cs#|jdk	r|jS|jj�S(
N(R.
R4R R7(
R�((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR2
�s

c
Cs{|jdk	r|jS|jj|�
}
|
s@|jj�}
n|js[d
j|
�
}
n|jdkrw|
d7}
n|
S(Ns[{}]i
s...(	R.
R4R(
R3
R R7R
R5R+
(R�tvar((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR4
�s





	




cCs�|
s(|sdggfSt
d
�
�
nt|
�
dkrc|
d}}|jdd�j�}nt
djt|
�
�
�
�
||g
gfS(Ns%Could not determine name for argumenti
iR1R2s8Arguments take exactly one parameter declaration, got {}(R4R�R�R6RY
R5(R�RZ
R�R targ((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR'
�s









c
Cs
|j�g
S(
N(
R4
(R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s
cCst|j
��
S(
N(RC
R4
(R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyRE
�s
cCs&|
jd
|j
d|jd|�
dS(NR`
R+
Rr(tadd_argumentR R+
(R�R�RW((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR��s
N(
RCR�R�RF
R4R�R�R2
R4
R'
R�RE
R�(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyR
�s				(IR�Rl
R-R)t
contextlibRt	functoolsR
t	itertoolsRt_compatRRRRt_unicodefunRRt
exceptionsR	R
RRR
Rt
formattingRRtglobalsRRR�RRttermuiRRRttypesRRRtutilsRRRRRtobjectRI
R
R�R�R%R(R0R4R:R�RHRNR[R]RjRkR�R�R@R
R
R%
R�R
(((s)/tmp/pip-build-W6Gm0N/click/click/core.pyt<module>
sz

































	

					
	�����;��<