o
    DDi9                    @   s  U d dl Z d dl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 d dlmZ d dlmZmZ d dlmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ d d	l,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 d d
l3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z; d dl<m=Z=m>Z>m?Z?m@Z@mAZA d dlBmCZC eDdejEZFeeG eHd< G dd deeZIG dd deeZJG dd deeZKeeddG dd deKZLeeddG dd deKZMeeddG dd deKZNeeddG dd deKZOeeddG dd  d eKZPeeddG d!d" d"eKZQG d#d$ d$eeZReeddG d%d& d&eReJZSeeddG d'd( d(eReIZTeeddG d)d* d*eZUG d+d, d,eJeZVeeddG d-d. d.eVZWeeddG d/d0 d0eIZXeeddG d1d2 d2eZYeeddG d3d4 d4eZZeeddG d5d6 d6eZ[eeddG d7d8 d8eZ\eeddG d9d: d:eVZ]eeddG d;d< d<eVZ^eeddG d=d> d>eZ_eeddG d?d@ d@eKZ`eeddG dAdB dBeKZaeeddG dCdD dDeZbeeddG dEdF dFeKZceeddG dGdH dHeKZdeeddG dIdJ dJeKZeeeddG dKdL dLeZfdMeeIeeeSeVf  f dNegdOe
eG fdPdQZheeddG dRdS dSeVZieeddG dTdU dUeVZjeeddG dVdW dWeZkeeddG dXdY dYeVZleeddG dZd[ d[eVZmeeddG d\d] d]eVZneeddG d^d_ d_eKZoeeddG d`da daeKZpeeddG dbdc dceZqeeddG ddde deeKZreeddG dfdg dgeKZsG dhdi dieeZteeddG djdk dkeVZueeddG dldm dmeZveeddG dndo doetZweeddG dpdq dqetZxeeddG drds dseZyeeddG dtdu dueZzG dvdw dweteZ{eeddG dxdy dye{Z|eeddG dzd{ d{e{Z}eeddG d|d} d}eZ~eeddG d~d detZeeddG dd deZeeddG dd detZeeddG dd detZeeddG dd deZeeddG dd detZeeddG dd deZeeddG dd deZeeddG dd deZeeddG dd deZeeddG dd deZeeddG dd deKZdS )    N)ABCabstractmethod)	dataclassfield)LiteralOptionalPatternSequenceUnion)	add_slots)MaybeSentinel)CSTNodeCSTValidationError)_BaseParenthesizedNode
AnnotationArgAsynchronous	AttributeBaseAssignTargetExpressionBaseDelTargetExpressionBaseExpressionConcatenatedStringExpressionPositionFromLeftCurlyBrace	LeftParenLeftSquareBracketListName
ParametersRightCurlyBrace
RightParenRightSquareBracketSimpleStringTuple)CodegenStatevisit_body_sequencevisit_optionalvisit_requiredvisit_sentinelvisit_sequence)AssignEqual	BaseAugOpBitOrColonCommaDot
ImportStar	Semicolon)BaseParenthesizableWhitespace	EmptyLineParenthesizedWhitespaceSimpleWhitespaceTrailingWhitespace)CSTVisitorTz[ \f\t]+_INDENT_WHITESPACE_REc                   @   s.   e Zd ZU dZdZeed ed f ed< dS )	BaseSuiteu  
    A dummy base-class for both :class:`SimpleStatementSuite` and :class:`IndentedBlock`.
    This exists to simplify type definitions and isinstance checks.

        A suite is a group of statements controlled by a clause. A suite can be one or
        more semicolon-separated simple statements on the same line as the header,
        following the header’s colon, or it can be one or more indented statements on
        subsequent lines.

        -- https://docs.python.org/3/reference/compound_stmts.html
     BaseStatementBaseSmallStatementbodyN)__name__
__module____qualname____doc__	__slots__r
   r	   __annotations__r;   r;   r;   P/var/www/Datamplify/venv/lib/python3.10/site-packages/libcst/_nodes/statement.pyr:   E   s   
 r:   c                   @      e Zd ZdZdZdS )r<   zx
    A class that exists to allow for typing to specify that any statement is allowed
    in a particular location.
    r;   Nr?   r@   rA   rB   rC   r;   r;   r;   rE   r<   W       r<   c                   @   sJ   e Zd ZU dZdZejZee	ef e
d< e	ddededdfd	d
ZdS )r=   a'  
    Encapsulates a small statement, like ``del`` or ``pass``, and optionally adds a
    trailing semicolon. A small statement is always contained inside a
    :class:`SimpleStatementLine` or :class:`SimpleStatementSuite`. This exists to
    simplify type definitions and isinstance checks.
    r;   	semicolonFstatedefault_semicolonreturnNc                 C   s   d S Nr;   )selfrJ   rK   r;   r;   rE   _codegen_implq   s   z BaseSmallStatement._codegen_implF)r?   r@   rA   rB   rC   r   DEFAULTrI   r
   r2   rD   r   r%   boolrO   r;   r;   r;   rE   r=   `   s   
 r=   T)frozenc                   @   sx   e Zd ZU dZeed< edZeed< e	j
Zeee	f ed< ddd	Zd
edd fddZ	ddededdfddZdS )DelzQ
    Represents a ``del`` statement. ``del`` is always followed by a target.
    target whitespace_after_delrI   rL   Nc                 C   &   | j jr| jtjstdd S d S )Nz)Must have at least one space after 'del'.)rW   emptyrU   _safe_to_use_with_word_operatorr   RIGHTr   rN   r;   r;   rE   	_validate   s   zDel._validatevisitorc                 C   2   t t| d| j|t| d| j|t| d| j|dS )NrU   rW   rI   )rU   rW   rI   )rT   r(   rU   rW   r)   rI   rN   r^   r;   r;   rE   _visit_and_replace_children   s   
zDel._visit_and_replace_childrenFrJ   rK   c                 C   s   | |  |d | j| | j| W d    n1 s!w   Y  | j}t|tr9|r7|d d S d S t|trE|| d S d S )Ndel; )	record_syntactic_position	add_tokenrW   _codegenrU   rI   
isinstancer   r2   rN   rJ   rK   rI   r;   r;   rE   rO         


zDel._codegen_implrL   NrP   )r?   r@   rA   rB   r   rD   r6   r   rW   r   rQ   rI   r
   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   rT   w   s   
 
	
rT   c                   @   T   e Zd ZU dZejZeeef e	d< de
dd fddZ	dded	edd
fddZd
S )Passz*
    Represents a ``pass`` statement.
    rI   r^   rL   c                 C      t t| d| j|dS NrI   )rI   )rl   r)   rI   r`   r;   r;   rE   ra         z Pass._visit_and_replace_childrenFrJ   rK   Nc                 C   v   | |  |d W d    n1 sw   Y  | j}t|tr-|r+|d d S d S t|tr9|| d S d S )Npassrc   rd   re   rI   rg   r   r2   rf   rh   r;   r;   rE   rO         

zPass._codegen_implrP   r?   r@   rA   rB   r   rQ   rI   r
   r2   rD   r8   ra   r%   rR   rO   r;   r;   r;   rE   rl      s   
 rl   c                   @   rk   )Breakzz
    Represents a ``break`` statement, which is used to break out of a :class:`For`
    or :class:`While` loop early.
    rI   r^   rL   c                 C   rm   rn   )ru   r)   rI   r`   r;   r;   rE   ra      ro   z!Break._visit_and_replace_childrenFrJ   rK   Nc                 C   rp   )Nbreakrc   rr   rh   r;   r;   rE   rO      rs   zBreak._codegen_implrP   rt   r;   r;   r;   rE   ru         
 ru   c                   @   rk   )Continuez
    Represents a ``continue`` statement, which is used to skip to the next iteration
    in a :class:`For` or :class:`While` loop.
    rI   r^   rL   c                 C   rm   rn   )rx   r)   rI   r`   r;   r;   rE   ra      ro   z$Continue._visit_and_replace_childrenFrJ   rK   Nc                 C   rp   )Ncontinuerc   rr   rh   r;   r;   rE   rO      rs   zContinue._codegen_implrP   rt   r;   r;   r;   rE   rx      rw   rx   c                   @   s   e Zd ZU dZdZee ed< ej	Z
eeef ed< ej	Zeeef ed< dddZd	edd fd
dZ	ddededdfddZdS )Returnz>
    Represents a ``return`` or a ``return x`` statement.
    Nvaluewhitespace_after_returnrI   rL   c                 C   sJ   | j }|d ur| j}t|t o|j}|r!|tjs#tdd S d S d S )Nz,Must have at least one space after 'return'.)	r{   r|   rg   r   rY   rZ   r   r[   r   )rN   r{   r|   
has_no_gapr;   r;   rE   r]     s   zReturn._validater^   c                 C   2   t t| d| j|t| d| j|t| d| j|dS )Nr|   r{   rI   )r|   r{   rI   )rz   r)   r|   r'   r{   rI   r`   r;   r;   rE   ra   (     
z"Return._visit_and_replace_childrenFrJ   rK   c                 C   s   | | 0 |d | j}| j}t|tr |d ur|d n|| |d ur.|| W d    n1 s8w   Y  | j}t|trP|rN|d d S d S t|tr\|| d S d S )NrL   rV   rc   )	rd   re   r|   r{   rg   r   rf   rI   r2   )rN   rJ   rK   r|   r{   rI   r;   r;   rE   rO   1  s*   






zReturn._codegen_implrj   rP   )r?   r@   rA   rB   r{   r   r   rD   r   rQ   r|   r
   r6   rI   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   rz     s    
 

rz   c                   @   \   e Zd ZU dZeed< ejZe	e
ef ed< dedd fddZ	dd	ed
eddfddZdS )Exprz
    An expression used as a statement, where the result is unused and unassigned.
    The most common place you will find this is in function calls where the return
    value is unneeded.
    r{   rI   r^   rL   c                 C   $   t t| d| j|t| d| j|dS )Nr{   rI   )r{   rI   )r   r(   r{   r)   rI   r`   r;   r;   rE   ra   Y     z Expr._visit_and_replace_childrenFrJ   rK   Nc                 C   sx   | |  | j| W d    n1 sw   Y  | j}t|tr.|r,|d d S d S t|tr:|| d S d S Nrc   )rd   r{   rf   rI   rg   r   re   r2   rh   r;   r;   rE   rO   _  s   

zExpr._codegen_implrP   )r?   r@   rA   rB   r   rD   r   rQ   rI   r
   r2   r8   ra   r%   rR   rO   r;   r;   r;   rE   r   H  s   
 r   c                   @   sF   e Zd ZU dZdZee ed< eed< dddZ	d	e
ddfd
dZdS )_BaseSimpleStatementad  
    A simple statement is a series of small statements joined together by semicolons.

        simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE

    Whitespace between each small statement is owned by the small statements themselves.
    It can be found on the required semicolon that will be attached to each non-terminal
    small statement.
    r;   r>   trailing_whitespacerL   Nc                 C   s.   | j }|d d D ]}|jd u rtdq	d S )NzAll but the last SmallStatement in a SimpleStatementLine or SimpleStatementSuite must have a trailing semicolon. Otherwise, there's no way to syntatically disambiguate each SmallStatement on the same line.)r>   rI   r   )rN   r>   
small_stmtr;   r;   rE   r]     s   
z_BaseSimpleStatement._validaterJ   c                 C   s   | j }|r7t|d }|j| || d t|D ]\}}|j|||kd qW d    n1 s1w   Y  n||  |d W d    n1 sLw   Y  | j| d S )N   end_node)rK   rq   )r>   lenrd   	enumeraterf   re   r   )rN   rJ   r>   laststmtidxstmtr;   r;   rE   rO     s   z"_BaseSimpleStatement._codegen_implrj   )r?   r@   rA   rB   rC   r	   r=   rD   r7   r]   r%   rO   r;   r;   r;   rE   r   m  s   
 

r   c                   @   sp   e Zd ZU dZee ed< dZee ed< e	
 Ze	ed< dedd fdd	Zdefd
dZdeddfddZdS )SimpleStatementLinea  
    A simple statement that's part of an IndentedBlock or Module. A simple statement is
    a series of small statements joined together by semicolons.

    This isn't differentiated from a :class:`SimpleStatementSuite` in the grammar, but
    because a :class:`SimpleStatementLine` can own additional whitespace that a
    :class:`SimpleStatementSuite` doesn't have, we're differentiating it in the CST.
    r>   r;   leading_linesr   r^   rL   c                 C   r_   )Nr   r>   r   )r   r>   r   )r   r*   r   r>   r(   r   r`   r;   r;   rE   ra        

z/SimpleStatementLine._visit_and_replace_childrenc                 C   s   | j  S rM   )r>   r\   r;   r;   rE   _is_removable  s   z!SimpleStatementLine._is_removablerJ   Nc                 C   s.   | j D ]}|| q|  t| | d S rM   )r   rf   add_indent_tokensr   rO   rN   rJ   llr;   r;   rE   rO     s   
z!SimpleStatementLine._codegen_impl)r?   r@   rA   rB   r	   r=   rD   r   r4   r7   r   r   r8   ra   rR   r   r%   rO   r;   r;   r;   rE   r     s   
 
r   c                   @   sd   e Zd ZU dZee ed< edZ	eed< e
 Ze
ed< dedd fdd	Zd
eddfddZdS )SimpleStatementSuitea  
    A simple statement that's used as a suite. A simple statement is a series of small
    statements joined together by semicolons. A suite is the thing that follows the
    colon in a compound statement.

    .. code-block::

        if test:<leading_whitespace><body><trailing_whitespace>

    This isn't differentiated from a :class:`SimpleStatementLine` in the grammar, but
    because the two classes need to track different whitespace, we're differentiating
    it in the CST.
    r>   rV   leading_whitespacer   r^   rL   c                 C   r~   )Nr   r>   r   )r   r>   r   )r   r(   r   r*   r>   r   r`   r;   r;   rE   ra     r   z0SimpleStatementSuite._visit_and_replace_childrenrJ   Nc                 C   s   | j | t| | d S rM   )r   rf   r   rO   rN   rJ   r;   r;   rE   rO     s   z"SimpleStatementSuite._codegen_impl)r?   r@   rA   rB   r	   r=   rD   r6   r   r   r7   r   r8   ra   r%   rO   r;   r;   r;   rE   r     s   
 
r   c                   @   `   e Zd ZU dZeed< dZee ed< e	
dZe	ed< dedd fd	d
ZdeddfddZdS )ElseaD  
    An ``else`` clause that appears optionally after an :class:`If`, :class:`While`,
    :class:`Try`, or :class:`For` statement.

    This node does not match ``elif`` clauses in :class:`If` statements. It also
    does not match the required ``else`` clause in an :class:`IfExp` expression
    (``a = if b else c``).
    r>   r;   r    whitespace_before_colonr^   rL   c                 C   2   t t| d| j|t| d| j|t| d| j|dS Nr   r   r>   )r   r   r>   )r   r*   r   r(   r   r>   r`   r;   r;   rE   ra        

z Else._visit_and_replace_childrenrJ   Nc                 C      | j D ]}|| q|  |j| | jd |d | j| |d | j| W d    d S 1 s9w   Y  d S )Nr   else:r   rf   r   rd   r>   re   r   r   r;   r;   rE   rO        


"zElse._codegen_implr?   r@   rA   rB   r:   rD   r   r	   r4   r6   r   r   r8   ra   r%   rO   r;   r;   r;   rE   r     s   
 
r   c                   @   s*   e Zd ZU dZdZeed< ee ed< dS )BaseCompoundStatementa  
    Encapsulates a compound statement, like ``if True: pass`` or ``while True: pass``.
    This exists to simplify type definitions and isinstance checks.

        Compound statements contain (groups of) other statements; they affect or control
        the execution of those other statements in some way. In general, compound
        statements span multiple lines, although in simple incarnations a whole compound
        statement may be contained in one line.

        -- https://docs.python.org/3/reference/compound_stmts.html
    r;   r>   r   N)	r?   r@   rA   rB   rC   r:   rD   r	   r4   r;   r;   r;   rE   r   %  s
   
 r   c                   @   s   e Zd ZU dZeed< eed< dZed e	df ed< dZ
ee ed< edZeed	< ed
Zeed< dddZdedd fddZddededdfddZdS )Ifu   
    An ``if`` statement. ``test`` holds a single test expression.

    ``elif`` clauses don’t have a special representation in the AST, but rather appear as
    extra :class:`If` nodes within the ``orelse`` section of the previous one.
    testr>   Norelser;   r   rV   whitespace_before_testr   whitespace_after_testrL   c                 C   rX   )Nz0Must have at least one space after 'if' keyword.)r   rY   r   rZ   r   r[   r   r\   r;   r;   rE   r]   Y  s   zIf._validater^   c                 C   \   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|dS )Nr   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   ra   `     


zIf._visit_and_replace_childrenFrJ   is_elifc                 C   s  | j D ]}|| q|  | jd u r| jn| j}|j| |dX ||r(dnd | j| | j| | j	| |d | j| | j}|d urit
|tr\|j|dd n|| W d    d S W d    d S W d    d S 1 s|w   Y  d S )Nr   elififr   T)r   )r   rf   r   r   r>   rd   re   r   r   r   rg   r   )rN   rJ   r   r   r   r   r;   r;   rE   rO   p  s*   



"zIf._codegen_implrj   rP   )r?   r@   rA   rB   r   rD   r:   r   r
   r   r   r	   r4   r6   r   r   r   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   r   ;  s   
 
r   c                   @   s|   e Zd ZU dZee ed< e Z	eed< dZ
ee ed< dZee ed< dd	d
Zdedd fddZdeddfddZdS )IndentedBlocka  
    Represents a block of statements beginning with an ``INDENT`` token and ending in a
    ``DEDENT`` token. Used as the body of compound statements, such as an if statement's
    body.

    A common alternative to an :class:`IndentedBlock` is a :class:`SimpleStatementSuite`,
    which can also be used as a :class:`BaseSuite`, meaning that it can be used as the
    body of many compound statements.

    An :class:`IndentedBlock` always occurs after a colon in a
    :class:`BaseCompoundStatement`, so it owns the trailing whitespace for the compound
    statement's clause.

    .. code-block::

        if test: # IndentedBlock's header
            body
    r>   headerNindentr;   footerrL   c                 C   s@   | j }|d urt|dkrtdt|d u rtdd S d S )Nr   z4An indented block must have a non-zero width indent.9An indent must be composed of only whitespace characters.)r   r   r   r9   	fullmatchrN   r   r;   r;   rE   r]     s   zIndentedBlock._validater^   c              	   C   s6   t t| d| j|| jt| d| j|t| d| j|dS )Nr   r>   r   )r   r   r>   r   )r   r(   r   r   r&   r>   r*   r   r`   r;   r;   rE   ra     s   z)IndentedBlock._visit_and_replace_childrenrJ   c                 C   s   | j | | j}||d u r|jn| | jrB|j| | jd | jd d | jD ]}|| q*W d    n1 s<w   Y  n$|  ||  |d W d    n1 s[w   Y  ||j	 | j
D ]}|| qi|  d S )Nr   r   )
start_noder   rq   )r   rf   r   increase_indentdefault_indentr>   rd   r   re   default_newliner   decrease_indent)rN   rJ   r   r   fr;   r;   rE   rO     s(   

zIndentedBlock._codegen_implrj   )r?   r@   rA   rB   r	   r<   rD   r7   r   r   r   r   strr   r4   r]   r8   ra   r%   rO   r;   r;   r;   rE   r     s   
 
r   c                   @   sv   e Zd ZU dZeeeef ed< e	
dZeed< e	
dZeed< ddd	Zd
edd fddZdeddfddZdS )AsNamezu
    An ``as name`` clause inside an :class:`ExceptHandler`, :class:`ImportAlias` or
    :class:`WithItem` node.
    namerV   whitespace_before_aswhitespace_after_asrL   Nc                 C   rX   )Nz7There must be at least one space between 'as' and name.)r   rY   r   rZ   r   r[   r   r\   r;   r;   rE   r]        zAsName._validater^   c                 C   2   t t| d| j|t| d| j|t| d| j|dS )Nr   r   r   )r   r   r   )r   r(   r   r   r   r`   r;   r;   rE   ra     s   

z"AsName._visit_and_replace_childrenrJ   c                 C   s2   | j | |d | j| | j| d S )Nas)r   rf   re   r   r   r   r;   r;   rE   rO     s   
zAsName._codegen_implrj   )r?   r@   rA   rB   r
   r   r$   r   rD   r6   r   r   r3   r   r]   r8   ra   r%   rO   r;   r;   r;   rE   r     s   
 
	r   c                   @   s   e Zd ZU dZeed< dZee ed< dZ	ee
 ed< dZee ed< edZeed	< ed
Zeed< dddZdedd fddZdeddfddZdS )ExceptHandlerzV
    An ``except`` clause that appears optionally after a :class:`Try` statement.
    r>   Ntyper   r;   r   rV   whitespace_after_exceptr   r   rL   c                 C   s   | j }| jd u r|d urtd|d urt|j tstd| j}|d ur5| jjr5t|tr5|js5td| j }|d urN|d urP|jjrR|	t
jsTtdd S d S d S d S )Nz%Cannot have a name for an empty type.:Must use a Name node for AsName name inside ExceptHandler.zHMust have at least one space after except when ExceptHandler has a type.zDMust have at least one space before as keyword in an except handler.)r   r   r   rg   r   r   rY   lparr   rZ   r   LEFT)rN   r   type_r;   r;   rE   r]   &  s2   
zExceptHandler._validater^   c                 C   s\   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|dS )Nr   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   ra   B  s   


z)ExceptHandler._visit_and_replace_childrenrJ   c                 C   s   | j D ]}|| q|  |j| | jd= |d | j| | j}|d ur/|| | j}|d ur;|| | j	| |d | j| W d    d S 1 sWw   Y  d S )Nr   exceptr   )
r   rf   r   rd   r>   re   r   r   r   r   rN   rJ   r   typenodenamenoder;   r;   rE   rO   R  s    




"zExceptHandler._codegen_implrj   )r?   r@   rA   rB   r:   rD   r   r   r   r   r   r   r	   r4   r6   r   r   r   r]   r8   ra   r%   rO   r;   r;   r;   rE   r     s   
 
r   c                   @   s   e Zd ZU dZeed< eed< dZee	 ed< dZ
ee ed< edZeed	< ed
Zeed< edZeed< dddZdedd fddZdeddfddZdS )ExceptStarHandlerzP
    An ``except*`` clause that appears after a :class:`TryStar` statement.
    r>   r   Nr   r;   r   r   r   rV   whitespace_after_starr   rL   c                 C   s*   | j }|d urt|j tstdd S d S )Nr   )r   rg   r   r   )rN   r   r;   r;   rE   r]     s   zExceptStarHandler._validater^   c                 C   sj   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|dS )	Nr   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   ra     s"   



z-ExceptStarHandler._visit_and_replace_childrenrJ   c                 C   s   | j D ]}|| q|  |j| | jdH |d | j| |d | j| | j}|d ur:|| | j	}|d urF|| | j
| |d | j| W d    d S 1 sbw   Y  d S )Nr   r   *r   )r   rf   r   rd   r>   re   r   r   r   r   r   r   r;   r;   rE   rO     s$   





"zExceptStarHandler._codegen_implrj   )r?   r@   rA   rB   r:   rD   r   r   r   r   r   r	   r4   r6   r   r   r   r   r]   r8   ra   r%   rO   r;   r;   r;   rE   r   e  s   
 
r   c                   @   r   )FinallyzV
    A ``finally`` clause that appears optionally after a :class:`Try` statement.
    r>   r;   r   r   r   r^   rL   c                 C   r   r   )r   r*   r   r(   r   r>   r`   r;   r;   rE   ra     r   z#Finally._visit_and_replace_childrenrJ   Nc                 C   r   )Nr   finallyr   r   r   r;   r;   rE   rO     r   zFinally._codegen_implr   r;   r;   r;   rE   r     s   
 r   c                   @   s   e Zd ZU dZeed< dZee ed< dZ	e
e ed< dZe
e ed< dZee ed< ed	Zeed
< dddZdedd fddZdeddfddZdS )Tryz
    A regular ``try`` statement that cannot contain :class:`ExceptStar` blocks. For
    ``try`` statements that can contain :class:`ExceptStar` blocks, see
    :class:`TryStar`.
    r>   r;   handlersNr   	finalbodyr   r   r   rL   c                 C   sh   t | jdkr| jd u rtdt | jdkr | jd ur tdtdd | jd d D r2tdd S )Nr   z?A Try statement must have at least one ExceptHandler or FinallyzNA Try statement must have at least one ExceptHandler in order to have an Else.c                 s   s    | ]}|j d u V  qd S rM   )r   ).0handlerr;   r;   rE   	<genexpr>       z Try._validate.<locals>.<genexpr>r   z.The bare except: handler must be the last one.)r   r   r   r   r   anyr\   r;   r;   rE   r]     s   zTry._validater^   c                 C   \   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|dS Nr   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   ra        

zTry._visit_and_replace_childrenrJ   c                 C   s  | j D ]}|| q|  | j}t| jdkr| jd }| j}|d u r'|n|}| j}|d u r2|n|}|j| |dD |	d | j
| |	d | j| | jD ]}|| qU|d urf|| |d urw|| W d    d S W d    d S 1 sw   Y  d S )Nr   r   r   tryr   )r   rf   r   r>   r   r   r   r   rd   re   r   rN   rJ   r   r   r   r   r   r;   r;   rE   rO     s0   





	"zTry._codegen_implrj   )r?   r@   rA   rB   r:   rD   r   r	   r   r   r   r   r   r   r   r4   r6   r   r   r]   r8   ra   r%   rO   r;   r;   r;   rE   r     s   
 
r   c                   @   s   e Zd ZU dZeed< ee ed< dZe	e
 ed< dZe	e ed< dZee ed< ed	Zeed
< dddZdedd fddZdeddfddZdS )TryStarz6
    A ``try`` statement with ``except*`` blocks.
    r>   r   Nr   r   r;   r   r   r   rL   c                 C      t | jdkrtdd S )Nr   z8A TryStar statement must have at least one ExceptHandler)r   r   r   r\   r;   r;   rE   r]   D  
   zTryStar._validater^   c                 C   r   r   )
r   r*   r   r(   r   r>   r   r'   r   r   r`   r;   r;   rE   ra   J  r   z#TryStar._visit_and_replace_childrenrJ   c                 C   s   | j D ]}|| q|  | jd }| j}|d u r|n|}| j}|d u r(|n|}|j| |dD |d | j| |d | j	| | jD ]}|| qK|d ur\|| |d urm|| W d    d S W d    d S 1 sxw   Y  d S )Nr   r   r   r   )
r   rf   r   r   r   r   rd   re   r   r>   r   r;   r;   rE   rO   X  s,   





	"zTryStar._codegen_implrj   )r?   r@   rA   rB   r:   rD   r	   r   r   r   r   r   r   r   r4   r6   r   r   r]   r8   ra   r%   rO   r;   r;   r;   rE   r   *  s   
 
r   c                   @   s   e Zd ZU dZeeef ed< dZe	e
 ed< ejZeeef ed< dddZd	edd fd
dZddededdfddZdedefddZedefddZede	e fddZdS )ImportAliasz
    An import, with an optional :class:`AsName`. Used in both :class:`Import` and
    :class:`ImportFrom` to specify a single import out of another module.
    r   NasnamecommarL   c              
   C   sp   | j }|d urt|jtstd|jjrtdz| j W d S  ty7 } zt	|dkr1td|d }~ww )Nz8Must use a Name node for AsName name inside ImportAlias.zAMust have at least one space before as keyword in an ImportAlias.Logic error!z1The imported name must be a valid qualified name.)
r   rg   r   r   r   r   rY   evaluated_name	Exceptionr   )rN   r   er;   r;   rE   r]     s(   zImportAlias._validater^   c                 C   2   t t| d| j|t| d| j|t| d| j|dS )Nr   r   r   )r   r   r   )r   r(   r   r'   r   r)   r   r`   r;   r;   rE   ra     
   z'ImportAlias._visit_and_replace_childrenFrJ   default_commac                 C      | |  | j| | j}|d ur|| W d    n1 s"w   Y  | j}|tju r8|r8|d d S t|t	rD|| d S d S N, )
rd   r   rf   r   r   r   rQ   re   rg   r/   rN   rJ   r   r   r   r;   r;   rE   rO        

zImportAlias._codegen_implnodec                 C   s<   t |tr|jS t |tr| |j d|jj S td)N.r   )rg   r   r{   r   _nameattrr   )rN   r   r;   r;   rE   r     s
   

zImportAlias._namec                 C   s   |  | jS )zO
        Returns the string name this :class:`ImportAlias` represents.
        )r   r   r\   r;   r;   rE   r        zImportAlias.evaluated_namec                 C   s   | j }|dur| |jS dS )z
        Returns the string name for any alias that this :class:`ImportAlias`
        has. If there is no ``asname`` attribute, this returns ``None``.
        N)r   r   r   rN   r   r;   r;   rE   evaluated_alias  s   zImportAlias.evaluated_aliasrj   rP   )r?   r@   rA   rB   r
   r   r   rD   r   r   r   r   rQ   r   r/   r]   r8   ra   r%   rR   rO   r   r   r   propertyr   r   r;   r;   r;   rE   r   o  s   
 
	r   c                   @   s|   e Zd ZU dZee ed< ejZ	e
eef ed< edZeed< ddd	Zd
edd fddZ	ddededdfddZdS )Importz"
    An ``import`` statement.
    namesrI   rV   whitespace_after_importrL   Nc                 C   sD   t | jdkrtdt| jd jtrtd| jjr tdd S )Nr   z5An ImportStatement must have at least one ImportAliasr   z2An ImportStatement does not allow a trailing comma*Must have at least one space after import.)r   r   r   rg   r   r/   r  rY   r\   r;   r;   rE   r]     s   zImport._validater^   c                 C   r   )Nr  r   rI   )r  r   rI   )r   r(   r  r*   r   r)   rI   r`   r;   r;   rE   ra     r   z"Import._visit_and_replace_childrenFrJ   rK   c                 C      | | - |d | j| t| jd }t| jD ]\}}|j|||kd qW d    n1 s5w   Y  | j}t|t	rM|rK|d d S d S t|t
rY|| d S d S )Nimportr   r   rc   )rd   re   r  rf   r   r   r   rI   rg   r   r2   )rN   rJ   rK   lastnameir   rI   r;   r;   rE   rO         


zImport._codegen_implrj   rP   )r?   r@   rA   rB   r	   r   rD   r   rQ   rI   r
   r2   r6   r   r  r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   r     s   
 

r   c                   @   s
  e Zd ZU dZeeeef  ed< ee	e
 ef ed< dZe	e ed< dZee ed< dZee ed< ejZeeef ed	< ed
Zeed< ed
Zeed< ed
Zeed< dddZdddZdddZdddZdedd fddZ 	d de!de"ddfddZ#dS )!
ImportFromz*
    A ``from x import y`` statement.
    moduler   r;   relativeNr   rparrI   rV   whitespace_after_fromwhitespace_before_importr  rL   c                 C   s(   | j d u rt| jdkrtdd S d S )Nr   z<Must have a module specified if there is no relative import.)r
  r   r  r   r\   r;   r;   rE   _validate_module(  s
   zImportFrom._validate_modulec                 C   s   | j }t|tr@t|dkrtd|d d D ]}|jd u r#tdq| jd ur2| jd u r2td| jd u r@| jd ur@tdt|trS| jd usO| jd urUtdd S d S )Nr   z0An ImportFrom must have at least one ImportAliasr   z'Non-final ImportAliases require a commaz+Cannot have left paren without right paren.z+Cannot have right paren without left paren.z1An ImportFrom using ImportStar cannot have parens)	r   rg   r	   r   r   r   r   r  r1   )rN   r   r   r;   r;   rE   _validate_names.  s*   


zImportFrom._validate_namesc                 C   sh   | j jr| jstd| jjr| jr| jd u std| jjr.| jd u r0t| j	t
s2tdd S d S d S )Nz(Must have at least one space after from.z+Must have at least one space before import.r  )r  rY   r  r   r  r
  r  r   rg   r   r1   r\   r;   r;   rE   _validate_whitespaceB  s   


zImportFrom._validate_whitespacec                 C      |    |   |   d S rM   )r  r  r  r\   r;   r;   rE   r]   P     zImportFrom._validater^   c                 C   s   | j }tt| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|t|tr:t| d||nt| d||t| d| j|t| d	| j|d
	S )Nr  r  r
  r  r  r   r   r  rI   )	r  r  r
  r  r  r   r   r  rI   )r   r	  r(   r  r*   r  r'   r
  r  r  r   rg   r1   r  r)   rI   )rN   r^   r   r;   r;   rE   ra   U  s(   


z&ImportFrom._visit_and_replace_childrenFrJ   rK   c                 C   s  | j }t|tr|d n|}| jd u r|n| j}|j| |dz |d | j| | jD ]}|| q.| j	}|d urB|| | j
| |d | j| | j}|d ur_|| t|tr|t|d }t|D ]\}	}
|
j||	|kd qnt|tr|| | j}|d ur|| W d    n1 sw   Y  | j}t|tr|r|d d S d S t|tr|| d S d S )Nr   r   fromr  r   r  rc   )r   rg   r	   r  rd   re   r  rf   r  r
  r  r  r   r   r   r1   rI   r   r2   )rN   rJ   rK   r   r   dotr
  r   r  r  r   r  rI   r;   r;   rE   rO   m  sH   










zImportFrom._codegen_implrj   rP   )$r?   r@   rA   rB   r   r
   r   r   rD   r	   r   r1   r  r0   r   r   r  r!   r   rQ   rI   r2   r6   r   r  r  r  r  r  r  r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   r	     s0   
 



r	  c                   @   sb   e Zd ZU dZeed< edZeed< edZ	eed< de
dd fdd	Zd
eddfddZdS )AssignTargetz]
    A target for an :class:`Assign`. Owns the equals sign and the whitespace around it.
    rU   rV   whitespace_before_equalwhitespace_after_equalr^   rL   c                 C   r   )NrU   r  r  )rU   r  r  )r  r(   rU   r  r  r`   r;   r;   rE   ra     s   

z(AssignTarget._visit_and_replace_childrenrJ   Nc                 C   s\   | |  | j| W d    n1 sw   Y  | j| |d | j| d S )N=)rd   rU   rf   r  re   r  r   r;   r;   rE   rO     s   
zAssignTarget._codegen_impl)r?   r@   rA   rB   r   rD   r6   r   r  r  r8   ra   r%   rO   r;   r;   r;   rE   r    s   
 r  c                   @   sr   e Zd ZU dZee ed< eed< ej	Z
eeef ed< dddZd	edd fd
dZ	ddededdfddZdS )Assignz
    An assignment statement such as ``x = y`` or ``x = y = z``. Unlike
    :class:`AnnAssign`, this does not allow type annotations but does
    allow for multiple targets.
    targetsr{   rI   rL   Nc                 C   r   )Nr   z7An Assign statement must have at least one AssignTarget)r   r  r   r\   r;   r;   rE   r]     r   zAssign._validater^   c                 C   r   )Nr  r{   rI   )r  r{   rI   )r  r*   r  r(   r{   r)   rI   r`   r;   r;   rE   ra     r   z"Assign._visit_and_replace_childrenFrJ   rK   c                 C   s   | |  | jD ]}|| q	| j| W d    n1 s!w   Y  | j}t|tr9|r7|d d S d S t|trE|| d S d S r   )	rd   r  rf   r{   rI   rg   r   re   r2   )rN   rJ   rK   rU   rI   r;   r;   rE   rO     ri   zAssign._codegen_implrj   rP   )r?   r@   rA   rB   r	   r  rD   r   r   rQ   rI   r
   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   r    s   
 
r  c                   @   s   e Zd ZU dZeed< eed< dZee	 ed< e
jZeee
f ed< e
jZeee
f ed< dd	d
Zdedd fddZ	ddededdfddZdS )	AnnAssignaE  
    An assignment statement such as ``x: int = 5`` or ``x: int``. This only
    allows for one assignment target unlike :class:`Assign` but it includes
    a variable annotation. Also unlike :class:`Assign`, the assignment target
    is optional, as it is possible to annotate an expression without assigning
    to it.
    rU   
annotationNr{   equalrI   rL   c                 C   s&   | j d u rt| jtrtdd S d S )Nz1Must have a value when specifying an AssignEqual.)r{   rg   r  r+   r   r\   r;   r;   rE   r]     s
   zAnnAssign._validater^   c              
   C   N   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|dS )NrU   r  r  r{   rI   )rU   r  r  r{   rI   )	r  r(   rU   r  r)   r  r'   r{   rI   r`   r;   r;   rE   ra        z%AnnAssign._visit_and_replace_childrenFrJ   rK   c                 C   s   | | ? | j| | jj|dd | j}|tju r'| jd ur'|d n
t	|t
r1|| | j}|d ur=|| W d    n1 sGw   Y  | j}t	|tr_|r]|d d S d S t	|trk|| d S d S )Nr   default_indicator = rc   )rd   rU   rf   r  r  r   rQ   r{   re   rg   r+   rI   r2   )rN   rJ   rK   r  r{   rI   r;   r;   rE   rO     s*   




zAnnAssign._codegen_implrj   rP   )r?   r@   rA   rB   r   rD   r   r{   r   r   r   rQ   r  r
   r+   rI   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   r    s"   
 	

r  c                   @   sl   e Zd ZU dZeed< eed< eed< ej	Z
eeef ed< dedd fdd	Z	
ddededdfddZdS )	AugAssignz@
    An augmented assignment statement, such as ``x += 5``.
    rU   operatorr{   rI   r^   rL   c              	   C   s@   t t| d| j|t| d| j|t| d| j|t| d| j|dS )NrU   r%  r{   rI   )rU   r%  r{   rI   )r$  r(   rU   r%  r{   r)   rI   r`   r;   r;   rE   ra   <  s   z%AugAssign._visit_and_replace_childrenFrJ   rK   Nc                 C   s   | |  | j| | j| | j| W d    n1 s"w   Y  | j}t|tr:|r8|d d S d S t|t	rF|| d S d S r   )
rd   rU   rf   r%  r{   rI   rg   r   re   r2   rh   r;   r;   rE   rO   D  s   

zAugAssign._codegen_implrP   )r?   r@   rA   rB   r   rD   r,   r   r   rQ   rI   r
   r2   r8   ra   r%   rR   rO   r;   r;   r;   rE   r$  (  s   
 	r$  c                   @   sp   e Zd ZU dZeed< dZee ed< e	
dZe	ed< e
 Zeed< ded	d fd
dZded	dfddZdS )	DecoratorzZ
    A single decorator that decorates a :class:`FunctionDef` or a :class:`ClassDef`.
    	decoratorr;   r   r   whitespace_after_atr   r^   rL   c              	   C   s@   t t| d| j|t| d| j|t| d| j|t| d| j|dS )Nr   r(  r'  r   )r   r(  r'  r   )r&  r*   r   r(   r(  r'  r   r`   r;   r;   rE   ra   j  s   


z%Decorator._visit_and_replace_childrenrJ   Nc                 C   sz   | j D ]}|| q|  ||  |d | j| | j| W d    n1 s0w   Y  | j| d S )N@)r   rf   r   rd   re   r(  r'  r   r   r;   r;   rE   rO   x  s   

zDecorator._codegen_impl)r?   r@   rA   rB   r   rD   r   r	   r4   r6   r   r(  r7   r   r8   ra   r%   rO   r;   r;   r;   rE   r&  T  s   
 r&  r>   cleanrL   c                 C   s   t | tr| r| d }ndS | }t |ttfr,t|jdkr dS |jd }t |ttfst |ts3dS |j}t |tt	frA|j
}ndS t |trJdS |durU|rUt|S |S )a   
    Implementation Reference:
    - :func:`ast.get_docstring` https://docs.python.org/3/library/ast.html#ast.get_docstring
    and https://github.com/python/cpython/blob/89aa4694fc8c6d190325ef8ed6ce6a6b8efb3e50/Lib/ast.py#L254
    - PEP 257 https://www.python.org/dev/peps/pep-0257/
    r   N)rg   r	   r:   r   r   r>   r   r{   r#   r   evaluated_valuebytesinspectcleandoc)r>   r*  exprvalr+  r;   r;   rE   get_docstring_impl  s*   






r1  c                   @   s*  e Zd ZU dZeed< eed< eed< dZe	e
 ed< dZee ed< dZee ed	< dZe	e ed
< dZe	e ed< edZeed< edZeed< edZeed< edZeed< dZed ed< edZeed< d"ddZdedd fddZdeddfddZ d#de!dee" fd d!Z#dS )$FunctionDefz 
    A function definition.
    r   paramsr>   r;   
decoratorsNreturnsasynchronousr   lines_after_decoratorsrV   whitespace_after_defr   whitespace_after_namewhitespace_before_paramsr   TypeParameterstype_parameters whitespace_after_type_parametersrL   c                 C   sZ   t | jjdkst | jjdkrtd| jjrtd| jd u r)| jjs+tdd S d S )Nr   z0Cannot have parens around Name in a FunctionDef.z8There must be at least one space between 'def' and name.z]whitespace_after_type_parameters must be empty if there are no type parameters in FunctionDef)	r   r   r   r  r   r8  rY   r<  r=  r\   r;   r;   rE   r]     s    
zFunctionDef._validater^   c                 C   s   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|t| d| j|t| d	| j|t| d
| j|t| d| j|t| d| j|t| d| j|t| d| j|dS )Nr   r4  r7  r6  r8  r   r9  r<  r=  r:  r3  r5  r   r>   )r   r4  r7  r6  r8  r   r9  r<  r=  r:  r3  r5  r   r>   )r2  r*   r   r4  r7  r'   r6  r(   r8  r   r9  r<  r=  r:  r3  r5  r   r>   r`   r;   r;   rE   ra     sJ   







z'FunctionDef._visit_and_replace_childrenrJ   c                 C   sT  | j D ]}|| q| jD ]}|| q| jD ]}|| q|  |j| | jds | j}|d ur:|| |d | j	| | j
| | j| | j}|d ur]|| | j| |d | j| | j| |d | j}|d ur|j|dd | j| |d | j| W d    d S 1 sw   Y  d S )Nr   def()z->r!  r   )r   rf   r4  r7  r   rd   r>   r6  re   r8  r   r9  r<  r=  r:  r3  r5  r   )rN   rJ   r   r'  ladr6  type_paramsr5  r;   r;   rE   rO     s<   








"zFunctionDef._codegen_implTr*  c                 C      t | j|S )z
        When docstring is available, returns a :func:`inspect.cleandoc` cleaned docstring.
        Otherwise, returns ``None``.
        r1  r>   rN   r*  r;   r;   rE   get_docstring=  r   zFunctionDef.get_docstringrj   T)$r?   r@   rA   rB   r   rD   r   r:   r4  r	   r&  r5  r   r   r6  r   r   r4   r7  r6   r   r8  r9  r:  r3   r   r<  r=  r]   r8   ra   r%   rO   rR   r   rF  r;   r;   r;   rE   r2    s(   
 
' r2  c                   @   sZ  e Zd ZU dZeed< eed< dZee	 ed< dZ
ee	 ed< dZee ed< ejZeeef ed< ejZeeef ed	< dZee ed
< dZee ed< edZeed< edZeed< edZeed< dZed ed< edZeed< d(ddZd(ddZ d(ddZ!d(ddZ"de#dd fdd Z$d!e%ddfd"d#Z&d)d%e'dee( fd&d'Z)dS )*ClassDefz
    A class definition.
    r   r>   r;   baseskeywordsr4  r   r  r   r7  rV   whitespace_after_classr   r9  r   Nr;  r<  r=  rL   c                 C   s2   | j jrtd| jd u r| jjstdd S d S )Nz:There must be at least one space between 'class' and name.z[whitespace_after_type_parameters must be empty if there are no typeparameters in a ClassDef)rK  rY   r   r<  r=  r\   r;   r;   rE   r  ~  s   
zClassDef._validate_whitespacec                 C   sp   t | jjdkst | jjdkrtdt| jtr$t| jtr$tdt| jtr4t| jtr6tdd S d S )Nr   z-Cannot have parens around Name in a ClassDef.<Do not mix concrete LeftParen/RightParen with MaybeSentinel.)	r   r   r   r  r   rg   r   r!   r   r\   r;   r;   rE   _validate_parens  s    zClassDef._validate_parensc                 C   s<   t dd | jD rtdt dd | jD rtdd S )Nc                 s   s    | ]}|j d uV  qd S rM   )keywordr   argr;   r;   rE   r     r   z*ClassDef._validate_args.<locals>.<genexpr>z)Bases must be arguments without keywords.c                 s   s$    | ]}|j d u o|jdkV  qd S N**)rN  starrO  r;   r;   rE   r     s   " zBKeywords must be arguments with keywords or dictionary expansions.)r   rI  r   rJ  r\   r;   r;   rE   _validate_args  s   zClassDef._validate_argsc                 C   r  rM   )r  rM  rT  r\   r;   r;   rE   r]     r  zClassDef._validater^   c                 C   s   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t	| d| j
|t| d| j|t| d	| j|t| d
| j|t| d| j|t| d| j|t| d| j|t| d| j|dS )Nr   r4  r7  rK  r   r9  r<  r=  r   rI  rJ  r  r   r>   )r   r4  r7  rK  r   r9  r<  r=  r   rI  rJ  r  r   r>   )rH  r*   r   r4  r7  r(   rK  r   r9  r'   r<  r=  r)   r   rI  rJ  r  r   r>   r`   r;   r;   rE   ra     sB   





z$ClassDef._visit_and_replace_childrenrJ   c                 C   s  | j D ]}|| q| jD ]}|| q| jD ]}|| q|  |j| | jd |d | j| | j	| | j
| | j}|d urQ|| | j| | j}t|trk| jse| jrj|d n
t|tru|| g | j| j}t|d }t|D ]\}	}
|
j||	|kd q| j}t|tr| js| jr|d n
t|tr|| | j| |d | j| W d    d S 1 sw   Y  d S )Nr   classr?  r   r  r@  r   )r   rf   r4  r7  r   rd   r>   re   rK  r   r9  r<  r=  r   rg   r   rI  rJ  r   r   r   r  r!   r   )rN   rJ   r   r'  rA  rB  r   argslast_argr  rP  r  r;   r;   rE   rO     sL   













"zClassDef._codegen_implTr*  c                 C   rC  )zy
        Returns a :func:`inspect.cleandoc` cleaned docstring if the docstring is available, ``None`` otherwise.
        rD  rE  r;   r;   rE   rF    s   zClassDef.get_docstringrj   rG  )*r?   r@   rA   rB   r   rD   r:   rI  r	   r   rJ  r4  r&  r   rQ   r   r
   r   r  r!   r   r4   r7  r6   r   rK  r9  r   r<  r   r=  r  rM  rT  r]   r8   ra   r%   rO   rR   r   rF  r;   r;   r;   rE   rH  E  s.   
 



#&rH  c                   @   st   e Zd ZU dZeed< dZee ed< e	j
Zeee	f ed< dddZd	edd fd
dZddededdfddZdS )WithItemz\
    A single context manager in a :class:`With` block, with an optional variable name.
    itemNr   r   rL   c                 C   s8   | j }|d ur|jjr| jtjstdd S d S d S )Nz/Must have at least one space before as keyword.)r   r   rY   rY  rZ   r   r   r   r   r;   r;   rE   r]     s   zWithItem._validater^   c                 C   r   )NrY  r   r   )rY  r   r   )rX  r(   rY  r'   r   r)   r   r`   r;   r;   rE   ra     r   z$WithItem._visit_and_replace_childrenFrJ   r   c                 C   r   r   )
rd   rY  rf   r   r   r   rQ   re   rg   r/   r   r;   r;   rE   rO     r   zWithItem._codegen_implrj   rP   )r?   r@   rA   rB   r   rD   r   r   r   r   rQ   r   r
   r/   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   rX    s   
 
	rX  c                   @   s   e Zd ZU dZee ed< eed< dZe	e
 ed< dZee ed< ejZeeef ed< ejZeeef ed	< ed
Zeed< edZeed< dddZdddZdedd fddZdeddfddZdS )Withz
    A ``with`` statement.
    itemsr>   Nr6  r;   r   r   r  rV   whitespace_after_withr   r   rL   c                 C   sH   t | jtrt | jtrtdt | jtr t | jtr"tdd S d S )NrL  )rg   r   r   r  r!   r   r   r\   r;   r;   rE   rM  D  s   zWith._validate_parensc                 C   s   |    t| jdkrtdt| jtr"| jd jtjkr"td| j	j
r:t| jts<| jd jtjs>tdd S d S d S )Nr   z1A With statement must have at least one WithItem.r   zJThe last WithItem in an unparenthesized With cannot have a trailing comma.z0Must have at least one space after with keyword.)rM  r   r[  r   rg   r  r   r   rQ   r\  rY   r   r   rY  rZ   r   r[   r\   r;   r;   rE   r]   N  s(   

zWith._validater^   c                 C   sx   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|t| d| j|t| d| j|d	S )
Nr   r6  r\  r   r[  r  r   r>   )r   r6  r\  r   r[  r  r   r>   )rZ  r*   r   r'   r6  r(   r\  r)   r   r[  r  r   r>   r`   r;   r;   rE   ra   c  s$   



z With._visit_and_replace_childrenrJ   c                 C   sf  | j D ]}|| q|  d}| jD ]}|j}t|tr+t|jtt	t
fr+d} nq|j| | jdu | j}|d urA|| |d | j| | j}t|trZ|| n|ra|d t| jd }t| jD ]\}	}|j||	|kd qm| j}
t|
tr|
| n|r|d | j| |d	 | j| W d    d S 1 sw   Y  d S )
NFTr   withr?  r   r  r@  r   )r   rf   r   r[  r   rg   r/   whitespace_afterr4   r7   r5   rd   r>   r6  re   r\  r   r   r   r   r  r!   r   )rN   rJ   r   needs_parenrY  r   r6  r   	last_itemr  r  r;   r;   rE   rO   w  sJ   









"zWith._codegen_implrj   )r?   r@   rA   rB   r	   rX  rD   r:   r6  r   r   r   r4   r   rQ   r   r
   r   r  r!   r6   r   r\  r   rM  r]   r8   ra   r%   rO   r;   r;   r;   rE   rZ  %  s   
 


rZ  c                   @   s   e Zd ZU dZeed< eed< eed< dZe	e
 ed< dZe	e ed< dZee ed	< ed
Zeed< ed
Zeed< ed
Zeed< edZeed< dddZdedd fddZdeddfddZdS )Forz-
    A ``for target in iter`` statement.
    rU   iterr>   Nr   r6  r;   r   rV   whitespace_after_forwhitespace_before_inwhitespace_after_inr   r   rL   c                 C   sb   | j jr| jtjstd| jjr| jtjstd| j	jr-| j
tjs/tdd S d S )Nz1Must have at least one space after 'for' keyword.z1Must have at least one space before 'in' keyword.z0Must have at least one space after 'in' keyword.)rc  rY   rU   rZ   r   r[   r   rd  r   re  rb  r\   r;   r;   rE   r]     s,   zFor._validater^   c                 C   s   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|t| d| j|t| d	| j|t| d
| j|d
S )Nr   r6  rc  rU   rd  re  rb  r   r>   r   )
r   r6  rc  rU   rd  re  rb  r   r>   r   )ra  r*   r   r'   r6  r(   rc  rU   rd  re  rb  r   r>   r   r`   r;   r;   rE   ra     s0   





zFor._visit_and_replace_childrenrJ   c                 C   s  | j D ]}|| q|  | jd u r| jn| j}|j| |db | j}|d ur.|| |d | j| | j	| | j
| |d | j| | j| | j| |d | j| | j}|d ur{|| W d    d S W d    d S 1 sw   Y  d S )Nr   forinr   )r   rf   r   r   r>   rd   r6  re   rc  rU   rd  re  rb  r   )rN   rJ   r   r   r6  r   r;   r;   rE   rO     s0   




"zFor._codegen_implrj   )r?   r@   rA   rB   r   rD   r   r:   r   r   r   r6  r   r   r	   r4   r6   r   rc  rd  re  r   r]   r8   ra   r%   rO   r;   r;   r;   rE   ra    s   
 
ra  c                   @   s   e Zd ZU dZeed< eed< dZee	 ed< dZ
ee ed< edZeed	< ed
Zeed< dddZdedd fddZdeddfddZdS )Whilez 
    A ``while`` statement.
    r   r>   Nr   r;   r   rV   whitespace_after_whiler   r   rL   c                 C   rX   )Nz3Must have at least one space after 'while' keyword.)ri  rY   r   rZ   r   r[   r   r\   r;   r;   rE   r]   +	  r   zWhile._validater^   c                 C   r   )Nr   ri  r   r   r>   r   )r   ri  r   r   r>   r   )
rh  r*   r   r(   ri  r   r   r>   r'   r   r`   r;   r;   rE   ra   4	  r   z!While._visit_and_replace_childrenrJ   c                 C   s   | j D ]}|| q|  | jd u r| jn| j}|j| |d? |d | j| | j| | j	| |d | j| | j}|d urX|| W d    d S W d    d S 1 scw   Y  d S )Nr   whiler   )
r   rf   r   r   r>   rd   re   ri  r   r   )rN   rJ   r   r   r   r;   r;   rE   rO   D	  s"   


"zWhile._codegen_implrj   )r?   r@   rA   rB   r   rD   r:   r   r   r   r   r	   r4   r6   r   ri  r   r]   r8   ra   r%   rO   r;   r;   r;   rE   rh  	  s   
 
	rh  c                   @   s   e Zd ZU dZdZee ed< dZee	 ed< e
jZeee
f ed< e
jZeee
f ed< ddd	Zd
edd fddZ	ddededdfddZdS )Raisez@
    A ``raise exc`` or ``raise exc from cause`` statement.
    Nexccausewhitespace_after_raiserI   rL   c                 C   s   | j d u r| jd urtd| j }|d ur-| j}t|t o |j}|r-|tj	s-td| j}|d urP|d urR|j
}t|t oC|j}|rT|tjsVtdd S d S d S d S )Nz6Must have an 'exc' when specifying 'clause'. on Raise.z+Must have at least one space after 'raise'.z+Must have at least one space before 'from'.)rl  rm  r   rn  rg   r   rY   rZ   r   r[   whitespace_before_fromr   )rN   rl  rn  r}   rm  ro  r;   r;   rE   r]   m	  s4   zRaise._validater^   c              	   C   s@   t t| d| j|t| d| j|t| d| j|t| d| j|dS )Nrn  rl  rm  rI   )rn  rl  rm  rI   )rk  r)   rn  r'   rl  rm  rI   r`   r;   r;   rE   ra   	  s   
z!Raise._visit_and_replace_childrenFrJ   rK   c                 C   s   | | > | j}| j}|d | j}t|tr#|d ur"|d n|| |d ur1|| |d ur<|j|dd W d    n1 sFw   Y  | j}t|tr^|r\|d d S d S t|t	rj|| d S d S )NraiserV   )default_spacerc   )
rd   rl  rm  re   rn  rg   r   rf   rI   r2   )rN   rJ   rK   rl  rm  rn  rI   r;   r;   rE   rO   	  s0   






zRaise._codegen_implrj   rP   )r?   r@   rA   rB   rl  r   r   rD   rm  r   r   rQ   rn  r
   r6   rI   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   rk  V	  s"   
 
!rk  c                   @   s   e Zd ZU dZeed< dZee ed< ej	Z
eeef ed< edZeed< ej	Zeeef ed< dd
dZded	d fddZ	ddeded	dfddZdS )AssertzT
    An assert statement such as ``assert x > 5`` or ``assert x > 5, 'Uh oh!'``
    r   Nmsgr   rV   whitespace_after_assertrI   rL   c                 C   sD   | j jr| jtjstd| jd u rt| j	t
r tdd S d S )Nz,Must have at least one space after 'assert'.z(Cannot have trailing comma after 'test'.)rt  rY   r   rZ   r   r[   r   rs  rg   r   r/   r\   r;   r;   rE   r]   	  s   zAssert._validater^   c              
   C   r  )Nrt  r   r   rs  rI   )rt  r   r   rs  rI   )	rr  r(   rt  r   r)   r   r'   rs  rI   r`   r;   r;   rE   ra   	  s   
z"Assert._visit_and_replace_childrenFrJ   rK   c                 C   s   | | < |d | j| | j| | j}| j}t|tr,|d ur+|d n|| |d ur:|| W d    n1 sDw   Y  | j	}t|tr\|rZ|d d S d S t|t
rh|| d S d S )Nassertr   rc   )rd   re   rt  rf   r   r   rs  rg   r   rI   r2   )rN   rJ   rK   r   rs  rI   r;   r;   rE   rO   	  s.   






zAssert._codegen_implrj   rP   )r?   r@   rA   rB   r   rD   rs  r   r   rQ   r   r
   r/   r6   r   rt  rI   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   rr  	  s"   
 
rr  c                   @   sd   e Zd ZU dZeed< ejZe	e
ef ed< dddZdedd fd	d
ZddededdfddZdS )NameItema  
    A single identifier name inside a :class:`Global` or :class:`Nonlocal` statement.

    This exists because a list of names in a ``global`` or ``nonlocal`` statement need
    to be separated by a comma, which ends up owned by the :class:`NameItem` node.
    r   r   rL   Nc                 C   s,   t | jjdkst | jjdkrtdd S )Nr   z,Cannot have parens around names in NameItem.)r   r   r   r  r   r\   r;   r;   rE   r]   
  s    zNameItem._validater^   c                 C   r   )Nr   r   )r   r   )rv  r(   r   r)   r   r`   r;   r;   rE   ra   
  r   z$NameItem._visit_and_replace_childrenFrJ   r   c                 C   st   | |  | j| W d    n1 sw   Y  | j}|tju r,|r,|d d S t|tr8|| d S d S r   )	rd   r   rf   r   r   rQ   re   rg   r/   rN   rJ   r   r   r;   r;   rE   rO   
  s   
zNameItem._codegen_implrj   rP   )r?   r@   rA   rB   r   rD   r   rQ   r   r
   r/   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   rv  	  s   
 
rv  c                   @   |   e Zd ZU dZee ed< edZ	eed< e
jZeee
f ed< ddd	Zd
edd fddZ	ddededdfddZdS )Globalz!
    A ``global`` statement.
    r   rV   whitespace_after_globalrI   rL   Nc                 C   D   t | jdkrtd| jd jtjkrtd| jjr tdd S )Nr   z3A Global statement must have at least one NameItem.r   z;The last NameItem in a Global cannot have a trailing comma.z4Must have at least one space after 'global' keyword.)r   r   r   r   r   rQ   rz  rY   r\   r;   r;   rE   r]   3
     zGlobal._validater^   c                 C   r   )Nrz  r   rI   )rz  r   rI   )ry  r(   rz  r*   r   r)   rI   r`   r;   r;   rE   ra   A
  r   z"Global._visit_and_replace_childrenFrJ   rK   c                 C   r  )Nglobalr   r  rc   )rd   re   rz  rf   r   r   r   rI   rg   r   r2   rN   rJ   rK   	last_namer  r   rI   r;   r;   rE   rO   J
  r  zGlobal._codegen_implrj   rP   )r?   r@   rA   rB   r	   rv  rD   r6   r   rz  r   rQ   rI   r
   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   ry  "
  s   
 

ry  c                   @   rx  )Nonlocalz#
    A ``nonlocal`` statement.
    r   rV   whitespace_after_nonlocalrI   rL   Nc                 C   r{  )Nr   z5A Nonlocal statement must have at least one NameItem.r   z=The last NameItem in a Nonlocal cannot have a trailing comma.z6Must have at least one space after 'nonlocal' keyword.)r   r   r   r   r   rQ   r  rY   r\   r;   r;   rE   r]   m
  r|  zNonlocal._validater^   c                 C   r   )Nr  r   rI   )r  r   rI   )r  r(   r  r*   r   r)   rI   r`   r;   r;   rE   ra   {
  s   z$Nonlocal._visit_and_replace_childrenFrJ   rK   c                 C   r  )Nnonlocalr   r  rc   )rd   re   r  rf   r   r   r   rI   rg   r   r2   r~  r;   r;   rE   rO   
  r  zNonlocal._codegen_implrj   rP   )r?   r@   rA   rB   r	   rv  rD   r6   r   r  r   rQ   rI   r
   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   r  \
  s   
 
r  c                   @   rF   )MatchPatternzc
    A base class for anything that can appear as a pattern in a :class:`Match`
    statement.
    r;   NrG   r;   r;   r;   rE   r  
  rH   r  c                   @   s   e Zd ZU dZeed< ed ed< dZee ed< e	
dZe	ed< e	
d	Ze	ed
< e
 Zeed< dZee ed< dZee ed< dddZdedd fddZdeddfddZdS )Matchz 
    A ``match`` statement.
    subject	MatchCasecasesr;   r   rV   whitespace_after_matchr   r   whitespace_after_colonNr   r   rL   c                 C   sV   t | jdkrtd| j}|d ur't |dkrtdt|d u r)tdd S d S )Nr   z.A match statement must have at least one case.z4A match statement must have a non-zero width indent.r   )r   r  r   r   r9   r   r   r;   r;   rE   r]   
  s   zMatch._validater^   c                 C   sn   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|| jt| d| j	|t| d| j
|dS )	Nr   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   ra   
  s$   



z!Match._visit_and_replace_childrenrJ   c                 C   s   | j D ]}|| q|  |j| | jd dT |d | j| | j| | j| |d | j	| | j
}||d u rH|jn| | jD ]}|| qN| jD ]}|| qY|  W d    d S 1 spw   Y  d S )Nr   r   matchr   )r   rf   r   rd   r  re   r  r  r   r  r   r   r   r   r   )rN   rJ   r   r   cr   r;   r;   rE   rO   
  s$   





"zMatch._codegen_implrj   )r?   r@   rA   rB   r   rD   r	   r   r4   r6   r   r  r   r7   r  r   r   r   r   r]   r8   ra   r%   rO   r;   r;   r;   rE   r  
  s   
 
r  c                   @   s   e Zd ZU dZeed< eed< dZee	 ed< dZ
ee ed< edZeed	< ed
Zeed< ed
Zeed< ed
Zeed< deddfddZdeddfddZdS )r  z@
    A single ``case`` block of a :class:`Match` statement.
    patternr>   Nguardr;   r   rV   whitespace_after_caser   whitespace_before_ifwhitespace_after_ifr   r^   rL   r   c                 C   sx   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|t| d| j|d	S )
Nr   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`   r;   r;   rE   ra   $  s(   




z%MatchCase._visit_and_replace_childrenrJ   c                 C   s   | j D ]}|| q|  |j| | jdH |d | j| | j| | j}|d urF| j	| |d | j
| || | j| |d | j| W d    d S 1 sbw   Y  d S )Nr   caser   r   )r   rf   r   rd   r>   re   r  r  r  r  r  r   )rN   rJ   r   r  r;   r;   rE   rO   :  s"   




"zMatchCase._codegen_impl)r?   r@   rA   rB   r  rD   r:   r  r   r   r   r	   r4   r6   r   r  r  r  r   r8   ra   r%   rO   r;   r;   r;   rE   r    s   
 r  c                   @   s   e Zd ZU dZeed< deddfddZdedd	fd
dZ	e
dee fddZejdee dd	fddZe
dee fddZejdee dd	fddZd	S )
MatchValuezE
    A match literal or value pattern that compares by equality.
    r{   r^   rL   r   c                 C   rm   Nr{   )r{   )r  r(   r{   r`   r;   r;   rE   ra   Y     z&MatchValue._visit_and_replace_childrenrJ   Nc                 C   <   | |  | j| W d    d S 1 sw   Y  d S rM   rd   r{   rf   r   r;   r;   rE   rO   \     "zMatchValue._codegen_implc                 C      | j jS rM   r{   r   r\   r;   r;   rE   r   `     zMatchValue.lparc                 C      || j _d S rM   r  rN   r{   r;   r;   rE   r   d     c                 C   r  rM   r{   r  r\   r;   r;   rE   r  h  r  zMatchValue.rparc                 C   r  rM   r  r  r;   r;   rE   r  l  r  )r?   r@   rA   rB   r   rD   r8   ra   r%   rO   r   r	   r   r   setterr!   r  r;   r;   r;   rE   r  O  s   
 r  c                   @   s   e Zd ZU dZeed< deddfddZdd	d
Zde	ddfddZ
edee fddZejdee ddfddZedee fddZejdee ddfddZdS )MatchSingletonz<
    A match literal pattern that compares by identity.
    r{   r^   rL   r   c                 C   rm   r  )r  r(   r{   r`   r;   r;   rE   ra   {  r  z*MatchSingleton._visit_and_replace_childrenNc                 C   s   | j j dvr
tdd S )N>   NoneTrueFalsez2A match singleton can only be True, False, or None)r{   r   r\   r;   r;   rE   r]   ~  s
   zMatchSingleton._validaterJ   c                 C   r  rM   r  r   r;   r;   rE   rO     r  zMatchSingleton._codegen_implc                 C   r  rM   r  r\   r;   r;   rE   r     r  zMatchSingleton.lparc                 C   r  rM   r  r  r;   r;   rE   r        c                 C   r  rM   r  r\   r;   r;   rE   r    r  zMatchSingleton.rparc                 C   r  rM   r  r  r;   r;   rE   r    r  rj   )r?   r@   rA   rB   r   rD   r8   ra   r]   r%   rO   r   r	   r   r   r  r!   r  r;   r;   r;   rE   r  q  s   
 
r  c                	   @   sb   e Zd ZU dZeed< ejZe	e
ef ed< dedd fddZ			dd
edededdfddZdS )MatchSequenceElementz1
    An element in a sequence match pattern.
    r{   r   r^   rL   c                 C   r   )Nr{   r   )r{   r   )r  r(   r{   r)   r   r`   r;   r;   rE   ra     s   z0MatchSequenceElement._visit_and_replace_childrenFTrJ   r   default_comma_whitespaceNc                 C   s   | | = | j| | j}|tju r |r ||rdnd nt|tr2|| W d    d S W d    d S W d    d S 1 sEw   Y  d S )Nr   ,)	rd   r{   rf   r   r   rQ   re   rg   r/   )rN   rJ   r   r  r   r;   r;   rE   rO     s   
"z"MatchSequenceElement._codegen_implFT)r?   r@   rA   rB   r  rD   r   rQ   r   r
   r/   r8   ra   r%   rR   rO   r;   r;   r;   rE   r    s(   
 
r  c                	   @   s|   e Zd ZU dZdZee ed< ej	Z
eeef ed< edZeed< dedd fd	d
Z		ddedededdfddZdS )	MatchStarzZ
    A starred element in a sequence match pattern. Matches the rest of the sequence.
    Nr   r   r   whitespace_before_namer^   rL   c                 C   r   )Nr  r   r   )r  r   r   )r  r(   r  r'   r   r)   r   r`   r;   r;   rE   ra     r   z%MatchStar._visit_and_replace_childrenFTrJ   r   r  c                 C   s   | | T |d | j| | j}|d u r|d n|| | j}|tju r7|r7||r3dnd nt|t	rI|| W d    d S W d    d S W d    d S 1 s\w   Y  d S )Nr   _r   r  )
rd   re   r  rf   r   r   r   rQ   rg   r/   )rN   rJ   r   r  r   r   r;   r;   rE   rO     s"   



"zMatchStar._codegen_implr  )r?   r@   rA   rB   r   r   r   rD   r   rQ   r   r
   r/   r6   r   r  r3   r8   ra   r%   rR   rO   r;   r;   r;   rE   r    s"   
 r  c                   @   s*   e Zd ZU dZdZeeeef  e	d< dS )MatchSequencez
    A match sequence pattern. It's either a :class:`MatchList` or a :class:`MatchTuple`.
    Matches a variable length sequence if one of the patterns is a :class:`MatchStar`,
    otherwise matches a fixed length sequence.
    r;   patternsN)
r?   r@   rA   rB   rC   r	   r
   r  r  rD   r;   r;   r;   rE   r    s   
 r  c                       s   e Zd ZU dZeeeef  ed< dZ	e
e ed< dZe
e ed< dZee ed< dZee ed< d fd
dZded	d fddZded	dfddZ  ZS )	MatchListz
    A list match pattern. It's either an "open sequence pattern" (without brackets) or a
    regular list literal (with brackets).
    r  Nlbracketrbracketr;   r   r  rL   c                    sN   | j r
| js
td| jr| j std| js| j stdtt|   d S )Nz.Cannot have left bracket without right bracketz.Cannot have right bracket without left bracketz1Must have brackets if matching against empty list)r  r  r   r  superr  r]   r\   	__class__r;   rE   r]     s   zMatchList._validater^   c              
   C   sN   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|dS )Nr   r  r  r  r  )r   r  r  r  r  )r  r*   r   r'   r  r  r  r  r`   r;   r;   rE   ra     r   z%MatchList._visit_and_replace_childrenrJ   c                 C   s   |  |B | j}|d ur|| | j}t|D ]\}}|j||t|d k d q| j}|d ur?|| W d    d S W d    d S 1 sJw   Y  d S Nr   r  )_parenthesizer  rf   r  r   r   r  )rN   rJ   r  patsr   patr  r;   r;   rE   rO   %  s   
"zMatchList._codegen_implrj   )r?   r@   rA   rB   r	   r
   r  r  rD   r  r   r   r  r"   r   r   r  r!   r]   r8   ra   r%   rO   __classcell__r;   r;   r  rE   r    s   
 	r  c                       s   e Zd ZU dZeeeef  ed< e	dd dZ
ee ed< e	dd dZee ed< d fddZded	d fddZded	d
fddZ  ZS )
MatchTuplez 
    A tuple match pattern.
    r  c                   C      t  fS rM   )r   r;   r;   r;   rE   <lambda>=      zMatchTuple.<lambda>)default_factoryr   c                   C   r  rM   )r!   r;   r;   r;   rE   r  ?  r  r  rL   Nc                    s(   t | jdk rtdtt|   d S )Nr   z5Tuple patterns must have at least pair of parenthesis)r   r   r   r  r  r]   r\   r  r;   rE   r]   A  s
   zMatchTuple._validater^   c                 C   r   Nr   r  r  )r   r  r  )r  r*   r   r  r  r`   r;   r;   rE   ra   I  r   z&MatchTuple._visit_and_replace_childrenrJ   c                 C   st   |  |+ | j}t|}t|D ]\}}|j||dkp!||d k |dkd qW d    d S 1 s3w   Y  d S )Nr   )r   r  )r  r  r   r   rf   )rN   rJ   r  patlenr   r  r;   r;   rE   rO   P  s   "zMatchTuple._codegen_implrj   )r?   r@   rA   rB   r	   r
   r  r  rD   r   r   r   r  r!   r]   r8   ra   r%   rO   r  r;   r;   r  rE   r  2  s   
 r  c                   @   s   e Zd ZU dZeed< eed< ejZ	e
eef ed< edZeed< edZeed< d	ed
d fddZddeded
dfddZdS )MatchMappingElementz;
    A ``key: value`` pair in a match mapping pattern.
    keyr  r   r   r   rV   r  r^   rL   c              
   C   N   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|dS )Nr  r   r  r  r   )r  r   r  r  r   )r  r(   r  r   r  r  r)   r   r`   r;   r;   rE   ra   q     

z/MatchMappingElement._visit_and_replace_childrenFrJ   r   Nc                 C      | | P | j| | j| |d | j| | j| | j}|tj	u r3|r3|d nt
|trE|| W d    d S W d    d S W d    d S 1 sXw   Y  d S )Nr   r   )rd   r  rf   r   re   r  r  r   r   rQ   rg   r/   rw  r;   r;   rE   rO         

	"z!MatchMappingElement._codegen_implrP   )r?   r@   rA   rB   r   rD   r  r   rQ   r   r
   r/   r6   r   r   r3   r  r8   ra   r%   rR   rO   r;   r;   r;   rE   r  \     
 
r  c                       s   e Zd ZU dZdZee ed< e	 Z
eed< e	 Zeed< dZee ed< e	dZeed	< dZee ed
< dZee ed< dZee ed< d fddZdedd fddZdeddfddZ  ZS )MatchMappingz"
    A match mapping pattern.
    r;   elementslbracerbraceNrestr   whitespace_before_resttrailing_commar   r  rL   c                    s0   t | jtr| jd urtdtt|   d S )Nz+Cannot have a trailing comma without **rest)rg   r  r/   r  r   r  r  r]   r\   r  r;   rE   r]     s   zMatchMapping._validater^   c                 C   sx   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|t| d| j|d	S )
Nr   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`   r;   r;   rE   ra     s   

z(MatchMapping._visit_and_replace_childrenrJ   c                 C   s   |  |U | j| | j}| j}t|D ]\}}|j||d up(|t|d k d q|d urL|d | j| || | j	}|d urL|| | j
| W d    d S 1 s]w   Y  d S )Nr   r  rR  )r  r  rf   r  r  r   r   re   r  r  r  )rN   rJ   elemsr  r   elr   r;   r;   rE   rO     s"   


"zMatchMapping._codegen_implrj   )r?   r@   rA   rB   r  r	   r  rD   r   r   r  r    r  r  r   r   r6   r  r  r/   r   r   r  r!   r]   r8   ra   r%   rO   r  r;   r;   r  rE   r    s   
 r  c                   @   s   e Zd ZU dZeed< eed< ejZ	e
eef ed< edZeed< edZeed< ded	d fd
dZddeded	dfddZdS )MatchKeywordElementz4
    A key=value pair in a :class:`MatchClass`.
    r  r  r   r   r  r  r^   rL   c              
   C   r  )Nr  r  r  r  r   )r  r  r  r  r   )r  r(   r  r  r  r  r)   r   r`   r;   r;   rE   ra     r  z/MatchKeywordElement._visit_and_replace_childrenFrJ   r   Nc                 C   r  )Nr  r   )rd   r  rf   r  re   r  r  r   r   rQ   rg   r/   rw  r;   r;   rE   rO     r  z!MatchKeywordElement._codegen_implrP   )r?   r@   rA   rB   r   rD   r  r   rQ   r   r
   r/   r6   r   r  r3   r  r8   ra   r%   rR   rO   r;   r;   r;   rE   r    r  r  c                   @   s   e Zd ZU dZeed< dZee ed< dZ	ee
 ed< edZeed< edZeed< edZeed	< dZee ed
< dZee ed< dedd fddZdeddfddZdS )
MatchClassz 
    A match class pattern.
    clsr;   r  kwdsr   whitespace_after_clswhitespace_before_patternswhitespace_after_kwdsr   r  r^   rL   c                 C   sx   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|d	S )
Nr   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;   r;   rE   ra   *  s&   

z&MatchClass._visit_and_replace_childrenrJ   Nc                 C   s   |  |a | j| | j| |d | j| | j}| j}t|D ]\}}|j||d t	|t	| k d q't|D ]\}}|j||d t	|k d qA| j
| |d W d    d S 1 siw   Y  d S )Nr?  r   r  r@  )r  r  rf   r  re   r  r  r  r   r   r  )rN   rJ   r  r  r   r  kwdr;   r;   rE   rO   ?  s   
$"zMatchClass._codegen_impl)r?   r@   rA   rB   r   rD   r  r	   r  r  r  r6   r   r  r3   r  r  r   r   r  r!   r8   ra   r%   rO   r;   r;   r;   rE   r    s   
 r  c                       s   e Zd ZU dZdZee ed< dZee	 ed< e
jZeee
f ed< e
jZeee
f ed< dZee ed< dZee ed	< d
edd fddZd fddZdeddfddZ  ZS )MatchAszE
    A match "as-pattern", capture pattern, or wildcard pattern.
    Nr  r   r   r   r;   r   r  r^   rL   c                 C   s\   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|dS )Nr   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   ra   p  s   

z#MatchAs._visit_and_replace_childrenc                    s.   | j d u r| jd urtdtt|   d S )Nz$Pattern must be None if name is None)r   r  r   r  r  r]   r\   r  r;   rE   r]   ~  s   zMatchAs._validaterJ   c                 C   s   |  |d | j}| j}|d urJ|| | j}|tju r#|d n
t|t	r-|| |d | j
}|tju r@|d n
t|t	rJ|| |d u rT|d n|| W d    d S W d    d S 1 slw   Y  d S )NrV   r   r  )r  r  r   rf   r   r   rQ   re   rg   r3   r   )rN   rJ   r  r   	ws_beforews_afterr;   r;   rE   rO     s,   







"zMatchAs._codegen_implrj   )r?   r@   rA   rB   r  r   r  rD   r   r   r   rQ   r   r
   r3   r   r   r	   r   r  r!   r8   ra   r]   r%   rO   r  r;   r;   r  rE   r  O  s   
 r  c                   @   r   )MatchOrElementz0
    An element in a :class:`MatchOr` node.
    r  	separatorr^   rL   c                 C   r   )Nr  r  )r  r  )r  r(   r  r)   r  r`   r;   r;   rE   ra     r   z*MatchOrElement._visit_and_replace_childrenFrJ   default_separatorNc                 C   s   | | 9 | j| | j}|tju r|r|d nt|tr.|| W d    d S W d    d S W d    d S 1 sAw   Y  d S )Nz | )	rd   r  rf   r  r   rQ   re   rg   r-   )rN   rJ   r  sepr;   r;   rE   rO     s   
"zMatchOrElement._codegen_implrP   )r?   r@   rA   rB   r  rD   r   rQ   r  r
   r-   r8   ra   r%   rR   rO   r;   r;   r;   rE   r    s   
 r  c                   @   sb   e Zd ZU dZee ed< dZee ed< dZ	ee
 ed< dedd fdd	Zd
eddfddZdS )MatchOrz
    A match "or-pattern". It matches each of its subpatterns in turn to the subject,
    until one succeeds. The or-pattern is then deemed to succeed. If none of the
    subpatterns succeed the or-pattern fails.
    r  r;   r   r  r^   rL   c                 C   r   r  )r  r*   r   r  r  r`   r;   r;   rE   ra     r   z#MatchOr._visit_and_replace_childrenrJ   Nc                 C   sb   |  |" | j}t|D ]\}}|j||d t|k d qW d    d S 1 s*w   Y  d S )Nr   )r  )r  r  r   rf   r   )rN   rJ   r  r   r  r;   r;   rE   rO     s   "zMatchOr._codegen_impl)r?   r@   rA   rB   r	   r  rD   r   r   r  r!   r8   ra   r%   rO   r;   r;   r;   rE   r    s   
 r  c                   @   sd   e Zd ZU dZeed< dZee ed< e	j
Zeee	f ed< deddfdd	Zd
edd fddZdS )TypeVarz
    A simple (non-variadic) type variable.

    Note: this node represents type a variable when declared using PEP-695 syntax.
    r   NboundcolonrJ   rL   c                 C   s   | | : | j| | j}| j}t|ts|| n	|d ur&|d |d ur7|| W d    d S W d    d S 1 sBw   Y  d S )Nz: )rd   r   rf   r  r  rg   r   re   )rN   rJ   r  r  r;   r;   rE   rO     s   


"zTypeVar._codegen_implr^   c                 C   r   )Nr   r  r  )r   r  r  )r  r(   r   r)   r  r'   r  r`   r;   r;   rE   ra     r   z#TypeVar._visit_and_replace_children)r?   r@   rA   rB   r   rD   r  r   r   r   rQ   r  r
   r.   r%   rO   r8   ra   r;   r;   r;   rE   r    s   
 r  c                   @   P   e Zd ZU dZeed< edZeed< de	ddfdd	Z
d
edd fddZdS )TypeVarTuplez#
    A variadic type variable.
    r   r   r   rJ   rL   Nc                 C   R   | |  |d | j| | j| W d    d S 1 s"w   Y  d S )Nr   rd   re   r   rf   r   r   r;   r;   rE   rO     
   
"zTypeVarTuple._codegen_implr^   c                 C   $   t t| d| j|t| d| j|dS Nr   r   )r   r   )r  r(   r   r   r`   r;   r;   rE   ra        
z(TypeVarTuple._visit_and_replace_childrenr?   r@   rA   rB   r   rD   r6   r   r   r%   rO   r8   ra   r;   r;   r;   rE   r    s   
 r  c                   @   r  )	ParamSpecz
    A parameter specification.

    Note: this node represents a parameter specification when declared using PEP-695
    syntax.
    r   r   r   rJ   rL   Nc                 C   r  rQ  r  r   r;   r;   rE   rO   /  r  zParamSpec._codegen_implr^   c                 C   r  r  )r  r(   r   r   r`   r;   r;   rE   ra   5  r  z%ParamSpec._visit_and_replace_childrenr  r;   r;   r;   rE   r    s   
 r  c                   @   s   e Zd ZU dZeeeef ed< e	j
Zeee	f ed< e	j
Zeee	f ed< dZed ed< edZeed< d	Zee ed
< ddededd	fddZdedd fddZdddZd	S )	TypeParamzV
    A single type parameter that is contained in a :class:`TypeParameters` list.
    paramr   r  r   r   r   rS  r   NdefaultFrJ   r   rL   c                 C   s   | j | | j}|tju r| jd ur|d n
t|tr#|| || j	 | j
| | j}|d ur;|| | j}t|trN|rL|d d S d S || d S )Nr#  r   )r  rf   r  r   rQ   r  re   rg   r+   rS  r   r   )rN   rJ   r   r  r  r   r;   r;   rE   rO   X  s"   



zTypeParam._codegen_implr^   c                 C   sV   t t| d| j|t| d| j|| jt| d| j|t| d| j|t| d| j	|d}|S )Nr  r  r   r  r   )r  r  rS  r   r  r   )
r  r(   r  r)   r  rS  r   r'   r  r   )rN   r^   retr;   r;   rE   ra   o  s   

z%TypeParam._visit_and_replace_childrenc                 C   sd   | j d u rt| jtrtd| jr| j st| jtstdt| jtr.| jdvr0tdd S d S )Nz3Must have a default when specifying an AssignEqual.z%Star can only be present if a defaultr  z'Must specify either '' or '*' for star.)r  rg   r  r+   r   rS  r   r\   r;   r;   rE   r]   |  s   zTypeParam._validaterP   rj   )r?   r@   rA   rB   r
   r  r  r  rD   r   rQ   r   r/   r  r+   rS  r   r6   r   r   r  r   r   r%   rR   rO   r8   ra   r]   r;   r;   r;   rE   r  >  s   
 r  c                   @   sf   e Zd ZU dZdZee ed< e	 Z
eed< e	 Zeed< deddfd	d
Zdedd fddZdS )r;  z
    Type parameters when specified with PEP-695 syntax.

    This node captures all specified parameters that are enclosed with square brackets.
    r;   r3  r  r  rJ   rL   Nc                 C   sP   | j | t| j}t| jD ]\}}|j||d |k d q| j| d S r  )r  rf   r   r3  r   r  )rN   rJ   
params_lenr   r  r;   r;   rE   rO     s
   
zTypeParameters._codegen_implr^   c                 C   r~   )Nr  r3  r  )r  r3  r  )r;  r(   r  r*   r3  r  r`   r;   r;   rE   ra     r   z*TypeParameters._visit_and_replace_children)r?   r@   rA   rB   r3  r	   r  rD   r   r   r  r"   r  r%   rO   r8   ra   r;   r;   r;   rE   r;    s   
 r;  c                   @   s   e Zd ZU dZeed< eed< dZee	 ed< e
dZe
ed< ejZee
ef ed< ejZee
ef ed	< e
dZe
ed
< ejZeeef ed< dddZdedd fddZ	ddededdfddZdS )	TypeAliasz
    A type alias statement.

    This node represents the ``type`` statement as specified initially by PEP-695.
    Example: ``type ListOrSet[T] = list[T] | set[T]``.
    r   r{   Nr<  rV   whitespace_after_typer9  r=  whitespace_after_equalsrI   rL   c                 C   s.   | j d u r| jtdtjhvrtdd S d S )Nr   z_whitespace_after_type_parameters must be empty when there are no type parameters in a TypeAlias)r<  r=  r6   r   rQ   r   r\   r;   r;   rE   r]     s   
zTypeAlias._validater^   c                 C   sx   t t| d| j|t| d| j|t| d| j|t| d| j|t| d| j|t| d| j	|t| d| j
|t| d| j|d	S )
Nr  r   r9  r<  r=  r  r{   rI   )r  r   r9  r<  r=  r  r{   rI   )r  r(   r  r   r)   r9  r'   r<  r=  r  r{   rI   r`   r;   r;   rE   ra     s.   



z%TypeAlias._visit_and_replace_childrenFrJ   rK   c                 C   s  | | ~ |d | j| | j| | j}t|tr*| jd u r)|d n|| | j	}| jd urM| j| t|trH|d n|| |d | j
| | j| | j}t|trn|rm|d n|| W d    d S W d    d S 1 sw   Y  d S )Nr   rV   r  rc   )rd   re   r  rf   r   r9  rg   r   r<  r=  r  r{   rI   )rN   rJ   rK   ws_after_namews_after_type_paramssemir;   r;   rE   rO     s8   










" zTypeAlias._codegen_implrj   rP   )r?   r@   rA   rB   r   rD   r   r<  r   r;  r6   r   r  r   rQ   r9  r
   r=  r  rI   r2   r]   r8   ra   r%   rR   rO   r;   r;   r;   rE   r    s,   
 
r  )r-  reabcr   r   dataclassesr   r   typingr   r   r   r	   r
   libcst._add_slotsr   libcst._maybe_sentinelr   libcst._nodes.baser   r   libcst._nodes.expressionr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   libcst._nodes.internalr%   r&   r'   r(   r)   r*   libcst._nodes.opr+   r,   r-   r.   r/   r0   r1   r2   libcst._nodes.whitespacer3   r4   r5   r6   r7   libcst._visitorsr8   compileUNICODEr9   r   rD   r:   r<   r=   rT   rl   ru   rx   rz   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r	  r  r  r  r$  r&  rR   r1  r2  rH  rX  rZ  ra  rh  rk  rr  rv  ry  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   <module>   s  
` (
	2?#0-+*HX*XJ&OCV7 ".?*/
$  /.xpCZF&8;	_I (!,7(0F0EI(G