
    RiaM                     *   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 n# e$ r d dlmZ d dlm
Z
mZmZ Y nw xY w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dS )    N)TYPE_CHECKINGAnyIterableListOptional   )Lexicon)StateMachinestate
transition)
ParseError)debug   )ParserContextvaluereturnc                 ,    |                      d          S )N-
startswithr   s    L/srv/django_bis/venv311/lib/python3.11/site-packages/invoke/parser/parser.pyis_flagr      s    C       c                 ,    |                      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                 V     t                      j        |i | d| _        g | _        d S )N )super__init__	remainderunparsed)selfr    r!   	__class__s      r   r%   zParseResult.__init__)   s1    $)&)))#%r   )__name__
__module____qualname____doc__r   r%   __classcell__r)   s   @r   r   r      s\         &c &S &T & & & & & & & & & &r   r   r   c            	       f    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dS )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
     NFcontextsr   initialignore_unknownr   c                    || _         t                      | _        || _        |D ]}t	          d                    |                     |j        st          d          d}|j        | j        v r't          |                    |j                            || j        |j        <   |j        D ]N}|| j        v r"t          |                    |                    | j        	                    ||j                   Od S )Nz	Adding {}z%Non-initial contexts must have names.z7A context named/aliased {!r} is already in this parser!)to)
r4   r	   r3   r5   r   formatname
ValueErroraliasesalias)r(   r3   r4   r5   contextexistsr<   s          r   r%   zParser.__init__D   s    		, 	< 	<G+$$W--...< J !HIIINF|t},, w|!<!<===*1DM','  < <DM))$V]]5%9%9:::##Egl#;;;;<	< 	<r   argvc                 H   t          | j        | j        | j                  }t	          d                    |                     	 |                    d          }n# t          $ r t          |          }Y nw xY w|d|         }||d         dd         }|r#t	          d                    ||                     t          |          D ]!\  }}g }|}	t          |          r|j        j        sd|v r[|                    d          \  }}
}d}t	          |                    |	||                     |                    |dz   |f           n8t          |          s(t          |          d	k    r|dd         }|d	d         |dd	         }}d
}t	          |                    |||                     ||j        j        v o
|j        dk    }|rW|j        j        |         j        r@d}t	          |                    ||                     |                    |dz   |f           n^d |D             }d}t	          |                    |	||                     t)          |          D ]}|                    |dz   |f           |j        r)|j        o|j        j        }||j        j        v }|r|s|	}g }|D ]\  }}|                    ||           |                    |           #|                                 |j        }d                    |          |_        |S )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
        )r4   r3   r5   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}c                 8    g | ]}d                      |          S )z-{})r8   .0xs     r   
<listcomp>z%Parser.parse_argv.<locals>.<listcomp>   s"     ? ? ?Qa ? ? ?r   z1Splitting multi-flag glob {!r} into {!r} and {!r} )ParseMachiner4   r3   r5   r   r8   indexr:   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&   rJ   token	mutationsorig_r   msg
full_tokenresterr	have_flag_restitemrV   subtoken_is_valid_flagrM   s                         r   
parse_argvzParser.parse_argvZ   s   0 L].	
 
 
 	#**400111	JJt$$EE 	 	 	IIEEE	FUF|L$	 	4;;E9MM   &dOO @	" @	"LE5 IDu~~ @gn&= @%<<&+ooc&:&:OE1eMC#**T5%88999$$eai%78888%e,, @Ua!&qqqJ"')U2A2Y%DHC#**Z==>>> !66 ?#1Y>  ! 	@W_%:5%A%M 	@ecjj55666!((%!)T):;;;; ? ?$ ? ? ?Qcjjue<<===$,UOO @ @D%,,eai->????" - #"<AGL,A).'/2G)G&  #%; # E "I ) * *uE5))))NN5!!!!88I..s   A A76A7)r2   NF)r*   r+   r,   r-   r   r   boolr%   r   strr   rj   r2   r   r   r1   r1   /   s         , /1-1$	< <?+< /*< 	<
 
< < < <,ptCy p[ p p p p 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 )-rI   r=   complete_flagcomplete_context)enterrB   end)r=   rB   rY   )from_eventr7   see_contextswitch_to_context)rr   rs   actionr7   see_unknown
store_onlyrr   r7   r   Nc                 L    t          d                    ||                     d S )NzParseMachine: {!r} => {!r})r   r8   )r(   rr   r7   s      r   changing_statezParseMachine.changing_state   s'    *11%<<=====r   r4   r   r3   r5   c                    || _         t          j        |          x| _        | _        t          d                    | j                             d | _        d| _        t                      | _
        t          j        |          | _        t          d                    | j                             t                                                       d S )NzInitialized with context: {!r}FzAvailable contexts: {!r})r5   copydeepcopyr4   r=   r   r8   rU   flag_got_valuer   rM   r3   r$   r%   )r(   r4   r3   r5   r)   s       r   r%   zParseMachine.__init__   s     -&*mG&<&<<t|.55dlCCDDD	#!mmh//(//>>???r   c                     | j         o| j         j        }|sdS | j         j        t          u r	| j        sdS | j         j        d u}| S )NFT)rU   rR   kindlistr~   	raw_value)r(   rR   	has_values      r   rT   z#ParseMachine.waiting_for_flag_value   sY     i9DI$9 	5 9>T!!$*=!4I't3	 }r   r^   c                    t          d                    |                     | j        dk    r9t          d                    |                     |                     |           d S | j        rG|| j        j        v r9t          d                    |                     |                     |           d S | j        rI|| j        j        v r;t          d                    |                     |                     |d           d S | j        r9t          d                    |                     | 	                    |           d S | j        rM| j        j
        rAd	}t          |                    | j        |                     |                     |           d S || j        v r|                     |           d S | j        r|| j        j        v rt          d
                    |                     | j        j        |         }|j        dk    r<| j        j        |_        d}t          |                    |j                             d S |                     |           d S | j        sLt          d                    |                     |                     d                    |                     d S t          d                    |                     |                     |           d S )NzHandling token: {!r}rB   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   r8   rQ   rw   r=   rP   switch_to_flaginverse_flagsrT   	see_valuemissing_positional_argssee_positional_argr3   rt   r4   r9   r   r5   error)r(   r^   rb   rU   s       r   rX   zParseMachine.handle  s   $++E22333 **5<<UCCDDDU###F< /	(ET\%777/((//000&&&&&\ ,	(et|'AAA)0077888t44444( (	(DKK   
 NN5!!!!! \ 	(dlB 	(FC#**T\511222##E*****dm##U#####\ 	(et|'9993::5AABBB<%e,DyF""!\.
_cjj,,----- ##E***** & (?FFuMMNNN

299%@@AAAAA<CCEJJKKK  '''''r   c                     t          d                    |                     | j        j                            |           d S )NzStoring unknown token {!r})r   r8   rM   r'   rO   )r(   r^   s     r   rx   zParseMachine.store_onlyJ  s>    *11%88999##E*****r   c                    t          d                    | j        r| j        j        n| j                             | j        rj| j        j        r^d}d                    d | j        j        D                       }|                     |                    | j        j        |                     | j        r/| j        | j        vr#| j                            | j                   d S d S d S )NzWrapping up context {!r}z6'{}' did not receive required positional arguments: {}z, c              3   J   K   | ]}d                      |j                  V  dS )z'{}'N)r8   r9   rD   s     r   	<genexpr>z0ParseMachine.complete_context.<locals>.<genexpr>X  sD         af%%     r   )	r   r8   r=   r9   r   rZ   r   rM   rO   )r(   re   namess      r   ro   zParseMachine.complete_contextO  s    &--%)\C!!t| 	
 	
 	
 < 	=DL@ 	=JCII  =    E JJszz$,"3U;;<<<< 	-DL;;Kt|,,,,,	- 	-;;r   r9   c                    t          j        | j        |                   | _        t	          d                    |                     t	          d                    | j        j                             t	          d                    | j        j                             t	          d                    | j        j                             d S )NzMoving to context {!r}zContext args: {!r}zContext flags: {!r}zContext inverse_flags: {!r})	r|   r}   r3   r=   r   r8   r    rP   r   )r(   r9   s     r   ru   zParseMachine.switch_to_context`  s    }T]4%899&--d33444"))$,*;<<===#**4<+=>>???+224<3MNNOOOOOr   c                    | j         r)d}t          |                    | j                              | j         rS| j         j        rG| j         j        ;| j         j        s/d}|                     |                    | j                              | j         rd| j         j        Z| j         j        rPd}t          |                    | j         j                             | j                             dd           d S d S d S d S )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)	rU   r   r8   rR   r   rV   r   r9   	set_value)r(   rb   re   s      r   rn   zParseMachine.complete_flagg  s   9 	)?C#**TY''((( I	.	%	. 	#+I& , BCJJszz$),,--- 9 	2,49K4MC#**TY^,,---I511111		2 	24444r   r   c                 :   | j         r| j         j        sdS | j         j        dS g }|                    | j        o| j        j                   |                    || j        v            t          |          r$d}t          |	                    |                    dS )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)
rU   rV   r   rO   r=   r   r3   anyr   r8   )r(   r   testsrb   s       r   check_ambiguityzParseMachine.check_ambiguity}  s     	 	di0 	5 9*5 T\Jdl&JKKKUdm+,,,u:: 	0MCSZZ..///	0 	0r   FrU   r   c                 .   |                      |           |                                  |r| j        j        |         n|}	 | j        j        |         | _        n@# t          $ r3}	 | j        j        |         | _        n# t          $ r |w xY wY d }~nd }~ww xY wt          d	                    | j                             d| _
        | j        rE| j        j        s;| }t          d	                    | j        |                     || j        _        d S d S d S )NzMoving to flag {!r}FzMarking seen flag {!r} as {})r   rn   r=   r   rP   rU   KeyErrorr4   r   r8   r~   rR   r   )r(   rU   r   evals        r   r   zParseMachine.switch_to_flag  sK   T""" 	3:Dt|)$//		*40DII 	 	 	 L.t4		     					 	#**4955666 $9 	"TY2 	"+C077	3GGHHH!DIOOO	" 	" 	" 	"s*   A 
B$A<;B<B		BBc                 *   |                      |           | j        rI| j        j        r=t          d                    | j        |                     || j        _        d| _        d S |                     d                    | j                             d S )NzSetting flag {!r} to value {!r}Tz!Flag {!r} doesn't take any value!)r   rU   rR   r   r8   r   r~   r   )r(   r   s     r   r   zParseMachine.see_value  s    U###9 	N. 	N3::49eLLMMM#DIO"&DJJ:AA$)LLMMMMMr   c                 F    | j         j        D ]}|j        
||_         d S d S N)r=   positional_argsr   )r(   r   args      r   r   zParseMachine.see_positional_arg  s;    </ 	 	Cy !	 !	 	r   rb   c                 ,    t          || j                  r   )r   r=   )r(   rb   s     r   r   zParseMachine.error  s    dl+++r   )r   N)F)r*   r+   r,   initial_stater   r   rl   rz   r	   rk   r%   propertyrT   rX   rx   ro   ru   rn   r   r   r   r   r   r   r.   r/   s   @r   rI   rI      s       M	E)O-?@AAAA	E)O-?@AAAA	E%);<====J+8FFFFJ"	    J$	   >C >S >T > > > >   	
 
     $     X08(C 8(D 8( 8( 8( 8(t+ + + + + +
- - - -"Pc Pd P P P P2 2 2 2,0S 0T 0 0 0 02" "3 " "$ " " " "BNs Nt N N N N     , , , , , , , , , ,r   rI   )r|   typingr   r   r   r   r   vendor.lexiconr	   vendor.fluidityr
   r   r   ImportErrorlexiconfluidity
exceptionsr   utilr   r=   r   rl   rk   r   r   r   r1   rI   r2   r   r   <module>r      s    ? ? ? ? ? ? ? ? ? ? ? ? ? ?	((((((AAAAAAAAAAA               $ # # # # #       '&&&&&&!3 !4 ! ! ! !" " " " " "& & & & &$' & & &"[ [ [ [ [ [ [ [|z, z, z, z, z,< z, z, z, z, z,s   % ==