
    mix                        d dl Z d dlZd dlmZmZmZ d dlmZmZ d dl	m
Z
mZmZmZ d dlmZmZmZ d dl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mZm Z m!Z!m"Z"m#Z#m$Z$m%Z% d dl&m'Z' d d	l(m)Z) d d
l*m+Z+m,Z,  ed          Z-e.Z/e.Z0ee+e,f         Z1e G d d                      Z2e G d d                      Z3e G d d                      Z4e G d d                      Z5dee-         dee6e/e-f                  fdZ7	 d,de2de2de8e+         de9ddf
dZ:ddde2d ed!e;de9fd"Z<de2de9fd#Z=d$e3d%e.de9fd&Z>de2d'e+d%e.de9fd(Z?de2d)e+d%e.de9fd*Z@de2de;fd+ZAdS )-    N)CallableIteratorSequence)	dataclassfield)OptionalTypeVarUnioncast)COMMA_PRIORITYDOT_PRIORITYBracketTracker)Mode)BRACKETSCLOSING_BRACKETSOPENING_BRACKETSSTANDALONE_COMMENTTEST_DESCENDANTSchild_towardsis_docstring	is_importis_multiline_stringis_one_sequence_betweenis_type_commentis_type_ignore_commentis_with_or_async_with_stmtmake_simple_prefixreplace_childsyms
whitespace)	str_width)token)LeafNodeTc            	          e Zd ZU dZ ed          Zeed<   dZe	ed<    ee
          Ze
e         ed<    ee          Zeee
e         f         ed	<    ee          Zeed
<   dZeed<   dZeed<   dZedz  ed<   	 d6dedededdfdZd7dededdfdZedefd            Zedefd            Zedefd            Zedefd            Zedefd            Zedefd            Zedefd            Zedefd            Z edefd            Z!edefd            Z"edefd            Z#edefd             Z$edefd!            Z%dd"d#e&egef         dz  defd$Z'defd%Z(defd&Z)defd'Z*defd(Z+defd)Z,d*edefd+Z-d,edefd-Z.dede
e         fd.Z/d8d/Z0dedefd0Z1	 d7d1ede2e3e4ee	f                  fd2Z5d9d3Z6de7fd4Z8defd5Z9dS ):Linez;Holds leaves and comments. Can be printed with `str(line)`.F)reprmoder   depthdefault_factoryleavescommentsbracket_trackerinside_bracketsshould_split_rhsNmagic_trailing_commaleafpreformattedtrack_bracketreturnc                    |j         t          v pD|j         t          j        t          j        fv p%t          |j                                                  }|sdS |j         t          j        k    r| j	        r
| j
        dd= | j
        r:|s8|xj        t          ||                     |          | j                  z  c_        | j        s|r|rl| j                            |           | j        j        r|                     |          r|| _        n)|                     |          r|                                  |                     |          s| j
                            |           dS dS )ag  Add a new `leaf` to the end of the line.

        Unless `preformatted` is True, the `leaf` will receive a new consistent
        whitespace prefix and metadata applied by :class:`BracketTracker`.
        Trailing commas are maybe removed, unpacked for loop variables are
        demoted from being delimiters.

        Inline comments are put aside.
        N)complex_subscriptr)   )typer   r"   FSTRING_MIDDLETSTRING_MIDDLEboolvaluestripCOLONis_class_paren_emptyr-   prefixr    is_complex_subscriptr)   r0   r/   markr2   has_magic_trailing_commaremove_trailing_commaappend_commentappend)selfr3   r4   r5   	has_values        c/var/www/html/bestrading.cuttalo.com/scripts/kaggle-env/lib/python3.11/site-packages/black/lines.pyrH   zLine.append5   s    I! (yU153GHH( DJ$$&&''	 	  	F9##(A#BCC ; 	| 	 KK:"&";";D"A"AY   KK
  	-| 	-} 	- %%d+++y- -0066 504D-..t44 -**,,,""4(( 	%Kt$$$$$	% 	%    c                     | j         j        dk    s| j                                         r<| j        rt	          d          | j        r|j        t          k    rt	          d          |                     ||           dS )zLike :func:`append()` but disallow invalid standalone comment structure.

        Raises ValueError when any `leaf` is appended after a standalone comment
        or when a standalone comment is not the first leaf on the line.
        r   z$cannot append to standalone commentsz5cannot append standalone comments to a populated liner4   N)	r/   r*   any_open_for_or_lambda
is_comment
ValueErrorr-   r:   r   rH   )rI   r3   r4   s      rK   append_safezLine.append_safe^   s      &!++#::<< ,  I !GHHH{ ty,>>> K   	D|44444rL   c                 h    t          | j                  dk    o| j        d         j        t          k    S )z"Is this line a standalone comment?   r   )lenr-   r:   r   rI   s    rK   rP   zLine.is_commentr   s-     4;1$RQ)<@R)RRrL   c                 `    t          |           o| j        d         j        t          j        k    S )zIs this line a decorator?r   )r=   r-   r:   r"   ATrV   s    rK   is_decoratorzLine.is_decoratorw   s%     Dzz=dk!n1UX==rL   c                 T    t          |           ot          | j        d                   S )zIs this an import line?r   )r=   r   r-   rV   s    rK   r   zLine.is_import|   s#     Dzz7iA777rL   c                 T    t          |           ot          | j        d                   S )zIs this a with_stmt line?r   )r=   r   r-   rV   s    rK   r   zLine.is_with_or_async_with_stmt   s$     DzzH8QHHHrL   c                     t          |           o5| j        d         j        t          j        k    o| j        d         j        dk    S )z Is this line a class definition?r   class)r=   r-   r:   r"   NAMEr>   rV   s    rK   is_classzLine.is_class   s@     JJ 0A#uz10A$/	
rL   c                 d    | j         o)| j        dd         d t          d          D             k    S )zEIs this line a class definition with a body consisting only of "..."?Nc                 B    g | ]}t          t          j        d           S .r#   r"   DOT.0_s     rK   
<listcomp>z&Line.is_stub_class.<locals>.<listcomp>   s1     6
 6
 6
%&DC  6
 6
 6
rL      )r_   r-   rangerV   s    rK   is_stub_classzLine.is_stub_class   sG     } 
RSS!1 6
 6
*/((6
 6
 6
 "
 	
rL   c                 6   	 | j         d         }n# t          $ r Y dS w xY w	 | j         d         }n# t          $ r d}Y nw xY w|j        t          j        k    r|j        dk    p8|j        t          j        k    o#|duo|j        t          j        k    o
|j        dk    S )zBIs this a function definition? (Also returns True for async defs.)r   FrT   Ndef)r-   
IndexErrorr:   r"   r^   r>   ASYNC)rI   
first_leafsecond_leafs      rK   is_defzLine.is_def   s    	QJJ 	 	 	55		'+{1~KK 	 	 	KKK	5:-K*2Be2K 
Ou{* +4'+ EJ.+ !U*		
s    
0 ??c                     | j         oE| j        dd         t          t          j        d          gd t          d          D             z   k    S )zHIs this line a function definition with a body consisting only of "..."?N:c                 B    g | ]}t          t          j        d           S rc   re   rg   s     rK   rj   z$Line.is_stub_def.<locals>.<listcomp>   s7     O
 O
 O
%&DC  O
 O
 O
rL   rk   )rt   r-   r#   r"   r@   rl   rV   s    rK   is_stub_defzLine.is_stub_def   sb     { 
t{233/Dc4J4J3K O
 O
*/((O
 O
 O
 4
  
 	
rL   c                 6   t          |           ot          | j                  dk    or| j        ok| j        d         j        t
          j        k    oK| j        d         j        dk    o5| j        d         j        t
          j        k    o| j        d         j        dk    S )zzIs this a class with no base classes but using parentheses?

        Those are unnecessary and should be removed.
              (rk   ))	r=   rU   r-   r_   r:   r"   LPARr>   RPARrV   s    rK   rA   zLine.is_class_paren_empty   s     JJ ,DK  A%,, A#uz1, A$+	,
 A#uz1, A$+	
rL   c                     | r | j         d         j        t          j        k    rdS | j         d         j        }|                    d          rdS |                    d          rdS dS )z#Is the line a triple quoted string?r   F)z"""z'''T)zr'''zr"""zR'''zR""")r-   r:   r"   STRINGr>   
startswith)rI   r>   s     rK   _is_triple_quoted_stringzLine._is_triple_quoted_string   sp      	t{1~*el::5A$N++ 	4<== 	4urL   c                 T    t          |           ot          | j        d                   S )zIs the line a docstring?r   )r=   r   r-   rV   s    rK   r   zLine.is_docstring   s#     Dzz:l4;q>:::rL   c                 f    d | j         D                                 t          j                  dk    S )z Is the line a chained assignmentc                     g | ]	}|j         
S  r:   rh   r3   s     rK   rj   z.Line.is_chained_assignment.<locals>.<listcomp>   s    222d	222rL   rT   )r-   countr"   EQUALrV   s    rK   is_chained_assignmentzLine.is_chained_assignment   s/     32dk22288EEIIrL   c                 v    t          | j                  dk    rdS | j        d         j        t          j        k    S )z/Does this line open a new level of indentation.r   F)rU   r-   r:   r"   r@   rV   s    rK   opens_blockzLine.opens_block   s4     t{q  5{2#u{22rL   first_leaf_matchesr   c                    t          | j                  dk    rdS | j        d         }|j        t          k    s|j        dS |du p ||j                  S )zIs this line converted from fmt off/skip code?

        If first_leaf_matches is not None, it only returns True if the first
        leaf of converted code matches.
        rT   Fr   N)rU   r-   r:   r   fmt_pass_converted_first_leaf)rI   r   r3   s      rK   is_fmt_pass_convertedzLine.is_fmt_pass_converted   sm     t{q  5{1~I+++195!T) 
-?-?..
 .
 	
rL   c                 @    | j         D ]}|j        t          k    r dS dS )z)If so, needs to be split before emitting.TF)r-   r:   r   rI   r3   s     rK   contains_standalone_commentsz!Line.contains_standalone_comments   s4    K 	 	Dy...tt / urL   c                     t          j        | j        d           D ]W\  }}|t          j        k    rt          |          }t          |          dk    r9|D ]}|                     |          r  dS XdS )zFChck if we have an implicit multiline string with comments on the linec                     | j         S Nr   )r3   s    rK   <lambda>zGLine.contains_implicit_multiline_string_with_comments.<locals>.<lambda>   s    di rL   rT   TF)	itertoolsgroupbyr-   r"   r   listrU   comments_after)rI   	leaf_typeleaf_group_iterator	leaf_listr3   s        rK   0contains_implicit_multiline_string_with_commentsz5Line.contains_implicit_multiline_string_with_comments   s    .7.?K///
 /
 
	  
	 *I* EL((011I9~~""!    &&t,,  444   urL   c                 "   t                      }	 | j        d         }|                    t          |                     |j        t
          j        k    s|j        t
          j        k    r6|j        s/| j        d         }|                    t          |                     n# t          $ r Y dS w xY wd}| j
                                        D ]B\  }}|D ]:}t          || j                  r |st          || j                  s||vr  dS d};CdS )Nr   r8   Fr)   T)setr-   addidr:   r"   COMMAr   r>   rp   r.   itemsr   r)   r   )rI   ignored_ids	last_leafcomment_seenleaf_idr.   comments          rK   $contains_uncollapsable_type_commentsz)Line.contains_uncollapsable_type_comments  s5   ee	BIOOByMM***~,,%*,,Y_, !KO	9... 	 	 	55	 !%!4!4!6!6 		$ 		$GX# $ $"7;;; $# $27KKK$#;66#ttt#$ us   BB   
B.-B.c                 h   | j         sdS t          d | j         D             d          }t          d t          | j                   D             d          }||k    rW| j         dd          D ]G}| j                            t          |          g           D ]}t          || j                  r  dS HdS )NFc              3   :   K   | ]}|j         d k    |j         V  dS r   Nlinenor   s     rK   	<genexpr>z9Line.contains_unsplittable_type_ignore.<locals>.<genexpr>=  s1      SS4$+QRBRBR4;BRBRBRBRSSrL   r   c              3   :   K   | ]}|j         d k    |j         V  dS r   r   r   s     rK   r   z9Line.contains_unsplittable_type_ignore.<locals>.<genexpr>?  s0      OOTdkQ>N>NT[>N>N>N>NOOrL   r8   r   T)r-   nextreversedr.   getr   r   r)   )rI   
first_line	last_linenoder   s        rK   !contains_unsplittable_type_ignorez&Line.contains_unsplittable_type_ignore,  s    { 	5 SS4;SSSUVWW
OOXdk%:%:OOOQR
 
	 "" BCC( $ $#}00D2>> $ $G-gDIFFF $#ttt$$ urL   c                 >    t          d | j        D                       S )Nc              3   4   K   | ]}t          |          V  d S r   )r   r   s     rK   r   z2Line.contains_multiline_strings.<locals>.<genexpr>N  s+      EE&t,,EEEEEErL   )anyr-   rV   s    rK   contains_multiline_stringszLine.contains_multiline_stringsM  s!    EEEEEEEErL   closingc                 .   |j         t          v r'| j        r | j        d         j         t          j        k    sdS |j         t          j        k    rdS |j         t          j        k    r|j        {|j        j         t          j	        k    ra|j
        Zt          |j
        || j        t          j        t          j        f          r'|j        J |j        j         t          j        k    sJ dS dS | j        rdS |j
        t          |j
        || j                  sdS dS )zReturn True if we have a magic trailing comma, that is when:
        - there's a trailing comma here
        - it's not from single-element square bracket indexing
        - it's not a one-tuple
        r   FTN)brackets)r:   r   r-   r"   r   RBRACERSQBparentr   traileropening_bracketr   LSQBprev_siblingsubscriptlistr   )rI   r   s     rK   rE   zLine.has_magic_trailing_commaP  s#    L,,, -B$335<5<''4<5:%%*N'4<77+7++K#j%*5	   8 +777+0D4FFFFFu4> 	4".7N#Wdk8
 8
. 4urL   r   c                    |j         t          k    r"| j                                        r	d|_        dS |j         t
          j        k    rdS | j        st          |_         d|_        dS | j        d         }|j         t
          j        k    r|j	        s|j
        rt          t          |j
                                                            dk    rPt          || j                  s:t          | j                  dk     rt          |_         d|_        dS | j        d         }| j                            t#          |          g                               |           dS )	z0Add an inline or standalone comment to the line. Fr   rk   r   r|   r8   T)r:   r   r/   any_open_bracketsrB   r"   COMMENTr-   r   r>   r   rU   r   r   r)   r.   
setdefaultr   rH   )rI   r   r   s      rK   rG   zLine.append_comment|  s@    L...$6688 /  GN5<5=((5{ 	-GLGN5KO	Nej((O )  ) D)0022334499#G$)<<< : 4;!##1!#uBI  I33::7CCCtrL   c                 R    | j                             t          |          g           S )z;Generate comments that should appear directly after `leaf`.)r.   r   r   r   s     rK   r   zLine.comments_after  s     }  D2...rL   c                    | j                                         }| j                            t          |          g           }| j                            t          | j         d                   g                               |           dS )z@Remove the trailing comma and moves the comments attached to it.r   N)r-   popr.   r   r   extend)rI   trailing_commatrailing_comma_commentss      rK   rF   zLine.remove_trailing_comma  sx    **"&-"3"3B~4F4F"K"K  DKO!4!4b99@@#	
 	
 	
 	
 	
rL   c                 J   | j                                         }|dS |j        }t          |t                    r<|j        t          j        k    rdS |j        t          j        k    rt          ||          }|duo*t          d |                                D                       S )zAReturn True iff `leaf` is part of a slice with non-trivial exprs.NFc              3   2   K   | ]}|j         t          v V  d S r   )r:   r   )rh   ns     rK   r   z,Line.is_complex_subscript.<locals>.<genexpr>  s;       3
 3
+,AF&&3
 3
 3
 3
 3
 3
rL   )r/   get_open_lsqbnext_sibling
isinstancer$   r:   r   	listmakerr   r   r   	pre_order)rI   r3   	open_lsqbsubscript_starts       rK   rC   zLine.is_complex_subscript  s    (6688	5#0ot,, 	G#t~55u#t'999"/"F"Fd* 
s 3
 3
0?0I0I0K0K3
 3
 3
 0
 0
 	
rL   is_reversedc              #     K   t          t          t          t                   gt          t
          t          t          f                  f         |rt          nt                    } || j	                  D ]p\  }}t          |j                  t          |j                  z   }d|j        v r dS |                     |          D ]}|t          |j                  z  }|||fV  qdS )zReturn an enumeration of leaves with their length.

        Stops prematurely on multiline strings and standalone comments.
        
N)r   r   r   r#   r   tupleIndexenumerate_reversed	enumerater-   rU   rB   r>   r   )rI   r   opindexr3   lengthr   s          rK   enumerate_with_lengthzLine.enumerate_with_length  s       htn%xeTk0B'CCD"-<9
 
 2dk?? 	& 	&KE4%%DJ7Ftz!!..t44 - -#gm,,,v%%%%%	& 	&rL   c                 \    t          | j        | j        | j        | j        | j                  S )N)r)   r*   r0   r1   r2   )r'   r)   r*   r0   r1   r2   rV   s    rK   clonez
Line.clone  s5    * 0!2!%!:
 
 
 	
rL   c                    | sdS d| j         z  }t          | j                  }t          |          }|j         | |j         }|d                    d |D                       z  }t          j        	                    | j
                                                  }d |D             }|d                    |          z  }|dz   S )zRender the line.r   z    r   c              3   4   K   | ]}t          |          V  d S r   strr   s     rK   r   zLine.__str__.<locals>.<genexpr>  s(      44Ts4yy444444rL   c                 ,    g | ]}t          |          S r   r   )rh   r   s     rK   rj   z Line.__str__.<locals>.<listcomp>  s    >>>WCLL>>>rL   )r*   iterr-   r   rB   r>   joinr   chainfrom_iterabler.   values)rI   indentr-   firstrescomments_iterr.   s          rK   __str__zLine.__str__  s     	4$*$dk""V4v4u{44rww44V444444!55dm6J6J6L6LMM>>>>>rwwx   TzrL   c                 8    t          | j        p| j                  S )z/Return True if the line has leaves or comments.)r=   r-   r.   rV   s    rK   __bool__zLine.__bool__  s    DK04=111rL   )FFF)r6   N)r6   r'   ):__name__
__module____qualname____doc__r   r)   r   __annotations__r*   intr   r-   r#   dictr.   LeafIDr   r/   r0   r=   r1   r2   rH   rR   propertyrP   rY   r   r   r_   rm   rt   ry   rA   r   r   r   r   r   r   r   r   r   r   r   rE   rG   r   rF   rC   r   r   r   r   r   r   r   r  r   rL   rK   r'   r'   '   s\        EEE"""D$"""E3NNNt444FDJ444).t)D)D)DHd64:%&DDD&+eN&K&K&KO^KKK!OT!!!"d"""(,$+,,, MR'% '%'%(,'%EI'%	'% '% '% '%R5 5 5D 5T 5 5 5 5( SD S S S XS >d > > > X> 84 8 8 8 X8 ID I I I XI 
$ 
 
 
 X
 
t 
 
 
 X
 
 
 
 
 X
$ 
T 
 
 
 X
 
d 
 
 
 X
 	$ 	 	 	 X	 ;d ; ; ; X; Jt J J J XJ 3T 3 3 3 X3 FJ
 
 
%-tfdl%;d%B
	
 
 
 
(d    $    "d " " " "H4    BFD F F F F* * * * * *X#d #t # # # #J/4 /DJ / / / /
 
 
 

 
$ 
 
 
 
( #(& &&	%tS()	*& & & &*
 
 
 
     2$ 2 2 2 2 2 2rL   r'   c                   F    e Zd ZU dZeed<   eed<   eed<   eed<   eed<   dS )	RHSResultz2Intermediate split result from a right hand split.headbodytailr   closing_bracketN)r  r  r  r  r'   r  r#   r   rL   rK   r  r    sK         <<
JJJ
JJJ
JJJrL   r  c                       e Zd ZU dZeed<   ed          ed<   eed<   dZe	ed<    e
e          Zee         ed<   dZe	ed	<   d
Zeed<   dee         fdZdS )
LinesBlockzClass that holds information about a block of formatted lines.

    This is introduced so that the EmptyLineTracker can look behind the standalone
    comments and adjust their empty lines for class or def lines.
    r)   previous_blockoriginal_liner   beforer+   content_linesafterF	form_feedr6   c                     t          t          | j                            }t          | j        | j        |          }|g| j        z   || j        z  gz   S )Nr   )r   r'   r)   r   r  r  r  r  )rI   
empty_linerB   s      rK   	all_lineszLinesBlock.all_lines  sP    49---..
#DKLLx$,,
TZ0G/HHHrL   N)r  r  r  r  r   r  r   r'   r  r  r   r   r  r   r  r  r=   r  r   rL   rK   r  r    s           JJJ\****FCOOO$uT:::M49:::E3NNNItI49 I I I I I IrL   r  c            
           e Zd ZU dZeed<   dZedz  ed<   dZe	dz  ed<    e
e          Zee         ed<   dZe	dz  ed<   d	ed
e	fdZd	ed
efdZd	ed
eeef         fdZd	ededed
eeef         fdZdS )EmptyLineTrackera{  Provides a stateful method that returns the number of potential extra
    empty lines needed before and after the currently processed line.

    Note: this tracker works on lines that haven't been split yet.  It assumes
    the prefix of the first leaf consists of optional newlines.  Those newlines
    are consumed by `maybe_empty_lines()` and included in the computation.
    r)   Nprevious_liner  r+   previous_defssemantic_leading_commentcurrent_liner6   c                    |j         dk    o't          |j                  od|j        d         j        v }|                     |          \  }}| j        r| j        j        nd}t          d||z
            }|                     |          rd}t          | j
        | j        ||||          }|j        r2| j        #| j        j        s| j        j        r|r| j        |r|| _        n|j        r|rd| _        || _        || _        |S )zReturn the number of extra empty lines before and after the `current_line`.

        This is for separating `def`, `async def` and `class` with extra empty
        lines (two on module-level).
        r   z
rT   )r)   r  r  r  r  r  N)r*   r=   r-   rB   _maybe_empty_linesr  r  max_line_is_module_docstringr  r)   rP   r  rY   r!  )rI   r"  r  r  r  previous_afterblocks          rK   maybe_empty_linesz"EmptyLineTracker.maybe_empty_lines$  sS    !# 8\())8,-a077 	
 //==6:6IP,22qQ/00 )),77 	F.&
 
 
 " 
	1!)&3 * +6 * ;A * 2:f:05-* 	1f 	1,0D))#rL   c                     | j         }|sdS t          |j        j                  dk    s|j        j        r|j        s|j        rdS |j         x}r|j        j        sdS |j         x}dS )NFrT   T)r  rU   r  r-   r   r_   rt   rP   )rI   r"  r  s      rK   r&  z*EmptyLineTracker._line_is_module_docstringQ  s    , 	5,34499!/< :$ : " :
 5 . ==n 	!/: u !/ ==n 	 trL   c                    d}|j         dk    r| j        j        rdnd}|j        r?|j        d         }|j                            d          }t          ||          }d|_        nd}t          |          }|j         }d }| j        rL| j        d         j         |k    r6| j        	                                }| j        r| j        d         j         |k    6|j
        s|j        r| j                            |           | j        dS |j        r(| j        j        rdS | j        j        r| j        j
        rdS || j        J | j        j        r5|j        r
|j        sd}nk|r|j
        s| j        j
        r|rdnd}nO|rd}nJd}nG|rd}nB|s>|j         r7|j        d         j        t$          j        k    r|j        d         j        d	vrd}nd}|j        s|j
        s|j        r|                     |||          S | j        j        r?| j        j         dk    r/|j         dk    r$|j        s|                    t.          
          sdS | j        j        r8|j        s1|                    t.          
          s|| j        j         k    r|pddfS |dfS )NrT   r   r|   r   r   r   r   r   r   rT   )withtryforwhileifmatchr   )rT   r   )r*   r)   is_pyir-   rB   r   minr=   r   r   rt   r_   rH   r  r   r   rm   r:   r"   r@   r>   rY   #_maybe_empty_lines_for_class_or_defr   r   )rI   r"  max_allowedrr   r  user_had_newliner*   previous_defs           rK   r$  z#EmptyLineTracker._maybe_empty_linesa  sC   ""#y/6!!QK 	%,Q/J&,,T22F--F "JF<<"   	4T%7%;%AU%J%J-1133L   	4T%7%;%AU%J%J 	4,"7 	4%%l333%4$ 	!* t!- $2D2K t#%111y ( 1K FF <#6 4;M;T "29QQFF FFFF FF$* %+B/4CC$+A.4MN N FFF$ 	(; 	|?T 	;;f&6  
 (	"(A--"a'' * ( 66)6TT ( 4 (	$ *	$ !66)6TT	$ +111Ka!##qyrL   r  r8  c                    | j         J | j         j        r| j        j        r	|j        rdS dS | j         j        |j        k     r.| j         j        s| j         j        r| j        j        rdS |rdnddfS d }| j         j        r]| j         j        |j        k    rH|dk    rB| j	        }|7|j
        0|j
        j        j        s|j
        j        j        s|j        dk    r|}ndS | j        j        r|j        s| j         j        rI| j         j        |j        k     rd}n| j         j        |j        k    rd}n|j        r| j         j        rd}nnd}nk| j         j        |j        k    rd}nS|j        s|j        r'| j         j        s|j        rt          d|          }n!d}nd}n|j        rdnd}| j         j        r|sd}|-|j
        }|$t!          |j        |          |j        z
  |_        d}|dfS )Nr-  r,  rT   r   r|   )r  rY   r)   r4  rm   r*   r_   rt   rP   r!  r  r  r   r  r5  ry   r%  r  )rI   r"  r  r8  comment_to_add_newlinesslcnewlinesr  s           rK   r6  z4EmptyLineTracker._maybe_empty_lines_for_class_or_def  s    !---* 	y L$> t4#l&888' 9+/+=+D 9 y t(/11a2259)	"(L,>>>!/C&2*8A 3*8D 3 J!OO*-''t9 "	$ (:(C %+l.@@@ HH'-0BBB HH!/ !D4F4T ! HH HH #)L,>>>#'3'@(/  % !  #1f~~HH  !HH(.5qqAH !- 6F ".4CN)/6AANDXX (. {rL   )r  r  r  r  r   r  r  r'   r  r  r   r   r   r!  r)  r=   r&  r   r  r$  r6  r   rL   rK   r  r    sG          JJJ!%M4$;%%%(,NJ%,,, %d ; ; ;M4:;;;26j4/666+d +z + + + +Zd t     [t [c3h [ [ [ [zN N*-NAEN	sCxN N N N N NrL   r  sequencer6   c              #   h   K   t          |           dz
  }t          |           D ]}||fV  |dz  }dS )z;Like `reversed(enumerate(sequence))` if that were possible.rT   N)rU   r   )r>  r   elements      rK   r   r     sS      MMAEH%%  g
 rL   Fnew_lineold_liner-   r4   c                     |D ]r}t          |j        |j                  }t          ||           |                     ||           |                    |          D ]}|                     |d           sdS )a  
    Append leaves (taken from @old_line) to @new_line, making sure to fix the
    underlying Node structure where appropriate.

    All of the leaves in @leaves are duplicated. The duplicates are then
    appended to @new_line and used to replace their originals in the underlying
    Node structure. Any comments attached to the old leaves are reattached to
    the new leaves.

    Pre-conditions:
        set(@leaves) is a subset of set(@old_line.leaves).
    rN   TN)r#   r:   r>   r   rH   r   )rA  rB  r-   r4   old_leafnew_leafcomment_leafs          rK   append_leavesrG    s      = =x~66h)))|<<<$33H== 	= 	=LOOLtO<<<<	== =rL   r   )line_strliner)   rH  c                   |st          |           }|                                 rdS d|vrt          |          |j        k    S |                    d          ^}}}t          |          |j        k    st          |          |j        k    rdS g }d}g }t
          j        }	t          | j                  D ]\  }
}|	t
          j        k    rd}|j	        dz   t          |          k    r|                    d           n/|j	        dz   t          |          k     r|                                }|%|#|j	        |j	        dz   k    r|j	        }	|dk    r dS |j	        |	k    rh|j        t          j        k    rSdg}||z  }| j        s|j	        dk    r9|
t          | j                  dz
  k    s	|j        |vr||j	        xx         dz  cc<   |	t
          j        k    rt%          |	|j	                  }	t'          |          r|j        rH|j        j        t*          j        k    s+|j        j        r"|j        j        j        t*          j        k    r dS t          |          dk    r dS |}|}t1          |          |v r5|                    |           |j        n|j        }t1          |          |v 5t          |          dk    rdS t3          d |D                       S )a  For non-multiline strings, return True if `line` is no longer than `line_length`.
    For multiline strings, looks at the context around `line` to determine
    if it should be inlined or split up.
    Uses the provided `line_str` rendering, if any, otherwise computes a new one.
    Fr   NrT   r   Tc              3   "   K   | ]
}|d k    V  dS r   r   )rh   vals     rK   r   z'is_line_short_enough.<locals>.<genexpr>  s&      **Csax******rL   )line_to_stringr   r!   line_lengthsplitmathinfr   r-   bracket_depthrU   rH   r   r:   r"   r   r0   r   r5  r   r   r   testdictsetmakerr   all)rI  r)   rH  r   ri   lastcommasmultiline_stringmultiline_string_contextsmax_level_to_updateir3   	had_commaignore_ctxsctxs                  rK   is_line_short_enoughr_  /  s$     (!$''((** u8""d&666nnT**OEAt$***ioo@P.P.Pu F$(*,'+xT[)) /! /!4$(**$(I!A%F33a    #a'#f++55"JJLL	%$0$2d6H16LLL '+&8#q== 55!444ek9Q9Q -16K44K$ 0(:Q(>(>S%%)))T->k-Q-Qt)***a/***$(**"%&94;M"N"Nt$$ 	!{  DI--K& .+/;+=+BdFW+W+W uu,--11uu#Cc((h&&)00555:%j	 c((h&& $%%**t**6******rL   c                    | j         }t          |          dk     rdS |d         j        t          j        k    r|d         j        t          j        k    rd}d}|d         }|ddd         D ]}|j        t          v r|j        t          vr dS |dz  }nh|j        t          j        k    r|dz  }nM|j        t          j        k    r'|j        t          j        k    s|j        t          v s dS n|j        t          vr dS |dk    r	|dk    r dS dS )	zReturn False if the line cannot be split *for sure*.

    This is not an exhaustive search but a cheap heuristic that we can use to
    avoid some unfortunate formattings (mostly around wrapping unsplittable code
    in unnecessary parentheses).
    r|   Fr   rT   r   r8   NT)	r-   rU   r:   r"   r   rf   r   r   r^   )rI  r-   
call_count	dot_countr   r3   s         rK   can_be_splitrc    s    [F
6{{Quay~%%&).EI*E*E
	bz26r6N 	 	Dy,,,9$444 55a

ei''Q		ej((	UY..$)?O2O2O 55"222uu1}}auu4rL   rhsrN  c                    | j         }d}t          |j                  D ]K}|r||j        u rd}|j        t
          k    r|s dS |s%|j        t          v r|j        |j        v r	|j        r|}L|j        }|j	        sdS |
                                }|                    |          }|dk    rdS |dk    r|t          k    r| j        j        rdS |t          k    rdS t!          |j                  dk    s
J d            |j        d         }|j        d         }	|j        t"          v r"|	j        t          vrt%          |||          rdS |j        d	         }
|j        d
         }|j        t&          j        k    sK|j        t&          j        k    s6|j        t&          j        k    rV|j        rO|j        j        t0          j        k    r5|
j        t"          v rdS t5          |          rdS t7          |||          rdS dS )a  Does `rhs.body` have a shape safe to reformat without optional parens around it?

    Returns True for only a subset of potentially nice looking formattings but
    the point is to not return false positives that end up producing lines that
    are too long.
    NFTrT   r|   zStranded delimiterr   )r   rN  r8   r   )rV  rN  )r  r   r-   r   r:   r   r   r>   r/   
delimitersmax_delimiter_prioritydelimiter_count_with_priorityr   r  r   r   rU   r   _can_omit_opening_parenr"   r   r   r   r   r   r   r   _can_omit_closing_paren)rd  rN  rI  r  r3   btmax_prioritydelimiter_countr   secondpenultimaterV  s               rK   can_omit_invisible_parensrp    sA    8D $(O%% # # 	#t'FFF"O9***?*55	#	---$33
 4 #O		B= t,,..L66|DDOu!>))ch.Q)
 5
 |##tt{q   "6    KNE[^Fz%%%&+=M*M*M"4u+NNN 	4 +b/K;r?D 		UZ9$$ I## $ DL00 ///5u%% 	 4"4dLLL 	45rL   r   c                   d}d| j         z  }d}|                                 D ]>\  }}}|j        t          v r|j        |u rd}|r||z  }||k    r n.|j        t
          v rd}?t          | j                  |dz   k    rdS dS ) See `can_omit_invisible_parens`.Fr{   r   TrT   )r*   r   r:   r   r   r   rU   r-   )rI  r   rN  	remainderr   _indexr3   leaf_lengths           rK   ri  ri    s    I^FF%)%?%?%A%A  !k9(((T-AU-J-JI 	"k!F##y,,,!	 t{vz))45rL   rV  c                    d| j         z  }d}|                                 D ]0\  }}}||z  }||j        u r|s||k    r dS  |j        t          v rd}1dS )rr  r{   FT)r*   r   r   r:   r   )rI  rV  rN  r   seen_other_bracketsrt  r3   ru  s           rK   rj  rj  %  s    ^F%)%?%?%A%A ' '!k+4'''" f&;&;tt '< Y***"&5rL   c                 F    t          |                               d          S )zmReturns the string representation of @line.

    WARNING: This is known to be computationally expensive.
    r   )r   r?   )rI  s    rK   rM  rM  6  s    
 t99??4   rL   r  )Br   rP  collections.abcr   r   r   dataclassesr   r   typingr   r	   r
   r   black.bracketsr   r   r   
black.moder   black.nodesr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    black.stringsr!   blib2to3.pgen2r"   blib2to3.pytreer#   r$   r%   r  r   r
  LNr'   r  r  r  r   r   r   r=   rG  r   r_  rc  rp  ri  rj  rM  r   rL   rK   <module>r     sa        8 8 8 8 8 8 8 8 8 8 ( ( ( ( ( ( ( ( 1 1 1 1 1 1 1 1 1 1 1 1 G G G G G G G G G G                                           & $ # # # # #             & & & & & & & & GCLL	
4: H2 H2 H2 H2 H2 H2 H2 H2V         I I I I I I I I* w w w w w w w wt! %q/1J     NS= =="=,0J=FJ=	= = = =0 EG U+ U+ U+t U+d U+c U+4 U+ U+ U+ U+p!t ! ! ! ! !H^	^^ 
^ ^ ^ ^B$ $ S T    2$  C D    "! !# ! ! ! ! ! !rL   