o
    q>e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   comp_clscomp r   W/var/www/bmteknikk.ddns.net/venv/lib/python3.10/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   )flags_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``.
        )complete_funcr   r   )rB   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`.
        )r8   rE   rD   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.
        NotImplementedErrorrD   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(   rJ   rK   ctxobjr   r   r   get_completions  s   
zShellComplete.get_completionsitemc                 C   rF   )zFormat a completion item into the form recognized by the
        shell script. This must be implemented by subclasses.

        :param item: Completion item to format.
        rG   r(   rQ   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   )rS   ).0rQ   rD   r   r   
<listcomp>&  s    z*ShellComplete.complete.<locals>.<listcomp>
)rI   rP   join)r(   rJ   rK   completionsoutr   rD   r   r     s   
zShellComplete.complete)r.   r/   r0   r1   r3   ClassVarr5   __annotations__r   MutableMappingr4   r)   propertyrB   DictrE   r   TupleListrI   r   rP   rS   r   r   r   r   r   r7      s>   
 

r7   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   )rb   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=   searchrc   decodegroupsr   r   )rf   outputmatchmajorminorr   r   r   _check_version0  s&   

	
zBashComplete._check_versionc                    s   |    t  S r'   )rp   superr   rD   	__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   r9   r   osenvironint
IndexErrorr(   cwordscwordrJ   rK   r   r   r   rI   N     
z BashComplete.get_completion_argsrQ   c                 C   s   |j  d|j S )N,)r!   r    rR   r   r   r   rS   Z  s   zBashComplete.format_completion)r   N)r.   r/   r0   r1   r+   _SOURCE_BASHr8   staticmethodrp   r5   r   r3   r_   r`   rI   r   rS   __classcell__r   r   rr   r   ra   *  s    ra   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   rt   ru   rx   r}   r   r   r   rI   d  r   zZshComplete.get_completion_argsrQ   c                 C   s(   |j  d|j d|jr|j S d S )NrV   r   )r!   r    r"   rR   r   r   r   rS   p  s   (zZshComplete.format_completionN)r.   r/   r0   r1   r+   _SOURCE_ZSHr8   r3   r_   r`   r5   rI   r   rS   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 )Nrv   rw   r   )r   ry   rz   pop)r(   r~   rK   rJ   r   r   r   rI   z  s   
z FishComplete.get_completion_argsrQ   c                 C   s2   |j r|j d|j d|j  S |j d|j S )Nr   	)r"   r!   r    rR   r   r   r   rS     s   zFishComplete.format_completionN)r.   r/   r0   r1   r+   _SOURCE_FISHr8   r3   r_   r`   r5   rI   r   rS   r   r   r   r   r   t  r   r   ShellCompleteType)bound)rb   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   rN   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,   nargsget_parameter_sourcer
   COMMANDLINEtuplelistlen)rN   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)rN   r    cr   r   r   _start_of_option  s   
r   rJ   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   is_flagcount	enumeratereversedr   r   opts)rN   rJ   r   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   allow_extra_argsallow_interspersed_argsr   )	make_contextcopyprotected_argsrJ   commandr   r   chainresolve_command)	r   r   r   rJ   rN   r   r+   cmdsub_ctxr   r   r   rL     sB   
$rL   rK   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.
    =r9   z--)r   r   appendr   
get_paramsr   r   )rN   rJ   rK   r+   r   r   r   r   r   r   rM   (  s"   



rM   r'   )1ry   r=   typingr3   r   r   corer   r   r   r   r   r	   r
   parserr   utilsr   r\   r5   r4   r{   r   r   r   r   r   r7   ra   r   r   TypeVarTyper   r   r^   r[   r6   r   r   boolr   r   r`   r   rL   r_   UnionrM   r   r   r   r   <module>   s   
 
&& ,j4

 	
9