
    ^j                        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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/e0Z1e0Z2ee-e.f         Z3e G d d                      Z4e G d d                      Z5e G d d                      Z6e+j7        e+j8        e+j9        e+j:        e+j;        e+j<        fZ= G d de
          Z>e G d d                      Z?dee/         dee@e1e/f                  fdZA	 d.de4de4deBe-         deCddf
dZDdd d!e4d"ed#eEdeCfd$ZFd!e4deCfd%ZGd&e5d'e0deCfd(ZHd!e4d)e-d'e0deCfd*ZId!e4d+e-d'e0deCfd,ZJd!e4deEfd-ZKdS )/    N)CallableIteratorSequence)	dataclassfield)
NamedTupleOptional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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+   r2   r1   markr4   has_magic_trailing_commaremove_trailing_commaappend_commentappend)selfr5   r6   r7   	has_values        O/var/www/app.qaans.com/backend/venv/lib/python3.11/site-packages/black/lines.pyrJ   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r6   N)	r1   r,   any_open_for_or_lambda
is_comment
ValueErrorr/   r<   r   rJ   )rK   r5   r6   s      rM   append_safezLine.append_safe^   s      &!++#::<< ,  I !GHHH{ ty,>>> K   	D|44444rN   c                 h    t          | j                  dk    o| j        d         j        t          k    S )z"Is this line a standalone comment?   r   )lenr/   r<   r   rK   s    rM   rR   zLine.is_commentr   s-     4;1$RQ)<@R)RRrN   c                 `    t          |           o| j        d         j        t          j        k    S )zIs this line a decorator?r   )r?   r/   r<   r$   ATrX   s    rM   is_decoratorzLine.is_decoratorw   s%     Dzz=dk!n1UX==rN   c                 T    t          |           ot          | j        d                   S )zIs this an import line?r   )r?   r   r/   rX   s    rM   r   zLine.is_import|   s#     Dzz7iA777rN   c                 T    t          |           ot          | j        d                   S )zIs this a with_stmt line?r   )r?   r   r/   rX   s    rM   r   zLine.is_with_or_async_with_stmt   s$     DzzH8QHHHrN   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@   rX   s    rM   is_classzLine.is_class   s@     JJ 0A#uz10A$/	
rN   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     rM   
<listcomp>z&Line.is_stub_class.<locals>.<listcomp>   s1     6
 6
 6
%&DC  6
 6
 6
rN      )ra   r/   rangerX   s    rM   is_stub_classzLine.is_stub_class   sG     } 
RSS!1 6
 6
*/((6
 6
 6
 "
 	
rN   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   FrV   Ndef)r/   
IndexErrorr<   r$   r`   r@   ASYNC)rK   
first_leafsecond_leafs      rM   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 re   rg   ri   s     rM   rl   z$Line.is_stub_def.<locals>.<listcomp>   s7     O
 O
 O
%&DC  O
 O
 O
rN   rm   )rv   r/   r%   r$   rB   rn   rX   s    rM   is_stub_defzLine.is_stub_def   sb     { 
t{233/Dc4J4J3K O
 O
*/((O
 O
 O
 4
  
 	
rN   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.
              (rm   ))	r?   rW   r/   ra   r<   r$   LPARr@   RPARrX   s    rM   rC   zLine.is_class_paren_empty   s     JJ ,DK  A%,, A#uz1, A$+	,
 A#uz1, A$+	
rN   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)rK   r@   s     rM   _is_triple_quoted_stringzLine._is_triple_quoted_string   sp      	t{1~*el::5A$N++ 	4<== 	4urN   c                 T    t          |           ot          | j        d                   S )zIs the line a docstring?r   )r?   r   r/   rX   s    rM   r   zLine.is_docstring   s#     Dzz:l4;q>:::rN   c                 f    d | j         D                                 t          j                  dk    S )z Is the line a chained assignmentc                     g | ]	}|j         
S  r<   rj   r5   s     rM   rl   z.Line.is_chained_assignment.<locals>.<listcomp>   s    222d	222rN   rV   )r/   countr$   EQUALrX   s    rM   is_chained_assignmentzLine.is_chained_assignment   s/     32dk22288EEIIrN   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)rW   r/   r<   r$   rB   rX   s    rM   opens_blockzLine.opens_block   s4     t{q  5{2#u{22rN   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.
        rV   Fr   N)rW   r/   r<   r   fmt_pass_converted_first_leaf)rK   r   r5   s      rM   is_fmt_pass_convertedzLine.is_fmt_pass_converted   sm     t{q  5{1~I+++195!T) 
-?-?..
 .
 	
rN   c                 @    | j         D ]}|j        t          k    r dS dS )z)If so, needs to be split before emitting.TF)r/   r<   r   rK   r5   s     rM   contains_standalone_commentsz!Line.contains_standalone_comments   s4    K 	 	Dy...tt / urN   c                     t          j        | j        d           D ]W\  }}|t          j        k    rt          |          }t          |          dk    r9|D ]}|                     |          r  dS XdS )zGCheck if we have an implicit multiline string with comments on the linec                     | j         S Nr   )r5   s    rM   <lambda>zGLine.contains_implicit_multiline_string_with_comments.<locals>.<lambda>   s    di rN   rV   TF)	itertoolsgroupbyr/   r$   r   listrW   comments_after)rK   	leaf_typeleaf_group_iterator	leaf_listr5   s        rM   0contains_implicit_multiline_string_with_commentsz5Line.contains_implicit_multiline_string_with_comments   s    .7.?K///
 /
 
	  
	 *I* EL((011I9~~""!    &&t,,  444   urN   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   r:   Fr+   T)setr/   addidr<   r$   COMMAr   r@   rr   r0   itemsr   r+   r   )rK   ignored_ids	last_leafcomment_seenleaf_idr0   comments          rM   $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     rM   	<genexpr>z9Line.contains_unsplittable_type_ignore.<locals>.<genexpr>=  s1      SS4$+QRBRBR4;BRBRBRBRSSrN   r   c              3   :   K   | ]}|j         d k    |j         V  dS r   r   r   s     rM   r   z9Line.contains_unsplittable_type_ignore.<locals>.<genexpr>?  s0      OOTdkQ>N>NT[>N>N>N>NOOrN   r:   r   T)r/   nextreversedr0   getr   r   r+   )rK   
first_line	last_linenoder   s        rM   !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$$ urN   c                 >    t          d | j        D                       S )Nc              3   4   K   | ]}t          |          V  d S r   )r   r   s     rM   r   z2Line.contains_multiline_strings.<locals>.<genexpr>N  s+      EE&t,,EEEEEErN   )anyr/   rX   s    rM   contains_multiline_stringszLine.contains_multiline_stringsM  s!    EEEEEEEErN   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   )rK   r   s     rM   rG   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urN   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   rm   r   r~   r:   T)r<   r   r1   any_open_bracketsrD   r$   COMMENTr/   r   r@   r   rW   r   r   r+   r0   
setdefaultr   rJ   )rK   r   r   s      rM   rI   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trN   c                 R    | j                             t          |          g           S )z;Generate comments that should appear directly after `leaf`.)r0   r   r   r   s     rM   r   zLine.comments_after  s     }  D2...rN   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/   popr0   r   r   extend)rK   trailing_commatrailing_comma_commentss      rM   rH   zLine.remove_trailing_comma  sx    **"&-"3"3B~4F4F"K"K  DKO!4!4b99@@#	
 	
 	
 	
 	
rN   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   )rj   ns     rM   r   z,Line.is_complex_subscript.<locals>.<genexpr>  s;       3
 3
+,AF&&3
 3
 3
 3
 3
 3
rN   )r1   get_open_lsqbnext_sibling
isinstancer&   r<   r!   	listmakerr   r   r   	pre_order)rK   r5   	open_lsqbsubscript_starts       rM   rE   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
 	
rN   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/   rW   rD   r@   r   )rK   r   opindexr5   lengthr   s          rM   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%%%%%	& 	&rN   c                 \    t          | j        | j        | j        | j        | j                  S )N)r+   r,   r2   r3   r4   )r)   r+   r,   r2   r3   r4   rX   s    rM   clonez
Line.clone  s5    * 0!2!%!:
 
 
 	
rN   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     rM   r   zLine.__str__.<locals>.<genexpr>  s(      44Ts4yy444444rN   c                 ,    g | ]}t          |          S r   r   )rj   r   s     rM   rl   z Line.__str__.<locals>.<listcomp>  s    >>>WCLL>>>rN   )r,   iterr/   r   rD   r@   joinr   chainfrom_iterabler0   values)rK   indentr/   firstrescomments_iterr0   s          rM   __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rN   c                 8    t          | j        p| j                  S )z/Return True if the line has leaves or comments.)r?   r/   r0   rX   s    rM   __bool__zLine.__bool__  s    DK04=111rN   )FFF)r8   N)r8   r)   ):__name__
__module____qualname____doc__r   r+   r   __annotations__r,   intr   r/   r%   dictr0   LeafIDr   r1   r2   r?   r3   r4   rJ   rT   propertyrR   r[   r   r   ra   ro   rv   r{   rC   r   r   r   r   r   r   r   r   r   r   r   rG   rI   r   rH   rE   r   r   r   r   r   r   r  r  r   rN   rM   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 2rN   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   rN   rM   r  r    sK         <<
JJJ
JJJ
JJJrN   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_feedr8   c                     t          t          | j                            }t          | j        | j        |          }|g| j        z   || j        z  gz   S )Nr   )r   r)   r+   r   r  r  r  r  )rK   
empty_linerD   s      rM   	all_lineszLinesBlock.all_lines  sP    49---..
#DKLLx$,,
TZ0G/HHHrN   N)r  r  r  r  r   r	  r	   r)   r  r
  r   r   r  r   r  r  r?   r  r   rN   rM   r  r    s           JJJ\****FCOOO$uT:::M49:::E3NNNItI49 I I I I I IrN   r  c                   2    e Zd ZU dZeed<   eed<   eed<   dS )_DecoratedFuncInfozGTracks the most recently seen decorated function for overload grouping.namer,   is_multiN)r  r  r  r  r   r	  r
  r?   r   rN   rM   r   r     s1         QQ
IIIJJJNNNNNrN   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Zedz  ed	<   ed
eez  dedz  fd            Zed
ededefd            Zeddd
eez  dededz  fd            Zededededefd            Zedededz  fd            Zededefd            Zedededz  fd            Zedededz  fd            Zededefd            ZdedefdZededefd            Zededefd             Z edededz  fd!            Z!ededefd"            Z"e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&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_pyi_previous_decorated_funcr   r8   c                 N   | }t          | t                    r8| j        t          j        k    r#| j        D ]}|j        t          j        k    r|} nt          |t                    r|j        t          j        k    rdS |j        d         }t          |t                    sJ |j        S )z?Extract the function name from a funcdef or async_funcdef node.NrV   )	r   r&   r<   r!   async_funcdefchildrenfuncdefr%   r@   )r   r,  sub	name_nodes       rM   _get_funcdef_namez"EmptyLineTracker._get_funcdef_name7  s      $dD!! 	di43E&E&E}  8t|++!GE , '4(( 	GLDL,H,H4$Q'	)T*****rN   r!  c                 D    t          fd| j        D                       S )zFCheck if a ``decorated`` node contains a function with the given name.c              3      K   | ]A}|j         t          j        t          j        fv ot                              |          k    V  Bd S r   )r<   r!   r,  r*  r$  r/  )rj   r-  r!  s     rM   r   zBEmptyLineTracker._decorated_node_has_func_named.<locals>.<genexpr>J  sf       
 
  Ht'9:: @ 223774?
 
 
 
 
 
rN   )r   r+  )r   r!  s    `rM   _decorated_node_has_func_namedz/EmptyLineTracker._decorated_node_has_func_namedG  sA      
 
 
 
 }
 
 
 
 
 	
rN   Freverser4  c                    |r| j         n| j        }|Q|j        t          j        k    rt          |t                    sJ |S |j        t          v r|r|j         n|j        }ndS |QdS )zkWalk siblings skipping whitespace tokens, returning the first
        ``decorated`` node found or ``None``.N)r   r   r<   r!   	decoratedr   r&   _WHITESPACE_TOKENS)r   r4  siblings      rM   _find_adjacent_decoratedz)EmptyLineTracker._find_adjacent_decoratedP  s     (/E$##D4E!|t~--!'400000!33329S'..w?St ! trN   if_stmtexclude_suitec                 &   | j         D ]}t          |t                    s|j        t          j        k    r.||u r3|j         D ]M}t          |t                    s|j        t          j        k    r.t                              ||          r  dS  dS )zCheck if any branch of an ``if_stmt`` (other than *exclude_suite*)
        contains a decorated function with the given *name*.TF)	r+  r   r&   r<   r!   suiter6  r$  r2  )r:  r;  r!  childstmts        rM   _if_stmt_branch_has_func_namedz/EmptyLineTracker._if_stmt_branch_has_func_nameda  s     % 	 	EeT** zTZ''%%  !$-- 9..#BB4NN  444urN   linec                     | j         r| j        sdS | j        d         j        dk    r| j        d         j        S | j        d         j        S )zDExtract the function name from a line that is a function definition.Nr   rq   rV   r~   )rv   r/   r@   rA  s    rM   _get_def_namezEmptyLineTracker._get_def_namex  sN     { 	$+ 	4;q>5((;q>''{1~##rN   c                 Z    | j         r| j        sdS t                              |           duS )z5Check if a def line is part of a decorated statement.FN)rv   r/   r$  _find_decorated_noderC  s    rM   _is_line_decoratedz#EmptyLineTracker._is_line_decorated  s5     { 	$+ 	544T::$FFrN   c                     | j         sdS | j         d         j        }|X|j        t          j        k    rt          |t                    sJ |S |j        t          j        t          j        fv rdS |j        }|XdS )z@Walk up from the first leaf of a line to its ``decorated`` node.Nr   )	r/   r   r<   r!   r6  r   r&   r=  
file_input)rA  r   s     rM   rF  z%EmptyLineTracker._find_decorated_node  s     { 	4{1~$yDN**!$-----yTZ999t;D  trN   c                     | j         sdS t                              |           }|dS |j        D ]=}|j        t
          j        t
          j        fv rt                              |          c S >dS )zFor a decorator line, extract the name of the function it decorates.

        Only handles decorated functions, not decorated classes.
        N)	r[   r$  rF  r+  r<   r!   r,  r*  r/  )rA  r6  r>  s      rM   _get_decorator_target_namez+EmptyLineTracker._get_decorator_target_name  s       	4$99$??	4' 	A 	AEzdlD,>???'99%@@@@@ @trN   c                     | j         sdS t                              |           }|dS t          d |j        D                       S )z7Check if a decorator line decorates a class definition.FNc              3   @   K   | ]}|j         t          j        k    V  d S r   )r<   r!   classdef)rj   r>  s     rM   r   z>EmptyLineTracker._decorator_decorates_class.<locals>.<genexpr>  s+      OO55:.OOOOOOrN   )r[   r$  rF  r   r+  )rA  r6  s     rM   _decorator_decorates_classz+EmptyLineTracker._decorator_decorates_class  sR       	5$99$??	5OOI<NOOOOOOrN   current_linec                     | j         }|dS |j        r|                     |          n|                     |          }|duo6||j        k    o+|j        |j        k    o|j        p|                     |          S )zGCheck if current_line belongs to the same overload group being tracked.NF)r(  r[   rK  rD  r!  r,   rG  )rK   rP  prevcur_names       rM   _is_in_current_groupz%EmptyLineTracker._is_in_current_group  s    0<5 (2D++L999##L11 	 D  UDI%U
l00U *Sd.E.El.S.S		
rN   decorated_nodec                 
   d}| j         D ]=}|j        t          j        t          j        fv rt
                              |          } n>|dS t
                              |           }|duot
                              ||          S )zCheck if a `decorated` AST node is the first in a multi-function group.

        Returns True when the next statement-level sibling is also a decorated
        function with the same name.
        NF)	r+  r<   r!   r,  r*  r$  r/  r9  r2  )rU  r!  r>  adjacents       rM   _decorated_node_starts_groupz-EmptyLineTracker._decorated_node_starts_group  s     #, 	 	EzdlD,>???'99%@@ @ <5#<<^LLt# 
(8(W(Wd)
 )
 	
rN   c                     | j         sdS t                              |           }||j        dS t                              |          S )zCheck if a decorator line starts a multi-function group.

        A multi-function group is 2+ consecutive decorated functions sharing the
        same name (e.g. @overload groups, @property + setter pairs).
        F)r[   r$  rF  r   rX  )rA  rU  s     rM   _is_start_of_decorated_groupz-EmptyLineTracker._is_start_of_decorated_group  sN       	5)>>tDD!^%:%B5<<^LLLrN   c                 @   | j         r | j         d         j        t          j        k    rdS | j         d         j        }|*t          |t                    r|j        t          j        k    rdS |j	        D ]}t          |t                    r^|j        t          j
        k    rI|j	        D ]?}|j        t          j        t          j        fv rt                              |          c c S @ n8|j        t          j        t          j        t          j        t          j        fvr ndS )zReturn the function name of the first decorated function in a block.

        *line* must be a block-opening line (ending with ``:``) such as
        ``if ...:``.  Returns ``None`` when the block doesn't start with a
        decorated function.
        r   N)r/   r<   r$   rB   r   r   r&   r!   r=  r+  r6  r,  r*  r$  r/  NEWLINENLINDENTDEDENT)rA  r=  r>  r-  s       rM   #_get_block_first_decorated_funcnamez4EmptyLineTracker._get_block_first_decorated_funcname  s    { 	dk"o2ekAA4B,=
5$ 7 7=5:;S;S4^ 	 	E%&& 5:+G+G > G GCxDL$2D#EEE/AA#FFFFFFF Fz%-5<!VVV WtrN   c                 ~   t                               |           }|dS | j        d         j        }|t	          |t
                    sdS |j        }|t	          |t
                    sdS t                               |          }|t                               ||          rdS t           	                    |||          S )u  Check if a block-opening line contains a decorated function that is
        part of a larger overload group — either because the ``if_stmt``'s next
        sibling is a same-name decorated function, or because another branch of
        the same ``if_stmt`` has one.
        NFr   T)
r$  r`  r/   r   r   r&   r   r9  r2  r@  )rA  	func_namer=  r:  rW  s        rM    _block_is_part_of_overload_groupz1EmptyLineTracker._block_is_part_of_overload_group  s     %HHNN	5B,=
5$ 7 7=5,?*Wd";";?5 $<<WEE$4$S$Si%
 %
 4  >>UI
 
 	
rN   c                    t                               |           }|dS t                               |           }|dS |j        }||j        t
          j        k    rdS |j        }||j        t
          j        k    rdS dD ]>}t                               ||          }|t           	                    ||          r dS ?t           
                    |||          S )zCheck if a decorator is inside an if/else block that is part of a
        broader overload group (a sibling or another branch of the same
        ``if_stmt`` contains a same-name decorated function).NF)TFr3  T)r$  rK  rF  r   r<   r!   r=  r:  r9  r2  r@  )rA  r!  r6  r=  r:  r4  rW  s          rM   %_is_decorator_in_conditional_overloadz6EmptyLineTracker._is_decorator_in_conditional_overload  s    
  ::4@@<5$99$??	5 =EJ$*445,?gldl::5 % 	 	G'@@ A  H $$CCHdSS % tt  >>wtTTTrN   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| _        | j
        j        ot           j        | j
        v }|r|j        r|                     |          rp|                     |          }|X| j        }	|	duo|	j        |k    o|	j         |j         k    }
t/          ||j         |
p|	duo|	j        |k    o|	j                  | _        nL|j        sE|j        s>| j        0|j         | j        j         k    r"|j        r|j        d         j        dv s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
rV   )r+   r  r  r  r  r  N)r!  r,   r"  elseelif)r,   r?   r/   rD   _maybe_empty_linesr  r  max_line_is_module_docstringr  r+   rR   r%  r[   r'  is_pyir   pyi_overload_group_blank_linesrv   rG  rD  r(  r!  r   r"  r@   )rK   rP  r  r  r  previous_afterblockoverload_groupsr!  rR  r"  s              rM   maybe_empty_linesz"EmptyLineTracker.maybe_empty_lines<  s    !# 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) IT!G49!T 	  #	9" "9t'>'>|'L'L "9)),77#<DD( = I-= J,*<< 
 9K!*0!) "V ,Td1BTt}	9 9 9D5 !-9$/9 5=$*d.O.UUU )/	 V
 !- 3A 6 <@P P P 591)#rN   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 )NFrV   T)r  rW   r  r/   r   ra   rv   rR   )rK   rP  r  s      rM   rl  z*EmptyLineTracker._line_is_module_docstring  s    , 	5,34499!/< :$ : " :
 5 . ==n 	!/: u !/ ==n 	 trN   c                    d}|j         dk    r| j        j        rdnd}| j        j        ot          j        | j        v }|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        rk|j        r|j        sd}n|r| j        | j        j        r|j        s{| j        j         |j         k    rf|j        r|j        d         j        d	v sK|                     |          rd}n;|j        r'|                     |          | j        j        k    rd}nd}n	|r:|j        r3|j        r,|j        d         j        d	v r|                     |          rd}n|rP|j        sI| j        j        r=|r4|j        r-| j        j         |j         k    r|                     |          rd}n|rdnd}n{|r*|j        r#| j        | j        j         |j         k    r|rdnd}nO|rd}nJd}nG|rd}nB|s>|j         r7|j        d         j        t8          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 )NrV   r   r~   r   r   r   r   r   r   rV   rg  )withtryforwhileifmatchr   )rV   r   )"r,   r+   rm  r   rn  r/   rD   r   minr?   r&  r   rv   ra   rJ   r%  r   r   ro   r(  r"  rR   r@   rT  r`  r!  rc  r<   r$   rB   r[   #_maybe_empty_lines_for_class_or_defr   r   )	rK   rP  max_allowedrq  rt   r  user_had_newliner,   previous_defs	            rM   rj  z#EmptyLineTracker._maybe_empty_lines  s   ""#y/6!!QKIT!G49!T 	  	%,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 Q( :1K :FF#89E9B F(3 F *0L4FFF$+ G )/28<LLL 00>> #!"%1 #@@NN<AB B "#!"#$$0$ %+$ %+A.48HHH==lKK I
 FF <#6 4;M;T '
>(4
> !.48JJJ AA,OO K "# '7!=A#$/ 9E9?<CUUU #3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rN   r  r  c                    | j         J | j        j        ot          j        | j        v }| 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        rM| j         j        |j        k     rd}n| j         j        |j        k    rd}n|j        r| j         j        rd}nd}n| j         j        |j        k    r|r|                     |          rd}nd}n|rC| j        <| j        j        r0| j         j        |j        k    r|                     |          rdnd}nB|r|                     |          rd}n'|rs|j        rl| j         j        |j        k    rW|                     |          rB| j        8| j        j        |                     |          k    s| j        j        |j        k    rd}n|j	        s|j        rT| j         j	        sH|r+|j        r$| j         j
        r|                     |          rd}nk|j        rt/          d|          }nSd}nPt          j        | j        v r|j        r|                     |          rd}nd}n|j        rdnd}| j         j        r|sd}|-|j        }|$t7          |j        |          |j        z
  |_        d}|dfS )Nrv  ru  rV   r   r~   )r%  r+   rm  r   rn  r[   ro   r,   ra   rv   rR   r'  r  r  r   r  rT  r(  r"  rZ  r!  rK  re  r}  %pyi_blank_line_before_decorated_classrO  r{   rk  r  )	rK   rP  r  r  rq  comment_to_add_newlinesslcnewlinesr  s	            rM   r~  z4EmptyLineTracker._maybe_empty_lines_for_class_or_def:  sO    !---IT!G49!T 	 * 	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 N	$ G(:(C G%+l.@@@ HH'-0BBB HH!/ !D4F4T ! HH HH #)L,>>>" !t'@'@'N'N ! HH HH55A5> B&,0BBB $ 9 9, G GN11Q  .T%>%>|%L%L . * -* &,0BBB55lCC C 5=9>::<HHI I 8>,BTTT #'3'@(/ $!$1! *5! BB<PP	!  !HH!' !  #1f~~HH  !HH=JJ - K33LAA K (.5qqAH !- 6F ".4CN)/6AANDXX (. {rN   )*r  r  r  r  r   r	  r%  r)   r  r  r   r   r&  r'  r(  r   staticmethodr&   r%   r   r/  r?   r2  r9  r@  rD  rG  rF  rK  rO  rT  rX  rZ  r`  rc  re  rr  rl  r   r
  rj  r~  r   rN   rM   r$  r$  &  sq          JJJ!%M4$;%%%(,NJ%,,, %d ; ; ;M4:;;;26j4/666>B "4t";BBBt d
    \ 
T 
 
 
 
 
 \
 .3  Tk'+	   \  &*25	   \, $D $S4Z $ $ $ \$ G G$ G G G \G 4 D4K    \  #*    \ P P$ P P P \P
 
$ 
 
 
 
" 
T 
d 
 
 
 \
$ M4 MD M M M \M $ 3:    \, 
t 
 
 
 
 \
:  UD  UT  U  U  U \ UDVd Vz V V V Vpd t     Tt Tc3h T T T Tl} }*-}AE}	sCx} } } } } }rN   r$  sequencer8   c              #   h   K   t          |           dz
  }t          |           D ]}||fV  |dz  }dS )z;Like `reversed(enumerate(sequence))` if that were possible.rV   N)rW   r   )r  r   elements      rM   r   r     sS      MMAEH%%  g
 rN   Fnew_lineold_liner/   r6   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).
    rP   TN)r%   r<   r@   r    rJ   r   )r  r  r/   r6   old_leafnew_leafcomment_leafs          rM   append_leavesr    s      = =x~66h)))|<<<$33H== 	= 	=LOOLtO<<<<	== =rN   r   )line_strrA  r+   r  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   NrV   r   Tc              3   "   K   | ]
}|d k    V  dS r   r   )rj   vals     rM   r   z'is_line_short_enough.<locals>.<genexpr>/  s&      **Csax******rN   )line_to_stringr   r#   line_lengthsplitmathinfr   r/   bracket_depthrW   rJ   r   r<   r$   r   r2   r   r}  r   r   r!   testdictsetmakerr   all)rA  r+   r  r   rk   lastcommasmultiline_stringmultiline_string_contextsmax_level_to_updateir5   	had_commaignore_ctxsctxs                  rM   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******rN   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   rV   r   r:   NT)	r/   rW   r<   r$   r   rh   r   r   r`   )rA  r/   
call_count	dot_countr   r5   s         rM   can_be_splitr  2  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4rN   rhsr  c                      j         } j        j        r j        j        d         } j        j                            t          |          g           }|rt           fd|D                       }t           fd|D                       }d}d} j         j        D ]R}	 j         j                            t          |	          g           D ]"}
t          |
 j         j                  rd} d}#S|r|s|r|rdS 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t1          |||          rdS |j        d         }|j        d         }|j        t2          j        k    sK|j        t2          j        k    s6|j        t2          j        k    rV|j        rO|j        j        t<          j        k    r5|j        t.          v rdS tA          |          rdS tC          |||          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.
    r   c              3   N   K   | ]}t          |j        j                   V   dS r   Nr   r  r+   rj   r   r  s     rM   r   z,can_omit_invisible_parens.<locals>.<genexpr>m  sH       * * 'wSX]CCC* * * * * *rN   c              3   P   K   | ] }t          |j        j                    V  !dS r  r  r  s     rM   r   z,can_omit_invisible_parens.<locals>.<genexpr>q  sK       , , +7GGGG, , , , , ,rN   Fr   TNrV   r~   zStranded delimiterr   )r   r  r:   )r  r  )"r  r  r/   r0   r   r   r   r   r+   r   r   r<   r   r   r@   r1   
delimitersmax_delimiter_prioritydelimiter_count_with_priorityr   r   r   rW   r   _can_omit_opening_parenr$   r   r   r   r   r!   r   r   _can_omit_closing_paren)r  r  rA  r   head_commentshas_type_ignore_in_headhas_other_comment_in_headhas_type_ignore_in_bodyhas_other_comment_in_bodyr5   r   r  btmax_prioritydelimiter_countr   secondpenultimater  s   `                  rM   can_omit_invisible_parensr  V  s    8D x  (/"-)--b.A.A2FF  	&) * * * *,* * * ' '# ), , , , ,,, , , ) )% ',#(-% 9 9"x044RXXrBB 9 9G-gCHMJJJ 926//4811	9 ( ,E ).E u $(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5rN   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   TrV   )r,   r   r<   r   r   r   rW   r/   )rA  r   r  	remainderr   _indexr5   leaf_lengths           rM   r  r    s    I^FF%)%?%?%A%A  !k9(((T-AU-J-JI 	"k!F##y,,,!	 t{vz))45rN   r  c                    d| j         z  }d}|                                 D ]0\  }}}||z  }||j        u r|s||k    r dS  |j        t          v rd}1dS )r  r}   FT)r,   r   r   r<   r   )rA  r  r  r   seen_other_bracketsr  r5   r  s           rM   r  r    s    ^F%)%?%?%A%A ' '!k+4'''" f&;&;tt '< Y***"&5rN   c                 F    t          |                               d          S )zmReturns the string representation of @line.

    WARNING: This is known to be computationally expensive.
    r   )r   rA   rC  s    rM   r  r    s    
 t99??4   rN   r  )Lr   r  collections.abcr   r   r   dataclassesr   r   typingr   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   	ENDMARKERr7  r   r$  r   r   r   r?   r  r   r  r  r  r  r  r  r   rN   rM   <module>r     s        8 8 8 8 8 8 8 8 8 8 ( ( ( ( ( ( ( ( = = = = = = = = = = = = = = 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, 
M	H	L	L	M	O         P
 P
 P
 P
 P
 P
 P
 P
f! %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D	DD 
D D D DN$ $ S T    2$  C D    "! !# ! ! ! ! ! !rN   