
    e]                     X   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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
      Z0e1Z2e1Z3ee.e/f   Z4e G d d             Z5e G d d             Z6e G d d             Z7e G d d             Z8dee0   deee2e0f      fdZ9	 d*de5de5de	e.   de:ddf
dZ;ddde5dede<de:fd Z=de5de:fd!Z>d"e6d#e1de:fd$Z?de5d%e.d#e1de:fd&Z@de5d'e.d#e1de:fd(ZAde5de<fd)ZBy)+    N)	dataclassfield)
CallableDictIteratorListOptionalSequenceTuple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+Z0d,edefd-Z1dedee   fd.Z2d8d/Z3dedefd0Z4	 d7d1ede5e6e7ee	f      fd2Z8d9d3Z9de:fd4Z;defd5Z<y):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 xs# t        |j                  j	                               }|syt
        j                  |j                   k(  r| j                  r| j                  dd= | j                  r<|s:|xj                  t        || j                  |      | j                        z  c_	        | j                  s|r|rk| j                  j                  |       | j                  j                   r| j#                  |      r)|| _        n!| j#                  |      r| j%                          | j'                  |      s| j                  j)                  |       yy)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   boolvaluestripr&   COLONis_class_paren_emptyr1   prefixr$   is_complex_subscriptr-   r4   r3   markr6   has_magic_trailing_commaremove_trailing_commaappend_commentappend)selfr7   r8   r9   	has_values        -/usr/lib/python3/dist-packages/black/lines.pyrJ   zLine.append?   s    II)ET$**2B2B2D-E	;;$))#(A(ABC ;;| KK:"&";";D"AYY K
 |}  %%d+yy--00604D-..t4**,""4(KKt$ )    c                    | j                   j                  dk(  s| j                   j                         rA| j                  rt	        d      | j
                  r|j                  t        k(  rt	        d      | j                  ||       y)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r8   N)	r3   r.   any_open_for_or_lambda
is_comment
ValueErrorr1   r>   r   rJ   )rK   r7   r8   s      rM   append_safezLine.append_safec   sr       &&!+##::< !GHH{{tyy,>> K  	D|4rN   c                 v    t        | j                        dk(  xr  | j                  d   j                  t        k(  S )z"Is this line a standalone comment?   r   )lenr1   r>   r   rK   s    rM   rR   zLine.is_commentw   s1     4;;1$RQ)<)<@R)RRrN   c                 p    t        |       xr* | j                  d   j                  t        j                  k(  S )zIs this line a decorator?r   )r?   r1   r>   r&   ATrX   s    rM   is_decoratorzLine.is_decorator|   s*     Dz=dkk!n11UXX==rN   c                 L    t        |       xr t        | j                  d         S )zIs this an import line?r   )r?   r   r1   rX   s    rM   r   zLine.is_import   s      Dz7iA77rN   c                 L    t        |       xr t        | j                  d         S )zIs this a with_stmt line?r   )r?   r    r1   rX   s    rM   r    zLine.is_with_or_async_with_stmt   s!     DzH8QHHrN   c                     t        |       xrH | j                  d   j                  t        j                  k(  xr | j                  d   j
                  dk(  S )z Is this line a class definition?r   class)r?   r1   r>   r&   NAMEr@   rX   s    rM   is_classzLine.is_class   sJ     J 0A##uzz10A$$/	
rN   c                     | j                   xrA | j                  dd t        d      D cg c]  }t        t        j
                  d       c}k(  S c c}w )zEIs this line a class definition with a body consisting only of "..."?N   .)ra   r1   ranger'   r&   DOTrK   _s     rM   is_stub_classzLine.is_stub_class   sN     }} 
RS!1*/(6
%&DC 6
 "
 	
 6
s   !Ac                    	 | j                   d   }	 | j                   d   }|j                  t        j                  k(  xr |j
                  dk(  xsS |j                  t        j                  k(  xr4 |duxr. |j                  t        j                  k(  xr |j
                  dk(  S # t        $ r Y yw xY w# t        $ r d}Y w xY w)zBIs this a function definition? (Also returns True for async defs.)r   FrV   Ndef)r1   
IndexErrorr>   r&   r`   r@   ASYNC)rK   
first_leafsecond_leafs      rM   is_defzLine.is_def   s    	QJ	*.++a.K 5::-K*2B2Be2K 
OOu{{* +4'+  EJJ.+ !!U*		
  		
  	K	s"   B$ B3 $	B0/B03C Cc           	          | j                   xr] | j                  dd t        t        j                  d      gt        d      D cg c]  }t        t        j                  d       c}z   k(  S c c}w )zHIs this line a function definition with a body consisting only of "..."?N:rd   re   )rq   r1   r'   r&   rB   rf   rg   rh   s     rM   is_stub_defzLine.is_stub_def   sf     {{ 
t{{23/Dc4J3K*/(O
%&DC O
 4
  
 	
 O
s   !A,c                    t        |       xr t        | j                        dk(  xr | j                  xr | j                  d   j                  t
        j                  k(  xrf | j                  d   j                  dk(  xrH | j                  d   j                  t
        j                  k(  xr | j                  d   j                  dk(  S )zzIs this a class with no base classes but using parentheses?

        Those are unnecessary and should be removed.
              (rd   ))	r?   rW   r1   ra   r>   r&   LPARr@   RPARrX   s    rM   rC   zLine.is_class_paren_empty   s     J ,DKK A%,, A##uzz1, A$$+	,
 A##uzz1, A$$+	
rN   c                     | r*| j                   d   j                  t        j                  k7  ry| j                   d   j                  }|j                  d      ry|j                  d      ryy)z#Is the line a triple quoted string?r   F)z"""z'''T)zr'''zr"""zR'''zR""")r1   r>   r&   STRINGr@   
startswith)rK   r@   s     rM   _is_triple_quoted_stringzLine._is_triple_quoted_string   s\     t{{1~**ell:A$$N+<=rN   c                     t         j                  | j                  vr| j                  S t	        |       xr# t        | j                  d   | j                        S )zIs the line a docstring?r   )r   unify_docstring_detectionr-   r   r?   r   r1   rX   s    rM   r   zLine.is_docstring   sD     ,,DII=000DzEl4;;q>499EErN   c                     | j                   D cg c]  }|j                   c}j                  t        j                        dkD  S c c}w )z Is the line a chained assignmentrV   )r1   r>   countr&   EQUALrK   r7   s     rM   is_chained_assignmentzLine.is_chained_assignment   s4     '+kk2d		288EII2s   Ac                     t        | j                        dk(  ry| j                  d   j                  t        j                  k(  S )z/Does this line open a new level of indentation.r   F)rW   r1   r>   r&   rB   rX   s    rM   opens_blockzLine.opens_block   s5     t{{q {{2##u{{22rN   first_leaf_matchesr   c                    t        | j                        dk7  ry| j                  d   }|j                  t        k7  s|j                  y|du xs  ||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   r1   r>   r   fmt_pass_converted_first_leaf)rK   r   r7   s      rM   is_fmt_pass_convertedzLine.is_fmt_pass_converted   sd     t{{q {{1~II++119!T) 
-?...
 	
rN   c                 P    | j                   D ]  }|j                  t        k(  s y y)z)If so, needs to be split before emitting.TF)r1   r>   r   r   s     rM   contains_standalone_commentsz!Line.contains_standalone_comments   s*    KK 	Dyy..	 rN   c                     t        j                  | j                  d       D ]N  \  }}|t        j                  k7  rt        |      }t        |      dk(  r4|D ]  }| j                  |      s  y P y)zFChck if we have an implicit multiline string with comments on the linec                     | j                   S N)r>   )r7   s    rM   <lambda>zGLine.contains_implicit_multiline_string_with_comments.<locals>.<lambda>  s
    dii rN   rV   TF)	itertoolsgroupbyr1   r&   r~   listrW   comments_after)rK   	leaf_typeleaf_group_iterator	leaf_listr7   s        rM   0contains_implicit_multiline_string_with_commentsz5Line.contains_implicit_multiline_string_with_comments   s|    .7.?.?KK//
 
	 *I* ELL(01I9~"!  &&t, 
	  rN   c                     t               }	 | j                  d   }|j                  t        |             |j                  t
        j                  k(  s)|j                  t
        j                  k(  r5|j                  s)| j                  d   }|j                  t        |             d}| j                  j                         D ]-  \  }}|D ]#  }t        |      r|st        |      s||vr  yd}% / y# t        $ r Y yw xY w)Nr   r<   FT)setr1   addidr>   r&   COMMAr|   r@   rm   r2   itemsr   r   )rK   ignored_ids	last_leafcomment_seenleaf_idr2   comments          rM   $contains_uncollapsable_type_commentsz)Line.contains_uncollapsable_type_comments  s    e	BIOOByM*~~,%**,Y__ !KKO	9. !%!4!4!6 		$GX# $"7+#27;#;6##$		$ )  		s   BC1 1	C=<C=c                 F   | j                   syt        d | j                   D        d      }t        d t        | j                         D        d      }||k(  rL| j                   dd  D ]:  }| j                  j	                  t        |      g       D ]  }t        |      s  y < y)NFc              3   T   K   | ]   }|j                   d k7  s|j                    " ywr   Nlineno.0r7   s     rM   	<genexpr>z9Line.contains_unsplittable_type_ignore.<locals>.<genexpr>D  s      S4$++QRBR4;;S   ((r   c              3   T   K   | ]   }|j                   d k7  s|j                    " ywr   r   r   s     rM   r   z9Line.contains_unsplittable_type_ignore.<locals>.<genexpr>F  s     OTdkkQ>NT[[Or   r<   T)r1   nextreversedr2   getr   r   )rK   
first_line	last_linenoder   s        rM   !contains_unsplittable_type_ignorez&Line.contains_unsplittable_type_ignore3  s    {{ S4;;SUVW
OXdkk%:OQR
	 " BC( $#}}00D2> $G-g6#$$
 rN   c                 :    t        d | j                  D              S )Nc              3   2   K   | ]  }t        |        y wr   )r   r   s     rM   r   z2Line.contains_multiline_strings.<locals>.<genexpr>U  s     E&t,Es   )anyr1   rX   s    rM   contains_multiline_stringszLine.contains_multiline_stringsT  s    EEEErN   closingc                    |j                   t        v r6| j                  r*| j                  d   j                   t        j                  k(  sy|j                   t        j
                  k(  ry|j                   t        j                  k(  r|j                  |j                  j                   t        j                  k(  r|j                  yt        |j                  || j                  t        j                  t        j                  f      r8|j                  J |j                  j                   t        j                  k(  sJ yy| j                  ry|j                  "t        |j                  || j                        syy)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   FT)brackets)r>   r   r1   r&   r   RBRACERSQBparentr#   traileropening_bracketr   LSQBprev_siblingsubscriptlistr   )rK   r   s     rM   rG   zLine.has_magic_trailing_commaW  s     LL,,B$$3<<5<<'<<5::%*NN''4<<7++7+++KK#jj%**5	 ++777++00D4F4FFFF>>"".7N##Wdkk8
 rN   r   c                    |j                   t        k(  r"| j                  j                         rd|_        y|j                   t
        j                  k7  ry| j                  st        |_         d|_        y| j                  d   }|j                   t
        j                  k(  r|j                  s|j                  rtt        t        |j                  j                                     dk  rEt        |      s:t        | j                        dk  rt        |_         d|_        y| j                  d   }| j                  j                  t!        |      g       j#                  |       y)z0Add an inline or standalone comment to the line. Fr   rd   rx   r<   T)r>   r   r3   any_open_bracketsrD   r&   COMMENTr1   r|   r@   r   rW   r   r   r2   
setdefaultr   rJ   )rK   r   r   s      rM   rI   zLine.append_comment  s    LL..$$668GN<<5==({{-GLGNKKO	NNejj(OO  D))002349#G,
 4;;!#1!#BI  I3::7CrN   c                 L    | j                   j                  t        |      g       S )z;Generate comments that should appear directly after `leaf`.)r2   r   r   r   s     rM   r   zLine.comments_after  s    }}  D2..rN   c                    | j                   j                         }| j                  j                  t        |      g       }| j                  j	                  t        | j                   d         g       j                  |       y)z@Remove the trailing comma and moves the comments attached to it.r   N)r1   popr2   r   r   extend)rK   trailing_commatrailing_comma_commentss      rM   rH   zLine.remove_trailing_comma  s]    *"&--"3"3B~4F"K  DKKO!4b9@@#	
rN   c                 N   | j                   j                         }|y|j                  }t        |t              rG|j
                  t        j                  k(  ry|j
                  t        j                  k(  rt        ||      }|duxr  t        d |j                         D              S )zAReturn True iff `leaf` is part of a slice with non-trivial exprs.NFc              3   @   K   | ]  }|j                   t        v   y wr   )r>   r   )r   ns     rM   r   z,Line.is_complex_subscript.<locals>.<genexpr>  s      3
+,AFF&&3
s   )r3   get_open_lsqbnext_sibling
isinstancer(   r>   r#   	listmakerr   r   r   	pre_order)rK   r7   	open_lsqbsubscript_starts       rM   rE   zLine.is_complex_subscript  s    ((668	#00ot,##t~~5##t'9'99"/"Fd* 
s 3
0?0I0I0K3
 0
 	
rN   is_reversedc              #     K   t        t        t        t           gt        t
        t        t        f      f   |rt        nt              } || j                        D ]u  \  }}t        |j                        t        |j                        z   }d|j                  v r y| j                  |      D ]  }|t        |j                        z  } |||f w yw)zReturn an enumeration of leaves with their length.

        Stops prematurely on multiline strings and standalone comments.
        
N)r   r   r
   r'   r   r   Indexenumerate_reversed	enumerater1   rW   rD   r@   r   )rK   r   opindexr7   lengthr   s          rM   enumerate_with_lengthzLine.enumerate_with_length  s      htn%xeTk0B'CCD"-9
 dkk? 	&KE4%DJJ7Ftzz!..t4 -#gmm,,- v%%	&s   CCc                     t        | j                  | j                  | j                  | j                  | j
                        S )N)r-   r.   r4   r5   r6   )r+   r-   r.   r4   r5   r6   rX   s    rM   clonez
Line.clone  s8    ** 00!22!%!:!:
 	
rN   c                 f   | syd| j                   z  }t        | j                        }t        |      }|j                   | |j
                   }|D ]  }|t        |      z  } t        j                  j                  | j                  j                               D ]  }|t        |      z  } |dz   S )zRender the line.r   z    )r.   iterr1   r   rD   r@   strr   chainfrom_iterabler2   values)rK   indentr1   firstresr7   r   s          rM   __str__zLine.__str__  s    $**$dkk"Vvhu{{m4 	D3t9C	 44T]]5I5I5KL 	 G3w<C	  TzrN   c                 H    t        | j                  xs | j                        S )z/Return True if the line has leaves or comments.)r?   r1   r2   rX   s    rM   __bool__zLine.__bool__  s    DKK04==11rN   )FFF)r:   N)r:   r+   )=__name__
__module____qualname____doc__r   r-   r   __annotations__r.   intr   r1   r   r'   dictr2   r   LeafIDr   r3   r4   r?   r5   r6   r	   rJ   rT   propertyrR   r[   r   r    ra   rj   rq   ru   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    rN   rM   r+   r+   1   s=   EE"D$"E3Nt4FDJ4).t)DHd64:%&D&+N&KO^K!OT!"d"+/(4./ MR"%"%(,"%EI"%	"%H5 5D 5T 5( SD S S >d > > 84 8 8 ID I I 
$ 
 
 
t 
 
 
 
 
$ 
T 
 
 
d 
 
 	$ 	 	 Fd F F Jt J J 3T 3 3 IM
%-hvt|.D%E
	
(d $ "d "H4 BFD F* * *X#d #t #J/4 /DJ /

 
$ 
( #(&&	%tS()	*&*
  2$ 2rN   r+   c                   D    e Zd ZU dZeed<   eed<   eed<   eed<   eed<   y)	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    s     <
J
J
J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y)
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_feedr:   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  )rK   
empty_linerD   s      rM   	all_lineszLinesBlock.all_lines  sO    499-.
#DKKLx$,,,
TZZ0G/HHHrN   N)r   r   r   r   r   r   r	   r+   r  r   r   r   r  r   r   r  r  r?   r  r  rN   rM   r	  r	    s`     J\**FCO$T:M49:E3NItI49 IrN   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y)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_liner:   c                 r   |j                   dk(  xr2 t        |j                        xr d|j                  d   j                  v }| j	                  |      \  }}| j
                  r| j
                  j                  nd}t        d||z
        }| j
                  r|| j
                  j
                  ft        | j
                  j                  j                        dk(  r:| j
                  j                  j                  r|j                  s|j                  sd}t        | j                  | j
                  ||||      }|j                  rP| j                   <| j                   j"                  sC| 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
NrV   )r-   r
  r  r  r  r  )r.   r?   r1   rD   _maybe_empty_linesr
  r  maxrW   r  r   ra   rq   r	  r-   rR   r  r[   r  )rK   r  r  r  r  previous_afterblocks          rM   maybe_empty_linesz"EmptyLineTracker.maybe_empty_lines+  s    !# 8\(()8,--a0777 	
 //=6:6I6I,,22qQ/0 ##22:D''55<<=B##11>>!**l.A.AF..&
 ""!!)&&33++66&22:f05-**f,0D))#rN   c                    d}|j                   dk(  r| j                  j                  rdnd}|j                  r>|j                  d   }|j                  j                  d      }t        ||      }d|_        nd}t        |      }|j                   }d }| j                  r_| j                  d   j                   |k\  rC| j                  j                         }| j                  r| j                  d   j                   |k\  rC|j                  s|j                  r| j                  j                  |       | j                  y|j                  rD| j                  j                  ry| j                  j                  r| j                  j                  ry|| j                  J | j                  j                  rN|j                  r|j                   sd}n|r)|j                  s| j                  j                  r|rdnd}ne|rd}n`d}n]|rd}nX|sT|j                   rH|j                  d   j"                  t$        j&                  k(  r|j                  d   j(                  d	vrd}nd}|j*                  s|j                  s|j                  r| j-                  |||      S | j                  j.                  rC|j.                  s7|j1                  t.        
      s!|| j                  j                   k(  r|xs ddfS |dfS )NrV   r   rx   r   r   r   r   r   r   rV   )withtryforwhileifmatchr   )r.   r-   is_pyir1   rD   r   minr?   r  r   rq   ra   rJ   r  r   r   rj   r>   r&   rB   r@   r[   #_maybe_empty_lines_for_class_or_defr   r   )rK   r  max_allowedro   r  user_had_newliner.   previous_defs           rM   r  z#EmptyLineTracker._maybe_empty_lines]  s   "#yy//!QK%,,Q/J&&,,T2F-F "JF<""   T%7%7%;%A%AU%J--113L   T%7%7%;%A%AU%J,"7"7%%l3%$$!!**!!--$2D2D2K2K#%%111yy((1K1KF<#6#64;M;M;T;T"2QFFFF$**$++B/44C$++A.44MN FF$$(;(;|?T?T;;f&6 
 (( ** 66)6T++111Ka!##qyrN   r  r,  c                    | j                   J | j                   j                  r$| j                  j                  r|j                  ryy| j                   j
                  |j
                  k  rM| j                   j                  s| j                   j                  r!| j                  j                  ry|rddfS ddfS d }| j                   j                  r| j                   j
                  |j
                  k(  rr|dk(  rm| j                  }|^|j                  R|j                  j                  j                  s2|j                  j                  j                  s|j                  dk  r|}ny| j                  j                  r	|j                  s| j                   j                  rt| j                   j
                  |j
                  k  rd}n| j                   j
                  |j
                  kD  rd}n|j                  r| j                   j                  rd}nd}n| j                   j
                  |j
                  kD  rd}nw|j                  s|j                  r2| j                   j                  s|j
                  rt        d|      }n0d}n-d}n*|j
                  rdnd}| j                   j                  r|sd}|8|j                  }|*t!        |j                  |      |j"                  z
  |_        d}|dfS )Nr!  r   rV   r   rx   )r  r[   r-   r(  rj   r.   ra   rq   rR   r  r
  r  r   r  r)  ru   r  r  )rK   r  r  r,  comment_to_add_newlinesslcnewlinesr
  s           rM   r*  z4EmptyLineTracker._maybe_empty_lines_for_class_or_def  s    !!---**yyL$>$>##l&8&88''4+=+=+D+Dyy(122a228<))""((L,>,>>!//C&&2**88AA**88DDJJ!O*-'99$$(:(:(C(C%%++l.@.@@ H''--0B0BB H!//D4F4F4T4T H H ##))L,>,>>##|'@'@((//%%  #1f~H  !H(..qAH !!--6F".4CCN)/66ANDXDXX (. {rN   )r   r   r   r   r   r   r  r	   r+   r
  r	  r   r   r  r   r  r  r   r   r  r?   r*  r  rN   rM   r  r    s     J$(M8D>(+/NHZ(/ %d ;M4:;59hz290d 0z 0dRt Rc3h RhN N*-NAEN	sCxNrN   r  sequencer:   c              #   ^   K   t        |       dz
  }t        |       D ]  }||f |dz  } yw)z;Like `reversed(enumerate(sequence))` if that were possible.rV   N)rW   r   )r2  r   elements      rM   r   r     s<     MAEH% g
s   +-new_lineold_liner1   r8   c                     |D ]j  }t        |j                  |j                        }t        ||       | j	                  ||       |j                  |      D ]  }| j	                  |d        l y)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   )r5  r6  r1   r8   old_leafnew_leafcomment_leafs          rM   append_leavesr;  
  sk      =x~~6h)|<$33H= 	=LOOLtO<	==rN   r   )line_strliner-   r<  c                   |st        |       }t        j                  |vr1t        |      |j                  k  xr d|vxr | j                          S | j                         ryd|vrt        |      |j                  k  S |j                  d      ^}}}t        |      |j                  kD  st        |      |j                  kD  ryg }d}g }t        j                  }	t        | j                        D ]  \  }
}|	t        j                  k(  rd}|j                  dz   t        |      kD  r|j                  d       n+|j                  dz   t        |      k  r|j                         }|1|/|j                  |j                  dz   k(  r|j                  }	|dkD  r y|j                  |	k  re|j                  t         j"                  k(  rHdg}||z  }|j$                  |v r|
t        | j                        dz
  k(  s||j                  xx   dz  cc<   |	t        j                  k7  rt'        |	|j                        }	t)        |      sQt        |      dkD  r y|}|}t+        |      |v st|j                  |       |j,                  |j,                  }t+        |      |v r9 t        |      dk(  ryt/        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   FNrV   r   Tc              3   &   K   | ]	  }|d k(    ywr   r  )r   vals     rM   r   z'is_line_short_enough.<locals>.<genexpr>x  s     *Csax*s   )line_to_stringr   multiline_string_handlingr%   line_lengthr   splitmathinfr   r1   bracket_depthrW   rJ   r   r>   r&   r   r   r)  r   r   r   all)r=  r-   r<  r   ri   lastcommasmultiline_stringmultiline_string_contextsmax_level_to_updateir7   	had_commaignore_ctxsctxs                  rM   is_line_short_enoughrR  "  s    !$'((4h4#3#33 8H$85577	
 ((*8"d&6&666nnT*OEAt$***io@P@P.P F'+*,-1XXT[[) '!4$((*'+I!!A%F3a ##a'#f+5"JJL	%$0$22d6H6H16LL '+&8&8#q= !44ekk9Q 04fK44K%%4c$++>NQR>R9Rt))*a/*$((*"%&94;M;M"Nt$,-1#Cc(h&)005::%jj	 c(h&G'!V $%**6***rN   c                 b   | j                   }t        |      dk  ry|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 y|dz  }n|j                  t        j
                  k(  r|dz  }nb|j                  t        j                  k(  r1|j                  t        j
                  k(  s(|j                  t        v s y|j                  t        vr y|dkD  s|dkD  s y y)	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).
    rx   Fr   rV   r   r<   NT)	r1   rW   r>   r&   r~   rg   r   r   r`   )r=  r1   
call_count	dot_countr   r7   s         rM   can_be_splitrV  {  s    [[F
6{Qay~~%&)..EII*E
	bz26r6N 	Dyy,,99$44 a
eii'Q	ejj(		UYY.$))?O2O "221}a!	$ rN   rhsrC  c                    | j                   }d}t        |j                        D ]i  }|r||j                  u rd}|j                  t
        k(  r|s y|r/|j                  t        v sB|j                  |j                  v s[|j                  sh|}k |j                  }|j                  sy|j                         }|j                  |      }|dkD  ry|dk(  r |t        k(  r| j                  j                  ry|t        k(  ryt!        |j                        dk\  sJ d       |j                  d   }|j                  d   }	|j                  t"        v r!|	j                  t        vrt%        |||      ry|j                  d	   }
|j                  d
   }|j                  t&        j(                  k(  sm|j                  t&        j*                  k(  sP|j                  t&        j,                  k(  ra|j.                  rU|j.                  j                  t0        j2                  k7  r.|
j                  t"        v ryt5        |      ryt7        |||      ryy)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.
    NFTrV   rx   zStranded delimiterr   )r   rC  r<   r   )rI  rC  )r  r   r1   r   r>   r   r   r@   r3   
delimitersmax_delimiter_prioritydelimiter_count_with_priorityr   r  r    r   rW   r   _can_omit_opening_parenr&   r|   r   r   r   r#   r   r   _can_omit_closing_paren)rW  rC  r=  r  r7   btmax_prioritydelimiter_countr   secondpenultimaterI  s               rM   can_omit_invisible_parensrc    s    88D '+O% #t'F'FF"O99**?		--$$3

"O# 
		B==,,.L66|DO!>)chh.Q.Q
 
 |#t{{q 6"66  KKNE[[^Fzz%%&++=M*M"4u+N ++b/K;;r?D 			UZZ99$ II#  DLL0 //u% "4dLrN   r   c                    d}d| j                   z  }d}| j                         D ]L  \  }}}|j                  t        v r|j                  |u rd}|s,||z  }||kD  r y|j                  t
        v sKd}N t        | j                        |dz   k(  ryy) See `can_omit_invisible_parens`.Frw   r   TrV   )r.   r   r>   r   r   r   rW   r1   )r=  r   rC  	remainderr   _indexr7   leaf_lengths           rM   r\  r\     s    I^FF%)%?%?%A !k99((T-A-AU-JIk!F#  yy,,!	 t{{vz)rN   rI  c                    d| j                   z  }d}| j                         D ]8  \  }}}||z  }||j                  u r
|s||k  s" y|j                  t        v s7d}: y)re  rw   FT)r.   r   r   r>   r   )r=  rI  rC  r   seen_other_bracketsrg  r7   rh  s           rM   r]  r]    sq    ^F%)%?%?%A '!k+4'''"f&;YY**"&' rN   c                 6    t        |       j                  d      S )zmReturns the string representation of @line.

    WARNING: This is known to be computationally expensive.
    r   )r   rA   )r=  s    rM   rA  rA  *  s    
 t9??4  rN   r   )Cr   rE  dataclassesr   r   typingr   r   r   r   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   rR  rV  rc  r\  r]  rA  r  rN   rM   <module>ru     s     (   H G $    & $   & CL	
4: E2 E2 E2P    I I I* c c cL! %q/1J  NS=="=,0J=FJ=	=2 02V+
V+V+),V+	V+r!t ! !H^	^^ 
^B$ $ S T 2$  C D "! !# !rN   