
    miz0                        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j'        dej(        dej)        dej*        dej+        dej,        dej-        dej.        dej/        dej0        dej1        dej2        dej3        dej4        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>d&S ).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dS )BracketMatchErrorzLRaised when an opening bracket is unable to be matched to a closing bracket.N)__name__
__module____qualname____doc__     f/var/www/html/bestrading.cuttalo.com/scripts/kaggle-env/lib/python3.11/site-packages/black/brackets.pyr.   r.   7   s        VVV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!dS )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dS | j        dk    r%|j         t          v r| j        |j         f| j        vrdS |                     |           |                     |           |j         t          v r| xj        dz  c_        	 | j                            | j        |j         f          }n%# t          $ r}t          d|           |d}~ww xY w||_        |j        s| j                            |           | j        |_        | j        dk    rct!          || j                  }|r$| j        || j        t'          | j                  <   n(t)          |          }|r|| j        t'          |          <   |j         t*          v rR|| j        | j        t,          |j                  f<   | xj        dz  c_        |j        s| j                            |           || _        |                     |           |                     |           dS )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.   $ 9%%F J!OO	---TY't/AAAF44T:::33D9999(((JJ!OJJ"&"4"8"8$*di9P"Q"Q   '(!%( (  
 $3D : ,%%d+++!Z:??-dDMBBE 625:4= 1 122066 605DOBtHH-9(((AEDtz749+==>JJ!OJJ: ,%%d+++--d333..t44444s   &B8 8
CCCc                 8    t          | j        p| 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J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   r3   excludec                 h    t          fd| 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   *   K   | ]\  }}|v	|V  d S Nr3   ).0kvr\   s      r5   	<genexpr>z8BracketTracker.max_delimiter_priority.<locals>.<genexpr>   s1      MMAAW<L<L1<L<L<L<LMMr4   )maxr;   items)rR   r\   s    `r5   max_delimiter_priorityz%BracketTracker.max_delimiter_priority   s6     MMMM!6!6!8!8MMMMMMr4   priorityc                     | j         sdS p|                                 t          fd| 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    d V  dS )r+   Nr3   )r`   prg   s     r5   rc   z?BracketTracker.delimiter_count_with_priority.<locals>.<genexpr>   s'      HH!x--1----HHr4   )r;   rf   sumvalues)rR   rg   s    `r5   delimiter_count_with_priorityz,BracketTracker.delimiter_count_with_priority   s[    
  	1<t::<<HHHHdo4466HHHHHHr4   c                     |j         t          j        k    r<|j        dk    r1| xj        dz  c_        | j                            | j                   dS dS )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   sQ     9
""tzU':':JJ!OJJ!((4444ur4   c                     | j         ra| j         d         | j        k    rK|j        t          j        k    r6|j        dk    r+| xj        dz  c_        | j                                          dS dS )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   sn     !	%b)TZ77	UZ''
d""JJ!OJJ!%%'''4ur4   c                     |j         t          j        k    r<|j        dk    r1| xj        dz  c_        | j                            | j                   dS dS )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   sQ     9
""tzX'='=JJ!OJJ(//
;;;4ur4   c                     | j         rV| j         d         | j        k    r@|j        t          j        k    r+| xj        dz  c_        | j                                          dS dS )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   sa     (	,R0DJ>>	U[((JJ!OJJ(,,...4ur4   c                 ^    | 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&    !%%tzA~uz&BC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   ;   sf        ,,E3NNN8=d8S8S8SM4eXo.45SSS).t)D)D)DJVX%&DDD HdTk   "'%"="="=d3i===).t)D)D)DT#YDDD!E$777ItDz777:5 :5$ :5 :5 :5 :5xK K K K K(4 ( ( ( (N Nhv.> N N N N N	I 	Ih 	Is 	I 	I 	I 	Id t    D T    T d    4 D    Dtd{ D D D D D Dr4   r7   r@   rA   c                 >    | j         t          j        k    rt          S dS )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     yEK1r4   Nr<   c                    t          | t          t          z            rdS | j        t          j        k    rB| j        r;| j        j        t          j        t          j	        hvr||j        t          v rt          S | j        t          v r=| j        r6| 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dS | j        dk    r+| j        r$| j        j        t          j        t          j        hv s| j        t          j        k    r1t3          | j        t6                    r| j        j        dk    rt8          S | j        dk    r2| j        r+| j        j        t          j        t          j        hv rt8          S | j        dv r(| j        r!| j        j        t          j        k    rt@          S | j        dk    rt"          S | j        d	k    rT| j        rM| j        j        t          j!        t          j"        hv r)| |j        t          j        k    r|j        d
k    st"          S | j        d
k    rJ| j        rC| j        j        t          j!        k    r)| |j        t          j        k    r|j        dk    st"          S | j        tF          v r| j        rtH          S dS )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   Nro   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BB  q 		UYK 	KT%5t7G$HHH2B!B!B 		^##K 	$KT[$.$AAAty))yK"" 		U\!! MU\))yU[111q 	
eK 	K0A BBB9## 4,d33	* &'11)) 	
dK 	Kt/? @@@%%z^###8HDI8U8UzT"" 	
dK 	Kt ??? ++%'' #" 	
eK 	K,, ++$&& #"z_$$$1r4   nodec                    | j         t          j        k    rdS | j        d         }| j        d         }|j         t          j        k    r|j         t          j        k    sdS t                      }| j        dd         D ]Y}t          |t                    r|
                    |           -|                                D ]}|
                    |           Z	 |                                S # t          $ r Y dS 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     yDIqM!E=DJ%*$$ej)@)@q			B]1R4   a 	GGAJJJJ

  ((***   qqs   C* *
C87C8r   c                 j   	 t          d t          |           D                       }n# t          $ r t                      cY S w xY wg }t                      }t	          |t          |                     D ]}| |         }|j        t          v r'|                    t          |j                 |f           |j        t          v rq|rm|j        |d         d         k    rV|                                \  }}t	          ||dz             D ]*}|                    t          | |                              + n|S )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   <   K   | ]\  }}|j         t          v |V  d S r_   )rC   r   )r`   ils      r5   rc   z6get_leaves_inside_matching_brackets.<locals>.<genexpr>m  s<       
 
!Qqv9I/I/IA/I/I/I/I
 
r4   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++
 
 
 
 
    uuM
%%C;F,, 
 
ay9(((  '$)"4a!89999((( mB.?.B!B!B(,,..5ua!e,, + +AGGBvayMM****+  ) Js   &) AA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 2 2 . . . . . . . . ( ( ( ( ( ( ( (                                !           & & & & & & & & 4:	 !#  " " "    %          U   	J	a	K	OQ	a	J	K	J	K	q	M1	Ha	K	a     e   W W W W W	 W W W \D \D \D \D \D \D \D \D~4 H    ] ]D ]D4K ]8 ] ] ] ]@     8 3v;      r4   