
    VhS                       d Z ddlmZ ddlZddlmZ ddlZddlZddlZddl	Z	ddl
Z
ddlZdZdZdZej                    G d de             Zej                    G d	 d
e             Zej                    G d de             Zej                    G d de             Z G d dej,                        Z G d de      Zej                    G d d             Zej                    G d d             Zej                    G d d             Z G d dej8                        Z G d dej<                        Z G d deej8                        Z  G d  d!e       Z! G d" d#e!      Z" G d$ d%e       Z# G d& d'e!      Z$ G d( d)e!      Z% G d* d+e       Z& G d, d-e      Z' G d. d/e      Z( G d0 d1eej8                        Z) G d2 d3e)      Z* G d4 d5eej8                        Z+ G d6 d7eej8                        Z, G d8 d9eej8                        Z-y):z:General purpose composite argument parsing and completion.    )annotationsN,=/c                      e Zd ZdZy)
Completionz+Base class for argument completion results.N__name__
__module____qualname____doc__     ]/home/dcms/DCMS/lib/python3.12/site-packages/ansible_test/_internal/cli/argparsing/parsers.pyr   r      s    5r   r   c                       e Zd ZU dZdZded<   y)CompletionUnavailablez Argument completion unavailable.zNo completions available.strmessageNr
   r   r   r   r   __annotations__r   r   r   r   r       s    *.GS.r   r   c                       e Zd ZU dZdZded<   y)CompletionErrorzArgument completion error.Nt.Optional[str]r   r   r   r   r   r   r   '   s    $#G_#r   r   c                      e Zd ZU dZded<   ded<   ded<    ej                  e      Zded	<   e	dd
       Z
e	dd       Zy)CompletionSuccessz&Successful argument completion result.bool	list_moder   consumedcontinuationdefault_factory	list[str]matchesc                N    t        | j                        dkD  xr | j                  S )z
        True if argcomplete should not mangle completion values, otherwise False.
        Only used when more than one completion exists to avoid overwriting the word undergoing completion.
           )lenr#   r   selfs    r   preservezCompletionSuccess.preserve7   s!     4<< 1$77r   c                    | j                   }| j                  rdn| j                  }| j                  s|D cg c]  }| j                   | |  }}|S c c}w )z3List of completion values to return to argcomplete. )r#   r   r   r)   r   )r(   completionsr   
completions       r   r,   zCompletionSuccess.completions?   sW     ll!^^r1B1B}}ZefJdmm_ZLGfKf gs   ANreturnr   )r/   r"   )r
   r   r   r   r   dataclassesfieldlistr#   propertyr)   r,   r   r   r   r   r   .   sR    0OM***4@GY@8 8 	 	r   r   c                  v    e Zd ZdZ ej
                         Z ej
                         Z ej
                         Zy)
ParserModez Mode the parser is operating in.N)	r
   r   r   r   enumautoPARSECOMPLETELISTr   r   r   r5   r5   L   s,    *DIIKEtyy{H499;Dr   r5   c                      e Zd ZdZy)ParserErrorz&Base class for all parsing exceptions.Nr	   r   r   r   r<   r<   T   s    0r   r<   c                  B    e Zd ZU dZded<   ded<   dZded<   d	Zded
<   y)ParserBoundaryz-Boundary details for parsing composite input.r   
delimitersr   requiredNr   matchTready)r
   r   r   r   r   rA   rB   r   r   r   r>   r>   X   s#    7ON!E?!E4r   r>   c                  P   e Zd ZU dZded<   dZded<   dZded<    ej                  e	      Z
d	ed
<    ej                  e	      Zded<    ej                  e	      Zded<   edd       ZddZddZedd       Zedd       Zedd       ZddZej,                  ddd       Zy) ParserStatez'State of the composite argument parser.r5   moder+   r   	remainderr   r    zlist[ParserBoundary]
boundarieszlist[t.Any]
namespacesr"   partsc                    | j                   duS )zHTrue if parsing is incomplete (unparsed input remains), otherwise False.N)rF   r'   s    r   
incompletezParserState.incompletem   s     ~~T))r   c                    | j                   r-| j                   j                  | j                   j                  }}nd\  }}|D ])  }|j                  |      |k(  r||k(  s y| | |k(  s) y y)z|Return True if the given value matches the provided choices, taking into account parsing boundaries, otherwise return False.)r+   NTF)current_boundaryr?   rA   rstrip)r(   valuechoicesr?   	delimiterchoices         r   rA   zParserState.matchr   s{      $($9$9$D$DdF[F[FaFa	J$,!J	 	 F}}Z(F2F? WYK(F2	  r   c                   dj                  d | j                  D              }|rMdt        j                  |      z   dz   }t        j                  |      }|j                  | j                  d      }n| j                  g}t        |      dkD  r|\  }}}n	|d   dd}}}t        | j                        D ]O  }|r/||j                  v r!||_
        | xj                  ||z   z  c_         nd|_
        d|_        |j                  sO n || _        |S )	zORead and return the next input segment, taking into account parsing boundaries.r+   c              3  4   K   | ]  }|j                     y wN)r?   ).0boundarys     r   	<genexpr>z#ParserState.read.<locals>.<genexpr>   s     QXX00Qs   z([z])r%   r   NF)joinrG   reescapecompilesplitrF   r&   reversedr?   rA   r   rB   r@   )	r(   r?   patternregexrI   rO   rQ   rF   rW   s	            r   readzParserState.read   s    WWQQQ
RYYz22T9GJJw'EKK2E^^$Eu:>*/'E9i*/(D$i9E 1 
	HY(*=*==!*!22!HN"HN  
	 #r   c                     | j                   d   S )zTHe root namespace.r   rH   r'   s    r   root_namespacezParserState.root_namespace   s     q!!r   c                     | j                   d   S )zThe current namespace.rc   r'   s    r   current_namespacezParserState.current_namespace   s     r""r   c                <    | j                   r| j                   d   S dS )z4The current parser boundary, if any, otherwise None.rf   N)rG   r'   s    r   rM   zParserState.current_boundary   s     '+ootr"?4?r   c                :    | j                   j                  |       y)zSet the current namespace.N)rH   append)r(   	namespaces     r   set_namespacezParserState.set_namespace   s    y)r   c              #     K   t        ||      }| j                  j                  |       	 | | j                  j                          |j                  r|j
                  st        d      yy# | j                  j                          w xY ww)z0Context manager for delimiting parsing of input.)r?   r@   zLrequired delimiter not found, hit up-level delimiter or end of input insteadN)r>   rG   rj   popr@   rA   r<   )r(   r?   r@   rW   s       r   delimitzParserState.delimit   sv      "Z(Kx(	"NOO!X^^lmm &4 OO!s   )BA/ ?B/BBNr.   )rO   r   rP   r"   r/   r   r/   r   r/   t.Any)r/   zt.Optional[ParserBoundary])rk   rr   r/   None)T)r?   r   r@   r   r/   zc.Iterator[ParserBoundary])r
   r   r   r   r   rF   r   r0   r1   r2   rG   rH   rI   r3   rK   rA   ra   rd   rg   rM   rl   
contextlibcontextmanagerro   r   r   r   rD   rD   b   s    1
IsHc'8{'8'8'NJ$N/k//EJE({((>E9>* *&@ " " # # @ @* n nr   rD   c                  B    e Zd ZU dZ ej
                  e      Zded<   y)DocumentationStatezAState of the composite argument parser's generated documentation.r    zdict[str, str]sectionsN)	r
   r   r   r   r0   r1   dictrx   r   r   r   r   rw   rw      s    K0{00FHnFr   rw   c                  >    e Zd ZdZej
                  dd       ZddZy)Parserz.Base class for all composite argument parsers.c                     y;Parse the input from the given state and return the result.Nr   r(   states     r   parsezParser.parse       r   c                0    t        dt        |              )2Generate and return documentation for this parser.zUndocumented parser: )	Exceptiontyper   s     r   documentzParser.document   s    /T
|<==r   Nr   rD   r/   rr   r   rw   r/   r   )r
   r   r   r   abcabstractmethodr   r   r   r   r   r{   r{      s$    8J J>r   r{   )	metaclassc                  z    e Zd ZdZ ej
                         Z	  ej
                         Z	  ej
                         Zy)MatchConditionszEAcceptable condition(s) for matching user input to available choices.N)	r
   r   r   r   r6   r7   CHOICEANYNOTHINGr   r   r   r   r      s5    OTYY[F
$))+C%diikGJr   r   c                  n    e Zd ZdZej
                  fddZej                  d	d       Z	d
dZ
ddZddZy)DynamicChoicesParserznBase class for composite argument parsers which use a list of choices that can be generated during completion.c                    || _         y rU   
conditions)r(   r   s     r   __init__zDynamicChoicesParser.__init__   s	    $r   c                     y)>Return a list of valid choices based on the given input value.Nr   r(   rO   s     r   get_choicesz DynamicChoicesParser.get_choices   r   r   c                    t               S )XReturn an instance of CompletionUnavailable when no match was found for the given value.)r   r   s     r   no_completion_matchz(DynamicChoicesParser.no_completion_match   s    $&&r   c                    t        d      S )RReturn an instance of ParserError when parsing fails and no choices are available.zNo choices available.)r<   r   s     r   no_choices_availablez)DynamicChoicesParser.no_choices_available   s    233r   c                   |j                         }| j                  |      }|j                  t        j                  k(  s|j
                  r| j                  t        j                  z  r|j                  ||      r|S | j                  t        j                  z  r|r|S | j                  t        j                  z  r&|s$|j                  r|j                  j                  s|S |j                  t        j                  k(  r3|r t        d| ddj                  |             | j                  |      t!               |D cg c]  }|j#                  |      s| }}|s| j%                  |      |j                  r,|j                  j&                  r|j                  j(                  nd}t+        |j                  t        j,                  k(  |j.                  ||      c c}w )r~   "z
" not in: z, r+   )r   r   r   r#   )ra   r   rE   r5   r8   rK   r   r   r   rA   r   r   rM   r<   rY   r   r   
startswithr   r@   r?   r   r:   r   )r(   r   rO   rP   rR   r#   r   s          r   r   zDynamicChoicesParser.parse   s   

""5)::)))U-=-=!7!77EKKw<W!4!44!8!885KaKajo  kA  kA  kG  kGzzZ---%%
499W;M:N&OPP//66'))(/Lf63D3DU3K6LL**511<A<R<RW\WmWmWvWvu--88|~jjJOO3^^%	
 	
 Ms   >GGN)r   r   r/   rs   rO   r   r/   r"   rO   r   r/   r   rO   r   r/   r<   r   )r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r      s>    x5D5K5K % 	M M'4#
r   r   c                  L     e Zd ZdZej
                  fd fdZddZddZ xZ	S )ChoicesParserzCComposite argument parser which relies on a static list of choices.c                4    || _         t        | 	  |       y Nr   rP   superr   )r(   rP   r   	__class__s      r   r   zChoicesParser.__init__!  s    J/r   c                    | j                   S )r   )rP   r   s     r   r   zChoicesParser.get_choices&  s    ||r   c                8    dj                  | j                        S )r   |)rY   rP   r   s     r   r   zChoicesParser.document*  s    xx%%r   )rP   r"   r   r   r/   rs   r   r   )
r
   r   r   r   r   r   r   r   r   __classcell__r   s   @r   r   r     s    MIXI_I_ 0
&r   r   c                  H     e Zd ZdZej
                  fd fdZd fdZ xZS )EnumValueChoicesParserzfComposite argument parser which relies on a static list of choices derived from the values of an enum.c                    || _         t        | 	  |D cg c]  }t        |j                         c}|       y c c}w )N)rP   r   )	enum_typer   r   r   rO   )r(   r   r   itemr   s       r   r   zEnumValueChoicesParser.__init__2  s3    "i!Hd#djj/!HU_`!Hs   <c                D    t         |   |      }| j                  |      S r~   )r   r   r   r(   r   rO   r   s      r   r   zEnumValueChoicesParser.parse7  s     e$~~e$$r   )r   zt.Type[enum.Enum]r   r   r/   rs   r   )	r
   r   r   r   r   r   r   r   r   r   s   @r   r   r   /  s    pSbSiSi a
% %r   r   c                  f     e Zd ZdZ ej
                  d      Zdd fdZd	dZd
 fdZ	ddZ
 xZS )IntegerParserz'Composite argument parser for integers.z^[1-9][0-9]*$c                0    || _         t        | 	          y rU   )maximumr   r   )r(   r   r   s     r   r   zIntegerParser.__init__B      r   c                v   |st        t        dd            }nO| j                  j                  |      r2t	        |      }|dz  }|gt        dd      D cg c]  }||z   	 c}z   }ng }| j
                  |D cg c]  }|| j
                  k  s| }}|D cg c]  }t        |       c}S c c}w c c}w c c}w )r   r%   
   r   )r2   rangePATTERNsearchintr   r   )r(   rO   numbers
int_prefixbaseins          r   r   zIntegerParser.get_choicesG  s    5B<(G\\  'UJ?D!la%E1dQh%EEGG <<#")?QQ$,,->q?G? '(1A(( &F @(s   B,8B1B1B6c                8    t         |   |      }t        |      S r   )r   r   r   r   s      r   r   zIntegerParser.parseY  s    e$5zr   c                     y)r   z	{integer}r   r   s     r   r   zIntegerParser.document^  s    r   rU   )r   zt.Optional[int]r/   rs   r   r   r   )r
   r   r   r   rZ   r\   r   r   r   r   r   r   r   s   @r   r   r   =  s*    1bjj)G
)$
r   r   c                  0     e Zd ZdZd fdZd fdZ xZS )BooleanParserz6Composite argument parser for boolean (yes/no) values.c                (    t         |   ddg       y )Nyesno)r   r   )r(   r   s    r   r   zBooleanParser.__init__f  s    %'r   c                ,    t         |   |      }|dk(  S )r~   r   r   r   r   s      r   r   zBooleanParser.parsei  s    e$~r   )r/   rs   )r   rD   r/   r   )r
   r   r   r   r   r   r   r   s   @r   r   r   c  s    @( r   r   c                  >     e Zd ZdZdd fdZd fdZd fdZ xZS )		AnyParserz8Composite argument parser which accepts any input value.c                    || _         t        j                  }|r|t        j                  z  }t        |   g |       y r   )no_match_messager   r   r   r   r   )r(   nothingr   r   r   s       r   r   zAnyParser.__init__r  s;     0$((
/111J
3r   c                f    | j                   rt        | j                         S t        |   |      S )r   )r   )r   r   r   r   r(   rO   r   s     r   r   zAnyParser.no_completion_match|  s-      (1F1FGGw*511r   c                d    | j                   rt        | j                         S t        |   |      S )r   )r   r<   r   r   r   s     r   r   zAnyParser.no_choices_available  s-      t4455w+E22r   )FN)r   r   r   r   r/   rs   r   r   )r
   r   r   r   r   r   r   r   r   s   @r   r   r   o  s    B423 3r   r   c                  4     e Zd ZdZddgZd fdZddZ xZS )RelativePathNameParserz2Composite argument parser for relative path names..z..c                0    || _         t        | 	          y rU   r   )r(   rP   r   s     r   r   zRelativePathNameParser.__init__  r   r   c                    t        | j                        }|| j                  v r"|j                  d | j                  D               |S )r   c              3  0   K   | ]  }| t            y wrU   )PATH_DELIMITER)rV   r   s     r   rX   z5RelativePathNameParser.get_choices.<locals>.<genexpr>  s     UdVN#34Us   )r2   rP   RELATIVE_NAMESextend)r(   rO   rP   s      r   r   z"RelativePathNameParser.get_choices  s=    t||$D''' NNUATATUUr   )rP   r"   r/   rs   r   )r
   r   r   r   r   r   r   r   r   s   @r   r   r     s    <4[N
	r   r   c                      e Zd ZdZddZy)
FileParserz>Composite argument parser for absolute or relative file paths.c                   |j                   t        j                  k(  rHt               j	                  |      }t
        j                  j                  |      st        d|       |S d}|j                  t        d      5 }|j                  r|xs d}	 t        j                  |      5 }|D cg c]2  }|j                         r|j                   t         n|j                  4 }}ddd       |s&j!                  t               |j!                  d       t#              j	                  |      }|| |j$                  xs d z  }|j                  rddd       |S c c}w # 1 sw Y   ~xY w# t        $ r g }Y w xY w# 1 sw Y   |S xY w)r~   zNot a file: r+   Fr@   r   Nz../)rE   r5   r8   r   r   ospathisfiler<   ro   r   rB   scandiris_dirnameOSErrorrj   r   rA   )	r(   r   r   rW   	directoryscanr   rP   parts	            r   r   zFileParser.parse  si   ::)));$$U+D77>>$'!L"788* ' D~> <(nn $I%ZZ	2 xdrv&wjn$))^4D'E\`\e\e'e&wG&wx
  ~6u-1':@@GDtfX^^%9r$:;;D nn<"  'xx x" %"$%<" s[   ?F E/(E#-7E$E#&E/.A%F E##E,	(E//E=:F <E==F  F
N)r   rD   r/   r   r
   r   r   r   r   r   r   r   r   r     s
    Hr   r   c                      e Zd ZdZddZy)AbsolutePathParserzpComposite argument parser for absolute file paths. Paths are only verified for proper syntax, not for existence.c                B   d}|j                  t        d      5 }|j                  rc|r|t        d      j	                  |      z  }n"|t        t        g      j	                  |      z  }||j                  xs dz  }|j                  rcddd       |S # 1 sw Y   |S xY w)r~   r+   Fr   T)r   N)ro   r   rB   r   r   r   rA   )r(   r   r   rW   s       r   r   zAbsolutePathParser.parse  s    ]]>E]: 	-h..Id399%@@DM>*:;AA%HHD,", ..	- 	- s   A/BBNr   r   r   r   r   r   r     s
    zr   r   c                       e Zd ZdZddZd fdZedd       Zedd       Zee	j                  d	d              Z xZS )
NamespaceParserzRBase class for composite argument parsers that store their results in a namespace.c                   |j                   }t        || j                        }|r?| j                  r3|j                  t
        j                  k(  rt        d      t        d      | j                  |      }| j                  r.|sg }t        || j                  |       |j                  |       |S t        || j                  |       |S )r~   z*Option cannot be specified more than once.)rg   getattrdest	limit_onerE   r5   r8   r<   r   	get_valueuse_listsetattrrj   )r(   r   rk   currentrO   s        r   r   zNamespaceParser.parse  s    ++	)TYY/t~~zzZ---!"NOO!"NOOu%==	499g6NN5!  Ityy%0r   c                "    t         |   |      S zhParse the input from the given state and return the result, without storing the result in the namespace.r   )r(   r   r   s     r   r   zNamespaceParser.get_value  s    w}U##r   c                     y)z3True if the destination is a list, otherwise False.Fr   r'   s    r   r   zNamespaceParser.use_list       r   c                    | j                    S )z4True if only one target is allowed, otherwise False.)r   r'   s    r   r   zNamespaceParser.limit_one  s     ==  r   c                     y);The name of the attribute where the value should be stored.Nr   r'   s    r   r   zNamespaceParser.dest  r   r   r   r.   rp   )r
   r   r   r   r   r   r3   r   r   r   r   r   r   r   s   @r   r   r     s\    \0$   ! ! J  Jr   r   c                  2    e Zd ZdZddZddZedd       Zy)	NamespaceWrappedParserzaComposite argument parser that wraps a non-namespace parser and stores the result in a namespace.c                     || _         || _        y rU   )_destparser)r(   r   r  s      r   r   zNamespaceWrappedParser.__init__  s    
r   c                8    | j                   j                  |      S r  )r  r   r   s     r   r   z NamespaceWrappedParser.get_value  s    {{  ''r   c                    | j                   S )r  )r  r'   s    r   r   zNamespaceWrappedParser.dest  s     zzr   N)r   r   r  r{   r/   rs   r   rp   )r
   r   r   r   r   r   r3   r   r   r   r   r
  r
    s#    k(  r   r
  c                  >    e Zd ZdZej
                  dd       ZddZy)KeyValueParserz4Base class for key/value composite argument parsers.c                     y)z3Return a dictionary of key names and value parsers.Nr   r   s     r   get_parserszKeyValueParser.get_parsers  r   r   c                   |j                   }| j                  |      }t        |      }|j                  t        d      5 }|j
                  rw|j                  t              5  t        |      j                  |      }ddd       |   j                  |      }t        |||       |j                  |       |j
                  rwddd       |S # 1 sw Y   RxY w# 1 sw Y   |S xY w)r~   Fr   N)rg   r  r2   ro   PAIR_DELIMITERrB   ASSIGNMENT_DELIMITERr   r   r   remove)r(   r   rk   parserskeyspairkeyrO   s           r   r   zKeyValueParser.parse  s    ++	""5)G}]]>E]: 		!d**]]#78 ;'-33E:C;  **51	3.C  **		! ; ;		! s%    "C"C=ACC	CC$Nr   rD   r/   dict[str, Parser]r   )r
   r   r   r   r   r   r  r   r   r   r   r  r    s$    >B Br   r  c                      e Zd ZdZd	dZed
d       Zedd       Zej                  dd       Z
ej                  dd       Zej                  dd       Zy)
PairParserz~Base class for composite argument parsers consisting of a left and right argument parser, with input separated by a delimiter.c                V   | j                         }|j                  |       |j                  | j                  | j                        5 }| j                  |      j                  |      }ddd       j                  r | j                        j                  |       |S # 1 sw Y   7xY wr}   )	create_namespacerl   ro   rQ   r@   get_left_parserr   rA   get_right_parser)r(   r   rk   rW   rR   s        r   r   zPairParser.parse3  s    ))+	I&]]4>>4==9 	>X))%066u=F	> >>!!&)//6	> 	>s   !BB(c                     y)zKTrue if the delimiter (and thus right parser) is required, otherwise False.Fr   r'   s    r   r@   zPairParser.requiredA  r  r   c                    t         S )z7The delimiter to use between the left and right parser.)r  r'   s    r   rQ   zPairParser.delimiterF  s
     r   c                     y)zCreate and return a namespace.Nr   r'   s    r   r!  zPairParser.create_namespaceK  r   r   c                     y)z$Return the parser for the left side.Nr   r   s     r   r"  zPairParser.get_left_parserO  r   r   c                     y)z%Return the parser for the right side.Nr   )r(   rR   s     r   r#  zPairParser.get_right_parserS  r   r   Nr   r.   rp   rq   )r   rD   r/   r{   )rR   rr   r/   r{   )r
   r   r   r   r   r3   r@   rQ   r   r   r!  r"  r#  r   r   r   r  r  0  s     I     	- - 	3 3 	4 4r   r  c                  F    e Zd ZdZddZej                  dd       ZddZy)	
TypeParserzBase class for composite argument parsers which parse a type name, a colon and then parse results based on the type given by the type name.c                "    | j                         S )3Return a dictionary of type names and type parsers.)get_stateless_parsersr   s     r   r  zTypeParser.get_parsers[  s    ))++r   c                     y)r,  Nr   r'   s    r   r-  z TypeParser.get_stateless_parsers_  r   r   c                    | j                  |      }|j                  d      5  t        t        |            j	                  |      }ddd       |   j	                  |      }|S # 1 sw Y   xY w)r~   :N)r  ro   r   r2   r   )r(   r   r  r  rO   s        r   r   zTypeParser.parsec  sg    ""5)]]3 	<W.44U;C	< ""5)	< 	<s   $A%%A.Nr  )r/   r  r   )	r
   r   r   r   r  r   r   r-  r   r   r   r   r*  r*  X  s.     V, 	B B	r   r*  ).r   
__future__r   r   collections.abccrt   r0   r6   r   rZ   typingtr  r  r   	dataclassr   r   r   r   r   Enumr5   r<   r>   rD   rw   ABCMetar{   Flagr   r   r   r   r   r   r   r   r   r   r   r
  r  r  r*  r   r   r   <module>r:     s.   @ " 
     	 	   
 6 6 6 /J / / $j $ $ 
  : 1) 1    bn bn bnJ G G G	>s{{ 	>Kdii K5
6S[[ 5
p&( &"%] %#( #L	M 	3 381 , B &,Jf ,J^_ "Vs{{ 6%43;; %4P3;; r   