a
    g	gbd                     @   sV  U d Z ddlZddlmZmZmZmZmZmZm	Z	m
Z
 ejdkrNddlmZ nddlmZ ejdkrrddlmZ nddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZmZmZmZ ee ejZ ee!d< e	dZ"e
eef Z#e$Z%e$Z&ej'ej(ej)hZ*ee!d< e j+e j,e j-e j.e j/e j0e j1e j2e j3e j4h
Z5ee!d< dZ6ee!d< dej7e6< ddhZ8ee!d< ej9ej:ej;ej<ej=ej>hZ?ee!d< ej@ejAejBejCejDejEejFejGejHejIejJejKejLejMhZNee!d< ejGejMhZOee!d< eOejHhB ZPee!d< e jQe jRe jSe jTe jUhZVee!d< e jWe jXe jYe jZe j[e j\e j]hZ^ee!d< e j_e j`e jae jbe jce jde jee jfe jge jhe jie jje jSe jke jlhZmee!d< e jne johZpee!d< h dZqee!d < e jre j[e jshZtee!d!< ejuejvejwejxejyejziZ{ee!d"< e|e{} Z~ee!d#< e|e{ Zee!d$< e~eB Zee!d%< eeje6hB Zee!d&< d'Zed(d)G d*d+ d+ee" Zeeed,d-d.Zee# ee d/d0d1Zee# eee&  ed2d3d4Zee# ee& d/d5d6Zee#ee# d7d8d9Ze#e#dd:d;d<Zee#d=d>d?Ze#ee d/d@dAZe#ed/dBdCZeed=dDdEZe#ed/dFdGZe#ed/dHdIZe#ed/dJdKZejuejvffeeee ee$e$f edLdMdNZe#ed/dOdPZde#eedRdSdTZe#ed/dUdVZe#ed/dWdXZeee& edYdZd[Zeed=d\d]Zeed/d^d_Ze#ed/d`daZe#ed/dbdcZeed=dddeZeed=dfdgZeed=dhdiZeed=djdkZeed=dldmZeed=dndoZdeeedqdrdsZd(dtee#eddudvdwZe#ee# d/dxdyZedd=dzd{Zeee d|d}d~Zeee d|ddZeee d|ddZeee d|ddZeee d|ddZeed=ddZdS )z>
blib2to3 Node/Leaf transformation-related utility functions.
    N)GenericIteratorListOptionalSetTupleTypeVarUnion)      )Final)r
   
   )	TypeGuard)
mypyc_attr)	CACHE_DIR)has_triple_quotes)pygram)token)NLLeafNode	type_reprsymsT
WHITESPACE	STATEMENT   STANDALONE_COMMENTandorLOGIC_OPERATORSCOMPARATORSMATH_OPERATORSSTARSVARARGS_SPECIALSVARARGS_PARENTSUNPACKING_PARENTSTEST_DESCENDANTSTYPED_NAMES>   =z/=z**=z*=z>>=z-=z@=z<<=z%=z^=z&=z//=z+=z|=ASSIGNMENTSIMPLICIT_TUPLEBRACKETOPENING_BRACKETSCLOSING_BRACKETSBRACKETSALWAYS_NO_SPACE7   T)Zallow_interpreted_subclassesc                   @   s8   e Zd ZdZeee dddZeee dddZdS )VisitorzBBasic lib2to3 visitor that yields things of type `T` on `visit()`.nodereturnc                 c   s`   |j dk rtj|j  }ntt|j }t| d| d}|rL||E dH  n| |E dH  dS )az  Main method to visit `node` and its children.

        It tries to find a `visit_*()` method for the given `node.type`, like
        `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects.
        If no dedicated `visit_*()` method is found, chooses `visit_default()`
        instead.

        Then yields objects of type `T` from the selected visitor.
           visit_N)typer   tok_namestrr   getattrvisit_default)selfr4   nameZvisitf r?   N/var/www/html/llm_bihealth/app/venv/lib/python3.9/site-packages/black/nodes.pyvisit   s    

zVisitor.visitc                 c   s*   t |tr&|jD ]}| |E dH  qdS )zCDefault `visit_*()` implementation. Recurses to children of `node`.N)
isinstancer   childrenrA   )r=   r4   childr?   r?   r@   r<      s    

zVisitor.visit_defaultN)	__name__
__module____qualname____doc__LNr   r   rA   r<   r?   r?   r?   r@   r2      s   r2   )leafcomplex_subscriptr5   c                C   sP  d}d}d}| j }| j}| j}|tv r*|S |tjkr8|S |dusNJ d| |tjkrr|j tjtj	tj
hvrr|S | j}|st|}	|	r|	j tv r|S |tjkr|	j tjkr|S |	j tjkr|s|S |S |	j tjkr|	jr |	jj tjtjtjtjhv r|S |	jj tjkr |	jS n|	j tjkrNt|	tjkrNt|	jtj	krN|S |	j tv rrt|	ttB dr |S n|	j tjkr|	jr |	jj tjtj
hv r |r|S |S nR|	jr|	jj tjkr|	j tv r|S |	j tjkr|jr|jj tj kr|S n|j tv r|S |j tjtjhv rB|r:|j tjkrL|S n
|j tjkrl|rL|j tjkrL|S n|j tjkr|s|S |tjkr|j t!vr|S n&|j tjkr|jS |j tjkrL|S n|j t!v r|sLt|}	|	r|	j tjkrL|S nJ|j tj"krf|tj#ks(|tj$kr,|S |sP|tj%ksJ|tj&krb|S n|j tjkrL|S n|j tjkr|tjkr|S |st|}	|	r|	j tj#kr|S n|j tjhtB v rL|S n|j tj kr|S |j tj'kr$|r|S t|}	|	r|	j tjks|	j tj%krL|S n(|j tj(kr^|tj#krB|S |rL|j tj#krL|S n|j tjtj
hv r|s|jdusJ d|jj tj	kr|S |S |sL|S n|j tj)kr|rL|tj%krL|S nr|j tj*kr|rL|j tj+krL|S nH|j tjtjhv r|st|}	|	r8|	j tv r<|S |	j}
|
dusPJ |	j tjkrv|
j tjtj
hv rv|S |	j tjkr|
j tjkr|S n|tj,tj-tj.hv rL|S n|j tj/kr|tj%kr|r|j tj%kr|S n2|tj,krL|dkr|S |rL|j tj%krL|S n0|j tj
kr.|S |j tj0krL|tjkrL|S |S )	zReturn whitespace prefix if needed for the given `leaf`.

    `complex_subscript` signals whether the given leaf is part of a subscription
    which has non-trivial arguments, like arithmetic expressions or function calls.
      z  Nz/INTERNAL ERROR: hand-made leaf without parent: )withinzsubscripts are always parentedimport)1r8   parentvaluer0   r   COMMENTCOLONr   Z	subscriptZsubscriptlistZsliceopprev_siblingpreceding_leafr-   COMMAEQUALarglistargument
parametersvarargslisttypedargslistprefixSTARparent_type	star_exprr$   	is_varargr%   r&   Zfactorr"   AT	decoratorr(   trailerLPARRPARDOTLSQBZdotted_nameclassdefatomdictsetmaker
DOUBLESTARNAMENUMBERSTRINGimport_fromexcept_clause)rJ   rK   NOSPACEZDOUBLESPACEtpvprevZprevpZprevp_parentr?   r?   r@   
whitespace   s>   


&"
rx   r3   c                 C   sP   | rL| j }|rDt|tr|S zt| d W S  tyB   Y dS 0 | j} q dS )z3Return the first leaf that precedes `node`, if any.N)rT   rB   r   listleaves
IndexErrorrP   )r4   resr?   r?   r@   rU     s    
rU   )r4   tokensr5   c                 C   sJ   |sdS |d du r| du S | s$dS | j |d kr6dS t| j|dd S )a;  Return if the `node` and its previous siblings match types against the provided
    list of tokens; the provided `node`has its type matched against the last element in
    the list.  `None` can be used as the first element to declare that the start of the
    list is anchored at the start of its parent's children.Try   NF)r8   prev_siblings_arerT   )r4   r~   r?   r?   r@   r     s    r   c                 C   s   | du s| j du rdS | j jS )z|
    Returns:
        @node.parent.type, if @node is not None and has a parent.
            OR
        None, otherwise.
    N)rP   r8   r4   r?   r?   r@   r_     s    r_   )ancestor
descendantr5   c                 C   s   |}|r|j | kr|j }q|S )z:Return the child of `ancestor` that contains `descendant`.)rP   )r   r   r4   r?   r?   r@   child_towards  s    r   )	old_child	new_childr5   c                 C   s.   | j }|sdS |  }|dur*||| dS )z
    Side Effects:
        * If @old_child.parent is set, replace @old_child with @new_child in
        @old_child's underlying Node structure.
            OR
        * Otherwise, this function does nothing.
    N)rP   removeinsert_child)r   r   rP   Z	child_idxr?   r?   r@   replace_child  s    r   )rJ   r5   c                 C   s`   | j }| }|r\|j}|du rq\|jd j |kr0q\|jtjkr>q\|jdurV|jjtv rVq\|}q
|S )zReturn `leaf` or one of its ancestors that is the topmost container of it.

    By "container" we mean a node where `leaf` is the very first child.
    Nr   )r]   rP   rC   r8   r   Z
file_inputrT   r/   )rJ   Zsame_prefix	containerrP   r?   r?   r@   container_of  s    r   c                 C   s*   t | tr| S | jr"t| jd S dS dS )z(Returns the first leaf of the node tree.r   N)rB   r   rC   first_leaf_ofr   r?   r?   r@   r     s
    
r   c                 C   s   | j tjtjtjtjhv S )z?Whether node is an arithmetic or a binary arithmetic expression)r8   r   
arith_expr
shift_exprxor_exprand_exprr   r?   r?   r@   is_arith_like  s    r   c                 C   s>   t | jd tjtjtjgrdS t | jtjtjtjgr:dS dS )NTF)	r   rP   r   NEWLINEINDENTr   simple_stmtrZ   rS   rJ   r?   r?   r@   is_docstring  s    r   c                 C   s>   | j tjko<t| jdko<| jd j tjko<| jd j tjkS )z+Return True if `node` holds an empty tuple.   r      )r8   r   rj   lenrC   r   re   rf   r   r?   r?   r@   is_empty_tuple  s    r   c                 C   sv   | j tjkrLt| }|du s(|j tjkr,dS t|jdkoJ|jd j tjkS | j t	v ott| jdkot| jd j tjkS )zMReturn True if `node` holds a tuple with one element, with or without parens.NFr   r   )
r8   r   rj   unwrap_singleton_parenthesistestlist_gexpr   rC   r   rV   r+   r4   Zgexpr?   r?   r@   is_one_tuple&  s     
r   c                 C   sD   | j tjkrdS t| }|du s,|j tjkr0dS tdd |jD S )zDReturn True if `node` holds a tuple that contains a walrus operator.FNc                 s   s   | ]}|j tjkV  qd S N)r8   r   namedexpr_test).0rD   r?   r?   r@   	<genexpr>>      z-is_tuple_containing_walrus.<locals>.<genexpr>)r8   r   rj   r   r   anyrC   r   r?   r?   r@   is_tuple_containing_walrus6  s    r   )openingclosingr{   bracketsr5   c           	      C   s   | j |j f|krdS |jd }t|D ]\}}|| u r& qDq&tdd}|d7 }||d D ]X}||u rl q|j}||kr\|j tjkr\|d7 }|jr\|jj tjtj	hv r\|d7 } qq\|dk S )zIReturn True if content between `opening` and `closing` is a one-sequence.Fr   z#Opening paren not found in `leaves`r   Nr   )
r8   bracket_depth	enumerateLookupErrorr   rV   rP   r   rX   r\   )	r   r   r{   r   depthZ_opening_indexrJ   Zcommasr   r?   r?   r@   is_one_sequence_betweenA  s,    
r   c                 C   s   t | }|duo|jtjkS )z7Return True iff `node` is of the shape ( test := test )N)r   r8   r   r   )r4   innerr?   r?   r@   is_walrus_assignmentf  s    r   F)r4   lastr5   c                 C   s   | j tjkot| jdkr>| jd j tjkr>| jd j tjkp|rtt| jdkrt| jd j tjkrt| jd j tj	kp|ot| jdko| jd j tjko| jd j tj	kS )z?Return True iff `node` is a trailer valid in a simple decoratorr   r   r   r
   )
r8   r   rd   r   rC   r   rg   rm   re   rf   )r4   r   r?   r?   r@   is_simple_decorator_trailerl  s(    r   c                 C   sp   | j tjkrdS | j tjkrl| jrl| jd j tjkojttt| jdd ojt	| jdk pjt| jd ddS dS )a\  Return True iff `node` could be a 'dotted name' decorator

    This function takes the node of the 'namedexpr_test' of the new decorator
    grammar and test if it would be valid under the old decorator grammar.

    The old grammar was: decorator: @ dotted_name [arguments] NEWLINE
    The new grammar is : decorator: @ namedexpr_test NEWLINE
    Tr   r   ry   r   )r   F)
r8   r   rm   r   powerrC   allmapr   r   r   r?   r?   r@   is_simple_decorator_expression  s    	r   c                 C   sx   | j tjkrdS t| r&| jdkr&dS | j tjkr6dS t| jdkrHdS | j\}}}|j tj	krt|j tj
krtt|S dS )zAReturn True if `node` holds a `yield` or `yield from` expression.TyieldFr
   )r8   r   Z
yield_expris_name_tokenrQ   rj   r   rC   r   re   rf   is_yield)r4   lparexprrparr?   r?   r@   r     s    r   )rJ   rN   r5   c                 C   s@   | j tvs| jsdS | j}|j tjkr6|js0dS |j}|j |v S )aF  Return True if `leaf` is a star or double star in a vararg or kwarg.

    If `within` includes VARARGS_PARENTS, this applies to function signatures.
    If `within` includes UNPACKING_PARENTS, it applies to right hand-side
    extended iterable unpacking (PEP 3132) and additional unpacking
    generalizations (PEP 448).
    F)r8   r$   rP   r   r`   )rJ   rN   ru   r?   r?   r@   ra     s    ra   c                 C   s   t | jod| jv S )zKReturn True if `leaf` is a multiline string that actually spans many lines.
)r   rQ   r   r?   r?   r@   is_multiline_string  s    r   c                 C   sV   t | jdksD| jd jtjksD| jd jtjksD| jd jtjkrHdS t| jd S )z2Return True if `node` is a suite with a stub body.   r   r   r
   Fr   )r   rC   r8   r   r   r   DEDENTis_stub_bodyr   r?   r?   r@   is_stub_suite  s    r   c                 C   sd   t | tr| jtjkrdS t| jdkr,dS | jd }|jtjkobt|jdkobtdd |jD S )zCReturn True if `node` is a simple statement containing an ellipsis.Fr   r   r
   c                 s   s   | ]}|t tjd kV  qdS ).N)r   r   rg   )r   rJ   r?   r?   r@   r     r   zis_stub_body.<locals>.<genexpr>)	rB   r   r8   r   r   r   rC   rj   r   )r4   rD   r?   r?   r@   r     s    
r   c                 C   sp   t | ts| jtjkrdS | jd | jd  }}t |ton|jtjkon|jdkont |ton|jtj	kon|jdkS )zGiven a `LN`, determines whether it's an atom `node` with invisible
    parens. Useful in dedupe-ing and normalizing parens.
    Fr   ry   rL   )
rB   r   r8   r   rj   rC   r   re   rQ   rf   )r4   firstr   r?   r?   r@   is_atom_with_invisible_parens  s    


r   c                 C   s   t | pt| S r   )is_empty_lparis_empty_rparr   r?   r?   r@   is_empty_par  s    r   c                 C   s   | j tjko| jdkS NrL   )r8   r   re   rQ   r   r?   r?   r@   r     s    r   c                 C   s   | j tjko| jdkS r   )r8   r   rf   rQ   r   r?   r?   r@   r     s    r   c                 C   sP   | j }| j}| j}t|tjkoL|dkr6|r6|jtjkpL|dkoL|oL|jtjkS )z9Return True if the given leaf starts an import statement.rO   from)	rP   r8   rQ   boolr   rm   r   import_namerp   )rJ   ru   rt   rv   r?   r?   r@   	is_import
  s    
r   c                 C   sR   t | jtjko*| jdko*| jo*| jjtjkpPt | jtjkoN| j	oN| j	jtjkS )zDReturn True if the given leaf starts a with or async with statement.with)
r   r8   r   rm   rQ   rP   r   	with_stmtASYNCZnext_siblingr   r?   r?   r@   is_with_or_async_with_stmt  s    r   c                 C   s*   t | jtjko&| jo&| jjtjtjhv S )zReturn True if the given leaf starts an async def/for/with statement.

    Note that `async def` can be either an `async_stmt` or `async_funcdef`,
    the latter is used when it has decorators.
    )r   r8   r   r   rP   r   Z
async_stmtZasync_funcdefr   r?   r?   r@   is_async_stmt_or_funcdef&  s    r   rL   )rJ   suffixr5   c                 C   s(   | j }| j}|tjthv o&|d| S )zdReturn True if the given leaf is a special comment.
    Only returns true for type comments for now.z# type:)r8   rQ   r   rR   r   
startswith)rJ   r   rt   rv   r?   r?   r@   is_type_comment3  s    r   )visible)rP   rD   r   r5   c                C   sh   t tj|rdnd}t tj|r"dnd}|j}d|_| p>d}ttj|||g}||_| 	|| dS )zWrap `child` in parentheses.

    This replaces `child` with an atom holding the parentheses and the old
    child.  That requires moving the prefix.

    If `visible` is False, the leaves will be valueless (and thus invisible).
    (rL   )r   N)
r   r   re   rf   r]   r   r   r   rj   r   )rP   rD   r   r   r   r]   indexr   r?   r?   r@   wrap_in_parentheses;  s    r   c                 C   s>   t | jdkrdS | j\}}}|jtjkr6|jtjks:dS |S )zqReturns `wrapped` if `node` is of the shape ( wrapped ).

    Parenthesis can be optional. Returns None otherwiser
   N)r   rC   r8   r   re   rf   )r4   r   wrappedr   r?   r?   r@   r   M  s    r   c                 C   s*   | j tjkrd| _n| j tjkr&d| _dS )zMake sure parentheses are visible.

    They could be invisible as part of some statements (see
    :func:`normalize_invisible_parens` and :func:`visit_import_from`).
    r   r   N)r8   r   re   rQ   rf   r   r?   r?   r@   ensure_visible[  s    r   )nlr5   c                 C   s   | j tjkS r   )r8   r   rm   r   r?   r?   r@   r   g  s    r   c                 C   s   | j tjkS r   )r8   r   re   r   r?   r?   r@   is_lpar_tokenk  s    r   c                 C   s   | j tjkS r   )r8   r   rf   r   r?   r?   r@   is_rpar_tokeno  s    r   c                 C   s   | j tjkS r   )r8   r   ro   r   r?   r?   r@   is_string_tokens  s    r   c                 C   s   | j tjkS r   )r8   r   rn   r   r?   r?   r@   is_number_tokenw  s    r   c                 C   sJ   | j }|durF|jr&|jjtjkr&dS |j r>|j jtjkr>dS |j }qdS )z6Returns whether this leaf is part of type annotations.NTF)rP   rT   r8   r   RARROWr   tname)rJ   r   r?   r?   r@   is_part_of_annotation{  s    r   )F)rL   )rH   systypingr   r   r   r   r   r   r   r	   version_infor   Ztyping_extensionsr   Zmypy_extensionsr   Zblack.cacher   Zblack.stringsr   Zblib2to3r   Zblib2to3.pgen2r   Zblib2to3.pytreer   r   r   r   Z
initializeZpython_symbolsr   __annotations__r   rI   intZLeafIDZNodeTyper   r   r   r   Zif_stmtZ
while_stmtZfor_stmtZtry_stmtrq   r   Zfuncdefri   Z
match_stmtZ
case_blockr   r   r9   r    LESSGREATEREQEQUALNOTEQUAL	LESSEQUALGREATEREQUALr!   VBAR
CIRCUMFLEXAMPER	LEFTSHIFT
RIGHTSHIFTPLUSMINUSr^   SLASHDOUBLESLASHPERCENTrb   TILDErl   r"   r#   r$   rX   rY   rd   r\   r[   r%   rj   rk   Z	listmakerr   Ztestlist_star_exprZsubject_exprpatternr&   testZlambdefZor_testZand_testZnot_testZ
comparisonr`   r   r   r   r   r   Ztermr   r'   r   Z
tname_starr(   r*   ZtestlistZexprlistr+   re   rf   rh   RSQBLBRACERBRACEr,   setkeysr-   valuesr.   r/   rV   r0   r   r2   r   r:   rx   rU   r   r_   r   r   r   r   r   r   r   r   r   r   r   r   r   r   ra   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r?   r?   r?   r@   <module>   s,  (



	
" g




%