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__/shell_completion.cpython-314.pyc
+
�
4i�H���a�R.t'0t^RIt^RIt^RIt^RIHt^RIHt^RIH	t	^RIH
t
^RIHt^RIHt^RIH
t
^R	IHt^R
IHt^RIHtRR
lt!RR4tRtRtRt!RR4t!RR]4t!RR]4t!RR]4t]P8!R]P:],R7tR]R]R]/t]^kR/R R!llt R"R#lt!R$R%lt"R&R'lt#R(R)lt$R*R+lt%R,R-lt&R#)0�N)�gettext)�Argument)�BaseCommand)�Context)�MultiCommand)�Option)�	Parameter)�ParameterSource)�split_arg_string)�echoc��V^8�dQhR\R\P\\P3,R\R\R\R\
/#)��cli�ctx_args�	prog_name�complete_var�instruction�return)r�t�MutableMapping�str�Any�int)�formats"�8/usr/lib/python3/dist-packages/click/shell_completion.py�__annotate__rsW��#
�#
�	�#
����s�A�E�E�z�*�#
��#
��	#
�
�#
�	�
#
�c���VPR4wrVp\V4pVf^#V!WW#4pVR8Xd\VP44^#VR8Xd\VP	44^#^#)a�Perform shell completion for the given CLI program.

:param cli: Command being called.
:param ctx_args: Extra arguments to pass to
    ``cli.make_context``.
:param prog_name: Name of the executable in the shell.
:param complete_var: Name of the environment variable that holds
    the completion instruction.
:param instruction: Value of ``complete_var`` with the completion
    instruction and shell, in the form ``instruction_shell``.
:return: Status code to exit with.
�_�source�complete)�	partition�get_completion_classrr r!)	rrrrr�shellr�comp_cls�comps	&&&&&    r�shell_completer'sm��&(�1�1�#�6��E�k�#�E�*�H�����C�9�;�D��h���T�[�[�]����j� ��T�]�]�_���rc�Pa�]tRt^7toRtRtR	V3RlRlltV3RlRltRtVt	R#)
�CompletionItema�Represents a completion value and metadata about the value. The
default metadata is ``type`` to indicate special shell handling,
and ``help`` if a shell supports showing a help string next to the
value.

Arbitrary parameters can be passed when creating the object, and
accessed using ``item.attr``. If an attribute wasn't passed,
accessing it returns ``None``.

:param value: The completion suggestion.
:param type: Tells the shell script to provide special completion
    support for the type. Click uses ``"dir"`` and ``"file"``.
:param help: String shown next to the value if supported.
:param kwargs: Arbitrary metadata. The built-in implementations
    don't use this, but custom type completions paired with custom
    shell support could use it.
Nc
�<�V^8�dQhRS[PRS[RS[PS[,RS[PRR/#)r�value�type�help�kwargsrN)rrr�Optional)r�
__classdict__s"�rr�CompletionItem.__annotate__LsM���
�
��u�u�
��
��j�j��o�	
�
�%�%�
�
�
rc�6�WnW nW0nW@nR#�N�r+r,r-�_info)�selfr+r,r-r.s&&&&,r�__init__�CompletionItem.__init__Ls��"�
��	�%)�	��
rc�:<�V^8�dQhRS[RS[P/#)r�namer)rrr)rr0s"�rrr1Xs���$�$��$����$rc�8�VPPV4#r3)r5�get)r6r:s&&r�__getattr__�CompletionItem.__getattr__Xs���z�z�~�~�d�#�#r)r5r-r,r+r4)�plainN)
�__name__�
__module__�__qualname__�__firstlineno__�__doc__�	__slots__r7r=�__static_attributes__�__classdictcell__�r0s@rr)r)7s%�����$3�I�
�
�$�$rr)a�%(complete_func)s() {
    local IFS=$'\n'
    local response

    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD %(complete_var)s=bash_complete $1)

    for completion in $response; do
        IFS=',' read type value <<< "$completion"

        if [[ $type == 'dir' ]]; then
            COMPREPLY=()
            compopt -o dirnames
        elif [[ $type == 'file' ]]; then
            COMPREPLY=()
            compopt -o default
        elif [[ $type == 'plain' ]]; then
            COMPREPLY+=($value)
        fi
    done

    return 0
}

%(complete_func)s_setup() {
    complete -o nosort -F %(complete_func)s %(prog_name)s
}

%(complete_func)s_setup;
a�#compdef %(prog_name)s

%(complete_func)s() {
    local -a completions
    local -a completions_with_descriptions
    local -a response
    (( ! $+commands[%(prog_name)s] )) && return 1

    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) %(complete_var)s=zsh_complete %(prog_name)s)}")

    for type key descr in ${response}; do
        if [[ "$type" == "plain" ]]; then
            if [[ "$descr" == "_" ]]; then
                completions+=("$key")
            else
                completions_with_descriptions+=("$key":"$descr")
            fi
        elif [[ "$type" == "dir" ]]; then
            _path_files -/
        elif [[ "$type" == "file" ]]; then
            _path_files -f
        fi
    done

    if [ -n "$completions_with_descriptions" ]; then
        _describe -V unsorted completions_with_descriptions -U
    fi

    if [ -n "$completions" ]; then
        compadd -U -V unsorted -a completions
    fi
}

if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
    # autoload from fpath, call function directly
    %(complete_func)s "$@"
else
    # eval/source/. command, register function for later
    compdef %(complete_func)s %(prog_name)s
fi
affunction %(complete_func)s;
    set -l response (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) %(prog_name)s);

    for completion in $response;
        set -l metadata (string split "," $completion);

        if test $metadata[1] = "dir";
            __fish_complete_directories $metadata[2];
        else if test $metadata[1] = "file";
            __fish_complete_path $metadata[2];
        else if test $metadata[1] = "plain";
            echo $metadata[2];
        end;
    end;
end;

complete --no-files --command %(prog_name)s --arguments "(%(complete_func)s)";
c��a�]tRt^�toRtV3RlRlt]V3RlRl4tV3RlRltV3RlR	lt	V3R
lRlt
V3RlR
ltV3RlRltV3RlRlt
V3RltRtVtR#)�
ShellCompletea�Base class for providing shell completion support. A subclass for
a given shell will override attributes and methods to implement the
completion instructions (``source`` and ``complete``).

:param cli: Command being called.
:param prog_name: Name of the executable in the shell.
:param complete_var: Name of the environment variable that holds
    the completion instruction.

.. versionadded:: 8.0
c
�t<�V^8�dQhRS[RS[PS[S[P3,RS[RS[RR/#)rrrrrrN)rrrrr)rr0s"�rr�ShellComplete.__annotate__�sP���
)�
)�
�
)��"�"�3����:�.�
)��	
)�
�
)�
�
)rc�6�WnW nW0nW@nR#r3)rrrr)r6rrrrs&&&&&rr7�ShellComplete.__init__�s���� �
�"��(�rc� <�V^8�dQhRS[/#�rr�r)rr0s"�rrrL�s���*�*�3�*rc��\P!RRVPPRR4\PR7pRVR2#)zAThe name of the shell function defined by the completion
script.
z\W*��-r)�flags�_completion)�re�subr�replace�ASCII)r6�	safe_names& r�	func_name�ShellComplete.func_name�s<��
�F�F�6�2�t�~�~�'=�'=�c�3�'G�r�x�x�X�	��9�+�[�)�)rc�^<�V^8�dQhRS[PS[S[P3,/#rP)r�Dictrr)rr0s"�rrrL�s%���

�

�Q�V�V�C����J�/�

rc�N�RVPRVPRVP/#)zVars for formatting :attr:`source_template`.

By default this provides ``complete_func``, ``complete_var``,
and ``prog_name``.
�
complete_funcrr)r\rr�r6s&r�source_vars�ShellComplete.source_vars�s+��
�T�^�^��D�-�-�����
�	
rc� <�V^8�dQhRS[/#rPrQ)rr0s"�rrrL�s���9�9��9rc�D�VPVP4,#)z�Produce the shell script that defines the completion
function. By default this ``%``-style formats
:attr:`source_template` with the dict returned by
:meth:`source_vars`.
)�source_templatercrbs&rr �ShellComplete.source�s���#�#�d�&6�&6�&8�8�8rc�n<�V^8�dQhRS[PS[PS[,S[3,/#rP�r�Tuple�Listr)rr0s"�rrrLs*���"�"�Q�W�W�Q�V�V�C�[�#�-=�%>�"rc��\h)z�Use the env vars defined by the shell script to return a
tuple of ``args, incomplete``. This must be implemented by
subclasses.
��NotImplementedErrorrbs&r�get_completion_args�!ShellComplete.get_completion_argss
��
"�!rc�t<�V^8�dQhRS[PS[,RS[RS[PS[,/#)r�args�
incompleter)rrlrr))rr0s"�rrrLs6���3�3��F�F�3�K�3�-0�3�	
����	�3rc��\VPVPVPV4p\	W1V4wrBVPW24#)a,Determine the context and last complete command or parameter
from the complete args. Call that object's ``shell_complete``
method to get the completions for the incomplete value.

:param args: List of complete args before the incomplete value.
:param incomplete: Value being completed. May be empty.
)�_resolve_contextrrr�_resolve_incompleter')r6rsrt�ctx�objs&&&  r�get_completions�ShellComplete.get_completionss?���t�x�x��������M��-�c��D����!�!�#�2�2rc�&<�V^8�dQhRS[RS[/#�r�itemr�r)r)rr0s"�rrrLs���"�"�n�"��"rc��\h)z�Format a completion item into the form recognized by the
shell script. This must be implemented by subclasses.

:param item: Completion item to format.
rn�r6r~s&&r�format_completion�ShellComplete.format_completions
��"�!rc� <�V^8�dQhRS[/#rPrQ)rr0s"�rrrLs���
�
�#�
rc��VP4wrVPW4pVUu.uFq@PV4NK	ppRPV4#uupi)z�Produce the completion data to send back to the shell.

By default this calls :meth:`get_completion_args`, gets the
completions, then calls :meth:`format_completion` for each
completion.
�
)rprzr��join)r6rsrt�completionsr~�outs&     rr!�ShellComplete.completesV�� �3�3�5����*�*�4�<��8C�D���%�%�d�+���D��y�y��~���Es�Ac�z<�V^8�dQh/S[PS[,;R&S[PS[,;R&#)rr:rg)r�ClassVarr)rr0s"�rrrL�s/�����*�*�S�/���&�Z�Z��_�$�'r)rrrrN)r@rArBrCrDr7�propertyr\rcr rprzr�r!�__annotate_func__rFrGrHs@rrJrJ�sv����
���
)�
)��*��*�

�

�9�9�"�"�3�3�"�"�
�
�{�rrJc�aa�]tRtRtoRtRt]t]V3RlRl4t	V3RlV3Rllt
V3RlR	ltV3R
lRltRt
VtV;t#)
�BashCompletei*zShell completion for Bash.�bashc�<�V^8�dQhRR/#)rrN�)rr0s"�rr�BashComplete.__annotate__1s�����D�rc��^RIp^RIpVPR4pVfRpMPVPVRRR.VPR7p\
P!RVPP44pVeDVP4wrVVR8gVR8Xd"VR8d\\R	4R
R7R#R#R#\\R4R
R7R#)
rNr�z--norcz-czecho "${BASH_VERSION}")�stdoutz^(\d+)\.(\d+)\.\d+�4zCShell completion is not supported for Bash versions older than 4.4.T)�errz@Couldn't detect Bash version, shell completion is not supported.)�shutil�
subprocess�which�run�PIPErW�searchr��decode�groupsrr)r�r��bash_exe�match�output�major�minors       r�_check_version�BashComplete._check_version0s������<�<��'�����E��^�^��8�T�+C�D�!���$��F��I�I�3�V�]�]�5I�5I�5K�L�E��� �<�<�>�L�E��s�{�e�s�l�u�s�{���4����0;�l�
��T�U��
rc� <�V^8�dQhRS[/#rPrQ)rr0s"�rrr�Qs��� � �� rc�@<�VP4\SV`	4#r3)r��superr )r6�	__class__s&�rr �BashComplete.sourceQs��������w�~��rc�n<�V^8�dQhRS[PS[PS[,S[3,/#rPrj)rr0s"�rrr�U�*���
 �
 �Q�W�W�Q�V�V�C�[�#�-=�%>�
 rc���\\PR,4p\\PR,4pV^VpW,pW43# \dRpY43#i;i��
COMP_WORDS�
COMP_CWORDrS�r�os�environr�
IndexError�r6�cwords�cwordrsrts&    rrp� BashComplete.get_completion_argsU�i��!�"�*�*�\�":�;���B�J�J�|�,�-���a����	���J������	��J����	���A�
A$�#A$c�&<�V^8�dQhRS[RS[/#r}r)rr0s"�rrr�as���+�+�n�+��+rc�8�VPRVP2#)�,)r,r+r�s&&rr��BashComplete.format_completionas���)�)��A�d�j�j�\�*�*rr�)r@rArBrCrDr:�_SOURCE_BASHrg�staticmethodr�r rpr�rFrG�
__classcell__)r�r0s@@rr�r�*sH����$��D�"�O�����@ � �
 �
 �+�+�+rr�c�Pa�]tRtRtoRtRt]tV3RlRltV3RlRlt	Rt
VtR	#)
�ZshCompleteiezShell completion for Zsh.�zshc�n<�V^8�dQhRS[PS[PS[,S[3,/#rPrj)rr0s"�rr�ZshComplete.__annotate__kr�rc���\\PR,4p\\PR,4pV^VpW,pW43# \dRpY43#i;ir�r�r�s&    rrp�ZshComplete.get_completion_argskr�r�c�&<�V^8�dQhRS[RS[/#r}r)rr0s"�rrr�ws���O�O�n�O��Orc�~�VPRVPRVP'dVP2#R2#)r�r)r,r+r-r�s&&rr��ZshComplete.format_completionws9���)�)��B�t�z�z�l�"�$�)�)�)�T�Y�Y�,M�N�N��,M�N�Nrr�N)r@rArBrCrDr:�_SOURCE_ZSHrgrpr�rFrGrHs@rr�r�es(����#��D�!�O�
 �
 �O�Orr�c�Pa�]tRtRtoRtRt]tV3RlRltV3RlRlt	Rt
VtR	#)
�FishCompletei{zShell completion for Fish.�fishc�n<�V^8�dQhRS[PS[PS[,S[3,/#rPrj)rr0s"�rr�FishComplete.__annotate__�r�rc���\\PR,4p\PR,pVR,pV'd'V'dVR,V8XdVP4W23#)r�r�:�NN���)rr�r��pop)r6r�rtrss&   rrp� FishComplete.get_completion_args�sP��!�"�*�*�\�":�;���Z�Z��-�
��b�z���$�4��8�z�#9��H�H�J���rc�&<�V^8�dQhRS[RS[/#r}r)rr0s"�rrr��s���+�+�n�+��+rc��VP'd)VPRVPRVP2#VPRVP2#)r��	)r-r,r+r�s&&rr��FishComplete.format_completion�sG���9�9�9��i�i�[��$�*�*��R��	�	�{�;�;��)�)��A�d�j�j�\�*�*rr�N)r@rArBrCrDr:�_SOURCE_FISHrgrpr�rFrGrHs@rr�r�{s&����$��D�"�O�
 �
 �+�+rr��ShellCompleteType)�boundr�r�r�c�f�V^8�dQhR\R\P\,R\/#)r�clsr:r)r�rr/r)rs"rrr�s,����	��"#�*�*�S�/���rc�8�Vf
VPpV\V&V#)aQRegister a :class:`ShellComplete` subclass under the given name.
The name will be provided by the completion instruction environment
variable during completion.

:param cls: The completion class that will handle completion for the
    shell.
:param name: Name to register the class under. Defaults to the
    class's ``name`` attribute.
)r:�_available_shells)r�r:s&&r�add_completion_classr��s"���|��x�x��!��d���Jrc��V^8�dQhR\R\P\P\,,/#)rr$r)rrr/�TyperJ)rs"rrr�s,��(�(��(��
�
�1�6�6�-�3H�(I�(rc�,�\PV4#)z�Look up a registered :class:`ShellComplete` subclass by the name
provided by the completion instruction environment variable. If the
name isn't registered, returns ``None``.

:param shell: Name the class is registered under.
)r�r<)r$s&rr#r#�s��� � ��'�'rc�<�V^8�dQhR\R\R\/#)rrx�paramr)rr	�bool)rs"rrr�s!��������t�rc���\V\4'gR#VPfQhVPP	VP4pVP
R8H;'g�VP
VP4\PJ;'gNVP
^8�;'d7\V\\34;'d\V4VP
8#)z�Determine if the given parameter is an argument that can still
accept values.

:param ctx: Invocation context for the command represented by the
    parsed complete args.
:param param: Argument object being checked.
Fr�)�
isinstancerr:�paramsr<�nargs�get_parameter_sourcer
�COMMANDLINE�tuple�list�len)rxr�r+s&& r�_is_incomplete_argumentr��s����e�X�&�&���:�:�!�!�!��J�J�N�N�5�:�:�&�E�
���r��	
�	
��#�#�E�J�J�/��7R�7R�R�	
�	
�
�K�K�!�O�
)�
)��5�5�$�-�0�
)�
)��E�
�U�[�[�(�
rc�<�V^8�dQhR\R\R\/#)rrxr+r)rrr�)rs"rrr�s!��"�"�'�"�#�"�$�"rc�D�V'gR#V^,pW P9#)z5Check if the value looks like the start of an option.F)�
_opt_prefixes)rxr+�cs&& r�_start_of_optionr��s ����
�a��A��!�!�!�!rc�r�V^8�dQhR\R\P\,R\R\
/#)rrxrsr�r)rrrlrr	r�)rs"rrr�s7��A�A�w�A�a�f�f�S�k�A�)�A�PT�Arc�N�\V\4'gR#VP'gVP'dR#Rp\	\V44F4wrEV^,VP8�dM\W4'gK2TpK6	VRJ;'dW2P9#)z�Determine if the given parameter is an option that needs a value.

:param args: List of complete args before the incomplete value.
:param param: Option object being checked.
FN)	r�r�is_flag�count�	enumerate�reversedr�r��opts)rxrsr��last_option�index�args&&&   r�_is_incomplete_optionr�s����e�V�$�$���}�}�}�������K�����/�
���1�9�u�{�{�"���C�%�%��K�0��d�"�@�@�{�j�j�'@�@rc
���V^8�dQhR\R\P\\P3,R\R\P
\,R\/#)rrrrrsr)rrrrrrlr)rs"rrr�sU��6�6�	�6����s�A�E�E�z�*�6��6��&�&��+�	6�

�6rc	�r�RVR&VP!W#P43/VBpVPVP,pV'd�VPp\V\4'd�VP'gNVPWC4wrgpVfV#VPWcVRR7pVPVP,pK�TpV'd@VPWC4wrgpVfV#VPVVVRRRR7pVPpKGTp.VPOVPOpK�V#V#)aHProduce the context hierarchy starting with the command and
traversing the complete arguments. This only follows the commands,
it doesn't trigger input prompts or callbacks.

:param cli: Command being called.
:param prog_name: Name of the executable in the shell.
:param args: List of complete args before the incomplete value.
T�resilient_parsing)�parentrF)r�allow_extra_args�allow_interspersed_argsr)	�make_context�copy�protected_argsrs�commandr�r�chain�resolve_command)	rrrrsrxrr:�cmd�sub_ctxs	&&&&     rrvrv�s,��%)�H�
 �!�

�
�
�9�i�i�k�
>�X�
>�C�������(�D�
��+�+���g�|�,�,��=�=�=�")�"9�"9�#�"D���4��;��J��&�&�t�#�QU�&�V���)�)�C�H�H�4�����&-�&=�&=�c�&H�O�D�t��{�"�
�!�.�.���"�)-�05�*.�
/��G�#�<�<�D���?��/�/�?�'�,�,�?����J�3�Jrc���V^8�dQhR\R\P\,R\R\P\P
\\3,\3,/#)rrxrsrtr)rrrlrrk�Unionrr	)rs"rrr/sP��,#�,#�	�,#����s��,#�14�,#��W�W�Q�W�W�[�)�+�
,�c�
1�2�,#rc��VR8XdRpM=RV9d7\W4'd&VPR4wr4pVPV4RV9d \W4'dVPV3#VPP	V4pVFp\WV4'gKWb3u#	VFp\
W4'gKWb3u#	VPV3#)aPFind the Click object that will handle the completion of the
incomplete value. Return the object and the incomplete value.

:param ctx: Invocation context for the command represented by
    the parsed complete args.
:param args: List of complete args before the incomplete value.
:param incomplete: Value being completed. May be empty.
�=rSz--)r�r"�appendr�
get_paramsrr�)rxrsrtr:rr�r�s&&&    rrwrw/s����S���
�	�
�	�/��@�@�(�2�2�3�7�������D���4��,�S�=�=��{�{�J�&�&�
�[�[�
#�
#�C�
(�F��� ��E�2�2��$�$����"�3�.�.��$�$���;�;�
�"�"rc��V^8�dQh/^\9d:\P\\P\
,3,;R&#)rr�)�__conditional_annotations__rr_rr�rJ)rs"rrrs5��	�	�l��1�6�6�#�q�v�v�m�4�4�5��m
rr3)(rr�rW�typingrrr�corerrrrrr	r
�parserr�utilsrr'r)r�r�r�rJr�r�r��TypeVarr�r�r�r�r#r�r�rrvrwr)rs@r�<module>r s����	�	�	�� �������!�$��#
�L"$�"$�L��@*��X��.g�g�T8+�=�8+�vO�-�O�,+�=�+�2�I�I�1����
�9N�O���L�
�L�	�;�9����((��2"�A�06�r,#r

Youez - 2016 - github.com/yon3zu
LinuXploit