
    ]jz0                        U d Z ddlmZmZ ddlmZmZ ddlmZm	Z	 ddl
mZmZmZmZmZmZmZmZmZmZ ddlmZ ddlmZmZ e	eef   ZeZeZeZeZdZ ee!d	<   d
Z"ee!d<   dZ#ee!d<   dZ$ee!d<   dZ%ee!d<   dZ&ee!d<   ejN                  dejP                  dejR                  dejT                  dejV                  dejX                  dejZ                  dej\                  dej^                  dej`                  dejb                  dejd                  dejf                  dejh                  diZ5ee!d<   dZ6ee!d<    G d d e7      Z8e G d! d"             Z9d#ed$efd%Z:d-d#ed'ed&z  d$efd(Z;d)ed$efd*Z<d+ee   d$e=e   fd,Z>y&).z,Builds on top of nodes.py to track brackets.    )IterableSequence)	dataclassfield)FinalUnion)
BRACKETCLOSING_BRACKETSCOMPARATORSLOGIC_OPERATORSMATH_OPERATORSOPENING_BRACKETSUNPACKING_PARENTSVARARGS_PARENTS	is_varargsyms)token)LeafNode   COMPREHENSION_PRIORITY   COMMA_PRIORITY   TERNARY_PRIORITY   LOGIC_PRIORITY   STRING_PRIORITY
   COMPARATOR_PRIORITY	                        MATH_PRIORITIES   DOT_PRIORITYc                       e Zd ZdZy)BracketMatchErrorzLRaised when an opening bracket is unable to be matched to a closing bracket.N)__name__
__module____qualname____doc__     8/root/env/lib/python3.12/site-packages/black/brackets.pyr.   r.   7   s    Vr4   r.   c                      e Zd ZU dZdZeed<    ee      Z	ee
eef   ef   ed<    ee      Zeeef   ed<   dZedz  ed<    ee      Zee   ed	<    ee      Zee   ed
<    ee      Zee   ed<   deddfdZdefdZdefdZddee   defdZddedefdZdedefdZdedefdZdedefdZdedefdZ dedz  fdZ!y)BracketTrackerz"Keeps track of brackets on a line.r   depth)default_factorybracket_match
delimitersNprevious_for_loop_depths_lambda_argument_depths	invisibleleafreturnc                    |j                   t        j                  k(  ry| j                  dk(  r7|j                   t        v r%| j                  |j                   f| j
                  vry| j                  |       | j                  |       |j                   t        v ru| xj                  dz  c_        	 | j
                  j                  | j                  |j                   f      }||_        |j                  s| j                  j                  |       | j                  |_        | j                  dk(  rlt!        || j"                        }|r/| j"                  #|| j$                  t'        | j"                        <   n%t)        |      }|r|| j$                  t'        |      <   |j                   t*        v rh|| j
                  | j                  t,        |j                      f<   | xj                  dz  c_        |j                  s| j                  j                  |       || _        | j/                  |       | j1                  |       y# t        $ r}t        d|       |d}~ww xY w)a  Mark `leaf` with bracket-related metadata. Keep track of delimiters.

        All leaves receive an int `bracket_depth` field that stores how deep
        within brackets a given leaf is. 0 means there are no enclosing brackets
        that started on this line.

        If a leaf is itself a closing bracket and there is a matching opening
        bracket earlier, it receives an `opening_bracket` field with which it forms a
        pair. This is a one-directional link to avoid reference cycles. Closing
        bracket without opening happens on lines continued from previous
        breaks, e.g. `) -> "ReturnType":` as part of a funcdef where we place
        the return type annotation on its own line of the previous closing RPAR.

        If a leaf is a delimiter (a token on which Black can split the line if
        needed) and it's on depth 0, its `id()` is stored in the tracker's
        `delimiters` field.
        Nr   r+   zDUnable to match a closing bracket to the following opening bracket: )typer   COMMENTr8   r
   r:   'maybe_decrement_after_for_loop_variable&maybe_decrement_after_lambda_argumentspopKeyErrorr.   opening_bracketvaluer?   appendbracket_depthis_split_before_delimiterr<   r;   idis_split_after_delimiterr   r	    maybe_increment_lambda_arguments!maybe_increment_for_loop_variable)selfr@   rI   edelims        r5   markzBracketTracker.markG   s   $ 99% JJ!O		--TYY't/A/AA44T:33D999((JJ!OJ"&"4"4"8"8$**dii9P"Q $3D ::%%d+!ZZ::?-dDMMBE25:4== 120605DOOBtH-99((AEDtzz7499+==>JJ!OJ::%%d+--d3..t41  '!!%( s   /1H> >	IIIc                 H    t        | j                  xs | j                        S )zReturn True if there is an open for or lambda expression on the line.

        See maybe_increment_for_loop_variable and maybe_increment_lambda_arguments
        for details.)boolr=   r>   rR   s    r5   any_open_for_or_lambdaz%BracketTracker.any_open_for_or_lambda   s     
 D))IT-I-IJJr4   c                 ,    t        | j                        S )zBReturn True if there is an yet unmatched open bracket on the line.)rW   r:   rX   s    r5   any_open_bracketsz BracketTracker.any_open_brackets   s    D&&''r4   excludec                 \    t        fd| j                  j                         D              S )zReturn the highest priority of a delimiter found on the line.

        Values are consistent with what `is_split_*_delimiter()` return.
        Raises ValueError on no delimiters.
        c              3   2   K   | ]  \  }}|vs|  y wNr3   ).0kvr\   s      r5   	<genexpr>z8BracketTracker.max_delimiter_priority.<locals>.<genexpr>   s     MAAW<L1Ms   )maxr;   items)rR   r\   s    `r5   max_delimiter_priorityz%BracketTracker.max_delimiter_priority   s#     M!6!6!8MMMr4   priorityc                     | j                   syxs | j                         t        fd| j                   j                         D              S )zReturn the number of delimiters with the given `priority`.

        If no `priority` is passed, defaults to max priority on the line.
        r   c              3   .   K   | ]  }|k(  s	d   yw)r+   Nr3   )r`   prg   s     r5   rc   z?BracketTracker.delimiter_count_with_priority.<locals>.<genexpr>   s     H!x-1Hs   
)r;   rf   sumvalues)rR   rg   s    `r5   delimiter_count_with_priorityz,BracketTracker.delimiter_count_with_priority   s@    
 <t::<Hdoo446HHHr4   c                     |j                   t        j                  k(  rJ|j                  dk(  r;| xj                  dz  c_        | j
                  j                  | j                         yy)zIn a for loop, or comprehension, the variables are often unpacks.

        To avoid splitting on the comma in this situation, increase the depth of
        tokens between `for` and `in`.
        forr+   TF)rC   r   NAMErJ   r8   r=   rK   rR   r@   s     r5   rQ   z0BracketTracker.maybe_increment_for_loop_variable   sJ     99

"tzzU':JJ!OJ!!((4r4   c                    | j                   rx| j                   d   | j                  k(  r\|j                  t        j                  k(  r?|j
                  dk(  r0| xj                  dz  c_        | j                   j                          yy)z>See `maybe_increment_for_loop_variable` above for explanation.inr+   TF)r=   r8   rC   r   rp   rJ   rG   rq   s     r5   rE   z6BracketTracker.maybe_decrement_after_for_loop_variable   se     !!%%b)TZZ7		UZZ'

d"JJ!OJ!!%%'r4   c                     |j                   t        j                  k(  rJ|j                  dk(  r;| xj                  dz  c_        | j
                  j                  | j                         yy)zIn a lambda expression, there might be more than one argument.

        To avoid splitting on the comma in this situation, increase the depth of
        tokens between `lambda` and `:`.
        lambdar+   TF)rC   r   rp   rJ   r8   r>   rK   rq   s     r5   rP   z/BracketTracker.maybe_increment_lambda_arguments   sJ     99

"tzzX'=JJ!OJ((//

;r4   c                     | j                   ri| j                   d   | j                  k(  rM|j                  t        j                  k(  r0| xj                  dz  c_        | j                   j                          yy)z=See `maybe_increment_lambda_arguments` above for explanation.rs   r+   TF)r>   r8   rC   r   COLONrG   rq   s     r5   rF   z5BracketTracker.maybe_decrement_after_lambda_arguments   sY     ((,,R0DJJ>		U[[(JJ!OJ((,,.r4   c                 r    | j                   j                  | j                  dz
  t        j                  f      S )z7Return the most recent opening square bracket (if any).r+   )r:   getr8   r   RSQBrX   s    r5   get_open_lsqbzBracketTracker.get_open_lsqb   s*    !!%%tzzA~uzz&BCCr4   )r3   )r   )"r/   r0   r1   r2   r8   int__annotations__r   dictr:   tupleDepthNodeTyper   r;   LeafIDPriorityr<   listr=   r>   r?   rU   rW   rY   r[   r   rf   rm   rQ   rE   rP   rF   r|   r3   r4   r5   r7   r7   ;   sO   ,E3N8=d8SM4eXo.45S).t)DJVX%&D HdTk "'"=d3i=).t)DT#YD!$7ItDz7:5 :5$ :5xK K(4 (Nhv.> N N	Ih 	Is 	Id t D T T d 4 D Dtd{ Dr4   r7   r@   rA   c                 J    | j                   t        j                  k(  rt        S y)zReturn the priority of the `leaf` delimiter, given a line break after it.

    The delimiter priorities returned here are from those delimiters that would
    cause a line break after themselves.

    Higher numbers are higher priority.
    r   )rC   r   COMMAr   )r@   s    r5   rO   rO      s     yyEKKr4   Nr<   c                    t        | t        t        z        ry| j                  t        j
                  k(  r\| j                  rP| j                  j                  t        j                  t        j                  hvr||j                  t        v rt        S | j                  t        v rU| j                  rI| j                  j                  t        j                  t        j                  hvrt        | j                     S | j                  t         v rt"        S | j                  t        j$                  k(  r%|#|j                  t        j$                  k(  rt&        S | j                  t        j(                  t        j*                  hvry| j,                  dk(  rB| j                  r6| j                  j                  t        j.                  t        j0                  hv s| j                  t        j*                  k(  r9t3        | j4                  t6              r| j4                  j,                  dk7  rt8        S | j,                  dk(  rH| j                  r<| j                  j                  t        j:                  t        j<                  hv rt8        S | j,                  dv r9| j                  r-| j                  j                  t        j>                  k(  rt@        S | j,                  dk(  rt"        S | j,                  dk(  rv| j                  rj| j                  j                  t        jB                  t        jD                  hv r4|,|j                  t        j(                  k(  r|j,                  d	k(  st"        S | j,                  d	k(  rg| j                  r[| j                  j                  t        jB                  k(  r4|,|j                  t        j(                  k(  r|j,                  dk(  st"        S | j,                  tF        v r| j                  rtH        S y)
zReturn the priority of the `leaf` delimiter, given a line break before it.

    The delimiter priorities returned here are from those delimiters that would
    cause a line break before themselves.

    Higher numbers are higher priority.
    )withinr   ro   asyncif>   r   elseisrt   not)%r   r   r   rC   r   DOTparentr   import_fromdotted_namer
   r,   r   factor	star_exprr*   r   r!   STRINGr   rp   ASYNCrJ   comp_forold_comp_for
isinstanceprev_siblingr   r   comp_ifold_comp_iftestr   comp_op
comparisonr   r   )r@   r<   s     r5   rM   rM      s    o0AAB  			UYYKKKKT%5%5t7G7G$HH2B!B 			^#KKKKT[[$..$AAtyy))yyK"" 			U\\! MMU\\)yyU[[11 	

eKKKK0A0A BB99# 4,,d3  &&'1)) 	

dKKKKt/?/? @@%%zz^#8H8HDII8UzzT"" 	

dKKKKt ?? +%' #" 	

eKKKK, +$& #"zz_$r4   nodec                    | j                   t        j                  k7  ry| j                  d   }| j                  d   }|j                   t        j
                  k(  r|j                   t        j                  k(  syt               }| j                  dd D ]J  }t        |t              r|j                  |       %|j                         D ]  }|j                  |        L 	 |j                         S # t        $ r Y yw xY w)zReturn maximum delimiter priority inside `node`.

    This is specific to atoms with contents contained in a pair of parentheses.
    If `node` isn't an atom or there are no enclosing parentheses, returns 0.
    r   rs   r+   )rC   r   atomchildrenr   LPARRPARr7   r   r   rU   leavesrf   
ValueError)r   firstlastbtcr@   s         r5   max_delimiter_priority_in_atomr   I  s     yyDIIMM!E==DJJ%**$ejj)@		B]]1R  aGGAJ
 	((** s   C/ /	C;:C;r   c                    	 t        d t        |       D              }g }t               }t	        |t        |             D ]  }| |   }|j                  t        v r$|j                  t        |j                     |f       |j                  t        v sQ|rZ|j                  |d   d   k(  rE|j                         \  }}t	        ||dz         D ]  }|j                  t        | |                !  |S  |S # t        $ r t               cY S w xY w)zReturn leaves that are inside matching brackets.

    The input `leaves` can have non-matching brackets at the head or tail parts.
    Matching brackets are included.
    c              3   L   K   | ]  \  }}|j                   t        v s|  y wr_   )rC   r   )r`   ils      r5   rc   z6get_leaves_inside_matching_brackets.<locals>.<genexpr>m  s%      
!Qqvv9I/IA
s   $$rs   r   r+   )next	enumerateStopIterationsetrangelenrC   r   rK   r	   r
   rG   addrN   )	r   start_indexbracket_stackidsr   r@   _startjs	            r5   #get_leaves_inside_matching_bracketsr   e  s    
#F+
 

 M
%C;F, 
ay99((  '$))"4a!8999((mB.?.B!B(,,.5ua!e, +AGGBvayM*+ J
 J  us   C1 1DDr_   )?r2   collections.abcr   r   dataclassesr   r   typingr   r   black.nodesr	   r
   r   r   r   r   r   r   r   r   blib2to3.pgen2r   blib2to3.pytreer   r   LNr}   r   r   r   r   r   r~   r   r   r   r   r!   VBAR
CIRCUMFLEXAMPER	LEFTSHIFT
RIGHTSHIFTPLUSMINUSSTARSLASHDOUBLESLASHPERCENTATTILDE
DOUBLESTARr*   r,   	Exceptionr.   r7   rO   rM   r   r   r   r3   r4   r5   <module>r      s   2 . (    ! & 4:	 !#  "  %    U 	JJ	a	KK	OOQ	a	JJ	KK	JJ	KK	q	MM1	HHa	KK	a   e W	 W \D \D \D~4 H ]D ]D4K ]8 ]@  8 3v; r4   