o
    96dH                     @   sB  U 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lmZ dedejeejf dedededefddZG dd dZdZdZdZG dd dZG dd deZG dd deZG d d! d!eZejd"ej e d#Z!eeed$Z"ej#eej e f e$d%< 	d<d&e!d'ej%e de!fd(d)Z&d*edej%ej e  fd+d,Z'd-e	d.ede(fd/d0Z)d-e	d1ede(fd2d3Z*d-e	d4ej+e d.ede(fd5d6Z,dedejeejf ded4ej+e de	f
d7d8Z-d-e	d4ej+e d9edej.ej/eef ef fd:d;Z0dS )=    N)gettext   )Argument)BaseCommand)Context)MultiCommand)Option)	Parameter)ParameterSource)split_arg_string)echoclictx_args	prog_namecomplete_varinstructionreturnc           	      C   sf   | d\}}}t|}|du rdS || |||}|dkr%t|  dS |dkr1t|  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   sourcer   complete)	partitionget_completion_classr   r   r   )	r   r   r   r   r   shellr   Zcomp_clscomp r   mC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\click/shell_completion.pyshell_complete   s   r   c                   @   sV   e Zd ZdZdZ		ddejdedeje dejd	df
d
dZ	ded	ejf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!   kwargsr   c                 K      || _ || _|| _|| _d S Nr   )selfr   r    r!   r$   r   r   r   __init__L      
zCompletionItem.__init__namec                 C   s   | j |S r&   )r"   get)r'   r*   r   r   r   __getattr__X   s   zCompletionItem.__getattr__)r#   N)__name__
__module____qualname____doc__	__slots__tAnystrOptionalr(   r,   r   r   r   r   r   7   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)";
c                
   @   s   e Zd ZU dZeje ed< 	 eje ed< 	 dedej	eej
f dededd	f
d
dZedefddZdejeej
f fddZdefddZdejeje ef fddZdeje dedeje fddZdedefddZdef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
    r*   source_templater   r   r   r   r   Nc                 C   r%   r&   )r   r   r   r   )r'   r   r   r   r   r   r   r   r(      r)   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   )flagsZ_completion)resubr   replaceASCII)r'   	safe_namer   r   r   	func_name   s   zShellComplete.func_namec                 C   s   | j | j| jdS )zVars for formatting :attr:`source_template`.

        By default this provides ``complete_func``, ``complete_var``,
        and ``prog_name``.
        )Zcomplete_funcr   r   )r@   r   r   r'   r   r   r   source_vars   s   zShellComplete.source_varsc                 C   s   | j |   S )zProduce the shell script that defines the completion
        function. By default this ``%``-style formats
        :attr:`source_template` with the dict returned by
        :meth:`source_vars`.
        )r7   rB   rA   r   r   r   r      s   zShellComplete.sourcec                 C      t )zUse the env vars defined by the shell script to return a
        tuple of ``args, incomplete``. This must be implemented by
        subclasses.
        NotImplementedErrorrA   r   r   r   get_completion_args   s   z!ShellComplete.get_completion_argsargs
incompletec                 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   )r'   rG   rH   ctxobjr   r   r   get_completions  s   
zShellComplete.get_completionsitemc                 C   rC   )zFormat a completion item into the form recognized by the
        shell script. This must be implemented by subclasses.

        :param item: Completion item to format.
        rD   r'   rN   r   r   r   format_completion  s   zShellComplete.format_completionc                    s4      \}} ||} fdd|D }d|S )zProduce 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   )rP   ).0rN   rA   r   r   
<listcomp>&  s    z*ShellComplete.complete.<locals>.<listcomp>
)rF   rM   join)r'   rG   rH   Zcompletionsoutr   rA   r   r     s   
zShellComplete.complete)r-   r.   r/   r0   r2   ClassVarr4   __annotations__r   MutableMappingr3   r(   propertyr@   DictrB   r   TupleListrF   r   rM   rP   r   r   r   r   r   r6      s>   
 

r6   c                       sl   e Zd ZdZdZeZedddZde	f fddZ
dejeje	 e	f fd	d
Zdede	fddZ  ZS )BashCompletezShell completion for Bash.bashr   Nc                  C   s   dd l } | jg d| jd}td|j }|d ur;| \}}|dk s-|dkr7|dk r9tt	ddd d S d S d S tt	d	dd d S )
Nr   )r^   z-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.)

subprocessrunPIPEr;   searchr_   decodegroupsr   r   )rb   outputmatchmajorminorr   r   r   _check_version0  s&   

	
zBashComplete._check_versionc                    s   |    t  S r&   )rl   superr   rA   	__class__r   r   r   J  s   
zBashComplete.sourcec                 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   r8   r   osenvironint
IndexErrorr'   cwordscwordrG   rH   r   r   r   rF   N     
z BashComplete.get_completion_argsrN   c                 C   s   |j  d|j S )N,)r    r   rO   r   r   r   rP   Z  s   zBashComplete.format_completion)r   N)r-   r.   r/   r0   r*   _SOURCE_BASHr7   staticmethodrl   r4   r   r2   r[   r\   rF   r   rP   __classcell__r   r   rn   r   r]   *  s    r]   c                   @   H   e Zd ZdZdZeZdejej	e
 e
f fddZdede
fddZd	S )
ZshCompletezShell completion for Zsh.zshr   c                 C   rp   rq   rt   ry   r   r   r   rF   d  r|   zZshComplete.get_completion_argsrN   c                 C   s(   |j  d|j d|jr|j S d S )NrS   r   )r    r   r!   rO   r   r   r   rP   p  s   (zZshComplete.format_completionN)r-   r.   r/   r0   r*   _SOURCE_ZSHr7   r2   r[   r\   r4   rF   r   rP   r   r   r   r   r   ^      r   c                   @   r   )
FishCompletezShell completion for Fish.fishr   c                 C   sH   t tjd }tjd }|dd  }|r |r |d |kr |  ||fS )Nrr   rs   r   )r   ru   rv   pop)r'   rz   rH   rG   r   r   r   rF   z  s   
z FishComplete.get_completion_argsrN   c                 C   s2   |j r|j d|j d|j  S |j d|j S )Nr}   	)r!   r    r   rO   r   r   r   rP     s   zFishComplete.format_completionN)r-   r.   r/   r0   r*   _SOURCE_FISHr7   r2   r[   r\   r4   rF   r   rP   r   r   r   r   r   t  r   r   ShellCompleteType)bound)r^   r   r   _available_shellsclsr*   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)r*   r   )r   r*   r   r   r   add_completion_class  s   r   r   c                 C   s
   t | S )zLook 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   r   r   r   r     s   
r   rK   paramc                 C   sl   t |tsdS |jdusJ | j|j}|jdkp5| |jtjup5|jdko5t |t	t
fo5t||jk S )zDetermine 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.
    FNr   r   )
isinstancer   r*   paramsr+   nargsZget_parameter_sourcer
   ZCOMMANDLINEtuplelistlen)rK   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   )Z_opt_prefixes)rK   r   cr   r   r   _start_of_option  s   
r   rG   c                 C   sj   t |tsdS |js|jrdS d}tt|D ]\}}|d |jkr$ nt| |r+|}q|duo4||jv S )zDetermine 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   Zis_flagcount	enumeratereversedr   r   opts)rK   rG   r   Zlast_optionindexargr   r   r   _is_incomplete_option  s   

r   c           	      C   s   d|d< | j || fi |}|j|j }|ru|j}t|trp|jsB|||\}}}|du r2|S |j |||dd}|j|j }n1|}|re|||\}}}|du rU|S |j |||dddd}|j}|sF|}g |j|j}n	 |S |s|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   Zallow_extra_argsallow_interspersed_argsr   )	Zmake_contextcopyZprotected_argsrG   commandr   r   chainZresolve_command)	r   r   r   rG   rK   r   r*   cmdZsub_ctxr   r   r   rI     sB   
$rI   rH   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.
    =r8   z--)r   r   appendr   
get_paramsr   r   )rK   rG   rH   r*   r   r   r   r   r   r   rJ   (  s"   



rJ   r&   )1ru   r;   typingr2   r   r   corer   r   r   r   r   r	   r
   parserr   utilsr   rX   r4   r3   rw   r   r   r~   r   r   r6   r]   r   r   TypeVarTyper   r   rZ   rW   r5   r   r   boolr   r   r\   r   rI   r[   UnionrJ   r   r   r   r   <module>   s   
 
&& ,j4

 	
9