
    /hM                       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 dCdZ G d d          ZdZdZdZ G d d          Z G d d e          Z G d! d"e          Z G d# d$e          Z ej        d%d&'          Zeeed(Z d)e!d*<   	 dDdEd.Z"dFd1Z#dGd4Z$dHd:Z%dId<Z&dJd>Z'dKd?Z(dLdBZ)d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intc                   |                     d          \  }}}t          |          }|dS  || |||          }|dk    r#t          |                                           dS |dk    r#t          |                                           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comps	            I/var/www/html/venv/lib/python3.11/site-packages/click/shell_completion.pyshell_completer!      s    & (11#66E1k#E**Hq8C9l;;DhT[[]]qj  T]]__q1    c                  ,    e Zd ZdZdZ	 	 dddZ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&   t.Anyr'   r   r(   
str | Nonekwargsr   Nonec                >    || _         || _        || _        || _        d S Nr%   )selfr&   r'   r(   r-   s        r    __init__zCompletionItem.__init__N   s$     "
	 $	


r"   namec                6    | j                             |          S r0   )r)   get)r1   r3   s     r    __getattr__zCompletionItem.__getattr__Z   s    z~~d###r"   )r*   N)
r&   r+   r'   r   r(   r,   r-   r+   r   r.   )r3   r   r   r+   )__name__
__module____qualname____doc__	__slots__r2   r6    r"   r    r$   r$   9   sZ         $ 3I
 	
 
 
 
 
$ $ $ $ $ $r"   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                  |    e Zd ZU dZded<   	 ded<   	 ddZed d            Zd!dZd dZ	d"dZ
d#dZd$dZ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
    zt.ClassVar[str]r3   source_templater   r   r   r   r   r   r   r   r.   c                >    || _         || _        || _        || _        d S r0   )r   r   r   r   )r1   r   r   r   r   s        r    r2   zShellComplete.__init__   s'      "(r"   c                    t          j        dd| j                            dd          t           j                  }d| dS )zQThe name of the shell function defined by the completion
        script.
        z\W* -r   )flags_completion)resubr   replaceASCII)r1   	safe_names     r    	func_namezShellComplete.func_name   sA    
 F62t~'='=c3'G'GrxXXX	)9))))r"   dict[str, t.Any]c                ,    | 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   )rK   r   r   r1   s    r    source_varszShellComplete.source_vars   s#     "^ -
 
 	
r"   c                :    | j         |                                 z  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`.
        )r?   rP   rO   s    r    r   zShellComplete.source   s     #d&6&6&8&888r"   tuple[list[str], str]c                    t           )zUse the env vars defined by the shell script to return a
        tuple of ``args, incomplete``. This must be implemented by
        subclasses.
        NotImplementedErrorrO   s    r    get_completion_argsz!ShellComplete.get_completion_args  s
    
 "!r"   args	list[str]
incompletelist[CompletionItem]c                    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!   )r1   rW   rY   ctxobjs        r    get_completionszShellComplete.get_completions	  sH     txMM-c4DDZ!!#z222r"   itemr$   c                    t           )zFormat a completion item into the form recognized by the
        shell script. This must be implemented by subclasses.

        :param item: Completion item to format.
        rT   r1   ra   s     r    format_completionzShellComplete.format_completion  s
     "!r"   c                                                       \  }}                     ||          } f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                :    g | ]}                     |          S r<   )rd   ).0ra   r1   s     r    
<listcomp>z*ShellComplete.complete.<locals>.<listcomp>&  s'    DDDt%%d++DDDr"   
)rV   r`   join)r1   rW   rY   completionsouts   `    r    r   zShellComplete.complete  sY      3355j**4<<DDDDDDDyy~~r"   N)
r   r   r   r   r   r   r   r   r   r.   r   r   )r   rL   r   rR   )rW   rX   rY   r   r   rZ   ra   r$   r   r   )r7   r8   r9   r:   __annotations__r2   propertyrK   rP   r   rV   r`   rd   r   r<   r"   r    r>   r>      s         
 
 
 %$$$
) 
) 
) 
) * * * X*

 

 

 

9 9 9 9" " " "
3 
3 
3 
3" " " "
 
 
 
 
 
r"   r>   c                  T     e Zd ZdZdZeZedd            Zd fdZ	dd	Z
ddZ xZS )BashCompletezShell completion for Bash.bashr   r.   c                    dd l } dd l}|                     d          }|d }nL|                    |dddg|j                  }t          j        d|j                                                  }|M|	                                \  }}|dk     s|dk    r&|dk     r"t          t          d	          d
           d S d S d S t          t          d          d
           d S )Nr   rt   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PIPErF   searchrv   decodegroupsr   r   )ry   rz   bash_exematchoutputmajorminors          r    _check_versionzBashComplete._check_version0  s&   <<''EE^^8T+CD! $  F I3V]5I5I5K5KLLE <<>>LE5s{{esllus{{4        +l{{ TUU     r"   r   c                l    |                                   t                                                      S r0   )r   superr   )r1   	__class__s    r    r   zBashComplete.sourceQ  s)    ww~~r"   rR   c                    t          t          j        d                   }t          t          j        d                   }|d|         }	 ||         }n# t          $ r d}Y nw xY w||fS N
COMP_WORDS
COMP_CWORDr   rB   split_arg_stringosenvironr   
IndexErrorr1   cwordscwordrW   rY   s        r    rV   z BashComplete.get_completion_argsU  x    !"*\":;;BJ|,--ag	JJ 	 	 	JJJ	 Z   
A A"!A"ra   r$   c                $    |j          d|j         S )N,)r'   r&   rc   s     r    rd   zBashComplete.format_completiona  s    )**dj***r"   )r   r.   rm   rn   ro   )r7   r8   r9   r:   r3   _SOURCE_BASHr?   staticmethodr   r   rV   rd   __classcell__)r   s   @r    rs   rs   *  s        $$D"O   \@           
  
  
  
 + + + + + + + +r"   rs   c                  *    e Zd ZdZdZeZddZdd	Zd
S )ZshCompletezShell completion for Zsh.zshr   rR   c                    t          t          j        d                   }t          t          j        d                   }|d|         }	 ||         }n# t          $ r d}Y nw xY w||fS r   r   r   s        r    rV   zZshComplete.get_completion_argsk  r   r   ra   r$   r   c                F    |j          d|j         d|j        r|j        nd S )Nri   r   )r'   r&   r(   rc   s     r    rd   zZshComplete.format_completionw  s/    )NNtzNN$)-LTYYNNNr"   Nrn   ro   )	r7   r8   r9   r:   r3   _SOURCE_ZSHr?   rV   rd   r<   r"   r    r   r   e  sR        ##D!O
  
  
  
 O O O O O Or"   r   c                  *    e Zd ZdZdZeZddZdd	Zd
S )FishCompletezShell completion for Fish.fishr   rR   c                    t          t          j        d                   }t          j        d         }|dd          }|r"|r |d         |k    r|                                 ||fS )Nr   r   r   )r   r   r   pop)r1   r   rY   rW   s       r    rV   z FishComplete.get_completion_args  sf    !"*\":;;Z-
abbz  	$ 	48z#9#9HHJJJZr"   ra   r$   r   c                d    |j         r|j         d|j         d|j          S |j         d|j         S )Nr   	)r(   r'   r&   rc   s     r    rd   zFishComplete.format_completion  sF    9 	<i;;$*;;	;;;)**dj***r"   Nrn   ro   )	r7   r8   r9   r:   r3   _SOURCE_FISHr?   rV   rd   r<   r"   r    r   r   {  sL        $$D"O
  
  
  
 + + + + + +r"   r   ShellCompleteTypeztype[ShellComplete])bound)rt   r   r   zdict[str, type[ShellComplete]]_available_shellsclsr3   r,   c                ,    || 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.
    )r3   r   )r   r3   s     r    add_completion_classr     s      |x!dJr"   r   type[ShellComplete] | Nonec                6    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   r5   )r   s    r    r   r     s       '''r"   stringrX   c                    ddl }|                     | d          }d|_        d|_        g }	 |D ]}|                    |           n*# t          $ r |                    |j                   Y nw xY w|S )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)posixrB   )shlexwhitespace_split
commentersappend
ValueErrortoken)r   r   lexrl   r   s        r    r   r     s    $ LLL
++fD+
)
)CCCN
C 	 	EJJu	    	

39	 Js   A $A/.A/r^   r   paramr   boolc                `   t          |t                    sdS |j        J | j                            |j                  }|j        dk    pd|                     |j                  t          j        up>|j        dk    o3t          |t          t          f          ot          |          |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   r3   paramsr5   nargsget_parameter_sourcer   COMMANDLINEtuplelistlen)r^   r   r&   s      r    _is_incomplete_argumentr     s     eX&& u:!!!JNN5:&&Er 	
##EJ//7RR	
 K!O )55$-00)E

U[(r"   r&   c                ,    |sdS |d         }|| j         v S )z5Check if the value looks like the start of an option.Fr   )_opt_prefixes)r^   r&   cs      r    _start_of_optionr     s&     uaA!!!r"   rW   c                    t          |t                    sdS |j        s|j        rdS d}t	          t          |                    D ]'\  }}|dz   |j        k    r nt          | |          r|}(|duo||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)r^   rW   r   last_optionindexargs         r    _is_incomplete_optionr     s     eV$$ u}  uK//  
s19u{""EC%% 	Kd"@{ej'@@r"   c           	        d|d<    | j         ||                                fi |5 }|j        |j        z   }|r|j        }t          |t                    r|j        sm|                    ||          \  }}}||cddd           S |                     |||d          5 }|}|j        |j        z   }ddd           n# 1 swxY w Y   n|}|rh|                    ||          \  }}}||cddd           S |                     |||ddd          5 }	|	}|j        }ddd           n# 1 swxY w Y   |h|}g |j        |j        }nn|ddd           n# 1 swxY 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_argsrW   commandr   r	   chainresolve_command)
r   r   r   rW   r^   r   r3   cmdsub_ctxsub_sub_ctxs
             r    r\   r\     s    %)H !		)TYY[[	=	=H	=	= )"SX- &	kG'5)) #}  E&-&=&=c4&H&HOD#t{") ) ) ) ) ) ) ) ))d3$ *   > %"2SX=	> > > > > > > > > > > > > > > "G 0*1*A*A#t*L*Lc4;#&3) ) ) ) ) ) ) )6 !--  #&-149.2 .   	0 )&1G#*<D	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0 	0  0" "CDW4Dw|DDDM  &	) ) ) ) ) ) ) ) ) ) ) ) ) ) )V Jsf   AEE B>2E>C	EC	%E8E
D)E)D-	-E0D-	1EE ErY   tuple[Command | Parameter, str]c                   |dk    rd}nBd|v r>t          | |          r.|                    d          \  }}}|                    |           d|vrt          | |          r	| j        |fS | j                            |           }|D ]}t          | ||          r||fc S |D ]}t          | |          r||fc S | 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.
    =rB   z--)r   r   r   r   
get_paramsr   r   )r^   rW   rY   r3   r   r   r   s          r    r]   r]   X  s    S

	
		/Z@@	(22377aD 4,S*=={J&&[##C((F  % % dE22 	%*$$$$	%
  % %"3.. 	%*$$$$	%
 ;
""r"   )r   r   r   r   r   r   r   r   r   r   r   r   r0   )r   r   r3   r,   r   r   )r   r   r   r   )r   r   r   rX   )r^   r   r   r   r   r   )r^   r   r&   r   r   r   )r^   r   rW   rX   r   r   r   r   )
r   r   r   r   r   r   rW   rX   r   r   )r^   r   rW   rX   rY   r   r   r   )*
__future__r   collections.abcabccabcr   rF   typingtr   r   corer   r   r   r	   r
   r   r   utilsr   r!   r$   r   r   r   r>   rs   r   r   TypeVarr   r   rp   r   r   r   r   r   r   r\   r]   r<   r"   r    <module>r      s   " " " " " " "       				 				                                                     ! ! ! ! ! !      # # # #L"$ "$ "$ "$ "$ "$ "$ "$L@*X.e e e e e e e eP8+ 8+ 8+ 8+ 8+= 8+ 8+ 8+vO O O O O- O O O,+ + + + += + + +2 AI19NOOO  5 5      04    (( ( ( (" " " "J   2" " " "A A A A0: : : :z,# ,# ,# ,# ,# ,#r"   