o
    ßý°j<f  ã                   @  s  U d dl mZ d dlmZ d dlZd dlZd dlZd dl	m	Z
 ddlmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ d`dd„Zejrfd dlmZ eddejd�Znejddd�ZG dd„ deje ƒZd Zd!Zd"Zd#Z G d$d%„ d%ej!ƒZ"G d&d'„ d'ƒZ#G d(d)„ d)e#ƒZ$G d*d+„ d+e#ƒZ%G d,d-„ d-e#ƒZ&G d.d/„ d/e#ƒZ'e$e&e'e%d0œZ(d1e)d2< ejd3d'd4�Z*	dadbd9d:„Z+ej,dcd>d?„ƒZ-ej,dddBd?„ƒZ-ej,dedEd?„ƒZ-ej,dfdGd?„ƒZ-dfdHd?„Z-dgdKdL„Z.dhdRdS„Z/didUdV„Z0djdXdY„Z1dkdZd[„Z2dld^d_„Z3dS )mé    )ÚannotationsN)Úgettexté   )ÚArgument)ÚCommand)ÚContext)ÚGroup)ÚOption)Ú	Parameter)ÚParameterSource)ÚechoÚclir   Úctx_argsúcabc.MutableMapping[str, t.Any]Ú	prog_nameÚstrÚcomplete_varÚinstructionÚreturnút.Literal[0, 1]c           	      C  sr   |  d¡\}}}t|ƒ}|du rdS || |||ƒ}|dkr)t| ¡  ¡ dd� dS |dkr7t| ¡  ¡ ƒ dS dS )	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.
    Ú_Nr   ÚsourceF)Únlr   Úcomplete)Ú	partitionÚget_completion_classr   r   Úencoder   )	r   r   r   r   r   Úshellr   Úcomp_clsÚcomp© r    ú‰/root/aizidognhua/tmp/workspace/projects/ec89d86c-575f-41c9-af57-ac45cbdbf775/venv/lib/python3.10/site-packages/click/shell_completion.pyÚshell_complete   s   r"   )ÚTypeVarÚ
_ValueT_coT)Ú	covariantÚdefault)r%   c                   @  s.   e Zd ZdZdZ		dddd„Zddd„ZdS )Ú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.
    ©ÚvalueÚtypeÚhelpÚ_infoÚplainNr)   r$   r*   r   r+   ú
str | NoneÚkwargsút.Anyr   ÚNonec                 K  ó   || _ || _|| _|| _d S ©Nr(   )Úselfr)   r*   r+   r/   r    r    r!   Ú__init__X   ó   
zCompletionItem.__init__Únamec                 C  s   | j  |¡S r3   )r,   Úget)r4   r7   r    r    r!   Ú__getattr__d   s   zCompletionItem.__getattr__)r-   N)
r)   r$   r*   r   r+   r.   r/   r0   r   r1   )r7   r   r   r0   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__r5   r9   r    r    r    r!   r'   C   s    ür'   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
af  function %(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)";
aÉ  Register-ArgumentCompleter -Native -CommandName %(prog_name)s -ScriptBlock {
    param($wordToComplete, $commandAst, $cursorPosition)

    $prev_complete = $env:%(complete_var)s
    $prev_words = $env:COMP_WORDS
    $prev_cword = $env:COMP_CWORD

    $env:%(complete_var)s = 'powershell_complete'
    $env:COMP_WORDS = $commandAst.ToString()
    if ($wordToComplete) {
        $env:COMP_CWORD = $commandAst.CommandElements.Count - 1
    } else {
        $env:COMP_CWORD = $commandAst.CommandElements.Count
    }

    try {
        $response = & %(prog_name)s 2>$null
    } finally {
        $env:%(complete_var)s = $prev_complete
        $env:COMP_WORDS = $prev_words
        $env:COMP_CWORD = $prev_cword
    }

    if (-not $response) { return }

    $prefix = "$wordToComplete*"
    $lines = $response -split "`n"
    for ($i = 0; $i + 2 -lt $lines.Count; $i += 3) {
        $type = $lines[$i]
        $value = $lines[$i + 1]
        $descr = $lines[$i + 2]
        if (-not $type) { continue }

        if ($type -eq 'plain') {
            $tip = if ($descr -and $descr -ne '_') { $descr } else { $value }
            [System.Management.Automation.CompletionResult]::new(
                $value, $value, 'ParameterValue', $tip)
        } elseif ($type -eq 'dir') {
            Get-ChildItem -Directory -Path $prefix -ErrorAction SilentlyContinue |
                ForEach-Object {
                    [System.Management.Automation.CompletionResult]::new(
                        $_.FullName, $_.Name, 'ProviderContainer', $_.FullName)
                }
        } elseif ($type -eq 'file') {
            Get-ChildItem -Path $prefix -ErrorAction SilentlyContinue |
                ForEach-Object {
                    $kind = 'ProviderItem'
                    if ($_.PSIsContainer) { $kind = 'ProviderContainer' }
                    [System.Management.Automation.CompletionResult]::new(
                        $_.FullName, $_.Name, $kind, $_.FullName)
                }
        }
    }
}
c                   @  s&   e Zd ZU ded< ded< ded< dS )Ú_SourceVarsDictr   Úcomplete_funcr   r   N)r:   r;   r<   Ú__annotations__r    r    r    r!   r?     s   
 r?   c                   @  sš   e Zd ZU dZded< 	 ded< 	 ded< ded< d	ed
< d	ed< d'dd„Zed(dd„ƒZd)dd„Zd(dd„Z	d*dd„Z
d+dd„Zd,d"d#„Zd(d$d%„Zd&S )-Ú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
    út.ClassVar[str]r7   Úsource_templater   r   r   r   r   r   r   r   r1   c                 C  r2   r3   )r   r   r   r   )r4   r   r   r   r   r    r    r!   r5   3  r6   zShellComplete.__init__c                 C  s*   t jdd| j dd¡t jd�}d|› d�S )zQThe name of the shell function defined by the completion
        script.
        z\W*Ú ú-r   )ÚflagsÚ_completion)ÚreÚsubr   ÚreplaceÚASCII)r4   Ú	safe_namer    r    r!   Ú	func_name?  s   zShellComplete.func_namer?   c                 C  s   | j | j| jdœS )z—Vars for formatting :attr:`source_template`.

        By default this provides ``complete_func``, ``complete_var``,
        and ``prog_name``.
        )r@   r   r   )rN   r   r   ©r4   r    r    r!   Úsource_varsG  s   ýzShellComplete.source_varsc                 C  s   | j |  ¡  S )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`.
        )rD   rP   rO   r    r    r!   r   S  s   zShellComplete.sourceútuple[list[str], str]c                 C  ó   t ‚)z˜Use the env vars defined by the shell script to return a
        tuple of ``args, incomplete``. This must be implemented by
        subclasses.
        ©ÚNotImplementedErrorrO   r    r    r!   Úget_completion_args[  s   z!ShellComplete.get_completion_argsÚargsú	list[str]Ú
incompleteúlist[CompletionItem[str]]c                 C  s0   t | j| j| j|ƒ}t|||ƒ\}}| ||¡S )aT  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_contextr   r   r   Ú_resolve_incompleter"   )r4   rV   rX   ÚctxÚobjr    r    r!   Úget_completionsb  s   
zShellComplete.get_completionsÚitemúCompletionItem[str]c                 C  rR   )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.
        rS   ©r4   r_   r    r    r!   Úformat_completionp  s   zShellComplete.format_completionc                   s4   ˆ   ¡ \}}ˆ  ||¡}‡ fdd„|D ƒ}d |¡S )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.
        c                   s   g | ]}ˆ   |¡‘qS r    )rb   )Ú.0r_   rO   r    r!   Ú
<listcomp>�  s    z*ShellComplete.complete.<locals>.<listcomp>Ú
)rU   r^   Újoin)r4   rV   rX   ÚcompletionsÚoutr    rO   r!   r   x  s   
zShellComplete.completeN)
r   r   r   r   r   r   r   r   r   r1   ©r   r   )r   r?   ©r   rQ   )rV   rW   rX   r   r   rY   ©r_   r`   r   r   )r:   r;   r<   r=   rA   r5   ÚpropertyrN   rP   r   rU   r^   rb   r   r    r    r    r!   rB     s&   
 





rB   c                      s^   e Zd ZU dZdZded< eZded< eddd	„ƒZ	d‡ fdd„Z
ddd„Zddd„Z‡  ZS )ÚBashCompletezShell completion for Bash.ÚbashrC   r7   rD   r   r1   c                  C  s®   dd l } dd l}|  d¡}|d u rd }n|j|dddg|jd�}t d|j ¡ ¡}|d urM| 	¡ \}}|dk s?|dkrI|dk rKt
td	ƒd
d� d S d S d S t
tdƒd
d� d S )Nr   rn   z--norcz-czecho "${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ÚPIPErI   Úsearchro   ÚdecodeÚgroupsr   r   )rr   rs   Úbash_exeÚmatchÚoutputÚmajorÚminorr    r    r!   Ú_check_version‹  s0   

þÿ
ûÿ	
þzBashComplete._check_versionr   c                   s   |   ¡  tƒ  ¡ S r3   )r   Úsuperr   rO   ©Ú	__class__r    r!   r   ¬  s   
zBashComplete.sourcerQ   c                 C  óX   t tjd ƒ}ttjd ƒ}|d|… }z	|| }W ||fS  ty+   d}Y ||fS w ©NÚ
COMP_WORDSÚ
COMP_CWORDr   rE   ©Úsplit_arg_stringÚosÚenvironÚintÚ
IndexError©r4   ÚcwordsÚcwordrV   rX   r    r    r!   rU   °  ó   
ýýz BashComplete.get_completion_argsr_   úCompletionItem[t.Any]c                 C  s   |j › d|j› �S )Nú,)r*   r)   ra   r    r    r!   rb   ¼  s   zBashComplete.format_completion)r   r1   ri   rj   )r_   r‘   r   r   )r:   r;   r<   r=   r7   rA   Ú_SOURCE_BASHrD   Ústaticmethodr   r   rU   rb   Ú__classcell__r    r    r�   r!   rm   …  s   
  
rm   c                   @  ó>   e Zd ZU dZdZded< eZded< ddd	„Zddd„Z	dS )ÚZshCompletezShell completion for Zsh.ÚzshrC   r7   rD   r   rQ   c                 C  rƒ   r„   r‡   r�   r    r    r!   rU   Æ  r�   zZshComplete.get_completion_argsr_   r`   r   c                 C  s<   |j pd}|dkr|j dd¡n|j}|j› d|› d|› �S )Nr   ú:z\:re   )r+   r)   rK   r*   )r4   r_   Úhelp_r)   r    r    r!   rb   Ò  s   
zZshComplete.format_completionNrj   rk   )
r:   r;   r<   r=   r7   rA   Ú_SOURCE_ZSHrD   rU   rb   r    r    r    r!   r—   À  s   
 
r—   c                   @  r–   )ÚFishCompletezShell completion for Fish.ÚfishrC   r7   rD   r   rQ   c                 C  sX   t tjd ƒ}tjd }|rt |ƒd }|dd … }|r(|r(|d |kr(| ¡  ||fS )Nr…   r†   r   r   éÿÿÿÿ)rˆ   r‰   rŠ   Úpop)r4   rŽ   rX   rV   r    r    r!   rU   ê  s   
z FishComplete.get_completion_argsr_   r`   r   c                 C  sF   |j r|j  dd¡ dd¡}|j› d|j› d|› �S |j› d|j› �S )z¸
        .. versionchanged:: 8.4.2
            Escape newlines and replace tabs with spaces in the help text to
            fix completion errors with multi-line help strings.
        re   z\nú	ú r’   ©r+   rK   r*   r)   ©r4   r_   rš   r    r    r!   rb   ø  s   
zFishComplete.format_completionNrj   rk   )
r:   r;   r<   r=   r7   rA   Ú_SOURCE_FISHrD   rU   rb   r    r    r    r!   rœ   ä  s   
 
rœ   c                   @  r–   )ÚPowerShellCompletezhShell completion for PowerShell (Windows PowerShell 5.1+ and pwsh 7+).

    .. versionadded:: 8.5.0
    Ú
powershellrC   r7   rD   r   rQ   c                 C  rƒ   r„   r‡   r�   r    r    r!   rU     r�   z&PowerShellComplete.get_completion_argsr_   r`   r   c                 C  s:   |j r|j  dd¡ dd¡}nd}|j› d|j› d|› �S )Núr¡   re   r   r¢   r£   r    r    r!   rb     s   z$PowerShellComplete.format_completionNrj   rk   )
r:   r;   r<   r=   r7   rA   Ú_SOURCE_POWERSHELLrD   rU   rb   r    r    r    r!   r¥   	  s   
 
r¥   )rn   r�   r¦   r˜   z't.Final[dict[str, type[ShellComplete]]]Ú_available_shellsÚ_ShellCompleteT)ÚboundÚclsútype[_ShellCompleteT]r7   r.   c                 C  s   |du r| j }| t|< | S )am  Register 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.
    N)r7   r©   )r¬   r7   r    r    r!   Úadd_completion_class5  s   r®   r   út.Literal['bash']útype[BashComplete]c                 C  ó   d S r3   r    ©r   r    r    r!   r   I  ó   r   út.Literal['fish']útype[FishComplete]c                 C  r±   r3   r    r²   r    r    r!   r   K  r³   út.Literal['zsh']útype[ZshComplete]c                 C  r±   r3   r    r²   r    r    r!   r   M  r³   útype[ShellComplete] | Nonec                 C  r±   r3   r    r²   r    r    r!   r   O  r³   c                 C  s
   t  | ¡S )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©   r8   r²   r    r    r!   r   Q  s   
ÚstringrW   c                 C  sX   ddl }|j | dd�}d|_d|_g }z| |¡ W |S  ty+   | |j¡ Y |S w )aó  Split an argument string as with :func:`shlex.split`, but don't
    fail if the string is incomplete. Ignores a missing closing quote or
    incomplete escape sequence and uses the partial token as-is.

    .. code-block:: python

        split_arg_string("example 'my file")
        ["example", "my file"]

        split_arg_string("example my\")
        ["example", "my"]

    :param string: String to split.

    .. versionchanged:: 8.2
        Moved to ``shell_completion`` from ``parser``.
    r   NT)ÚposixrE   )ÚshlexÚwhitespace_splitÚ
commentersÚextendÚ
ValueErrorÚappendÚtoken)r¹   r»   Úlexrh   r    r    r!   rˆ   [  s   úúrˆ   r\   r   Úparamr
   Úboolc                 C  s^   t |tƒsdS | j |j¡}|jdkp.|  |j¡tjup.|jdko.t |t	t
fƒo.t|ƒ|jk S )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ž   r   )Ú
isinstancer   Úparamsr8   r7   ÚnargsÚget_parameter_sourcer   ÚCOMMANDLINEÚtupleÚlistÚlen)r\   rÃ   r)   r    r    r!   Ú_is_incomplete_argument  s   

ÿ
ÿúrÍ   r)   c                 C  s   |sdS |d }|| j v S )z5Check if the value looks like the start of an option.Fr   )Ú_opt_prefixes)r\   r)   Úcr    r    r!   Ú_start_of_option–  s   
rÐ   rV   c                 C  sn   t |tƒsdS |js|jrdS d}tt|ƒƒD ]\}}|d |jkr$ n
t| |ƒr-|} nq|duo6||jv S )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.
    FNr   )	rÅ   r	   Úis_flagÚcountÚ	enumerateÚreversedrÇ   rÐ   Úopts)r\   rV   rÃ   Úlast_optionÚindexÚargr    r    r!   Ú_is_incomplete_optionŸ  s   

þrÙ   c           
   	   C  s�  d|d< | j || ¡ fi |¤Ž�®}|j|j }|r®|j}t|tƒr£|js\| ||¡\}}}|du r:|W  d  ƒ S |j |||dd��}|}|j|j }W d  ƒ n1 sVw   Y  nH|}|r˜| ||¡\}}}|du rv|W  d  ƒ S |j |||dddd��}	|	}|j}W d  ƒ n1 s‘w   Y  |s`|}g |j¢|j¢}nn|sW d  ƒ |S W d  ƒ |S W d  ƒ |S 1 sÁw   Y  |S )a`  Produce 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_parsingN)ÚparentrÚ   F)rÛ   Úallow_extra_argsÚallow_interspersed_argsrÚ   )	Úmake_contextÚcopyÚ_protected_argsrV   ÚcommandrÅ   r   ÚchainÚresolve_command)
r   r   r   rV   r\   rá   r7   ÚcmdÚsub_ctxÚsub_sub_ctxr    r    r!   rZ   ¸  sh   
õÿü€çú÷úÚ
ý+Ø
ý+þ
×+Õ+rZ   rX   útuple[Command | Parameter, str]c                 C  s®   |dkrd}nd|v rt | |ƒr| d¡\}}}| |¡ d|vr+t | |ƒr+| j|fS | j | ¡}|D ]}t| ||ƒrA||f  S q3|D ]}t| |ƒrQ||f  S qD| j|fS )ah  Find 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.
    ú=rE   z--)rÐ   r   rÀ   rá   Ú
get_paramsrÙ   rÍ   )r\   rV   rX   r7   r   rÆ   rÃ   r    r    r!   r[   õ  s"   

ÿ
ÿ
r[   )r   r   r   r   r   r   r   r   r   r   r   r   r3   )r¬   r­   r7   r.   r   r­   )r   r¯   r   r°   )r   r´   r   rµ   )r   r¶   r   r·   )r   r   r   r¸   )r¹   r   r   rW   )r\   r   rÃ   r
   r   rÄ   )r\   r   r)   r   r   rÄ   )r\   r   rV   rW   rÃ   r
   r   rÄ   )
r   r   r   r   r   r   rV   rW   r   r   )r\   r   rV   rW   rX   r   r   rç   )4Ú
__future__r   Úcollections.abcÚabcÚcabcr‰   rI   ÚtypingÚtr   r   Úcorer   r   r   r   r	   r
   r   Úutilsr   r"   ÚTYPE_CHECKINGÚtyping_extensionsr#   ÚAnyr$   ÚGenericr'   r“   r›   r¤   r¨   Ú	TypedDictr?   rB   rm   r—   rœ   r¥   r©   rA   rª   r®   Úoverloadr   rˆ   rÍ   rÐ   rÙ   rZ   r[   r    r    r    r!   Ú<module>   sj    
'&&,:o;$%#üÿ



$

	
=