
    ziqn                        U d Z ddlZddlmZmZmZmZmZmZm	Z	m
Z
mZ ej        dk    rddlmZ nddlmZ ddlmZ ddlmZ ddlmZ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$j0        e$j1        e$j2        e$j3        e$j4        e$j5        e$j6        e$j7        e$j8        h
Z9ee%d<   dZ:ee%d<   dej;        e:<   ddhZ<ee%d<   ej=        ej>        ej?        ej@        ejA        ejB        hZCee%d<   ejD        ejE        ejF        ejG        ejH        ejI        ejJ        ejK        ejL        ejM        ejN        ejO        ejP        ejQ        hZRee%d<   ejK        ejQ        hZSee%d<   eSejL        hz  ZTee%d<   e$jU        e$jV        e$jW        e$jX        e$jY        hZZee%d<   e$j[        e$j\        e$j]        e$j^        e$j_        e$j`        e$ja        hZbee%d<   e$jc        e$jd        e$je        e$jf        e$jg        e$jh        e$ji        e$jj        e$jk        e$jl        e$jm        e$jn        e$jW        e$jo        e$jp        hZqee%d<   e$jr        e$js        hZtee%d<   h dZuee%d<   e$jv        e$j_        e$jw        hZxee%d <   ejy        ejz        ej{        ej|        ej}        ej~        iZee%d!<    ee                                          Zee%d"<    ee                                          Zee%d#<   eez  Zee%d$<   eej        e:hz  Zee%d%<   d&Z ed'(           G d) d*ee&                               Zd+ed,ed-ed.efd/Zdud1e(d2ed3ed.efd4Zd5ee'         d.ee         fd6Zd5ee'         d7eee*                  d.efd8Zd5ee'         d.ee*         fd9Zd:e d;e'd.ee'         fd<Zd=e'd>e'd.dfd?Zd+ed.e'fd@Zd5e'd.ee         fdAZd5e'd.efdBZd+ed.efdCZd5e'd.efdDZd5e'd.efdEZd5e'd.efdFZejy        ejz        ffdGedHedIee         dJe	e(e(f         d.ef
dKZd5e'd.efdLZdvd5e'dNed.efdOZd5e'd.efdPZd5e'd.efdQZd+edRee*         d.efdSZd+ed.efdTZd5e d.efdUZd5e d.efdVZd5e d-ed.efdWZd5e'd.efdXZd5e'd.efdYZd+ed.efdZ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d`Zd+ed.efdaZdbed.efdcZd'dddee dfe'dged.dfdhZd5e'd.ee'         fdiZd+ed.dfdjZdked.ee         fdlZdked.ee         fdmZdked.ee         fdnZdked.ee         fdoZdked.ee         fdpZd+ed.efdqZd5e'd.ee         fdrZd5e'd.ee         fdsZd+ed.e'fdtZdS )wz>
blib2to3 Node/Leaf transformation-related utility functions.
    N)	FinalGenericIteratorListOptionalSetTupleTypeVarUnion)   
   )	TypeGuard)
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)selfrE   namevisitfs       V/var/www/tmov.alphamb/tmov_inventario/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   childrenrS   )rO   rE   childs      rR   rN   zVisitor.visit_default   sd      dD!! 	- - -::e,,,,,,,,,,	- 	-- -rT   N)	__name__
__module____qualname____doc__LNr   r   rS   rN    rT   rR   rD   rD      sf        LL0" 0! 0 0 0 00-" -! - - - - - -rT   rD   leafcomplex_subscriptmoderF   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 | j        }	|	st          |          }
|
r|
j         t          v r|S |t          j        k    r2|
j         t          j        k    r|S |
j         t          j        k    r|s|S |S |
j         t          j        k    rf|
j        r]|
j        j         t          j        t          j        t          j        t          j        hv r|S |
j        j         t          j        k    r|
j        S nF|
j         t          j        k    rAt/          |
          t          j        k    r$t/          |
j                  t          j	        k    r|S |
j         t2          v r!t5          |
t6          t8          z            r|S n|
j         t          j        k    r2|
j        r*|
j        j         t          j        t          j
        hv r|r|n|S nz|
j        r*|
j        j         t          j        k    r|
j         t<          v r|S |
j         t          j        k    r#|j        r|j        j         t          j         k    r|S n|	j         t          v r|S |j         t          j        t          j        hv r|	r|	j         t          j        k    r|S n|j         t          j        k    r|	r|	j         t          j        k    r|S n|j         t          j        k    r[|	s|S |t          j        k    r|	j         tB          vr|S nv|	j         t          j        k    r|	j        S |	j         t          j        k    r|S nA|j         tB          v r,|	s(t          |          }
|
r|
j         t          j        k    r|S n|j         t          j"        k    ra|t          j#        k    s|t          j$        k    r|S |	s$|t          j%        k    s|t          j&        k    r|S 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 n>|	j         t          j        ht2          z  v r|S n|j         t          j         k    r|S |j         t          j'        k    rC|	r|S t          |          }
|
r*|
j         t          j        k    s|
j         t          j%        k    r|S n|j         t          j(        k    r-|t          j#        k    r|S |	r|	j         t          j#        k    r|S nm|j         t          j        t          j
        hv rl|	s/|j        
J d            |j        j         t          j	        k    r|S |S tR          j*        |v r'|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          j-        k    r|	r|	j         t          j.        k    r|S n|j         t          j        t          j        hv r|	st          |          }
|
r|
j         t          v r|S |
j        }|J |
j         t          j        k    r!|j         t          j        t          j
        hv r|S |
j         t          j        k    r|j         t          j        k    r|S n|t          j/        t          j0        t          j1        hv r|S n|j         t          j2        k    r\|t          j%        k    r|	r|	j         t          j%        k    r|S np|t          j/        k    r!|dk    r|S |	r|	j         t          j%        k    r|S n>|j         t          j
        k    r|S |j         t          j3        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)4rJ   parentvaluer@   r   COMMENTCOLONr   	subscriptsubscriptlistsliceopprev_siblingpreceding_leafr=   COMMAEQUALarglistargument
parametersvarargslisttypedargslistprefixSTARparent_type	star_exprr'   	is_varargr(   r)   factorr%   AT	decoratorr+   trailerLPARRPARDOTLSQBdotted_nameclassdefr   walrus_subscript
COLONEQUALatomdictsetmaker
DOUBLESTARNAMENUMBERSTRINGimport_fromexcept_clause)r_   r`   ra   NOSPACEDOUBLESPACEtpvprevprevpprevp_parents               rR   
whitespacer      s    BE"K	AA
AO	EM==TDTT===EKAF+  
 	D :q!! 	
&666IzU[((	u{**3D*	L:$$| (<$LMO$	)   I\&$*<<< !<' J%*$$E""dn44EL))T-??? IZ+++9J'JKKK 	 Z5;&&| : 1dndl5S S S 19uur9 L		!T[00
n,,IZ58###QX]dn5T5TI	&	&	&	v$/4<000 	tyEK//I 0 
4#	#	# 	DI,,I	
4%	%	% 	Iy++	 , Y%+%% ;Y%+%%I & 
;		 	"1%%E EJ%+55		
4<		
??a5:ooI 	EI~~ej	 "1 Y%+%%I & 
4=	 	 I 	"1%%E EJ%*44	 5 Y5;-*::::I ; 
4>	!	!		
4#	#	# 	Iq!! 	
eh..%*	2I2II 3J 
4=	 	 
??I 	DI++I	
DNDL1	1	1 	8'')I'''x} 222I%--!!!TY%2B%B%B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LrT   
nl_count	form_feed
empty_linec                 ,    |r|| dz
  z  dz   |z   S || z  S )z$Generate a normalized prefix string.   r^   )r   r   r   s      rR   make_simple_prefixr     s/     Ahl+t3j@@  rT   rE   c                     | rb| j         }|rPt          |t                    r|S 	 t          |                                          d         S # t
          $ r Y dS w xY w| j        } | bdS )z3Return the first leaf that precedes `node`, if any.N)rn   rV   r   listleaves
IndexErrorrg   )rE   ress     rR   ro   ro     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)rJ   prev_siblings_arern   )rE   r   s     rR   r   r     sc    
  tbzt| uyF2JuT.ss<<<rT   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)rg   rJ   rE   s    rR   ry   ry     s      |t{*t;rT   ancestor
descendantc                 L    |}|r|j         | k    r|j         }|r|j         | k    |S )z:Return the child of `ancestor` that contains `descendant`.)rg   )r   r   rE   s      rR   child_towardsr     s=    #D
 4;(**{  4;(**KrT   	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)rg   removeinsert_child)r   r   rg   	child_idxs       rR   replace_childr     sT     F   ""IIy11111 rT   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   )rw   rg   rW   rJ   r   
file_inputrn   r?   )r_   same_prefix	containerrg   s       rR   container_ofr     s    
 +KI
 !>?1$33;$/))*v/B/G8/S/S	   rT   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)rV   r   rW   first_leaf_ofr   s    rR   r   r     s=    $ } T]1-...trT   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)rJ   r   
arith_expr
shift_exprxor_exprand_exprr   s    rR   is_arith_liker     s*    9	  rT   c                    | j         t          j        k    rdS t          | j                  }t          |                              d          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)rJ   r   r   r   rh   setintersectionr   rg   NEWLINEINDENTr   simple_stmtrt   rj   )r_   rw   s     rR   is_docstringr     s    yEL  utz**F
6{{'' udEM5<9IJ   t tTEU&VWW  t5rT   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   )rJ   r   r   lenrW   r   r   r   r   s    rR   is_empty_tupler   ,  s`     		TY 	0!#	0M!!UZ/	0 M!!UZ/	rT   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   )
rJ   r   r   unwrap_singleton_parenthesistestlist_gexpr   rW   r   rp   r;   rE   gexps     rR   is_one_tupler   6  s    yDI+D11<49(:::54=!!Q&O4=+;+@EK+OO 		^# 	1!#	1M!!U[0rT   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)rJ   r   namedexpr_test).0rX   s     rR   	<genexpr>z-is_tuple_containing_walrus.<locals>.<genexpr>N  s,      LLUuzT00LLLLLLrT   )rJ   r   r   r   r   anyrW   r   s     rR   is_tuple_containing_walrusr   F  s[    yDIu'--D|tyD$666uLLdmLLLLLLrT   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   )
rJ   bracket_depth	enumerateLookupErrorr   rp   rg   r   rr   rv   )	r   r   r   r   depth_opening_indexr_   commasr   s	            rR   is_one_sequence_betweenr   Q  s    	gl#x//u!A%E )& 1 1 A A7??E  ?@@@FaN~'  7??E*E!!di5;&>&>aKF{ t{/"4     !A:rT   c                 R    t          |           }|duo|j        t          j        k    S )z7Return True iff `node` is of the shape ( test := test )N)r   rJ   r   r   )rE   inners     rR   is_walrus_assignmentr   v  s)    (..EBt/B!BBrT   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   )
rJ   r   r   r   rW   r   r   r   r   r   )rE   r   s     rR   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'rT   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)
rJ   r   r   r   powerrW   allmapr   r   r   s    rR   is_simple_decorator_expressionr     s     yEJtyDJ= 	a %3 7qt9LMMNN &&* Q24=3D4PPP 5rT   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   )rJ   r   
yield_expris_name_tokenrh   r   r   rW   r   r   r   is_yield)rE   lparexprrpars       rR   r   r     s    yDO##tT tzW44tyDIu
4=Qu}D$yEJ49
#:#:~~5rT   re   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)rJ   r'   rg   r   rz   )r_   re   r   s      rR   r{   r{     sY     y((((uAv x 	5H6VrT   c                 <    t          | j                  od| j        v S )zKReturn True if `leaf` is a multiline string that actually spans many lines.r   )r   rh   r_   s    rR   is_multiline_stringr     s    TZ((?TTZ-??rT   c                 ,    | j         t          j        k    S r   )rJ   r   funcdefr   s    rR   
is_funcdefr    s    9$$rT   c                 V    | j         t          j        t          j        t          j        hv S r   )rJ   r   r  r   async_funcdefr   s    rR   is_function_or_classr    s    9t}d6HIIIrT   c                    | j         $t          j        |v rt          | j                   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   )rg   r   dummy_implementationsr  rw   stripr   rW   rJ   r   r   r   DEDENTis_stub_body)rE   ra   s     rR   is_stub_suiter    s     	)T11$T[11 2 u { u 	DMa= EM11= EL00= EL00u}Q$$&& ua()))rT   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     rR   r   zis_stub_body.<locals>.<genexpr>  s3      HHUY,,,HHHHHHrT   )rV   r   rJ   r   r   r   rW   rw   r
  r   r   )rE   rX   s     rR   r  r    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	rT   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   rc   )
rV   r   rJ   r   r   rW   r   r   rh   r   )rE   firstr   s      rR   is_atom_with_invisible_parensr    s     $ di!7!7u-"DM"$54E5$ 	J%*$	K2	 tT""	 I#		
 J"rT   c                 >    t          |           pt          |           S r   )is_empty_lparis_empty_rparr   s    rR   is_empty_parr  %  s    5-"5"55rT   c                 B    | j         t          j        k    o
| j        dk    S Nrc   )rJ   r   r   rh   r   s    rR   r  r  )      9
"7tzR'77rT   c                 B    | j         t          j        k    o
| j        dk    S r  )rJ   r   r   rh   r   s    rR   r  r  -  r  rT   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.rf   from)	rg   rJ   rh   boolr   r   r   import_namer   )r_   r   r   r   s       rR   	is_importr   1  ss    A	A
A	UZ 	
(]?q?QVt/?%? BV@@af0@&@	  rT   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  rJ   r   r   rh   rg   r   	with_stmtASYNCnext_siblingr   s    rR   is_with_or_async_with_stmtr&  ?  s    	UZ 	/J& 	/K	/ K.	  	
 
	U[  	5	5"dn4
 
	rT   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  rJ   r   r$  rg   r   
async_stmtr  r   s    rR   is_async_stmt_or_funcdefr)  M  sJ     	U[  	FK	FK$2D EE  rT   c                 r    | j         }| j        }|t          j        t          hv o|                    d          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.z# type:)rJ   rh   r   ri   r    
startswithr_   r   r   s      rR   is_type_commentr-  Z  s6    
 		A
A 233OY8O8OOrT   c                 f    | j         }| j        }|t          j        t          hv ot          |          S )zGReturn True if the given leaf is a type comment with ignore annotation.)rJ   rh   r   ri   r    is_type_ignore_comment_stringr,  s      rR   is_type_ignore_commentr0  d  s2    	A
A 233X8UVW8X8XXrT   rh   c                 ,    |                      d          S )zSReturn True if the given string match with type comment with
    ignore annotation.z# type: ignore)r+  )rh   s    rR   r/  r/  k  s     ,---rT   )visiblerg   rX   r2  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).
    (rc   )r   N)
r   r   r   r   rw   r   r   r   r   r   )rg   rX   r2  r   r   rw   indexr   s           rR   wrap_in_parenthesesr7  q  s     
72CC33D
72CC33D\FELLLNNaETYud 344II
y)))))rT   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   rW   rJ   r   r   r   )rE   r   wrappedr   s       rR   r   r     sS     4=Qt-D'4I##	UZ(?(?tNrT   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`).
    r4  r5  N)rJ   r   r   rh   r   r   s    rR   ensure_visibler;    s@     yEJ


	ej	 	 


 
!	 rT   nlc                 ,    | j         t          j        k    S r   )rJ   r   r   r<  s    rR   r   r         7ej  rT   c                 ,    | j         t          j        k    S r   )rJ   r   r   r>  s    rR   is_lpar_tokenrA    r?  rT   c                 ,    | j         t          j        k    S r   )rJ   r   r   r>  s    rR   is_rpar_tokenrC    r?  rT   c                 ,    | j         t          j        k    S r   )rJ   r   r   r>  s    rR   is_string_tokenrE        7el""rT   c                 ,    | j         t          j        k    S r   )rJ   r   r   r>  s    rR   is_number_tokenrH    rF  rT   c                     | j         }|O|j        r|j        j        t          j        k    rdS |j         r|j         j        t
          j        k    rdS |j         }|OdS )z6Returns whether this leaf is part of type annotations.NTF)rg   rn   rJ   r   RARROWr   tname)r_   r   s     rR   is_part_of_annotationrL    sg    {H

  	X%:%?5<%O%O4? 	x3tzAA4? 
 5rT   c                 v    t          | t                    r| S | j        sdS t          | j        d                   S )z,Returns the first leaf of the ancestor node.Nr   )rV   r   rW   
first_leafr   s    rR   rN  rN    s=    $ ,] ,t$-*+++rT   c                 v    t          | t                    r| S | j        sdS t          | j        d                   S )z+Returns the last leaf of the ancestor node.Nr   )rV   r   rW   	last_leafr   s    rR   rP  rP    s=    $ ,] ,tr*+++rT   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   )rg   rW   )r_   rE   s     rR    furthest_ancestor_with_last_leafrR    sk    D
+ $+. 44;;OPR;S3S3S{ + $+. 44;;OPR;S3S3SKrT   )r   )F)r\   systypingr   r   r   r   r   r   r	   r
   r   version_infor   typing_extensionsmypy_extensionsr   black.cacher   
black.moder   r   black.stringsr   r   blib2to3r   blib2to3.pgen2r   blib2to3.pytreer   r   r   r   
initializepython_symbolsr   __annotations__r   r]   intLeafIDNodeTyper  r   r   r   if_stmt
while_stmtfor_stmttry_stmtr   r#  r  r   
match_stmt
case_blockr   r    rK   r#   LESSGREATEREQEQUALNOTEQUAL	LESSEQUALGREATEREQUALr$   VBAR
CIRCUMFLEXAMPER	LEFTSHIFT
RIGHTSHIFTPLUSMINUSrx   SLASHDOUBLESLASHPERCENTr}   TILDEr   r%   r&   r'   rr   rs   r   rv   ru   r(   r   r   	listmakerr   testlist_star_exprsubject_exprpatternr)   testlambdefor_testand_testnot_test
comparisonrz   r   r   r   r   r   termr   r*   rK  
tname_starr+   r:   testlistexprlistr;   r   r   r   RSQBLBRACERBRACEr<   r   keysr=   valuesr>   r?   rp   r@   rJ  rD   r  rL   r   r   ro   r   ry   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r{   r   r  r  r  r  r  r  r  r  r   r&  r)  r-  r0  r/  r7  r   r;  r   rA  rC  rE  rH  rL  rN  rP  rR  r^   rT   rR   <module>r     s     


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