
    khaM                        d dl Z d dlmZmZmZmZmZ 	 ddlmZ ddl	m
Z
mZmZ ddlmZ ddlmZ erdd	lmZ d
edefdZd
edefdZ G d ded         Z G d d      Z G d de
      Zy# e$ r d dlmZ d dlm
Z
mZmZ Y _w xY w)    N)TYPE_CHECKINGAnyIterableListOptional   )Lexicon)StateMachinestate
transition)
ParseError)debug   )ParserContextvaluereturnc                 $    | j                  d      S )N-
startswithr   s    f/var/www/pru.catia.catastroantioquia-mas.com/tasa/lib/python3.12/site-packages/invoke/parser/parser.pyis_flagr      s    C      c                 $    | j                  d      S )N--r   r   s    r   is_long_flagr      s    D!!r   c                   0     e Zd ZdZdededdf fdZ xZS )ParseResulta(  
    List-like object with some extra parse-related attributes.

    Specifically, a ``.remainder`` attribute, which is the string found after a
    ``--`` in any parsed argv list; and an ``.unparsed`` attribute, a list of
    tokens that were unable to be parsed.

    .. versionadded:: 1.0
    argskwargsr   Nc                 @    t        |   |i | d| _        g | _        y )N )super__init__	remainderunparsed)selfr    r!   	__class__s      r   r%   zParseResult.__init__)   s#    $)&)#%r   )__name__
__module____qualname____doc__r   r%   __classcell__r)   s   @r   r   r      s'    &c &S &T & &r   r   r   c            	       R    e Zd ZdZ	 	 	 dded   ded   deddfdZd	ee	   de
fd
Zy)Parseray  
    Create parser conscious of ``contexts`` and optional ``initial`` context.

    ``contexts`` should be an iterable of ``Context`` instances which will be
    searched when new context names are encountered during a parse. These
    Contexts determine what flags may follow them, as well as whether given
    flags take values.

    ``initial`` is optional and will be used to determine validity of "core"
    options/flags at the start of the parse run, if any are encountered.

    ``ignore_unknown`` determines what to do when contexts are found which do
    not map to any members of ``contexts``. By default it is ``False``, meaning
    any unknown contexts result in a parse error exception. If ``True``,
    encountering an unknown context halts parsing and populates the return
    value's ``.unparsed`` attribute with the remaining parse tokens.

    .. versionadded:: 1.0
    Ncontextsr   initialignore_unknownr   c                    || _         t               | _        || _        |D ]  }t	        dj                  |             |j                  st        d      d}|j                  | j                  v r$t        |j                  |j                              || j                  |j                  <   |j                  D ]Q  }|| j                  v rt        |j                  |            | j                  j                  ||j                         S  y )Nz	Adding {}z%Non-initial contexts must have names.z7A context named/aliased {!r} is already in this parser!)to)
r3   r	   r2   r4   r   formatname
ValueErroraliasesalias)r(   r2   r3   r4   contextexistsr;   s          r   r%   zParser.__init__D   s     	, 	<G+$$W-.<< !HIINF||t}}, w||!<==*1DMM',,'  <DMM)$V]]5%9::##Egll#;<	<r   argvc                    t        | j                  | j                  | j                        }t	        dj                  |             	 |j                  d      }|d| }||d dd }|rt	        dj                  ||             t        |      D ]%  \  }}g }|}	t        |      r|j                  j                  s{d|v rK|j                  d      \  }}
}d}t	        |j                  |	||             |j                  |dz   |f       n,t        |      s t        |      d	kD  r|dd }|d	d |dd	 }}d
}t	        |j                  |||             ||j                   j"                  v xr |j$                  dk7  }|rW|j                   j"                  |   j&                  r4d}t	        |j                  ||             |j                  |dz   |f       nb|D cg c]  }dj                  |       }}d}t	        |j                  |	||             t)        |      D ]  }|j                  |dz   |f        |j*                  rD|j,                  xr |j,                  j.                  }||j                   j"                  v }|r|s|	}g }|D ]  \  }}|j1                  ||        |j3                  |       ( |j5                          |j                  }dj7                  |      |_        |S # t        $ r t        |      }Y w xY wc c}w )a  
        Parse an argv-style token list ``argv``.

        Returns a list (actually a subclass, `.ParseResult`) of
        `.ParserContext` objects matching the order they were found in the
        ``argv`` and containing `.Argument` objects with updated values based
        on any flags given.

        Assumes any program name has already been stripped out. Good::

            Parser(...).parse_argv(['--core-opt', 'task', '--task-opt'])

        Bad::

            Parser(...).parse_argv(['invoke', '--core-opt', ...])

        :param argv: List of argument string tokens.
        :returns:
            A `.ParseResult` (a ``list`` subclass containing some number of
            `.ParserContext` objects).

        .. versionadded:: 1.0
        )r3   r2   r4   zStarting argv: {!r}r   Nr   z"Remainder: argv[{!r}:][1:] => {!r}=z1Splitting x=y expr {!r} into tokens {!r} and {!r}r   z,Splitting {!r} into token {!r} and rest {!r}unknownzE{!r} is a flag for current context & it takes a value, giving it {!r}z-{}z1Splitting multi-flag glob {!r} into {!r} and {!r} )ParseMachiner3   r2   r4   r   r7   indexr9   len	enumerater   resultr'   	partitionappendr   r<   flagscurrent_statetakes_valuereversedwaiting_for_flag_valueflagoptionalinserthandlefinishjoinr&   )r(   r>   machineddashbodyr&   rD   token	mutationsorig_r   msg
full_tokenresterr	have_flagx_restitemrP   subtoken_is_valid_flagrG   s                          r   
parse_argvzParser.parse_argvZ   s   0 LL]]..	
 	#**401	JJt$E FU|L$	4;;E9M &dO @	"LE5 IDu~gnn&=&=%<&+ooc&:OE1eMC#**T5%89$$eai%78%e,Ua!&qJ"')U2AY%DHC#**Z=> !6!66 ?#11Y>  !W__%:%:5%A%M%Mecjj56!((%!)T):;:> ?Qa ? ?Qcjjue<=$,UO @D%,,eai->?@$ --"<<AGLL,A,A).'//2G2G)G& %; E "I ) *uE5)*NN5!A@	"B 	88I.Y  	IE	V !@s   K+ L+LL) NF)r*   r+   r,   r-   r   r   boolr%   r   strr   re   rf   r   r   r1   r1   /   sa    , /1-1$	<?+< /*< 	<
 
<,ptCy p[ pr   r1   c                       e Zd ZdZ edddg        edddg        edddg        eddd	        edd
dd        edddd       dededdfdZdddede	ddf fdZ
ede	fd       ZdeddfdZdeddfdZd*dZdeddfdZd*d Zd!ede	fd"Zd+d#ed$e	ddfd%Zd!eddfd&Zd!eddfd'Zd(eddfd)Z xZS ),rC   r<   complete_flagcomplete_context)enterrA   end)r<   rA   rS   )from_eventr6   see_contextswitch_to_context)rn   ro   actionr6   see_unknown
store_onlyrn   r6   r   Nc                 :    t        dj                  ||             y )NzParseMachine: {!r} => {!r})r   r7   )r(   rn   r6   s      r   changing_statezParseMachine.changing_state   s    *11%<=r   r3   r   r2   r4   c                 p   || _         t        j                  |      x| _        | _        t        dj                  | j                               d | _        d| _        t               | _
        t        j                  |      | _        t        dj                  | j                               t        | 5          y )NzInitialized with context: {!r}FzAvailable contexts: {!r})r4   copydeepcopyr3   r<   r   r7   rO   flag_got_valuer   rG   r2   r$   r%   )r(   r3   r2   r4   r)   s       r   r%   zParseMachine.__init__   s     -&*mmG&<<t|.55dllCD	#!mh/(//>?r   c                     | j                   xr | j                   j                  }|sy| j                   j                  t        u r| j                  sy| j                   j
                  d u}| S )NFT)rO   rL   kindlistrz   	raw_value)r(   rL   	has_values      r   rN   z#ParseMachine.waiting_for_flag_value   s]     ii9DII$9$9 99>>T!$*=*=II''t3	 }r   rX   c                    t        dj                  |             | j                  dk(  r,t        dj                  |             | j                  |       y | j                  rD|| j                  j
                  v r,t        dj                  |             | j                  |       y | j                  rF|| j                  j                  v r.t        dj                  |             | j                  |d       y | j                  r,t        dj                  |             | j                  |       y | j                  rO| j                  j                  r9d	}t        |j                  | j                  |             | j                  |       y || j                  v r| j                  |       y | j                  r|| j                  j
                  v rt        d
j                  |             | j                  j
                  |   }|j                  dk(  rB| j                  j                  |_        d}t        |j                  |j                                y | j                  |       y | j"                  s;t        dj                  |             | j%                  dj                  |             y t        dj                  |             | j                  |       y )NzHandling token: {!r}rA   z!Top-of-handle() see_unknown({!r})zSaw flag {!r}zSaw inverse flag {!r}T)inversez2We're waiting for a flag value so {!r} must be it?z2Context {!r} requires positional args, eating {!r}zSaw (initial-context) flag {!r}helpzGSaw --help in a per-task context, setting task name ({!r}) as its valuez'Can't find context named {!r}, erroringzNo idea what {!r} is!z$Bottom-of-handle() see_unknown({!r}))r   r7   rK   rs   r<   rJ   switch_to_flaginverse_flagsrN   	see_valuemissing_positional_argssee_positional_argr2   rp   r3   r8   r   r4   error)r(   rX   r\   rO   s       r   rR   zParseMachine.handle  s,   $++E23 *5<<UCDU#<<ET\\%7%77/((/0&\\et||'A'AA)0078t4((DKK
 NN5! \\dllBBFC#**T\\512##E*dmm#U#\\et||'9'993::5AB<<%%e,DyyF"!\\..
_cjj,- ##E* &&?FFuMN

299%@A<CCEJK  'r   c                     t        dj                  |             | j                  j                  j	                  |       y )NzStoring unknown token {!r})r   r7   rG   r'   rI   )r(   rX   s     r   rt   zParseMachine.store_onlyJ  s.    *11%89##E*r   c                 0   t        dj                  | j                  r| j                  j                  n| j                               | j                  ry| j                  j                  rcd}dj                  d | j                  j                  D              }| j                  |j                  | j                  j                  |             | j                  r?| j                  | j                  vr&| j                  j                  | j                         y y y )NzWrapping up context {!r}z6'{}' did not receive required positional arguments: {}z, c              3   R   K   | ]  }d j                  |j                         ! yw)z'{}'N)r7   r8   ).0ra   s     r   	<genexpr>z0ParseMachine.complete_context.<locals>.<genexpr>X  s%       aff%s   %')	r   r7   r<   r8   r   rT   r   rG   rI   )r(   r_   namess      r   rk   zParseMachine.complete_contextO  s    &--%)\\!!t||	
 <<DLL@@JCII == E JJszz$,,"3"3U;<<<DLL;KKt||, <<r   r8   c                    t        j                  | j                  |         | _        t	        dj                  |             t	        dj                  | j                  j                               t	        dj                  | j                  j                               t	        dj                  | j                  j                               y )NzMoving to context {!r}zContext args: {!r}zContext flags: {!r}zContext inverse_flags: {!r})	rx   ry   r2   r<   r   r7   r    rJ   r   )r(   r8   s     r   rq   zParseMachine.switch_to_context`  s    }}T]]4%89&--d34"))$,,*;*;<=#**4<<+=+=>?+224<<3M3MNOr   c                 l   | j                   r&d}t        |j                  | j                                | j                   rn| j                   j                  rX| j                   j                  B| j                   j
                  s,d}| j                  |j                  | j                                | j                   r|| j                   j                  e| j                   j
                  rNd}t        |j                  | j                   j                               | j                   j                  dd       y y y y )Nz+Completing current flag {} before moving onz-Flag {!r} needed value and was not given one!z9Saw optional flag {!r} go by w/ no value; setting to TrueTF)cast)	rO   r   r7   rL   r~   rP   r   r8   	set_value)r(   r\   r_   s      r   rj   zParseMachine.complete_flagg  s    99?C#**TYY'( II		%%		##+II&&ACJJszz$)),- 99,,49K9KMC#**TYY^^,-II51	 :L49r   r   c                 j   | j                   r| j                   j                  sy| j                   j                  yg }|j                  | j                  xr | j                  j
                         |j                  || j                  v        t        |      rd}t        |j                  |            y)zs
        Guard against ambiguity when current flag takes an optional value.

        .. versionadded:: 1.0
        FNz9{!r} is ambiguous when given after an optional-value flag)
rO   rP   r~   rI   r<   r   r2   anyr   r7   )r(   r   testsr\   s       r   check_ambiguityzParseMachine.check_ambiguity}  s     		dii00 99* T\\Jdll&J&JKUdmm+,u:MCSZZ.// r   rO   r   c                 X   | j                  |       | j                          |r| j                  j                  |   n|}	 | j                  j                  |   | _        t        dj                  | j
                               d| _
        | j
                  rQ| j
                  j                  s:| }t        dj                  | j
                  |             || j
                  _        y y y # t        $ r9}	 | j                  j                  |   | _        n# t        $ r |w xY wY d }~d }~ww xY w)NzMoving to flag {!r}FzMarking seen flag {!r} as {})r   rj   r<   r   rJ   rO   KeyErrorr3   r   r7   rz   rL   r   )r(   rO   r   evals        r   r   zParseMachine.switch_to_flag  s   T" 	3:t||))$/		**40DI 	#**49956 $99TYY22+C077		3GH!DIIO 39  	 LL..t4	   	s*    C' '	D)1DD$DD$$D)c                 :   | j                  |       | j                  rT| j                  j                  r>t        dj	                  | j                  |             || j                  _        d| _        y | j                  dj	                  | j                               y )NzSetting flag {!r} to value {!r}Tz!Flag {!r} doesn't take any value!)r   rO   rL   r   r7   r   rz   r   )r(   r   s     r   r   zParseMachine.see_value  sl    U#99..3::499eLM#DIIO"&DJJ:AA$))LMr   c                 d    | j                   j                  D ]  }|j                  ||_         y  y N)r<   positional_argsr   )r(   r   args      r   r   zParseMachine.see_positional_arg  s/    <<// 	Cyy !		r   r\   c                 .    t        || j                        r   )r   r<   )r(   r\   s     r   r   zParseMachine.error  s    dll++r   )r   N)F)r*   r+   r,   initial_stater   r   rh   rv   r	   rg   r%   propertyrN   rR   rt   rk   rq   rj   r   r   r   r   r   r   r.   r/   s   @r   rC   rC      s   M	)O-?@A	)O-?@A	%);<=+8F"	 $	>C >S >T >   	
 
$   08(C 8(D 8(t+ + +
-"Pc Pd P2,0S 0T 02"3 " "$ "BNs Nt N  , , ,r   rC   )rx   typingr   r   r   r   r   vendor.lexiconr	   vendor.fluidityr
   r   r   ImportErrorlexiconfluidity
exceptionsr   utilr   r<   r   rh   rg   r   r   r   r1   rC   rf   r   r   <module>r      s     ? ?	(AA $ &!3 !4 !" " "&$' &"[ [|z,< z,M   s   A, ,BB