
    ^j~                     P   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j&        ej'        ej(        hZ)ee d<   ej*        ej+        ej,        ej-        ej.        ej/        ej0        ej1        ej2        ej3        h
Z4ee d<   dZ5ee d<   dej6        e5<   ddhZ7ee d<   ej8        ej9        ej:        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jK        ejL        hZMee d<   ejF        ejL        hZNee d<   eNejG        hz  ZOee d<   ejP        ejQ        ejR        ejS        ejT        hZUee d<   ejV        ejW        ejX        ejY        ejZ        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jR        ejj        ejk        ejl        hZmee d<   ejn        ejo        hZpee d<   h dZqee d<   ejr        ejZ        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        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#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Zd3e"d,efdIZeju        ejv        ffdJedKedLee         dMee#e#f         d,ef
dNZd3e"d,efdOZd~d3e"dQed,efdRZd3e"d,efdSZd3e"d,efdTZd)edUe|e%         d,efdVZd3ed,efdWZd3ed,ef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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                   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)selfrA   namevisitfs       O/var/www/app.qaans.com/backend/venv/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   childrenrO   )rK   rA   childs      rN   rJ   zVisitor.visit_default   sd      dD!! 	- - -::e,,,,,,,,,,	- 	-- -rP   N)	__name__
__module____qualname____doc__LNr   r   rO   rJ    rP   rN   r@   r@      sf        LL0" 0! 0 0 0 00-" -! - - - - - -rP   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        }	|	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 tn          j8        |v rd|t          j1        k    rts          |          r|S t          |           }
|
r2|
j         t          j1        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  Nz/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      sg    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.$66   %=a%@%@ It$$ 	UZ5#333|  8 F F 	LrP   
nl_count	form_feed
empty_linec                 ,    |r|| dz
  z  dz   |z   S || z  S )z$Generate a normalized prefix string.   rZ   )r   r   r   s      rN   make_simple_prefixr     s/     Ahl+t3j@@  rP   rA   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)rm   rR   r   listleaves
IndexErrorrc   )rA   ress     rN   rn   rn     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)rF   prev_siblings_arerm   )rA   r   s     rN   r   r     sc    
  tbzt| uyF2JuT.ss<<<rP   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)rc   rF   rA   s    rN   rx   rx     s      |t{*t;rP   ancestor
descendantc                 L    |}|r|j         | k    r|j         }|r|j         | k    |S )z:Return the child of `ancestor` that contains `descendant`.)rc   )r   r   rA   s      rN   child_towardsr     s=     D
 4;(**{  4;(**KrP   	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)rc   removeinsert_child)r   r   rc   	child_idxs       rN   replace_childr     sT     F   ""IIy11111 rP   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   )rv   rc   rS   rF   r   
file_inputrm   r;   )r[   same_prefix	containerrc   s       rN   container_ofr     s    
 +KI
 !>?1$33;$/))*v/B/G8/S/S	   rP   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)rR   r   rS   first_leaf_ofr   s    rN   r   r     s=    $ } T]1-...trP   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)rF   r   
arith_expr
shift_exprxor_exprand_exprr   s    rN   is_arith_liker   !  s*    9	  rP   c                     dt           dt          ffd| j        t          j        k    oBt          | j                  dk    o*| j        d         j        t          j        k    o
 |           S )z1Whether whitespace around `**` should be removed.rA   rB   c                 .   t          | t                    r5| 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   | ]} |          V  d S NrZ   ).0rT   	is_simples     rN   	<genexpr>z>is_simple_exponentiation.<locals>.is_simple.<locals>.<genexpr>4  s-      CCEyy''CCCCCCrP   )rR   r   rF   r   r   r   r   r   r   r|   rS   allrA   r   s    rN   r   z+is_simple_exponentiation.<locals>.is_simple.  s    dD!! 	D9U\59eFV WWWY$+%%9T]1-...CCCCT]CCCCCCrP      )	rY   boolrF   r   powerlenrS   r   r   r   s    @rN   r   r   +  s    D Dt D D D D D D 		TZ 	!#	M""e&66	 IdOO	rP   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)rR   r   rF   r   r   r   rd   setintersectionrc   r   simple_stmtrm   r   r   NEWLINEINDENTrs   rf   )rA   rv   s     rN   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5rP   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   )rF   r   r   r   rS   r   r   r   r   s    rN   is_empty_tupler   ^  s`     		TY 	0!#	0M!!UZ/	0 M!!UZ/	rP   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   )
rF   r   r   unwrap_singleton_parenthesistestlist_gexpr   rS   r   ro   r7   rA   gexps     rN   is_one_tupler   h  s    yDI+D11<49(:::54=!!Q&O4=+;+@EK+OO 		^# 	1!#	1M!!U[0rP   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)rF   r   r   r   r   r   s     rN   is_tupler   x  sA    yDIu'--D|tyD$666u4rP   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 r   )rF   r   namedexpr_testr   rT   s     rN   r   z-is_tuple_containing_walrus.<locals>.<genexpr>  s,      LLUuzT00LLLLLLrP   rF   r   r   r   r   anyrS   r   s     rN   is_tuple_containing_walrusr     s[    yDIu'--D|tyD$666uLLdmLLLLLLrP   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   )rF   r   ry   r   s     rN   r   z+is_tuple_containing_star.<locals>.<genexpr>  s+      GGuzT^+GGGGGGrP   r   r   s     rN   is_tuple_containing_starr     s[    yDIu'--D|tyD$666uGGGGGGGGrP   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   )rF   r   old_comp_forr   s     rN   r   zis_generator.<locals>.<genexpr>  s,      JJ5uzT..JJJJJJrP   r   r   s     rN   is_generatorr     s[    yDIu'--D|tyD$666uJJDMJJJJJJrP   openingclosingr   bracketsc                 j   | j         |j         f|k    rdS |j        dz   }t          |          D ]\  }}|| u r ndS 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   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    	gl#x//u!A%E )& 1 1  7??E  uFaN~'  7??E*E!!di5;&>&>aKF{ t{/"4     !A:rP   c                 R    t          |           }|duo|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BrP   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   )
rF   r   r   r   rS   r   r   r   r   r   )rA   r  s     rN   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'rP   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)
rF   r   r   r   r   rS   r   mapr  r   r   s    rN   is_simple_decorator_expressionr    s     yEJtyDJ= 	a %3 7qt9LMMNN &&* Q24=3D4PPP 5rP   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   )rF   r   
yield_expris_name_tokenrd   r   r   rS   r   r   r   is_yield)rA   lparexprrpars       rN   r  r    s    yDO##tT tzW44tyDIu
4=Qu}D$yEJ49
#:#:~~5rP   ra   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)rF   r"   rc   r   ry   )r[   ra   r   s      rN   r{   r{     sY     y((((uAv x 	5H6VrP   c                 ,    | j         t          j        k    S )z&Return True if the node is an f-string)rF   r   fstringr   s    rN   
is_fstringr  -  s    9$$rP   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)rv   r   )rH   r   rv   r   r   r   
get_linenolineno)rA   string_without_prefixstring_leafs      rN   fstring_tstring_to_stringr  2  sY    IIc$+&6&6&8&89u|%:4;OOOK**/aKrP   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   )rR   r   r  r  r   r   rd   )rA   r[   s     rN   is_multiline_stringr  :  sl    $ *T"2"2 (..	D$		 uTZ((?TTZ-??rP   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  sF    9T%566666;""";dm<<<rP   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   )rc   r   rv   stripr   rS   rF   r   r   r   DEDENTis_stub_bodyr   s    rN   is_stub_suiter&  M  s    {'B4'H'Hu { u 	DMa= EM11= EL00= EL00u}Q$$&& ua()))rP   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   r[   s     rN   r   zis_stub_body.<locals>.<genexpr>q  s3      HHUY,,,HHHHHHrP   )rR   r   rF   r   r   r   rS   rv   r#  r   r   )rA   rT   s     rN   r%  r%  d  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	rP   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_   )
rR   r   rF   r   r   rS   r   r   rd   r   )rA   firstr  s      rN   is_atom_with_invisible_parensr,  u  s     $ di!7!7u-"DM"$54E5$ 	J%*$	K2	 tT""	 I#		
 J"rP   c                 >    t          |           pt          |           S r   )is_empty_lparis_empty_rparr[   s    rN   is_empty_parr1    s    5-"5"55rP   c                 B    | j         t          j        k    o
| j        dk    S Nr_   )rF   r   r   rd   r0  s    rN   r.  r.        9
"7tzR'77rP   c                 B    | j         t          j        k    o
| j        dk    S r3  )rF   r   r   rd   r0  s    rN   r/  r/    r4  rP   c                 (   | j         }| j        }| j        }t          |t          j        k    r|r|j        t          j        k    pI|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.rb   from)rc   rF   rd   r   r   LAZYr   lazy_importr   import_namer   )r[   r   r   r   s       rN   	is_importr;    s    A	A
A	
ej	=Q	=16T-=#= 	
O hC1C43C)C FKDAD!&D4D*D	 	 	rP   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   rF   r   r   rd   rc   r   	with_stmtASYNCnext_siblingr0  s    rN   is_with_or_async_with_stmtrA    s    	UZ 	/J& 	/K	/ K.	  	
 
	U[  	5	5"dn4
 
	rP   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   rF   r   r?  rc   r   
async_stmtasync_funcdefr0  s    rN   is_async_stmt_or_funcdefrE    sJ     	U[  	FK	FK$2D EE  rP   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.)rF   rd   r   re   r   is_type_comment_stringr[   r]   r   r   s       rN   is_type_commentrI    s6    
 		A
A 233W8NqRV8W8WWrP   rd   c                     |                      d          o.| dd                                                               d          S )N#r   ztype:)
startswithlstriprd   r]   s     rN   rG  rG    s=    C  KU122Y%5%5%7%7%B%B7%K%KKrP   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.)rF   rd   r   re   r   is_type_ignore_comment_stringrH  s       rN   is_type_ignore_commentrQ    s<    	A
A 233 8U	49 9 rP   c                     t          | |          o@|                     dd          d                                                             d          S )zSReturn True if the given string match with type comment with
    ignore annotation.r4   r   ignore)rG  splitrM  rL  rN  s     rN   rP  rP    sH     "%.. $5;;sA3F3F	4fhhzz(##$rP   )visiblerc   rT   rU  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   rv   r   r   r   r   r   )rc   rT   rU  r  r  rv   indexr   s           rN   wrap_in_parenthesesrZ    s     
72CC33D
72CC33D\FELLLNNaETYud 344II
y)))))rP   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   rS   rF   r   r   r   )rA   r  wrappedr  s       rN   r   r     sS     4=Qt-D'4I##	UZ(?(?tNrP   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`).
    rW  rX  N)rF   r   r   rd   r   r0  s    rN   ensure_visibler^    s@     yEJ


	ej	 	 


 
!	 rP   nlc                 ,    | j         t          j        k    S r   )rF   r   r   r_  s    rN   r  r  
      7ej  rP   c                 ,    | j         t          j        k    S r   )rF   r   r   ra  s    rN   is_lpar_tokenrd    rb  rP   c                 ,    | j         t          j        k    S r   )rF   r   r   ra  s    rN   is_rpar_tokenrf    rb  rP   c                 ,    | j         t          j        k    S r   )rF   r   r   ra  s    rN   is_number_tokenrh    s    7el""rP   )rB   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.NrB   ri  )rc   rm   rF   r   RARROWr   tname)r[   r   s     rN   get_annotation_typerm    sg    {H

  	X%:%?5<%O%O8? 	x3tzAA7? 
 4rP   c                 6    | j         J t          |           duS )z7Returns whether this leaf is part of a type annotation.N)rc   rm  r0  s    rN   is_part_of_annotationro  &  s#    ;"""t$$D00rP   c                 v    t          | t                    r| S | j        sdS t          | j        d                   S )z,Returns the first leaf of the ancestor node.Nr   )rR   r   rS   
first_leafr   s    rN   rq  rq  ,  s=    $ ,] ,t$-*+++rP   c                 v    t          | t                    r| S | j        sdS t          | j        d                   S )z+Returns the last leaf of the ancestor node.Nr   )rR   r   rS   	last_leafr   s    rN   rs  rs  6  s=    $ ,] ,tr*+++rP   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   )rc   rS   )r[   rA   s     rN    furthest_ancestor_with_last_leafru  @  sk    D
+ $+. 44;;OPR;S3S3S{ + $+. 44;;OPR;S3S3SKrP   rF   c                     | j         }||j        |k    rdS |j         }|| j        }||j        |k    rdS |j        }|dS )NTF)rm   rF   r@  )rA   rF   siblings      rN   has_sibling_with_typerx  H  sk    G

<44& 
 G

<44& 

 5rP   )r   )F)rX   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   rY   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%   rl  rz   r&   r6   testlistexprlistr7   r   r   r   RSQBrj   RBRACEr8   r   keysr9   valuesr:   r;   ro   FSTRING_MIDDLEFSTRING_ENDTSTRING_MIDDLETSTRING_ENDr   r<   rk  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,  r1  r.  r/  r;  rA  rE  rI  rG  rQ  rP  rZ  r   r^  r  rd  rf  rh  rm  ro  rq  rs  ru  rx  rZ   rP   rN   <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xT x xT xc x x x xv! ! ! !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    2 $    &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 = = = =* * * * * *.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     # $      rP   