o
    jx>                     @   s   d Z ddlmZ 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d	Z
d!d
dZd!ddZd"ddZd"ddZdd Zd#ddZdd Zd$ddZdd Zdd ZdS )%z?Provides tab completion functionality for CLIs built with Fire.    )absolute_import)division)print_functionN)inspectutilsbashc                 C   s(   |dkrt | t||S t| t||S )Nfish)_FishScript	_Commands_BashScript)name	componentdefault_optionsshell r   P/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/fire/completion.pyScript   s   r   c              	      s  |pt  }t ||\}}}d}d}d}dd fdd}	g }
t  }|  |t | }|t | }|D ] }|	|jdt|| || d	}|
|j||d
 q>d|
}|j|d}|j  |d| 	dd	dd	ddd|dS )aX  Returns a Bash script registering a completion function for the commands.

  Args:
    name: The first token in the commands, also the name of the command.
    commands: A list of all possible commands that tab completion can complete
        to. Each command is a list or tuple of the string tokens that make up
        that command.
    default_options: A dict of options that can be used with any command. Use
        this if there are flags that can always be appended to a command.
  Returns:
    A string which is the Bash script. Source the bash script to enable tab
    completion in Bash.
  a  # bash completion support for {name}
# DO NOT EDIT.
# This script is autogenerated by fire/completion.py.

_complete-{identifier}()
{{
  local cur prev opts lastcommand
  COMPREPLY=()
  prev="${{COMP_WORDS[COMP_CWORD-1]}}"
  cur="${{COMP_WORDS[COMP_CWORD]}}"
  lastcommand=$(get_lastcommand)

  opts="{default_options}"
  GLOBAL_OPTIONS="{global_options}"

{checks}

  COMPREPLY=( $(compgen -W "${{opts}}" -- ${{cur}}) )
  return 0
}}

get_lastcommand()
{{
  local lastcommand i

  lastcommand=
  for ((i=0; i < ${{#COMP_WORDS[@]}}; ++i)); do
    if [[ ${{COMP_WORDS[i]}} != -* ]] && [[ -n ${{COMP_WORDS[i]}} ]] && [[
      ${{COMP_WORDS[i]}} != $cur ]]; then
      lastcommand=${{COMP_WORDS[i]}}
    fi
  done

  echo $lastcommand
}}

filter_options()
{{
  local opts
  opts=""
  for opt in "$@"
  do
    if ! option_already_entered $opt; then
      opts="$opts $opt"
    fi
  done

  echo $opts
}}

option_already_entered()
{{
  local opt
  for opt in ${{COMP_WORDS[@]:0:$COMP_CWORD}}
  do
    if [ $1 == $opt ]; then
      return 0
    fi
  done
  return 1
}}

is_prev_global()
{{
  local opt
  for opt in $GLOBAL_OPTIONS
  do
    if [ $opt == $prev ]; then
      return 0
    fi
  done
  return 1
}}

complete -F _complete-{identifier} {command}
z;
  case "${{lastcommand}}" in
  {lastcommand_checks}
  esaczQ
    {command})
      {opts_assignment}
      opts=$(filter_options $opts)
    ;;z
      if is_prev_global; then
        opts="${{GLOBAL_OPTIONS}}"
      else
        opts="{options} ${{GLOBAL_OPTIONS}}"
      fiz,
      opts="{options} ${{GLOBAL_OPTIONS}}" c                    s   |  krS S Nr   )commandr   Z%opts_assignment_main_command_templateZ#opts_assignment_subcommand_templater   r   _GetOptsAssignmentTemplate   s   z/_BashScript.<locals>._GetOptsAssignmentTemplate )options)r   opts_assignment
)lastcommand_checks/ .,)r   r   checksr   
identifierglobal_options)
set_GetMapsaddunionkeysformatjoinsortedappendreplace)r   commandsr   r!   options_mapsubcommands_mapZbash_completion_templateZcheck_wrapperZlastcommand_check_templater   linesZcommands_setr   r   r   r   r   r   r   r
   "   sP   

M

r
   c              
   C   s   |pt  }t| ||\}}}d}d}d}d}	t | t | D ]3}
||
 D ]}||j| |
|d7 }q)||
 |D ]}|
| k}||j| |
|rL|	nd|dd7 }q=q#|jd	d
d |D dS )aX  Returns a Fish script registering a completion function for the commands.

  Args:
    name: The first token in the commands, also the name of the command.
    commands: A list of all possible commands that tab completion can complete
        to. Each command is a list or tuple of the string tokens that make up
        that command.
    default_options: A dict of options that can be used with any command. Use
        this if there are flags that can always be appended to a command.
  Returns:
    A string which is the Fish script. Source the fish script to enable tab
    completion in Fish.
  aL  function __fish_using_command
    set cmd (commandline -opc)
    for i in (seq (count $cmd) 1)
        switch $cmd[$i]
        case "-*"
        case "*"
            if [ $cmd[$i] = $argv[1] ]
                return 0
            else
                return 1
            end
        end
    end
    return 1
end

function __option_entered_check
    set cmd (commandline -opc)
    for i in (seq (count $cmd))
        switch $cmd[$i]
        case "-*"
            if [ $cmd[$i] = $argv[1] ]
                return 1
            end
        end
    end
    return 0
end

function __is_prev_global
    set cmd (commandline -opc)
    set global_options {global_options}
    set prev (count $cmd)

    for opt in $global_options
        if [ "--$opt" = $cmd[$prev] ]
            echo $prev
            return 0
        end
    end
    return 1
end

zJcomplete -c {name} -n '__fish_using_command {command}' -f -a {subcommand}
z}complete -c {name} -n '__fish_using_command {command};{prev_global_check} and __option_entered_check --{option}' -l {option}
z and __is_prev_global;)r   r   
subcommandr   --)r   r   prev_global_checkoptionr   c                 s   s    | ]	}d | d V  qdS )"Nr   ).0r3   r   r   r   	<genexpr>  s    z_FishScript.<locals>.<genexpr>)r!   )r"   r#   r&   r%   r'   lstripr(   )r   r,   r   r!   r-   r.   Zfish_sourceZsubcommand_templateZflag_templater2   r   r0   r3   Zcheck_neededr   r   r   r      s6   

-


	r   Fc                 C   s   t |tr|drdS |rdS |tu s|tu s|tu rdS t |ttr'dS g }t|r4||v r4dS t	| rb|du rDt
| pCi }||}|rb|jdv rRdS ttdtd}t |j|rbdS t |trm|d S dS )a  Returns whether a member should be included in auto-completion or help.

  Determines whether a member of an object with the specified name should be
  included in auto-completion or help text(both usage and detailed help).

  If the member name starts with '__', it will always be excluded. If it
  starts with only one '_', it will be included for all non-string types. If
  verbose is True, the members, including the private members, are included.

  When not in verbose mode, some modules and functions are excluded as well.

  Args:
    component: The component containing the member.
    name: The name of the member.
    member: The member itself.
    class_attrs: (optional) If component is a class, provide this as:
      inspectutils.GetClassAttrsDict(component). If not provided, it will be
      computed.
    verbose: Whether to include private members.
  Returns
    A boolean value indicating whether the member should be included.
  __FTN)methodproperty_tuplegetter_)
isinstancestr
startswithr   r   r   typeinspectismoduleisclassr   GetClassAttrsDictgetkindgetattrcollectionsobject)r   r   memberclass_attrsverboseZmodules_to_hideZ
class_attrZtuplegetterr   r   r   MemberVisible  s4   



rM   c                    sF   t tr
 }nt} du rt  fdd|D S )a  Returns a list of the members of the given component.

  If verbose is True, then members starting with _ (normally ignored) are
  included.

  Args:
    component: The component whose members to list.
    class_attrs: (optional) If component is a class, you may provide this as:
      inspectutils.GetClassAttrsDict(component). If not provided, it will be
      computed. If provided, this determines how class members will be treated
      for visibility. In particular, methods are generally hidden for
      non-instantiated classes, but if you wish them to be shown (e.g. for
      completion scripts) then pass in a different class_attr for them.
    verbose: Whether to include private members.
  Returns:
    A list of tuples (member_name, member) of all members of the component.
  Nc              	      s*   g | ]\}}t || d r||fqS )rK   rL   )rM   )r5   member_namerJ   rK   r   rL   r   r   
<listcomp>o  s    
z"VisibleMembers.<locals>.<listcomp>)r=   dictitemsrA   
getmembersr   rD   )r   rK   rL   membersr   rP   r   VisibleMembersU  s   



rV   c                 C   s.   g }| D ]}| dd}|d|  q|S )zTakes a list of fn args and returns a list of the fn's completion strings.

  Args:
    fn_args: A list of the args accepted by a function.
  Returns:
    A list of possible completion strings for that function.
  r<   -r1   )r+   r*   )Zfn_argsZcompletionsargr   r   r   _CompletionsFromArgsv  s
   rY   c                 C   sv   t | s
t | rt| }t|j|j S t| t	t
fr)dd tt| D S t | r0g S dd t| |dD S )a  Gives possible Fire command completions for the component.

  A completion is a string that can be appended to a command to continue that
  command. These are used for TAB-completions in Bash for Fire CLIs.

  Args:
    component: The component whose completions to list.
    verbose: Whether to include all completions, even private members.
  Returns:
    A list of completions for a command that would so far return the component.
  c                 S   s   g | ]}t |qS r   )r>   )r5   indexr   r   r   rQ     s    zCompletions.<locals>.<listcomp>c                 S   s   g | ]\}}t |qS r   )_FormatForCommand)r5   rO   r<   r   r   r   rQ     s    rL   )rA   	isroutinerC   r   ZGetFullArgSpecrY   args
kwonlyargsr=   tuplelistrangelenisgeneratorrV   )r   rL   specr   r   r   Completions  s   


rf   c                 C   s,   t | ts	t| } | dr| S | ddS )a  Replaces underscores with hyphens, unless the token starts with a token.

  This is because we typically prefer hyphens to underscores at the command
  line, but we reserve hyphens at the start of a token for flags. This becomes
  relevant when --verbose is activated, so that things like __str__ don't get
  transformed into --str--, which would get confused for a flag.

  Args:
    token: The token to transform.
  Returns:
    The transformed token.
  r<   rW   )r=   r>   r?   r+   )tokenr   r   r   r[     s
   

r[      c                 c   s    t | st | rt| ddD ]}|fV  qt | rdS |dk r%dS t| i ddD ]\}}t|}|fV  t||d D ]}|f| V  q?q,dS )a	  Yields tuples representing commands.

  To use the command from Python, insert '.' between each element of the tuple.
  To use the command from the command line, insert ' ' between each element of
  the tuple.

  Args:
    component: The component considered to be the root of the yielded commands.
    depth: The maximum depth with which to traverse the member DAG for commands.
  Yields:
    Tuples, each tuple representing one possible command for this CLI.
    Only traverses the member DAG up to a depth of depth.
  Fr\   N   rN   )rA   r]   rC   rf   rV   r[   r	   )r   depth
completionrO   rJ   r   r   r   r   r	     s"   

r	   c                 C   s
   |  dS )NrW   )r?   )rX   r   r   r   	_IsOption  s   
rl   c           
         s   t   }t fdd}tt}|D ]G}t|dkr5t|d r+||d  q||  |d  q|r\|d }t|d }t|rH|}	n|}	|	| | |	|dd | q|||fS )	a  Returns sets of subcommands and options for each command.

  Args:
    name: The first token in the commands, also the name of the command.
    commands: A list of all possible commands that tab completion can complete
        to. Each command is a list or tuple of the string tokens that make up
        that command.
    default_options: A dict of options that can be used with any command. Use
        this if there are flags that can always be appended to a command.
  Returns:
    global_options: A set of all options of the first token of the command.
    subcommands_map: A dict storing set of subcommands for each
        command/subcommand.
    options_map: A dict storing set of options for each subcommand.
  c                      s
   t   S r   )copyr   r   r   r   <lambda>  s   
 z_GetMaps.<locals>.<lambda>ri   r   r<   rW   )	rm   rH   defaultdictr"   rc   rl   r$   r[   r+   )
r   r,   r   r!   r-   r.   r   r0   rX   Zargs_mapr   rn   r   r#     s$   


r#   )Nr   r   )NF)F)rh   )__doc__
__future__r   r   r   rH   rm   rA   firer   r   r
   r   rM   rV   rY   rf   r[   r	   rl   r#   r   r   r   r   <module>   s(   

 

]
9!

#