403Webshell
Server IP : 178.105.222.151  /  Your IP : 216.73.216.38
Web Server : nginx/1.28.3
System : Linux MNK 7.0.0-15-generic #15-Ubuntu SMP PREEMPT_DYNAMIC Wed Apr 22 16:06:43 UTC 2026 x86_64
User : www-data ( 33)
PHP Version : 8.5.4
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/click/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/click/__pycache__/core.cpython-314.pyc
+
�
4i<����^RIt^RIt^RIt^RIt^RIt^RIt^RIHt^RI	H
t
^RI	Ht^RIH
t
^RIHt^RIHt^RIHt^R	IHt^R
IHt^RIHt^RIHt^R
IHt^RIHt^RIHt^RIHt^RIHt^RIHt^RI H!t!^RI H"t"^RI#H$t$^RI#H%t%^RI#H&t&^RI'H(t(^RI'H)t)^RI'H*t*^RI+H,t,^RI+H-t-^RI+H.t.^RI+H/t/^RI+H0t0^R I+H1t1]Pd'd^RI3t4^R!I5H6t6^R"I7H8t8]Pr!R#]PtR$]Pv3,R%7t<]Pr!R&4t=R'R(lt>RGR)R*llt?R+R,lt@]
RHR-R.ll4tAR/R0ltB!R1R2]P�4tD!R3R44tE!R5R64tF!R7R8]F4tG!R9R:]G4tH!R;R<]H4tI!R=R>]H4tJR?R@ltK!RARB4tL!RCRD]L4tM!RERF]L4tNR#)I�N)�abc)�contextmanager)�	ExitStack)�update_wrapper)�gettext)�ngettext)�repeat)�
TracebackType)�types��Abort)�BadParameter)�ClickException��Exit)�MissingParameter��
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��
HelpOption��CompletionItem�F.)�bound�Vc	��V^8�dQhRRR\R\P\P\R3,,/#)��ctx�Context�
incomplete�return�Command)�str�t�Iterator�Tuple)�formats"�,/usr/lib/python3/dist-packages/click/core.py�__annotate__r;2s:��$�$�	�$� #�$��Z�Z�����Y��'�(�$�c#�"�\P!\VP4pVP	V4FLpVPV4'gKVP
W4pVfK3VP'dKGW43x�KN	R#5i)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)r6�cast�MultiCommand�command�
list_commands�
startswith�get_command�hidden)r0r2�multi�namer@s&&   r:�_complete_visible_commandsrG2se���
�F�F�<����-�E��#�#�C�(���?�?�:�&�&��'�'��2�G��"�7�>�>�>��m�#�)�s�AB�B�,B�Bc
�<�V^8�dQhRRR\RRR\RR/#)	r/�base_commandr?�cmd_name�cmdr4�registerr3N)r5�bool)r9s"r:r;r;Es4���� ��,/��6?��KO��	�r<c�,�VP'd\V\4'gR#V'dRpMRp\VRVP:RV:RV:R\V4PR\V4PRVP:R	24h)
NzdIt is not possible to add multi commands as children to another multi command that is in chain mode.zdFound a multi command as subcommand to a multi command that is in chain mode. This is not supported.z
. Command z is set to chain and zA was added as a subcommand but it in itself is a multi command. (z is a z within a chained z named z).)�chain�
isinstancer?�RuntimeErrorrF�type�__name__)rIrJrKrL�hints&&&& r:�_check_multicommandrUEs�������Z��\�%B�%B���
<�	
�
=�	
���&�
�<�,�,�/�0��<��$�<�v�d�3�i�.@�.@�-A�
�T�,�/�8�8�9�:���� ��		$��r<c	��V^8�dQhR\P\,R\R\P\P
\R3,,/#)r/�iterable�
batch_sizer3.)r6�Iterabler-�int�Listr8)r9s"r:r;r;]s>��:�:�A�J�J�q�M�:�s�:�q�v�v�a�g�g�a��f�o�7N�:r<c	�L�\\\\V4V4!4#�N)�list�zipr	�iter)rWrXs&&r:�batchra]s����V�D��N�J�7�8�9�9r<c�x�V^8�dQhRRR\PR,R\PR,/#)r/r0r1�param�	Parameterr3N)r6�Optionalr7)r9s"r:r;r;bs6����	���:�:�k�2���Z�Z���r<c#��"�Rx�R# \d3pTPfYnTeTPfYnhRp?i\dpTPfYnhRp?ii;i5i)z>Context manager that attaches extra information to exceptions.N)rr0rcr)r0rc�es&& r:�augment_usage_errorsrhasZ���
�
�����5�5�=��E��������G�
�����5�5�=��E�
���s6�A-�
�A-�A*�-A�A*�A*�A%�%A*�*A-c��V^8�dQhR\PR,R\PR,R\PR,/#)r/�invocation_orderrd�declaration_orderr3)r6�Sequencer[)r9s"r:r;r;tsA��3�3��j�j��-�3��z�z�+�.�3��V�V�K��3r<c�.a�RV3Rllp\WR7#)a�Returns 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
c�^�V^8�dQhRRR\P\\3,/#)r/�itemrdr3)r6r8rM�float)r9s"r:r;�0iter_params_for_processing.<locals>.__annotate__�s'��&�&�{�&�q�w�w�t�U�{�';�&r<c�<�SPV4pVP'*V3# \d\R4pL+i;i)�inf)�index�
ValueErrorrp�is_eager)ro�idxrjs& �r:�sort_key�,iter_params_for_processing.<locals>.sort_key�sF���	�)�/�/��5�C��=�=� �#�%�%���	���,�C�	�s�'�A�A��key)�sorted)rjrkrxsf& r:�iter_params_for_processingr}ts��� &�&��#�2�2r<c���]tRt^�tRt]P!4t]P!4t]P!4t	]P!4t
]P!4tRtR#)�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)
rS�
__module__�__qualname__�__firstlineno__�__doc__�enum�auto�COMMANDLINE�ENVIRONMENT�DEFAULT�DEFAULT_MAP�PROMPT�__static_attributes__r�r<r:rr�sO����)�)�+�K�:��)�)�+�K�>��i�i�k�G�6��)�)�+�K�A�
�Y�Y�[�F�@r<rc��a�]tRt^�toRt]tR?V3RlRlltV3RlRltV3RlRlt	V3R	lR
lt
]R@V3RlRll4t]
V3R
lRl4tV3RlRltV3RlRltV3RlRltV3RlRlt]
V3RlRl4tV3RlRltV3RlRltV3RlRlt]P0R@V3RlR ll4t]P0RAV3R!lR"ll4tR@V3R#lR$lltV3R%lR&ltV3R'lR(ltRBV3R)lR*lltV3R+lR,ltV3R-lR.ltV3R/lR0lt]P0V3R1lR2l4t ]P0V3R3lR4l4t V3R5lR6lt V3R7lR8lt!V3R9lR:lt"V3R;lR<lt#V3R=lt$R>t%Vt&R#)Cr1a�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.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.
Nc"�<�V^8�dQhRRRS[PR,RS[PS[,RS[PS[P,RS[PS[,RS[PS[PS[S[P3,,R	S[PS[,R
S[PS[,RS[RS[PS[,R
S[PS[,RS[PS[,RS[PS[PS[,,RS[PS[PS[.S[3,,RS[PS[,RS[PS[,RR/#)r/r@r4�parentr1�	info_name�obj�auto_envvar_prefix�default_map�terminal_width�max_content_width�resilient_parsing�allow_extra_args�allow_interspersed_args�ignore_unknown_options�help_option_names�token_normalize_func�color�show_defaultr3N)	r6rer5�Any�MutableMappingrZrMr[�Callable)r9�
__classdict__s"�r:r;�Context.__annotate__
sp���j'�j'��j'��
�
�9�%�j'��:�:�c�?�	j'�
�Z�Z����
�j'��J�J�s�O�
j'��Z�Z�� 0� 0��a�e�e�� <�=�j'��
�
�3��j'��:�:�c�?�j'� �j'��*�*�T�*�j'�"#���D�!1�j'�!"�
�
�4� 0�j'��:�:�a�f�f�S�k�2�j'� �j�j����S�E�3�J�)?�@�j'� �z�z�$��!j'�"�j�j��&�#j'�$
�%j'r<c��W nWnW0n/Vn.Vn.VnV'd\
VP4M	\
4VnVfVe
VPpW@n\VR/4Vn
Vf2Ve.Ve*VPeVPPV4pW`nRVn
VfVe
VPpWpnVfVe
VPpW�nV
f
VP p
W�nVf
VP"pW�nVf
VP$pW�nV
fVeVP&p
MR.p
W�nVfVe
VP(pVVnW�nVfKVeFVP,e8VPe*VP,RVPP/42pMVP/4pVeVP1RR4pWPnVfVe
VP2pW�nVfVe
VP4pVVn.Vn^Vn/Vn\=4VnR#)N�metaz--help�_�-) r�r@r��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)�selfr@r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�s&&&&&&&&&&&&&&&&&r:�__init__�Context.__init__
su��(����"��+-���!#��	�
,.���FL��V�-A�-A�)B�RU�RW����;�6�-��*�*�C���)0����)D��
�
���%��"��"�"�.� �,�,�0�0��;�K�EP��48����!�f�&8�#�2�2�N�0>���$��);� &� 8� 8��3D���#�&�7�7��!1��"�*�&-�&E�&E�#�.E�$�!�)�%,�%C�%C�"�-C�#��$��!�$*�$<�$<�!�%-�J�!�/@���'�F�,>�#)�#>�#>� �

!�	
�!�(9��
�%��"��-�-�9��N�N�.��0�0�1��4�>�>�3G�3G�3I�2J�K�#��"4�!9�!9�!;���)�!3�!;�!;�C��!E��3E���=�V�/��L�L�E�(-�
���F�$6�!�.�.�L�/;���?A������?A���$�;��r<c�^<�V^8�dQhRS[PS[S[P3,/#�r/r3�r6�Dictr5r�)r9r�s"�r:r;r��s%���
�
�a�f�f�S�!�%�%�Z�0�
r<c��RVPPV4RVPRVPRVPRVP
RVP/#)z�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
r@r�r�r�r�r�)r@�to_info_dictr�r�r�r�r��r�s&r:r��Context.to_info_dict�sW��
�t�|�|�0�0��6������� 5� 5�%�t�'C�'C�$�d�&A�&A� �$�"9�"9�

�	
r<c�<�V^8�dQhRR/#�r/r3r1r�)r9r�s"�r:r;r��s�����9�r<c�N�V;P^,
un\V4V#)�)r�rr�s&r:�	__enter__�Context.__enter__�s�����q����T���r<c�<�V^8�dQhRS[PS[PS[,,RS[PS[,RS[PS[,RR/#)r/�exc_type�	exc_value�tbr3N)r6re�Type�
BaseExceptionr
)r9r�s"�r:r;r��sW���	�	��*�*�Q�V�V�M�2�3�	��:�:�m�,�	�
�J�J�}�%�		�

�	r<c��V;P^,unVP^8XdVP4\4R#)r�N)r��closer)r�r�r�r�s&&&&r:�__exit__�Context.__exit__�s,��	
���q����;�;�!���J�J�L��
r<c�H<�V^8�dQhRS[RS[PR,/#)r/�cleanupr3r1)rMr6r7)r9r�s"�r:r;r��s$���#!�#!�T�#!�Q�Z�Z�	�-B�#!r<c#�:"�V'gV;P^,
unV;_uu_4pVx�RRR4V'gV;P^,unR#R# +'giL5;i T'gT;P^,unii;i5i)a�This 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.
N)r�)r�r��rvs&& r:�scope�
Context.scope�sf���:��K�K�1��K�	!�����������q� ����������q� ���s1�"B�
A4�A!�A4�%B�!A1	�,A4�4$B�Bc�^<�V^8�dQhRS[PS[S[P3,/#r�r�)r9r�s"�r:r;r�s%�����a�f�f�S�!�%�%�Z�(�r<c��VP#)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�s&r:r��Context.metas��4�z�z�r<c� <�V^8�dQhRS[/#r�r)r9r�s"�r:r;r� s���
�
�
�
r<c�P�VPVPVPR7#)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)�formatter_classr�r�r�s&r:�make_formatter�Context.make_formatter s-���#�#��%�%��1G�1G�$�
�	
r<c�J<�V^8�dQhRS[PS[,RS[/#)r/�context_managerr3)r6�ContextManagerr-)r9r�s"�r:r;r�.s&���?�?�Q�-=�-=�a�-@�?�Q�?r<c�8�VPPV4#)aARegister 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�s&&r:�
with_resource�Context.with_resource.s��6���-�-�o�>�>r<c�<�V^8�dQhRS[PRS[P3,RS[PRS[P3,/#�r/�f.r3�r6r�r�)r9r�s"�r:r;r�Ks=���
,�
,�q�z�z�#�q�u�u�*�5�
,�!�*�*�S�!�%�%�Z�:P�
,r<c�8�VPPV4#)aURegister 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�s&&r:�
call_on_close�Context.call_on_closeKs�����(�(��+�+r<c�<�V^8�dQhRR/#)r/r3Nr�)r9r�s"�r:r;r�Ws���'�'�t�'r<c�X�VPP4\4VnR#)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�s&r:r��
Context.closeWs ��
	
����� �$�;��r<c� <�V^8�dQhRS[/#r��r5)r9r�s"�r:r;r�as�����c�r<c��RpVPe
VPpVPe�VPP.p\VPP\
4'dMVPPP
V4F#pVPVPV44K%	RPV4RV2pVP4#)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.
�� )r�r��command_pathrPr@r4�
get_params�extend�get_usage_pieces�join�lstrip)r�r��parent_command_pathrcs&   r:r��Context.command_path`s������>�>�%����B��;�;�"�#'�;�;�#;�#;�"<���$�+�+�-�-�w�7�7�!�[�[�0�0�;�;�D�A�E�'�.�.�u�/E�/E�d�/K�L�B��H�H�0�1�2�!�B�4�8�B��y�y�{�r<c�<�V^8�dQhRR/#r�r�)r9r�s"�r:r;r�ss�����9�r<c�B�TpVPeVPpKV#)zFinds the outermost context.�r�)r��nodes& r:�	find_root�Context.find_rootss�����k�k�%��;�;�D��r<c�n<�V^8�dQhRS[PS[,RS[PS[,/#�r/�object_typer3)r6r�r-re)r9r�s"�r:r;r�zs+���
�
�q�v�v�a�y�
�Q�Z�Z��]�
r<c�~�TpVe7\VPV4'd
VP#VPpK:R#)z)Finds the closest object of a given type.N)rPr�r�)r�rrs&& r:�find_object�Context.find_objectzs3��$(�����$�(�(�K�0�0��x�x���;�;�D�r<c�J<�V^8�dQhRS[PS[,RS[/#r)r6r�r-)r9r�s"�r:r;r��s#�����������q�r<c�L�VPV4pVfV!4;VnpV#)zpLike :meth:`find_object` but sets the innermost object to a
new instance of `object_type` if it does not exist.
)r
r�)r�rr�s&& r:�
ensure_object�Context.ensure_object�s,���
�
�k�
*��
�:�'�M�)�D�H�r��	r<c�b<�V^8�dQhRS[RRRS[PS[P,/#)r/rF�call�te.Literal[True]r3)r5r6rer�)r9r�s"�r:r;r��s2��� � �� �1� �	
���A�E�E�	� r<c��R#r]r��r�rFrs&&&r:�lookup_default�Context.lookup_default���� r<c��<�V^8�dQhRS[RRRS[PS[PS[PS[P
.S[P3,3,,/#)r/rFrzte.Literal[False]r3)r5r6re�Unionr�r�)r9r�s"�r:r;r��sV���@�@��@�2�@�	
���A�G�G�A�E�E�1�:�:�b�!�%�%�i�#8�8�9�	:�@r<c��R#r]r�rs&&&r:rr����=@r<c�d<�V^8�dQhRS[RS[RS[PS[P,/#)r/rFrr3)r5rMr6rer�)r9r�s"�r:r;r��s/�����3��d��a�j�j����>O�r<c��VPe>VPPV4pV'd\V4'dV!4#V#R#)z�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�rFr�values&&& r:rr�s@�����'��$�$�(�(��.�E�������w���L�r<c�$<�V^8�dQhRS[RR/#)r/�messager3�te.NoReturnr�)r9r�s"�r:r;r��s���(�(�C�(�M�(r<c��\W4h)ztAborts the execution of the program with a specific error
message.

:param message: the error message to fail with.
r)r�r!s&&r:�fail�Context.fail�s����'�'r<c�<�V^8�dQhRR/#)r/r3r"r�)r9r�s"�r:r;r��s�����}�r<c��\4h)zAborts the script.rr�s&r:�abort�
Context.abort�s	���g�
r<c�$<�V^8�dQhRS[RR/#)r/�coder3r")rZ)r9r�s"�r:r;r��s�������]�r<c��\V4h)z-Exits the application with a given exit code.r)r�r+s&&r:�exit�Context.exit�s���4�j�r<c� <�V^8�dQhRS[/#r�r�)r9r�s"�r:r;r��s���,�,�3�,r<c�8�VPPV4#)zQHelper method to get formatted usage string for the current
context and command.
)r@�	get_usager�s&r:r1�Context.get_usage�s���|�|�%�%�d�+�+r<c� <�V^8�dQhRS[/#r�r�)r9r�s"�r:r;r��s���+�+�#�+r<c�8�VPPV4#)zNHelper method to get formatted help page for the current
context and command.
)r@�get_helpr�s&r:r5�Context.get_help�s���|�|�$�$�T�*�*r<c�"<�V^8�dQhRRRR/#)r/r@r4r3r1r�)r9r�s"�r:r;r��s���H�H��H�y�Hr<c�<�\V4!WPVR7#)z^Create a new context of the same type as this context, but
for a new command.

:meta private:
)r�r�)rRrF)r�r@s&&r:�_make_sub_context�Context._make_sub_context�s���D�z�'�\�\�$�G�Gr<c�X<�V^8�dQhRRRS[PRS[PRS[/#)r/�_Context__callback�t.Callable[..., V]r��kwargsr3)r6r�r-)r9r�s"�r:r;r��s;�����(���u�u���%�%�	�

�r<c��R#r]r���_Context__selfr<r�r>s&&*,r:�invoke�Context.invoke�s��
r<c�l<�V^8�dQhRRRS[PRS[PRS[P/#)r/r<r4r�r>r3�r6r�)r9r�s"�r:r;r��s?��������u�u���%�%�	�

���r<c��R#r]r�r@s&&*,r:rBrC�s��r<c
�<�V^8�dQhRS[PR,RS[PRS[PRS[PS[PS[3,/#)r/r<r�r>r3)r4r=)r6rr�r-)r9r�s"�r:r;r��sV���33�33��G�G�;�<�33��u�u�33��%�%�	33�

��������	�33r<c	��\V\4'd�TpVPf\R4h\P
!RVP4pVP
V4pVPFVpVPV9gKVP'gK*VPWVPV44W6P&KX	VPPV4MTp\V4;_uu_4V;_uu_4V!V/VBuuRRR4uuRRR4# +'giM;iRRR4R# +'giR#;i)aXInvokes 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`.

.. versionchanged:: 8.0
    All ``kwargs`` are tracked in :attr:`params` so they will be
    passed if :meth:`forward` is called at multiple levels.
Nz?The given command does not have a callback that can be invoked.r=)rPr4r��	TypeErrorr6r>r9r�rF�expose_value�type_cast_value�get_default�updaterh)rAr<r�r>�	other_cmdr0rcs&&*,   r:rBrC�s��2�j�'�*�*�"�I��!�!�)��U����V�V�$8�)�:L�:L�M�
��*�*�9�5�C�"�)�)���:�:�V�+��0B�0B�0B�).�)>�)>��.�.�s�3�*�F�:�:�&�*�
�J�J���f�%��C�
!�&�
)�
)���!�4�2�6�2���*�
)�����*�
)�
)�
)�s$�;E�D#	�
E�#D3
�.E�E	c�l<�V^8�dQhRRRS[PRS[PRS[P/#)r/�
_Context__cmdr4r�r>r3rE)r9r�s"�r:r;r�s5���5�5�y�5����5�!�%�%�5�A�E�E�5r<c���\V\4'g\R4hVPF pWC9gKVPV,W4&K"	VP!V.VO5/VB#)aJSimilar 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.)rPr4rIr�rB)rArPr�r>rcs&&*, r:�forward�Context.forwards\���%��)�)��8�9�9��]�]�E��"� &�
�
�e� 4��
�#��}�}�U�4�T�4�V�4�4r<c�*<�V^8�dQhRS[RS[RR/#)r/rF�sourcer3N)r5r)r9r�s"�r:r;r�)s"���.�.��.�o�.�$�.r<c�"�W PV&R#)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�rFrUs&&&r:�set_parameter_source�Context.set_parameter_source)s��(.���t�$r<c�J<�V^8�dQhRS[RS[PS[,/#)r/rFr3)r5r6rer)r9r�s"�r:r;r�2s$���0�0��0����O�1L�0r<c�8�VPPV4#)aGet 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�rFs&&r:�get_parameter_source�Context.get_parameter_source2s�� �%�%�)�)�$�/�/r<c�H<�V^8�dQh/S[PR,;R&#)r/rr�)r6r�)r9r�s"�r:r;r��s����D�V�V�O�,�<�Er<)r�r�r�r�r�r�r�r�r�r�r�r@r�r�r�r�r�r�r�r�r�r�r�r�r�r�)NNNNNNNFNNNNNNN�T�.�r)'rSr�r�r�r�rr�r�r�r�r�rr��propertyr�r�r�r�r�r�rr
rr6�overloadrr$r(r-r1r5r9rBrRrWr[�__annotate_func__r��__classdictcell__�r�s@r:r1r1�s�����\�B0=�O�j'�j'�X
�
�*��
	�	��#!�#!��#!�J����6
�
�?�?�:
,�
,�'�'�����$��
�
����Z�Z� � �� ��Z�Z�@�@��@���((�(�����,�,�+�+�H�H��Z�Z�����Z�Z����33�33�j5�5�&.�.�0�0�S�r<r1c�a�]tRtRtoRt]tRtRtRt	R$V3RlRllt
V3RlR	ltV3R
lRltV3RlR
lt
V3RlRltR$V3RlRlltV3RlRltV3RlRltV3RlRlt]P(R%V3RlRll4t]P(R&V3RlRll4tR'V3RlRlltR$V3RlRlltV3R lR!ltV3R"ltR#tVtR#)(�BaseCommandiEaeThe 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.
FTNc�<�V^8�dQhRS[PS[,RS[PS[PS[S[P3,,RR/#)r/rF�context_settingsr3N)r6rer5r�r�)r9r�s"�r:r;�BaseCommand.__annotate__fsR���O�O��j�j��o�O��*�*�Q�%5�%5�c�1�5�5�j�%A�B�O�
�	Or<c�*�WnVf/pW nR#r])rFri)r�rFris&&&r:r��BaseCommand.__init__fs���	��#�!��?O�r<c�d<�V^8�dQhRS[RS[PS[S[P3,/#�r/r0r3�r1r6r�r5r�)r9r�s"�r:r;rjws,���#�#��#�A�F�F�3����:�,>�#r<c��RVP/#)a1Gather information that could be useful for a tool generating
user-facing documentation. This traverses the entire structure
below this command.

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

:param ctx: A :class:`Context` representing this command.

.. versionadded:: 8.0
rF�rF�r�r0s&&r:r��BaseCommand.to_info_dictws����	�	�"�"r<c� <�V^8�dQhRS[/#r�r�)r9r�s"�r:r;rj�����:�:�#�:r<c�P�RVPPRVPR2#��<r��>��	__class__rSrFr�s&r:�__repr__�BaseCommand.__repr__��&���4�>�>�*�*�+�1�T�Y�Y�K�q�9�9r<c�&<�V^8�dQhRS[RS[/#rn�r1r5)r9r�s"�r:r;rj�s���D�D�W�D��Dr<c��\R4h)zBase commands cannot get usage��NotImplementedErrorrrs&&r:r1�BaseCommand.get_usage�s��!�"B�C�Cr<c�&<�V^8�dQhRS[RS[/#rnr�)r9r�s"�r:r;rj�s���C�C�G�C��Cr<c��\R4h)zBase commands cannot get helpr�rrs&&r:r5�BaseCommand.get_help�s��!�"A�B�Br<c
�<�V^8�dQhRS[PS[,RS[PS[,RS[PS[,RS[P
RS[/#)r/r�r�r��extrar3)r6rer5r[r1r�)r9r�s"�r:r;rj�sZ���(�(��:�:�c�?�(��f�f�S�k�(��
�
�7�#�	(�
���(�
�
(r<c�"�VPP4FwrVWT9gK
WdV&K	VP!V3RVRV/VBpVPRR7;_uu_4VP	Wr4RRR4V# +'giT#;i)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�r�F�r�N)ri�items�
context_classr��
parse_args)r�r�r�r�r�r{rr0s&&&&,   r:�make_context�BaseCommand.make_context�s���6�/�/�5�5�7�J�C���"�c�
�8�� � ��
��
��
��	
���Y�Y�u�Y�
%�
%��O�O�C�&�&��
�&�
%��
�s�!A=�=B	c�t<�V^8�dQhRS[RS[PS[,RS[PS[,/#�r/r0r�r3�r1r6r[r5)r9r�s"�r:r;rj�s7���W�W�g�W�Q�V�V�C�[�W�Q�V�V�C�[�Wr<c��\R4h)z�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`.
z1Base commands do not know how to parse arguments.r�)r�r0r�s&&&r:r��BaseCommand.parse_args�s��
"�"U�V�Vr<c�:<�V^8�dQhRS[RS[P/#rn�r1r6r�)r9r�s"�r:r;rj�s#���P�P�'�P�a�e�e�Pr<c��\R4h)zkGiven a context, this invokes the command.  The default
implementation is raising a not implemented error.
z*Base commands are not invocable by defaultr�rrs&&r:rB�BaseCommand.invoke�s��"�"N�O�Or<c�N<�V^8�dQhRS[RS[RS[PR,/#�r/r0r2r3r*�r1r5r6r[)r9r�s"�r:r;rj�s,�����'��s��q�v�v�FV�?W�r<c�aa�^RIHo.pSPeuSPo\SP\
4'gK<SPP'gKZVPVV3Rl\SV444K�V#)a�Return a list of completions for the incomplete value. Looks
at the names of chained multi-commands.

Any command could be part of a chained multi-command, so sibling
commands are valid at any point during command completion. Other
command classes will return more completions.

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

.. versionadded:: 8.0
r)c3�|<"�TF1wrVSP9gKS!WP4R7x�K3	R#5i���helpN)r��get_short_help_str)�.0rFr@r*r0s&  ��r:�	<genexpr>�-BaseCommand.shell_complete.<locals>.<genexpr>�s<�����)T�
���3�#5�#5�5�L�N�4�.H�.H�.J�K�K�)T�s�<�<)	�click.shell_completionr*r�rPr@r?rOr�rG)r�r0r2�resultsr*s&f& @r:�shell_complete�BaseCommand.shell_complete�sg���	:�*,���j�j�$��*�*�C��#�+�+�|�4�4����9J�9J�9J�����)C�C��)T����r<c��<�V^8�dQhRS[PS[PS[,,RS[PS[,RS[PS[,RRRS[PRR/#)	r/r��	prog_name�complete_var�standalone_moderr�r3r")r6rerlr5r�)r9r�s"�r:r;rj�sl������j�j����C��)���:�:�c�?���j�j��o�	�
,�����
�
�r<c��R#r]r��r�r�r�r�r�r�s&&&&&,r:�main�BaseCommand.main�s��r<c�<�V^8�dQhRS[PS[PS[,,RS[PS[,RS[PS[,RS[RS[P
RS[P
/#)r/r�r�r�r�r�r3�r6rerlr5rMr�)r9r�s"�r:r;rj�sp������j�j����C��)���:�:�c�?���j�j��o�	�
�����
�
���r<c��R#r]r�r�s&&&&&,r:r�r��s��r<c�<�V^8�dQhRS[PS[PS[,,RS[PS[,RS[PS[,RS[RS[RS[P
RS[P
/#)r/r�r�r�r��windows_expand_argsr�r3r�)r9r�s"�r:r;rj�s����o�o��j�j����C��)�o��:�:�c�?�o��j�j��o�	o�
�o�"�
o����o�
���or<c���VfA\PR,p\PR8XdV'd\	V4pM\V4pVf\
4pVPWbV4VP!W!3/VB;_uu_4pVPV4pV'g
VuuRRR4#VP4RRR4R# +'giR#;i \\3d+p	\\PR7\4T	hRp	?	i\ dEp	T'ghT	P#4\P!T	P$4Rp	?	R#Rp	?	i\&d�p	T	P(\(P*8Xd�\,P.!\,P0\3\P444\n\,P.!\,P0\3\P44\n\P!^4Rp	?	R#hRp	?	ii;i \6dEp	T'd'\P!T	P$4Rp	?	R#T	P$uRp	?	#Rp	?	i\dHT'gh\\9R4\PR7\P!^4R#i;i)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.
N�r�NN�nt)�filezAborted!)�sys�argv�osrFr"r^r!�_main_shell_completionr�rBr-�EOFError�KeyboardInterruptr#�stderrr
r�show�	exit_code�OSError�errno�EPIPEr6r>�TextIOr&�stdoutrr�)
r�r�r�r�r�r�r�r0r�rgs
&&&&&&,   r:r�r��s���f�<��8�8�B�<�D��w�w�$��#6�#�D�)�����:�D���,�.�I�	
�#�#�E�l�C�.	�
��&�&�y�@�%�@�@�C����S�)�B�*�!�A�@��H�H�J�A�@�@�@���/�0�
%��#�*�*�%��g�1�$��!�
&�&������������%�%���
��7�7�e�k�k�)�!"������2D�S�Z�Z�2P�!Q�C�J�!"������2D�S�Z�Z�2P�!Q�C�J��H�H�Q�K�K���

���	#��������%�%��{�{�"���	�"����:��S�Z�Z�0��H�H�Q�K�		�s��2C!�
C
�(
C!�3C
�C!�
C	�C!�C!�!H=�2%D�H=�$H=�%9E$�I�$H=�1H=�2B?H8�1I�7H8�8H=�=I�K�(J
�9J
�K�
K�K� ;K�Kc�<�V^8�dQhRS[PS[S[P3,RS[RS[PS[,RR/#)r/�ctx_argsr�r�r3N)r6r�r5r�re)r9r�s"�r:r;rjgsN������"�"�3����:�.�����j�j��o�	�

�r<c��Vf7VPRR4PRR4pRVR2P4p\PP	V4pV'gR#^RIHpV!WW#V4p\P!V4R#)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��.�	_COMPLETE)r�)	r�r�r��environr��shell_completionr�r�r-)r�r�r�r��
complete_name�instructionr�r�s&&&&    r:r��"BaseCommand._main_shell_completiongst��$��%�-�-�c�3�7�?�?��S�I�M��}�o�Y�7�=�=�?�L��j�j�n�n�\�2����4�
�D�I�[�
Q������r<c�h<�V^8�dQhRS[PRS[PRS[P/#)r/r�r>r3rE)r9r�s"�r:r;rj�s.���*�*�a�e�e�*�q�u�u�*����*r<c�&�VP!V/VB#)zAlias for :meth:`main`.)r��r�r�r>s&*,r:�__call__�BaseCommand.__call__�s���y�y�$�)�&�)�)r<c�J<�V^8�dQh/S[PS[,;R&#)r/r�)r6r�r1)r9r�s"�r:r;rjEs����2�6�6�'�?�,�3r<)rirFr])NNNT)NNN.)NNNTT)rSr�r�r�r�r1r�r�r�r�r�r�r|r1r5r�r�rBr�r6rbr�r�r�rcr�rdres@r:rgrgEs������0&-�M���"��"��O�O�"#�#�:�:�D�D�C�C�(�(�TW�W�P�P���:�Z�Z������Z�Z�����o�o�b��@*�*�E
�r<rgc�aa�]tRtRtoRtR(V3RlV3RllltV3RlV3RlltV3RlRltV3R	lR
ltV3RlRlt	V3R
lRlt
V3RlRltV3RlRltV3RlRlt
V3RlRltR)V3RlRlltV3RlRltV3RlRltV3RlRltV3RlR ltV3R!lR"ltV3R#lR$ltV3R%lV3R&lltR'tVtV;t#)*r4i�ajCommands 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: issues a message indicating that
                         the command is deprecated.

.. 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.
c�"<�V^8�dQhRS[PS[,RS[PS[PS[S[P3,,RS[PS[P
RS[P3,,RS[PS[PR,,RS[PS[,RS[PS[,R	S[PS[,R
S[PS[,RS[RS[R
S[RS[RR/
#)r/rFrir�.r�rdr��epilog�
short_help�options_metavar�add_help_option�no_args_is_helprD�
deprecatedr3N)r6rer5r�r�r�r[rM)r9r�s"�r:r;�Command.__annotate__�s����%�%��j�j��o�%��*�*�Q�%5�%5�c�1�5�5�j�%A�B�%��*�*�Q�Z�Z��Q�U�U�
�3�4�	%�
�
�
�1�6�6�+�.�/�%��j�j��o�
%��
�
�3��%��J�J�s�O�%����C��%��%��%��%��%�
�%r<c
��<�\S
V`W4W0nT;'g.VnWPnW`nW�nWpnW�nRVn	W�n
W�nW�nR#r])
�superr�r�r�r�r�r�r�r��_help_optionr�rDr�)r�rFrir�r�r�r�r�r�r�r�rDr�r{s&&&&&&&&&&&&&�r:r��Command.__init__�s[���	����0�!�
�*0���2����	���.��$��.��48���.����$�r<c�d<�V^8�dQhRS[RS[PS[S[P3,/#rnro)r9r�s"�r:r;r��s,���
�
��
�A�F�F�3����:�,>�
r<c	�<�\SV`V4pTPVPV4Uu.uFq3P4NK	upVPVP
VPVPVPR7V#uupi))r�r�r�r�rDr�)	r�r�rMr�r�r�r�rDr�)r�r0�	info_dictrcr{s&&  �r:r��Command.to_info_dict�sz����G�(��-�	����6:�o�o�c�6J�K�6J�U�&�&�(�6J�K�����;�;�����;�;����
	�	
����Ls�Bc�&<�V^8�dQhRS[RS[/#rnr�)r9r�s"�r:r;r��s���1�1�W�1��1r<c��VP4pVPW4VP4PR4#)z]Formats the usage line into a string and returns it.

Calls :meth:`format_usage` internally.
�
)r��format_usage�getvalue�rstrip�r�r0�	formatters&& r:r1�Command.get_usage�s:��
�&�&�(�	����#�)��!�!�#�*�*�4�0�0r<c�H<�V^8�dQhRS[RS[PR,/#)r/r0r3rd)r1r6r[)r9r�s"�r:r;r��s$�����g��!�&�&��*=�r<c�T�VPpVPV4pVe.VOVNpV#r])r��get_help_option)r�r0r��help_options&&  r:r��Command.get_params�s5��
�[�[���*�*�3�/���"�#�2�#�{�#�B��	r<c�*<�V^8�dQhRS[RS[RR/#�r/r0r�r3N�r1r)r9r�s"�r:r;r��s'���B�B��B�M�B�d�Br<c�~�VPV4pVPVPRPV44R#)zcWrites 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�r0r��piecess&&& r:r��Command.format_usage�s3��
�*�*�3�/�����c�.�.�����0@�Ar<c�J<�V^8�dQhRS[RS[PS[,/#rnr�)r9r�s"�r:r;r��s#���	�	��	�A�F�F�3�K�	r<c��VP'dVP.M.pVPV4F#pVPVPV44K%	V#)zXReturns all the pieces that go into the usage line and returns
it as a list of strings.
)r�r�r�r�)r�r0r�rcs&&  r:r��Command.collect_usage_pieces�sP��(,�';�';�';�d�"�"�
#����_�_�S�)�E��I�I�e�,�,�S�1�2�*��	r<c�J<�V^8�dQhRS[RS[PS[,/#rnr�)r9r�s"�r:r;r�s#�������Q�V�V�C�[�r<c���\VP4pVPF9pVPVP4VPVP
4K;	\
V4#)z&Returns the names for the help option.)r�r�r��difference_update�opts�secondary_optsr^)r�r0�	all_namesrcs&&  r:�get_help_option_names�Command.get_help_option_namessR����-�-�.�	��[�[�E��'�'��
�
�3��'�'��(<�(<�=�!��I��r<c�H<�V^8�dQhRS[RS[PR,/#)r/r0r3�Option)r1r6re)r9r�s"�r:r;r�s$���!�!�7�!�q�z�z�(�/C�!r<c��VPV4pV'dVP'gR#VPf^RIHpV!V4VnVP#)z�Returns the help option object.

Unless ``add_help_option`` is ``False``.

.. versionchanged:: 8.1.8
    The help option is now cached to avoid creating it multiple times.
Nr')r	r�r��
decoratorsr()r�r0�help_optionsr(s&&  r:r��Command.get_help_optionsO���1�1�#�6���4�#7�#7�#7�����$�.� *�<� 8�D��� � � r<c�&<�V^8�dQhRS[RS[/#rn)r1r)r9r�s"�r:r;r�)s�����w��<�r<c�n�\V4pVPV4FpVPW!4K	V#)z6Creates the underlying option parser for this command.)rr��
add_to_parser)r�r0�parserrcs&&  r:�make_parser�Command.make_parser)s2���c�"���_�_�S�)�E�����,�*��
r<c�&<�V^8�dQhRS[RS[/#rnr�)r9r�s"�r:r;r�0s���1�1�G�1��1r<c��VP4pVPW4VP4PR4#)zVFormats the help into a string and returns it.

Calls :meth:`format_help` internally.
r�)r��format_helpr�r�r�s&& r:r5�Command.get_help0s:��
�&�&�(�	�����(��!�!�#�*�*�4�0�0r<c�&<�V^8�dQhRS[RS[/#)r/�limitr3)rZr5)r9r�s"�r:r;r�9s�������S�r<c�8�VP'd"\P!VP4pM+VP'd\	VPV4pMRpVP
'd\
R4PVR7pVP4#)zPGets short help for the command or makes it by shortening the
long help string.
r��(Deprecated) {text}��text)	r��inspect�cleandocr�r$r�r�r9�strip)r�rr s&& r:r��Command.get_short_help_str9sm���?�?�?��#�#�D�O�O�4�D�
�Y�Y�Y�*�4�9�9�e�<�D��D��?�?�?��*�+�2�2��2�=�D��z�z�|�r<c�*<�V^8�dQhRS[RS[RR/#r�r�)r9r�s"�r:r;r�Is"���+�+�w�+�=�+�T�+r<c��VPW4VPW4VPW4VPW4R#)z�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��format_help_text�format_options�
format_epilogr�s&&&r:r�Command.format_helpIs<��	
���#�)����c�-����C�+����3�*r<c�*<�V^8�dQhRS[RS[RR/#r�r�)r9r�s"�r:r;r�Zs"���+�+�G�+�
�+�$�+r<c��VPe8\P!VP4PR4^,pMRpVP'd\R4P
VR7pV'dEVP4VP4;_uu_4VPV4RRR4R#R# +'giR#;i)z3Writes the help text to the formatter if it exists.N�r�rr)
r�r!r"�	partitionr�r�r9�write_paragraph�indentation�
write_text)r�r0r�r s&&& r:r'�Command.format_help_textZs����9�9� ��#�#�D�I�I�.�8�8��>�q�A�D��D��?�?�?��*�+�2�2��2�=�D���%�%�'��&�&�(�(��$�$�T�*�)�(��)�(�(�s�%C�C	c�*<�V^8�dQhRS[RS[RR/#r�r�)r9r�s"�r:r;r�ks"���
)�
)�'�
)�m�
)��
)r<c�>�.pVPV4F+pVPV4pVfKVPV4K-	V'd?VP\	R44;_uu_4VPV4RRR4R#R# +'giR#;i)z8Writes all the options into the formatter if they exist.N�Options)r��get_help_record�append�sectionr��write_dl)r�r0r�rrcr�s&&&   r:r(�Command.format_optionsksy�����_�_�S�)�E��&�&�s�+�B��~����B��*�
��"�"�1�Y�<�0�0��"�"�4�(�1�0��0�0�0�s�-B�B	c�*<�V^8�dQhRS[RS[RR/#r�r�)r9r�s"�r:r;r�ws"���-�-��-�]�-�t�-r<c��VP'de\P!VP4pVP4VP	4;_uu_4VPV4RRR4R#R# +'giR#;i)z2Writes the epilog into the formatter if it exists.N)r�r!r"r/r0r1)r�r0r�r�s&&& r:r)�Command.format_epilogwsa���;�;�;��%�%�d�k�k�2�F��%�%�'��&�&�(�(��$�$�V�,�)�(�	�)�(�(�s�A9�9B
	c�t<�V^8�dQhRS[RS[PS[,RS[PS[,/#r�r�)r9r�s"�r:r;r��s2�����g��Q�V�V�C�[��Q�V�V�C�[�r<c
���V'gZVP'dHVP'g6\VP4VPR7VP4VP
V4pVPVR7wrBp\WPPV44FpVPWV4wrrK	V'dwVP'geVP'gSVP\RR\V44PRP!\#\$V44R74W!nVP(P+VP(4V#)�r�)r�z&Got unexpected extra argument ({args})z'Got unexpected extra arguments ({args})r�)r�r�r#r5r�r-rr�r}r��handle_parse_resultr�r$r�lenr9r��mapr5r�r�rM)r�r0r�rr�param_orderrcrs&&&     r:r��Command.parse_args�s����,�,�,�S�5J�5J�5J������s�y�y�1��H�H�J��!�!�#�&��"(�"3�"3��"3�">���K�/��_�_�S�=Q�R�E��3�3�C�t�D�K�E�4�S���,�,�,�S�5J�5J�5J��H�H��<�=���I���&�c�h�h�s�3��~�6�&�7�
������ � ��!5�!5�6��r<c�:<�V^8�dQhRS[RS[P/#rnr�)r9r�s"�r:r;r��s���;�;�'�;�a�e�e�;r<c��VP'd>\R4PVPR7p\	\VRR7RR7VPe(VP!VP3/VPB#R#)zUGiven a context, this invokes the attached callback (if it exists)
in the right way.
z7DeprecationWarning: The command {name!r} is deprecated.rq�red)�fgT)�errN)	r�r�r9rFr#r r�rBr�)r�r0r!s&& r:rB�Command.invoke�sk���?�?�?��I���f�$�)�)�f�$�
�
��w�5�)�t�4��=�=�$��:�:�d�m�m�:�s�z�z�:�:�%r<c�N<�V^8�dQhRS[RS[RS[PR,/#r�r�)r9r�s"�r:r;r��s,���!�!�'�!�s�!�q�v�v�FV�?W�!r<c�<aaa�^RIHo.pS'd�S^,P4'g�VPV4F�o\	S\
4'dRSP'g@SP'g0VPSP4\PJdKlVPVVV3Rl.SPOSPO44K�	VP\SV`AVS44V#)z�Return a list of completions for the incomplete value. Looks
at the names of options and chained multi-commands.

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

.. versionadded:: 8.0
r)c3�~<"�TF2pVPS4'gKS!VSPR7x�K4	R#5ir�)rBr�)r�rFr*r2rcs& ���r:r��)Command.shell_complete.<locals>.<genexpr>�s4����� D�����z�2�:�N�4�e�j�j�9�9� D�s�=�=)r�r*�isalnumr�rPrrD�multipler[rFrr�r�rrr�r�)r�r0r2r�r*rcr{s&&f @@�r:r��Command.shell_complete�s����	:�*,���j��m�3�3�5�5�����-��"�5�&�1�1��|�|�|�!�N�N�N��4�4�U�Z�Z�@�*�6�6�7������ D�%�*�*� D�u�/C�/C� D���.�$	���u�w�-�c�:�>�?��r<)r�r�r�r�r�r�rDr�r�r�r�)NNNNNNz	[OPTIONS]TFFF)�-)rSr�r�r�r�r�r�r1r�r�r�r	r�rr5r�rr'r(r)r�rBr�r�rd�
__classcell__�r{r�s@@r:r4r4�s�����'�R%�%�B
�
�1�1���B�B�	�	���!�!�2��1�1��� +�+�"+�+�"
)�
)�-�-���0;�;�!�!�!r<r4c�<aa�]tRtRtoRtRtRtRV3RlV3RllltV3RlV3RlltV3R	lV3R
llt	V3RlV3Rllt
RV3R
lRlltV3RlRltV3RlV3Rllt
V3RlV3RlltV3RlRltV3RlRltV3RlRltV3RlV3RlltRtVtV;t#) r?i�aJA 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. This can be set or changed later with the
    :meth:`result_callback` decorator.
:param attrs: Other command arguments described in :class:`Command`.
TFc�(<�V^8�dQhRS[PS[,RS[RS[PS[,RS[PS[,RS[RS[PS[PRS[P
3,,RS[P
R	R
/#)r/rF�invoke_without_commandr��subcommand_metavarrO�result_callback.�attrsr3N)r6rer5rMr�r�)r9r�s"�r:r;�MultiCommand.__annotate__�s����$�$��j�j��o�$�!%�$����D�)�	$�
�J�J�s�O�$��
$����A�J�J�s�A�E�E�z�$:�;�$����$�
�$r<c�V<�\S	V`!V3/VBVfV'*pW0nW nVfV'dRpMRpW@nWPnW`nVP
'dKVPF8p\V\4'gKVP'dK/\R4h	R#R#)Nz*COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...zCOMMAND [ARGS]...z<Multi commands in chain mode cannot have optional arguments.)r�r�r�rXrYrO�_result_callbackr�rP�Argument�requiredrQ)
r�rFrXr�rYrOrZr[rcr{s
&&&&&&&, �r:r��MultiCommand.__init__�s����	����'��'��"�"8�8�O�.��&<�#��%��%Q�"�%8�"�"4���
�!0���:�:�:������e�X�.�.�u�~�~�~�&�/���%�r<c�d<�V^8�dQhRS[RS[PS[S[P3,/#rnro)r9r�s"�r:r;r\s,�������A�F�F�3����:�,>�r<c�v<�\SV`V4p/pVPV4FapVPW4pVfKVP	V4pVPRR7;_uu_4VPV4W4&RRR4Kc	VP
W0PR7V# +'giK�;i)NFr�)�commandsrO)r�r�rArCr9r�rMrO)r�r0r�rdrFr@�sub_ctxr{s&&     �r:r��MultiCommand.to_info_dicts�����G�(��-�	����&�&�s�+�D��&�&�s�1�G�����+�+�G�4�G����u��-�-�!(�!5�!5�g�!>���.�-�,�	���(�*�*��=���	.�-�-�s�)B'�'B8c�J<�V^8�dQhRS[RS[PS[,/#rnr�)r9r�s"�r:r;r\s#�������A�F�F�3�K�r<c�\<�\SV`V4pVPVP4V#r])r�r�r7rY)r�r0r�r{s&& �r:r��!MultiCommand.collect_usage_piecess)���
�W�
)�#�
.��
�	�	�$�)�)�*��	r<c�*<�V^8�dQhRS[RS[RR/#r�r�)r9r�s"�r:r;r\#s"���-�-�'�-�m�-��-r<c�H<�\SV`W4VPW4R#r])r�r(�format_commands)r�r0r�r{s&&&�r:r(�MultiCommand.format_options#s���
���s�.����S�,r<c�R<�V^8�dQhRS[RS[PS[.S[3,/#)r/r�r3)rMr6r�r+)r9r�s"�r:r;r\'s*���+�+�t�+��
�
�A�3��6�8J�+r<c�aa�RVV3RllpV#)aAdds 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
c�0�V^8�dQhR\R\/#)r/r�r3)r+)r9s"r:r;�2MultiCommand.result_callback.<locals>.__annotate__Ds��	�	��	�q�	r<c�<aa�SPoSe	S'd
SSnS#VV3Rlp\\P!\V4S4;SnpV#)Nc�4<�S!V.VO5/VBpS!V.VO5/VB#r]r�)�_MultiCommand__valuer�r>�innerr��old_callbacks&*, ��r:�function�AMultiCommand.result_callback.<locals>.decorator.<locals>.functionKs,���$�W�>�t�>�v�>����0��0��0�0r<)r^rr6r>r+)r�rwr�rvr�r�sf  @��r:�	decorator�/MultiCommand.result_callback.<locals>.decoratorDsN����0�0�L��#�w�()��%���
1�*8����q�(�8K�Q�)O�O�D�!�B��Ir<r�)r�r�rysff r:rZ�MultiCommand.result_callback's���:	�	��r<c�*<�V^8�dQhRS[RS[RR/#r�r�)r9r�s"�r:r;r\Ts"���-�-�7�-�}�-��-r<c�B�.pVPV4F@pVPW4pVfKVP'dK.VPWE34KB	\	V4'd�VP
^,
\
RV44,
p.pVF(wrEVPV4pVPWH34K*	V'd?VP\R44;_uu_4VPV4RRR4R#R#R# +'giR#;i)zUExtra format methods for multi methods that adds all the commands
after the options.
Nc3�F"�TFp\V^,4x�K	R#5i)rN�rB)r�rKs& r:r��/MultiCommand.format_commands.<locals>.<genexpr>es���-N�X�c�c�#�a�&�k�k�X�s�!�Commands)rArCrDr7rBr��maxr�r8r�r9)	r�r0r�rd�
subcommandrKr�rowsr�s	&&&      r:rl�MultiCommand.format_commandsTs������,�,�S�1�J��"�"�3�3�C��{���z�z�z���O�O�Z�-�.�2��x�=�=��O�O�a�'�#�-N�X�-N�*N�N�E��D�#+��
��-�-�e�4�����Z�.�/�$,���&�&�q��}�5�5��&�&�t�,�6�5���6�5�5�s�-D
�
D	c�t<�V^8�dQhRS[RS[PS[,RS[PS[,/#r�r�)r9r�s"�r:r;r\ps2���
�
�g�
�Q�V�V�C�[�
�Q�V�V�C�[�
r<c�<�V'gZVP'dHVP'g6\VP4VPR7VP4\SV`W4pVP'dW1n	.Vn
VP#V'dVR,VR,uVn	Vn
VP#)r@�Nr�Nr�)r�r�r#r5r�r-r�r�rOr�r�)r�r0r��restr{s&&& �r:r��MultiCommand.parse_argsps������,�,�,�S�5J�5J�5J������s�y�y�1��H�H�J��w�!�#�,���:�:�:�!%���C�H��x�x���+/��8�T�"�X�(�C�����x�x�r<c�:<�V^8�dQhRS[RS[P/#rnr�)r9r�s"�r:r;r\s#���B'�B'�'�B'�a�e�e�B'r<c
�T<aa�RVV3RllpSP'gmSP'dAS;_uu_4\S	S`
S4pT!SP'd.MT4uuRRR4#SP\
R44.SPOSPOp.Sn.SnSP'g�S;_uu_4SPSV4wrVpVfQhVSn	\S	S`
S4VPWTSR7pV;_uu_4V!VPPV44uuRRR4uuRRR4#S;_uu_4V'dRMRSn	\S	S`
S4.pV'dXSPSV4wrVpVfQhVPVVSRRR7pVPV4VP.uqGnK_.pVF@pV;_uu_4VPVPPV44RRR4KB	V!V4uuRRR4# +'giEL�;i +'giM;iRRR4EK +'giEL*;i +'giK�;i +'giR#;i)	c�X�V^8�dQhR\PR\P/#�r/rr3rE)r9s"r:r;�)MultiCommand.invoke.<locals>.__annotate__�s"��	�	�1�5�5�	�Q�U�U�	r<c�t<�SPe)SP!SPV3/SPBpV#r])r^rBr��rr0r�s&��r:�_process_result�,MultiCommand.invoke.<locals>._process_result�s3����$�$�0��
�
�4�#8�#8�%�N�3�:�:�N���Lr<NzMissing command.r�*TF)r�r�r�)
r�rXr�rBrOr$r�r��resolve_commandr�r�r@r7)
r�r0r�r�r�rJrKre�contextsr{s
ff       �r:rB�MultiCommand.invokes!���	�	�
�!�!�!��*�*�*��S�����,�B�*�����2��D��S�
�H�H�Q�)�*�+�0��#�#�/�c�h�h�/��������
�z�z�z���&*�&:�&:�3��&E�#��t���&��)1��&����s�#��*�*�8�#�*�F���W�*�7�?�?�+A�+A�'�+J�K��W�
���S�,0�S�d�C�"��G�N�3��
�H��&*�&:�&:�3��&E�#��t���&���*�*����%)�,1�+�������(�%,�\�\�2�"��l��B�#���W��I�I�g�o�o�4�4�W�=�>��W�$�#�2�&�3�S�=�S�S��,�W��W�
�����J�W�W��/�S�S�s[�+H;�AI.�!I	�
I.�*J�
A(J�2+J�J�;I	�I
�I.�.I?	�J�
	J�J'	c
��<�V^8�dQhRS[RS[PS[,RS[PS[P
S[,S[P
S[,S[PS[,3,/#r�)r1r6r[r5r8rer4)r9r�s"�r:r;r\�sV���8�8��8�"#�&�&��+�8�	
������C��!�*�*�W�"5�q�v�v�c�{�B�	C�8r<c���\V^,4pTpVPW4pVf1VPe#VPV4pVPW4pVfpVP'g^\	V4^,'dVPWP4VP\R4PVR74V'dTMRWRR,3#)rNzNo such command {name!r}.rqr�)
r%rCr�r�rr�r�r$r�r9)r�r0r�rJ�original_cmd_namerKs&&&   r:r��MultiCommand.resolve_command�s����D��G�$��$�����s�-���;�3�3�3�?��/�/��9�H��"�"�3�1�C��;�s�4�4�4���"�1�%�%�����X�X�.��H�H�Q�2�3�:�:�@Q�:�R�S��x�D�#�B�x�7�7r<c�P<�V^8�dQhRS[RS[RS[PS[,/#�r/r0rJr3�r1r5r6rer4)r9r�s"�r:r;r\�s+���"�"�w�"�#�"�!�*�*�W�:M�"r<c��\h)zkGiven a context and a command name, this returns a
:class:`Command` object if it exists or returns `None`.
r��r�r0rJs&&&r:rC�MultiCommand.get_command�s
��"�!r<c�J<�V^8�dQhRS[RS[PS[,/#rnr�)r9r�s"�r:r;r\�s#�������Q�V�V�C�[�r<c��.#)zDReturns a list of subcommand names in the order they should
appear.
r�rrs&&r:rA�MultiCommand.list_commands�s	���	r<c�N<�V^8�dQhRS[RS[RS[PR,/#r�r�)r9r�s"�r:r;r\�s,�����'��s��q�v�v�FV�?W�r<c	��<�^RIHp\W4UUu.uFwrEV!WEP4R7NK	pppVP	\
SV`W44V#uuppi)aReturn 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
r)r�)r�r*rGr�r�r�r�)r�r0r2r*rFr@r�r{s&&&    �r:r��MultiCommand.shell_complete�sa���	:�"<�C�!L�
�!L�
��
�4�&@�&@�&B�C�!L�	�
�	���u�w�-�c�>�?����
s�"A)r^rOrXr�rY)NFNNFN�F)rSr�r�r�r�r�r�r�r�r�r(rZrlr�rBr�rCrAr�r�rdrTrUs@@r:r?r?�s������2��#��$�$�L��$��
-�-�+�+�Z-�-�8
�
�B'�B'�H8�8�6"�"�����r<r?c�xaa�]tRtRtoRtRtRtRV3RlV3RllltRV3RlRllt]	PV3RlR	l4t]	PV3R
lRl4tV3RlR
lt]	PV3RlRl4t]	PV3RlRl4tV3RlRltV3RlRlt
V3RlRltV3RltRtVtV;t#)�Groupi�a!A group allows a command to have subcommands attached. This is
the most common way to implement nesting in Click.

:param name: The name of the group command.
:param commands: A dict mapping names to :class:`Command` objects.
    Can also be a list of :class:`Command`, which will use
    :attr:`Command.name` to create the dict.
:param attrs: Other command arguments described in
    :class:`MultiCommand`, :class:`Command`, and
    :class:`BaseCommand`.

.. versionchanged:: 8.0
    The ``commands`` argument can be a list of command objects.
Nc�<�V^8�dQhRS[PS[,RS[PS[PS[PS[S[3,S[PS[,3,,RS[PRR/#)r/rFrdr[r3N)r6rer5rr�r4rlr�)r9r�s"�r:r;�Group.__annotate__"sw���A�A��j�j��o�A��*�*�
�G�G�A�$�$�S�'�\�2�A�J�J�w�4G�G�H�
�A����
A�
�Ar<c��<�\SV`!V3/VBVf/pMK\V\P4'd,VUu/uFqDP
fKVP
VbK!	ppW nR#uupir])r�r�rPrrlrFrd)r�rFrdr[�cr{s&&&, �r:r��Group.__init__"sc���	����'��'����H�
��#�,�,�
/�
/�+3�J�8�a�v�v�	�����	�8�H�J�9A�
��Ks�A-�A-c�N<�V^8�dQhRS[RS[PS[,RR/#)r/rKrFr3N)r4r6rer5)r9r�s"�r:r;r�4s*���"�"�w�"�a�j�j��o�"��"r<c��T;'g
VPpVf\R4h\WVRR7WPV&R#)zsRegisters another :class:`Command` with this group.  If the name
is not provided, the name of the command is used.
NzCommand has no name.T)rL)rFrIrUrd)r�rKrFs&&&r:�add_command�Group.add_command4s>�����s�x�x���<��2�3�3��D��d�;�!�
�
�d�r<c�b<�V^8�dQhRS[PRS[P3,RS[/#)r/�_Group__func.r3�r6r�r�r4)r9r�s"�r:r;r�?s$���E�E�a�j�j��a�e�e��4�E��Er<c��R#r]r��r�r�s&&r:r@�
Group.command>s��BEr<c	�<�V^8�dQhRS[PRS[PRS[PS[PRS[P3,.S[3,/#�r/r�r>r3.)r6r�r�r4)r9r�s"�r:r;r�BsO���<�<��U�U�<�&'�e�e�<�	
���Q�Z�Z��Q�U�U�
�+�,�g�5�	6�<r<c��R#r]r�r�s&*,r:r@r�A���9<r<c
��<�V^8�dQhRS[PRS[PRS[PS[PS[PRS[P3,.S[3,S[3,/#r�)r6r�rr�r4)r9r�s"�r:r;r�Fs]���'�'��U�U�'�&'�e�e�'�	
������Q�Z�Z��Q�U�U�
�3�4�g�=�>��G�	H�'r<c�@aaaa�^RIHoRpS'd>\S^,4'd&\S4^8Xd	S'dQR4hSwpRoSP'd#SPR4fSPSR&RVVVV3RllpVe	V!V4#V#)a�A 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@Nz7Use 'command(**kwargs)(callable)' to provide arguments.�clsc�r�V^8�dQhR\PR\P3,R\/#r�r�)r9s"r:r;�#Group.command.<locals>.__annotate__es+��	�	����C����J�/�	�G�	r<c�F<�S!S/SB!V4pSPV4V#r]�r�)r�rKr�r@r>r�s& ����r:ry� Group.command.<locals>.decoratores*���"�D�3�F�3�A�6�C����S�!��Jr<r�)rr@rrB�
command_classr�)r�r�r>�funcryr@sfjl  @r:r@r�Fs����"	(�37���H�T�!�W�%�%��D�	�Q��v�
I�H�
I�-��G�T��D�����&�*�*�U�"3�";� �.�.�F�5�M�	�	�
���T�?�"��r<c�`<�V^8�dQhRS[PRS[P3,RR/#)r/r�.r3r�r�)r9r�s"�r:r;r�ps$���C�C�A�J�J�s�A�E�E�z�2�C�w�Cr<c��R#r]r�r�s&&r:�group�Group.groupos��@Cr<c	�<�V^8�dQhRS[PRS[PRS[PS[PRS[P3,.R3,/#�r/r�r>r3.r�)r6r�r�)r9r�s"�r:r;r�ssO���<�<��U�U�<�&'�e�e�<�	
���Q�Z�Z��Q�U�U�
�+�,�g�5�	6�<r<c��R#r]r�r�s&*,r:r�r�rr�r<c
��<�V^8�dQhRS[PRS[PRS[PS[PS[PRS[P3,.R3,R3,/#r�)r6r�rr�)r9r�s"�r:r;r�ws]���*�*��U�U�*�&'�e�e�*�	
������Q�Z�Z��Q�U�U�
�3�4�g�=�>��G�	H�*r<c�~aaaa�^RIHoRpS'd>\S^,4'd&\S4^8Xd	S'dQR4hSwpRoSPeFSPR4f3SP\Jd\
S4SR&MSPSR&RVVVV3RllpVe	V!V4#V#)a�A 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�Nz5Use 'group(**kwargs)(callable)' to provide arguments.r�c�j�V^8�dQhR\PR\P3,RR/#)r/r�.r3r�r�)r9s"r:r;�!Group.group.<locals>.__annotate__�s+��	�	����C����J�/�	�G�	r<c�F<�S!S/SB!V4pSPV4V#r]r�)r�rKr�r�r>r�s& ����r:ry�Group.group.<locals>.decorator�s*�����/��/��2�C����S�!��Jr<r�)rr�rrB�group_classr�rR)r�r�r>r�ryr�sfjl  @r:r�r�ws����"	&�37���H�T�!�W�%�%��D�	�Q��v�
G�F�
G�-��G�T��D����'�F�J�J�u�,=�,E����4�'� $�T�
��u�
� $� 0� 0��u�
�	�	�
���T�?�"��r<c�P<�V^8�dQhRS[RS[RS[PS[,/#r�r�)r9r�s"�r:r;r��s+���+�+�w�+�#�+�!�*�*�W�:M�+r<c�8�VPPV4#r])rdr�r�s&&&r:rC�Group.get_command�s���}�}� � ��*�*r<c�J<�V^8�dQhRS[RS[PS[,/#rnr�)r9r�s"�r:r;r��s#���%�%��%�Q�V�V�C�[�%r<c�,�\VP4#r])r|rdrrs&&r:rA�Group.list_commands�s���d�m�m�$�$r<c�<�V^8�dQh/S[PS[PS[,,;R&S[PS[PS[PR,S[PS[,3,,;R&#)r/r�r�r�)r6rer�r4rrR)r9r�s"�r:r;r��sY����*�:�:�a�f�f�W�o�.�5�+�B���A�G�G�A�F�F�7�O�Q�V�V�D�\�$A�B�C�J�Cr<)rd�NNr])rSr�r�r�r�r�r�r�r�r6rbr@r�rCrArcr�rdrTrUs@@r:r�r��s�����
�(26�M�GK�K�A�A�$"�"��Z�Z�E��E��Z�Z�<��<�'�'�R�Z�Z�C��C��Z�Z�<��<�*�*�X+�+�%�%�Q�r<r�c�|aa�]tRtRtoRtRV3RlV3RllltV3RlRltV3RlRltV3R	lR
ltRt	Vt
V;t#)
�CommandCollectioni�aSA 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.

See :class:`MultiCommand` and :class:`Command` for the description of
``name`` and ``attrs``.
c�<�V^8�dQhRS[PS[,RS[PS[PS[,,RS[P
RR/#)r/rF�sourcesr[r3N)r6rer5r[r?r�)r9r�s"�r:r;�CommandCollection.__annotate__�sQ���;�;��j�j��o�;����A�F�F�<�0�1�;����	;�

�;r<c�L<�\SV`!V3/VBT;'g.VnR#r])r�r�r�)r�rFr�r[r{s&&&,�r:r��CommandCollection.__init__�s$���	����'��'�-4�]�]���r<c�$<�V^8�dQhRS[RR/#)r/�	multi_cmdr3N)r?)r9r�s"�r:r;r��s���'�'�L�'�T�'r<c�<�VPPV4R#)z1Adds a new multi command to the chain dispatcher.N)r�r7)r�r�s&&r:�
add_source�CommandCollection.add_source�s�������I�&r<c�P<�V^8�dQhRS[RS[RS[PS[,/#r�r�)r9r�s"�r:r;r��s+���
�
�w�
�#�
�!�*�*�W�:M�
r<c��VPF:pVPW4pVfKVP'd
\WV4Vu#	R#r])r�rCrOrU)r�r0rJrUr�s&&&  r:rC�CommandCollection.get_command�sB���l�l�F��#�#�C�2�B��~��:�:�:�'���;��	�#�r<c�J<�V^8�dQhRS[RS[PS[,/#rnr�)r9r�s"�r:r;r��s#�������Q�V�V�C�[�r<c��\4pVPF#pVPVPV44K%	\	V4#r])r�r�rMrAr|)r�r0r�rUs&&  r:rA�CommandCollection.list_commands�s:������l�l�F��I�I�f�*�*�3�/�0�#��b�z�r<)r�r�)rSr�r�r�r�r�r�rCrAr�rdrTrUs@@r:r�r��s7�����;�;�'�'�
�
���r<r�c��V^8�dQhR\PR\P\P,/#r��r6r�r7)r9s"r:r;r;�s+����q�u�u�����A�E�E�!2�r<c�P�\V\4'd\h\V4#)zlCheck if the value is iterable but not a string. Raises a type
error, or return an iterator over the value.
)rPr5rIr`)rs&r:�_check_iterr��s ���%��������;�r<c�a�]tRtRtoRtRtR0V3RlRlltV3RlRltV3R	lR
ltV3RlRlt	]
V3R
lRl4tV3RlRlt]
PR1V3RlRll4t]
PR2V3RlRll4tR1V3RlRlltV3RlRltV3RlRltV3RlRltV3RlRltV3RlR ltV3R!lR"ltV3R#lR$ltV3R%lR&ltV3R'lR(ltV3R)lR*ltV3R+lR,ltV3R-lR.ltR/tVtR#)3rdi�a�
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.

.. 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.
�	parameterNc�<�V^8�dQhRS[PS[PS[,,RS[PS[PS[PS[P3,,RS[RS[PS[PS[PS[P.S[P3,3,,RS[PS[PS[
RS[P.S[P3,,RS[PS[,RS[R	S[PS[,R
S[RS[RS[PS[PS[S[PS[,3,,R
S[PS[PS[
RS[.S[PS[PR,S[PS[,3,3,,RR/
#)r/�param_declsrRr`�defaultr�rd�nargsrQ�metavarrJrv�envvarr�r*r3N)
r6rerlr5rr�	ParamTyper�rMr�r1rZr[)r9r�s"�r:r;�Parameter.__annotate__-s����V�V��Z�Z��
�
�3��0�V��j�j�������!�%�%�!7�8�9�V��	V�
���A�G�G�A�E�E�1�:�:�b�!�%�%�i�+@�$@�A�B�V��*�*�Q�Z�Z��+�q�u�u�(E�q�u�u�(L�M�N�
V��z�z�#��V��V����C��V��V��V��
�
�1�7�7�3��
�
�3��#7�8�9�V��
�
�
�J�J��+�s�+�������/�0�!�&�&��+�=�>�@�
�
�V�&
�'Vr<c
	��VVVTPT;'gRV	4wVnVnVn\P
!W$4VnVf6VPP'dVPPpM^pW0n	WPn
W`nWpnW�n
W@nW�nW�nW�nW�nVPP'dOW`PP8wd5\'RVPPRVP:RVR24h\)V4'gTMRp
V
esV'd\+\-V
4R4p
V^8wdLV
eF\-V
4T^8�d1\1T
4T8wdT'dRMR	p\'R
TRTR24hR#R#R#R#R# \.d\'R4Rhi;i \.dT'dRpMRp\'T4Rhi;i)
Nz'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=r�)�_parse_declsrFrrr�convert_typerR�is_composite�arityr`r�r�rQrJr�rvr�r��_custom_shell_completerur�nextr�rIrB)r�r�rRr`r�r�r�rQr�rJrvr�r��
check_defaultr!�subjects&&&&&&&&&&&&&   r:r��Parameter.__init__-s���(	
���48�4E�4E����2�|�5
�1��	�4�9�d�1�&+�%7�%7��%F��	��=��y�y�%�%�%��	�	������ �
� �
��
� �
�(���� �
�����&4�#���y�y�%�%�%�%�9�9�?�?�*B� �&�t�y�y���&7�8�!�Y�Y�M��u�g�Q�@���,4�G�+<�+<�G�$�M��(��$�(,�[��-G��(N�
��A�:�-�";�<�#�M�2��q�y�S��%7�5�%@�3;�-���(�(��	�1C�E�7�!�L���&A�y�#<�:�)��
%�$�(�O��#�$�$��%�	<�#�!:�$�
'T�G�(��1�t�;�	<�s�F>�4G�>G�G>�,G>c�^<�V^8�dQhRS[PS[S[P3,/#r�r�)r9r�s"�r:r;r��s%���
�
�a�f�f�S�!�%�%�Z�0�
r<c��RVPRVPRVPRVPRVPP4RVPRVPRVPR	VPR
VP/
#)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
rF�param_type_namerrrRr`r�rQr�r�)rFrrrrRr�r`r�rQr�r�r�s&r:r��Parameter.to_info_dict�su��
�D�I�I��t�3�3��D�I�I��d�1�1��D�I�I�*�*�,���
�
��T�Z�Z���
�
��t�|�|��d�k�k�
�	
r<c� <�V^8�dQhRS[/#r�r�)r9r�s"�r:r;r��rur<c�P�RVPPRVPR2#rwrzr�s&r:r|�Parameter.__repr__�r~r<c
��<�V^8�dQhRS[PS[,RS[RS[PS[P
S[,S[PS[,S[PS[,3,/#�r/�declsrJr3�r6rlr5rMr8rer[)r9r�s"�r:r;r��sU���$�$��Z�Z��_�$�48�$�	
������C��!�&�&��+�q�v�v�c�{�:�	;�$r<c��\4hr]r�)r�rrJs&&&r:r�Parameter._parse_decls�s
��"�#�#r<c� <�V^8�dQhRS[/#r�r�)r9r�s"�r:r;r��s�����S�r<c��VP#)z}Returns the human readable name of this parameter.  This is the
same as the name for options, but the metavar for arguments.
rqr�s&r:�human_readable_name�Parameter.human_readable_name�s��
�y�y�r<c� <�V^8�dQhRS[/#r�r�)r9r�s"�r:r;r��s�����c�r<c���VPe
VP#VPPV4pVf%VPPP	4pVP
^8wd
VR,
pV#)N�...)r�rR�get_metavarrFr�r�)r�r�s& r:�make_metavar�Parameter.make_metavar�s_���<�<�#��<�<���)�)�'�'��-���?��i�i�n�n�*�*�,�G��:�:��?��u��G��r<c�b<�V^8�dQhRS[RRRS[PS[P,/#�r/r0rrr3�r1r6rer�)r9r�s"�r:r;r���2��� � �� �"4� �	
���A�E�E�	� r<c��R#r]r��r�r0rs&&&r:rL�Parameter.get_default�rr<c��<�V^8�dQhRS[RS[RS[PS[PS[P
S[P.S[P
3,3,,/#�r/r0rr3�r1rMr6rerr�r�)r9r�s"�r:r;r���V���@�@��@�"&�@�	
���A�G�G�A�E�E�1�:�:�b�!�%�%�i�#8�8�9�	:�@r<c��R#r]r�r%s&&&r:rLr&�rr<c��<�V^8�dQhRS[RS[RS[PS[PS[P
S[P.S[P
3,3,,/#r(r))r9r�s"�r:r;r��sQ�������"&��	
���A�G�G�A�E�E�1�:�:�b�!�%�%�i�#8�8�9�	:�r<c��VPVPRR7pVf
VPpV'd\V4'dV!4pV#)aEGet 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)rrFr�r)r�r0rrs&&& r:rLr&�sB��.�"�"�4�9�9�5�"�9���=��L�L�E��H�U�O�O��G�E��r<c�*<�V^8�dQhRS[RS[RR/#�r/rr0r3N�rr1)r9r�s"�r:r;r��s"���$�$�L�$�w�$�4�$r<c��\4hr]r��r�rr0s&&&r:r�Parameter.add_to_parser�s��!�#�#r<c�<�V^8�dQhRS[RS[PS[S[P3,RS[P
S[PS[3,/#)r/r0rr3)r1r6�Mappingr5r�r8r)r9r�s"�r:r;r��sH�������"#�)�)�C����J�"7��	
�������'�	(�r<c�P�VPVP4p\PpVf"VP	V4p\P
pVf,VP
VP4p\PpVf"VPV4p\PpW43#r])
r�rFrr��value_from_envvarr�rr�rLr�)r�r0rrrUs&&&  r:�
consume_value�Parameter.consume_value�s���������#�� �,�,���=��*�*�3�/�E�$�0�0�F��=��&�&�t�y�y�1�E�$�0�0�F��=��$�$�S�)�E�$�,�,�F��}�r<c�T<�V^8�dQhRS[RS[PRS[P/#�r/r0rr3r�)r9r�s"�r:r;r��s*���1�1�7�1�1�5�5�1�Q�U�U�1r<c��aaaa�Vf(SP'gSPR8XdR#R#RVV3RlloSP^8XgSPP'dRVV3RlloM(SPR8Xd
RVVV3RlloMRVVV3R	lloSP'd?\;QJd.V3R
lS!V44FNK	5#!V3R
lS!V444#S!V4#)
zeConvert and validate a value against the option's
:attr:`type`, :attr:`multiple`, and :attr:`nargs`.
Nc��V^8�dQhR\PR\P\P,/#r�r�)r9s"r:r;�/Parameter.type_cast_value.<locals>.__annotate__	s+��		�		�a�e�e�		��
�
�1�5�5�(9�		r<c�j<�\V4# \d\\R4SSR7Rhi;i)zValue must be an iterable.�r0rcN)r�rIrr�r�s&��r:�
check_iter�-Parameter.type_cast_value.<locals>.check_iter	sA���
�"�5�)�)���
�#��2�3��D����	
�s�
�$2c�X�V^8�dQhR\PR\P/#r�rE)r9s"r:r;r?	s"��
=�
=�q�u�u�
=����
=r<c�,<�SPVSSR7#))rcr0�rRr�s&��r:�convert�*Parameter.type_cast_value.<locals>.convert	s����y�y��d��y�<�<r<c�X�V^8�dQhR\PR\P/#r�rE)r9s"r:r;r?	s&��
Q�
Q�q�u�u�
Q����
Qr<c�<�\;QJd.VV3RlS!V44FNK	5#!VV3RlS!V444#)c3�J<"�TFpSPVSS4x�K	R#5ir]rF�r��xr0r�s& ��r:r��=Parameter.type_cast_value.<locals>.convert.<locals>.<genexpr>	s#����P�>O��T�Y�Y�q�$��4�4�>O��� #)�tuple�rrBr0r�s&���r:rGrH	s/����u�P�j��>O�P�u�P�u�P�j��>O�P�P�Pr<c�X�V^8�dQhR\PR\P/#r�rE)r9s"r:r;r?	s&��
E�
E�q�u�u�
E����
Er<c	�N<�\S!V44p\V4SP8wdG\\	RR\V44PSP\V4R7SSR7h\;QJd.VV3RlV4FNK	5#!VV3RlV44#)z%Takes {nargs} values but 1 was given.z*Takes {nargs} values but {len} were given.)r�rBrAc3�J<"�TFpSPVSS4x�K	R#5ir]rFrLs& ��r:r�rN&	s!����D�e��T�Y�Y�q�$��4�4�e�rO)rPrBr�rrr9rQs&���r:rGrH	s�����j��/�0���u�:����+�&� �C�H���J��!�&�t�z�z�s�5�z�&�B��"����u�D�e�D�u�D�u�D�e�D�D�Dr<c3�4<"�TF
pS!V4x�K	R#5ir]r�)r�rMrGs& �r:r��,Parameter.type_cast_value.<locals>.<genexpr>)	s����?�->������->�s����r�)rQr�rRrrP)r�r0rrBrGsff&@@r:rK�Parameter.type_cast_value�s�����=�����$�*�*��*:�2�D��D�		�		��:�:��?�d�i�i�4�4�4�
=�
=��Z�Z�2�
�
Q�
Q�

E�
E� �=�=�=��5�?�Z��->�?�5�?�5�?�Z��->�?�?�?��u�~�r<c�:<�V^8�dQhRS[PRS[/#r�)r6r�rM)r9r�s"�r:r;r�-	s�����a�e�e���r<c�j�VfR#VP^8wgVP'd
VR8XdR#R#)NTFr�)r�rQ)r�rs&&r:�value_is_missing�Parameter.value_is_missing-	s)���=���J�J�!�O�t�}�}�}�%�2�+��r<c�T<�V^8�dQhRS[RS[PRS[P/#r<r�)r9r�s"�r:r;r�6	s*���	�	��	����	�1�5�5�	r<c���VPW4pVP'd$VPV4'd
\WR7hVPeVP	WV4pV#)rA)rKr`r[rr�)r�r0rs&&&r:�
process_value�Parameter.process_value6	sU���$�$�S�0���=�=�=�T�2�2�5�9�9�"�s�7�7��=�=�$��M�M�#�U�3�E��r<c�J<�V^8�dQhRS[RS[PS[,/#rn�r1r6rer5)r9r�s"�r:r;r�A	s#�������A�J�J�s�O�r<c�N�VPfR#\VP\4'd7\PPVP4pV'dV#R#VPF.p\PPV4pV'gK,Vu#	R#r])r�rPr5r�r�r�)r�r0r�r�s&&  r:�resolve_envvar_value�Parameter.resolve_envvar_valueA	sy���;�;����d�k�k�3�'�'���������,�B���	���
�+�+���Z�Z�^�^�F�+���2��I�	&�r<c�^<�V^8�dQhRS[RS[PS[P,/#rnr")r9r�s"�r:r;r�S	s(�����W�����A�E�E�1B�r<c��VPV4pVe-VP^8wdVPPV4pV#r])rdr�rR�split_envvar_value)r�r0r�s&& r:r8�Parameter.value_from_envvarS	s:�� $� 9� 9�#� >��
�>�d�j�j�A�o����-�-�b�1�B��	r<c�<�V^8�dQhRS[RS[PS[S[P3,RS[P
S[,RS[PS[PS[P
S[,3,/#)r/r0rr�r3)r1r6r6r5r�r[r8)r9r�s"�r:r;r�[	s`�������"#�)�)�C����J�"7��?@�v�v�c�{��	
���������s��#�	$�r<c��\WR7;_uu_4VPW4wrEVPVPV4VP	W4pRRR4VP'dXVPVP&XV3# \
dTP'ghRpLYi;i +'giLe;i))rcN)	rhr9rWrFr_�	Exceptionr�rJr�)r�r0rr�rrUs&&&&  r:rA�Parameter.handle_parse_result[	s���"�#�
2�
2� �.�.�s�9�M�E��$�$�T�Y�Y��7�
��*�*�3�6��3�����$)�C�J�J�t�y�y�!��d�{����
��,�,�,����	
��
3�
2�s/�0B4�B�B1�+B1�.B4�0B1�1B4�4C	c�t<�V^8�dQhRS[RS[PS[PS[S[3,,/#rn�r1r6rer8r5)r9r�s"�r:r;r�o	s1���
�
�7�
�q�z�z�!�'�'�#�s�(�:K�/L�
r<c��R#r]r�rrs&&r:r6�Parameter.get_help_recordo	s��r<c�J<�V^8�dQhRS[RS[PS[,/#rnr�)r9r�s"�r:r;r�r	s#�����G�����s��r<c��.#r]r�rrs&&r:r��Parameter.get_usage_piecesr	s���	r<c�&<�V^8�dQhRS[RS[/#rnr�)r9r�s"�r:r;r�u	s���7�7�'�7�c�7r<c�t�VP;'gVP.pRPRV44#)zkGet a stringified version of the param for use in error messages to
indicate which param caused the error.
� / c3�."�TFpRVR2x�K
	R#5i)�'Nr�)r�rMs& r:r��+Parameter.get_error_hint.<locals>.<genexpr>z	s���6�I�q�A�a�S��(�I�s�)rrr�)r�r0�	hint_lists&& r:�get_error_hint�Parameter.get_error_hintu	s3���I�I�;�;�$�":�":�!;�	��z�z�6�I�6�6�6r<c�N<�V^8�dQhRS[RS[RS[PR,/#r�r�)r9r�s"�r:r;r�|	s,���?�?�'�?�s�?�q�v�v�FV�?W�?r<c�^�VPe�VPWV4pV'd:\V^,\4'd^RIHpVUu.uF
qT!V4NK	pp\
P!\
PR,V4#VPPWV4#uupi)aXReturn 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
r)r*)
rrPr5r�r*r6r>r[rRr�)r�r0r2r�r*r�s&&&   r:r��Parameter.shell_complete|	s����&�&�2��1�1�#�Z�H�G��:�g�a�j�#�6�6�A�6=�>�g��>�!�,�g��>��6�6�!�&�&�!1�2�G�<�<��y�y�'�'��:�>�>��	?s�B*)rr�r�r�rJrvr�rQrFr�rr`rrR)NNFNNNFNTFNNr^r_)rSr�r�r�r�rr�r�r|rrarrr6rbrLrr9rKr[r_rdr8rAr6r�r|r�r�rdres@r:rdrd�s����G�R"�O�V�V�p
�
�,:�:�$�$�
�������Z�Z� � �� ��Z�Z�@�@��@���B$�$���(1�1�f��	�	���$����(
�
���7�7�?�?r<rdc�paa�]tRtRtoRtRtRV3RlV3RllltV3RlV3RlltV3RlR	ltV3R
lRlt	V3RlR
lt
]PRV3RlRll4t
]PRV3RlRll4t
RV3RlV3Rlllt
V3RlRltV3RlV3RlltV3RlRltV3RlV3RlltRtVtV;t#) ri�	aOptions 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. 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: 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.1.0
    Help text indentation is cleaned here instead of only in the
    ``@option`` decorator.

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

.. versionchanged:: 8.1.0
    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.
�optionc$�V<�V^8�dQhRS[PS[PS[,,RS[PS[S[R3,RS[PS[S[3,RS[PS[S[3,RS[RS[RS[PS[,R	S[PS[P,R
S[RS[RS[R
S[PS[PS[PS[P3,,RS[PS[,RS[RS[RS[RS[PRR/#)r/r�r�Nr�confirmation_prompt�prompt_required�
hide_input�is_flag�
flag_valuerQ�count�allow_from_autoenvrRr�rD�show_choices�show_envvarr[r3)	r6rerlr5rrMr�rr�)r9r�s"�r:r;�Option.__annotate__�	sb���tL�tL��Z�Z��
�
�3��0�tL��g�g�d�C��o�.�tL�����c�	�"�	tL�
�W�W�T�3�Y�/�tL��
tL��tL����D�!�tL��J�J�q�u�u�%�tL��tL��tL�!�tL��j�j�������!�%�%�!7�8�9�tL��j�j��o�tL��tL� �!tL�"�#tL�$���%tL�&
�'tLr<c�<�V
'd\P!V
4p
RV9p\SV`!V3RVRV	/VBVRJdEVPf\R4hVPP
RR4P4pMVRJdRpMTpVVnW@n	WPn
W`nW�nVPRJ;'dVP'*Vn
Vf3VeRpMLVP'dRpM7\VP4pM!VRJdVP'g
VRJVn
VV'd2V'd*VP 'gV	'd	RVnMRVnVfVP"'*pVV'd!Vf\$P&!RV4VnWpnT;'d%\-VP(\$P.4VnW�nW�nV
'd0Vf\$P6!^R	7VnV'd^VnW�nW�nW nW�nVVn VPBR8Xd\R
4hVP'd0VP*'dVP0'g\R4hVP0'gVP'd\R4hVP0'd,VP'dVPe\R
4hVP4'd=VPD'd\R4hVP*'d\R4hR#R#)r�rRrQTNz&'name' is required with 'prompt=True'.r�r�F)�minz&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'.r�rW)#r!r"r�r�rFrIr��
capitalizerr�r�r�rDrrMrr`r�rrrRr�rP�
BoolParamType�is_bool_flagr�r��IntRanger�r�r�r�r�r�rQ)r�r�r�rr�r�r�r�r�rQr�r�rRr�rDr�r�r[�default_is_missing�prompt_textr{s&&&&&&&&&&&&&&&&&,  �r:r��Option.__init__�	s����(��#�#�D�)�D�&�e�3��
����L�4�L�(�L�e�L��T�>��y�y� �� H�I�I�+/�9�9�+<�+<�S�#�+F�+Q�+Q�+S�K�
�u�_��K� �K�!���#6� �.��$����"&���D�!8�!U�!U��AU�AU�=U����?��%����'�'�'����t�2�2�3��
��
�d�&<�&<�&<�&0�t�%;�D�"���)�$�-�-�-��!���$�����!�\�\�)�J���t�|��*�*�4��<�D�I�$��")�"X�"X�j����E�DW�DW�.X���!+���
���|�!�N�N�q�1��	�!� ���"4���	�(��(��&�����z�z�R��� H�I�I��{�{�{�t�|�|�|�D�4E�4E�4E�� M�N�N��$�$�$��)<�)<�)<�� S�T�T�� � � �T�_�_�_����9P��O����z�z�z��=�=�=�#�$K�L�L��<�<�<�#�$J�K�K� �	r<c�^<�V^8�dQhRS[PS[S[P3,/#r�r�)r9r�s"�r:r;r�I
s%���
�
�a�f�f�S�!�%�%�Z�0�
r<c	��<�\SV`4pVPVPVPVP
VPVPVPR7V#))r�rr�r�r�rD)	r�r�rMr�rr�r�r�rD)r�r�r{s& �r:r��Option.to_info_dictI
sU����G�(�*�	��������;�;��L�L�����*�*��;�;�
	�	
��r<c
��<�V^8�dQhRS[PS[,RS[RS[PS[P
S[,S[PS[,S[PS[,3,/#rr)r9r�s"�r:r;r�U
sU���5*�5*��Z�Z��_�5*�48�5*�	
������C��!�&�&��+�q�v�v�c�{�:�	;�5*r<c��.p.pRp.pVEFpVP4'dVe\RVR24hTpK1VR,R8XdRMRpW�9d�VPV^4wr�V	P4p	V	'd,VP	\V	44VP	V	4V
P
4p
V
'd VP	V
P
44W�8Xd\RV:R24hK�VP	\V44VP	V4EK	VfbV'dZVPRR	7V^,^,PR
R4P4pVP4'gRpVfV'gRW43#\RV:24hV'gV'g\R
VRVR24hWSV3#)NzName 'z' defined twicer��/�;zBoolean option z) cannot use the same flag for true/false.c�(�\V^,4)#r`r)rMs&r:�<lambda>�%Option._parse_decls.<locals>.<lambda>w
s��s�1�Q�4�y�jr<rzr�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'?)�isidentifierrI�splitr�r7rr�ru�sortr��lower)r�rrJrrrF�possible_names�decl�
split_char�first�seconds&&&        r:r�Option._parse_declsU
s������������D�� � �"�"��#�#�f�T�F�/�$B�C�C���$(��H��O�S��
��%�$(�J�J�z�1�$=�M�E�!�L�L�N�E��&�-�-�i��.>�?����E�*�#�]�]�_�F��&�-�-�f�m�m�o�>���(�-�d�X�69�9���'�#�)�)�)�D�/�:��K�K��%�/�2�<�N����$8��9�!�!�$�Q�'�/�/��S�9�?�?�A�D��$�$�&�&����<���T�1�1��H��	�R��
��N��<�T�F�C(�(,�v�R�1��
��>�)�)r<c�*<�V^8�dQhRS[RS[RR/#r0r1)r9r�s"�r:r;r��
s"���%�%�L�%�w�%�4�%r<c�R�VP'dRpMVP'dRpMRpVP'd�VR2pVP'dhVP'dVVPWPVPVRR7VPVVPVPVRR7R#VPVVPVPVVPR7R#VPVVPVPVVPR7R#)	r7r��store�_constT)r�r�dest�action�constF)r�rr�r�r�N)
rQr�r�r�r�
add_optionrrFr�r�)r�rr0r�s&&& r:r�Option.add_to_parser�
s���=�=�=��F�
�Z�Z�Z��F��F��<�<�<��x�v�&�F�� � � �T�%8�%8�%8��!�!��9�9�4�9�9�V�SW�"���!�!���,�,����!��"���!�!��������!��/�/�"��
�����Y�Y��Y�Y���j�j�
�
r<c�t<�V^8�dQhRS[RS[PS[PS[S[3,,/#rnro)r9r�s"�r:r;r��
s9���lG�lG�7�lG�q�z�z�!�'�'�#�s�(�:K�/L�lGr<c��aa�SP'dR#RoRVV3RllpV!SP4.pSP'd"VPV!SP44SP;'gRp.pSP
'd�SPpVfXSP'dFVPe8SPe*VPRSPP42pVe[\V\4'dTMRPRV44pVP\R4PVR	74VP pR
VnSP#VRR7p	W�nRp
RpSP$e2\SP$\4'dR
;r�M'SP$p
MVP$e
VP$p
V'gV
'EdNV	EeIV'dRSP$R
2pM�\V	\&\(34'dRPRV	44pM�\*P,!V	4'd
\R4pM�SP.'dKSP'd9\1V	'd
SPMSP^,4^,pMDSP.'dSP'gV	'gRpMV	R8XdRpM\V	4pV'd+VP\R4PVR74\SP2\4P64'dySP8'd4SP2P:^8XdSP2P<e4SP2P?4p
V
'dVPV
4SP@'dVP\R44V'd(RPV4pV'd	VRVR2MRVR2pS'dRMRPV4V3# Y�ni;i)NFc�Z�V^8�dQhR\P\,R\/#)r/rr3)r6rlr5)r9s"r:r;�,Option.get_help_record.<locals>.__annotate__�
s"��	�	�a�j�j��o�	�#�	r<c�<�\V4wrV'dRoSP'g-SP'gVRSP42,
pV#)Tr�)rr�r�r)rr��any_slashes�any_prefix_is_slashr�s&  ��r:�_write_opts�+Option.get_help_record.<locals>._write_opts�
sK���+�4�0�O�B��&*�#��<�<�<��
�
�
���$�+�+�-�.�/�/���Ir<r�r�z, c3�8"�TFp\V4x�K	R#5ir]r��r��ds& r:r��)Option.get_help_record.<locals>.<genexpr>�
s���":�6�a�3�q�6�6�6���zenv var: {var})�varTr.�(�)c3�8"�TFp\V4x�K	R#5ir]r�r�s& r:r�r��
s���*I�=�a�3�q�6�6�=�r�z	(dynamic)z""zdefault: {default})r�r`z; z  [�]�[rw)!rDrrr7r�r�r�r�r�rFr�rPr5r�r�r9r�rLr�r^rPr!�
isfunctionr�rrRr�_NumberRangeBaser�r�r��_describe_ranger`)r�r0r�r�r�r�r��var_str�	resilient�
default_valuer��show_default_is_str�default_string�	range_str�	extra_strr�sf&             @r:r6�Option.get_help_record�
sr����;�;�;��#��	�	��$�)�)�$�
%�������I�I�k�$�"5�"5�6�7��y�y���B���������[�[�F��~��+�+�+��.�.�:��	�	�-� #� 6� 6�7�q������9J�8K�L�F��!�"�&�#�.�.�����":�6�":�:��
���Q�/�0�7�7�G�7�D�E�
�)�)�	� $���	.� �,�,�S�u�,�=�M�$-�!���#�����(��$�+�+�S�1�1�59�9�#�l�#�0�0��
�
�
�
)��+�+�L��<�<�]�5N�"�#$�T�%6�%6�$7�q�!9���M�D�%�=�9�9�!%���*I�=�*I�!I���#�#�M�2�2�!"�;����"�"�"�t�':�':�':�"+�"/�T�Y�Y�T�5H�5H�!�L�"��"���"�"�"�4�+>�+>�+>�}�!#���"�$�!%��!$�]�!3������Q�3�4�;�;�N�;�S�T�
�t�y�y�%�"8�"8�9�9��Z�Z�Z�D�I�I�M�M�Q�$6�4�9�9�=�=�;P��	�	�1�1�3�I�����Y�'��=�=�=��L�L��:��'���	�	�%�(�I�/3�d�V�3�y�k��+�1�Y�K�q�9I�D�+���<�<�R�@�$�F�F��k%.�!�s�,Q�Q"c�b<�V^8�dQhRS[RRRS[PS[P,/#r!r")r9r�s"�r:r;r�"r#r<c��R#r]r�r%s&&&r:rL�Option.get_default!rr<c��<�V^8�dQhRS[RS[RS[PS[PS[P
S[P.S[P
3,3,,/#r(r))r9r�s"�r:r;r�'r*r<c��R#r]r�r%s&&&r:rLr�&rr<c��<�V^8�dQhRS[RS[RS[PS[PS[P
S[P.S[P
3,3,,/#r(r))r9r�s"�r:r;r�+sQ���3�3��3�"&�3�	
���A�G�G�A�E�E�1�:�:�b�!�%�%�i�#8�8�9�	:�3r<c�V<�VP'd�VP'gvVPPFYpVPVP8XgK VP
'gK4\P!\V4Pu#	R#\SV`-WR7#)Nr.)r�r�r@r�rFr�r6r>rr�r�rL)r�r0rrcr{s&&& �r:rLr�+st����<�<�<�� 1� 1� 1����+�+���:�:����*�u�}�}�}��6�6�&�%�0�;�;�;�,���w�"�3�"�2�2r<c�:<�V^8�dQhRS[RS[P/#rnr�)r9r�s"�r:r;r�;s���
�
�G�
����
r<c
�*aa�SPfQhSPS4pSP'd\SPV4#\SPVSPSP
SPSPVV3RlR7#)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.
c�(<�SPSV4#r])r_)rMr0r�s&��r:r��)Option.prompt_for_value.<locals>.<lambda>Rs����!3�!3�C��!;r<)r�rRr�r�r��
value_proc)rrLr�rrRr�r�r�)r�r0r�sff r:�prompt_for_value�Option.prompt_for_value;s�����{�{�&�&�&��"�"�3�'�������4�;�;��0�0���K�K���������*�*� $� 8� 8�;�
�	
r<c�J<�V^8�dQhRS[RS[PS[,/#rnrb)r9r�s"�r:r;r�Us#�������A�J�J�s�O�r<c�2<�\SV`V4pVeV#VP'doVPeaVPeSVPRVPP42p\PPV4pV'dV#R#)Nr�)	r�rdr�r�rFr�r�r�r�)r�r0r�r�r{s&&  �r:rd�Option.resolve_envvar_valueUs����
�W�
)�#�
.��
�>��I�
�#�#�#��&�&�2��	�	�%��.�.�/�q������1B�0C�D�F�������'�B���	�r<c�^<�V^8�dQhRS[RS[PS[P,/#rnr")r9r�s"�r:r;r�hs(�����W�����A�E�E�1B�r<c�:�VPV4pVfR#VP^8g\VP4,pV^8�dTVPPV4pVP'd'VP^8wd\
W P4pV#r])rdr�rMrQrRrhra)r�r0r��value_depths&&  r:r8�Option.value_from_envvarhsv�� $� 9� 9�#� >��
�:���z�z�Q��$�t�}�}�*=�=����?����-�-�b�1�B��}�}�}����q���2�z�z�*���	r<c�<�V^8�dQhRS[RS[PS[R3,RS[PS[P
S[3,/#)r/r0rrdr3)r1r6r6r5r8r�r)r9r�s"�r:r;r�xsE���#�#��#�"#�)�)�C��,<�"=�#�	
�������'�	(�#r<c�<�\SV`W4wr4V\JdeVPe7VP'g%VPV4p\PpW43#VPp\PpW43#VP'dxVet\;QJdRV4F'gKRM	RM
!RV44'd:VUu.uFqU\Jd
VPMTNK	pp\PpW43#VR\P09dfVPeXVP'gVP'd4VP'g"VPV4p\PpW43#uupi)Nc3�0"�TFq\Jx�K	R#5ir]r)r��vs& r:r��'Option.consume_value.<locals>.<genexpr>�s���:�E�q�*�*�E�s�TF)r�r9rrr�r�rr�r�r�rQ�anyr�r`r�)r�r0rrrUr�r{s&&&   �r:r9�Option.consume_valuexsM�����-�c�8�
��
�%�%��{�{�&�s�/D�/D�/D��-�-�c�2��(�/�/��0�}��-����(�4�4��*�}��%
�M�M�M��!���:�E�:����:�E�:�:�:�OT�U�u�!�->�(>�T�_�_�A�E�u�E�U�$�0�0�F��}��
�t�_�4�4�5�5����'�����$�"6�"6�"6��)�)�)��)�)�#�.�E�$�+�+�F��}���Vs� F	)rr�r�r�r�r�r�rDr�r�r�rr�r�r�r�rR)NNFFTFNNFFTNNFTFr^r_)rSr�r�r�r�rr�r�rrr6r6rbrLr�rdr8r9r�rdrTrUs@@r:rr�	s�����:�x�O�tL�tL�l
�
�5*�5*�n%�%�NlG�lG�\�Z�Z� � �� ��Z�Z�@�@��@�3�3� 
�
�4��&�� #�#�#r<rc�aa�]tRtRtoRtRtRV3RlV3Rlllt]V3RlRl4tV3RlR	lt	V3R
lRlt
V3RlR
ltV3RlRltV3RlRlt
RtVtV;t#)r_i�z�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 constructor of :class:`Parameter`.
�argumentc�<�V^8�dQhRS[PS[,RS[PS[,RS[P
RR/#)r/r�r`r[r3N)r6rlr5rerMr�)r9r�s"�r:r;�Argument.__annotate__�sN���L�L��Z�Z��_�L��*�*�T�"�L����	L�

�Lr<c�
<�Vf,VPR4eRpMVPR^4^8�pRV9d\R4h\SV`!V3RV/VBVPeVP
R8Xd\R4hR#R#)	Nr�Fr�rQz9__init__() got an unexpected keyword argument 'multiple'.r`z('default' is not supported for nargs=-1.rW)r�rIr�r�r�r�)r�r�r`r[r{s&&&,�r:r��Argument.__init__�s�������y�y��#�/� �� �9�9�W�a�0�1�4������W�X�X�
����A�x�A�5�A���|�|�'�D�J�J�"�,<�� J�K�K�-=�'r<c� <�V^8�dQhRS[/#r�r�)r9r�s"�r:r;r��s���!�!�S�!r<c�j�VPe
VP#VPP4#r])r�rFr�r�s&r:r�Argument.human_readable_name�s'���<�<�#��<�<���y�y��� � r<c� <�V^8�dQhRS[/#r�r�)r9r�s"�r:r;r��s���
�
�c�
r<c��VPe
VP#VPPV4pV'gVPP	4pVP
'gRVR2pVP^8wd
VR,
pV#)Nr�r�r)r�rRrrFr�r`r�)r�r�s& r:r�Argument.make_metavar�sl���<�<�#��<�<���i�i�#�#�D�)����)�)�/�/�#�C��}�}�}��c�U�!�*�C��:�:��?��5�L�C��
r<c
��<�V^8�dQhRS[PS[,RS[RS[PS[P
S[,S[PS[,S[PS[,3,/#rr)r9r�s"�r:r;r��sU������Z�Z��_��48��	
������C��!�&�&��+�q�v�v�c�{�:�	;�r<c���V'gV'gR..3#\R4h\V4^8Xd,V^,;r4VPRR4P4pM\R\V4R24hW4..3#)Nz8Argument is marked as exposed, but does not have a name.r�r�z6Arguments take exactly one parameter declaration, got r�)rIrBr�r�)r�rrJrF�args&&&  r:r�Argument._parse_decls�s������R��|�#��V�W�W��u�:��?��q��!�D��<�<��S�)�/�/�1�D�����J�<�q�"��
��U�B��r<c�J<�V^8�dQhRS[RS[PS[,/#rnr�)r9r�s"�r:r;r��s#���%�%�G�%����s��%r<c�$�VP4.#r]�rrrs&&r:r��Argument.get_usage_pieces�s���!�!�#�$�$r<c�&<�V^8�dQhRS[RS[/#rnr�)r9r�s"�r:r;r��s���*�*�'�*�c�*r<c�*�RVP4R2#)ryrrrs&&r:r|�Argument.get_error_hint�s���4�$�$�&�'�q�)�)r<c�*<�V^8�dQhRS[RS[RR/#r0r1)r9r�s"�r:r;r��s'���H�H�L�H�w�H�4�Hr<c�V�VPVPVPVR7R#))r�r�r�N)�add_argumentrFr�r3s&&&r:r�Argument.add_to_parser�s��������$�*�*�$��Gr<r�r])rSr�r�r�r�rr�rarrrr�r|rr�rdrTrUs@@r:r_r_�sk�����!�O�L�L�*�!��!�

�
���"%�%�*�*�H�H�Hr<r_r�r])Or�r�r!r�r��typingr6�collectionsr�
contextlibrr�	functoolsrrr�r�	itertoolsr	rr
r��
exceptionsr
rrrrr�
formattingrr�globalsrrrrrr�termuirrr �utilsr!r"r#r$r%r&�
TYPE_CHECKING�typing_extensions�terr(r�r*�TypeVarr�r�r+r-rGrUrarhr}�Enumrr1rgr4r?r�r�r�rdrr_r�r<r:�<module>rss�����	�
���%� �$� ������$�&��(�"�%�$� �!�%� �����'���*��%��?�?�?�"�&�0��I�I�c����C����J�/�0���I�I�c�N��$�&�0:�����$3�6A�d�i�i�A�4Y
0�Y
0�xD*�D*�N
z�k�z�z	r�7�r�j	i%�L�i%�X*��*�Z�p?�p?�f
G�Y�G�TIH�y�IHr<

Youez - 2016 - github.com/yon3zu
LinuXploit