
    h0                        U d Z ddlmZmZ ddlmZmZ ddl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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ejj                  diZ6ee"d<   dZ7ee"d<    G d d e8      Z9e 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,Z?y&).z,Builds on top of nodes.py to track brackets.    )IterableSequence)	dataclassfield)FinalOptional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__     A/var/www/html/immo/lib/python3.12/site-packages/black/brackets.pyr/   r/   7   s    Vr5   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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   r,   zDUnable to match a closing bracket to the following opening bracket: )typer   COMMENTr9   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)selfrA   rJ   edelims        r6   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?   rS   s    r6   any_open_for_or_lambdaz%BracketTracker.any_open_for_or_lambda   s     
 D))IT-I-IJJr5   c                 ,    t        | j                        S )zBReturn True if there is an yet unmatched open bracket on the line.)rX   r;   rY   s    r6   any_open_bracketsz BracketTracker.any_open_brackets   s    D&&''r5   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Nr4   ).0kvr]   s      r6   	<genexpr>z8BracketTracker.max_delimiter_priority.<locals>.<genexpr>   s     MAAW<L1Ms   )maxr<   items)rS   r]   s    `r6   max_delimiter_priorityz%BracketTracker.max_delimiter_priority   s#     M!6!6!8MMMr5   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,   Nr4   )ra   prh   s     r6   rd   z?BracketTracker.delimiter_count_with_priority.<locals>.<genexpr>   s     H!x-1Hs   
)r<   rg   sumvalues)rS   rh   s    `r6   delimiter_count_with_priorityz,BracketTracker.delimiter_count_with_priority   s@    
 <t::<Hdoo446HHHr5   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)rD   r   NAMErK   r9   r>   rL   rS   rA   s     r6   rR   z0BracketTracker.maybe_increment_for_loop_variable   sJ     99

"tzzU':JJ!OJ!!((4r5   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>   r9   rD   r   rq   rK   rH   rr   s     r6   rF   z6BracketTracker.maybe_decrement_after_for_loop_variable   se     !!%%b)TZZ7		UZZ'

d"JJ!OJ!!%%'r5   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)rD   r   rq   rK   r9   r?   rL   rr   s     r6   rQ   z/BracketTracker.maybe_increment_lambda_arguments   sJ     99

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

;r5   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.rt   r,   TF)r?   r9   rD   r   COLONrH   rr   s     r6   rG   z5BracketTracker.maybe_decrement_after_lambda_arguments   sY     ((,,R0DJJ>		U[[(JJ!OJ((,,.r5   c                 r    | j                   j                  | j                  dz
  t        j                  f      S )z7Return the most recent opening square bracket (if any).r,   )r;   getr9   r   RSQBrY   s    r6   get_open_lsqbzBracketTracker.get_open_lsqb   s*    !!%%tzzA~uzz&BCCr5   )r4   )r   )#r0   r1   r2   r3   r9   int__annotations__r   dictr;   tupleDepthNodeTyper   r<   LeafIDPriorityr=   r   listr>   r?   r@   rV   rX   rZ   r\   r   rg   rn   rR   rF   rQ   rG   r}   r4   r5   r6   r8   r8   ;   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r5   r8   rA   rB   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   )rD   r   COMMAr   )rA   s    r6   rP   rP      s     yyEKKr5   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   rp   asyncif>   r   elseisru   not)%r   r   r   rD   r   DOTparentr   import_fromdotted_namer   r-   r   factor	star_exprr+   r   r"   STRINGr    rq   ASYNCrK   comp_forold_comp_for
isinstanceprev_siblingr   r   comp_ifold_comp_iftestr   comp_op
comparisonr   r   )rA   r=   s     r6   rN   rN      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_$r5   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   rt   r,   )rD   r   atomchildrenr   LPARRPARr8   r   r   rV   leavesrg   
ValueError)r   firstlastbtcrA   s         r6   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`   )rD   r   )ra   ils      r6   rd   z6get_leaves_inside_matching_brackets.<locals>.<genexpr>m  s%      
!Qqvv9I/IA
s   $$rt   r   r,   )next	enumerateStopIterationsetrangelenrD   r   rL   r
   r   rH   addrO   )	r   start_indexbracket_stackidsr   rA   _startjs	            r6   #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`   )@r3   collections.abcr   r   dataclassesr   r   typingr   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+   r-   	Exceptionr/   r8   rP   rN   r   r   r   r4   r5   r6   <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 ]HTN ]h ]@  8 3v; r5   