
    mi1                       d Z ddlZddlZddlmZmZ ddlmZ ddlm	Z	m
Z
 ddlmZmZ ddlmZmZ ddlmZmZmZmZmZ dd	lmZmZmZmZmZ dd
lmZmZm Z m!Z!m"Z"m#Z#m$Z$ ddl%m&Z&m'Z'm(Z( ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZN ddlOmPZP ddlQmRZRmSZSmTZTmUZUmVZV ddlWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ ddl_m`Z` ddlambZbmcZc edZeeebecf         Zf G d deX          Zg G d de1e                   Zhdedee&         de'deidz  fdZj	 dUdede'dee&         dee         fdZkdede'delfdZm G d de	          Znded ee&         de'dee         fd!Zo	 	 dVdede'dee&         d"eee         dee         f
d#Zp	 dUded"eee         defd$Zq	 	 dVd%edede'dee&         d"eee         dee         fd&Zrd'ed%ede'delfd(Zsd)ed*ed+eddfd,Ztd-eueb         d.ed/ebdelfd0Zvd-eueb         d.ed/ebd1endef
d2Zwd3e]de]fd4Zxdededdz  fd5Zyd6ebdee&         delfd7Zzd8eld9eddedefd:Z{eehZ|exdedee&         de'dee         fd;            Z}exdedee&         de'dee         fd<            Z~d=ecd>eei         de'dee&         ddf
d?Zd@ecdAefdBedddfdCZd=ecde'dee&         ddfdDZd=ecde'dee&         ddfdEZd=ecd@ecde'dee&         ddf
dFZd=efde'delfdGZd=efdelfdHZ	 	 dWd=efd@efde'dee&         dJeldKeldelfdLZded/ebdelfdMZdedNeddeeee                  fdOZdPdQdedRe]de'dee&         dSeideue         fdTZdS )Xz
Generating lines of code.
    N)
CollectionIterator)replace)Enumauto)partialwraps)Unioncast)COMMA_PRIORITYDOT_PRIORITYSTRING_PRIORITY#get_leaves_inside_matching_bracketsmax_delimiter_priority_in_atom)FMT_OFFFMT_ONcontains_fmt_directivegenerate_commentslist_comments)Line	RHSResultappend_leavescan_be_splitcan_omit_invisible_parensis_line_short_enoughline_to_string)FeatureModePreview)%ASSIGNMENTSBRACKETSCLOSING_BRACKETSOPENING_BRACKETSSTANDALONE_COMMENT	STATEMENT
WHITESPACEVisitorensure_visiblefstring_tstring_to_stringget_annotation_typehas_sibling_with_typeis_arith_likeis_async_stmt_or_funcdefis_atom_with_invisible_parensis_docstringis_empty_tupleis_generatoris_lpar_tokenis_multiline_stringis_name_tokenis_one_sequence_betweenis_one_tupleis_parent_function_or_classis_part_of_annotationis_rpar_tokenis_stub_bodyis_stub_suiteis_tupleis_tuple_containing_staris_tuple_containing_walrusis_type_ignore_comment_string	is_varargis_walrus_assignmentis_yieldsymswrap_in_parentheses)normalize_numeric_literal)fix_multiline_docstringget_string_prefixnormalize_string_prefixnormalize_string_quotes"normalize_unicode_escape_sequences)CannotTransformStringMergerStringParenStripperStringParenWrapperStringSplitterTransformerhug_power_op)token)LeafNodec                       e Zd ZdZdS )CannotSplitzBA readable split that fits the allotted line length is impossible.N)__name__
__module____qualname____doc__     e/var/www/html/bestrading.cuttalo.com/scripts/kaggle-env/lib/python3.11/site-packages/black/linegen.pyrV   rV   e   s        LLLLr\   rV   c            	           e Zd ZdZdedee         ddfdZd+dede	e
         fd	Zd
ede	e
         f fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
edee         dee         de	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZd
ede	e
         fdZ dede	e
         fdZ!dede	e
         fdZ"dede	e
         fd Z#d
ede	e
         fd!Z$d
ede	e
         fd"Z%dede	e
         fd#Z&dede	e
         fd$Z'd
ede	e
         fd%Z(d
ede	e
         fd&Z)d
ede	e
         fd'Z*d
ede	e
         fd(Z+d
ede	e
         fd)Z,d,d*Z- xZ.S )-LineGeneratorzGenerates reformatted Line objects.  Empty lines are not emitted.

    Note: destroys the tree it's visiting by mutating prefixes of its leaves
    in ways that will no longer stringify to valid Python code on the tree.
    modefeaturesreturnNc                 N    || _         || _        |  |                                  d S N)r`   ra   __post_init__)selfr`   ra   s      r]   __init__zLineGenerator.__init__r   s.    	 r\   r   indentc              #     K   | j         s| j         xj        |z  c_        dS t          | j         j                  dk    r!t	          | j         j        d                   rdS | j         }t          | j        |j        |z             | _         |V  dS )zGenerate a line.

        If the line is empty, only emit if it makes sense.
        If the line is too long, split it first and then generate.

        If any lines were generated, set up a new current_line.
        N   r   r`   depth)current_linerl   lenleavesr-   r   r`   )rf   rh   complete_lines      r]   linezLineGenerator.linex   s         	##v-##Ft '((A--2J$Q'3
 3
- F) di}7JV7STTTr\   nodec              #     K   t          |t                    r| j        j                                        }t          || j                  D ]}|r| j                            |           |j        t          j
        k    r5| j                            |           |                                 E d{V  i|                                 E d{V  | j                            |           |                                 E d{V  |rd|_        |j        t          vr| j                            |           t                                          |          E d{V  dS )zCDefault `visit_*()` implementation. Recurses to children of `node`.r`   N )
isinstancerS   rm   bracket_trackerany_open_bracketsr   r`   appendtyperR   COMMENTrq   prefixr&   supervisit_default)rf   rr   rx   comment	__class__s       r]   r~   zLineGenerator.visit_default   sy     dD!! 	/ $ 1 A S S U U,T	BBB + +$ +%,,W5555\U]22%,,W555#yy{{********  $yy{{*******%,,W555#yy{{********  ! y
**!((...77((...........r\   c              #   n  K   |j         o|j         j        t          j        k    }|stt	          t          j        d          }t	          t          j        d          }|j        }d|_        ||_        |                    d|           |                    |           | 	                    |          E d{V  dS )zVisit an `x if y else z` testru   r   N)
prev_siblingrz   rR   LPARrS   RPARr|   insert_childappend_childr~   )rf   rr   already_parenthesizedlparrparr|   s         r]   
visit_testzLineGenerator.visit_test   s       F$"3"8EJ"F 	 % 	$
B''D
B''D[FDK DKa&&&d###%%d+++++++++++r\   c              #   v   K   |                      d          E d{V  |                     |          E d{V  dS )z/Increase indentation level, maybe yield a line.rj   Nrq   r~   rf   rr   s     r]   visit_INDENTzLineGenerator.visit_INDENT   sV       99R==       %%d+++++++++++r\   c              #      K   |                                  E d{V  |                     |          E d{V  |                      d          E d{V  dS )z/Decrease indentation level, maybe yield a line.Nr   r   s     r]   visit_DEDENTzLineGenerator.visit_DEDENT   sz      
 99;; %%d+++++++++ 99R==         r\   keywordsparensc              #      K   t          ||| j        | j                   |j        D ]O}t	          |          r#|j        |v r|                                 E d{V  |                     |          E d{V  PdS )a  Visit a statement.

        This implementation is shared for `if`, `while`, `for`, `try`, `except`,
        `def`, `with`, `class`, `assert`, and assignments.

        The relevant Python language `keywords` for a given statement will be
        NAME leaves within it. This methods puts those on a separate line.

        `parens` holds a set of string leaf values immediately after which
        invisible parens should be put.
        parens_afterr`   ra   N)normalize_invisible_parensr`   ra   childrenr4   valuerq   visit)rf   rr   r   r   childs        r]   
visit_stmtzLineGenerator.visit_stmt   s       	#vDI	
 	
 	
 	
 ] 	) 	)EU## 'x(?(?99;;&&&&&&&zz%((((((((((		) 	)r\   c              #   d   K   |                      |          E d {V  d|j        d         _        d S Nru   r   r~   r   r|   r   s     r]   visit_typeparamszLineGenerator.visit_typeparams   A      %%d+++++++++"$ar\   c              #   d   K   |                      |          E d {V  d|j        d         _        d S Nru   rj   r   r   s     r]   visit_typevartuplez LineGenerator.visit_typevartuple   r   r\   c              #   d   K   |                      |          E d {V  d|j        d         _        d S r   r   r   s     r]   visit_paramspeczLineGenerator.visit_paramspec   r   r\   c              #     K   t           j        | j        v rt          |j                  D ]\  }}|dk    r|j        |dz
           j        t          j        k    rn|j        t          j	        k    rG|j        d         j        t          v r.t          |          st          ||| j        | j        d           t          ||d           |                     |          E d {V  d S )Nr   rj   Fparentr`   ra   remove_brackets_around_commavisible)r   wrap_long_dict_values_in_parensr`   	enumerater   rz   rR   COLONrC   atomr#   rA   #maybe_make_parens_invisible_in_atomra   rD   r~   )rf   rr   ir   s       r]   visit_dictsetmakerz LineGenerator.visit_dictsetmaker   s     2di??%dm44 H H566=Q',;;
di//!N1-26FFF 4U ; ; G <!#'!%%)]9>     ,D%GGGG%%d+++++++++++r\   c              #     K   |                                  E d{V  d}|j        D ]}|j        t          j        k    rd}|rz|j        t
          j        k    rQ|j        d         j        t          j        k    r1t          ||| j	        | j
        d          rt          ||d           nt          ||d           d}|j        D ]}|                     |          E d{V  dS )zVisit function definition.NFTr   r   r   )rq   r   rz   rR   RARROWrC   r   r   r   r`   ra   rD   r   )rf   rr   is_return_annotationr   s       r]   visit_funcdefzLineGenerator.visit_funcdef  s%     99;;  %] 	- 	-EzU\))'+$$% -:**u~a/@/E/S/S:#!Y!%5:   H ,D%GGGG'eUCCCC',$] 	) 	)Ezz%((((((((((	) 	)r\   c              #      K   t          |t                      | j        | j                   |                                 E d{V  |j        D ]}|                     |          E d{V  dS )z'Visit either a match or case statement.r   N)r   setr`   ra   rq   r   r   rf   rr   r   s      r]   visit_match_casezLineGenerator.visit_match_case%  s      "suu49t}	
 	
 	
 	
 99;;] 	) 	)Ezz%((((((((((	) 	)r\   c              #      K   t          |          r(|                     |j        d                   E d{V  dS |                     |          E d{V  dS )zVisit a suite.   N)r;   r   r   r~   r   s     r]   visit_suitezLineGenerator.visit_suite/  ss       	0zz$-"233333333333))$///////////r\   c              #     K   d}|j         D ]<}||t          j        k    r!t          |          rt	          ||d           |j        }=|j        r|j        j        t          v rt          |          r,t          |          r| 
                    |          E d{V  dS |                     d          E d{V  | 
                    |          E d{V  |                     d          E d{V  dS |j        r8t          |j                  r$d|_        | 
                    |          E d{V  dS |                                 E d{V  | 
                    |          E d{V  dS )z,Visit a statement without nested statements.NFr   rj   r   ru   )r   rR   SEMIr,   rD   rz   r   r%   r7   r:   r~   rq   r;   r|   )rf   rr   	prev_typer   s       r]   visit_simple_stmtzLineGenerator.visit_simple_stmt6  s      $	] 	# 	#E!Y%*%<%<-PUBVBV%<#D%????
II; 	04;+y88*400 )\$5G5G )--d3333333333399R==(((((((--d33333333399R==((((((((( { }T[99  --d333333333yy{{"""""""))$///////////r\   c              #   H  K   |                                  E d{V  t          |j                  }|D ]D}|                     |          E d{V  |j        t
          j        k    s|j        t          k    r nEt          |          }|                     |          E d{V  dS )z-Visit `async def`, `async for`, `async with`.N)	rq   iterr   r   rz   rR   ASYNCr$   next)rf   rr   r   r   internal_stmts        r]   visit_async_stmtzLineGenerator.visit_async_stmtN  s      99;;&& 	 	Ezz%(((((((((zU[((EJ:L,L,L  -M
 X::m,,,,,,,,,,,r\   c              #      K   |j         D ]7}|                                 E d{V  |                     |          E d{V  8dS )zVisit decorators.N)r   rq   r   r   s      r]   visit_decoratorszLineGenerator.visit_decorators^  sh      ] 	) 	)Eyy{{"""""""zz%((((((((((	) 	)r\   c              #      K   t          |j        d d                   D ]\  }}|j        |dz            }t          |t                    s+|j                                        }|j        t          j        k    r^|j        t          j
        k    rI|j        d         j        t          j        k    r)|                    d          sd|vrt          ||           t          || j        | j                   |                     |          E d {V  d S )Nr   rj   r   )0x0b0ojr`   ra   )r   r   rv   rS   r   lowerrz   rR   NUMBERrC   trailerDOT
startswithrD   remove_await_parensr`   ra   r~   )rf   rr   idxleaf	next_leafr   s         r]   visit_powerzLineGenerator.visit_powerd  s     "4="#566 	0 	0ICcAg.IdD)) J$$&&E	U\))Ndl22&q).%);;(();<< < u$$#D$///Dty4=IIII%%d+++++++++++r\   r   c              #   >   K   |                                  E d{V  dS )zBRemove a semicolon and put the other statement on a separate line.N)rq   rf   r   s     r]   
visit_SEMIzLineGenerator.visit_SEMI|  s,      99;;r\   c              #   t   K   |                      |          E d{V  |                                 E d{V  dS )zAEnd of file. Process outstanding comments and end with a newline.N)r~   rq   r   s     r]   visit_ENDMARKERzLineGenerator.visit_ENDMARKER  sR      %%d+++++++++99;;r\   c              #   @  K   | j         j                                        }|s|                                 E d {V  |j        }|                                }t          |          dk    o5t          |d         t                    ot          |d         t                    }|r|j
        rt          d |j
                            d          D                       rnt          || j                  D ]P}|                                 E d {V  | j                             |           |                                 E d {V  Qd|_
        | j                             |           |s|                                 E d {V  d S d S |                     |          E d {V  d S )Nr   r   r   c              3      K   | ]M}|                                                     d           o!t          |                                            V  NdS )#N)stripr   r   ).0rq   s     r]   	<genexpr>z9LineGenerator.visit_STANDALONE_COMMENT.<locals>.<genexpr>  si       # #  

'',, =.tzz||<<<# # # # # #r\   
rt   ru   )rm   rw   rx   rq   r   
splitlinesrn   r   r   r   r|   anysplitr   r`   ry   r~   )rf   r   rx   r   linesis_fmt_off_blockr   s          r]   visit_STANDALONE_COMMENTz&LineGenerator.visit_STANDALONE_COMMENT  s      -=OOQQ  	#yy{{""""""" 
  ""JJ!O :&uQx99:&uRy&99 	
  	0 { 
!s # # !K--d33# # #     
!
  1DIFFF + +G#yy{{*******%,,W555#yy{{******** $$T***$ '99;;&&&&&&&&&' ' ))$///////////r\   c           	   #     K   |j         \  }}|j        t          j        k    rt	          |j                   dk    r|j         d         j        t
          j        k    r{t          t
          j        d          }t          t
          j	        d          }|
                                pd}|                    |t          t          j        |||g                     |                     |          E d{V  dS )z_Force parentheses between a unary op and a binary power:

        -2 ** 8 -> -(2 ** 8)
           rj   ()r   N)r   rz   rC   powerrn   rR   
DOUBLESTARrS   r   r   remover   rT   r   r~   )rf   rr   	_operatoroperandr   r   indexs          r]   visit_factorzLineGenerator.visit_factor  s      
 "]	7LDJ&&G$%%** #(E,<<<
C((D
C((DNN$$)EeT$)dGT5J%K%KLLL%%d+++++++++++r\   c              #      K   t          |j                  dk    rEt          |j        d         || j        | j                  rt          ||j        d         d           |                     |          E d{V  dS )a)  
        Add potential parentheses around types in function parameter lists to be made
        into real parentheses in case the type hint is too long to fit on a line
        Examples:
        def foo(a: int, b: float = 7): ...

        ->

        def foo(a: (int), b: (float) = 7): ...
        r   r   r   r`   ra   Fr   N)rn   r   r   r`   ra   rD   r~   r   s     r]   visit_tnamezLineGenerator.visit_tname  s       t}""'JM!T	DM(
 (
 (
"  dmA&6FFFF%%d+++++++++++r\   c              #     K   t          |           t          |          r3t          j        d|j                  s| j        j        r$t          |j                  }t          |          }n|j        }t          |          }|t          |          d          }|d         }|d         |k    rdnd}|||          }| }d| j        j        z  }t          |          rt          ||          }n|                                }d}|rm|d         |k    rd|z   }|d         |k    r|dz  }|d         d	k    r>t          |          t          |                    d	                    z
  }	|	d
z  r|dz  }d}n|sd}||z  }
|dk    r|                                }|rt          |d                   nd}t          |          dk    rq||z   | j        j        k    r^t          |          |z   | j        j        k    r>|s<|j        d|z
           dk    r||
z   |z   |
z   |_        n8||
z   |z   dz   |z   |
z   |_        n!||
z   |z   |
z   |_        n||
z   |z   |
z   |_        | j        j        rG|j        t(          j        k    r2t          |j                  |_        t          |j                  |_        |                     |          E d {V  d S )Nz\\\s*\nr   rj   r   z    F r   \r   Tr   )rJ   r/   researchr   r`   string_normalizationrH   rI   rG   rn   rm   rl   r3   rF   r   rstripr   line_lengthrz   rR   STRINGr~   )rf   r   	docstringr|   
quote_char	quote_lendocstring_started_emptyrh   has_trailing_backslashbackslash_countquoter   last_line_lengths                r]   visit_STRINGzLineGenerator.visit_STRING  s#     *4000 N	@bi
DJ&G&G N	@ y- 	'3DJ??	 4I>>		 J	&y11F!#f++--0I"1J 'q\Z77QI!)YJ"67I*3m#t066F"4(( .3IvFF		%OO--	%*"  Q<:-- #iIR=J..$IR=D((&))nns9;K;KD;Q;Q7R7R&RO&* 6 "S(	15.,  	 *E A~~ ",,..5>#E3uRy>>>A  JJNN(94ty7LLLFi/493HHH2 I z"y.1T99%+e^i%?%%G

%+e^i%?$%F%ORW%W

!'%)!;e!CDJJ#e^i7%?
9) 	=di5<.G.G0<<DJ0<<DJ%%d+++++++++++r\   c              #   ^   K   t          |           |                     |          E d {V  d S rd   )rE   r~   r   s     r]   visit_NUMBERzLineGenerator.visit_NUMBER+  s@      !$'''%%d+++++++++++r\   c              #     K   t          |j                  dk    r|j        d         }|j        d         }|j        t          j        k    r|j        t          j        k    s*|j        t          j        k    r=|j        t          j        k    r(t          |j        d         || j	        | j
                   |                     |          E d{V  dS )zVisit any atomr   r   r   rj   r   N)rn   r   rz   rR   LSQBRSQBLBRACERBRACEr   r`   ra   r~   )rf   rr   firstlasts       r]   
visit_atomzLineGenerator.visit_atom/  s      t}""M!$E=$D
ej((TY%*-D-D
el**tyEL/H/H 4M!$!]	    %%d+++++++++++r\   c              #     K   t          |          }|                    |           d|j        v r;t          d |j        D                       r|                     |          E d {V  d S |                     |          E d {V  d S )Nr   c              3   b   K   | ]*}|j         t          j        k    d t          |          v V  +dS r   Nrz   rC   fstring_replacement_fieldstrr   r   s     r]   r   z.LineGenerator.visit_fstring.<locals>.<genexpr>E  I       -
 -
zT;;; CJJ;;;;-
 -
r\   r)   r   r   r   r   r~   r  rf   rr   string_leafs      r]   visit_fstringzLineGenerator.visit_fstringA        /55[!!!;$$$ -
 -
-
 -
 -
 *
 *
$ ))+666666666F$$[11111111111r\   c              #     K   t          |          }|                    |           d|j        v r;t          d |j        D                       r|                     |          E d {V  d S |                     |          E d {V  d S )Nr   c              3   b   K   | ]*}|j         t          j        k    d t          |          v V  +dS r  r  r  s     r]   r   z.LineGenerator.visit_tstring.<locals>.<genexpr>T  r  r\   r  r   s      r]   visit_tstringzLineGenerator.visit_tstringP  r#  r\   c              #      K   t           j        | j        v rt          |dh| j        | j                   |                     |          E d {V  d S )Ninr   )r   wrap_comprehension_inr`   r   ra   r~   r   s     r]   visit_comp_forzLineGenerator.visit_comp_for  sj      (DI55&D6	DM    %%d+++++++++++r\   c              #   @   K   |                      |          E d {V  d S rd   )r*  r   s     r]   visit_old_comp_forz LineGenerator.visit_old_comp_for  s2      &&t,,,,,,,,,,,r\   c                 X   t          | j                  | _        | j        }t	                      }t          |dhddh          | _        t          |h dddh          | _        t          |dd	hdh          | _        t          |d
d	hd
dh          | _	        t          |h d|          | _
        t          |dhdh          | _        t          |dhdh          | _        t          |dh|          | _        t          ||t                    | _        t          |dhdh          | _        t          ||dh          | _        t          ||dh          | _        | j        | _        | j        | _        | j        | _        | j        | _        t          ||dh          | _        dS )z,You are in a twisty little maze of passages.rt   assert,)r   r   >   ifelifelser0  r1  whiler2  forr(  >   tryr2  exceptfinallyr6  withclassrb   importdelN)r   r`   rm   r   r   r   visit_assert_stmtvisit_if_stmtvisit_while_stmtvisit_for_stmtvisit_try_stmtvisit_except_clausevisit_with_stmtvisit_classdefr    visit_expr_stmtvisit_return_stmtvisit_import_fromvisit_del_stmtr   visit_async_funcdefr   visit_decoratedr   visit_match_stmtvisit_case_blockvisit_guard)rf   v   Øs      r]   re   zLineGenerator.__post_init__  s    di000Ouu!(hZSV!X!X!X$...f~
 
 
 !(Wf4Ewi X X X%a5&/5RV-XXX%<<<R
 
 
 $+1z8*#U#U#U &qF8VHMMM%a7)BGGG&q2kJJJ!(hZ
!S!S!S!(R
!K!K!K%a"eWEEE#'#8 #4 !% 5 $ 5"1r4&AAAr\   )r   )rb   N)/rW   rX   rY   rZ   r   r   r   rg   intr   r   rq   LNr~   rT   r   rS   r   r   r   r  r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r"  r&  r*  r,  re   __classcell__)r   s   @r]   r_   r_   k   s        T Z-@ T     3 x~    2/" /$ / / / / / /4,t , , , , ,&, ,(4. , , , ,! !(4. ! ! ! !))$'H)69#h)	$) ) ) ).%T %htn % % % %%t % % % % %%D %Xd^ % % % %,t , , , , ,,)$ )8D> ) ) ) )4)T )htn ) ) ) )0 0$ 0 0 0 00d 0x~ 0 0 0 00-T -htn - - - - )T )htn ) ) ) ), ,$ , , , ,0t     D Xd^    
)0T )0htn )0 )0 )0 )0V, ,(4. , , , ,", ,$ , , , ,$V, V,(4. V, V, V, V,p, ,(4. , , , ,,t , , , , ,$2$ 28D> 2 2 2 22$ 28D> 2 2 2 2`,4 ,HTN , , , ,-t - - - - -B B B B B B B Br\   r_   rq   ra   r`   rb   c           	      |    	 t          t          t          | ||                              S # t          $ r Y d S w xY wrd   )r   r   rQ   rK   )rq   ra   r`   s      r]   !_hugging_power_ops_line_to_stringrS    sK    
d<h#E#EFFGGG   tts   *- 
;;r[   c              #   H  K   | j         r| V  dS t          |           }t          | ||          p|}|j        }|j        }t          ||          }t          ||          }t          ||          }	t          ||          }
| 	                                sy| j
        sr| j        skt          | ||          s|                                 rE| j        r|                                 s*|                                 st"          j        |v r||g}ng }n| j        rt)          | |          s	t*          g}ndt,          dt.          dt0          t2                   dt4          dt6          t.                   f
d} t9          d	d
d|i                      }t"          j        |v r#| j        r|||	t:          t<          |
|g}n"|||	|
|g}n| j        rt:          t<          |g}n|g}|                    t@                     |D ]1}	 tC          | ||||          }|E d{V   dS # tD          $ r Y .w xY w| V  dS )zTransform a `line`, potentially splitting it into many lines.

    They should fit in the allotted `line_length` but might not be able to.

    `features` are syntactical features that may be used in the output.
    N)r`   line_strrf   rq   ra   r`   rb   c           	   3      K   t          ||j                  D ]D}t          t          ||||                    }t	          |d         |          r|E d{V   dS Et          |||          E d{V  dS )zWraps calls to `right_hand_split`.

            The calls increasingly `omit` right-hand trailers (bracket pairs with
            content), meaning the trailers get glued together to split on another
            bracket pair instead.
            omitr   rt   N)ra   )generate_trailers_to_omitr  listright_hand_splitr   )rf   rq   ra   r`   rX  r   s         r]   _rhsztransform_line.<locals>._rhs  s       2$8HII  -dD(NNNOO
 (at<<< $$$$$$$$FF (dXFFFFFFFFFFFFr\   rhsr[   __call__rU  )#
is_commentr   rS  r  r   rL   rM   rO   rN   $contains_uncollapsable_type_commentsshould_split_rhsmagic_trailing_commar   !contains_unsplittable_type_ignoreinside_bracketscontains_standalone_comments0contains_implicit_multiline_string_with_commentsr   string_processingis_defshould_split_funcdef_with_rhsleft_hand_splitobjectr   r   r   r   r   rz   delimiter_splitstandalone_comment_splitry   rQ   run_transformerrK   )rq   r`   ra   rU  line_str_hugging_power_opsllsnstring_mergestring_paren_stripstring_splitstring_paren_wraptransformersr\  r]  	transformresults                   r]   transform_linerz    s       


d##H
 	*$$??K8  
	B		"BB''L,R44!"b))L*2r22 5577J%%J% )J%
 !D;UVVVJ% 5577J% %J% +/*K*K*M*MJ% EEGGJ% $,,(*<=LLLL	 :%:4FF :%'(	G	G $	G0:70C	GKO	Gd^	G 	G 	G 	G: 2d5"z401133$,,#  & #,%  !& %  # % /1I3O #u %%%!  		$T9dHxXXXF EE	  	 	 	H	 




s   /H
HHc                 f   g }d}| j         D ]G}|j        t          j        k    rd}|r|                    |           |j        t          j        k    rd}Ht          | j        | j                  }t          |          }|D ])}|                    |dt          |          |v            *|j        duS )zIf a funcdef has a magic trailing comma in the return type, then we should first
    split the line with rhs to respect the comma.
    FTrk   preformattedtrack_bracketN)ro   rz   rR   r   ry   r   r   r`   rl   r   idrc  )rq   r`   return_type_leavesin_return_typer   ry  leaves_to_tracks          r]   rj  rj  1  s     &(N " "9##"N 	,%%d+++9$$!N ty
333F9:LMMO" 
 
T((o5 	 	
 	
 	
 	
 &d22r\   c                   J    e Zd Z e            Z e            Z e            ZdS )_BracketSplitComponentN)rW   rX   rY   r   headbodytailr[   r\   r]   r  r  P  s/        466D466D466DDDr\   r  	_featuresc              #     K   t           j        t           j        fD ]5}g }g }g }|}d}d}	t          | j                  D ]
\  }
}|
dk    r|j        t           j        k    r|	dz  }	n;|	dk    r5|j        t           j        k    r|	dz  }	n|j        t           j        k    r|	dz  }	||u rf|j        t          v rX|j        |u rOt          |t                    r:|t           j        k    r|	dk    s$t          |           t          |           |r|n|}|                    |           ||u r%|j        |k    r|t           j        k    r|	dk    s|}|}|r|r n7|r|st          d          t          || |t          j                  }t          || |t          j                  }t          || |t          j                  }t'          |||           |||fD ]}|r|V  	dS )a/  Split line into many lines, starting with the first matching bracket pair.

    Note: this usually looks weird, only use this for function definitions.
    Prefer RHS otherwise.  This is why this function is not symmetrical with
    :func:`right_hand_split` which also handles optional parentheses.
    Nr   r   rj   No brackets found	component)rR   r   r  r   ro   rz   r  r"   opening_bracketrv   rS   r(   ry   rV   bracket_split_build_liner  r  r  r   bracket_split_succeeded_or_raise)rq   r  r`   	leaf_typetail_leavesbody_leaveshead_leavescurrent_leavesmatching_bracketrl   r   r   r  r  r  ry  s                   r]   rk  rk  V  sh      j%*- & &	"$"$"$$(,$T[11 	1 	1KE4zzdi5:55 
9
**QJEEY%*,,QJE+--I!111(,<<</66 =
 #ej00UQYYt$$$/0000;!L!!$''',,9	))"ej00UQYY'+$%0N 	 	E /; /-...#T+7M7R  D $T+7M7R  D $T+7M7R  D %T4666t$   	LLL r\   rX  c              #   `   K   t          | |          }t          || |||          E d{V  dS )aX  Split line into many lines, starting with the last matching bracket pair.

    If the split was by optional parentheses, attempt splitting without them, too.
    `omit` is a collection of closing bracket IDs that shouldn't be considered for
    this split.

    Note: running this function modifies `bracket_depth` on the leaves of `line`.
    rW  ra   rX  N)_first_right_hand_split%_maybe_split_omitting_optional_parens)rq   r`   ra   rX  
rhs_results        r]   r[  r[    sd       )D999J4D$           r\   c                    g }g }g }|}d}d}t          | j                  D ]S}||u r
||u r|r|n|}|                    |           ||u r*|j        t          v rt          |          |vr|j        }|}|}T|r|r|st          d          |                                 |                                 |                                 d}	t          j
        | j        v r |d         j        r|d         j        |d         u rt          |          }
g }g }|d         j        t          j        t          j        fv }|rdnd}t#          |
          d|z   k    r|
d         j        t          v r|
d         j        |
|         u r|r*|                    |
                    d                     d}|                    |
                    d                     |                    d|
                                           t#          |
          d|z   k    r)|
d         j        t          v r|
d         j        |
|         u |r|
rt)          |
| |d         t*          j                  }| j        j        r|
d         j        t          j        k    rd}nS| j        j        t5          d	 ||z   D                       z
  }t7          |t9          | j        |
                    rd}nd}|r|
}|                    |           ||z   }|}	t)          || |t*          j                  }|	t)          || |t*          j                  }	t)          || |t*          j                  }tA          ||	|           tC          ||	|||          S )a#  Split the line into head, body, tail starting with the last bracket pair.

    Note: this function should not have side effects. It's relied upon by
    _maybe_split_omitting_optional_parens to get an opinion whether to prefer
    splitting on the right side of an assignment statement.
    Nr  r   r   rj   r   r  Tc              3   N   K   | ] }t          t          |                    V  !d S rd   )rn   r  r   r   s     r]   r   z*_first_right_hand_split.<locals>.<genexpr>  sB       : : D		NN: : : : : :r\   r  rt   F)"reversedro   ry   rz   r"   r  r  rV   reverser   *hug_parens_with_braces_and_square_bracketsr`   r   rZ  rR   STARr   rn   popinsertr  r  r  rc  COMMAr  sumr   r   extendr  r  r  r   )rq   rX  r  r  r  r  r  closing_bracketr   r  inner_body_leaveshugged_opening_leaveshugged_closing_leavesis_unpackingunpacking_offset
inner_body
should_hugr  r  r  s                       r]   r  r    sB    !K K K N#'O#'O%% 	- 	-[((&&0;!Ld###[((y,,,D1E1E"&"6"&!, / /K / -...D:diGGN  	HN*k"o== --,.,."1~*uz5;K.LL%1 8q!""a*:&:::!"%*.>>>!"%5 !123 3   %%,,->-B-B1-E-EFFF#$ !(():)>)>q)A)ABBB!((,=,A,A,C,CDDD !""a*:&:::!"%*.>>>!"%5 !123 3 ! 	"%6 	"1!%b)05	  J 	.&%b).%+==!

"i3c : : 58M M: : : 7 7  (WTYK%P%P%P   & "'JJ!%J "/""#89993kA!#T?6L6Q  D |':P:U
 
 
 $T?6L6Q  D %T4666T4HHHr\   r]  c              #     K   t           j        |vr| j        j        t          j        k    r| j        j        s| j        j        t          j        k    rj| j        j        s]|j	        sUt          | |j                  r?t          | j                  h|}	 t          ||          }t          || |          rt          |||||          E d {V  d S n# t           $ r}|j        rnt%          | j                  sst)          | j        |          s]t*          j        rA| j        j        r5| j        j        j        r$| j        j        j        j        t0          j        k    st!          d          || j                                        s| j                                        rt!          d          |Y d }~nd }~ww xY wt;          | j                   t;          | j                   | j        | j        | j        fD ]}|r|V  	d S )NrW  r  rt   z<Splitting failed, body is still too long and can't be split.zThe current optional pair of parentheses is bound to fail to satisfy the splitting algorithm because the head or the tail contains multiline strings which by definition never fit one line.)r   FORCE_OPTIONAL_PARENTHESESr  rz   rR   r   r   r  r   	is_importr   r  r  r  _prefer_split_rhs_oop_over_rhsr  rV   is_chained_assignmentr   r  r   r   r   r   rC   dictsetmakerr  contains_multiline_stringsr  r(   )r]  rq   r`   ra   rX  rhs_oopery  s           r]   r  r    s{      	*(::$
22#) 3 $
22#) 3 	 3 &c4+;<< 3 3&''/$/%	-d>>>G-gsDAA @T4(          	  	 	 	)  !**,SXDAAA ;	
 +2 +29 +29>$BSSS "R 
 3355	86688	 " 
 /	< 3&'''3&'''8SXsx0   	LLL s   <C 
F<!CF77F<r  c                    | j                                         s2| j                                        s| j                                        rdS t          j        ru|j        j        ri|j        j        j        rX|j        j        j        j        t          j
        k    r4|j        j        j        r#t          d | j        j        D                       S t          |j         j                  dk    r%|j         j        d         j        t           j        k    sdS t          d |j         j        dd         D                       sdS t%          |j         t'          ||j        dz
  	          
          sdS |j         j        dS d |j         j        D                                 t           j                  }d | j         j        D                                 t           j                  }|dk    r||k    rdS d}t/          | j         j                  D ]+}|j        t           j        k    r n|j        t0          v rd} n,|p8t          d | j         j        D                       ot%          | j         |
          S )z
    Returns whether we should prefer the result from a split omitting optional parens
    (rhs_oop) over the original (rhs).
    Tc              3   @   K   | ]}|j         t          j        k    V  d S rd   )rz   rR   r   r  s     r]   r   z1_prefer_split_rhs_oop_over_rhs.<locals>.<genexpr>o  s+      LL49+LLLLLLr\   r   c              3   2   K   | ]}|j         t          v V  d S rd   )rz   r!   r  s     r]   r   z1_prefer_split_rhs_oop_over_rhs.<locals>.<genexpr>v  s)      FFtyH$FFFFFFr\   Nr   rj   r  rt   c                     g | ]	}|j         
S r[   rz   r  s     r]   
<listcomp>z2_prefer_split_rhs_oop_over_rhs.<locals>.<listcomp>  s    BBB$DIBBBr\   c                     g | ]	}|j         
S r[   r  r  s     r]   r  z2_prefer_split_rhs_oop_over_rhs.<locals>.<listcomp>  s    JJJd	JJJr\   Fc              3   @   K   | ]}|j         t          j        k    V  d S rd   )rz   rR   EQUALr  s     r]   r   z1_prefer_split_rhs_oop_over_rhs.<locals>.<genexpr>  s+      IIT	U[(IIIIIIr\   )r  rd  r  r  r   r   r  r   rz   rC   r  rw   
delimitersr   ro   rn   rR   r  r   r   r  rc  countr  r"   )r  r]  r`   rhs_head_equal_countrhs_oop_head_equal_count has_closing_bracket_after_assignr   s          r]   r  r  W  s    	6688<99;; <99;;
 t 	/M&M &-M &-2d6GGGH$/ H LL8KLLLLLL   A%%#(/"*=*Bek*Q*Qt FF"1EFFFFF t  wt1AA1EFFF    t x$0t CB#(/BBBHHUUJJgl6IJJJPP    a$8;S$S$Su',$,--  9##E9(((/3,E ) 	) 	
 IIW\5HIIIII >$W\===r\   r  r  r  c                     t          t          |                                                    }|s.|dk    rt          d          |dk     rt          d| d          dS dS )a  Raise :exc:`CannotSplit` if the last left- or right-hand split failed.

    Do nothing otherwise.

    A left- or right-hand split is based on a pair of brackets. Content before
    (and including) the opening bracket is left on one line, content inside the
    brackets is put on a separate line, and finally content starting with and
    following the closing bracket is put on a separate line.

    Those are called `head`, `body`, and `tail`, respectively. If the split
    produced the same line (all content in `head`) or ended up with an empty `body`
    and the `tail` is just the closing bracket, then it's considered failed.
    r   z)Splitting brackets produced the same liner   z,Splitting brackets on an empty body to save z characters is not worth itN)rn   r  r   rV   )r  r  r  tail_lens       r]   r  r    s     3t99??$$%%H q==IJJJ\\ x          \r\   ro   originalr  c                 P   | sdS |j         rdS |j        sdS |j        dk    rdS t          d | D                       rdS t	          d | D             d           }|dS t          |          dk    rdS |j        r-|j        j        r!|j        j        j        t          j
        k    rdS dS )NFTr   c              3   `   K   | ])}|j         t          j        k    ot          |           V  *d S rd   )rz   rR   r  r8   r  s     r]   r   z)_ensure_trailing_comma.<locals>.<genexpr>  sM        IM	U[ D)>t)D)D%D     r\   c              3   (   K   | ]}|j         	|V  d S rd   r   r  s     r]   r   z)_ensure_trailing_comma.<locals>.<genexpr>  s)      DDdDTDDDDDDr\   rb   )r  ri  r   r   r   r*   r   next_siblingrz   rR   VBAR)ro   r  r  leaf_with_parents       r]   _ensure_trailing_commar    s      u t? u##u
  QW      u DDfDDDdKKt+,,88u 	#0 #05CCu4r\   r  c                   t          |j        |j                  }|t          j        u rd|_        |xj        dz  c_        t          | ||          rt          t          |           dz
  dd          D ]g}| |         j	        t          k    r| |         j	        t          j        k    r3t          t          j        d          }|                     |dz   |            t                      }|t          j        u rt#          |           }| D ]X}|                    |dt'          |          |v            |                    |          D ]}	|                    |	d           Y|t          j        u rt+          ||          rd|_        |S )ai  Return a new line with given `leaves` and respective comments from `original`.

    If it's the head component, brackets will be tracked so trailing commas are
    respected.

    If it's the body component, the result line is one-indented inside brackets and as
    such has its first leaf's prefix normalized and a trailing comma added when
    expected.
    rk   Trj   r   r/  r|  r}  )r   r`   rl   r  r  re  r  rangern   rz   r$   rR   r  rS   r  r   r  r   ry   r  comments_aftershould_split_linerb  )
ro   r  r  r  ry  r   	new_commar  r   comment_afters
             r]   r  r    s     x}HN;;;F*///!%!&(ODD 	3v;;?B33  !9>%777!9>U[00 $U[# 6 6IMM!a%333#&55O*///=fEE < <T((o5 	 	
 	
 	

 &44T:: 	< 	<MMM-dM;;;;	<*///4E5 5/ #'Mr\   
split_funcc           
           t                     dt          dt          t                   dt          dt
          t                   f fd            }|S )zNormalize prefix of the first leaf in every line returned by `split_func`.

    This is a decorator over relevant split functions.
    rq   ra   r`   rb   c              3   X   K    | ||          D ]}d|j         d         _        |V  d S r   )ro   r|   )rq   ra   r`   
split_liner  s       r]   split_wrapperz0dont_increase_indentation.<locals>.split_wrapper  sO       %*T8T:: 	 	J*,Ja '	 	r\   )r	   r   r   r   r   r   )r  r  s   ` r]   dont_increase_indentationr    sg     :(19=	$      r\   c                     t          t          | j                  dz
  dd          D ]!}| j        |         j        t          k    r|c S "d S )Nrj   r   r   )r  rn   ro   rz   r$   )rq   leaf_idxs     r]   _get_last_non_comment_leafr  "  sU    #dk**Q.266  ;x %);;;OOO <4r\   r   c                     t          | t          j        h          rt          j        |v S t          | t          j        t          j        h          rt          j        |v S dS )N)withinT)r@   rC   typedargslistr   TRAILING_COMMA_IN_DEFarglistargumentTRAILING_COMMA_IN_CALL)r   ra   s     r]   _can_add_trailing_commar  )  s\    t12333 9,88t|T];<<< :-994r\   safedelimiter_priorityc                     | ru|t           k    rj|j        d         j        t          j        k    rJ|j        d         j        t
          k    r/t          t          j        d          }|                    |           |S )Nr   r/  )r   ro   rz   rR   r  r$   rS   ry   )r  r  rq   r  s       r]   _safe_add_trailing_commar  1  sh    .00KO EK//KO $666c**	IKr\   c              #      K   t           j                  dk    rt          d          d j        d         } j        }	 |                    t          |          h          }n# t          $ r t          d          dw xY w|t          k    r(|                    |          dk    rt          d          t           j
         j         j        	          t          j        }d
}dt          dt           t                   f fddt          dt           t                   f fd}t#                     }	t%           j                  D ]`\  }
} |          E d{V  |
dk    o4|j                            t           j        |
dz
                               }||k    s	|t*          v r ||          E d{V  t-          ||j                  }|r|j        |k    rt1          ||          }|j        t4          k    r|
|	k    rt7          ||          |j                            t          |                    }||k    rh|
dz   t           j                  k     r(|t*          vr | j        |
dz                      E d{V  V  t           j
         j         j        	          brt7          ||          V  dS dS )zSplit according to delimiters of the highest priority.

    If the appropriate Features are given, the split will add trailing commas
    also in function signatures and calls that contain `*` and `**`.
    r   z
Line emptyNr   excludezNo delimiters foundrj   z7Splitting a single attribute from its owner looks wrongr`   rl   re  Tr   rb   c              3      K   	                      | d           dS # t          $ r> V  t          j        j        j                                      |            Y dS w xY w)EAppend `leaf` to current line or to new line if appending impossible.Tr  r  Nappend_safe
ValueErrorr   r`   rl   re  ry   r   rm   rq   s    r]   append_to_linez'delimiter_split.<locals>.append_to_line_  s      	&$$T$===== 	& 	& 	&Ydj$BV  L %%%%%%	&    AA&%A&c              3   ^   K                        |           D ]} |          E d {V  d S rd   )r  )r   r  r  rq   s     r]   append_commentsz(delimiter_split.<locals>.append_commentsl  sS      !0066 	5 	5M%~m4444444444	5 	5r\   )rn   ro   rV   rw   max_delimiter_priorityr  r  r   delimiter_count_with_priorityr   r`   rl   re  sysmaxsizerS   r   r  r   r  getMIGRATE_COMMENT_DELIMITERSminbracket_depthr  rz   r$   r  )rq   ra   r`   	last_leafbtr  lowest_depthtrailing_comma_safer  last_non_comment_leafr  r   previous_priorityleaf_priorityr  rm   s   `             @@r]   rm  rm  @  s|      4;1,''T1BI		B;6696OO ; ; ;/00d:; 	l**,,-?@@AEESTTTYdj$:N  L ;L&T &htn & & & & & & &5d 5x~ 5 5 5 5 5 5 5 7t<<#DK00    $!>$'''''''''$qL 
R]->->t{8a<()).
 .
 !333!%???&t,,,,,,,,,<);<< 	J4#5#E#E"9$"I"I>///H@U4U4U3#%7 L ))"T((33...1s4;////&.HHH*?4;x!|+DEEEEEEEEEYdj$BV  L  /!3\
 
 	 s   $A( (Bc              #   n   K                                     st          d          t           j         j         j                  dt          dt          t                   f fd} j        D ]<} ||          E d{V   	                    |          D ]} ||          E d{V  =rV  dS dS )z4Split standalone comments from the rest of the line.z*Line does not have any standalone commentsr  r   rb   c              3      K   	                      | d           dS # t          $ r> V  t          j        j        j                                      |            Y dS w xY w)r  Tr  )rl   re  Nr  r  s    r]   r  z0standalone_comment_split.<locals>.append_to_line  s      	&$$T$===== 	& 	& 	&	T=Q  L %%%%%%	&r  N)
rf  rV   r   r`   rl   re  rS   r   ro   r  )rq   ra   r`   r  r   r  rm   s   `     @r]   rn  rn    s'     
 ,,.. HFGGGYdj$:N  L&T &htn & & & & & & &  5 5!>$'''''''''!0066 	5 	5M%~m4444444444	5   r\   rr   r   c          	      6	   t          | j        d|          D ]}t          |j        t                    r dS  | j        t          j        k    rt          | ||           d}t          t          | j                            D ]\  }}t          |t                    r(|j        t          j        k    rt          ||||           t          |t                    r)|j        t          j        k    rt          |dh||           t          |t                    r)|j        t          j        k    rt          |dh||           |dk    r,t          |t                    r|j        t          j        k    rd}|dk    rt          |t                    rp|j        t          j        k    r[| j        t          j        k    rFt+          ||          s6t-          |          s't/          || ||dd	          rt1          | |d
           |rb|j        t          j        k    r| j        t          j        k    rlt          |j        t6                    rR|j        j        t8          j        k    r8|j        j        dk    r(t/          || ||d          rt1          | |d
           nt          |t                    r*| j        t          j        k    rt=          || ||           n|j        t          j        k    rd|v rlt?          |j                  dk    rTtA          |j        d                   r:tC          |j        d                   r |j        d         j        t          j"        k    s&t/          || ||          rt1          | |d
           ntG          |          rt1          | |d
           n| j        t          j$        k    rtK          | ||            dS |dk    r,|j        t8          j&        k    r| j        t          j'        k    r|t          |t6                    r/|j(        (|j(        j        t8          j)        k    r|j        dk    r dS tU          |          st1          | |d
           |j        t8          j+        k    }t          |t6                    o
|j        |v p|}dS )aE  Make existing optional parentheses invisible or create new ones.

    `parens_after` is a set of string leaf values immediately after which parens
    should be put.

    Standardizes on visible parentheses for single-element tuples, and keeps
    existing visible parentheses for other tuples and generator expressions.
    F)is_endmarkerr`   Nr   caser0  r   T)r   r`   ra   r   allow_star_exprr   r4  r   r   r(  r   r   rj   r   ),r   r|   r   r   r   rz   rC   	with_stmt_maybe_wrap_cms_in_parensr   rZ  r   rv   rT   	annassignr   
case_blockguardtestlist_star_exprr   	expr_stmt_atom_has_magic_trailing_comma_is_atom_multiliner   rD   for_stmtr   rS   rR   NAMEremove_with_parensrn   r2   r9   testr6   import_from_normalize_import_fromr  except_clauser  r   r3   r  )	rr   r   r`   ra   pc
check_lparr   r   comma_checks	            r]   r   r     s    DKe$GGG  !"(G44 	FF	 yDN""!$h777J!$t}"5"566 l
 l
u eT"" 	uzT^'C'C&Lth    eT"" 	uzT_'D'D&VH4(   
 eT"" 	uzTZ'?'?&TF    QJJ5$'' 
d555J QJJ5$'' 
di''	T^++25$?? ,&u-- , 3!-1 $   @ $D%???? 7	@
di''I..u1488 /&+uz99&,556%15   D (eUCCCCE4(( '@TY$.-H-H"5$THMMMMMty(($$''1,,!%."344 -!%."455 - N1%*di776$TH   D (eUCCCCe$$ @#D%>>>>>d...&tUE:::

J%*,,I!333
  5$''@&2&+u{::K6)) (// @#D%????jEK/t,, 
K<'6; 	
Ul
 l
r\   r   r   r   c                 v   t          |          r7t          | j        d                   sJ d|_        d| j        d         _        d S |j        t
          j        k    r]|                     |t          t
          j	        d                     | 
                    t          t
          j        d                     d S d S )Nr   ru   )r2   r9   r   r   rz   rR   r  r   rS   r   r   r   )r   r   r   s      r]   r   r   C  s     U 2V_R011111$&!!!	uz	!	!E4
B#7#7888DR0011111 
"	!r\   c                    | j         d         j        t          j        k    rt	          | j                   dk    r| j         d         j        t
          j        k    rb| j         d         j         d         j        t          j        k    r8t          | j         d         | ||d          rt          | | j         d         d           t          t          | j         d         j         d                   }t          t          | j         d         j         d                   }| j         d         j         d         }t          |t                    r{|j        t
          j        k    s>|j         d         j        t          j        k    st          d |j         D                       r*t!          |           t!          |           d S d S d S d S d S d S d S )	Nr   rj   Tr   Fr   r   c              3   j   K   | ].}t          |t                    o|j        t          j        k    V  /d S rd   )rv   rS   rz   rR   r   r  s     r]   r   z&remove_await_parens.<locals>.<genexpr>m  sO         ud++N
e>N0N     r\   )r   rz   rR   AWAITrn   rC   r   r   r   rD   r   rS   rv   rT   r   r   r(   )rr   r`   ra   r  r  bracket_contentss         r]   r   r   Q  s   }Q++DM0B0BQ0F0FM!!TY..a )!,1UZ??2a !-1   K $D$-*:EJJJJ #4q)9)B1)EFFO"4q)9)B2)FGGO#}Q/8;*D11 	0 %33#,Q/4CC  !1!:     D ////////C ,+0F0F..??*	0 	0CCr\   c                    t           j        |vs8t          | j                  dk    s | j        d         j        t
          j        k    rdS d}t          dt          | j                            D ]&}| j        |         j        t          j	        k    r|} n'|t          t          j        d          }t          t          j        d          }| j        d|         }|D ]}|                                 t          t
          j        |t          t
          j        |          |g          }	|                     d|	           dS dS )zWhen enabled and safe, wrap the multiple context managers in invisible parens.

    It is only safe when `features` contain Feature.PARENTHESIZED_CONTEXT_MANAGERS.
    r   rj   Nru   )r   PARENTHESIZED_CONTEXT_MANAGERSrn   r   rz   rC   r   r  rR   r   rS   r   r   r   rT   testlist_gexpr   )
rr   r`   ra   colon_indexr   r   r   context_managersr   	new_childs
             r]   r  r  v  s=    	.h>>t}""= DI--"K1c$-(())  = EK//KE 0 EJ##EJ##=;7% 	 	ELLNNNN Id4#57GHH$O
 
	 	!Y''''') r\   c                    | j         t          j        k    rht          | |||d          rt	          || d           t          | j        d         t                    r t          | j        d         | ||           d	S d	S | j         t          j	        k    r4| j        D ]*}t          |t                    rt          || ||           +d	S | j         t          j
        k    rit          d |                                 D                       s@t          | j        d         | ||d          r#t	          | | j        d         d           d	S d	S d	S d	S )
z6Recursively hide optional parens in `with` statements.Tr   Fr   rj   r   c              3   @   K   | ]}|j         t          j        k    V  d S rd   )rz   rR   
COLONEQUALr  s     r]   r   z%remove_with_parens.<locals>.<genexpr>  s=       3 3*.	U%%3 3 3 3 3 3r\   r   N)rz   rC   r   r   rD   rv   r   rT   r  r,  asexpr_testr   ro   )rr   r   r`   ra   r   s        r]   r  r    s   ( yDI.)-
 
 
 	=  e<<<<dmA&-- 	Ut}Q/D8TTTTTT	U 	U	d(	(	(] 	N 	NE%&& N"5$THMMMM	N 	N 
d&	&	&s 3 326++--3 3 3 0 0	& /M!)-
 
 
 	G  dmA&6FFFFFF 
'	&	&	&	G 	Gr\   c                 2    |j         sdS t          |           S )zCheck if an atom node has a magic trailing comma.

    Returns True for single-element tuples with trailing commas like (a,),
    which should be preserved to maintain their tuple type.
    F)rc  r6   )rr   r`   s     r]   r  r    s"     $ ur\   c                     t          | t                    rt          | j                  dk     rdS | j        d         }|                                D ]#}t          |t
                    rd|j        v r dS $dS )zGCheck if an atom node is multiline (indicating intentional formatting).r   Frj   r   T)rv   rT   rn   r   	pre_orderrS   r|   )rr   middler   s      r]   r  r    s    dD!! S%7%7!%;%;u ]1F!!##  eT"" 	tu|';';445r\   Fr   r  c                    | j         t          j        t          j        fvsYt	          |           sIt          |           s9t          |           r|j         t          j        k    st          |           r/|j         t          j        k    rt          | t          j                  st          |           r|j         t          j        k    s|st          |           t          k    rit           j        |v rt          |           r{| j        t| j        j         t          j        k    rZ| j        $t+          | j                  r| j        j        dk    s/t/          |           s |st1          |           st3          |           rdS t5          |           r|j         t          j        t          j        t          j        t          j        t          j        t          j        t          j        t          j        t          j         t          j!        t          j"        t          j!        fv rdS | j#        d         }| j#        d         }tI          |          r4tK          |          r$| j#        d         }tM          |j'        (                                |          sd|_        d|_        tS          |||||	           tU          |          r|+                    |j#        d                    |j#        d         j'        (                                r5|j#        d         j'        |j#        d         j'        z   |j#        d         _'        |j#        d         j'        (                                r|j#        d         j'        |j'        z   |_'        dS d
S )a  If it's safe, make the parens in the atom `node` invisible, recursively.
    Additionally, remove repeated, adjacent invisible parens from the atom `node`
    as they are redundant.

    Returns whether the node should itself be wrapped in invisible parentheses.
    NasFr   r   rj   rt   ru   r   T),rz   rC   r   exprr0   r6   r<   r3  r  r+   rR   r  rB   r  r   r   r   UNPARENTHESIZED_EXCEPT_TYPESr   r!  r  r4   r   r>   r=   r1   rA   r  assert_stmtreturn_stmtfuncdefr,  tnamer  del_stmtr   r2   r9   r?   r|   r   r   r.   r   )	rr   r   r`   ra   r   r  r  r  r7  s	            r]   r   r     sF    		$)TY///$ 	0 	0 TNN 	0  &{d.>>>TNN  ? t~--%dEK88 . TNN .  &{dn<<
 -  = /t44FF 4@@TNN A K+K$(::: %1%d&788 2)/477 &d++	 8
   8
 %=T$B$B 8  8 uD!! ;NNLNJMMM
 
 
 5M!E=DU !d 3 3 !q!
 .fm.A.A.C.C$OOO	
 EKDJ+)E	
 	
 	
 	
 )00 	G NN6?1-...q!(..00  OA&-0B0II ") r")//11 G$ob184;Fu4r\   c                    |j         r	|j        dv sdS t                      }d}	 | j        d         }|j        t
          j        k    r$d}|                    t          |                     | j	        
                    |          }n# t          t          f$ r Y dS w xY w|t          k    o1| j        j        r|p#|j         j        t           j        t           j        hv S )zFShould `line` be immediately split with `delimiter_split()` after RHS?z[{(Fr   Tr  )r   r   r   ro   rz   rR   r  addr  rw   r  
IndexErrorr  r   r`   rc  rC   r   r  )rq   r  r  trailing_commar  max_prioritys         r]   r  r  \  s     " '<'E'Eu
 eeGNKO	>U[((!NKK9&&&+BB7BSS
#   uu >) 		'	:N 	H!&49d6F*GGs   A!B BBr  c              #   \  K   t                      }| j        s|V  d| j        z  }d}d}t                      }|                     d          D ]\  }}}	||	z  }||k    r dS |	t	          |j                  t	          |j                  z   k    }
|j        t          k    s|
r dS |r||u rd}`|j        t          v rv|dk    r| j
        |dz
           nd}|r:|j        t          j        k    r%|j        t          |j        || j
                  s dS |                    t!          |                     |j        t          v r|dk    r| j
        |dz
           nd}|r2|j        t"          v r$|                    t!          |                     ?|rO|                    t!          |                     |                    |           |                                 |V  |r:|j        t          j        k    r%|j        t          |j        || j
                  s dS |j        r	|j        }|}dS )a  Generate sets of closing bracket IDs that should be omitted in a RHS.

    Brackets can be omitted if the entire trailer up to and including
    a preceding closing bracket fits in one line.

    Yielded sets are cumulative (contain results of previous yields, too).  First
    set is empty, unless the line should explode, in which case bracket pairs until
    the one that needs to explode are omitted.
       NT)is_reversedr   rj   )r   rc  rl   enumerate_with_lengthrn   r   r|   rz   r$   r"   ro   rR   r  r  r5   rB  r  r#   updateclear)rq   r  rX  lengthr  r  inner_bracketsr   r   leaf_lengthhas_inline_commentprevs               r]   rY  rY  w  s      D$ 


^F#'O#'O"%%%N$($>$>4$>$P$P 6' 6' t[+KEE(3tz??S=M=M+MM9***.@*EE -	'&&"&...16t{519--
	U[00,83,dDK  9 EE""2d88,,,Y***-2QYY4;uqy))DD 	%555 ""2d88,,, O,,---N+++$$&&&


 I,,(4/0DdDKXX 5
 z '"&"6"&m6' 6'r\   ru   r_  rx  rU  c                   |st          |           }g } || |          D ]\}t          |                              d          |k    rt          d          |                    t          ||                     ]t          |          }t          j        |v s|j	        j
        dk    s| j        j        rt          d | j        j        D                       s}|                                 si|d                                         sO|d                                         s5t#          |d                   st          d | j        D                       r|S |                                 }t)          || | j                   |t          j        hz  }	t+          |||	|	          }
t-          fd
|
D                       r|
}|S )Nr   z-Line transformer returned an unchanged resultr   r]  c              3   $   K   | ]}|j         V  d S rd   )r   )r   brackets     r]   r   z"run_transformer.<locals>.<genexpr>  s$      KKw}KKKKKKr\   r   rt   c              3   (   K   | ]}|j         d u V  d S rd   r  r  s     r]   r   z"run_transformer.<locals>.<genexpr>  s)      ;;tt{d";;;;;;r\   r_  c              3   :   K   | ]}t          |           V  dS )rt   N)r   )r   lnr`   s     r]   r   z"run_transformer.<locals>.<genexpr>  s1      
H
H2...
H
H
H
H
H
Hr\   )r   r  r   rK   r  rz  r   r   r  r   rW   rw   	invisibler   r  ra  rd  r   ro   cloner   ro  all)rq   rx  r`   ra   rU  ry  transformed_linefeatures_set	line_copyfeatures_fopsecond_opinions     `        r]   ro  ro    s     (!$''F%IdHd;; V V  &&t,,88!"QRRRn%5D8TTTUUUUx==L*l::'500#- 1KKD,@,JKKKKK 1 **,, 1 !999;;	 1
 !96688 1  q	555 1 ;;t{;;;;; 1 

I)T4;///7#E"FFL$9dL8  N 
H
H
H
H
H
H
HHH  Mr\   )r[   )r[   r[   )FF)rZ   r   r  collections.abcr   r   dataclassesr   enumr   r   	functoolsr   r	   typingr
   r   black.bracketsr   r   r   r   r   black.commentsr   r   r   r   r   black.linesr   r   r   r   r   r   r   
black.moder   r   r   black.nodesr    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   black.numericsrE   black.stringsrF   rG   rH   rI   rJ   black.transrK   rL   rM   rN   rO   rP   rQ   blib2to3.pgen2rR   blib2to3.pytreerS   rT   rO  LeafIDrP  rV   r_   r  rS  rz  boolrj  r  rk  r[  r  r  r  r  rZ  r  r  r  r  r  r  r  rm  rn  r   r   r   r   r  r  r  r  r   r  rY  ro  r[   r\   r]   <module>rp     s    
			 



 0 0 0 0 0 0 0 0               $ $ $ $ $ $ $ $                                                    . - - - - - - - - -& & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & &N 5 4 4 4 4 4                               !           & & & & & & & & 

4:M M M M M/ M M M|B |B |B |B |BGDM |B |B |B~
!  	4Z	    =?y y
yy&0&9yd^y y y yx3 3D 3T 3 3 3 3>    T   ?
?%g.?6:?d^? ? ? ?J %'!	 

 ! V
	
 d^   ,  "dI dI
dI
V
dI dI dI dI dIV %'!A A	A
A A !	A
 V
A d^A A A AHHH&H.2H	H H H HV4 t 4 D    4!J!"&!9=!	! ! ! !H.J.. .
 &. 
. . . .b+ +    "T cDj    $ *W2E $    	4 	S 	 	QU 	 	 	 	 .~>  V
V$W-V59Vd^V V V Vr 
$W-59d^   DC

C
!#hC
15C
AKGATC
	C
 C
 C
 C
L24 2 23 24 2 2 2 2"0d "0$ "0*W:M "0RV "0 "0 "0 "0J'(
'('(&0&9'(	'( '( '( '(T-G
-G-G$(-G4>w4G-G	-G -G -G -G`	 	4 	D 	 	 	 	R D    ( */!n n
nn n !	n
 #'n n 
n n n nbD 4 D    6I'D I's I'xF?T I' I' I' I'd + + +
++ + !	+ + 
$Z+ + + + + +r\   