HEX

File: //usr/local/CyberPanel/lib/python3.10/site-packages/click/__pycache__/core.cpython-310.pyc
o

��h_��@sddlmZddlmZddlZddlZddlZddlZddl	Z	ddl
ZddlmZddlm
Z
ddlmZddlmZddlmZddlmZdd	lmZdd
lmZddlmZddlmZd
dlmZd
dlmZd
dlmZd
dlmZd
dlm Z d
dlm!Z!d
dlm"Z"d
dlm#Z#d
dl$m%Z%d
dl$m&Z&d
dl'm(Z(d
dl'm)Z)d
dl*m+Z+d
dl*m,Z,d
dl*m-Z-d
dl.m/Z/d
dl.m0Z0d
dl.m1Z1d
d l2m3Z3d
d!l2m4Z4d
d"l2m5Z5d
d#l2m6Z6d
d$l2m7Z7d
d%l2m8Z8ej9r�d
d&l:m;Z;ej<d'd(d)�Z=e�<d*�Z>dmd1d2�Z?	3dndod<d=�Z@dpdCdD�ZAe	dqdrdHdI��ZBdsdNdO�ZCGdPdQ�dQejD�ZEGdRd,�d,�ZFGdSd8�d8�ZGGdTdU�dUeH�ZIGdVdW�dWeGeIdX�ZJGdYd5�d5eG�ZKGdZd[�d[eKeIdX�ZLGd\d]�d]eK�ZMdtdadb�ZNGdcdd�dd�ZOGdedf�dfeO�ZPGdgdh�dheO�ZQdudkdl�ZRdS)v�)�annotationsN)�abc)�Counter)�AbstractContextManager)�contextmanager)�	ExitStack)�update_wrapper)�gettext)�ngettext)�repeat)�
TracebackType�)�types��Abort)�BadParameter)�ClickException)�Exit)�MissingParameter)�NoArgsIsHelpError��
UsageError)�
HelpFormatter)�join_options)�pop_context)�push_context��_flag_needs_value)�
_OptionParser)�
_split_opt)�confirm)�prompt)�style)�_detect_program_name)�_expand_args)�echo)�make_default_short_help)�make_str)�PacifyFlushWrapper��CompletionItem�F�t.Callable[..., t.Any])�bound�V�ctx�Context�
incomplete�str�return�"cabc.Iterator[tuple[str, Command]]ccsR�t�t|j�}|�|�D]}|�|�r&|�||�}|dur&|js&||fVq
dS)z�List all the subcommands of a group that start with the
    incomplete value and aren't hidden.

    :param ctx: Invocation context for the group.
    :param incomplete: Value being completed. May be empty.
    N)�t�cast�Group�command�
list_commands�
startswith�get_command�hidden)r/r1�multi�namer8�r?�@/usr/local/CyberPanel/lib/python3.10/site-packages/click/core.py�_complete_visible_commands5s�	

��rAF�base_commandr7�cmd_name�cmd�Command�register�bool�NonecCsP|jrt|t�s
dS|rd|�d|j�d�}t|��d|�d|j�d�}t|��)Nz$It is not possible to add the group z to another group z that is in chain mode.zFound the group z! as subcommand to another group  z. that is in chain mode. This is not supported.)�chain�
isinstancer7r>�RuntimeError)rBrCrDrF�messager?r?r@�_check_nested_chainHs��
���rM�iterable�cabc.Iterable[V]�
batch_size�int�list[tuple[V, ...]]cCstttt|�|�ddi��S)N�strictF)�list�zipr�iter)rNrPr?r?r@�batch\�rW�param�Parameter | None�cabc.Iterator[None]c
csz�zdVWdSty(}z|jdur||_|dur#|jdur#||_�d}~wty<}z	|jdur7||_�d}~ww)z>Context manager that attaches extra information to exceptions.N)rr/rYr)r/rY�er?r?r@�augment_usage_errors`s �
�
��r]�invocation_order�cabc.Sequence[Parameter]�declaration_order�list[Parameter]csd	�fdd�}t||d�S)
aReturns all declared parameters in the order they should be processed.

    The declared parameters are re-shuffled depending on the order in which
    they were invoked, as well as the eagerness of each parameters.

    The invocation order takes precedence over the declaration order. I.e. the
    order in which the user provided them to the CLI is respected.

    This behavior and its effect on callback evaluation is detailed at:
    https://click.palletsprojects.com/en/stable/advanced/#callback-evaluation-order
    �item�	Parameterr3�tuple[bool, float]cs6z��|�}Wn
tytd�}Ynw|j|fS)N�inf)�index�
ValueError�float�is_eager)rb�idx�r^r?r@�sort_key�s�z,iter_params_for_processing.<locals>.sort_key��keyN)rbrcr3rd)�sorted)r^r`rlr?rkr@�iter_params_for_processingssrpc@s@eZdZdZe��Z	e��Z	e��Z	e��Z		e��Z
dS)�ParameterSourcea\This is an :class:`~enum.Enum` that indicates the source of a
    parameter's value.

    Use :meth:`click.Context.get_parameter_source` to get the
    source for a parameter by name.

    .. versionchanged:: 8.0
        Use :class:`~enum.Enum` and drop the ``validate`` method.

    .. versionchanged:: 8.0
        Added the ``PROMPT`` value.
    N)�__name__�
__module__�__qualname__�__doc__�enum�auto�COMMANDLINE�ENVIRONMENT�DEFAULT�DEFAULT_MAP�PROMPTr?r?r?r@rq�s
rqc@s�eZdZUdZeZded<															d�d�d"d#�Zed�d%d&��Z	d�d(d)�Z
d�d*d+�Zd�d2d3�Ze
d�d�d7d8��Zed�d9d:��Zd�d<d=�Zd�dAdB�Zd�dEdF�Zd�dGdH�Zed�dJdK��Zd�dLdM�Zd�dQdR�Zd�dSdT�Zej	4d�d�dXdY��Zej	Zd�d�d]dY��Zd�d�d^dY�Zd�dadb�Zd�dcdd�Zd�d�dhdi�Zd�djdk�Zd�dldm�Zd�dndo�Z ejd�dudv��Z!ejd�dwdv��Z!d�dzdv�Z!d�d|d}�Z"d�d�d��Z#d�d�d��Z$dS)�r0a�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.

    :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: Show the default value for commands. If this
        value is not set, it defaults to the value from the parent
        context. ``Command.show_default`` overrides this default for the
        specific command.

    .. versionchanged:: 8.2
        The ``protected_args`` attribute is deprecated and will be removed in
        Click 9.0. ``args`` will contain remaining unparsed tokens.

    .. versionchanged:: 8.1
        The ``show_default`` parameter is overridden by
        ``Command.show_default``, instead of the other way around.

    .. versionchanged:: 8.0
        The ``show_default`` parameter defaults to the value from the
        parent context.

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

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

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

    .. versionchanged:: 2.0
        Added the ``resilient_parsing``, ``help_option_names``, and
        ``token_normalize_func`` parameters.
    ztype[HelpFormatter]�formatter_classNFr8rE�parent�Context | None�	info_name�
str | None�obj�t.Any | None�auto_envvar_prefix�default_map�&cabc.MutableMapping[str, t.Any] | None�terminal_width�
int | None�max_content_width�resilient_parsingrG�allow_extra_args�bool | None�allow_interspersed_args�ignore_unknown_options�help_option_names�list[str] | None�token_normalize_func�t.Callable[[str], str] | None�color�show_defaultr3rHcCs||_||_||_i|_g|_g|_|rt|j�nt�|_|dur(|dur(|j}||_t	|di�|_
|durI|durI|durI|jdurI|j�|�}||_d|_
|durZ|durZ|j}||_|durh|durh|j}||_|
durr|j}
|
|_|dur||j}||_|dur�|j}||_|
dur�|dur�|j}
ndg}
|
|_|dur�|dur�|j}||_|	|_|dur�|dur�|jdur�|jdur�|j�d|j����}n|��}|dur�|�dd�}||_|dur�|dur�|j}||_|dur�|dur�|j}||_g|_d|_i|_t�|_dS)N�metaz--help�_�-r) r~r8r��params�args�_protected_args�set�
_opt_prefixesr��getattr�_metar��get�invoked_subcommandr�r�r�r�r�r�r�r�r��upper�replacer�r��_close_callbacks�_depth�_parameter_sourcer�_exit_stack)�selfr8r~r�r�r�r�r�r�r�r�r�r�r�r�r�r�r?r?r@�__init__s~



��zContext.__init__�	list[str]cCsddl}|jdtdd�|jS)Nrzo'protected_args' is deprecated and will be removed in Click 9.0. 'args' will contain remaining unparsed tokens.���
stacklevel)�warnings�warn�DeprecationWarningr�)r�r�r?r?r@�protected_args�s�zContext.protected_args�dict[str, t.Any]cCs$|j�|�|j|j|j|j|jd�S)a*Gather information that could be useful for a tool generating
        user-facing documentation. This traverses the entire CLI
        structure.

        .. code-block:: python

            with Context(cli) as ctx:
                info = ctx.to_info_dict()

        .. versionadded:: 8.0
        )r8r�r�r�r�r�)r8�to_info_dictr�r�r�r�r��r�r?r?r@r��s

�zContext.to_info_dictcCs|jd7_t|�|S�Nr
)r�rr�r?r?r@�	__enter__�szContext.__enter__�exc_type�type[BaseException] | None�	exc_value�BaseException | None�tb�TracebackType | NonecCs*|jd8_|jdkr|��t�dS�Nr
r)r��closer)r�r�r�r�r?r?r@�__exit__�s

zContext.__exit__T�cleanup�cabc.Iterator[Context]c	csp�|s
|jd7_z#|�}|VWd�n1swYW|s,|jd8_dSdS|s7|jd8_w)aIThis 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.
        r
N)r�)r�r��rvr?r?r@�scope�s����z
Context.scopecC�|jS)a�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
        )r�r�r?r?r@r�szContext.metarcCs|j|j|jd�S)a=Creates the :class:`~click.HelpFormatter` for the help and
        usage output.

        To quickly customize the formatter class used without overriding
        this method, set the :attr:`formatter_class` attribute.

        .. versionchanged:: 8.0
            Added the :attr:`formatter_class` attribute.
        )�width�	max_width)r}r�r�r�r?r?r@�make_formatter-s
�zContext.make_formatter�context_manager�AbstractContextManager[V]r.cC�|j�|�S)a�Register a resource as if it were used in a ``with``
        statement. The resource will be cleaned up when the context is
        popped.

        Uses :meth:`contextlib.ExitStack.enter_context`. It calls the
        resource's ``__enter__()`` method and returns the result. When
        the context is popped, it closes the stack, which calls the
        resource's ``__exit__()`` method.

        To register a cleanup function for something that isn't a
        context manager, use :meth:`call_on_close`. Or use something
        from :mod:`contextlib` to turn it into a context manager first.

        .. code-block:: python

            @click.group()
            @click.option("--name")
            @click.pass_context
            def cli(ctx):
                ctx.obj = ctx.with_resource(connect_db(name))

        :param context_manager: The context manager to enter.
        :return: Whatever ``context_manager.__enter__()`` returns.

        .. versionadded:: 8.0
        )r��
enter_context)r�r�r?r?r@�
with_resource;szContext.with_resource�fr,cCr�)a�Register a function to be called when the context tears down.

        This can be used to close resources opened during the script
        execution. Resources that support Python's context manager
        protocol which would be used in a ``with`` statement should be
        registered with :meth:`with_resource` instead.

        :param f: The function to execute on teardown.
        )r��callback)r�r�r?r?r@�
call_on_closeXs
zContext.call_on_closecCs|j��t�|_dS)z�Invoke all close callbacks registered with
        :meth:`call_on_close`, and exit all context managers entered
        with :meth:`with_resource`.
        N)r�r�rr�r?r?r@r�ds
z
Context.closer2cCsvd}|jdur
|j}|jdur7|jjg}t|jjt�r-|jj�|�D]
}|�|�|��q"d�	|��d|��}|�
�S)z�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.
        �N� )r�r~�command_pathrJr8rE�
get_params�extend�get_usage_pieces�join�lstrip)r�r��parent_command_pathrYr?r?r@r�ms


zContext.command_pathcCs"|}|jdur|j}|jdus|S)zFinds the outermost context.N�r~)r��noder?r?r@�	find_root�s


�zContext.find_root�object_type�type[V]�V | NonecCs0|}|durt|j|�r|jS|j}|dusdS)z)Finds the closest object of a given type.N)rJr�r~)r�r�r�r?r?r@�find_object�s�zContext.find_objectcCs"|�|�}|dur|�|_}|S)z�Like :meth:`find_object` but sets the innermost object to a
        new instance of `object_type` if it does not exist.
        N)r�r�)r�r�r�r?r?r@�
ensure_object�s
zContext.ensure_objectr>�call�t.Literal[True]cC�dS�Nr?�r�r>r�r?r?r@�lookup_default��zContext.lookup_default.�t.Literal[False]�$t.Any | t.Callable[[], t.Any] | NonecCr�r�r?r�r?r?r@r��r�cCs0|jdur|j�|�}|rt|�r|�S|SdS)a*Get the default for a parameter from :attr:`default_map`.

        :param name: Name of the parameter.
        :param call: If the default is a callable, call it. Disable to
            return the callable instead.

        .. versionchanged:: 8.0
            Added the ``call`` parameter.
        N)r�r��callable)r�r>r��valuer?r?r@r��s

rL�
t.NoReturncCs
t||��)z�Aborts the execution of the program with a specific error
        message.

        :param message: the error message to fail with.
        r)r�rLr?r?r@�fail�s
zContext.failcC�t��)zAborts the script.rr�r?r?r@�abort�sz
Context.abortr�coderQcCs|��t|��)z�Exits the application with a given exit code.

        .. versionchanged:: 8.2
            Callbacks and context managers registered with :meth:`call_on_close`
            and :meth:`with_resource` are closed before exiting.
        )r�r)r�r�r?r?r@�exit�szContext.exitcC�|j�|�S)zaHelper method to get formatted usage string for the current
        context and command.
        )r8�	get_usager�r?r?r@r���zContext.get_usagecCr�)z^Helper method to get formatted help page for the current
        context and command.
        )r8�get_helpr�r?r?r@r��r�zContext.get_helpcCst|�||j|d�S)zvCreate a new context of the same type as this context, but
        for a new command.

        :meta private:
        �r�r~)�typer>)r�r8r?r?r@�_make_sub_context�szContext._make_sub_contextr��t.Callable[..., V]r��t.Any�kwargscOr�r�r?�r�r�r�r�r?r?r@�invoke�r�zContext.invokecOr�r�r?r�r?r?r@r����Command | t.Callable[..., V]�	t.Any | Vc	Os�t|t�r=|}|jdurtd��t�d|j�}|�|�}|jD]}|j|vr5|j	r5|�
||�|��||j<q|j�|�n|}t
|��)|�||i|��Wd�Wd�S1s_wYWd�dS1sowYdS)a-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.

        .. versionchanged:: 8.0
            All ``kwargs`` are tracked in :attr:`params` so they will be
            passed if :meth:`forward` is called at multiple levels.

        .. versionchanged:: 3.2
            A new context is created, and missing arguments use default values.
        Nz?The given command does not have a callback that can be invoked.r�)rJrEr��	TypeErrorr5r6r�r�r>�expose_value�type_cast_value�get_default�updater])r�r�r�r��	other_cmdr/rYr?r?r@r��s.

�



��
��"�rDcOsLt|t�s	td��|jD]
}||vr|j|||<q|j|g|�Ri|��S)azSimilar 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.

        .. versionchanged:: 8.0
            All ``kwargs`` are tracked in :attr:`params` so they will be
            passed if ``forward`` is called at multiple levels.
        zCallback is not a command.)rJrErr�r�)r�rDr�r�rYr?r?r@�forwards


�zContext.forward�sourcerqcCs||j|<dS)z�Set the source of a parameter. This indicates the location
        from which the value of the parameter was obtained.

        :param name: The name of the parameter.
        :param source: A member of :class:`~click.core.ParameterSource`.
        N)r�)r�r>rr?r?r@�set_parameter_source/szContext.set_parameter_source�ParameterSource | NonecCr�)aXGet the source of a parameter. This indicates the location
        from which the value of the parameter was obtained.

        This can be useful for determining when a user specified a value
        on the command line that is the same as the default value. It
        will be :attr:`~click.core.ParameterSource.DEFAULT` only if the
        value was actually taken from the default.

        :param name: The name of the parameter.
        :rtype: ParameterSource

        .. versionchanged:: 8.0
            Returns ``None`` if the parameter was not provided from any
            source.
        )r�r�)r�r>r?r?r@�get_parameter_source8szContext.get_parameter_source)NNNNNNNFNNNNNNN)"r8rEr~rr�r�r�r�r�r�r�r�r�r�r�r�r�rGr�r�r�r�r�r�r�r�r�r�r�r�r�r�r3rH)r3r��r3r�)r3r0)r�r�r�r�r�r�r3rH�T)r�rGr3r�)r3r)r�r�r3r.)r�r,r3r,)r3rH�r3r2)r�r�r3r�)r�r�r3r.)r>r2r�r�r3r��.)r>r2r�r�r3r�)r>r2r�rGr3r�)rLr2r3r�)r3r�)r)r�rQr3r�)r8rEr3r0)r�r�r�r�r�r�r3r.)r�rEr�r�r�r�r3r�)r�r�r�r�r�r�r3r�)rDrEr�r�r�r�r3r�)r>r2rrqr3rH)r>r2r3r	)%rrrsrtrurr}�__annotations__r��propertyr�r�r�r�rr�r�r�r�r�r�r�r�r�r�r5�overloadr�r�r�r�r�r�r�r�rrr
r?r?r?r@r0�sv
e�+


%



	


	��







0
	c@sreZdZUdZeZded<dZdZdZ												dldmdd�Z
dnd!d"�Zdod$d%�Zdpd&d'�Z
dqd)d*�Zdrd-d.�Zdsd0d1�Zdsd2d3�Zdtd5d6�Zdud8d9�Zdpd:d;�Zdvdwd?d@�ZdrdAdB�ZdrdCdD�ZdrdEdF�ZdrdGdH�Z	dxdydOdP�ZdzdQdR�Zd{dSdT�Zd|dWdX�Zej				d}d~d_d`��Z ej				add�dbd`��Z 					d�d�ddd`�Z 	dxd�dgdh�Z!d�djdk�Z"dS)�rEag	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.

    :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: If ``True`` or non-empty string, issues a message
                        indicating that the command is deprecated and highlights
                        its deprecation in --help. The message can be customized
                        by using a string as the value.

    .. versionchanged:: 8.2
        This is the base class for all commands, not ``BaseCommand``.
        ``deprecated`` can be set to a string as well to customize the
        deprecation message.

    .. versionchanged:: 8.1
        ``help``, ``epilog``, and ``short_help`` are stored unprocessed,
        all formatting is done when outputting help text, not at init,
        and is done even if not using the ``@command`` decorator.

    .. versionchanged:: 8.0
        Added a ``repr`` showing the command name.

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

    .. versionchanged:: 2.0
        Added the ``context_settings`` parameter.
    z
type[Context]�
context_classFTN�	[OPTIONS]r>r��context_settingsr�r��t.Callable[..., t.Any] | Noner��list[Parameter] | None�help�epilog�
short_help�options_metavar�add_help_optionrG�no_args_is_helpr<�
deprecated�
bool | strr3rHc

Csb||_|dur	i}||_||_|pg|_||_||_||_||_|	|_d|_	|
|_
||_||_dSr�)
r>rr�r�rrrrr�_help_optionrr<r)
r�r>rr�r�rrrrrrr<rr?r?r@r��s

zCommand.__init__r/r0r�cCs0|jdd�|�|�D�|j|j|j|j|jd�S)NcSsg|]}|���qSr?)r�)�.0rYr?r?r@�
<listcomp>��z(Command.to_info_dict.<locals>.<listcomp>)r>r�rrrr<r)r>r�rrrr<r�r�r/r?r?r@r��s�zCommand.to_info_dictr2cC�d|jj�d|j�d�S�N�<r��>��	__class__rrr>r�r?r?r@�__repr__��zCommand.__repr__cC�"|��}|�||�|���d�S)zmFormats the usage line into a string and returns it.

        Calls :meth:`format_usage` internally.
        �
)r��format_usage�getvalue�rstrip�r�r/�	formatterr?r?r@r���zCommand.get_usagerac	Csz|j}|�|�}|durg|�|�}	ddl}dd�|D�}t|�}dd�|��D�}|D]
}|jd|�d�d	d
�q-|S)NTrcSsg|]
}|jD]}|�qqSr?)�opts)r rY�optr?r?r@r!�sz&Command.get_params.<locals>.<listcomp>css �|]\}}|dkr|VqdS)r
Nr?)r r5�countr?r?r@�	<genexpr>�s�z%Command.get_params.<locals>.<genexpr>zThe parameter zM is used more than once. Remove its duplicate as parameters should be unique.�r�)r��get_help_optionr�r�itemsr�)	r�r/r��help_optionr�r4�opts_counter�duplicate_opts�
duplicate_optr?r?r@r��s

�zCommand.get_paramsr2rcCs"|�|�}|�|jd�|��dS)zsWrites the usage line into the formatter.

        This is a low-level method called by :meth:`get_usage`.
        r�N)�collect_usage_pieces�write_usager�r�)r�r/r2�piecesr?r?r@r.�s
zCommand.format_usager�cCs6|jr|jgng}|�|�D]
}|�|�|��q|S)zhReturns all the pieces that go into the usage line and returns
        it as a list of strings.
        )rr�r�r�)r�r/r�rYr?r?r@r?�szCommand.collect_usage_piecescCs6t|j�}|jD]}|�|j�|�|j�qt|�S)z&Returns the names for the help option.)r�r�r��difference_updater4�secondary_optsrT)r�r/�	all_namesrYr?r?r@�get_help_option_names�s


zCommand.get_help_option_names�
Option | NonecCsL|�|�}|r
|jsdS|jdur#ddlm}||�|�|j��|_|jS)z�Returns the help option object.

        Skipped if :attr:`add_help_option` is ``False``.

        .. versionchanged:: 8.1.8
            The help option is now cached to avoid creating it multiple times.
        Nr
)r;)rErr�
decoratorsr;r��pop)r�r/r�r;r?r?r@r9s


zCommand.get_help_optionrcCs(t|�}|�|�D]}|�||�q	|S)z6Creates the underlying option parser for this command.)rr��
add_to_parser)r�r/�parserrYr?r?r@�make_parserszCommand.make_parsercCr,)zfFormats the help into a string and returns it.

        Calls :meth:`format_help` internally.
        r-)r��format_helpr/r0r1r?r?r@r�"r3zCommand.get_help�-�limitrQcCsj|jr
t�|j�}n|jrt|j|�}nd}|jr1t|jt�r&d|j�d�nd}td�j	||d�}|�
�S)z`Gets short help for the command or makes it by shortening the
        long help string.
        r��
(DEPRECATED: �)�(DEPRECATED)�{text} {deprecated_message}��text�deprecated_message)r�inspect�cleandocrr&rrJr2r��format�strip)r�rNrTrUr?r?r@�get_short_help_str+s
���zCommand.get_short_help_strcCs4|�||�|�||�|�||�|�||�dS)a0Writes 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.�format_help_text�format_options�
format_epilogr1r?r?r@rLBszCommand.format_helpcCs�|jdurt�|j��d�d}nd}|jr.t|jt�r#d|j�d�nd}td�j||d	�}|rP|�	�|�
��|�|�Wd�dS1sIwYdSdS)
z3Writes the help text to the formatter if it exists.N�rr�rOrPrQrRrS)rrVrW�	partitionrrJr2r�rX�write_paragraph�indentation�
write_text)r�r/r2rTrUr?r?r@r[Ss"

���
"��zCommand.format_help_textcCsvg}|�|�D]}|�|�}|dur|�|�q|r9|�td���|�|�Wd�dS1s2wYdSdS)z8Writes all the options into the formatter if they exist.N�Options)r��get_help_record�append�sectionr��write_dl)r�r/r2r4rYr�r?r?r@r\ks

�"��zCommand.format_optionscCsV|jr)t�|j�}|��|���|�|�Wd�dS1s"wYdSdS)z2Writes the epilog into the formatter if it exists.N)rrVrWr`rarb)r�r/r2rr?r?r@r]ws
"��zCommand.format_epilogr�r�r~r�extrar�cKsz|j��D]\}}||vr|||<q|j|f||d�|��}|jdd��|�||�Wd�|S1s6wY|S)a�This 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.

        To quickly customize the context class used without overriding
        this method, set the :attr:`context_class` attribute.

        :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's usually
                          the name of the script, for commands below it's
                          the name of the command.
        :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.

        .. versionchanged:: 8.0
            Added the :attr:`context_class` attribute.
        r�F�r�N)rr:rr��
parse_args)r�r�r�r~rhrnr�r/r?r?r@�make_context�s�
��zCommand.make_contextcCs�|s|jr|jst|��|�|�}|j|d�\}}}t||�|��D]}|�|||�\}}q"|rK|jsK|jsK|�	t
ddt|��jd�
tt|��d��||_|j�|j�|S)N)r�z&Got unexpected extra argument ({args})z'Got unexpected extra arguments ({args})r�)rr�rrKrjrpr��handle_parse_resultr�r�r
�lenrXr��mapr2r�r�r)r�r/r�rJr4�param_orderrYr�r?r?r@rj�s&
���zCommand.parse_argscCsn|jr%t|jt�rd|j��nd}td�j|j|d�}tt|dd�dd�|jd	ur5|j	|jfi|j
��Sd	S)
zeGiven a context, this invokes the attached callback (if it exists)
        in the right way.
        r�r�zFDeprecationWarning: The command {name!r} is deprecated.{extra_message})r>�
extra_message�red��fgT��errN)rrJr2r�rXr>r%r"r�r�r�)r�r/rprLr?r?r@r��s���
�zCommand.invoker1�list[CompletionItem]cs�ddlm�g}�rA�d��sA|���D]+�t�t�r+�js+�js,���j	�t
jur,q|����fdd�g�j
��j�D��q�jdurh�j�t�jt�rc�jjrc|���fdd�t���D���jdusF|S)a�Return a list of completions for the incomplete value. Looks
        at the names of options and chained multi-commands.

        Any command could be part of a chained multi-command, so sibling
        commands are valid at any point during command completion.

        :param ctx: Invocation context for this command.
        :param incomplete: Value being completed. May be empty.

        .. versionadded:: 8.0
        rr)c3s(�|]}|���r�|�jd�VqdS��rN)r:r)r r>)r*r1rYr?r@r7�s��
�z)Command.shell_complete.<locals>.<genexpr>Nc3s.�|]\}}|�jvr�||��d�VqdSrw)r�rZ�r r>r8)r*r/r?r@r7�s�
��)�click.shell_completionr*�isalnumr�rJ�Optionr<�multipler
r>rqrxr�r4rCr~r8r7rIrA�r�r/r1�resultsr?)r*r/r1rYr@�shell_complete�s2���
�
�
�
�
zCommand.shell_complete�cabc.Sequence[str] | None�	prog_name�complete_var�standalone_moder�r�cKr�r�r?�r�r�r�r�r�rhr?r?r@�main��zCommand.main.cKr�r�r?r�r?r?r@r�r��windows_expand_argsc

Ks"|durtjdd�}tjdkr|rt|�}nt|�}|dur"t�}|�|||�z�z8|j||fi|���}|�	|�}|sH|Wd�WWS|�
�Wd�n1sVwYWWdSWWdSttfyz}	z
t
tjd�t�|	�d}	~	wty�}	z|s��|	��t�
|	j�WYd}	~	WdSd}	~	wty�}	z+|	jtjkr�t�tjttj��t_t�tjttj��t_t�
d�n�WYd}	~	WdSd}	~	wwty�}	z|r�t�
|	j�n	|	jWYd}	~	SWYd}	~	dSd}	~	wt�y|s��t
td�tjd�t�
d�YdSw)a�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``
        needs to be caught.

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

        :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 windows_expand_args: Expand glob patterns, user dir, and
            env vars in command line args on Windows.
        :param extra: extra keyword arguments are forwarded to the context
                      constructor.  See :class:`Context` for more information.

        .. versionchanged:: 8.0.1
            Added the ``windows_expand_args`` parameter to allow
            disabling command line arg expansion on Windows.

        .. versionchanged:: 8.0
            When taking arguments from ``sys.argv`` on Windows, glob
            patterns, user dir, and env vars are expanded.

        .. versionchanged:: 3.0
           Added the ``standalone_mode`` parameter.
        Nr
�nt)�filezAborted!)�sys�argv�osr>r$rTr#�_main_shell_completionrkr�r��EOFError�KeyboardInterruptr%�stderrrr�show�	exit_code�OSError�errno�EPIPEr5r6�TextIOr(�stdoutrr�)
r�r�r�r�r�r�rhr/r�r\r?r?r@r�sb3�
�
,������
����ctx_args�cabc.MutableMapping[str, t.Any]cCsj|dur|�dd��dd�}d|�d���}tj�|�}|s dSddlm}||||||�}t�|�dS)a�Check if the shell is asking for tab completion, process
        that, then exit early. Called from :meth:`main` before the
        program is invoked.

        :param prog_name: Name of the executable in the shell.
        :param complete_var: Name of the environment variable that holds
            the completion instruction. Defaults to
            ``_{PROG_NAME}_COMPLETE``.

        .. versionchanged:: 8.2.0
            Dots (``.``) in ``prog_name`` are replaced with underscores (``_``).
        Nr�r��.�	_COMPLETEr
)r�)	r�r�r��environr��shell_completionr�r�r�)r�r�r�r��
complete_name�instructionr�r�r?r?r@r��szCommand._main_shell_completionr�cOs|j|i|��S)zAlias for :meth:`main`.)r��r�r�r�r?r?r@�__call__��zCommand.__call__)NNNNNNrTFFF)r>r�rr�r�rr�rrr�rr�rr�rr�rrGrrGr<rGrrr3rH�r/r0r3r�r
�r/r0r3r2)r/r0r3ra�r/r0r2rr3rH�r/r0r3r�)r/r0r3rF)r/r0r3r)rM)rNrQr3r2r�)
r�r�r�r�r~rrhr�r3r0�r/r0r�r�r3r��r/r0r3r��r/r0r1r2r3rv)NNNT)r�r�r�r�r�r�r�r�rhr�r3r�)NNN.)r�r�r�r�r�r�r�rGrhr�r3r�)NNNTT)r�r�r�r�r�r�r�rGr�rGrhr�r3r�)r�r�r�r2r�r�r3rH)r�r�r�r�r3r�)#rrrsrtrur0rrr�r�r�r�r�r*r�r�r.r?rEr9rKr�rZrLr[r\r]rkrjr�r�r5rr�r�r�r?r?r?r@rEKsv
2�
,


	





	




�
%

/�	��u� c@s eZdZddd�Zd
d	d
�ZdS)�_FakeSubclassCheck�subclassr�r3rGcC�t||jd�S�Nr)�
issubclass�	__bases__)�clsr�r?r?r@�__subclasscheck__��z$_FakeSubclassCheck.__subclasscheck__�instancer�cCr�r�)rJr�)r�r�r?r?r@�__instancecheck__�r�z$_FakeSubclassCheck.__instancecheck__N)r�r�r3rG)r�r�r3rG)rrrsrtr�r�r?r?r?r@r��s
r�c@�eZdZdZdS)�_BaseCommandz\
    .. deprecated:: 8.2
        Will be removed in Click 9.0. Use ``Command`` instead.
    N�rrrsrtrur?r?r?r@r���r�)�	metaclasscs<eZdZUdZdZdZdZded<dZded<							dRdS�fdd�
Z	dT�fdd�Z
dUdVd"d#�Zej
dWd&d'��Zej
dXd*d'��ZdYd,d'�Zej
dZd-d.��Zej
d[d0d.��Zd\d2d.�Zd]d^d5d6�Zd_d:d;�Zd`d=d>�Zd`�fd?d@�Zda�fdCdD�ZdadEdF�Zdb�fdGdH�Zdc�fdIdJ�ZdddLdM�Zde�fdPdQ�Z�ZS)fr7a�A group is a command that nests other commands (or more groups).

    :param name: The name of the group command.
    :param commands: Map names to :class:`Command` objects. Can be a list, which
        will use :attr:`Command.name` as the keys.
    :param invoke_without_command: Invoke the group's callback even if a
        subcommand is not given.
    :param no_args_is_help: If no arguments are given, show the group's help and
        exit. Defaults to the opposite of ``invoke_without_command``.
    :param subcommand_metavar: How to represent the subcommand argument in help.
        The default will represent whether ``chain`` is set or not.
    :param chain: Allow passing more than one subcommand argument. After parsing
        a command's arguments, if any arguments remain another command will be
        matched, and so on.
    :param result_callback: A function to call after the group's and
        subcommand's callbacks. The value returned by the subcommand is passed.
        If ``chain`` is enabled, the value will be a list of values returned by
        all the commands. If ``invoke_without_command`` is enabled, the value
        will be the value returned by the group's callback, or an empty list if
        ``chain`` is enabled.
    :param kwargs: Other arguments passed to :class:`Command`.

    .. versionchanged:: 8.0
        The ``commands`` argument can be a list of command objects.

    .. versionchanged:: 8.2
        Merged with and replaces the ``MultiCommand`` base class.
    TFNztype[Command] | None�
command_classztype[Group] | type[type] | None�group_classr>r��commands�Acabc.MutableMapping[str, Command] | cabc.Sequence[Command] | None�invoke_without_commandrGrr��subcommand_metavarrI�result_callbackrr�r�r3rHc
s�t�j|fi|��|duri}n
t|tj�rdd�|D�}||_|dur(|}||_||_|dur9|r7d}nd}||_||_	||_
|j	rW|jD]}	t|	t�rV|	j
sVtd��qHdSdS)NcSsi|]}|jdur|j|�qSr��r>�r �cr?r?r@�
<dictcomp>��z"Group.__init__.<locals>.<dictcomp>z*COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...zCOMMAND [ARGS]...z5A group in chain mode cannot have optional arguments.)�superr�rJr�Sequencer�rr�r�rI�_result_callbackr��Argument�requiredrK)
r�r>r�r�rr�rIr�r�rY�r)r?r@r��s4

���zGroup.__init__r/r0r�c	s�t��|�}i}|�|�D]/}|�||�}|durq
|�|�}|jdd��|�|�||<Wd�n1s7wYq
|j||jd�|S)NFri)r�rI)r�r�r9r;r�r�rrI)r�r/�	info_dictr�r>r8�sub_ctxr�r?r@r�s
��zGroup.to_info_dictrDrEcCs8|p|j}|dur
td��t|||dd�||j|<dS)z�Registers another :class:`Command` with this group.  If the name
        is not provided, the name of the command is used.
        NzCommand has no name.T)rF)r>rrMr�)r�rDr>r?r?r@�add_command+s

zGroup.add_command�_Group__funcr,cCr�r�r?�r�r�r?r?r@r85r�z
Group.commandr��-t.Callable[[t.Callable[..., t.Any]], Command]cOr�r�r?r�r?r?r@r88r��7t.Callable[[t.Callable[..., t.Any]], Command] | Commandcs�ddlm�d}�r!t�d�r!t��dkr�rJd���\}d��jr0��d�dur0�j�d<d����fdd
�}|durB||�S|S)aA shortcut decorator for declaring and attaching a command to
        the group. This takes the same arguments as :func:`command` and
        immediately registers the created command with this group by
        calling :meth:`add_command`.

        To customize the command class used, set the
        :attr:`command_class` attribute.

        .. versionchanged:: 8.1
            This decorator can be applied without parentheses.

        .. versionchanged:: 8.0
            Added the :attr:`command_class` attribute.
        r
)r8Nrz7Use 'command(**kwargs)(callable)' to provide arguments.r?r�r�r,r3rEc� ��i���|�}��|�|Sr��r��r�rD�r�r8r�r�r?r@�	decorator\�
z Group.command.<locals>.decorator)r�r,r3rE)rGr8r�rmr�r��r�r�r��funcr�r?r�r@r8=s�
cCr�r�r?r�r?r?r@�groupfr�zGroup.group�+t.Callable[[t.Callable[..., t.Any]], Group]cOr�r�r?r�r?r?r@r�ir��3t.Callable[[t.Callable[..., t.Any]], Group] | Groupcs�ddlm�d}�r!t�d�r!t��dkr�rJd���\}d��jdur>��d�dur>�jtur9t���d<n�j�d<d����fdd
�}|durP||�S|S)aA shortcut decorator for declaring and attaching a group to
        the group. This takes the same arguments as :func:`group` and
        immediately registers the created group with this group by
        calling :meth:`add_command`.

        To customize the group class used, set the :attr:`group_class`
        attribute.

        .. versionchanged:: 8.1
            This decorator can be applied without parentheses.

        .. versionchanged:: 8.0
            Added the :attr:`group_class` attribute.
        r
)r�Nrz5Use 'group(**kwargs)(callable)' to provide arguments.r?r�r�r,r3r7cr�r�r�r��r�r�r�r�r?r@r��r�zGroup.group.<locals>.decorator)r�r,r3r7)rGr�r�rmr�r�r�r�r?r�r@r�ns �

r��t.Callable[[F], F]csd��fdd�}|S)a�Adds a result callback to the 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.result_callback()
            def process_result(result, input):
                return result + input

        :param replace: if set to `True` an already existing result
                        callback will be removed.

        .. versionchanged:: 8.0
            Renamed from ``resultcallback``.

        .. versionadded:: 3.0
        r�r+r3csH�j��dus	�r��_�Sd��fdd�}tt�t|����_}|S)	Nr�r�r�r�r3cs,�|g|�Ri|��}�|g|�Ri|��Sr�r?)r�r�r��inner�r��old_callbackr?r@�function�sz:Group.result_callback.<locals>.decorator.<locals>.function)r�r�r�r�r�r�r3r�)r�rr5r6r+)r�r�r��r�r�r�r@r��sz(Group.result_callback.<locals>.decoratorN)r�r+r3r+r?)r�r�r�r?r�r@r��szGroup.result_callbackrCr2�Command | NonecCs|j�|�S)z}Given a context and a command name, this returns a :class:`Command`
        object if it exists or returns ``None``.
        )r�r�)r�r/rCr?r?r@r;�r�zGroup.get_commandr�cCs
t|j�S)zCReturns a list of subcommand names in the order they should appear.)ror�r#r?r?r@r9�s
zGroup.list_commandscst��|�}|�|j�|Sr�)r�r?rer��r�r/r�r�r?r@r?�szGroup.collect_usage_piecesr2rcst��||�|�||�dSr�)r�r\�format_commandsr1r�r?r@r\�szGroup.format_optionsc	Cs�g}|�|�D]}|�||�}|durq|jrq|�||f�qt|�rh|jdtdd�|D��}g}|D]\}}|�|�}|�||f�q6|rj|�t	d���|�
|�Wd�dS1sawYdSdSdS)zeExtra format methods for multi methods that adds all the commands
        after the options.
        N�css�|]	}t|d�VqdS)rN�rm)r rDr?r?r@r7���z(Group.format_commands.<locals>.<genexpr>�Commands)r9r;r<rermr��maxrZrfr�rg)	r�r/r2r��
subcommandrDrN�rowsrr?r?r@r��s(
"��zGroup.format_commandscsf|s|jr|jst|��t��||�}|jr||_g|_|jS|r0|dd�|dd�|_|_|jSr�)rr�rr�rjrIr�r�)r�r/r��restr�r?r@rj�s�zGroup.parse_argsc	
sd��fdd�}�js6�jr/��t����}|�jrgn|�Wd�S1s*wY��td��g�j��j�}g�_g�_�js���I���|�\}}}|dusYJ�|�_	t����|j
||�d�}|�||j�|��Wd�Wd�S1s�wYWd�n1s�wY��f|r�dnd�_	t����g}|rՈ��|�\}}}|dus�J�|j
||�d	d
d�}|�|�|jg}|_|s�g}|D]}|�|�|j�|��Wd�n1s�wYq�||�Wd�S1�swYdS)
Nr�r�r3cs&�jdur�j�j|fi�j��}|Sr�)r�r�r��r��r/r�r?r@�_process_results
z%Group.invoke.<locals>._process_resultzMissing command.r��*TF)r~r�r��r�r�r3r�)
r�r�r�r�rIr�r�r��resolve_commandr�rkr8re)	r�r/r�r�r�rCrDr��contextsr�r�r@r�sb �����
�
��&�zGroup.invoke�,tuple[str | None, Command | None, list[str]]cCs�t|d�}|}|�||�}|dur"|jdur"|�|�}|�||�}|dur@|js@t|�dr5|�||�|�td�j|d��|rD|nd||dd�fS)NrzNo such command {name!r}.r�r
)	r'r;r�r�rrjr�r�rX)r�r/r�rC�original_cmd_namerDr?r?r@r�Hs
zGroup.resolve_commandr1rvcs<ddlm��fdd�t||�D�}|�t��||��|S)a0Return a list of completions for the incomplete value. Looks
        at the names of options, subcommands, and chained
        multi-commands.

        :param ctx: Invocation context for this command.
        :param incomplete: Value being completed. May be empty.

        .. versionadded:: 8.0
        rr)cs g|]\}}�||��d��qS)rx)rZryr)r?r@r!os��z(Group.shell_complete.<locals>.<listcomp>)rzr*rAr�r�r�r~r�r)r@r�cs

�zGroup.shell_complete)NNFNNFN)r>r�r�r�r�rGrr�r�r�rIrGr�rr�r�r3rHr�r�)rDrEr>r�r3rH)r�r,r3rE)r�r�r�r�r3r�)r�r�r�r�r3r�)r�r,r3r7)r�r�r�r�r3r�)r�r�r�r�r3r��F)r�rGr3r��r/r0rCr2r3r�r�r�r�r�)r/r0r�r�r3r�r�)rrrsrtrur�r�r�rr�r�r�r�r5rr8r�r�r;r9r?r\r�rjr�r�r��
__classcell__r?r?r�r@r7�sH
�0

)
,
-


Dc@r�)�
_MultiCommandzZ
    .. deprecated:: 8.2
        Will be removed in Click 9.0. Use ``Group`` instead.
    Nr�r?r?r?r@r�wr�r�csNeZdZdZ		dd�fdd�
Zddd�Zd�fdd�Zd�fdd�Z�ZS) �CommandCollectiona�A :class:`Group` that looks up subcommands on other groups. If a command
    is not found on this group, each registered source is checked in order.
    Parameters on a source are not added to this group, and a source's callback
    is not invoked when invoking its commands. In other words, this "flattens"
    commands in many groups into this one group.

    :param name: The name of the group command.
    :param sources: A list of :class:`Group` objects to look up commands from.
    :param kwargs: Other arguments passed to :class:`Group`.

    .. versionchanged:: 8.2
        This is a subclass of ``Group``. Commands are looked up first on this
        group, then each of its sources.
    Nr>r��sources�list[Group] | Noner�r�r3rHcs"t�j|fi|��|p
g|_dSr�)r�r�r�)r�r>r�r�r�r?r@r��szCommandCollection.__init__r�r7cCs|j�|�dS)z$Add a group as a source of commands.N)r�re)r�r�r?r?r@�
add_source�r�zCommandCollection.add_sourcer/r0rCr2r�csXt��||�}|dur
|S|jD]}|�||�}|dur)|jr%t|||�|SqdSr�)r�r;r�rIrM)r�r/rCr�rr�r?r@r;�s
�zCommandCollection.get_commandr�cs4tt��|��}|jD]
}|�|�|��qt|�Sr�)r�r�r9r�rro)r�r/r�rr�r?r@r9�s
zCommandCollection.list_commands)NN)r>r�r�rr�r�r3rH)r�r7r3rHr�r�)	rrrsrtrur�rr;r9r�r?r?r�r@r�~s�

r�r�r��cabc.Iterator[t.Any]cCst|t�rt�t|�S)ztCheck if the value is iterable but not a string. Raises a type
    error, or return an iterator over the value.
    )rJr2rrVr�r?r?r@�_check_iter�s
rc@seZdZdZdZ													d_d`dd �Zdad"d#�Zdbd%d&�Zdcd*d+�Ze	dbd,d-��Z
ddd0d1�Zej
	dedfd5d6��Zej
	7dgdhd8d6��Z	dedhd9d6�Zdid<d=�ZdjdAdB�ZdkdEdF�ZdldGdH�ZdkdIdJ�ZdmdKdL�ZdndMdN�ZdodRdS�ZdpdUdV�ZdqdWdX�ZdddYdZ�Zdrd]d^�ZdS)srca�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 latter 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 function to further process or validate the value
        after type conversion. It is called as ``f(ctx, param, value)``
        and must return the value. It is called for all sources,
        including prompts.
    :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). If ``nargs=-1``, all remaining
                  parameters are collected.
    :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.
    :param shell_complete: A function that returns custom shell
        completions. Used instead of the param's type completion if
        given. Takes ``ctx, param, incomplete`` and must return a list
        of :class:`~click.shell_completion.CompletionItem` or a list of
        strings.
    :param deprecated: If ``True`` or non-empty string, issues a message
                        indicating that the argument is deprecated and highlights
                        its deprecation in --help. The message can be customized
                        by using a string as the value. A deprecated parameter
                        cannot be required, a ValueError will be raised otherwise.

    .. versionchanged:: 8.2.0
        Introduction of ``deprecated``.

    .. versionchanged:: 8.2
        Adding duplicate parameter names to a :class:`~click.core.Command` will
        result in a ``UserWarning`` being shown.

    .. versionchanged:: 8.2
        Adding duplicate parameter names to a :class:`~click.core.Command` will
        result in a ``UserWarning`` being shown.

    .. versionchanged:: 8.0
        ``process_value`` validates required parameters and bounded
        ``nargs``, and invokes the parameter callback before returning
        the value. This allows the callback to validate prompts.
        ``full_process_value`` is removed.

    .. versionchanged:: 8.0
        ``autocompletion`` is renamed to ``shell_complete`` and has new
        semantics described above. The old name is deprecated and will
        be removed in 8.1, until then it will be wrapped to match the
        new requirements.

    .. versionchanged:: 8.0
        For ``multiple=True, nargs>1``, the default must be a list of
        tuples.

    .. versionchanged:: 8.0
        Setting a default is no longer required for ``nargs>1``, it will
        default to ``None``. ``multiple=True`` or ``nargs=-1`` will
        default to ``()``.

    .. 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.
    �	parameterNFT�param_declsr�r��types.ParamType | t.Any | Noner�rG�defaultr�r��5t.Callable[[Context, Parameter, t.Any], t.Any] | None�nargsr�r}�metavarr�rri�envvar�str | cabc.Sequence[str] | Noner��Nt.Callable[[Context, Parameter, str], list[CompletionItem] | list[str]] | Nonerrr3rHcCs�||||�|pd|	�\|_|_|_t�||�|_|dur*|jjr(|jj}nd}||_	||_
||_||_|	|_
||_|
|_||_||_||_|
|_	|jjrg||jjkrgtd|jj�d|j�d|�d���t|�sm|nd}|dur�|r�z	tt|�d�}Wnty�td�d�w|dkr�|dur�zt|�Wnty�|r�d	}nd
}t|�d�w|dkr�t|�|kr�|r�dnd}td
|�d|�d���|r�|
r�td|j�d|j�d|j�d���dSdS)Nr?r
Tz'nargs' must be z (or None) for type z
, but it was r�z1'default' must be a list when 'multiple' is true.zK'default' must be a list of lists when 'multiple' is true and 'nargs' != 1.z+'default' must be a list when 'nargs' != 1.zitem length�lengthz
'default' z must match nargs=zThe z 'z1' is deprecated and still required. A deprecated z cannot be required.)�_parse_declsr>r4rCr�convert_typer��is_composite�arityr�r�r	r}rrrir
r�_custom_shell_completerrgr��nextrrrm�param_type_name�human_readable_name)r�rr�r�rr�r	r}r
rrirr�r�
check_defaultrL�subjectr?r?r@r�s��
�������
�����zParameter.__init__r�cCs2|j|j|j|j|j��|j|j|j|j	|j
d�
S)z�Gather information that could be useful for a tool generating
        user-facing documentation.

        Use :meth:`click.Context.to_info_dict` to traverse the entire
        CLI structure.

        .. versionadded:: 8.0
        )
r>rr4rCr�r�r	r}rr)r>rr4rCr�r�r�r	r}rrr�r?r?r@r�{s
�zParameter.to_info_dictr2cCr$r%r(r�r?r?r@r*�r+zParameter.__repr__�decls�cabc.Sequence[str]�'tuple[str | None, list[str], list[str]]cCr�r���NotImplementedError)r�rrr?r?r@r�szParameter._parse_declscCr�)z�Returns the human readable name of this parameter.  This is the
        same as the name for options, but the metavar for arguments.
        r�r�r?r?r@r�szParameter.human_readable_namer/r0cCsJ|jdur|jS|jj||d�}|dur|jj��}|jdkr#|d7}|S)N�rYr/r
�...)r
r��get_metavarr>r�r	)r�r/r
r?r?r@�make_metavar�s

zParameter.make_metavarr�r�r�cCr�r�r?�r�r/r�r?r?r@r�r�zParameter.get_default.cCr�r�r?r"r?r?r@r�r�cCs4|j|jdd�}|dur|j}|rt|�r|�}|S)a�Get the default for the parameter. Tries
        :meth:`Context.lookup_default` first, then the local default.

        :param ctx: Current context.
        :param call: If the default is a callable, call it. Disable to
            return the callable instead.

        .. versionchanged:: 8.0.2
            Type casting is no longer performed when getting a default.

        .. versionchanged:: 8.0.1
            Type casting can fail in resilient parsing mode. Invalid
            defaults will not prevent showing help text.

        .. versionchanged:: 8.0
            Looks at ``ctx.default_map`` first.

        .. versionchanged:: 8.0
            Added the ``call`` parameter.
        F�r�N)r�r>rr�)r�r/r�r�r?r?r@r�srJrcCr�r�r�r�rJr/r?r?r@rI�szParameter.add_to_parserr4�cabc.Mapping[str, t.Any]�tuple[t.Any, ParameterSource]cCsd|�|j�}tj}|dur|�|�}tj}|dur"|�|j�}tj}|dur.|�|�}tj	}||fSr�)
r�r>rqrx�value_from_envvarryr�r{rrz�r�r/r4r�rr?r?r@�
consume_value�s

zParameter.consume_valuer�r�cs�|dur�js�jdkrdSdSd��fdd	���jd
ks!�jjr*d��fdd��n�jdkr9d���fd
d��n	d���fdd���jrRt�fdd��|�D��S�|�S)zuConvert and validate a value against the option's
        :attr:`type`, :attr:`multiple`, and :attr:`nargs`.
        N���r?r�r�r3rcs.zt|�WStyttd���d�d�w)NzValue must be an iterable.�r/rY)rrrr�r�r�r?r@�
check_iter�s

���z-Parameter.type_cast_value.<locals>.check_iterr
cs�j|��d�S)Nr�r�r�r�r?r@�convert	r�z*Parameter.type_cast_value.<locals>.convertcst��fdd��|�D��S)Nc3��|]
}��|���VqdSr�r-�r �xr�r?r@r7
	���=Parameter.type_cast_value.<locals>.convert.<locals>.<genexpr>)�tupler��r,r/r�r?r@r.		rXcs\t�|��}t|��jkr"ttddt|��j�jt|�d���d��t��fdd�|D��S)Nz%Takes {nargs} values but 1 was given.z*Takes {nargs} values but {len} were given.)r	rmr+c3r/r�r-r0r�r?r@r7	r2r3)r4rmr	rr
rXr�r5r?r@r.	s���
c3s�|]}�|�VqdSr�r?r0)r.r?r@r7	��z,Parameter.type_cast_value.<locals>.<genexpr>�r�r�r3rr�)r}r	r�rr4�r�r/r�r?)r,r.r/r�r@r�s
zParameter.type_cast_valuecCs,|durdS|jdks|jr|dkrdSdS)NTr
r?F)r	r})r�r�r?r?r@�value_is_missing#	s
zParameter.value_is_missingcCsD|�||�}|jr|�|�rt||d��|jdur |�|||�}|S)Nr+)rr�r9rr�r8r?r?r@�
process_value,	s
zParameter.process_valuecCs\|jdurdSt|jt�rtj�|j�}|r|SdS|jD]}tj�|�}|r+|SqdSr�)rrJr2r�r�r��r�r/r�rr?r?r@�resolve_envvar_value7	s

��zParameter.resolve_envvar_valuecCs,|�|�}|dur|jdkr|j�|�}|Sr�)r<r	r��split_envvar_valuer�r?r?r@r'I	s
zParameter.value_from_envvarr�r��tuple[t.Any, list[str]]c	Cs�t||d��b|�||�\}}|jrB|durB|tjtjfvrBt|jt�r*d|j��nd}td�j	|j
|j|d�}tt
|dd�dd	�|�|j|�z|�||�}Wnty`|js\�d}YnwWd�n1skwY|jry||j|j<||fS)
N)rYr�r�zKDeprecationWarning: The {param_type} {name!r} is deprecated.{extra_message})�
param_typer>rprqrrTrt)r]r)rrqrzr{rJr2r�rXrrr%r"rr>r:�	Exceptionr�rr�)r�r/r4r�r�rrprLr?r?r@rlQ	sD���������#zParameter.handle_parse_result�tuple[str, str] | NonecCr�r�r?r#r?r?r@rd|	r�zParameter.get_help_recordcCsgSr�r?r#r?r?r@r�	r�zParameter.get_usage_piecescCs"|jp|jg}d�dd�|D��S)z{Get a stringified version of the param for use in error messages to
        indicate which param caused the error.
        � / css�|]	}d|�d�VqdS)�'Nr?r0r?r?r@r7�	r�z+Parameter.get_error_hint.<locals>.<genexpr>)r4rr�)r�r/�	hint_listr?r?r@�get_error_hint�	szParameter.get_error_hintr1rvcsd|jdur*|�|||�}|r$t|dt�r$ddlm��fdd�|D�}t�d|�S|j�|||�S)a�Return a list of completions for the incomplete value. If a
        ``shell_complete`` function was given during init, it is used.
        Otherwise, the :attr:`type`
        :meth:`~click.types.ParamType.shell_complete` function is used.

        :param ctx: Invocation context for this command.
        :param incomplete: Value being completed. May be empty.

        .. versionadded:: 8.0
        Nrr)csg|]}�|��qSr?r?r�r)r?r@r!�	r"z,Parameter.shell_complete.<locals>.<listcomp>rv)	rrJr2rzr*r5r6r�r�r~r?r)r@r��	s
zParameter.shell_complete)
NNFNNNFNTFNNF)rr�r�rr�rGrr�r�rr	r�r}rGr
r�rrGrirGrrr�r
rrr3rHrr
�rrrrGr3rr�r�r/r0r�r�r3r�r�r/r0r�rGr3r��rJrr/r0r3rH)r/r0r4r%r3r&)r/r0r�r�r3r�)r�r�r3rG�r/r0r3r��r/r0r3r�)r/r0r4r%r�r�r3r>�r/r0r3rAr�r�)rrrsrtrurr�r�r*rrrr!r5rrrIr)rr9r:r<r'rlrdr�rEr�r?r?r?r@rc�sVY�
_


���
!


3
	



+

rccs�eZdZdZdZ																	dPdQ�fd#d$�
ZdR�fd&d'�ZdS�fd+d,�ZdTd1d2�ZdUd5d6�Z	dVd8d9�Z
dWd;d<�Zej
	dXdYd?d@��Zej
	AdZd[dCd@��Z	dXd[�fdDd@�
Zd\dEdF�Zd]�fdGdH�Zd^dIdJ�Zd_�fdNdO�Z�ZS)`r|a�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: Show the default value for this option in its
        help text. Values are not shown by default, unless
        :attr:`Context.show_default` is ``True``. If this value is a
        string, it shows that string in parentheses instead of the
        actual value. This is particularly useful for dynamic options.
        For single option boolean flags, the default remains hidden if
        its value is ``False``.
    :param show_envvar: Controls if an environment variable should be
        shown on the help page and error messages.
        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. A deprecated option cannot be
        prompted.
    :param confirmation_prompt: Prompt a second time to confirm the
        value if it was prompted for. Can be set to a string instead of
        ``True`` to customize the message.
    :param prompt_required: If set to ``False``, the user will be
        prompted for input only when the option was specified as a flag
        without a value.
    :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.
    :param attrs: Other command arguments described in :class:`Parameter`.

    .. versionchanged:: 8.2
        ``envvar`` used with ``flag_value`` will always use the ``flag_value``,
        previously it would use the value of the environment variable.

    .. versionchanged:: 8.1
        Help text indentation is cleaned here instead of only in the
        ``@option`` decorator.

    .. versionchanged:: 8.1
        The ``show_default`` parameter overrides
        ``Context.show_default``.

    .. versionchanged:: 8.1
        The default of a single option boolean flag is not shown if the
        default value is ``False``.

    .. versionchanged:: 8.0.1
        ``type`` is detected from ``flag_value`` if given.
    �optionNFTrr�r��bool | str | Noner!r�confirmation_prompt�prompt_requiredrG�
hide_input�is_flagr��
flag_valuer�r}r6�allow_from_autoenvr�rrr�r<�show_choices�show_envvarr�attrsr�r3rHcs�|
rt�|
�}
d|v}t�j|f||	|d�|��|dur0|jdur&td��|j�dd���}n	|dur7d}n|}|rRt|t	�rFd|�d	�nd
}|
durP|
|n|}
||_
||_||_||_
||_|j
duoi|j|_|dur�|durvd}n|jr|d}nt|j�}n|dur�|js�|du|_||r�|r�|js�|	r�d|_nd|_|r�|dur�|j}||r�|dur�t�d|�|_||_|o�t|jtj�|_||_|
|_|
r�|dur�tjdd
�|_|r�d|_||_|
|_||_||_ ||_!	|r�|r�t"d��|j#dkr�td��|j
�r|j�r|j�std��|j�s|j�rtd��|j�r-|j
�r-|j
du�r-td��|j�rA|j$�r9td��|j�rCtd��dSdS)Nr)r�r}rTz&'name' is required with 'prompt=True'.r�r�FrOrPrQr?r)�minz)`deprecated` options cannot use `prompt`.r*z&nargs=-1 is not supported for options.z+'prompt' is not valid for non-boolean flag.z1Secondary flag is not valid for non-boolean flag.z9'prompt' with 'hide_input' is not valid for boolean flag.z%'count' is not valid with 'multiple'.z$'count' is not valid with 'is_flag'.)%rVrWr�r�r>rr��
capitalizerJr2r!rOrPrQr<rrGrCr�rrrr�rR�
BoolParamType�is_bool_flagrSr6�IntRangerTrr�rUrVrgr	r})r�rr�r!rOrPrQrRrSr}r6rTr�rr<rUrVrrW�default_is_missing�prompt_textrUr�r?r@r��	s�
���
��

��zOption.__init__r�cs0t���}|j|j|j|j|j|j|jd�|S)N)rr!rRrSr6r<)	r�r�rrr!rRrSr6r<)r�r�r�r?r@r�i
s
�zOption.to_info_dictr/r0r2cs(t��|�}|jr|d|j�d�7}|S)Nz (env var: 'z'))r�rErVr)r�r/�resultr�r?r@rEu
szOption.get_error_hintrrrrcCslg}g}d}g}|D]e}|��r|durtd|�d���|}q
|dd�dkr)dnd}||vrc|�|d�\}	}
|	��}	|	rI|�t|	��|�|	�|
��}
|
rV|�|
���|	|
krbtd|�d���q
|�t|��|�|�q
|dur�|r�|jdd	�d
�|dd�	dd
��
�}|��s�d}|dur�|s�d||fStd|����|s�|s�td|�d|�d���|||fS)NzName 'z' defined twicer
�/�;zBoolean option z) cannot use the same flag for true/false.cSst|d�Sr�r��r1r?r?r@�<lambda>�
sz%Option._parse_decls.<locals>.<lambda>rmrr�r�z6Could not determine name for option with declarations z*No options defined but a name was passed (zH). Did you mean to declare an argument instead? Did you mean to pass '--z'?)�isidentifierr�splitr0rerr�rg�sortr��lower)r�rrr4rCr>�possible_names�decl�
split_char�first�secondr?r?r@r{
sX

��
���
zOption._parse_declsrJrcCs�|jrd}n|jrd}nd}|jrE|�d�}|jr6|jr6|j||j|j|dd�|j||j|j|dd�dS|j||j|j||jd�dS|j||j|j||j	d�dS)	Nrer6�store�_constT)r�r4�dest�action�constF)r�r4rorpr	)
r}r6rRr[rC�
add_optionr4r>rSr	)r�rJr/rpr?r?r@rI�
s@
�
�
�
�zOption.add_to_parserrAcs�jrdSd�d���fdd�}|�j�g}�jr!|�|�j���jp%d}����}g}d	|vrA|�td
�jd�|d	�d��d
|vrR|�td�j|d
d��d|vr]|�|d�d|vrj|�t|d��|r�d�|�}|r{|�d|�d�nd|�d�}�r�dnd�|�|fS)NFr4rr3r2cs:t|�\}}|r
d��js�js|d�j�d���7}|S)NTr�)r/)rrRr6r!)r4r��any_slashes��any_prefix_is_slashr/r�r?r@�_write_opts�
sz+Option.get_help_record.<locals>._write_optsr��envvarszenv var: {var}�, )�varrzdefault: {default})r�ranger�z; z  [�]�[rB)r4rr3r2)	r<r4rCrer�get_help_extrar�rXr�)r�r/rvr�rrh�extra_items�	extra_strr?rtr@rd�
s0


�
 zOption.get_help_record�types.OptionHelpExtrac
Cs�i}|jr>|j}|dur$|jr$|jdur$|jdur$|j�d|j����}|dur>t|t�r3|f|d<ntdd�|D��|d<|j	}d|_	z|j
|dd�}W||_	n||_	wd}d}|jdurmt|jt�rid}}n|j}n|jduru|j}|s}|r�|dur�|r�d|j�d	�}nGt|ttf�r�d
�
dd�|D��}n5t�|�r�td�}n+|jr�|jr�t|r�|jn|jd
�d}n|jr�|js�|s�d}n|dkr�d}nt|�}|r�||d<t|jtj�r�|jr�|jjd
kr�|jjdus�|j��}	|	r�|	|d<|jr�d|d<|S)Nr�rwcs��|]}t|�VqdSr��r2�r �dr?r?r@r7r6z(Option.get_help_extra.<locals>.<genexpr>TFr#�(rPrxcsr�r�r�r�r?r?r@r74r6z	(dynamic)rr
r�z""rrzr�)rVrrTr�r>r�rJr2r4r�rr�rTr�rV�
isfunctionr�r[rCrr4r�r�_NumberRangeBaser6rXr��_describe_ranger�)
r�r/rhr�	resilient�
default_valuer��show_default_is_str�default_string�	range_strr?r?r@r}sr�







����
zOption.get_help_extrar�r�cCr�r�r?r"r?r?r@rVr�zOption.get_default.r�cCr�r�r?r"r?r?r@r[r�csR|jr!|js!|jjD]}|j|jkr|jrt�t|�j	Sq
dSt
�j||d�S)Nr#)rRr[r8r�r>rr5r6r|rSr�r)r�r/r�rYr�r?r@r`s�c
sv�jdusJ�����}�jrt�j|�Si}t�jt�r"�j|d<t�jf|�j�j�j	�j
��fdd�d�|��S)z�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.
        Nr�cs���|�Sr�)r:rbr�r?r@rc�sz)Option.prompt_for_value.<locals>.<lambda>)rr�rQrUrO�
value_proc)r!rr[r rJr�rGr�rQrUrO)r�r/r�
prompt_kwargsr?r�r@�prompt_for_valueps&

���zOption.prompt_for_valuecsvt��|�}|dur|jr|jrt|j�S|S|jr9|jdur9|jdur9|j�d|j����}t	j
�|�}|r9|SdS)Nr�)r�r<rRrSr2rTr�r>r�r�r�r�r;r�r?r@r<�s
�

zOption.resolve_envvar_valuecCs^|�|�}|durdS|jdkt|j�}|dkr-|j�|�}|jr-|jdkr-t||j�}|Sr�)r<r	rGr}r�r=rW)r�r/r��value_depthr?r?r@r'�s
zOption.value_from_envvarr4�cabc.Mapping[str, Parameter]r&cs�t��||�\}}|tur+�jdur!|js!��|�}tj}||fS�j}tj	}||fS�j
rK|durKtdd�|D��rK�fdd�|D�}tj	}||fS|dtjhvrh�jdurh�j
s]�jrh|jsh��|�}tj}||fS)Ncss�|]}|tuVqdSr�r�r �vr?r?r@r7�r6z'Option.consume_value.<locals>.<genexpr>csg|]}|tur�jn|�qSr?)rrSr�r�r?r@r!�r�z(Option.consume_value.<locals>.<listcomp>)r�r)rr!r�r�rqr|rSrxr}�anyrzr�rPr(r�r�r@r)�s8
����
�
���
zOption.consume_value)NNFFTFNNFFTNNFTFF)&rr�r�rNr!rrOrrPrGrQrGrRr�rSr�r}rGr6rGrTrGr�rrr�r<rGrUrGrVrGrrrWr�r3rHrr�rFrIrL)r/r0r3r�rrGrrHr�rJrK)r/r0r4r�r3r&)rrrsrtrurr�r�rErrIrdr}r5rrr�r<r'r)r�r?r?r�r@r|�	sPA�

7
'
-P���
!
r|csjeZdZdZdZ	d$d%�fdd
�
Zed&dd��Zd'dd�Zd(dd�Z	d)dd�Z
d'dd�Zd*d"d#�Z�Z
S)+r�aArguments 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 constructor of :class:`Parameter`.
    �argumentNrrr�r�rWr�r3rHcsz|dur|�d�durd}n|�dd�dk}d|vrtd��t�j|fd|i|��	|jdur9|jd
kr;td��dSdS)NrFr	r
rr}z9__init__() got an unexpected keyword argument 'multiple'.r�Tr*z('default' is not supported for nargs=-1.)r�rr�r�rr	)r�rr�rWr�r?r@r��s�zArgument.__init__r2cCs|jdur|jS|j��Sr�)r
r>r�r�r?r?r@r�s

zArgument.human_readable_namer/r0cCsd|jdur|jS|jj||d�}|s|j��}|jr|d7}|js'd|�d�}|jdkr0|d7}|S)Nr�!r|r{r
r)r
r�r r>r�rr�r	)r�r/ryr?r?r@r!s


zArgument.make_metavarrrrGrcCsj|s
|s	dggfStd��t|�dkr"|d}}|�dd���}n
tdt|��d|�d���||ggfS)	Nz8Argument is marked as exposed, but does not have a name.r
rr�r�z6Arguments take exactly one parameter declaration, got z: r�)rrmr�rg)r�rrr>�argr?r?r@rs
���zArgument._parse_declsr�cCs|�|�gSr��r!r#r?r?r@r� szArgument.get_usage_piecescCsd|�|��d�S)NrCr�r#r?r?r@rE#szArgument.get_error_hintrJrcCs|j|j|j|d�dS)N)ror	r�)�add_argumentr>r	r$r?r?r@rI&r+zArgument.add_to_parserr�)rrr�r�rWr�r3rHr
r�rFr�rI)rrrsrtrurr�rrr!rr�rErIr�r?r?r�r@r��s�



r�r>�objectcCsHddl}|dkr|jdtdd�tS|dkr |jdtdd�tSt|��)Nr�BaseCommandzT'BaseCommand' is deprecated and will be removed in Click 9.0. Use 'Command' instead.r�r��MultiCommandzS'MultiCommand' is deprecated and will be removed in Click 9.0. Use 'Group' instead.)r�r�r�r�r��AttributeError)r>r�r?r?r@�__getattr__*s ��r�)r/r0r1r2r3r4r�)
rBr7rCr2rDrErFrGr3rH)rNrOrPrQr3rRr�)r/r0rYrZr3r[)r^r_r`r_r3rar7)r>r2r3r�)S�
__future__r�collections.abcr�cabcrvr�rVr�r��typingr5�collectionsr�
contextlibrrr�	functoolsrr	r�r
�	itertoolsrrrr��
exceptionsrrrrrrr�
formattingrr�globalsrrrJrrr�termuir r!r"�utilsr#r$r%r&r'r(�
TYPE_CHECKINGr�r*�TypeVarr+r.rArMrWr]rp�Enumrqr0rEr�r�r�r7r�r�rrcr|r�r�r?r?r?r@�<module>s�

�
�
(^F
8
d?N