a
    g	gg                     @   s&  d Z ddl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mZmZmZmZmZ ddlmZmZmZmZ ddlmZmZmZ dd	lmZ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-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZD ddlEmFZF ddlGmHZHmIZImJZJmKZKmLZL ddlMmNZNmOZOmPZPmQZQmRZRmSZSmTZT ddlUmVZV ddlWmXZXmYZY eZZ[eeXeYf Z\G dd deNZ]G dd de0e Z^d_ee%ee$ ee dddZ_G dd deZ`eee$ e%ee dddZad`ee%ee$ ee[ ee ddd Zbdaeee[ ed!d"d#Zcdbeee%ee$ ee[ ee d$d%d&Zdee%eed'd(d)Zfeeedd*d+d,ZgeeX eeXe`ed-d.d/ZheSeSd0d1d2ZieeeZ d3d4d5ZjeeeZeed6d7d8Zkeieee$ e%ee d9d:d;Zleieee$ e%ee d9d<d=ZmeXeedd>d?d@ZneYeeo e%ee$ ddAdBdCZpeYe\eZddDdEdFZqeYddGdHdIZreYe%ee$ ddJdKdLZseYeYddMdNdOZtdce\e\eeeedQdRdSZueeXeedTdUdVZveeZeee[  dWdXdYZwdZd[eeSe%ee$ eoee d\d]d^ZxdS )dz
Generating lines of code.
    N)replace)Enumauto)partialwraps)
CollectionIteratorListOptionalSetUnioncast)COMMA_PRIORITYDOT_PRIORITY#get_leaves_inside_matching_bracketsmax_delimiter_priority_in_atom)FMT_OFF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RARROWSTANDALONE_COMMENT	STATEMENT
WHITESPACEVisitorensure_visibleis_arith_likeis_async_stmt_or_funcdefis_atom_with_invisible_parensis_docstringis_empty_tupleis_lpar_tokenis_multiline_stringis_name_tokenis_one_sequence_betweenis_one_tupleis_rpar_tokenis_stub_bodyis_stub_suiteis_tuple_containing_walrus	is_varargis_walrus_assignmentis_yieldsymswrap_in_parentheses)normalize_numeric_literal)fix_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                   @   s   e Zd ZdZdS )CannotSplitzBA readable split that fits the allotted line length is impossible.N)__name__
__module____qualname____doc__ rQ   rQ   P/var/www/html/llm_bihealth/app/venv/lib/python3.9/site-packages/black/linegen.pyrL   S   s   rL   c                       s  e Zd ZdZeee ddddZd4ee	e
 ddd	Zee	e
 d
 fddZee	e
 d
ddZee	e
 d
ddZee	e
 d
ddZeee ee e	e
 dddZee	e
 d
ddZee	e
 d
ddZee	e
 d
ddZee	e
 d
ddZee	e
 d
ddZee	e
 d
d d!Zee	e
 d
d"d#Zee	e
 d
d$d%Zee	e
 d&d'd(Zee	e
 d&d)d*Zee	e
 d&d+d,Z ee	e
 d
d-d.Z!ee	e
 d&d/d0Z"dd1d2d3Z#  Z$S )5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.
    N)modefeaturesreturnc                 C   s   || _ || _|  |   d S N)rT   rU   __post_init__)selfrT   rU   rQ   rQ   rR   __init__`   s    zLineGenerator.__init__r   )indentrV   c                 c   sp   | j s| j  j|7  _dS tj| jv rJt| j jdkrJt| j jd rJdS | j }t| j|j| d| _ |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   rT   depth)	current_liner^   r   "improved_async_statements_handlingrT   lenleavesr*   r   )rY   r[   Zcomplete_linerQ   rQ   rR   linef   s    
	zLineGenerator.linenoderV   c                 #   s   t |tr| jj }t|D ]f}|r4| j| q|jtj	kr\| j| | 
 E dH  q| 
 E dH  | j| | 
 E dH  qt||d | jjr|jtjkrt|j|_t|j|_|jtjkrt| |jtvr| j| t |E dH  dS )zCDefault `visit_*()` implementation. Recurses to children of `node`.Ninside_brackets)
isinstancerJ   r_   bracket_trackerany_open_bracketsr   appendtyperI   COMMENTrc   normalize_prefixrT   string_normalizationSTRINGr?   valuer@   NUMBERr<   r&   supervisit_default)rY   re   rj   comment	__class__rQ   rR   rt      s(    

zLineGenerator.visit_defaultc                 c   sf   t j| jv rR|jo|jjtjk}|sRttjd}ttjd}|	d| |
| | |E dH  dS )zVisit an `x if y else z` test r   N)r   Z$parenthesize_conditional_expressionsrT   prev_siblingrl   rI   LPARrJ   RPARinsert_childappend_childrt   )rY   re   Zalready_parenthesizedlparrparrQ   rQ   rR   
visit_test   s    
zLineGenerator.visit_testc                 c   s$   |  dE dH  | |E dH  dS )z/Increase indentation level, maybe yield a line.r\   Nrc   rt   rY   re   rQ   rQ   rR   visit_INDENT   s    zLineGenerator.visit_INDENTc                 c   s2   |   E dH  | |E dH  |  dE dH  dS )z/Decrease indentation level, maybe yield a line.Nr   r   rQ   rQ   rR   visit_DEDENT   s    zLineGenerator.visit_DEDENT)re   keywordsparensrV   c                 c   sT   t ||| j| jd |jD ]4}t|r>|j|v r>|  E dH  | |E dH  qd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_afterrT   rU   N)normalize_invisible_parensrT   rU   childrenr0   rq   rc   visit)rY   re   r   r   childrQ   rQ   rR   
visit_stmt   s    
zLineGenerator.visit_stmtc                 c   s   t j| jv rt|jD ]r\}}|dkr(q|j|d  jtjkr|jtj	krz|jd jtj
krzt||ddrt||dd qt||dd q| |E d H  d S )Nr   r\   Fparentremove_brackets_around_commaZvisible)r   Zwrap_long_dict_values_in_parensrT   	enumerater   rl   rI   COLONr:   atomrz   #maybe_make_parens_invisible_in_atomr;   rt   )rY   re   ir   rQ   rQ   rR   visit_dictsetmaker   s    z LineGenerator.visit_dictsetmakerc                 c   s   |   E dH  d}|jD ]h}|jtjkr.d}q|r|jtjkrn|jd jtjkrnt||ddr|t	||dd nt	||dd d}q|jD ]}| 
|E dH  qdS )zVisit function definition.NFTr   r   r   )rc   r   rl   rI   r#   r:   r   rz   r   r;   r   )rY   re   Zis_return_annotationr   rQ   rQ   rR   visit_funcdef   s"    

zLineGenerator.visit_funcdefc                 c   sD   t |t | j| jd |  E dH  |jD ]}| |E dH  q*dS )z'Visit either a match or case statement.r   N)r   setrT   rU   rc   r   r   rY   re   r   rQ   rQ   rR   visit_match_case  s    
zLineGenerator.visit_match_casec                 c   s<   | j jr(t|r(| |jd E dH  n| |E dH  dS )zVisit a suite.   N)rT   is_pyir5   r   r   rt   r   rQ   rQ   rR   visit_suite  s    zLineGenerator.visit_suitec                 c   s   d}|j D ]2}|du s |tjkr6t|r6t||dd |j}q
|joN|jjtv }|r| jj	rvt
|rv| |E dH  q| dE dH  | |E dH  | dE dH  n6| jj	r|jrt|js|  E dH  | |E dH  dS )z,Visit a statement without nested statements.NFr   r\   r   )r   rI   SEMIr)   r;   rl   r   r%   rT   r   r4   rt   rc   r5   )rY   re   Z	prev_typer   Zis_suite_likerQ   rQ   rR   visit_simple_stmt  s(    
zLineGenerator.visit_simple_stmtc                 c   s   |   E dH  t|j}|D ].}| |E dH  |jtjksF|jtkr qLqt|}t	j
| jv rr| |E dH  n|jD ]}| |E dH  qxdS )z-Visit `async def`, `async for`, `async with`.N)rc   iterr   r   rl   rI   ASYNCr$   nextr   r`   rT   )rY   re   r   r   Zinternal_stmtrQ   rQ   rR   visit_async_stmt.  s    

zLineGenerator.visit_async_stmtc                 c   s.   |j D ]"}|  E dH  | |E dH  qdS )zVisit decorators.N)r   rc   r   r   rQ   rQ   rR   visit_decoratorsB  s    
zLineGenerator.visit_decoratorsc                 c   s   t |jd d D ]r\}}|j|d  }t|ts4q|j }|jtjkr|jt	j
kr|jd jtjkr|dsd|vrt|| qt| | |E d H  d S )Nr   r\   r   )0x0bZ0oj)r   r   rh   rJ   rq   lowerrl   rI   rr   r:   trailerDOT
startswithr;   remove_await_parensrt   )rY   re   idxleafZ	next_leafrq   rQ   rQ   rR   visit_powerH  s$    




zLineGenerator.visit_powerr   rV   c                 c   s   |   E dH  dS )zBRemove a semicolon and put the other statement on a separate line.N)rc   rY   r   rQ   rQ   rR   
visit_SEMI`  s    zLineGenerator.visit_SEMIc                 c   s"   |  |E dH  |  E dH  dS )zAEnd of file. Process outstanding comments and end with a newline.N)rt   rc   r   rQ   rQ   rR   visit_ENDMARKERd  s    zLineGenerator.visit_ENDMARKERc                 c   s.   | j j s|  E d H  | |E d H  d S rW   )r_   ri   rj   rc   rt   r   rQ   rQ   rR   visit_STANDALONE_COMMENTi  s    z&LineGenerator.visit_STANDALONE_COMMENTc                 c   s   |j \}}|jtjkrtt|j dkrt|j d jtjkrtttjd}ttj	d}|
 pXd}||ttj|||g | |E dH  dS )z_Force parentheses between a unary op and a binary power:

        -2 ** 8 -> -(2 ** 8)
           r\   ()r   N)r   rl   r:   powerra   rI   
DOUBLESTARrJ   rz   r{   remover|   rK   r   rt   )rY   re   	_operatoroperandr~   r   indexrQ   rQ   rR   visit_factorn  s    

zLineGenerator.visit_factorc                 c   s  t j| jv rt| t|rd|jvr| jjrFt|j}t|}n|j}t	|}|t
|d  }|d }|d |kr|dnd}|||  }| }d| jj }t|rt||}n| }d}|r*|d |krd| }|d |kr|d7 }|d d	kr4t
|t
|d	 }	|	d
 r4|d7 }d}n
|s4d}|| }
| jr|dkr| }|rht
|d nd}t
|dkr|| | jjkrt
|| | jjkr|s||
 | d | |
 |_n||
 | |
 |_n||
 | |
 |_| |E d H  d S )Nz\
r   r\   r   z    F r   \r   T
)r   Zhex_codes_in_unicode_sequencesrT   rA   r,   rq   ro   r?   r@   r>   ra   r_   r^   r/   r=   striprstrip
splitlinesline_lengthrt   )rY   r   	docstringprefix
quote_charZ	quote_lenZdocstring_started_emptyr[   Zhas_trailing_backslashZbackslash_countquotelinesZlast_line_lengthrQ   rQ   rR   visit_STRING  s\    



zLineGenerator.visit_STRING)rV   c                 C   s0  t | jd| _| j}t }t|dhddhd| _t|h dddhd| _t|dd	hdhd| _t|d
d	hd
dhd| _	t|h d|d| _
t|dhdhd| _t|dhdhd| _t|dh|d| _t||td| _t|dhdhd| _t||dhd| _t||dhd| _| j| _| j| _| j| _| j| _dS )z,You are in a twisty little maze of passages.rT   assert,)r   r   >   ifelseelifr   r   whiler   forin>   exceptr   tryfinallyr   withclassrV   importdelN)r   rT   r_   r   r   r   Zvisit_assert_stmtZvisit_if_stmtZvisit_while_stmtZvisit_for_stmtZvisit_try_stmtZvisit_except_clauseZvisit_with_stmtZvisit_classdefr   Zvisit_expr_stmtZvisit_return_stmtZvisit_import_fromZvisit_del_stmtr   Zvisit_async_funcdefr   Zvisit_decoratedr   Zvisit_match_stmtZvisit_case_block)rY   v   ØrQ   rQ   rR   rX     s.    
zLineGenerator.__post_init__)r   )%rM   rN   rO   rP   r   r   r   rZ   intr   r   rc   LNrt   rK   r   rJ   r   r   r   strr   r   r   r   r   r   r   r   r   r   r   r   r   r   rX   __classcell__rQ   rQ   rv   rR   rS   Y   s0   
SrS   rQ   )rc   rT   rU   rV   c              	   c   s  | j r| V  dS t| }|j}|j}t||}t||}t||}t||}	|  s| j	s| j
st| ||dsv|  r| jr|  stj|v r||g}
ng }
n| jrtg}
ntttt ttt ddd}t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 ]H}zt| ||||d	}W n typ   Y q<Y n0 |E dH   qq<| 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)rT   line_str)rY   rc   rU   rT   rV   c                 s   s^   t ||jD ]8}tt||||d}t|d |dr|E dH   dS qt|||dE dH  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   r   N)rU   )generate_trailers_to_omitr   listright_hand_splitr   )rY   rc   rU   rT   r   r   rQ   rQ   rR   _rhs  s    	
ztransform_line.<locals>._rhsrhsrQ   __call__r   ) Z
is_commentr   r   ro   rC   rD   rF   rE   $contains_uncollapsable_type_commentsshould_split_rhsmagic_trailing_commar   !contains_unsplittable_type_ignorerg   contains_standalone_commentsr   Zstring_processingis_defleft_hand_splitobjectr   r   r   r   r   rl   delimiter_splitstandalone_comment_splitrk   rH   run_transformerrB   )rc   rT   rU   r   ZllZsnZstring_mergeZstring_paren_stripZstring_splitZstring_paren_wrapZtransformersr   r   	transformresultrQ   rQ   rR   transform_line  sz    	








r   c                   @   s   e Zd Ze Ze Ze ZdS )_BracketSplitComponentN)rM   rN   rO   r   headbodytailrQ   rQ   rQ   rR   r   e  s   r   )rc   	_featuresrT   rV   c                 c   s   g }g }g }|}d}| j D ]j}||u r`|jtv r`|j|u r`t|tr`t| t| |r\|n|}|| ||u r|jtv r|}|}q|st	dt
|| |tjd}	t
|| |tjd}
t
|| |tjd}t|	|
| |	|
|fD ]}|r|V  qd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.
    NNo brackets found	component)rb   rl   r!   opening_bracketrh   rJ   r(   rk   r"   rL   bracket_split_build_liner   r   r   r    bracket_split_succeeded_or_raise)rc   r   rT   tail_leavesbody_leaveshead_leavescurrent_leavesZmatching_bracketr   r   r   r   r   rQ   rQ   rR   r   k  sJ    	





r   )rc   rT   rU   r   rV   c                 c   s(   t | |d}t|| |||dE dH  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`.
    r   rU   r   N)_first_right_hand_split%_maybe_split_omitting_optional_parens)rc   rT   rU   r   Z
rhs_resultrQ   rQ   rR   r     s    
r   )rc   r   rV   c                 C   s   g }g }g }|}d}d}t | jD ]V}||u rB||u rB|r>|n|}|| ||u r"|jtv r"t||vr"|j}|}|}q"|r|r|std|  |  |  t	|| |t
jd}	t	|| |t
jd}
t	|| |t
jd}t|	|
| t|	|
|||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  )reversedrb   rk   rl   r!   idr  rL   reverser  r   r   r   r   r  r   )rc   r   r  r  r	  r
  r  closing_bracketr   r   r   r   rQ   rQ   rR   r    s@    




r  )r   rc   rT   rU   r   rV   c              
   c   s  t j|vr| jjtjkr| jjs| jjtjkr| jjs|j	s| j
dst| |jrt| jh|}zt||d}tj|jv rt| jjdkr| jjd jtjkrtdd | jjd d D rt| jt||jd d	d
r| jjd u rt||r.t|||||dE d H  W d S W np ty } zVt| j
sjt| j
|d
sjtd|n"| j s| j  rtd|W Y d }~n
d }~0 0 t!| j t!| j | j| j
| j fD ]}|r|V  qd S )Nr   r   r   c                 s   s   | ]}|j tv V  qd S rW   )rl   r    .0r   rQ   rQ   rR   	<genexpr>      z8_maybe_split_omitting_optional_parens.<locals>.<genexpr>r   r\   )r   r   r  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  rl   rI   rz   rq   r  r{   	is_importr   r   r   r   r  r  r   Z/prefer_splitting_right_hand_side_of_assignmentsrT   ra   r   rb   EQUALanyr   r   r   _prefer_split_rhs_oopr  rL   r   contains_multiline_stringsr   r(   )r   rc   rT   rU   r   rhs_ooper   rQ   rQ   rR   r    s~    



	




r  )r  rT   rV   c                 C   s~   d}t | jjD ]&}|jtjkr$ q8|jtv rd} q8q|p|tdd | jjD r`t| j|dp|| j	 p|| j
	 p|| j	 S )z\
    Returns whether we should prefer the result from a split omitting optional parens.
    FTc                 s   s   | ]}|j tjkV  qd S rW   )rl   rI   r  r  rQ   rQ   rR   r  =  r  z(_prefer_split_rhs_oop.<locals>.<genexpr>r   )r  r   rb   rl   rI   r  r!   r  r   r   r   r   )r  rT   Z has_closing_bracket_after_assignr   rQ   rQ   rR   r  +  s"    
	
r  )r   r   r   rV   c                 C   sB   t t| }|s>|dkr&tdn|dk r>td| d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)ra   r   r   rL   )r   r   r   Ztail_lenrQ   rQ   rR   r  H  s    

r  )rb   originalr  r  rV   c                C   sv  t |j|jd}|tju rd|_| jd7  _| rt| d dd |jo|jdkot	dd | D  ot	d	d | d j
t| d j
d
dfD  }|js|rtt| d ddD ]D}| | jtkrq| | jtjkrttjd}| |d |  qqt }|tju rt| }| D ]>}	|j|	dt|	|v d ||	D ]}
|j|
dd q:q|tju rrt||rrd|_|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.
    r]   Tr\   r   rf   r   c                 s   s   | ]}|j tjkV  qd S rW   )rl   rI   COMMAr  rQ   rQ   rR   r  ~  r  z+bracket_split_build_line.<locals>.<genexpr>c                 s   s0   | ](}t |trt |jtr|jjtkV  qd S rW   )rh   rK   ry   rJ   rl   r#   )r  re   rQ   rQ   rR   r    s   r   Nr   r   )preformattedZtrack_bracketr!  )r   rT   r^   r   r   rg   rn   r   rq   r  r   getattrr  rangera   rl   r$   rI   r   rJ   insertr   r   r   rk   r  comments_aftershould_split_liner   )rb   r  r  r  r   Z	no_commasr   	new_commaZleaves_to_trackr   comment_afterrQ   rQ   rR   r  b  sR    
	

r  )
split_funcrV   c                    s,   t  ttt ttt d fdd}|S )zNormalize prefix of the first leaf in every line returned by `split_func`.

    This is a decorator over relevant split functions.
    rc   rU   rT   rV   c                 3   s.    | ||D ]}t |jd dd |V  qd S )Nr   Trf   )rn   rb   )rc   rU   rT   Z
split_liner*  rQ   rR   split_wrapper  s    z0dont_increase_indentation.<locals>.split_wrapper)r   r   r   r   r   r   )r*  r-  rQ   r,  rR   dont_increase_indentation  s
    
r.  )rc   rV   c                 C   s8   t t| jd ddD ]}| j| jtkr|  S qd S )Nr\   r   r   )r$  ra   rb   rl   r$   )rc   leaf_idxrQ   rQ   rR   _get_last_non_comment_leaf  s    
r0  )safedelimiter_priorityrc   rV   c                 C   sH   | rD|t krD|jd jtjkrD|jd jtkrDttjd}|| |S )Nr   r   )r   rb   rl   rI   r   r$   rJ   rk   )r1  r2  rc   r(  rQ   rQ   rR   _safe_add_trailing_comma  s    
r3  r+  c                 #   s  zj d }W n ty*   tddY n0 j}z|jt|hd}W n tyd   tddY n0 |tkr||dkrtdt	j
jjd tj}d	}ttt	 d
 fdd}t}	tj D ]\}
}||E dH  |D ]}||E dH  qt||j}|j|krdt|tjhdr>|o:tj|v }n&t|tjtjhdrd|obtj|v }tj|v r|j t!kr|
|	krt"||  |j#$t|}||krΈ V  t	j
jjd qΈ rt"||   V  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 emptyNexcludezNo delimiters foundr\   z7Splitting a single attribute from its owner looks wrongrT   r^   rg   Tr   c                 3   sN   z j | dd W n6 tyH    V  tjjjd  |  Y n0 dS )EAppend `leaf` to current line or to new line if appending impossible.Tr"  r6  NZappend_safe
ValueErrorr   rT   r^   rg   rk   r   r_   rc   rQ   rR   append_to_line  s    z'delimiter_split.<locals>.append_to_line)Zwithin)%rb   
IndexErrorrL   ri   max_delimiter_priorityr  r9  r   Zdelimiter_count_with_priorityr   rT   r^   rg   sysmaxsizerJ   r   r0  r   r&  minZbracket_depthr7   r:   Ztypedargslistr   ZTRAILING_COMMA_IN_DEFZarglistargumentZTRAILING_COMMA_IN_CALLr   Zadd_trailing_comma_consistentlyrl   r$   r3  
delimitersget)rc   rU   rT   	last_leafZbtr2  Zlowest_depthZtrailing_comma_safer<  Zlast_non_comment_leafr/  r   r)  Zleaf_priorityrQ   r;  rR   r     sf    	r   c                 #   s    dstdtjjjd ttt d fdd}jD ]0}||E dH  	|D ]}||E dH  qbqF r V  dS )z4Split standalone comments from the rest of the line.r   z*Line does not have any standalone commentsr6  r   c                 3   sN   z j | dd W n6 tyH    V  tjjjd  |  Y n0 dS )r7  Tr"  )r^   rg   Nr8  r:  r;  rQ   rR   r<  0  s    z0standalone_comment_split.<locals>.append_to_lineN)
r   rL   r   rT   r^   rg   rJ   r   rb   r&  )rc   rU   rT   r<  r   r)  rQ   r;  rR   r   $  s    

r   )r   rg   rV   c                C   sV   |sL| j d}d|d vrL|d d}t|dkr>|d8 }d| | _ dS d| _ dS )	zLeave existing extra newlines if not `inside_brackets`. Remove everything
    else.

    Note: don't use backslashes for formatting or you'll lose your voting rights.
    #r   r   r   r   r\   Nrx   )r   splitcountra   )r   rg   ZsplZnl_countrQ   rQ   rR   rn   G  s    
rn   )re   r   rT   rU   rV   c          	      C   s  t | jddD ]}|jtv r dS q| jtjkr<t| || d}tt	| j
D ]\}}t|tr~|jtjkr~t||||d |dkrt|tr|jtjkrd}|r|jtjkr| jtjkrt|jtr|jjtjkr|jjdkrt|| ddrt| |dd	 nt|tr4| jtjkr4t||  n|jtjkr`t|| d
rt| |dd	 nt|rzt| |dd	 np| jtjkrt| ||  qnN|dkr|jtjkr| jtjkrqNn$t|trt|st| |dd	 |jtjk}t|to|j|v p|}qNd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)Zis_endmarkerNr   r   Tr   r   r   r   r\   ) r   r   rq   r   rl   r:   	with_stmt_maybe_wrap_cms_in_parensr   r   r   rh   rK   	annassignr   Ztestlist_star_exprr   for_stmtry   rJ   rI   NAMEr   r;   remove_with_parensr2   import_from_normalize_import_fromSTARexcept_clauser/   r   )	re   r   rT   rU   ZpcZ
check_lparr   r   Zcomma_checkrQ   rQ   rR   r   Y  sz    








r   )r   r   r   rV   c                 C   sd   t |r.t| jd sJ d|_d| jd _n2|jtjkr`| |ttj	d | 
ttjd d S )Nr   rx   )r.   r3   r   rq   rl   rI   rR  r|   rJ   rz   r}   r{   )r   r   r   rQ   rQ   rR   rQ    s    rQ  rd   c                 C   s  | j d jtjkrt| j dkr| j d jtjkr| j d j d jtjkrt| j d | ddrzt	| | j d 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rt| t| n:|jtjkr|j d jtjkrt| t| t| d S )Nr   r\   Tr   Fr   r   )r   rl   rI   AWAITra   r:   r   rz   r   r;   r   rJ   rh   rK   r   r(   r   )re   r  r  Zbracket_contentsrQ   rQ   rR   r     s2    $	

r   )re   rT   rU   rV   c           
      C   s   t j|vs4tj|vs4t| jdks4| jd jtjkr8dS d}t	dt| jD ]}| j| jt
jkrL|} qlqL|durtt
jd}tt
jd}| jd| }|D ]}|  qttj|ttj||g}	| d|	 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   r\   Nrx   )r   ZPARENTHESIZED_CONTEXT_MANAGERSr   Z(wrap_multiple_context_managers_in_parensra   r   rl   r:   r   r$  rI   r   rJ   rz   r{   r   rK   testlist_gexpr|   )
re   rT   rU   Zcolon_indexr   r~   r   Zcontext_managersr   	new_childrQ   rQ   rR   rK    s0    
rK  )re   r   rV   c                 C   s   | j tjkrJt| |ddr(t|| dd t| jd trt| jd |  nx| j tj	krx| jD ]}t|tr\t||  q\nJ| j tj
krtdd |  D st| jd | ddrt| | jd dd d	S )
z6Recursively hide optional parens in `with` statements.Tr   Fr   r\   c                 s   s   | ]}|j tjkV  qd S rW   )rl   rI   
COLONEQUALr  rQ   rQ   rR   r  ,  s   z%remove_with_parens.<locals>.<genexpr>r   N)rl   r:   r   r   r;   rh   r   rK   rO  rU  Zasexpr_testr  rb   )re   r   r   rQ   rQ   rR   rO    s,    

rO  F)re   r   r   rV   c                 C   s   | j tjksHt| sHt| sHt| r0|j tjksH|s@t| tksHt	| rLdS t
| r|j tjtjtjtjtjtjtjtjtjtjf
v rdS | jd }| jd }t|rt|r| jd }d|_d|_t|||d t|r||jd  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.
    Fr   r   r\   rx   r   T)rl   r:   r   r-   r2   r9   Z	expr_stmtr   r   r6   r8   rL  Zassert_stmtZreturn_stmtrS  ZfuncdefrJ  rM  Zdel_stmtr   r.   r3   rq   r   r+   r   )re   r   r   firstlastZmiddlerQ   rQ   rR   r   7  s\    

	




r   )rc   r  rV   c              	   C   s   |j r|jdv sdS t }d}z:| jd }|jtjkrHd}|t| | j	j
|d}W n ttfyp   Y dS 0 |tko| 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   Tr4  )r   rq   r   rb   rl   rI   r   addr  ri   r>  r=  r9  r   rT   r   r:   r   rP  )rc   r  r5  Ztrailing_commarE  Zmax_priorityrQ   rQ   rR   r'  y  s     
r'  )rc   r   rV   c                 c   s  t  }| js|V  d| j }d}d}t  }| jddD ]~\}}}	||	7 }||krX q|	t|jt|j k}
|jtks~|
r q|r||u rd}nb|jt	v r|dkr| j
|d  nd}|r|jtjkr|jdurt|j|| j
s q|t| q6|jt	v r6|dkr| j
|d  nd}|rB|jtv rB|t| q6|rn|t| || |  |V  |r|jtjkr|jdurt|j|| j
s q|jr6|j}|}q6d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)r  r   r\   )r   r   r^   Zenumerate_with_lengthra   rq   r   rl   r$   r!   rb   rI   r   r  r1   rZ  r  r"   updateclear)rc   r   r   lengthr  r  Zinner_bracketsr   r   Zleaf_lengthZhas_inline_commentprevrQ   rQ   rR   r     sj    







r   rx   r   )rc   r   rT   rU   r   rV   c                   s(  |st | }g }|| | D ]2}t|d|kr:td|t| |d qt|}tj|v s|j	j
dks| jjrtdd | jjD s|  s|d  s|d  st|d  dstd	d | jD r|S |  }t|| | j |tjhB }	t|| |	|d
}
t fdd|
D r$|
}|S )Nr   z-Line transformer returned an unchanged result)rT   rU   r   c                 s   s   | ]}|j V  qd S rW   )rq   )r  ZbracketrQ   rQ   rR   r    r  z"run_transformer.<locals>.<genexpr>r   r   c                 s   s   | ]}|j d u V  qd S rW   rI  r  rQ   rQ   rR   r    r  r   c                 3   s   | ]}t | d V  qdS )r   N)r   )r  lnr   rQ   rR   r  	  r  )r   r   r   rB   extendr   r   r   r  rw   rM   ri   Z	invisibler  r  r   r   r   rb   cloner   r   all)rc   r   rT   rU   r   r   Ztransformed_lineZfeatures_setZ	line_copyZfeatures_fopZsecond_opinionrQ   r   rR   r     sH    



r   )rQ   )rQ   rQ   )rQ   )rQ   rQ   )F)yrP   r?  Zdataclassesr   enumr   r   	functoolsr   r   typingr   r   r	   r
   r   r   r   Zblack.bracketsr   r   r   r   Zblack.commentsr   r   r   Zblack.linesr   r   r   r   r   r   r   Z
black.moder   r   r   Zblack.nodesr   r    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;   Zblack.numericsr<   Zblack.stringsr=   r>   r?   r@   rA   Zblack.transrB   rC   rD   rE   rF   rG   rH   Zblib2to3.pgen2rI   Zblib2to3.pytreerJ   rK   r   ZLeafIDr   rL   rS   r   r   r   r   r  r  boolr  r  r  r.  r0  r3  r   r   rn   r   r   rQ  r   rK  rO  r   r'  r   r   rQ   rQ   rQ   rR   <module>   s   $$	|$	    
u
2   4  MJ
S
"V&
+- BR