
    ]j}                     :   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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jL                  ejN                  ejP                  hZ)ee d<   ejT                  ejV                  ejX                  ejZ                  ej\                  ej^                  ej`                  ejb                  ejd                  ejf                  h
Z4ee d<   dZ5ee d<   dejl                  e5<   ddhZ7ee d<   ejp                  ejr                  ejt                  ejv                  ejx                  ejz                  hZ>ee d<   ej~                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  hZMee d<   ej                  ej                  hZNee d<   eNej                  hz  ZOee d<   ej                  ej                  ej                  ej                  ej                  hZUee d<   ej                  ej                  ej                  ej                  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j                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  hZmee d<   ej                  ej                  hZpee d<   h dZqee d<   ej                  ej                  ej                  hZtee d<   ej                  ej                  ej                  ej                  ej                  ej                  iZ{ee d<    e|e{j                               Z~ee d <    e|e{j                               Zee d!<   e~ez  Zee d"<   eej                  e5e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#d/ed0ed,efd1Zd2e"d3z  d,ed3z  fd4Zd2e"d3z  d5ee%d3z     d,efd6Zd2e"d3z  d,e%d3z  fd7Zd8ed9e"d,e"d3z  fd:Zd;e"d<e"d,d3fd=Zd)ed,e"fd>Zd2e"d,ed3z  fd?Zd2e"d,efd@Zd2e"d,efdAZd2ed,efdBZd2e"d,efdCZd2e"d,efdDZd2e"d,efdEZd2e"d,efdFZd2e"d,efdGZd2e"d,efdHZej                  ej                  ffdIedJedKee   dLee#e#f   d,ef
dMZd2e"d,efdNZd|d2e"dOed,efdPZd2e"d,efdQZd2e"d,efdRZd)edSe|e%   d,efdTZd2ed,efdUZd2ed,efdVZd2e"d,efdWZd2ed,efdXZd2ed,efdYZd2e"d,efdZZd2e"d,efd[Zd)ed,efd\Zd)e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+ed,efdbZdced+ed,efddZd)ed+ed,efdeZdced+ed,efdfZd%dgdhedie"djed,d3fdkZd2e"d,e"d3z  fdlZd)ed,d3fdmZdned,ee   fdoZdned,ee   fdpZdned,ee   fdqZdned,ee   fdrZd)ed,eds   fdtZd)ed,efduZd2e"d,ed3z  fdvZd2e"d,ed3z  fdwZd)ed,e"fdxZd2e"dye#d,efdzZy3)}z>
blib2to3 Node/Leaf transformation-related utility functions.
    )Iterator)FinalGenericLiteral	TypeGuardTypeVarUnion)
mypyc_attr)	CACHE_DIR)ModePreview)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                   <    e Zd ZdZdedee   fdZdedee   fdZy)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{    y| j                  |      E d{    y7 7 w)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)selfrA   namevisitfs       5/root/env/lib/python3.12/site-packages/black/nodes.pyvisitzVisitor.visit   s{      99s?>>$)),Dy+,D
 v5d|##))$/// $/s$   A)B+B,BBBBc              #      K   t        |t              r+|j                  D ]  }| j                  |      E d{     yy7 w)zCDefault `visit_*()` implementation. Recurses to children of `node`.N)
isinstancer   childrenrO   )rK   rA   childs      rN   rJ   zVisitor.visit_default   s=     dD! -::e,,,- ",s   4A?	AN)	__name__
__module____qualname____doc__LNr   r   rO   rJ        rN   r@   r@      s3    L0" 0! 00-" -! -rZ   r@   leafcomplex_subscriptmoderB   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                  }	|	st        |      }
|
r|
j                   t         v r|S |t        j                  k(  rB|
j                   t        j                  k(  r|S |
j                   t        j"                  k7  r|s|S |S |
j                   t        j$                  k(  r|
j                  rY|
j                  j                   t        j&                  t        j(                  t        j*                  t        j,                  hv r|S |
j                  j                   t        j.                  k(  r|
j0                  S |
j                   t        j2                  k(  rSt5        |
      t        j6                  k(  r7t5        |
j                        t        j                  t        j8                  fv r|S |
j                   t:        v rt=        |
t>        t@        z        r4|S |
j                   t        j                  k(  rI|
j                  r|
j                  j                   t        j                  t        j                  hv r|r|S |S |
j                  r;|
j                  j                   t        jB                  k(  r|
j                   tD        v r|S |
j                   t        jF                  k(  rh|j                  r\|j                  j                   t        jH                  k(  r5|S |	j                   t         v r|S |	j                   t        jJ                  k(  r|S |j                   t        j*                  t        j&                  hv r"|	r|	j                   t        j"                  k7  r|S |j                   t        j,                  k(  r#|	r|	j                   t        j"                  k7  r|S |j                   t        j.                  k(  ru|	s|S |t        j$                  k(  r|	j                   tL        vr|S |	j                   t        j$                  k(  r|	j0                  S |	j                   t        j"                  k7  rL|S |j                   tL        v r0|	s5t        |      }
|
r|
j                   t        j"                  k7  r
|S |j                   t        jN                  k(  rs|t        jP                  k(  s|t        jR                  k(  r|S |	s)|t        jT                  k(  s|t        jV                  k(  r|S |	j                   t        j"                  k7  rz|S |j                   t        j(                  k(  rk|t        j$                  k(  r|S |	s-t        |      }
|
r|
j                   t        jP                  k(  r|S |	j                   t        j$                  ht:        z  v r|S |j                   t        jH                  k(  r|S |j                   t        jX                  k(  rN|	r|S t        |      }
|
r;|
j                   t        jF                  k(  s|
j                   t        jT                  k(  rh|S |j                   t        jZ                  k(  r8|t        jP                  k(  r|S |	r1|	j                   t        jP                  k(  r|S |j                   t        j                  t        j                  hv rw|	s>|j                  J d       |j                  j                   t        j                  k(  r|S |S |t        j\                  k(  s|	j                   t        j\                  k(  r|S |sp|S |j                   t        j^                  k(  r|	rN|t        jT                  k(  r:|S |j                   t        j`                  k(  r#|	r|	j                   t        jb                  k(  r|S |j                   t        jB                  t        j6                  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(  r0|j                   t        j(                  k(  r|S |t        jd                  t        jf                  t        jh                  hv r|S |j                   t        jj                  k(  ro|t        jT                  k(  r!|	r|	j                   t        jT                  k(  r|S |t        jd                  k(  ry|dk(  r|S |	rp|	j                   t        jT                  k(  rS|S |j                   t        j                  k(  r|S |j                   t        jl                  k(  r|t        j2                  k(  r|S tn        jp                  |v rm|t        jb                  k(  rts        |      r|S t        |       }
|
r@|
j                   t        jb                  k(  r#|
j                  rts        |
j                        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  z/INTERNAL ERROR: hand-made leaf without parent: )withinzsubscripts are always parentedimport):rF   parentvaluer<   r   COMMENTCOLONr   	subscriptsubscriptlistsliceopLBRACEfstring_replacement_fieldtstring_replacement_fieldprev_siblingpreceding_leafr9   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_clauser   simplify_power_operator_huggingis_simple_exponentiation)r[   r\   r]   NOSPACEDOUBLESPACEtpvprevprevpprevp_parents               rN   
whitespacer      s    BE"K		AA

AO	EMM=TKD8TT=EKKAFF+ 
 	ELLQVV&&&&(  	Dq!

&66IzzU[[(	u{{*3D	L::$||<<$$LLMMOO$$	)  I\\&&$*<*<< !<<' JJ%**$E"dnn4ELL)d.@.@$//-RR IZZ++9J'JK	ZZ5;;&|| 1 1dnndll5S S 1u9r9 LL!!T[[0

n,IZZ588#QXX]]dnn5TI	&	&		ejj	 	vv$//4<<00tyyEKK/I	
4##	#DII,I	
4%%	%Iyy+	YY%++% ;;YY%++%I	
;	"1%EEJJ%++5		
4<<	

?a5::oIEII~ejj	YY%++%I	
4==	 I"1%EEJJ%**4	YY5;;-*:::I	
4>>	!		
4##	#Iq!

ehh.%**		2II	
4==	 

?IDII+I	
DNNDLL1	188'I)II'xx}} 2 22I%"""dii53C3C&CL"I	
499	ANI	
4$$	$DII!1!11I	
DKK0	0"1%EEJJ*::	 <<L+++zzU[[(\->->C . 	u{{*|/@/@DMM/Q	5::u||U\\::I	
4##	#		>		UYY.	%**_H}		UYY.		
4<<			
4%%	%

?I..$6   %=a%@It$UZZ5#3#33|| 8 F	LrZ   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      rN   make_simple_prefixr     s)    hl+t3j@@  rZ   rA   Nc                     | rL| j                   }|r/t        |t              r|S 	 t        |j	                               d   S | j                  } | rLy# t
        $ r Y yw xY w)z3Return the first leaf that precedes `node`, if any.N)rm   rQ   r   listleaves
IndexErrorrc   )rA   ress     rN   rn   rn     sf    
#t$
CJJL)"--
 {{  	  s   A 	AAtokensc                 x    |sy|d   | du S | sy| j                   |d   k7  ry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)rF   prev_siblings_arerm   )rA   r   s     rN   r   r     sP    
 bzt|yyF2JT..s<<rZ   c                 L    | | j                   y| j                   j                  S )z|
    Returns:
        @node.parent.type, if @node is not None and has a parent.
            OR
        None, otherwise.
    N)rc   rF   rA   s    rN   rx   rx     s%     |t{{*;;rZ   ancestor
descendantc                 h    |}|r-|j                   | k7  r|j                   }|r|j                   | k7  r|S )z:Return the child of `ancestor` that contains `descendant`.)rc   )r   r   rA   s      rN   child_towardsr     s3     D
4;;(*{{ 4;;(*KrZ   	old_child	new_childc                 l    | j                   }|sy| j                         }||j                  ||       yy)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)rc   removeinsert_child)r   r   rc   	child_idxs       rN   replace_childr     s>     F  "IIy1 rZ   c                 &   | j                   }| }|r|j                  }|	 |S |j                  d   j                   |k7  r	 |S |j                  t        j
                  k(  r	 |S |j                  |j                  j                  t        v r	 |S |}|r|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.
    r   )rv   rc   rR   rF   r   
file_inputrm   r;   )r[   same_prefix	containerrc   s       rN   container_ofr     s    
 ++KI
!!>  ??1$$3  ;;$//) 	 *v/B/B/G/G8/S  	  rZ   c                 p    t        | t              r| S | j                  rt        | j                  d         S y)z(Returns the first leaf of the node tree.r   N)rQ   r   rR   first_leaf_ofr   s    rN   r   r     s/    $}}T]]1-..rZ   c                     | j                   t        j                  t        j                  t        j                  t        j
                  hv S )z?Whether node is an arithmetic or a binary arithmetic expression)rF   r   
arith_expr
shift_exprxor_exprand_exprr   s    rN   is_arith_liker   !  s4    99	  rZ   c                    dt         dt        ffd| j                  t        j                  k(  xrN t        | j                        dk\  xr4 | j                  d   j                  t        j                  k(  xr  |       S )z1Whether whitespace around `**` should be removed.rA   rB   c                 X   t        | t              rJ| j                  t        j                  t        j
                  t        j                  t        j                  fv S | j                  t        j                  k(  r | j                  d         S t        fd| j                  D              S )Nr   c              3   .   K   | ]  } |        y wNrY   ).0rS   	is_simples     rN   	<genexpr>z>is_simple_exponentiation.<locals>.is_simple.<locals>.<genexpr>4  s     CEy'Cs   )rQ   r   rF   r   r   r   r   r   r   r|   rR   allrA   r   s    rN   r   z+is_simple_exponentiation.<locals>.is_simple.  sp    dD!99U\\599eFVFV WWWYY$++%T]]1-..CT]]CCCrZ      )	rX   boolrF   r   powerlenrR   r   r   r   s    @rN   r   r   +  sv    D Dt D 			TZZ 	!#	MM"""e&6&66	 dO	rZ   c                    t        | t              rN| j                  t        j                  k7  ryt        | j                        }t        |      j                  d      ry| j                  r| j                  j                  t        j                  k(  r^| j                  j                  sH| j                  j                  r2| j                  j                  j                  t        j                  k(  ryt        | j                  d t        j                  t        j                   t        j                  g      ryt        | j                  t        j"                  t        j$                  t        j                  g      ryy)NFbBfFT)rQ   r   rF   r   r   r   rd   setintersectionrc   r   simple_stmtrm   r   r   NEWLINEINDENTrs   rf   )rA   rv   s     rN   is_docstringr   >  s    $99$"4::.v;##F+ 	KK 0 00((KKKK##t6dEMM5<<9I9IJ  tTEUEU&VW rZ   c                     | j                   t        j                  k(  xrp t        | j                        dk(  xrV | j                  d   j                   t
        j                  k(  xr* | j                  d   j                   t
        j                  k(  S )z+Return True if `node` holds an empty tuple.   r   r   )rF   r   r   r   rR   r   r   r   r   s    rN   is_empty_tupler   ^  sq     			TYY 	0!#	0MM!!!UZZ/	0 MM!!!UZZ/	rZ   c                    | j                   t        j                  k(  rot        |       }||j                   t        j                  k7  ryt        |j                        dk(  xr* |j                  d   j                   t        j                  k(  S | j                   t        v xrD t        | j                        dk(  xr* | j                  d   j                   t        j                  k(  S )zMReturn True if `node` holds a tuple with one element, with or without parens.Fr   r   )
rF   r   r   unwrap_singleton_parenthesistestlist_gexpr   rR   r   ro   r7   rA   gexps     rN   is_one_tupler   h  s    yyDII+D1<499(:(::4==!Q&O4==+;+@+@EKK+OO 			^# 	1!#	1MM!!!U[[0rZ   c                     | j                   t        j                  k7  ryt        |       }||j                   t        j                  k7  ryy)z$Return True if `node` holds a tuple.FT)rF   r   r   r   r   r   s     rN   is_tupler   x  s;    yyDII'-D|tyyD$6$66rZ   c                     | j                   t        j                  k7  ryt        |       }||j                   t        j                  k7  ryt        d |j                  D              S )zDReturn True if `node` holds a tuple that contains a walrus operator.Fc              3   V   K   | ]!  }|j                   t        j                  k(   # y wr   )rF   r   namedexpr_testr   rS   s     rN   r   z-is_tuple_containing_walrus.<locals>.<genexpr>  s     LUuzzT000L   ')rF   r   r   r   r   anyrR   r   s     rN   is_tuple_containing_walrusr     sM    yyDII'-D|tyyD$6$66LdmmLLLrZ   c                     | j                   t        j                  k7  ryt        |       }||j                   t        j                  k7  ryt        d |j                  D              S )zBReturn True if `node` holds a tuple that contains a star operator.Fc              3   V   K   | ]!  }|j                   t        j                  k(   # y wr   )rF   r   ry   r   s     rN   r   z+is_tuple_containing_star.<locals>.<genexpr>  s     GuzzT^^+Gr   r   r   s     rN   is_tuple_containing_starr     sM    yyDII'-D|tyyD$6$66GGGGrZ   c                     | j                   t        j                  k7  ryt        |       }||j                   t        j                  k7  ryt        d |j                  D              S )z(Return True if `node` holds a generator.Fc              3   V   K   | ]!  }|j                   t        j                  k(   # y wr   )rF   r   old_comp_forr   s     rN   r   zis_generator.<locals>.<genexpr>  s     J5uzzT...Jr   r   r   s     rN   is_generatorr     sM    yyDII'-D|tyyD$6$66JDMMJJJrZ   openingclosingr   bracketsc                    | j                   |j                   f|k7  ry|j                  dz   }t        |      D ]  \  }}|| u s n yd}|dz  }||d D ]  }||u r |dk  S |j                  }||k(  s|j                   t        j                  k(  s=|dz  }|j
                  sO|j
                  j                   t        j                  t        j                  hv s|dz  } |dk  S  |dk  S )zIReturn True if content between `opening` and `closing` is a one-sequence.Fr   r   Nr   )	rF   bracket_depth	enumerater   ro   rc   r   rq   ru   )	r   r   r   r   depth_opening_indexr[   commasr   s	            rN   is_one_sequence_betweenr     s    	gll#x/!!A%E )& 1 7?
 FaN~' 7? A: **E!dii5;;&>aKF{{t{{//""4   !A: A:rZ   c                 ^    t        |       }|duxr |j                  t        j                  k(  S )z7Return True iff `node` is of the shape ( test := test )N)r   rF   r   r   )rA   inners     rN   is_walrus_assignmentr    s+    (.EBt/B/B!BBrZ   lastc                    | j                   t        j                  k(  xr\ t        | j                        dk(  xrV | j                  d   j                   t
        j                  k(  xr* | j                  d   j                   t
        j                  k(  xs |xrp t        | j                        dk(  xrV | j                  d   j                   t
        j                  k(  xr* | j                  d   j                   t
        j                  k(  xst |xrp t        | j                        dk(  xrV | j                  d   j                   t
        j                  k(  xr* | j                  d   j                   t
        j                  k(  S )z?Return True iff `node` is a trailer valid in a simple decoratorr   r   r   r   )
rF   r   r   r   rR   r   r   r   r   r   )rA   r  s     rN   is_simple_decorator_trailerr    s1   99$ !# 4a %%24a %%3	
  4DMM"a'4a %%34 a %%3	
  4DMM"a'4a %%34 a %%3'rZ   c                    | j                   t        j                  k(  ry| j                   t        j                  k(  r| j
                  r| j
                  d   j                   t        j                  k(  xr\ t        t        t        | j
                  dd             xr4 t        | j
                        dk  xs t        | j
                  d   d      S y)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)
rF   r   r   r   r   rR   r   mapr  r   r   s    rN   is_simple_decorator_expressionr    s     yyEJJyyDJJ==a %%3 7q9LMN &* Q24==3D4P rZ   c                    | j                   t        j                  k(  ryt        |       r| j                  dk(  ry| j                   t        j
                  k7  ryt        | j                        dk7  ry| j                  \  }}}|j                   t        j                  k(  r(|j                   t        j                  k(  rt        |      S y)zAReturn True if `node` holds a `yield` or `yield from` expression.TyieldFr   )rF   r   
yield_expris_name_tokenrd   r   r   rR   r   r   r   is_yield)rA   lparexprrpars       rN   r  r    s    yyDOO#TtzzW4yyDII
4==Q}}D$yyEJJ499

#:~rZ   ra   c                     | j                   t        vs| j                  sy| j                  }|j                   t        j                  k(  r|j                  sy|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)rF   r"   rc   r   ry   )r[   ra   r   s      rN   r{   r{     sW     yy((Avv xxHH66VrZ   c                 <    | j                   t        j                  k(  S )z&Return True if the node is an f-string)rF   r   fstringr   s    rN   
is_fstringr  -  s    99$$rZ   c                     t        |       t        | j                        d }t        t        j
                  || j                        }| j                         xs d|_        |S )z:Converts an fstring or tstring node back to a string node.N)rv   r   )rH   r   rv   r   r   r   
get_linenolineno)rA   string_without_prefixstring_leafs      rN   fstring_tstring_to_stringr  2  sN    Ic$++&6&89u||%:4;;OK*/aKrZ   c                     t        | t              rt        |       rt        |       }nt        | t              r| }nyt        |j                        xr d|j                  v S )zKReturn True if `leaf` is a multiline string that actually spans many lines.F
)rQ   r   r  r  r   r   rd   )rA   r[   s     rN   is_multiline_stringr  :  sL    $*T"2(.	D$	TZZ(?TTZZ-??rZ   c                     | j                   t        j                  t        j                  hv sJ | j                  J | j                  j                   t        j
                  t        j                  hv S r   )rF   r   suiter   rc   funcdefr   r   s    rN   is_parent_function_or_classr!  F  sU    99T%5%56666;;""";;dmm<<<rZ   c                    | j                   t        |       sy| j                  j                         ryt	        | j
                        dk7  s~| j
                  d   j                  t        j                  k7  sT| j
                  d   j                  t        j                  k7  s*| j
                  d   j                  t        j                  k7  ry| j
                  d   j                  j                         ryt        | j
                  d         S )z2Return True if `node` is a suite with a stub body.F   r   r   r   r   )rc   r!  rv   stripr   rR   rF   r   r   r   DEDENTis_stub_bodyr   s    rN   is_stub_suiter'  M  s    {{'B4'H {{ 	DMMa==  EMM1==  ELL0==  ELL0}}Q$$&a())rZ   c                    t        | t              r| j                  t        j                  k7  ryt        | j                        dk7  ry| j                  d   }|j                  j                          xrU |j                  t        j                  k(  xr6 t        |j                        dk(  xr t        d |j                  D              S )zCReturn True if `node` is a simple statement containing an ellipsis.Fr   r   r   c              3   V   K   | ]!  }|t        t        j                  d       k(   # yw).N)r   r   r   )r   r[   s     rN   r   zis_stub_body.<locals>.<genexpr>q  s      HUYY,,Hr   )rQ   r   rF   r   r   r   rR   rv   r$  r   r   )rA   rS   s     rN   r&  r&  d  s    dD!TYY$2B2B%B
4==QMM!ELL   	IJJ$))#	I1$	I HHH	rZ   c                    t        | t              s| j                  t        j                  k7  ry| j
                  d   | j
                  d   }}t        |t              xrp |j                  t        j                  k(  xrQ |j                  dk(  xr@ t        |t              xr. |j                  t        j                  k(  xr |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   rF   r   r   rR   r   r   rd   r   )rA   firstr  s      rN   is_atom_with_invisible_parensr-  u  s     $dii!7--"DMM"$54E5$ 	JJ%**$	KK2	 tT"	 II#		
 JJ"rZ   c                 2    t        |       xs t        |       S r   )is_empty_lparis_empty_rparr[   s    rN   is_empty_parr2    s    5-"55rZ   c                 ^    | j                   t        j                  k(  xr | j                  dk(  S Nr_   )rF   r   r   rd   r1  s    rN   r/  r/    #    99

"7tzzR'77rZ   c                 ^    | j                   t        j                  k(  xr | j                  dk(  S r4  )rF   r   r   rd   r1  s    rN   r0  r0    r5  rZ   c                 *   | j                   }| j                  }| j                  }t        |t        j
                  k(  xrR |dk(  xr! |xr |j                  t        j                  k(  xs( |dk(  xr! |xr |j                  t        j                  k(        S )z9Return True if the given leaf starts an import statement.rb   from)	rc   rF   rd   r   r   r   r   import_namer   )r[   r   r   r   s       rN   	is_importr:    s    A		A

A	UZZ 	
(]?q?QVVt/?/?%? BV@@aff0@0@&@	 rZ   c                    t        | j                  t        j                  k(  xrF | j                  dk(  xr5 | j
                  xr' | j
                  j                  t        j                  k(        xs] t        | j                  t        j                  k(  xr5 | j                  xr' | j                  j                  t        j                  k(        S )zDReturn True if the given leaf starts a with or async with statement.with)
r   rF   r   r   rd   rc   r   	with_stmtASYNCnext_siblingr1  s    rN   is_with_or_async_with_stmtr@    s    		UZZ 	/JJ& 	/KK	/ KK.	 	
 
		U[[  	5	5""dnn4
	rZ   c                     t        | j                  t        j                  k(  xrD | j                  xr6 | 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   rF   r   r>  rc   r   
async_stmtasync_funcdefr1  s    rN   is_async_stmt_or_funcdefrD    sU     		U[[  	FKK	FKK$2D2D EE rZ   c                 ~    | j                   }| j                  }|t        j                  t        hv xr 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.)rF   rd   r   re   r   is_type_comment_stringr[   r]   r   r   s       rN   is_type_commentrH    s9    
 			A

A 233W8NqRV8WWrZ   rd   c                 l    | j                  d      xr" | dd  j                         j                  d      S )N#r   ztype:)
startswithlstriprd   r]   s     rN   rF  rF    s2    C KU12Y%5%5%7%B%B7%KKrZ   c                 ~    | j                   }| j                  }|t        j                  t        hv xr t        ||      S )zGReturn True if the given leaf is a type comment with ignore annotation.)rF   rd   r   re   r   is_type_ignore_comment_stringrG  s       rN   is_type_ignore_commentrP    s=    		A

A 233 8U	49 rZ   c                     t        | |      xr2 | j                  dd      d   j                         j                  d      S )zSReturn True if the given string match with type comment with
    ignore annotation.r4   r   ignore)rF  splitrL  rK  rM  s     rN   rO  rO    s=     "%. $5;;sA3F	4fhzz(#$rZ   )visiblerc   rS   rT  c                6   t        t        j                  |rdnd      }t        t        j                  |rdnd      }|j                  }d|_        |j                         xs d}t        t        j                  |||g      }||_        | j                  ||       y)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   rv   r   r   r   r   r   )rc   rS   rT  r  r  rv   indexr   s           rN   wrap_in_parenthesesrY    s{     

7C3D

7C3D\\FELLLNaETYYud 34II
y)rZ   c                     t        | j                        dk7  ry| j                  \  }}}|j                  t        j                  k(  r|j                  t        j
                  k(  sy|S )zqReturns `wrapped` if `node` is of the shape ( wrapped ).

    Parenthesis can be optional. Returns None otherwiser   N)r   rR   rF   r   r   r   )rA   r  wrappedr  s       rN   r   r     sO     4==Q--D'4II#		UZZ(?NrZ   c                     | j                   t        j                  k(  rd| _        y| j                   t        j                  k(  rd| _        yy)zMake sure parentheses are visible.

    They could be invisible as part of some statements (see
    :func:`normalize_invisible_parens` and :func:`visit_import_from`).
    rV  rW  N)rF   r   r   rd   r   r1  s    rN   ensure_visibler]    s7     yyEJJ
	ejj	 
 
!rZ   nlc                 <    | j                   t        j                  k(  S r   )rF   r   r   r^  s    rN   r  r        77ejj  rZ   c                 <    | j                   t        j                  k(  S r   )rF   r   r   r`  s    rN   is_lpar_tokenrc    ra  rZ   c                 <    | j                   t        j                  k(  S r   )rF   r   r   r`  s    rN   is_rpar_tokenre    ra  rZ   c                 <    | j                   t        j                  k(  S r   )rF   r   r   r`  s    rN   is_number_tokenrg    s    77ell""rZ   )rB   paramNc                    | j                   }|w|j                  r(|j                  j                  t        j                  k(  ry|j                   r(|j                   j                  t
        j                  k(  ry|j                   }|wy)z<Returns the type of annotation this leaf is part of, if any.NrB   rh  )rc   rm   rF   r   RARROWr   tname)r[   r   s     rN   get_annotation_typerl    si    {{H

  X%:%:%?%?5<<%O??x33tzzA?? 
 rZ   c                 8    | j                   J t        |       duS )z7Returns whether this leaf is part of a type annotation.N)rc   rl  r1  s    rN   is_part_of_annotationrn  #  s"    ;;"""t$D00rZ   c                 p    t        | t              r| S | j                  syt        | j                  d         S )z,Returns the first leaf of the ancestor node.Nr   )rQ   r   rR   
first_leafr   s    rN   rp  rp  )  s/    $]]$--*++rZ   c                 p    t        | t              r| S | j                  syt        | j                  d         S )z+Returns the last leaf of the ancestor node.Nr   )rQ   r   rR   	last_leafr   s    rN   rr  rr  3  s/    $]]r*++rZ   c                    | }|j                   r{|j                   j                  re||j                   j                  d   u rJ|j                   }|j                   r2|j                   j                  r||j                   j                  d   u rJ|S )zGReturns the furthest ancestor that has this leaf node as the last leaf.r   )rc   rR   )r[   rA   s     rN    furthest_ancestor_with_last_leafrt  =  sk    D
++$++..44;;;O;OPR;S3S{{ ++$++..44;;;O;OPR;S3SKrZ   rF   c                     | j                   }||j                  |k(  ry|j                   }|| j                  }||j                  |k(  ry|j                  }|y)NTF)rm   rF   r?  )rA   rF   siblings      rN   has_sibling_with_typerw  E  so    G

<<4&& 
 G

<<4&& 

 rZ   )r  )F)rW   collections.abcr   typingr   r   r   r   r   r	   mypy_extensionsr
   black.cacher   
black.moder   r   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   r=  r   r   
match_stmt
case_blockr   r   rG   r   LESSGREATEREQEQUALNOTEQUAL	LESSEQUALGREATEREQUALr   VBAR
CIRCUMFLEXAMPER	LEFTSHIFT
RIGHTSHIFTPLUSMINUSrw   SLASHDOUBLESLASHPERCENTr}   TILDEr   r    r!   r"   rq   rr   r   ru   rt   r#   r   r   	listmakerr   testlist_star_exprsubject_exprpatternr$   testlambdefor_testand_testnot_test
comparisonry   r  r   r   r   r   termr   r   r%   rk  rz   r&   r6   testlistexprlistr7   r   r   r   RSQBrj   RBRACEr8   r   keysr9   valuesr:   r;   ro   FSTRING_MIDDLEFSTRING_ENDTSTRING_MIDDLETSTRING_ENDr   r<   rj  r@   r   rH   r   r   rn   r   r   rx   r   r   r   r   r   r   r   r   r   r   r   r   r   tupler   r  r  r  r  r{   r  r  r  r!  r'  r&  r-  r2  r/  r0  r:  r@  rD  rH  rF  rP  rO  rY  r   r]  r  rc  re  rg  rl  rn  rp  rr  rt  rw  rY   rZ   rN   <module>r     sK	   % E E & ! $ >    5 5   ) ##e # CL
4:	 \\5<<?
E ?LLOOMMMMNNLLMMOOOO	5    E %9! " &	JJ	MM	MM	NN	OO	U  
JJ		KK	OO		JJ	KK	JJ	KK		MM	HH	KK	   

E,,-u -5;;-/ % /LLMMLL  	IINNLL 5  	IILLLLMMMMOONNIIMMMMOOOOLLIIJJ! % $ jj$//2U 2U $ (?(?O O	JJ

	JJ

	LL%,, 
 glln- % -gnn./ % /"%55% 5)	KK					JJ-   
 .-gaj - /-DxT x xT xc xv! ! !3 !RU !d td{ $=BI =tHtO/D = = 
b4i 
HtO 
D b R$Y 2R 2B 24 2"t  2 td{  t 2 $ &r d @  r d  2 $ MR MD MH2 H$ HKr Kd K "'UZZ 8	""" J" CHo	"
 
"JCr Cd Cb   4  02 $ *D #h- D .%T %d %
D T 	@b 	@T 	@=d =t =* * *.r d " t $6t 6 68 8 88 8 8D T T d 
4 
D 
X$ Xd Xt XL# LT Ld 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,R ,D4K ,,B ,4$; ,4 B  # $ rZ   