
    e0                        U d 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 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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ejj                  dejl                  dejn                  dejp                  diZ9ee%d<   dZ:ee%d<    G d de;      Z<e G d  d!             Z=d"ed#e#fd$Z>d,d"ed&e	e   d#e#fd'Z?d(ed#e#fd)Z@d*e
e   d#ee!   fd+ZAy%)-z,Builds on top of nodes.py to track brackets.    )	dataclassfield)	DictFinalIterableListOptionalSequenceSetTuple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__     0/usr/lib/python3/dist-packages/black/brackets.pyr3   r3   6   s    Vr9   r3   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e   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e   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   r0   zDUnable to match a closing bracket to the following opening bracket: )typer   COMMENTr=   r   r?   'maybe_decrement_after_for_loop_variable&maybe_decrement_after_lambda_argumentspopKeyErrorr3   opening_bracketvaluerD   appendbracket_depthis_split_before_delimiterrA   r@   idis_split_after_delimiterr   r    maybe_increment_lambda_arguments!maybe_increment_for_loop_variable)selfrE   rN   edelims        r:   markzBracketTracker.markF   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.)boolrB   rC   rW   s    r:   any_open_for_or_lambdaz%BracketTracker.any_open_for_or_lambda   s     
 D))IT-I-IJJr9   c                 ,    t        | j                        S )zBReturn True if there is an yet unmatched open bracket on the line.)r\   r?   r]   s    r:   any_open_bracketsz BracketTracker.any_open_brackets   s    D&&''r9   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Nr8   ).0kvra   s      r:   	<genexpr>z8BracketTracker.max_delimiter_priority.<locals>.<genexpr>   s     MAAW<L1Ms   )maxr@   items)rW   ra   s    `r:   max_delimiter_priorityz%BracketTracker.max_delimiter_priority   s#     M!6!6!8MMMr9   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)r0   Nr8   )re   prl   s     r:   rh   z?BracketTracker.delimiter_count_with_priority.<locals>.<genexpr>   s     H!x-1Hs   
)r@   rk   sumvalues)rW   rl   s    `r:   delimiter_count_with_priorityz,BracketTracker.delimiter_count_with_priority   s@    
 <t::<Hdoo446HHHr9   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`.
        forr0   TF)rH   r   NAMErO   r=   rB   rP   rW   rE   s     r:   rV   z0BracketTracker.maybe_increment_for_loop_variable   sJ     99

"tzzU':JJ!OJ!!((4r9   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.inr0   TF)rB   r=   rH   r   ru   rO   rL   rv   s     r:   rJ   z6BracketTracker.maybe_decrement_after_for_loop_variable   se     !!%%b)TZZ7		UZZ'

d"JJ!OJ!!%%'r9   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 `:`.
        lambdar0   TF)rH   r   ru   rO   r=   rC   rP   rv   s     r:   rU   z/BracketTracker.maybe_increment_lambda_arguments   sJ     99

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

;r9   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.rx   r0   TF)rC   r=   rH   r   COLONrL   rv   s     r:   rK   z5BracketTracker.maybe_decrement_after_lambda_arguments   sY     ((,,R0DJJ>		U[[(JJ!OJ((,,.r9   c                 r    | j                   j                  | j                  dz
  t        j                  f      S )z7Return the most recent opening square bracket (if any).r0   )r?   getr=   r   RSQBr]   s    r:   get_open_lsqbzBracketTracker.get_open_lsqb   s*    !!%%tzzA~uzz&BCCr9   )r8   )r   )%r4   r5   r6   r7   r=   int__annotations__r   dictr?   r   r   DepthNodeTyper   r@   LeafIDPriorityrA   r	   listrB   r   rC   rD   rZ   r\   r^   r`   r   rk   rr   rV   rJ   rU   rK   r   r8   r9   r:   r<   r<   :   sO   ,E3N8=d8SM4eXo.45S).t)DJVX%&D#Hhtn#"'"=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x~ Dr9   r<   rE   rF   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   )rH   r   COMMAr   )rE   s    r:   rT   rT      s     yyEKKr9   NrA   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   rt   asyncif>   r   elseisry   not)%r   r   r   rH   r   DOTparentr   import_fromdotted_namer   r1   r   factor	star_exprr/   r   r&   STRINGr$   ru   ASYNCrO   comp_forold_comp_for
isinstanceprev_siblingr   r   comp_ifold_comp_iftestr    comp_op
comparisonr   r"   )rE   rA   s     r:   rR   rR      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_$r9   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   rx   r0   )rH   r   atomchildrenr   LPARRPARr<   r   r   rZ   leavesrk   
ValueError)r   firstlastbtcrE   s         r:   max_delimiter_priority_in_atomr   H  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rd   )rH   r   )re   ils      r:   rh   z6get_leaves_inside_matching_brackets.<locals>.<genexpr>l  s%      
!Qqvv9I/IA
s   $$rx   r   r0   )next	enumerateStopIterationsetrangelenrH   r   rP   r   r   rL   addrS   )	r   start_indexbracket_stackidsr   rE   _startjs	            r:   #get_leaves_inside_matching_bracketsr   d  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rd   )Br7   dataclassesr   r   typingr   r   r   r   r	   r
   r   r   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/   r1   	Exceptionr3   r<   rT   rR   r   r   r8   r9   r:   <module>r      s   2 ( U U U   ! & 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 ]HTN ]h ]@  8 3v; r9   