
    mikz                     L   U d Z ddlmZ ddlmZmZmZmZmZm	Z	 ddl
mZ ddlmZ ddlmZ ddlmZ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j.        ej/        ej0        ej1        ej2        h
Z3eed<   dZ4eed<   dej5        e4<   ddhZ6eed<   ej7        ej8        ej9        ej:        ej;        ej<        hZ=eed<   ej>        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jK        hZLeed<   ejE        ejK        hZMeed<   eMejF        hz  ZNeed<   ejO        ejP        ejQ        ejR        ejS        hZTeed<   ejU        ejV        ejW        ejX        ejY        ejZ        ej[        hZ\eed<   ej]        ej^        ej_        ej`        eja        ejb        ejc        ejd        eje        ejf        ejg        ejh        ejQ        eji        ejj        ejk        hZleed<   ejm        ejn        hZoeed<   h dZpeed<   ejq        ejY        ejr        hZseed<   ejt        eju        ejv        ejw        ejx        ejy        iZzeed<    e{ez|                                          Z}eed <    e{ez~                                          Zeed!<   e}ez  Zeed"<   eej        e4ej        ej        ej        ej        ej        hz  Zeed#<   d$Z ed%&           G d' d(ee                                Zd)ed*ed+ed,efd-Zd}d/e"d0ed1ed,efd2Zd3e!d4z  d,ed4z  fd5Zd3e!d4z  d6ee$d4z           d,efd7Zd3e!d4z  d,e$d4z  fd8Zd9ed:e!d,e!d4z  fd;Zd<e!d=e!d,d4fd>Zd)ed,e!fd?Zd3e!d,ed4z  fd@Zd3e!d,efdAZd3ed,efdBZd3e!d,efdCZd3e!d,efdDZd3e!d,efdEZd3e!d,efdFZd3e!d,efdGZd3e!d,efdHZejt        eju        ffdIedJedKee         dLee"e"f         d,ef
dMZd3e!d,efdNZd~d3e!dPed,efdQZd3e!d,efdRZd3e!d,efdSZd)edTe{e$         d,efdUZd3ed,efdVZd3ed,efdWZd3e!d,efdXZd3ed,efdYZd3ed,efdZZd3ed,efd[Zd3e!d,efd\Zd3e!d,efd]Zd)ed,efd^Zd)ed,efd_Zd)ed,efd`Zd)ed,efdaZd)ed,efdbZd)ed,efdcZd)ed+ed,efddZdeed+ed,efdfZd)ed+ed,efdgZdeed+ed,efdhZd%didjedke!dled,d4fdmZd3e!d,e!d4z  fdnZd)ed,d4fdoZdped,ee         fdqZdped,ee         fdrZdped,ee         fdsZdped,ee         fdtZd)ed,edu         fdvZd)ed,efdwZd3e!d,ed4z  fdxZd3e!d,ed4z  fdyZd)ed,e!fdzZd3e!d{e"d,efd|Zd4S )z>
blib2to3 Node/Leaf transformation-related utility functions.
    )Iterator)FinalGenericLiteral	TypeGuardTypeVarUnion)
mypyc_attr)	CACHE_DIR)Mode)get_string_prefix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)selfr@   namevisitfs       c/var/www/html/bestrading.cuttalo.com/scripts/kaggle-env/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   childrenrN   )rJ   r@   childs      rM   rI   zVisitor.visit_default   sd      dD!! 	- - -::e,,,,,,,,,,	- 	-- -rO   N)	__name__
__module____qualname____doc__LNr   r   rN   rI    rO   rM   r?   r?      sf        LL0" 0! 0 0 0 00-" -! - - - - - -rO   r?   leafcomplex_subscriptmoderA   c                &   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 |t          j        k    r!|j         t          j        t          j        f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 ng|
j         t          j        k    rKt5          |
          t          j        k    r.t5          |
j                  t          j	        t          j        fv r|S |
j         t:          v r!t=          |
t>          t@          z            r|S n|
j         t          j        k    r2|
j        r*|
j        j         t          j        t          j
        hv r|r|n|S n|
j        r*|
j        j         t          j!        k    r|
j         tD          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%        k    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         tL          vr|S nh|	j         t          j        k    r|	j        S |	j         t          j        k    r|S n3|j         tL          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 n|	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 n0|	j         t          j        ht:          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 n|j         t          j-        k    r-|t          j(        k    r|S |	r|	j         t          j(        k    r|S n_|j         t          j        t          j
        hv r^|	s/|j        
J d            |j        j         t          j	        k    r|S |S |t          j.        k    s|	j         t          j.        k    r|S |s|S n|j         t          j/        k    r|	r|t          j*        k    r|S n|j         t          j0        k    r|	r|	j         t          j1        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          j2        t          j3        t          j4        hv r|S n|j         t          j5        k    r\|t          j*        k    r|	r|	j         t          j*        k    r|S np|t          j2        k    r!|dk    r|S |	r|	j         t          j*        k    r|S n>|j         t          j
        k    r|S |j         t          j6        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)7rE   parentvaluer;   r   COMMENTCOLONr   	subscriptsubscriptlistsliceopLBRACEfstring_replacement_fieldtstring_replacement_fieldprev_siblingpreceding_leafr8   COMMAEQUALarglistargument
parametersvarargslisttypedargslistprefixSTARparent_type	star_expr
tname_starr!   	is_varargr"   r#   factorr   AT	decoratorBANGr%   trailerLPARRPARDOTLSQBdotted_nameclassdef
COLONEQUALatomdictsetmaker
DOUBLESTARNAMENUMBERSTRINGimport_fromexcept_clause)rZ   r[   r\   NOSPACEDOUBLESPACEtpvprevprevpprevp_parents               rM   
whitespacer      s    BE"K	AA
AO	EM==TDTT===EKAF+  
 	ELQV&&(   	D =q!! 	
&666IzU[((	u{**3D*	L:$$| (<$LMO$	)   I\&$*<<< !<' J%*$$E""dn44EL))d.@$/-RRR IZ+++9J'JKKK 	 Z5;&&| : 1dndl5S S S 19uur9 L		!T[00
n,,IZ58###QX]dn5T5TI	&	&	&		ej	 	 	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%"""di53C&C&CL" 	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LrO   
nl_count	form_feed
empty_linec                 ,    |r|| dz
  z  dz   |z   S || z  S )z$Generate a normalized prefix string.   rY   )r   r   r   s      rM   make_simple_prefixr     s/     Ahl+t3j@@  rO   r@   Nc                     | 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)rl   rQ   r   listleaves
IndexErrorrb   )r@   ress     rM   rm   rm     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)rE   prev_siblings_arerl   )r@   r   s     rM   r   r     sc    
  tbzt| uyF2JuT.ss<<<rO   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)rb   rE   r@   s    rM   rw   rw     s      |t{*t;rO   ancestor
descendantc                 L    |}|r|j         | k    r|j         }|r|j         | k    |S )z:Return the child of `ancestor` that contains `descendant`.)rb   )r   r   r@   s      rM   child_towardsr     s=     D
 4;(**{  4;(**KrO   	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)rb   removeinsert_child)r   r   rb   	child_idxs       rM   replace_childr     sT     F   ""IIy11111 rO   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   )ru   rb   rR   rE   r   
file_inputrl   r:   )rZ   same_prefix	containerrb   s       rM   container_ofr     s    
 +KI
 !>?1$33;$/))*v/B/G8/S/S	   rO   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)rQ   r   rR   first_leaf_ofr   s    rM   r   r     s=    $ } T]1-...trO   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)rE   r   
arith_expr
shift_exprxor_exprand_exprr   s    rM   is_arith_liker     s*    9	  rO   c                 d   t          | t                    rO| j        t          j        k    rdS t          | j                  }t          |                              d          rdS | j	        rS| j	        j        t          j        k    r9| j	        j        s-| j	        j	        r!| j	        j	        j        t          j        k    rdS 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 )NFbBfFT)rQ   r   rE   r   r   r   rc   setintersectionrb   r   simple_stmtrl   r   r   NEWLINEINDENTrr   re   )r@   ru   s     rM   is_docstringr   "  s   $ 9$$5"4:..v;;##F++ 	5 	K 000( 1K 1 K#t66tdEM5<9IJ   t tTEU&VWW  t5rO   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   r   )rE   r   r   lenrR   r   r   r   r   s    rM   is_empty_tupler   B  s`     		TY 	0!#	0M!!UZ/	0 M!!UZ/	rO   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   )
rE   r   r   unwrap_singleton_parenthesistestlist_gexpr   rR   r   rn   r6   r@   gexps     rM   is_one_tupler   L  s    yDI+D11<49(:::54=!!Q&O4=+;+@EK+OO 		^# 	1!#	1M!!U[0rO   c                     | j         t          j        k    rdS t          |           }||j         t          j        k    rdS dS )z$Return True if `node` holds a tuple.FNT)rE   r   r   r   r   r   s     rM   is_tupler   \  sA    yDIu'--D|tyD$666u4rO   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)rE   r   namedexpr_test.0rS   s     rM   	<genexpr>z-is_tuple_containing_walrus.<locals>.<genexpr>o  s,      LLUuzT00LLLLLLrO   rE   r   r   r   r   anyrR   r   s     rM   is_tuple_containing_walrusr   g  s[    yDIu'--D|tyD$666uLLdmLLLLLLrO   c                     | j         t          j        k    rdS t          |           }||j         t          j        k    rdS t          d |j        D                       S )zBReturn True if `node` holds a tuple that contains a star operator.FNc              3   @   K   | ]}|j         t          j        k    V  d S r   )rE   r   rx   r   s     rM   r   z+is_tuple_containing_star.<locals>.<genexpr>z  s+      GGuzT^+GGGGGGrO   r   r   s     rM   is_tuple_containing_starr   r  s[    yDIu'--D|tyD$666uGGGGGGGGrO   c                     | j         t          j        k    rdS t          |           }||j         t          j        k    rdS t          d |j        D                       S )z(Return True if `node` holds a generator.FNc              3   @   K   | ]}|j         t          j        k    V  d S r   )rE   r   old_comp_forr   s     rM   r   zis_generator.<locals>.<genexpr>  s,      JJ5uzT..JJJJJJrO   r   r   s     rM   is_generatorr   }  s[    yDIu'--D|tyD$666uJJDMJJJJJJrO   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   )
rE   bracket_depth	enumerateLookupErrorr   rn   rb   r   rp   rt   )	r   r   r   r   depth_opening_indexrZ   commasr   s	            rM   is_one_sequence_betweenr     s    	gl#x//u!A%E )& 1 1 A A7??E  ?@@@FaN~'  7??E*E!!di5;&>&>aKF{ t{/"4     !A:rO   c                 R    t          |           }|duo|j        t          j        k    S )z7Return True iff `node` is of the shape ( test := test )N)r   rE   r   r   )r@   inners     rM   is_walrus_assignmentr     s)    (..EBt/B!BBrO   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      )
rE   r   r   r   rR   r   r   r   r   r   )r@   r   s     rM   is_simple_decorator_trailerr     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'rO   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)
rE   r   r   r   powerrR   allmapr   r   r   s    rM   is_simple_decorator_expressionr     s     yEJtyDJ= 	a %3 7qt9LMMNN &&* Q24=3D4PPP 5rO   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   )rE   r   
yield_expris_name_tokenrc   r   r   rR   r   r   r   is_yield)r@   lparexprrpars       rM   r  r    s    yDO##tT tzW44tyDIu
4=Qu}D$yEJ49
#:#:~~5rO   r`   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)rE   r!   rb   r   rx   )rZ   r`   r   s      rM   rz   rz     sY     y((((uAv x 	5H6VrO   c                 ,    | j         t          j        k    S )z&Return True if the node is an f-string)rE   r   fstringr   s    rM   
is_fstringr    s    9$$rO   c                     t          |           t          | j                  d         }t          t          j        || j                  }|                                 pd|_        |S )z:Converts an fstring or tstring node back to a string node.N)ru   r   )rG   r   ru   r   r   r   
get_linenolineno)r@   string_without_prefixstring_leafs      rM   fstring_tstring_to_stringr    sY    IIc$+&6&6&8&89u|%:4;OOOK**/aKrO   c                     t          | t                    rt          |           rt          |           }nt          | t                    r| }ndS t          |j                  od|j        v S )zKReturn True if `leaf` is a multiline string that actually spans many lines.Fr   )rQ   r   r  r  r   r   rc   )r@   rZ   s     rM   is_multiline_stringr    sl    $ *T"2"2 (..	D$		 uTZ((?TTZ-??rO   c                     | j         t          j        t          j        hv sJ | j        J | j        j         t          j        t          j        hv S r   )rE   r   suiter   rb   funcdefr   r   s    rM   is_parent_function_or_classr  *  sF    9T%566666;""";dm<<<rO   c                 V    | j         t          j        t          j        t          j        hv S r   )rE   r   r  r   async_funcdefr   s    rM   is_function_or_classr  1  s    9t}d6HIIIrO   c                    | j         t          |           sdS | j                                        rdS 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 | j        d         j                                        rdS t          | j        d                   S )z2Return True if `node` is a suite with a stub body.NF   r   r   r   r   )rb   r  ru   stripr   rR   rE   r   r   r   DEDENTis_stub_bodyr   s    rM   is_stub_suiter   5  s    {'B4'H'Hu { u 	DMa= EM11= EL00= EL00u}Q$$&& ua()))rO   c                 r   t          | t                    r| j        t          j        k    rdS t          | j                  dk    rdS | j        d         }|j                                         oJ|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   rZ   s     rM   r   zis_stub_body.<locals>.<genexpr>Y  s3      HHUY,,,HHHHHHrO   )rQ   r   rE   r   r   r   rR   ru   r  r   r   )r@   rS   s     rM   r  r  L  s    dD!! TY$2B%B%Bu
4=QuM!EL    	IJ$)#	I1$	I HHHHHHH	rO   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^   )
rQ   r   rE   r   r   rR   r   r   rc   r   )r@   firstr   s      rM   is_atom_with_invisible_parensr&  ]  s     $ di!7!7u-"DM"$54E5$ 	J%*$	K2	 tT""	 I#		
 J"rO   c                 >    t          |           pt          |           S r   )is_empty_lparis_empty_rparrZ   s    rM   is_empty_parr+  o  s    5-"5"55rO   c                 B    | j         t          j        k    o
| j        dk    S Nr^   )rE   r   r   rc   r*  s    rM   r(  r(  s      9
"7tzR'77rO   c                 B    | j         t          j        k    o
| j        dk    S r-  )rE   r   r   rc   r*  s    rM   r)  r)  w  r.  rO   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.ra   from)	rb   rE   rc   boolr   r   r   import_namer   )rZ   r   r   r   s       rM   	is_importr4  {  ss    A	A
A	UZ 	
(]?q?QVt/?%? BV@@af0@&@	  rO   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)
r2  rE   r   r   rc   rb   r   	with_stmtASYNCnext_siblingr*  s    rM   is_with_or_async_with_stmtr:    s    	UZ 	/J& 	/K	/ K.	  	
 
	U[  	5	5"dn4
 
	rO   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.
    )r2  rE   r   r8  rb   r   
async_stmtr  r*  s    rM   is_async_stmt_or_funcdefr=    sJ     	U[  	FK	FK$2D EE  rO   c                 h    | j         }| j        }|t          j        t          hv ot          ||          S )aB  Return True if the given leaf is a type comment. This function should only
    be used for general type comments (excluding ignore annotations, which should
    use `is_type_ignore_comment`). Note that general type comments are no longer
    used in modern version of Python, this function may be deprecated in the future.)rE   rc   r   rd   r   is_type_comment_stringrZ   r\   r   r   s       rM   is_type_commentrA    s6    
 		A
A 233W8NqRV8W8WWrO   rc   c                     |                      d          o.| dd                                                               d          S )N#r   ztype:)
startswithlstriprc   r\   s     rM   r?  r?    s=    C  KU122Y%5%5%7%7%B%B7%K%KKrO   c                 h    | j         }| j        }|t          j        t          hv ot          ||          S )zGReturn True if the given leaf is a type comment with ignore annotation.)rE   rc   r   rd   r   is_type_ignore_comment_stringr@  s       rM   is_type_ignore_commentrI    s<    	A
A 233 8U	49 9 rO   c                     t          | |          o@|                     dd          d                                                             d          S )zSReturn True if the given string match with type comment with
    ignore annotation.r3   r   ignore)r?  splitrE  rD  rF  s     rM   rH  rH    sH     "%.. $5;;sA3F3F	4fhhzz(##$rO   )visiblerb   rS   rM  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   ru   r   r   r   r   r   )rb   rS   rM  r  r  ru   indexr   s           rM   wrap_in_parenthesesrR    s     
72CC33D
72CC33D\FELLLNNaETYud 344II
y)))))rO   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   rR   rE   r   r   r   )r@   r  wrappedr  s       rM   r   r     sS     4=Qt-D'4I##	UZ(?(?tNrO   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`).
    rO  rP  N)rE   r   r   rc   r   r*  s    rM   ensure_visiblerV    s@     yEJ


	ej	 	 


 
!	 rO   nlc                 ,    | j         t          j        k    S r   )rE   r   r   rW  s    rM   r  r        7ej  rO   c                 ,    | j         t          j        k    S r   )rE   r   r   rY  s    rM   is_lpar_tokenr\    rZ  rO   c                 ,    | j         t          j        k    S r   )rE   r   r   rY  s    rM   is_rpar_tokenr^    rZ  rO   c                 ,    | j         t          j        k    S r   )rE   r   r   rY  s    rM   is_number_tokenr`    s    7el""rO   )rA   paramNc                     | 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 )z<Returns the type of annotation this leaf is part of, if any.NrA   ra  )rb   rl   rE   r   RARROWr   tname)rZ   r   s     rM   get_annotation_typere    sg    {H

  	X%:%?5<%O%O8? 	x3tzAA7? 
 4rO   c                 6    | j         J t          |           duS )z7Returns whether this leaf is part of a type annotation.N)rb   re  r*  s    rM   is_part_of_annotationrg    s#    ;"""t$$D00rO   c                 v    t          | t                    r| S | j        sdS t          | j        d                   S )z,Returns the first leaf of the ancestor node.Nr   )rQ   r   rR   
first_leafr   s    rM   ri  ri    s=    $ ,] ,t$-*+++rO   c                 v    t          | t                    r| S | j        sdS t          | j        d                   S )z+Returns the last leaf of the ancestor node.Nr   )rQ   r   rR   	last_leafr   s    rM   rk  rk    s=    $ ,] ,tr*+++rO   c                     | }|j         rN|j         j        rB||j         j        d         u r.|j         }|j         r |j         j        r||j         j        d         u .|S )zGReturns the furthest ancestor that has this leaf node as the last leaf.r   )rb   rR   )rZ   r@   s     rM    furthest_ancestor_with_last_leafrm  %  sk    D
+ $+. 44;;OPR;S3S3S{ + $+. 44;;OPR;S3S3SKrO   rE   c                     | j         }||j        |k    rdS |j         }|| j        }||j        |k    rdS |j        }|dS )NTF)rl   rE   r9  )r@   rE   siblings      rM   has_sibling_with_typerp  -  sk    G

<44& 
 G

<44& 

 5rO   )r   )F)rW   collections.abcr   typingr   r   r   r   r   r	   mypy_extensionsr
   black.cacher   
black.moder   black.stringsr   r   blib2to3r   blib2to3.pgen2r   blib2to3.pytreer   r   r   r   
initializepython_symbolsr   __annotations__r   rX   intLeafIDNodeTyper  r   r   r   if_stmt
while_stmtfor_stmttry_stmtr   r7  r  r   
match_stmt
case_blockr   r   rF   r   LESSGREATEREQEQUALNOTEQUAL	LESSEQUALGREATEREQUALr   VBAR
CIRCUMFLEXAMPER	LEFTSHIFT
RIGHTSHIFTPLUSMINUSrv   SLASHDOUBLESLASHPERCENTr|   TILDEr   r   r    r!   rp   rq   r   rt   rs   r"   r   r   	listmakerr   testlist_star_exprsubject_exprpatternr#   testlambdefor_testand_testnot_test
comparisonrx   r  r   r   r   r   termr   r   r$   rd  ry   r%   r5   testlistexprlistr6   r   r   r   RSQBri   RBRACEr7   r   keysr8   valuesr9   r:   rn   FSTRING_MIDDLEFSTRING_ENDTSTRING_MIDDLETSTRING_ENDr~   r;   rc  r?   r2  rG   r   r   rm   r   r   rw   r   r   r   r   r   r   r   r   r   r   r   r   tupler   r   r   r   r  rz   r  r  r  r  r  r   r  r&  r+  r(  r)  r4  r:  r=  rA  r?  rI  rH  rR  r   rV  r  r\  r^  r`  re  rg  ri  rk  rm  rp  rY   rO   rM   <module>r     s     % $ $ $ $ $ E E E E E E E E E E E E E E E E & & & & & & ! ! ! ! ! !       > > > > > > > >                   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)	K					J-     
 ...- - - - -gaj - - /.-DoT o oT oc o o o od! ! ! !3 !RU ! ! ! !d td{    $=BI =tHtO/D = = = = = 
b4i 
HtO 
 
 
 
D b R$Y    2R 2B 24 2 2 2 2"t     2 td{     t    r d    @     r d     2 $    MR MD M M M MH2 H$ H H H HKr Kd K K K K "'UZ 8	" """ J" CHo	"
 
" " " "JCr Cd C C C C b      4     02 $    *D #h- D    .%T %d % % % %
D T    	@b 	@T 	@ 	@ 	@ 	@=d =t = = = =Jt J J J J J* * * * * *.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 
 
 
 
X$ Xd Xt X X X XL# LT Ld L L L L T d    $ $D $T $ $ $ $ EI * * * *R *T *T * * * *$r b4i    	 	$ 	 	 	 	!b !Yt_ ! ! ! !!b !Yt_ ! ! ! !!b !Yt_ ! ! ! !# #y # # # #	d 	w/F'G 	 	 	 	1 1 1 1 1 1,R ,D4K , , , ,,B ,4$; , , , ,4 B     # $      rO   