
    !.dbd                     v
   U d Z ddlZddlmZmZmZmZmZmZm	Z	m
Z
 ej        dk    rddlmZ nddlmZ ej        dk    rddlmZ nddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZmZmZmZ  ej        e           ej        Z ee!d<    e	d          Z"e
eef         Z#e$Z%e$Z&ej'        ej(        ej)        hZ*ee!d<   e j+        e j,        e j-        e j.        e j/        e j0        e j1        e j2        e j3        e j4        h
Z5ee!d<   dZ6ee!d<   dej7        e6<   ddhZ8ee!d<   ej9        ej:        ej;        ej<        ej=        ej>        hZ?ee!d<   ej@        ejA        ejB        ejC        ejD        ejE        ejF        ejG        ejH        ejI        ejJ        ejK        ejL        ejM        hZNee!d<   ejG        ejM        hZOee!d<   eOejH        hz  ZPee!d<   e jQ        e jR        e jS        e jT        e jU        hZVee!d<   e jW        e jX        e jY        e jZ        e j[        e j\        e j]        hZ^ee!d<   e j_        e j`        e ja        e jb        e jc        e jd        e je        e jf        e jg        e jh        e ji        e jj        e jS        e jk        e jl        hZmee!d<   e jn        e jo        hZpee!d<   h dZqee!d <   e jr        e j[        e js        hZtee!d!<   eju        ejv        ejw        ejx        ejy        ejz        iZ{ee!d"<    e|e{}                                          Z~ee!d#<    e|e{                                          Zee!d$<   e~ez  Zee!d%<   eej        e6hz  Zee!d&<   d'Z ed()           G d* d+ee"                               Zd,ed-ed.efd/Zd0ee#         d.ee         fd1Zd0ee#         d2eee&                  d.efd3Zd0ee#         d.ee&         fd4Zd5ed6e#d.ee#         fd7Zd8e#d9e#d.dfd:Zd,ed.e#fd;Zd0e#d.ee         fd<Zd0e#d.efd=Zd,ed.efd>Zd0e#d.efd?Zd0e#d.efd@Zd0e#d.efdAZeju        ejv        ffdBedCedDee         dEee$e$f         d.ef
dFZd0e#d.efdGZdjd0e#dIed.efdJZd0e#d.efdKZd0e#d.efdLZd,edMee&         d.efdNZd,ed.efdOZd0ed.efdPZd0e#d.efdQZd0e#d.efdRZd,ed.efdSZd,ed.efdTZd,ed.efdUZd,ed.efdVZd,ed.efdWZd,ed.efdXZdkd,edZed.efd[Zd(d\d]ed^e#d_ed.dfd`Zd0e#d.ee#         fdaZd,ed.dfdbZdced.ee         fddZdced.ee         fdeZdced.ee         fdfZdced.ee         fdgZdced.ee         fdhZd,ed.efdiZdS )lz>
blib2to3 Node/Leaf transformation-related utility functions.
    N)GenericIteratorListOptionalSetTupleTypeVarUnion)      )Final)r   
   )	TypeGuard)
mypyc_attr)	CACHE_DIR)has_triple_quotes)pygram)token)NLLeafNode	type_reprsymsT
WHITESPACE	STATEMENT   STANDALONE_COMMENTandorLOGIC_OPERATORSCOMPARATORSMATH_OPERATORSSTARSVARARGS_SPECIALSVARARGS_PARENTSUNPACKING_PARENTSTEST_DESCENDANTSTYPED_NAMES>   %=&=*=+=-=/=@=^=|=**=//=<<=>>==ASSIGNMENTSIMPLICIT_TUPLEBRACKETOPENING_BRACKETSCLOSING_BRACKETSBRACKETSALWAYS_NO_SPACE7   T)allow_interpreted_subclassesc                   J    e Zd ZdZdedee         fdZdedee         fdZdS )VisitorzBBasic lib2to3 visitor that yields things of type `T` on `visit()`.nodereturnc              #     K   |j         dk     rt          j        |j                  }n!t          t	          |j                             }t          | d| d          }|r ||          E d{V  dS |                     |          E d{V  dS )az  Main method to visit `node` and its children.

        It tries to find a `visit_*()` method for the given `node.type`, like
        `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects.
        If no dedicated `visit_*()` method is found, chooses `visit_default()`
        instead.

        Then yields objects of type `T` from the selected visitor.
           visit_N)typer   tok_namestrr   getattrvisit_default)selfrC   namevisitfs       +lib/python3.11/site-packages/black/nodes.pyvisitzVisitor.visit   s       9s??>$),DDy++,,D
 55 	0vd||#########))$///////////    c              #      K   t          |t                    r%|j        D ]}|                     |          E d{V  dS dS )zCDefault `visit_*()` implementation. Recurses to children of `node`.N)
isinstancer   childrenrQ   )rM   rC   childs      rP   rL   zVisitor.visit_default   sd      dD!! 	- - -::e,,,,,,,,,,	- 	-- -rR   N)	__name__
__module____qualname____doc__LNr   r   rQ   rL    rR   rP   rB   rB      sf        LL0" 0! 0 0 0 00-" -! - - - - - -rR   rB   leafcomplex_subscriptrD   c                4   d}d}d}| j         }| j        }| j        }|t          v r|S |t          j        k    r|S |J d|             |t          j        k    r,|j         t          j        t          j	        t          j
        hvr|S | j        }|st          |          }	|	r|	j         t          v r|S |t          j        k    r2|	j         t          j        k    r|S |	j         t          j        k    r|s|S |S |	j         t          j        k    rf|	j        r]|	j        j         t          j        t          j        t          j        t          j        hv r|S |	j        j         t          j        k    r|	j        S nF|	j         t          j        k    rAt/          |	          t          j        k    r$t/          |	j                  t          j	        k    r|S |	j         t2          v r!t5          |	t6          t8          z            r|S n|	j         t          j        k    r2|	j        r*|	j        j         t          j        t          j
        hv r|r|n|S nz|	j        r*|	j        j         t          j        k    r|	j         t<          v r|S |	j         t          j        k    r#|j        r|j        j         t          j         k    r|S n|j         t          v r|S |j         t          j        t          j        hv r|r|j         t          j        k    r|S n|j         t          j        k    r|r|j         t          j        k    r|S n||j         t          j        k    r[|s|S |t          j        k    r|j         tB          vr|S nA|j         t          j        k    r|j        S |j         t          j        k    r|S n|j         tB          v r,|s(t          |          }	|	r|	j         t          j        k    r|S n|j         t          j"        k    ra|t          j#        k    s|t          j$        k    r|S |s$|t          j%        k    s|t          j&        k    r|S nu|j         t          j        k    r|S n\|j         t          j        k    r^|t          j        k    r|S |s*t          |          }	|	r|	j         t          j#        k    r|S n	|j         t          j        ht2          z  v r|S n|j         t          j         k    r|S |j         t          j'        k    rC|r|S t          |          }	|	r*|	j         t          j        k    s|	j         t          j%        k    r|S nz|j         t          j(        k    r-|t          j#        k    r|S |r|j         t          j#        k    r|S n8|j         t          j        t          j
        hv r7|s/|j        
J d            |j        j         t          j	        k    r|S |S |s|S n|j         t          j)        k    r|r|t          j%        k    r|S n|j         t          j*        k    r|r|j         t          j+        k    r|S n|j         t          j        t          j        hv r|st          |          }	|	r|	j         t          v r|S |	j        }
|
J |	j         t          j        k    r!|
j         t          j        t          j
        hv r|S |	j         t          j        k    r|
j         t          j        k    r|S n|t          j,        t          j-        t          j.        hv r|S n|j         t          j/        k    r\|t          j%        k    r|r|j         t          j%        k    r|S np|t          j,        k    r!|dk    r|S |r|j         t          j%        k    r|S n>|j         t          j
        k    r|S |j         t          j0        k    r|t          j        k    r|S |S )	zReturn whitespace prefix if needed for the given `leaf`.

    `complex_subscript` signals whether the given leaf is part of a subscription
    which has non-trivial arguments, like arithmetic expressions or function calls.
      z  Nz/INTERNAL ERROR: hand-made leaf without parent: )withinzsubscripts are always parentedimport)1rH   parentvaluer>   r   COMMENTCOLONr   	subscriptsubscriptlistsliceopprev_siblingpreceding_leafr;   COMMAEQUALarglistargument
parametersvarargslisttypedargslistprefixSTARparent_type	star_exprr%   	is_varargr&   r'   factorr#   AT	decoratorr)   trailerLPARRPARDOTLSQBdotted_nameclassdefatomdictsetmaker
DOUBLESTARNAMENUMBERSTRINGimport_fromexcept_clause)r]   r^   NOSPACEDOUBLESPACEtpvprevprevpprevp_parents              rP   
whitespacer      s    BEK	AA
AO	EM==TDTT===EKAF+  
 	D :q!! 	
&666IzU[((	u{**3D*	L:$$| (<$LMO$	)   I\&$*<<< !<' J%*$$E""dn44EL))T-??? IZ+++9J'JKKK 	 Z5;&&| : 1dndl5S S S 19uur9 L		!T[00
n,,IZ58###QX]dn5T5TI	&	&	&	v$/4<000 	tyEK//I 0 
4#	#	# 	DI,,I	
4%	%	% 	Iy++	 , Y%+%% ;Y%+%%I & 
;		 	"1%%E EJ%+55		
4<		
??a5:ooI 	EI~~ej	 "1 Y%+%%I & 
4=	 	 I 	"1%%E EJ%*44	 5 Y5;-*::::I ; 
4>	!	!		
4#	#	# 	Iq!! 	
eh..%*	2I2II 3J 
4=	 	 
??I 	DI++I	
DNDL1	1	1 	8'')I'''x} 222I" 	I	 
49		 	ANNI	
4$	$	$ 	DI!111I	
DK0	0	0 	"1%%E EJ*:::	 <L+++zU[((\->C . . 	u{**|/@DM/Q/Q	5:u|U\:::I ; 
4#	#	#	>> 	UY..	%*__H}} 	UY..		
4<				
4%	%	%
??ILrR   rC   c                     | rb| j         }|rPt          |t                    r|S 	 t          |                                          d         S # t
          $ r Y dS w xY w| j        } | bdS )z3Return the first leaf that precedes `node`, if any.N)rk   rT   r   listleaves
IndexErrorrd   )rC   ress     rP   rl   rl     s    
  	#t$$ 
CJJLL))"--   tt {   4s   &A 
AAtokensc                     |sdS |d         | du S | sdS | j         |d         k    rdS t          | j        |dd                   S )a;  Return if the `node` and its previous siblings match types against the provided
    list of tokens; the provided `node`has its type matched against the last element in
    the list.  `None` can be used as the first element to declare that the start of the
    list is anchored at the start of its parent's children.Tr   NF)rH   prev_siblings_arerk   )rC   r   s     rP   r   r     sc    
  tbzt| uyF2JuT.ss<<<rR   c                 0    | | j         dS | j         j        S )z|
    Returns:
        @node.parent.type, if @node is not None and has a parent.
            OR
        None, otherwise.
    N)rd   rH   rC   s    rP   rv   rv     s      |t{*t;rR   ancestor
descendantc                 L    |}|r|j         | k    r|j         }|r|j         | k    |S )z:Return the child of `ancestor` that contains `descendant`.)rd   )r   r   rC   s      rP   child_towardsr     s=    #D
 4;(**{  4;(**KrR   	old_child	new_childc                 x    | j         }|sdS |                                 }||                    ||           dS dS )z
    Side Effects:
        * If @old_child.parent is set, replace @old_child with @new_child in
        @old_child's underlying Node structure.
            OR
        * Otherwise, this function does nothing.
    N)rd   removeinsert_child)r   r   rd   	child_idxs       rP   replace_childr     sT     F   ""IIy11111 rR   c                     | j         }| }|rV|j        }|nL|j        d         j         |k    rn5|j        t          j        k    rn|j        |j        j        t          v rn|}|V|S )zReturn `leaf` or one of its ancestors that is the topmost container of it.

    By "container" we mean a node where `leaf` is the very first child.
    Nr   )rt   rd   rU   rH   r   
file_inputrk   r=   )r]   same_prefix	containerrd   s       rP   container_ofr     s    
 +KI
 !>?1$33;$/))*v/B/G8/S/S	   rR   c                 v    t          | t                    r| S | j        rt          | j        d                   S dS )z(Returns the first leaf of the node tree.r   N)rT   r   rU   first_leaf_ofr   s    rP   r   r     s=    $ } T]1-...trR   c                 l    | j         t          j        t          j        t          j        t          j        hv S )z?Whether node is an arithmetic or a binary arithmetic expression)rH   r   
arith_expr
shift_exprxor_exprand_exprr   s    rP   is_arith_liker     s*    9	  rR   c                     t          | j        d t          j        t          j        t
          j        g          rdS t          | j        t
          j        t          j        t
          j        g          rdS dS )NTF)	r   rd   r   NEWLINEINDENTr   simple_stmtrq   rg   r]   s    rP   is_docstringr     sb    dEM5<9IJ   t tTEU&VWW  t5rR   c                     | j         t          j        k    oWt          | j                  dk    o?| j        d         j         t
          j        k    o| j        d         j         t
          j        k    S )z+Return True if `node` holds an empty tuple.   r      )rH   r   r   lenrU   r   r}   r~   r   s    rP   is_empty_tupler     s`     		TY 	0!#	0M!!UZ/	0 M!!UZ/	rR   c                 x   | j         t          j        k    r`t          |           }||j         t          j        k    rdS t          |j                  dk    o|j        d         j         t          j        k    S | j         t          v o7t          | j                  dk    o| j        d         j         t          j        k    S )zMReturn True if `node` holds a tuple with one element, with or without parens.NFr   r   )
rH   r   r   unwrap_singleton_parenthesistestlist_gexpr   rU   r   rm   r9   rC   gexps     rP   is_one_tupler   &  s    yDI+D11<49(:::54=!!Q&O4=+;+@EK+OO 		^# 	1!#	1M!!U[0rR   c                     | j         t          j        k    rdS t          |           }||j         t          j        k    rdS t          d |j        D                       S )zDReturn True if `node` holds a tuple that contains a walrus operator.FNc              3   @   K   | ]}|j         t          j        k    V  d S N)rH   r   namedexpr_test).0rV   s     rP   	<genexpr>z-is_tuple_containing_walrus.<locals>.<genexpr>>  s,      LLUuzT00LLLLLLrR   )rH   r   r   r   r   anyrU   r   s     rP   is_tuple_containing_walrusr   6  s[    yDIu'--D|tyD$666uLLdmLLLLLLrR   openingclosingr   bracketsc                    | j         |j         f|k    rdS |j        dz   }t          |          D ]\  }}|| u r nt          d          d}|dz  }||d         D ]a}||u r nZ|j        }||k    rL|j         t          j        k    r7|dz  }|j        r+|j        j         t          j        t          j	        hv r|dz  } nb|dk     S )zIReturn True if content between `opening` and `closing` is a one-sequence.Fr   z#Opening paren not found in `leaves`r   Nr   )
rH   bracket_depth	enumerateLookupErrorr   rm   rd   r   ro   rs   )	r   r   r   r   depth_opening_indexr]   commasr   s	            rP   is_one_sequence_betweenr   A  s    	gl#x//u!A%E )& 1 1 A A7??E  ?@@@FaN~'  7??E*E!!di5;&>&>aKF{ t{/"4     !A:rR   c                 R    t          |           }|duo|j        t          j        k    S )z7Return True iff `node` is of the shape ( test := test )N)r   rH   r   r   )rC   inners     rP   is_walrus_assignmentr   f  s)    (..EBt/B!BBrR   Flastc                 F   | j         t          j        k    ot          | j                  dk    o?| j        d         j         t
          j        k    o| j        d         j         t
          j        k    p|oWt          | j                  dk    o?| j        d         j         t
          j        k    o| j        d         j         t
          j	        k    pY|oWt          | j                  dk    o?| j        d         j         t
          j        k    o| j        d         j         t
          j	        k    S )z?Return True iff `node` is a trailer valid in a simple decoratorr   r   r   r   )
rH   r   r|   r   rU   r   r   r   r}   r~   )rC   r   s     rP   is_simple_decorator_trailerr   l  s   9$ !# 4a %24a %3	
  4DM""a'4a %34 a %3	
  4DM""a'4a %34 a %3'rR   c                 r   | j         t          j        k    rdS | j         t          j        k    r| j        r| j        d         j         t          j        k    obt          t          t          | j        dd                             o3t          | j                  dk     pt          | j        d         d          S dS )a\  Return True iff `node` could be a 'dotted name' decorator

    This function takes the node of the 'namedexpr_test' of the new decorator
    grammar and test if it would be valid under the old decorator grammar.

    The old grammar was: decorator: @ dotted_name [arguments] NEWLINE
    The new grammar is : decorator: @ namedexpr_test NEWLINE
    Tr   r   r   r   )r   F)
rH   r   r   r   powerrU   allmapr   r   r   s    rP   is_simple_decorator_expressionr     s     yEJtyDJ= 	a %3 7qt9LMMNN &&* Q24=3D4PPP 5rR   c                 V   | j         t          j        k    rdS t          |           r| j        dk    rdS | j         t          j        k    rdS t          | j                  dk    rdS | j        \  }}}|j         t          j	        k    r$|j         t          j
        k    rt          |          S dS )zAReturn True if `node` holds a `yield` or `yield from` expression.TyieldFr   )rH   r   
yield_expris_name_tokenre   r   r   rU   r   r}   r~   is_yield)rC   lparexprrpars       rP   r   r     s    yDO##tT tzW44tyDIu
4=Qu}D$yEJ49
#:#:~~5rR   rb   c                     | j         t          vs| j        sdS | j        }|j         t          j        k    r|j        sdS |j        }|j         |v S )aF  Return True if `leaf` is a star or double star in a vararg or kwarg.

    If `within` includes VARARGS_PARENTS, this applies to function signatures.
    If `within` includes UNPACKING_PARENTS, it applies to right hand-side
    extended iterable unpacking (PEP 3132) and additional unpacking
    generalizations (PEP 448).
    F)rH   r%   rd   r   rw   )r]   rb   r   s      rP   rx   rx     sY     y((((uAv x 	5H6VrR   c                 <    t          | j                  od| j        v S )zKReturn True if `leaf` is a multiline string that actually spans many lines.
)r   re   r   s    rP   is_multiline_stringr     s    TZ((?TTZ-??rR   c                 *   t          | j                  dk    s`| j        d         j        t          j        k    s@| j        d         j        t          j        k    s | j        d         j        t          j        k    rdS t          | j        d                   S )z2Return True if `node` is a suite with a stub body.   r   r   r   Fr   )r   rU   rH   r   r   r   DEDENTis_stub_bodyr   s    rP   is_stub_suiter     sx     	DMa= EM11= EL00= EL00ua()))rR   c                 >   t          | t                    r| j        t          j        k    rdS t          | j                  dk    rdS | j        d         }|j        t          j        k    o5t          |j                  dk    ot          d |j        D                       S )zCReturn True if `node` is a simple statement containing an ellipsis.Fr   r   r   c              3   R   K   | ]"}|t          t          j        d           k    V  #dS ).N)r   r   r   )r   r]   s     rP   r   zis_stub_body.<locals>.<genexpr>  s3      HHUY,,,HHHHHHrR   )	rT   r   rH   r   r   r   rU   r   r   )rC   rV   s     rP   r   r     s    dD!! TY$2B%B%Bu
4=QuM!E
di 	I1$	IHHHHHHHrR   c                 b   t          | t                    s| j        t          j        k    rdS | j        d         | j        d         }}t          |t                    oT|j        t          j        k    o?|j        dk    o4t          |t                    o|j        t          j	        k    o
|j        dk    S )zGiven a `LN`, determines whether it's an atom `node` with invisible
    parens. Useful in dedupe-ing and normalizing parens.
    Fr   r   r`   )
rT   r   rH   r   r   rU   r   r}   re   r~   )rC   firstr   s      rP   is_atom_with_invisible_parensr     s     $ di!7!7u-"DM"$54E5$ 	J%*$	K2	 tT""	 I#		
 J"rR   c                 >    t          |           pt          |           S r   )is_empty_lparis_empty_rparr   s    rP   is_empty_parr    s    5-"5"55rR   c                 B    | j         t          j        k    o
| j        dk    S Nr`   )rH   r   r}   re   r   s    rP   r   r         9
"7tzR'77rR   c                 B    | j         t          j        k    o
| j        dk    S r  )rH   r   r~   re   r   s    rP   r   r     r  rR   c                     | j         }| j        }| j        }t          |t          j        k    o9|dk    r|r|j        t          j        k    p|dk    o|o|j        t          j        k              S )z9Return True if the given leaf starts an import statement.rc   from)	rd   rH   re   boolr   r   r   import_namer   )r]   r   r   r   s       rP   	is_importr
  
  ss    A	A
A	UZ 	
(]?q?QVt/?%? BV@@af0@&@	  rR   c                 $   t          | j        t          j        k    o+| j        dk    o | j        o| j        j        t          j        k              pBt          | j        t          j        k    o | j	        o| j	        j        t          j        k              S )zDReturn True if the given leaf starts a with or async with statement.with)
r  rH   r   r   re   rd   r   	with_stmtASYNCnext_siblingr   s    rP   is_with_or_async_with_stmtr    s    	UZ 	/J& 	/K	/ K.	  	
 
	U[  	5	5"dn4
 
	rR   c                     t          | j        t          j        k    o*| j        o#| j        j        t
          j        t
          j        hv           S )zReturn True if the given leaf starts an async def/for/with statement.

    Note that `async def` can be either an `async_stmt` or `async_funcdef`,
    the latter is used when it has decorators.
    )r  rH   r   r  rd   r   
async_stmtasync_funcdefr   s    rP   is_async_stmt_or_funcdefr  &  sJ     	U[  	FK	FK$2D EE  rR   r`   suffixc                 x    | j         }| j        }|t          j        t          hv o|                    d|z             S )zdReturn True if the given leaf is a special comment.
    Only returns true for type comments for now.z# type:)rH   re   r   rf   r   
startswith)r]   r  r   r   s       rP   is_type_commentr  3  s<     		A
A 233XYQWEW8X8XXrR   )visiblerd   rV   r  c                :   t          t          j        |rdnd          }t          t          j        |rdnd          }|j        }d|_        |                                pd}t          t          j        |||g          }||_        | 	                    ||           dS )zWrap `child` in parentheses.

    This replaces `child` with an atom holding the parentheses and the old
    child.  That requires moving the prefix.

    If `visible` is False, the leaves will be valueless (and thus invisible).
    (r`   )r   N)
r   r   r}   r~   rt   r   r   r   r   r   )rd   rV   r  r   r   rt   indexr   s           rP   wrap_in_parenthesesr  ;  s     
72CC33D
72CC33D\FELLLNNaETYud 344II
y)))))rR   c                     t          | j                  dk    rdS | j        \  }}}|j        t          j        k    r|j        t          j        k    sdS |S )zqReturns `wrapped` if `node` is of the shape ( wrapped ).

    Parenthesis can be optional. Returns None otherwiser   N)r   rU   rH   r   r}   r~   )rC   r   wrappedr   s       rP   r   r   M  sS     4=Qt-D'4I##	UZ(?(?tNrR   c                 ~    | j         t          j        k    r	d| _        dS | j         t          j        k    r	d| _        dS dS )zMake sure parentheses are visible.

    They could be invisible as part of some statements (see
    :func:`normalize_invisible_parens` and :func:`visit_import_from`).
    r  r  N)rH   r   r}   re   r~   r   s    rP   ensure_visibler"  [  s@     yEJ


	ej	 	 


 
!	 rR   nlc                 ,    | j         t          j        k    S r   )rH   r   r   r#  s    rP   r   r   g      7ej  rR   c                 ,    | j         t          j        k    S r   )rH   r   r}   r%  s    rP   is_lpar_tokenr(  k  r&  rR   c                 ,    | j         t          j        k    S r   )rH   r   r~   r%  s    rP   is_rpar_tokenr*  o  r&  rR   c                 ,    | j         t          j        k    S r   )rH   r   r   r%  s    rP   is_string_tokenr,  s      7el""rR   c                 ,    | j         t          j        k    S r   )rH   r   r   r%  s    rP   is_number_tokenr/  w  r-  rR   c                     | j         }|O|j        r|j        j        t          j        k    rdS |j         r|j         j        t
          j        k    rdS |j         }|OdS )z6Returns whether this leaf is part of type annotations.NTF)rd   rk   rH   r   RARROWr   tname)r]   r   s     rP   is_part_of_annotationr3  {  sg    {H

  	X%:%?5<%O%O4? 	x3tzAA4? 
 5rR   )F)r`   )rZ   systypingr   r   r   r   r   r   r	   r
   version_infor   typing_extensionsr   mypy_extensionsr   black.cacher   black.stringsr   blib2to3r   blib2to3.pgen2r   blib2to3.pytreer   r   r   r   
initializepython_symbolsr   __annotations__r   r[   intLeafIDNodeTyper   r   r   r   if_stmt
while_stmtfor_stmttry_stmtr   r  funcdefr   
match_stmt
case_blockr   r   rI   r!   LESSGREATEREQEQUALNOTEQUAL	LESSEQUALGREATEREQUALr"   VBAR
CIRCUMFLEXAMPER	LEFTSHIFT
RIGHTSHIFTPLUSMINUSru   SLASHDOUBLESLASHPERCENTrz   TILDEr   r#   r$   r%   ro   rp   r|   rs   rr   r&   r   r   	listmakerr   testlist_star_exprsubject_exprpatternr'   testlambdefor_testand_testnot_test
comparisonrw   r   r   r   r   r   termr   r(   r2  
tname_starr)   r8   testlistexprlistr9   r}   r~   r   RSQBLBRACERBRACEr:   setkeysr;   valuesr<   r=   rm   r>   r1  rB   r  rJ   r   rl   r   rv   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rx   r   r   r   r   r  r   r   r
  r  r  r  r  r   r"  r   r(  r*  r,  r/  r3  r\   rR   rP   <module>rp     sl     


 P P P P P P P P P P P P P P P P P P P Pv''''''w       ++++++ & & & & & & ! ! ! ! ! ! + + + + + +                   5 5 5 5 5 5 5 5 5 5 5 5  )   #e # # # GCLL
4:	 \5<?
E ? ? ?LOMMNLMOO	5      E   %9! " & & &	J	M	M	N	O	U    
J		K	O		J	K	J	K		M	H	K	     
E,-u - - -5;-/ % / / /LML    	INL 5    	ILLMMONIMMOOLIJ %   " j$/2U 2 2 2  U   " (?O O O O	J
	J
	L%,   
 #gllnn-- % - - -#gnn..// % / / /"%55% 5 5 5)U[:L,MM M M M	 ...- - - - -gaj - - /.-DcT c c# c c c cL" (4.    $=HRL =$x7I2J =t = = = = 
hrl 
x'9 
 
 
 
D b Xb\    2R 2B 24 2 2 2 2"t     2 x~     t    t          r d     MR MD M M M M "'UZ 8	" """ J" CHo	"
 
" " " "JCr Cd C C C C b      4     02 $    *D #h- D    .@d @t @ @ @ @

* 
* 
* 
* 
* 
*r d      t    $6t 6 6 6 6 68 8 8 8 8 88 8 8 8 8 8D T    T d    
4 
D 
 
 
 
Y Y$ Y YT Y Y Y Y EI * * * *R *T *T * * * *$r hrl    	 	$ 	 	 	 	!b !Yt_ ! ! ! !!b !Yt_ ! ! ! !!b !Yt_ ! ! ! !# #y # # # ## #y # # # #	 	 	 	 	 	 	 	rR   