Ë
    zñ�jaM  ã                   ó  — 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    úU/var/www/api.ozpay.ru/ozpay/venv/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ØNˆFØ�|‰|˜tŸ}™}Ñ,Ü  §¡¨w¯|©|Ó!<Ó=Ð=Ø*1ˆD�M‰M˜'Ÿ,™,Ñ'Ø Ÿ™ò <�Ø˜DŸM™MÑ)Ü$ V§]¡]°5Ó%9Ó:Ð:Ø—‘×#Ñ# E¨g¯l©lÐ#Õ;ñ<ñ	<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 à—L‘LØ—]‘]Ø×.Ñ.ô	
ˆô 	Ð#×*Ñ*¨4Ó0Ô1ð	Ø—J‘J˜tÓ$ˆEð �F�Uˆ|ˆØ˜˜�L  Ð$ˆ	ÙÜØ4×;Ñ;¸EÀ9ÓMôô & d›Oó @	"‰LˆE�5ð ˆIØˆDÜ�u�~ g§n¡n×&=Ó&=à˜%‘<Ø&+§o¡o°cÓ&:‘O�E˜1˜eØM�CÜ˜#Ÿ*™* T¨5°%Ó8Ô9Ø×$Ñ$ e¨a¡i°Ð%7Ö8ä% eÕ,´°U³¸a³Ø!&¡q �JØ"'¨¨ )¨U°2°A¨Y˜%�DØH�CÜ˜#Ÿ*™* Z°¸Ó=Ô>ð  §¡×!6Ñ!6Ð6ò ?Ø#×1Ñ1°YÑ>ð ñ ! W§_¡_×%:Ñ%:¸5Ñ%A×%MÒ%MØe˜Ü˜cŸj™j¨°Ó5Ô6Ø!×(Ñ(¨%°!©)°TÐ):Õ;à:>Ö ?°Q §¡¨a¥Ð ?˜Ð ?ØQ˜Ü˜cŸj™j¨¨u°eÓ<Ô=Ü$,¨U£Oò @˜DØ%×,Ñ,¨e°a©i¸Ð->Õ?ð@ð$ ×-Ò-Ø"Ÿ<™<ÒA¨G¯L©L×,AÑ,A�Ø).°'·/±/×2GÑ2GÐ)GÐ&Ù Ñ%;Ø �EØ "�IØ )ò *‘��uØ—‘˜E 5Õ)ð*à�N‰N˜5Ö!ðA@	"ðB 	�‰ÔØ—‘ˆØŸ8™8 IÓ.ˆÔØˆøôY ò 	Ü˜“I‹Eð	üò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˜t C™yð 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‡   ø€ ð -ˆÔÜ&*§m¡m°GÓ&<Ð<ˆŒ�t”|ÜÐ.×5Ñ5°d·l±lÓ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]   € ð —i‘iÒ9 D§I¡I×$9Ñ$9ˆÙØð �9‰9�>‰>œTÑ!¨$×*=Ò*=Øà—I‘I×'Ñ'¨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 r–t        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Ô#Øà�<Š<˜E T§\¡\×%7Ñ%7Ñ7Ü�/×(Ñ(¨Ó/Ô0Ø×Ñ Õ&Ø�\Š\˜e t§|¡|×'AÑ'AÑAÜÐ)×0Ñ0°Ó7Ô8Ø×Ñ ¨tÐÕ4à×(Ò(ÜØD×KÑKØóôð
 �N‰N˜5Õ!ð �\Š\˜dŸl™l×BÒBØFˆCÜ�#—*‘*˜TŸ\™\¨5Ó1Ô2Ø×#Ñ# EÕ*à�d—m‘mÑ#Ø×Ñ˜UÕ#à�\Š\˜e t§|¡|×'9Ñ'9Ñ9ÜÐ3×:Ñ:¸5ÓAÔBØ—<‘<×%Ñ% eÑ,ˆDà�y‰y˜FÒ"Ø!Ÿ\™\×.Ñ.�”
Ø_�Ü�c—j‘j §¡Ó,Õ-ð ×#Ñ# EÕ*ð ×&Ò&ÜÐ?×FÑFÀuÓMÔNØ—
‘
Ð2×9Ñ9¸%Ó@ÕAäÐ<×CÑCÀEÓ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%   è ø€ ò àð —‘˜aŸf™f×%ñùs   ‚%')	r   r7   r<   r8   r†   rT   rˆ   rG   rI   )r(   r_   Únamess      r   rk   zParseMachine.complete_contextO  sÆ   € ÜØ&×-Ñ-Ø%)§\¢\�—‘×!Ò!°t·|±|óô	
ð �<Š<˜DŸL™L×@Ò@ØJˆCØ—I‘Iñ àŸ™×=Ñ=ôó ˆEð �J‰J�s—z‘z $§,¡,×"3Ñ"3°UÓ;Ô<Ø�<Š<˜DŸL™L°·±Ñ;Ø�K‰K×Ñ˜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Ñ2°4·<±<×3MÑ3MÓ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Ø   € Ø�9Š9Ø?ˆCÜ�#—*‘*˜TŸY™YÓ'Ô(ð �IŠIØ—	‘	×%Ò%Ø—	‘	×#Ñ#Ð+Ø—I‘I×&Ò&àAˆCØ�J‰J�s—z‘z $§)¡)Ó,Ô-ð �9Š9˜Ÿ™×,Ñ,Ð4¸¿¹×9KÒ9KØMˆCÜ�#—*‘*˜TŸY™YŸ^™^Ó,Ô-à�I‰I×Ñ ¨5ÐÕ1ð	 :LÐ4ˆ9r   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�   € ð —	’	˜dŸi™i×0Ò0Øð �9‰9×ÑÐ*Øð ˆà�‰�T—\‘\ÒJ d§l¡l×&JÑ&JÔKà�‰�U˜dŸm™mÐ+Ô,ÜˆuŒ:ØMˆCÜ˜SŸZ™Z¨Ó.Ó/Ð/ð 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Ñ0ˆDŒIô 	Ð#×*Ñ*¨4¯9©9Ó5Ô6ð $ˆÔà�9Š9˜TŸY™Y×2Ò2Ø�+ˆCÜÐ0×7Ñ7¸¿	¹	À3ÓGÔHØ!ˆD�I‰I�Oð 3ˆ9øô ò 	ðØ ŸL™L×.Ñ.¨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Ô#Ø�9Š9˜Ÿ™×.Ò.ÜÐ3×:Ñ:¸4¿9¹9ÀeÓLÔMØ#ˆD�I‰IŒOØ"&ˆDÕà�J‰JÐ:×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Ø�y‰yÑ Ø!�”	Ùñ	r   r\   c                 ó.   — t        || j                  «      ‚r�   )r   r<   )r(   r\   s     r   rˆ   zParseMachine.errorÆ  s   € Ü˜˜dŸl™lÓ+Ð+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ð,0 Sð 0¨Tó 0ñ2" 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