
    j                        d dl Z d dl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 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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)	dataclassfield)CallableIteratorOptionalSequenceTypeVarUnioncast)COMMA_PRIORITYDOT_PRIORITYBracketTracker)ModePreview)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e         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'egef                  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.Z0d8d/Z1dedefd0Z2	 d7d1ede3e4e5ee	f                  fd2Z6d9d3Z7de8fd4Z9defd5Z:d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 p:|j         t          j        k    p%t	          |j                                                  }|sdS t          j        |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boolvaluestripCOLONis_class_paren_emptyr.   prefixr!   is_complex_subscriptr*   r1   r0   markr3   has_magic_trailing_commaremove_trailing_commaappend_commentappend)selfr4   r5   r6   	has_values        U/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/black/lines.pyrH   zLine.append4   s    I! (yE00( DJ$$&&''	 	  	F;$)##(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r5   N)	r0   r+   any_open_for_or_lambda
is_comment
ValueErrorr.   r;   r   rH   )rI   r4   r5   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_commentq   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_decoratorv   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		*.+a.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           j        | j        vr| j        S t	          |           ot          | j        d         | j                  S )zIs the line a docstring?r   )r   unify_docstring_detectionr*   r   r=   r   r.   rV   s    rK   r   zLine.is_docstring   s@     ,DI==00DzzEl4;q>49EEErL   c                 f    d | j         D                                 t          j                  dk    S )z Is the line a chained assignmentc                     g | ]	}|j         
S  r;   rh   r4   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   r4   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   r4   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   )r4   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_listr4   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 ]4\  }}|D ],}t          |          r|st          |          s||vr  dS d}-5dS )Nr   r9   FT)setr.   addidr;   r#   COMMAr   r>   rp   r/   itemsr   r   )rI   ignored_ids	last_leafcomment_seenleaf_idr/   comments          rK   $contains_uncollapsable_type_commentsz)Line.contains_uncollapsable_type_comments	  s'   ee	BIOOByMM***~,,%*,,Y_, !KO	9... 	 	 	55	 !%!4!4!6!6 		$ 		$GX# $ $"7++ $# $27;;$#;66#ttt#$ us   BB   
B.-B.c                 Z   | j         sdS t          d | j         D             d          }t          d t          | j                   D             d          }||k    rP| j         dd          D ]@}| j                            t          |          g           D ]}t          |          r  dS Ad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   r9   T)r.   nextreversedr/   getr   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-g66 $#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>O  s+      EE&t,,EEEEEErL   )anyr.   rV   s    rK   contains_multiline_stringszLine.contains_multiline_stringsN  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_commaQ  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    rIt          |          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|   r9   T)r;   r   r0   any_open_bracketsrB   r#   COMMENTr.   r   r>   r   rU   r   r   r/   
setdefaultr   rH   )rI   r   r   s      rK   rG   zLine.append_comment}  s9    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   )r0   get_open_lsqbnext_sibling
isinstancer%   r;   r    	listmakerr   r   r   	pre_order)rI   r4   	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indexr4   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+   r1   r2   r3   )r(   r*   r+   r1   r2   r3   rV   s    rK   clonez
Line.clone  s5    * 0!2!%!:
 
 
 	
rL   c                 V   | sdS d| j         z  }t          | j                  }t          |          }|j         | |j         }|D ]}|t          |          z  }t          j        	                    | j
                                                  D ]}|t          |          z  }|dz   S )zRender the line.r   z    )r+   iterr.   r   rB   r>   strr   chainfrom_iterabler/   values)rI   indentr.   firstresr4   r   s          rK   __str__zLine.__str__  s     	4$*$dk""V4v4u{44 	 	D3t99CC 44T]5I5I5K5KLL 	  	 G3w<<CC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)r7   N)r7   r(   );__name__
__module____qualname____doc__r   r*   r   __annotations__r+   intr   r.   r$   dictr/   LeafIDr   r0   r1   r=   r2   r3   r   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(   &   sa        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"""+/(4./// 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	 Fd F F F XF Jt J J J XJ 3T 3 3 3 X3 IM
 
 
%-hvt|.D%E
	
 
 
 
(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_feedr7   c                     t          t          | j                            }t          | j        | j        |          }|g| j        z   || j        z  gz   S )N)r*   )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e         ed<   dZ	ee
         ed<    ee          Zee         ed<   dZee
         ed<   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_liner7   c                    |j         dk    o't          |j                  od|j        d         j        v }|                     |          \  }}| j        r| j        j        nd}t          d||z
            }| j        rO| j        j        Ct          | j        j	        j                  dk    r!| j        j	        j
        r|j        s	|j        s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
NrT   )r*   r  r  r  r  r  )r+   r=   r.   rB   _maybe_empty_linesr  r  maxrU   r  r   r_   rt   r  r*   rP   r  rY   r  )rI   r  r  r  r  previous_afterblocks          rK   maybe_empty_linesz"EmptyLineTracker.maybe_empty_lines%  s    !# 8\())8,-a077 	
 //==6:6IP,22qQ/00 	 #2:D'5<==BB#1> C!* C.:.A C F.&
 
 
 " 
	1!)&3 * +6 * ;A * 2:f:05-* 	1f 	1,0D))#rL   c                 p   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        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   )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_linesW  s   ""#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  
 (	$ *	$ !66)6TT	$ +111Ka!##qyrL   r  r1  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*   r-  rm   r+   r_   rt   rP   r  r  r  r   r  r.  ry   r   r  )rI   r  r  r1  comment_to_add_newlinesslcnewlinesr  s           rK   r/  z4EmptyLineTracker._maybe_empty_lines_for_class_or_def  s    !---* 	y L$> t4#l&888' 9+/+=+D 9 y t(/11a228<)	"(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=   r/  r   rL   rK   r  r    s%          JJJ$(M8D>(((+/NHZ(/// %d ; ; ;M4:;;;59hz29990d 0z 0 0 0 0dRt Rc3h R R R RhN N*-NAEN	sCxN N N N N NrL   r  sequencer7   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   )r7  r   elements      rK   r   r     sS      MMAEH%%  g
 rL   Fnew_lineold_liner.   r5   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   )r:  r;  r.   r5   old_leafnew_leafcomment_leafs          rK   append_leavesr@    s      = =x~66h)))|<<<$33H== 	= 	=LOOLtO<<<<	== =rL   r   )line_strliner*   rA  c                   |st          |           }t          j        |vr1t          |          |j        k    od|vo|                                  S |                                 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`t          |          dk    r dS |}|}t-          |          |v r5|                    |           |j        n|j        }t-          |          |v 5t          |          dk    rdS t1          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.
    r   FNrT   r   Tc              3   "   K   | ]
}|d k    V  dS r   r   )rh   vals     rK   r   z'is_line_short_enough.<locals>.<genexpr>t  s&      **Csax******rL   )line_to_stringr   multiline_string_handlingr"   line_lengthr   splitmathinfr   r.   bracket_depthrU   rH   r   r;   r#   r   r1   r   r.  r   r   r   all)rB  r*   rA  r   ri   lastcommasmultiline_stringmultiline_string_contextsmax_level_to_updateir4   	had_commaignore_ctxsctxs                  rK   is_line_short_enoughrW    s(     (!$''(44h4#33 8H$855777	
 ((** u8""d&666nnT**OEAt$***ioo@P.P.Pu F'+*,-1XT[)) )! )!4$(**'+I!A%F33a    #a'#f++55"JJLL	%$0$2d6H16LLL '+&8#q== 55!444ek9Q9Q 04fK44K$ 0(:Q(>(>S%%)))T->k-Q-Qt)***a/***$(**"%&94;M"N"Nt$$ 	!,--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   r9   NT)	r.   rU   r;   r#   r   rf   r   r   r^   )rB  r.   
call_count	dot_countr   r4   s         rK   can_be_splitr[  w  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   rhsrH  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   rH  r9   r   )rN  rH  )r
  r   r.   r   r;   r   r   r>   r0   
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)r\  rH  rB  r  r4   btmax_prioritydelimiter_countr   secondpenultimaterN  s               rK   can_omit_invisible_parensrh    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.   )rB  r   rH  	remainderr   _indexr4   leaf_lengths           rK   ra  ra    s    I^FF%)%?%?%A%A  !k9(((T-AU-J-JI 	"k!F##y,,,!	 t{vz))45rL   rN  c                    d| j         z  }d}|                                 D ]0\  }}}||z  }||j        u r|s||k    r dS  |j        t          v rd}1dS )rj  r{   FT)r+   r   r   r;   r   )rB  rN  rH  r   seen_other_bracketsrl  r4   rm  s           rK   rb  rb    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?   )rB  s    rK   rF  rF  &  s    
 t99??4   rL   r   )Br   rJ  dataclassesr   r   typingr   r   r   r   r	   r
   r   black.bracketsr   r   r   
black.moder   r   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=   r@  r   rW  r[  rh  ra  rb  rF  r   rL   rK   <module>rz     s]        ( ( ( ( ( ( ( ( O O O O O O O O O O O O O O O O O O G G G G G G G G G G $ $ $ $ $ $ $ $                                     & $ # # # # #             & & & & & & & & GCLL	
4: J2 J2 J2 J2 J2 J2 J2 J2Z         I I I I I I I I* c c c c c c c cL! %q/1J     NS= =="=,0J=FJ=	= = = =2 02X+ X+ X+
X+X+),X+	X+ X+ X+ X+v!t ! ! ! ! !H^	^^ 
^ ^ ^ ^B$ $ S T    2$  C D    "! !# ! ! ! ! ! !rL   