o DDi-*@s ddlZddlmZmZddlmZddlmZddlm Z m Z ddl m Z m Z ddlmZmZmZddlmZmZmZmZmZmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mee ddGddde"Z?ee ddGddde"Z@ee ddGddde"ZAee ddGddde"ZBee ddGddde"ZCGd d!d!e"eZDGd"d#d#e ZEGd$d%d%eDeZFGd&d'd'eFeZGGd(d)d)eFeZHee ddGd*d+d+eGeHZIee ddGd,d-d-eFZJGd.d/d/eFeZKee ddGd0d1d1eKZLee ddGd2d3d3eKZMee ddGd4d5d5eKZNGd6d7d7eFeZOed8ZPGd9d:d:eOeZQee ddGd;d<dd>e"eZSee ddGd?d@d@eSZTee ddGdAdBdBeSZUee ddGdCdDdDeQZVee ddGdEdFdFeOZWee ddGdGdHdHe"ZXee ddGdIdJdJeFZYee ddGdKdLdLeFZZee ddGdMdNdNeFZ[ee ddGdOdPdPeFZ\ee ddGdQdRdReGeHZ]GdSdTdTe"eZ^ee ddGdUdVdVe^Z_ee ddGdWdXdXe^Z`ee ddGdYdZdZe"Zaee ddGd[d\d\eGeHZbee ddGd]d^d^e"Zcee ddGd_d`d`e"Zdee ddGdadbdbe"Zeee ddGdcdddde"Zfee ddGdedfdfe"Zgee ddGdgdhdheFZhee ddGdidjdje"ZiGdkdldleFeZjee ddGdmdndnejZkee ddGdodpdpeFZlee ddGdqdrdreFZmee ddGdsdtdte"Znee ddGdudvdveFZoGdwdxdxe"eZpGdydzdzepeZqGd{d|d|epeZree ddGd}d~d~eqZsee ddGddderZtee ddGdddeqeFeDZuee ddGddderZvee ddGdddeGeHZwGdddeFeZxee ddGdddexeGeHZyGdddeFeZzGdddezeZ{ee ddGddde{Z|GdddezeZ}ee ddGddde}Z~ee ddGddde"Zee ddGddde"ZGdddeFeZGdddeeZee ddGdddeZee ddGdddexeZee ddGddde{eZee ddGddde}eZee ddGdddeFZdS)N)ABCabstractmethod) literal_eval)contextmanager) dataclassfield)autoEnum) Floatnumber Imagnumber Intnumber)Callable GeneratorLiteralOptionalSequenceUnion) add_slots) MaybeSentinel)CSTCodegenErrorCSTNodeCSTValidationError) CodegenStatevisit_optionalvisit_requiredvisit_sentinelvisit_sequence) AssignEqual BaseBinaryOp BaseBooleanOp BaseCompOp BaseUnaryOpColonCommaDotInIsIsNotNotNotIn)BaseParenthesizableWhitespaceSimpleWhitespace) CSTVisitorTT)frozenc@HeZdZUdZedZeed<de ddfddZ de dd fd d Z d S) LeftSquareBracketz Used by various nodes to denote a subscript or list section. This doesn't own the whitespace to the left of it since this is owned by the parent node. whitespace_aftervisitorreturncCtt|d|j|dSNr1r1)r/rr1selfr2r9Q/var/www/Datamplify/venv/lib/python3.10/site-packages/libcst/_nodes/expression.py_visit_and_replace_children<  z-LeftSquareBracket._visit_and_replace_childrenstateNcC|d|j|dS)N[ add_tokenr1_codegenr8r=r9r9r: _codegen_implC zLeftSquareBracket._codegen_impl __name__ __module__ __qualname____doc__r+rr1r*__annotations__r,r;rrDr9r9r9r:r/1 r/c@r.) RightSquareBracketz Used by various nodes to denote a subscript or list section. This doesn't own the whitespace to the right of it since this is owned by the parent node. r0whitespace_beforer2r3cCr4NrN)rN)rMrrNr7r9r9r:r;Sr<z.RightSquareBracket._visit_and_replace_childrenr=NcC|j||ddS)N]rNrBrArCr9r9r:rDZ z RightSquareBracket._codegen_impl rGrHrIrJr+rrNr*rKr,r;rrDr9r9r9r:rMHrLrMc@r.) LeftCurlyBracez Used by various nodes to denote a dict or set. This doesn't own the whitespace to the left of it since this is owned by the parent node. r0r1r2r3cCr4r5)rUrr1r7r9r9r:r;jr<z*LeftCurlyBrace._visit_and_replace_childrenr=NcCr>)N{r@rCr9r9r:rDqrEzLeftCurlyBrace._codegen_implrFr9r9r9r:rU_rLrUc@r.) RightCurlyBracez Used by various nodes to denote a dict or set. This doesn't own the whitespace to the right of it since this is owned by the parent node. r0rNr2r3cCr4rO)rWrrNr7r9r9r:r;r<z+RightCurlyBrace._visit_and_replace_childrenr=NcCrP)N}rRrCr9r9r:rDrSzRightCurlyBrace._codegen_implrTr9r9r9r:rWvrLrWc@r.) LeftParenz Used by various nodes to denote a parenthesized section. This doesn't own the whitespace to the left of it since this is owned by the parent node. r0r1r2r3cCr4r5)rYrr1r7r9r9r:r;r<z%LeftParen._visit_and_replace_childrenr=NcCr>)N(r@rCr9r9r:rDrEzLeftParen._codegen_implrFr9r9r9r:rYrLrYc@r.) RightParenz Used by various nodes to denote a parenthesized section. This doesn't own the whitespace to the right of it since this is owned by the parent node. r0rNr2r3cCr4rO)r[rrNr7r9r9r:r;r<z&RightParen._visit_and_replace_childrenr=NcCrP)N)rRrCr9r9r:rDrSzRightParen._codegen_implrTr9r9r9r:r[rLr[c@sReZdZUdZedZeed<dddZde ddfd d Z d e ddfd d Z dS) Asynchronousze Used by asynchronous function definitions, as well as ``async for`` and ``async with``.  r1r3NcCst|jjdkr tddS)Nz0Must have at least one space after Asynchronous.)lenr1valuerr8r9r9r: _validateszAsynchronous._validater2cCr4r5)r]rr1r7r9r9r:r;r<z(Asynchronous._visit_and_replace_childrenr=cCsD|| |dWdn1swY|j|dS)Nasync)record_syntactic_positionrAr1rBrCr9r9r:rDs  zAsynchronous._codegen_implr3N) rGrHrIrJr+rr1rKrcr,r;rrDr9r9r9r:r]s  r]c@sZeZdZUdZdZdZeeed<dZ ee ed<d ddZ e d e ded fd d ZdS)_BaseParenthesizedNodea We don't want to have another level of indirection for parenthesis in our tree, since that makes us more of a CST than an AST. So, all the expressions or atoms that can be wrapped in parenthesis will subclass this to get that functionality. r9lparrparr3NcCsH|jr |js td|js|jrtdt|jt|jkr"tddS)Nz+Cannot have left paren without right paren.z+Cannot have right paren without left paren.zCannot have unbalanced parens.)rhrirr`rbr9r9r:rcs  z _BaseParenthesizedNode._validater=NNNccsb|jD]}||q|| dVWdn1swY|jD]}||q'dSN)rhrBreri)r8r=rhrir9r9r: _parenthesizes     z$_BaseParenthesizedNode._parenthesizerf)rGrHrIrJ __slots__rhrrYrKrir[rcrrrrlr9r9r9r:rgs  rgc@seZdZeZeZdS)ExpressionPositionN)rGrHrIrLEFTRIGHTr9r9r9r:rns rnc@s@eZdZdZdZdedefddZdedddddefd d Zd S) BaseExpressionzX An base class for all expressions. :class:`BaseExpression` contains no fields. r9positionr3cCst|jdko t|jdkS)a Returns true if this expression is safe to be use with a word operator such as "not" without space between the operator an ourselves. Examples where this is true are "not(True)", "(1)in[1,2,3]", etc. This base function handles parenthesized nodes, but certain nodes such as tuples, dictionaries and lists will override this to signifiy that they're always safe. r)r`rhrir8rrr9r9r:_safe_to_use_with_word_operators z.BaseExpression._safe_to_use_with_word_operatorleftrightcCs0|tjkr |tjS|tjkr|tjSdSNF)rnrprtro)r8rrrurvr9r9r:+_check_left_right_word_concatenation_safetys    z:BaseExpression._check_left_right_word_concatenation_safetyN) rGrHrIrJrmrnboolrtrxr9r9r9r:rqs rqc@eZdZdZdZdS)BaseAssignTargetExpressiona An expression that's valid on the left side of an assignment. That assignment may be part an :class:`Assign` node, or it may be part of a number of other control structures that perform an assignment, such as a :class:`For` loop. Python's grammar defines all expression as valid in this position, but the AST compiler further restricts the allowed types, which is what this type attempts to express. This is similar to a :class:`BaseDelTargetExpression`, but it also includes :class:`StarredElement` as a valid node. The set of valid nodes are defined as part of `CPython's AST context computation `_. r9NrGrHrIrJrmr9r9r9r:r{r{c@rz)BaseDelTargetExpressiona An expression that's valid on the right side of a :class:`Del` statement. Python's grammar defines all expression as valid in this position, but the AST compiler further restricts the allowed types, which is what this type attempts to express. This is similar to a :class:`BaseAssignTargetExpression`, but it excludes :class:`StarredElement`. The set of valid nodes are defined as part of `CPython's AST context computation `_ and as part of `CPython's bytecode compiler `_. r9Nr|r9r9r9r:r~0r}r~cspeZdZUdZeed<dZeeed<dZ ee ed<de ddfdd Z dfd d Z d edd fddZZS)Namea8 A simple variable name. Names are typically used in the context of a variable access, an assignment, or a deletion. Dotted variable names (``a.b.c``) are represented with :class:`Attribute` nodes, and subscripted variable names (``a[b]``) are represented with :class:`Subscript` nodes. rar9rhrir2r3cC(tt|d|j||jt|d|j|dSNrhri)rhrari)rrrhrarir7r9r9r:r;W z Name._visit_and_replace_childrenNcsDtt|t|jdkrtd|js td|jddS)Nrz"Cannot have empty name identifier.zName z is not a valid identifier.)superrrcr`rar isidentifierrb __class__r9r:rc^s  zName._validater=cC<||||jWddS1swYdSrkrlrArarCr9r9r:rDe "zName._codegen_implrf)rGrHrIrJstrrKrhrrYrir[r,r;rcrrD __classcell__r9r9rr:rDs  rc@sheZdZUdZdZeeed<dZee ed<de ddfddZ d e de fd d Zd edd fddZd S)Ellipsisa$ An ellipsis ``...``. When used as an expression, it evaluates to the `Ellipsis constant`_. Ellipsis are often used as placeholders in code or in conjunction with :class:`SubscriptElement`. .. _Ellipsis constant: https://docs.python.org/3/library/constants.html#Ellipsis r9rhrir2r3cC$tt|d|j|t|d|j|dS)Nrhri)rhri)rrrhrir7r9r9r:r;zz$Ellipsis._visit_and_replace_childrenrrcCdSNTr9rsr9r9r:rtz(Ellipsis._safe_to_use_with_word_operatorr=NcCs:|||dWddS1swYdS)Nz...)rlrArCr9r9r:rDs  "zEllipsis._codegen_impl)rGrHrIrJrhrrYrKrir[r,r;rnryrtrrDr9r9r9r:rjs rcs.eZdZdZdZdedeffdd ZZS) BaseNumberz A type such as :class:`Integer`, :class:`Float`, or :class:`Imaginary` that can be used anywhere that you need to explicitly take any number type. r9rrr3cs|tjkrdStt||S)z Numbers are funny. The expression "5in [1,2,3,4,5]" is a valid expression which evaluates to "True". So, encapsulate that here by allowing zero spacing with the left hand side of an expression with a comparison operator. T)rnrorrrtrsrr9r:rts z*BaseNumber._safe_to_use_with_word_operator) rGrHrIrJrmrnryrtrr9r9rr:rsrc~eZdZUeed<dZeeed<dZee ed<de ddfddZ dfd d Z d e dd fd dZedefddZZS)Integerrar9rhrir2r3cCrr)rrrhrarir7r9r9r:r;rz#Integer._visit_and_replace_childrenNc(tt|tt|jstddS)NzNumber is not a valid integer.)rrrcre fullmatch INTNUMBER_RErarrbrr9r:rczInteger._validater=cCrrkrrCr9r9r:rDrzInteger._codegen_implcC t|jS)zW Return an :func:`ast.literal_eval` evaluated int of :py:attr:`value`. rrarbr9r9r:evaluated_value zInteger.evaluated_valuerf)rGrHrIrrKrhrrYrir[r,r;rcrrDpropertyintrrr9r9rr:r rcr)Floatrar9rhrir2r3cCrr)rrrhrarir7r9r9r:r;rz!Float._visit_and_replace_childrenNcr)NzNumber is not a valid float.)rrrcrrFLOATNUMBER_RErarrbrr9r:rcrzFloat._validater=cCrrkrrCr9r9r:rDrzFloat._codegen_implcCr)zY Return an :func:`ast.literal_eval` evaluated float of :py:attr:`value`. rrbr9r9r:rrzFloat.evaluated_valuerf)rGrHrIrrKrhrrYrir[r,r;rcrrDrfloatrrr9r9rr:rs rcr) Imaginaryrar9rhrir2r3cCrr)rrrhrarir7r9r9r:r;rz%Imaginary._visit_and_replace_childrenNcr)Nz Number is not a valid imaginary.)rrrcrr IMAGNUMBER_RErarrbrr9r:rcrzImaginary._validater=cCrrkrrCr9r9r:rDrzImaginary._codegen_implcCr)z[ Return an :func:`ast.literal_eval` evaluated complex of :py:attr:`value`. rrbr9r9r:rrzImaginary.evaluated_valuerf)rGrHrIrrKrhrrYrir[r,r;rcrrDrcomplexrrr9r9rr:rrrc@rz) BaseStringz A type that can be used anywhere that you need to take any string. This includes :class:`SimpleString`, :class:`ConcatenatedString`, and :class:`FormattedString`. r9Nr|r9r9r9r:r r"'z"""z'''csNeZdZdZedefddZedefddZde de ffdd Z Z S) _BasePrefixedStringr9r3cCr)z Returns the string's prefix, if any exists. See `String and Bytes literals `_ for more information. Nr9rbr9r9r:prefixs z_BasePrefixedString.prefixcCr)z Returns the quotation used to denote the string. Can be either ``'``, ``"``, ``'''`` or ``"""``. Nr9rbr9r9r:quote%z_BasePrefixedString.quoterrcs,|tjkrdS|jdkrdStt||S)a  ``"a"in"abc`` is okay, but if you add a prefix, (e.g. ``b"a"inb"abc"``), the string is no longer valid on the RHS of the word operator, because it's not clear where the keyword ends and the prefix begins, unless it's parenthesized. Tr0)rnrorrrrtrsrr9r:rt-s   z3_BasePrefixedString._safe_to_use_with_word_operator) rGrHrIrmrrrStringQuoteLiteralrrnryrtrr9r9rr:rs rcseZdZUdZeed<dZeeed<dZ ee ed<dfdd Z e defd d Z e defd d Ze defddZdeddfddZdeddfddZe deeeffddZZS) SimpleStringz Any sort of literal string expression that is not a :class:`FormattedString` (f-string), including triple-quoted multi-line strings. rar9rhrir3Ncstt||j}|dvrtdt|}t|j|dkr#td|j|dvs4|j||jdkr8tdt|j|dkrq|j||j|d krs|j||j|dksm|j||jd ksm|j||jd krutddSdSdS) N)r0rubbrrbzInvalid string prefix.z"String must have enclosing quotes.rrz+String must have matching enclosing quotes.r_)rrrcrrr`ra)r8r prefixlenrr9r:rcOs*zSimpleString._validatecC2d}|jD]}|dvr|S||7}q|S)z~ Returns the string's prefix, if any exists. The prefix can be ``r``, ``u``, ``b``, ``br`` or ``rb``. r0r)ralowerr8rcr9r9r:ro  zSimpleString.prefixcCsd}|jt|jdD]}|dvrn|r||dkrn||7}q t|dkr0|dd}ndt|krrrrrr_r>r_rzInvalid string )rar`r Exception)r8rcharr9r9r:r}s    zSimpleString.quotecCs(t|j}t|j}|j||| S)a Returns the raw value of the string as it appears in source, without the beginning or end quotes and without the prefix. This is often useful when constructing transforms which need to manipulate strings in source code. )r`rrra)r8 prefix_len quote_lenr9r9r: raw_values zSimpleString.raw_valuer2cCrr)rrrhrarir7r9r9r:r;rz(SimpleString._visit_and_replace_childrenr=cCrrkrrCr9r9r:rDrzSimpleString._codegen_implcCr)zW Return an :func:`ast.literal_eval` evaluated str of :py:attr:`value`. rrbr9r9r:rrzSimpleString.evaluated_valuerf)rGrHrIrJrrKrhrrYrir[rcrrrrrr,r;rrDrbytesrrr9r9rr:r=s    %  rc@rz)BaseFormattedStringContentz The base type for :class:`FormattedStringText` and :class:`FormattedStringExpression`. A :class:`FormattedString` is composed of a sequence of :class:`BaseFormattedStringContent` parts. r9Nr|r9r9r9r:rsrc@s>eZdZUdZeed<deddfddZdeddfd d Z dS) FormattedStringTexta Part of a :class:`FormattedString` that is not inside curly braces (``{`` or ``}``). For example, in:: f"ab{cd}ef" ``ab`` and ``ef`` are :class:`FormattedStringText` nodes, but ``{cd}`` is a :class:`FormattedStringExpression`. rar2r3cCs t|jdS)N)ra)rrar7r9r9r:r;s z/FormattedStringText._visit_and_replace_childrenr=NcCs||jdSrk)rArarCr9r9r:rDsz!FormattedStringText._codegen_impl) rGrHrIrJrrKr,r;rrDr9r9r9r:rs   rc@seZdZUdZeed<dZeeed<dZ ee e ed<e dZeed<e dZeed<dZeeed <dd d Zd ed dfddZded dfddZdS)FormattedStringExpressionaK Part of a :class:`FormattedString` that is inside curly braces (``{`` or ``}``), including the surrounding curly braces. For example, in:: f"ab{cd}ef" ``{cd}`` is a :class:`FormattedStringExpression`, but ``ab`` and ``ef`` are :class:`FormattedStringText` nodes. An f-string expression may contain ``conversion`` and ``format_spec`` suffixes that control how the expression is converted to a string. See `Python's language reference `__ for details. expressionN conversion format_specr0whitespace_before_expressionwhitespace_after_expressionequalr3cCs$|jdur|jdvrtddSdS)N)srazInvalid f-string conversion.)rrrbr9r9r:rcsz#FormattedStringExpression._validater2c Csf|j}tt|d|j|t|d|j|t|d|j|t|d|j||j|dur/t |d||dSddS)Nrrrrr)rrrrrr) rrrrrrrrrr)r8r2rr9r9r:r;s, z5FormattedStringExpression._visit_and_replace_childrenr=cCs|d|j||j||j}|dur|||j||j}|dur4|d|||j}|durJ|d|D]}||qB|ddS)NrV!:rX)rArrBrrrrr)r8r=rrrspecr9r9r:rD4s"         z'FormattedStringExpression._codegen_implrf)rGrHrIrJrqrKrrrrrrr+rrr*rrrrcr,r;rrDr9r9r9r:rs$     rcseZdZUdZeeed<dZeed<dZ e ded<dZ ee ed <dZ eeed <dfd d Zed efddZed efddZded dfddZded d fddZZS)FormattedStringa  An "f-string". These formatted strings are string literals prefixed by the letter "f". An f-string may contain interpolated expressions inside curly braces (``{`` and ``}``). F-strings are defined in `PEP 498`_ and documented in `Python's language reference `__. >>> import libcst as cst >>> cst.parse_expression('f"ab{cd}ef"') FormattedString( parts=[ FormattedStringText( value='ab', ), FormattedStringExpression( expression=Name( value='cd', lpar=[], rpar=[], ), conversion=None, format_spec=None, whitespace_before_expression=SimpleWhitespace( value='', ), whitespace_after_expression=SimpleWhitespace( value='', ), ), FormattedStringText( value='ef', ), ], start='f"', end='"', lpar=[], rpar=[], ) .. _PEP 498: https://www.python.org/dev/peps/pep-0498/#specification partszf"startrrendr9rhrir3Ncs\tt||j}|dvrtd|jt|d}||jkr$td|dvr,tddS)N)ffrrfzInvalid f-string prefix.z-f-string must have matching enclosing quotes.rz"Invalid f-string enclosing quotes.)rrrcrrrr`r)r8r starttokenrr9r:rcs zFormattedString._validatecCr)zq Returns the string's prefix, if any exists. The prefix can be ``f``, ``fr``, or ``rf``. r0r)rrrr9r9r:rrzFormattedString.prefixcCs|jS)r)rrbr9r9r:rszFormattedString.quoter2c Cs:tt|d|j||jt|d|j||jt|d|j|dS)Nrhrri)rhrrrri)rrrhrrrrir7r9r9r:r;sz+FormattedString._visit_and_replace_childrenr=cCs^|| ||j|jD]}||q||jWddS1s(wYdSrk)rlrArrrBr)r8r=partr9r9r:rDs    "zFormattedString._codegen_implrf)rGrHrIrJrrrKrrrrrhrYrir[rcrrrrr,r;rrDrr9r9rr:rHs  .   rcseZdZUdZeeefed<eeedfed<dZe e ed<dZ e e ed<e dZeed<d ed effd d Zdfdd Zded dfddZded d fddZed eeed ffddZZS)ConcatenatedStringaK Represents an implicitly concatenated string, such as:: "abc" "def" == "abcdef" .. warning:: This is different from two strings joined in a :class:`BinaryOperation` with an :class:`Add` operator, and is `sometimes viewed as an antifeature of Python `_. rurvr9rhrir0whitespace_betweenrrr3c&tt||r dS|||j|jSr)rrrtrxrurvrsrr9r:rts  z2ConcatenatedString._safe_to_use_with_word_operatorNcstt|t|jjst|jjrtdt|jjs#t|jjr'tdd|jj v}|j}t |tr`_. :: # x < y < z Comparison( Name("x"), [ ComparisonTarget(LessThan(), Name("y")), ComparisonTarget(LessThan(), Name("z")), ], ) ru comparisonsr9rhrirrr3cs,tt||r dS|||j|jdjS)NTr)rrrtrxrurrrsrr9r:rtrs z*Comparison._safe_to_use_with_word_operatorNcsttt|t|jdkrtd|j}|jD]}|j}t|t t t t fr4|j jr4|tjs4td|j}qdS)Nrz(Must have at least one ComparisonTarget.r)rrrcr`rrrurrr%r)r&r'rNrrtrnror)r8previous_comparatortargetrrr9r:rczs& zComparison._validater2c Cs@tt|d|j|t|d|j|t|d|j|t|d|j|dS)Nrhrurri)rhrurri)rrrhrrurrir7r9r9r:r; z&Comparison._visit_and_replace_childrenr=cCsR|||j||jD]}||qWddS1s"wYdSrk)rlrurBr)r8r=compr9r9r:rDs    "zComparison._codegen_implrf)rGrHrIrJrqrKrrrhrYrir[rnryrtrcr,r;rrDrr9r9rr:rGs  rcseZdZUdZeed<eed<dZee ed<dZ ee ed<dfd d Z d e ddfd d Zdedeffdd ZdeddfddZZS)UnaryOperationz Any generic unary expression, such as ``not x`` or ``-x``. :class:`UnaryOperation` nodes apply a :class:`BaseUnaryOp` to an expression. rrr9rhrir3NcsFtt|t|jtr|jjjr|j t j s!t ddSdSdS)Nz0Must have at least one space after not operator.) rrrcrrr(r1rrrtrnrprrbrr9r:rcs  zUnaryOperation._validater2c C@tt|d|j|t|d|j|t|d|j|t|d|j|dS)Nrhrrri)rhrrri)rrrhrrrrir7r9r9r:r;rz*UnaryOperation._visit_and_replace_childrenrrcsHtt||r dS|tjkrt|jt S|tjkr"|j tjSdS)zu As long as we aren't comprised of the Not unary operator, we are safe to use without space. TF) rrrtrnrprrr(rorrsrr9r:rts  z.UnaryOperation._safe_to_use_with_word_operatorr=cCH|||j||j|WddS1swYdSrk)rlrrBrrCr9r9r:rD  "zUnaryOperation._codegen_implrf)rGrHrIrJr!rKrqrhrrYrir[rcr,r;rnryrtrrDrr9r9rr:rs  rcseZdZUdZeed<eed<eed<dZee ed<dZ ee ed<de d dfd d Z d ed effd d Zded dfddZZS)BinaryOperationaJ An operation that combines two expression such as ``x << y`` or ``y + z``. :class:`BinaryOperation` nodes apply a :class:`BaseBinaryOp` to an expression. Binary operations do not include operations performed with :class:`BaseBooleanOp` nodes, such as ``and`` or ``or``. Instead, those operations are provided by :class:`BooleanOperation`. It also does not include support for comparision operators performed with :class:`BaseCompOp`, such as ``<``, ``>=``, ``==``, ``is``, or ``in``. Instead, those operations are provided by :class:`Comparison`. rurrvr9rhrir2r3c CrNrhrurrvri)rhrurrvri)rrrhrrurrvrir7r9r9r:r;z+BinaryOperation._visit_and_replace_childrenrrcrr)rrrtrxrurvrsrr9r:rt  z/BinaryOperation._safe_to_use_with_word_operatorr=NcCrrkrlrurBrrvrCr9r9r:rD rzBinaryOperation._codegen_impl)rGrHrIrJrqrKrrhrrYrir[r,r;rnryrtrrDrr9r9rr:rs  rcseZdZUdZeed<eed<eed<dZee ed<dZ ee ed<dfd d Z d e ddfd dZdedeffdd Zdedd fddZZS)BooleanOperationaH An operation that combines two booleans such as ``x or y`` or ``z and w`` :class:`BooleanOperation` nodes apply a :class:`BaseBooleanOp` to an expression. Boolean operations do not include operations performed with :class:`BaseBinaryOp` nodes, such as ``+`` or ``<<``. Instead, those operations are provided by :class:`BinaryOperation`. It also does not include support for comparision operators performed with :class:`BaseCompOp`, such as ``<``, ``>=``, ``==``, ``is``, or ``in``. Instead, those operations are provided by :class:`Comparison`. rurrvr9rhrir3NcsVtt||jjjr|jtj st d|jj jr'|j tj s)t ddSdS)Nz5Must have at least one space around boolean operator.)rrrcrrNrrurtrnrorr1rvrprbrr9r:rc1s   zBooleanOperation._validater2c Crr)rrrhrrurrvrir7r9r9r:r;Drz,BooleanOperation._visit_and_replace_childrenrrcrr)rrrtrxrurvrsrr9r:rtMrz0BooleanOperation._safe_to_use_with_word_operatorr=cCrrkrrCr9r9r:rDTrzBooleanOperation._codegen_implrf)rGrHrIrJrqrKrrhrrYrir[rcr,r;rnryrtrrDrr9r9rr:rs  rcseZdZUdZeed<eed<eZeed<dZ e e ed<dZ e e ed<ded dfd d Zd ed effd d Zded dfddZZS) Attributea An attribute reference, such as ``x.y``. Note that in the case of ``x.y.z``, the outer attribute will have an attr of ``z`` and the value will be another :class:`Attribute` referencing the ``y`` attribute on ``x``:: Attribute( value=Attribute( value=Name("x") attr=Name("y") ), attr=Name("z"), ) raattrdotr9rhrir2r3c Cr)Nrhrarrri)rhrarrri)rrrhrrarrrir7r9r9r:r;}rz%Attribute._visit_and_replace_childrenrrcrr)rrrtrxrarrsrr9r:rtrz)Attribute._safe_to_use_with_word_operatorr=NcCrrk)rlrarBrrrCr9r9r:rDrzAttribute._codegen_impl)rGrHrIrJrqrKrr$rrhrrYrir[r,r;rnryrtrrDrr9r9rr:r[s  rc@rz) BaseSlicezl Any slice type that can slot into a :class:`SubscriptElement`. This node is purely for typing. r9Nr|r9r9r9r:rrrc@sbeZdZUdZeed<dZeeded<dZ ee ed<de ddfd d Z d e ddfd d ZdS)Indexzf Any index as passed to a :class:`Subscript`. In ``x[2]``, this would be the ``2`` value. raN*starwhitespace_after_starr2r3cCs(t|jt|d|j|t|d|j|dS)Nr ra)r r ra)rr rr rrar7r9r9r:r;s z!Index._visit_and_replace_childrenr=cCs@|j}|dur |||j}|dur|||j|dSrk)r rAr rBra)r8r=r wsr9r9r:rDs  zIndex._codegen_impl)rGrHrIrJrqrKr rrr r*r,r;rrDr9r9r9r:rs  rc@seZdZUdZeeed<eeed<dZeeed<e Z eed<e j Z eee fed<ded dfd d Zd ed dfd dZdS)Slicez Any slice operation in a :class:`Subscript`, such as ``1:``, ``2:3:4``, etc. Note that the grammar does NOT allow parenthesis around a slice so they are not supported here. rupperNstep first_colon second_colonr2r3c CsNtt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|dS)Nrrr rr)rrr rr) r rrrrr rrrr7r9r9r:r;s z!Slice._visit_and_replace_childrenr=cCs|j}|dur |||j||j}|dur|||j}|tjur1|jdur1|dn t |t r;|||j}|durI||dSdSNr) rrBrr rrDEFAULTrrArr")r8r=rr rrr9r9r:rDs       zSlice._codegen_impl)rGrHrIrJrrqrKrr"rrrrrrr,r;rrDr9r9r9r:r s    r c@sZeZdZUdZeed<ejZe e efed<de ddfddZ dd e d edd fd d Zd S)SubscriptElementa] Part of a sequence of slices in a :class:`Subscript`, such as ``1:2, 3``. This is not used in Python's standard library, but it is used in some third-party libraries. For example, `NumPy uses it to select values and ranges from multi-dimensional arrays `_. slicecommar2r3cC$tt|d|j|t|d|j|dS)Nrr)rr)rrrrrr7r9r9r:r; rz,SubscriptElement._visit_and_replace_childrenFr= default_commaNcCst|||j|Wdn1swY|j}|tjur,|r,|ddSt|tr8||dSdS)N, ) rerrBrrrrArr#r8r=rrr9r9r:rDs  zSubscriptElement._codegen_implF)rGrHrIrJrrKrrrrr#r,r;rryrDr9r9r9r:rs  rcseZdZUdZeed<eeed<e Z eed<e Z e ed<dZ eeed<dZeeed<e d Zeed <dfd d Zded dfddZded effdd Zded d fddZZS) Subscriptz A indexed subscript reference (:class:`Index`) such as ``x[2]``, a :class:`Slice` such as ``x[1:-1]``, or an extended slice (:class:`SubscriptElement`) such as ``x[1:2, 3]``. rarlbracketrbracketr9rhrir0whitespace_after_valuer3Ncs(tt|t|jdkrtddS)Nr_z#Cannot have empty SubscriptElement.)rrrcr`rrrbrr9r:rc4szSubscript._validater2c Csjtt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|t|d|j|t|d|j |dS) Nrhrarrrrri)rhrarrrrri) rrrhrrarrrrrir7r9r9r:r;:s z%Subscript._visit_and_replace_childrenrrc>|tjkrdStt||rdS|tjkr|jtjSdS)NTF)rnrorrrtrprarsrr9r:rtGs  z)Subscript._safe_to_use_with_word_operatorr=cCs||;|j||j||j|t|jd}t|jD] \}}|j|||kdq$|j|WddS1sCwYdS)Nr_r) rlrarBrrr`r enumerater)r8r= lastsliceirr9r9r:rDPs    "zSubscript._codegen_implrf)rGrHrIrJrqrKrrr/rrrMrrhrYrir[r+rr*rcr,r;rnryrtrrDrr9r9rr:rs    rc@sreZdZUdZeed<ejZe e efed<e dZ e ed<deddfdd Z dd ed eedd fd dZd S) Annotationa An annotation for a function (`PEP 3107`_) or on a variable (`PEP 526`_). Typically these are used in the context of type hints (`PEP 484`_), such as:: # a variable with a type good_ideas: List[str] = [] # a function with type annotations def concat(substrings: Sequence[str]) -> str: ... .. _PEP 3107: https://www.python.org/dev/peps/pep-3107/ .. _PEP 526: https://www.python.org/dev/peps/pep-0526/ .. _PEP 484: https://www.python.org/dev/peps/pep-0484/ annotationwhitespace_before_indicatorr^whitespace_after_indicatorr2r3cC2tt|d|j|t|d|j|t|d|j|dS)Nr&r'r%)r&r'r%)r$rr&rr'r%r7r9r9r:r;ysz&Annotation._visit_and_replace_childrenNr=default_indicatorcCs|durtd|j}t|tr||nt|tr%|dkr$|dntd|||j|| ||j |WddS1sKwYdS)NzGMust specify a concrete default_indicator if default used on indicator.z->r^r) rr&rr*rBrrArr'rer%)r8r=r)r&r9r9r:rDs"       "zAnnotation._codegen_implrk)rGrHrIrJrqrKrrr&rr*r+rr'r,r;rrrrDr9r9r9r:r$[s"  r$c@sNeZdZUdZejeddZeed<de ddfddZ d e dd fd d Z d S) ParamStarz A sentinel indicator on a :class:`Parameters` list to denote that the subsequent params are keyword-only args. This syntax is described in `PEP 3102`_. .. _PEP 3102: https://www.python.org/dev/peps/pep-3102/#specification r^r6rr2r3cCr4)Nr)r)r*rrr7r9r9r:r;sz%ParamStar._visit_and_replace_childrenr=NcCr>Nr)rArrBrCr9r9r:rDrEzParamStar._codegen_impl) rGrHrIrJr#rr+rrKr,r;rrDr9r9r9r:r*s  r*c@sdeZdZUdZejZeeefe d<e dZ e e d<deddfddZdd ed edd fd dZd S) ParamSlashz A sentinel indicator on a :class:`Parameters` list to denote that the previous params are positional-only args. This syntax is described in `PEP 570`_. .. _PEP 570: https://www.python.org/dev/peps/pep-0570/#specification rr0r1r2r3cCr)Nrr1)rr1)r,rrrr1r7r9r9r:r;s  z&ParamSlash._visit_and_replace_childrenFr=rNcCsT|d|j||j}|tjur|r|ddSt|tr(||dSdS)N/r)rAr1rBrrrrr#rr9r9r:rDs   zParamSlash._codegen_implr)rGrHrIrJrrrrr#rKr+rr1r*r,r;rryrDr9r9r9r:r,s  r,c @seZdZUdZeed<dZeeed<e j Z e e e fed<dZeeed<e j Ze ee fed<e j Ze ee fed<ed Zeed <ed Zeed <dd dZded dfddZ  ddedeeded dfddZdS)Paramz A positional or keyword argument in a :class:`Parameters` list. May contain an :class:`Annotation` and, in some cases, a ``default``. nameNr%rdefaultrr r0r whitespace_after_paramr3cCsD|jdurt|jtrtdt|jtr|jdvr tddSdS)Nz3Must have a default when specifying an AssignEqual.r0r**-Must specify either '', '*' or '**' for star.)r0rrrrr rrbr9r9r:rcszParam._validater2c Csnt|jt|d|j|t|d|j|t|d|j|t|d|j|t|d|j |t|d|j |t|d|j |dS) Nr r/r%rr0rr1)r r r/r%rr0rr1) r.r rr r/rr%rrr0rr1r7r9r9r:r;s  z!Param._visit_and_replace_childrenFr= default_starrc Cs,||0|j}t|tr|durtd|}t|tr"|||j||j |Wdn1s8wY|j }|durK|j|dd|j }|tj ur^|j dur^|dn t|trh|||j }|durt|||j}|tj ur|r|dn t|tr|||j|dS)Nz=Must specify a concrete default_star if default used on star.r)r) = r)rer rrrrrAr rBr/r%rrr0rrr#r1) r8r=r5rr r%rr0rr9r9r:rDs<             zParam._codegen_implrfrw)rGrHrIrJrrKr%rr$rrrrrr0rqrr#r rr+rr r*r1rcr,r;rryrDr9r9r9r:r.s.  r.c@seZdZUdZdZeeed<ej Z e ee efed<dZ eeed<dZeeed<dZeeed<ej Ze eefed <d eed ed dfd dZd!ddZd!ddZd!ddZd!ddZd!ddZded dfddZd efddZded dfdd ZdS)" Parametersz. A function or lambda parameter list. r9paramsstar_arg kwonly_paramsN star_kwargposonly_params posonly_indvalssectionr3cCsDt|dkrdS|D]}t|jtr|jdkrtd|dq dS)Nrr0z"Expecting a star prefix of '' for z Param.)r`rr rr)r8r>r?valr9r9r:_validate_stars_sequencecs  z#Parameters._validate_stars_sequencecC*t|jtrt|jdkrtddSdS)Nrz;Must have at least one posonly param if ParamSlash is used.)rr=r,r`r<rrbr9r9r:_validate_posonly_indl z Parameters._validate_posonly_indcCrB)Nrz9Must have at least one kwonly param if ParamStar is used.)rr9r*r`r:rrbr9r9r:_validate_kwonly_starrrDz Parameters._validate_kwonly_starcCsd}g|j|jRD]}|jr|sd}q |rtdq |j}t|tr-|jdur-td|j}|dur=|jdur?tddSdS)NFTzCCannot have param without defaults following a param with defaults.z!Cannot have default for star_arg.z#Cannot have default for star_kwarg.)r<r8r0rr9rr.r;)r8 seen_defaultparamr9r;r9r9r:_validate_defaultsxs$zParameters._validate_defaultscCst|jdkr|j|jddt|jdkr|j|jdd|j}t|tr5t|jtr5|jdkr5t dt|j dkrD|j|j dd|j }|durZt|jtr\|jdkr^t d dSdSdS) Nrr8)r?r<rz2Expecting a star prefix of '*' for star_arg Param.r:r3z5Expecting a star prefix of '**' for star_kwarg Param.) r`r8rAr<r9rr.r rrr:r;)r8r9r;r9r9r:_validate_starss2    zParameters._validate_starscCs$||||dSrk)rCrErHrIrbr9r9r:rcs zParameters._validater2c Cs\tt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|t|d|j |dS)Nr<r=r8r9r:r;)r<r=r8r9r:r;) r7rr<rr=r8r9r:rr;r7r9r9r:r;s  z&Parameters._visit_and_replace_childrencCs8t|jdkr dSt|jdkr|jdjdvrdSdS)a Determine if Parameters need a space after the `lambda` keyword. Returns True iff it's safe to omit the space between `lambda` and these Parameters. See also `BaseExpression._safe_to_use_with_word_operator`. For example: `lambda*_: pass` rF>rr3T)r`r<r8r rbr9r9r:_safe_to_join_with_lambdas  z$Parameters._safe_to_join_with_lambdar=c Cs|j}t|trt|jdk}n t|ttfrd}nd}t|jD] \}}|j |dddq!|pBt|j dkpBt|jdkpB|j du}|j }t|t rS|j ||dnt|jdkrg|rb|dn|dt|j d }|p{t|jdkp{|j du}t|j D]\}}|j |d||kp|dqt|tr|r|d n$t|trt|jdkp|j du}|j |d |dn t|tr| |t|jd }|j du}t|jD]\}}|j |d||kp|dq|j } | dur| j |d dddSdS) NrTFr0)r5rr z/, r-r_z*, rr3)r9rrr`r:r.r*r!r<rBr8r;r=r,rA) r8r=r9 starincludedr#rG more_valuesr= lastparamr;r9r9r:rDs`            zParameters._codegen_implrf) rGrHrIrJr8rr.rKrrr9rr*r:r;rr<r=r,rrArCrErHrIrcr,r;ryrJrrDr9r9r9r:r7Fs"      r7cseZdZUdZeed<eed<eje ddZ eed<dZ e e ed<dZe eed <ejZeeefed <d ed effd d Zdfdd Zded dfddZded dfddZZS)Lambdaa: A lambda expression that creates an anonymous function. :: Lambda( params=Parameters([Param(Name("arg"))]), body=Ellipsis(), ) Represents the following code:: lambda arg: ... Named functions statements are provided by :class:`FunctionDef`. r8bodyr^r6colonr9rhriwhitespace_after_lambdarrr3cs0|tjkrt|jdkp|j|St|SNr)rnror`rirOrtrrsrr9r:rt<s  z&Lambda._safe_to_use_with_word_operatorNcstt|g|jj|jj|jj}|jj}t|tr#| ||jj }|dur0| |t |dkrX|D] }|j durCt dq8|j}t|trZ|jr\|js^t ddSdSdSdS)Nrz+Lambda params cannot have type annotations.z@Must have at least one space after lambda when specifying params)rrNrcr8r<r:r9rr.appendr;r`r%rrQr*rrJ)r8 all_paramsr9r;rGrQrr9r:rcCsB      zLambda._validater2c Cs\tt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|t|d|j |dS)NrhrQr8rPrOri)rhrQr8rPrOri) rNrrhrrQrr8rPrOrir7r9r9r:r;ds z"Lambda._visit_and_replace_childrenr=cCs||]|d|j}t|tr>t|jjdkr8t|jjdkr8t|jjt s8t|jj dkr8|jj dus=|dn t|t rH| ||j ||j ||j |WddS1sewYdS)Nlambdarr^)rlrArQrrr`r8r<r9r.r:r;r*rBrPrO)r8r=rQr9r9r:rDps$          "zLambda._codegen_implrf)rGrHrIrJr7rKrqr"rr+rPrhrrYrir[rrrQrr*rnryrtrcr,r;rrDrr9r9rr:rNs ! rNc@seZdZUdZeed<dZeeed<e j Z e e e fed<e j Ze ee fed<dZeded <edZeed <edZeed <dd dZded dfddZddeded dfddZdS)Argz A single argument to a :class:`Call`. This supports named keyword arguments in the form of ``keyword=value`` and variable argument expansion using ``*args`` or ``**kwargs`` syntax. raNkeywordrrr0r2r r whitespace_after_argr3cCsT|jdurt|jtrtd|jdvrtd|jdvr&|jdur(tddSdS)Nz3Must have a keyword when specifying an AssignEqual.r2r4)rr3z-Cannot specify a star and a keyword together.)rWrrrrr rbr9r9r:rcs z Arg._validater2c Cs`t|jt|d|j|t|d|j|t|d|j|t|d|j|t|d|j |t|d|j |dS)Nr rWrrarrX)r r rWrrarrX) rVr rr rrWrrrarrXr7r9r9r:r;s  zArg._visit_and_replace_childrenFr=rcCs||C||j|j||j}|dur|||j}|tjur1|jdur1|dn t |t r;|||j |Wdn1sKwY|j }|tjur`|r`|dn t |t rj|||j|dS)Nr6r)rerAr r rBrWrrrrrrarr#rX)r8r=rrWrrr9r9r:rDs&           zArg._codegen_implrfr)rGrHrIrJrqrKrWrrrrrrrrr#r rr+rr r*rXrcr,r;rryrDr9r9r9r:rVs    rVc seZdZUdZdZdZeeed<deddfddZ dede e ege egdfffd d Z dede e ege ege egdffffd d Z dfd d ZZS)_BaseExpressionWithArgsz Arguments are complicated enough that we can't represent them easily in typing. So, we have common validation functions here. r9argsargr3NcCs6|jdurdS|jdkrdS|jdkrtdtd)z[ Validates that we only have a mix of "keyword=arg" and "**arg" expansion. Nr3rzICannot have iterable argument unpacking after keyword argument unpacking.zACannot have positional argument after keyword argument unpacking.)rWr rr8r[r9r9r:_check_kwargs_or_keywordss   z1_BaseExpressionWithArgs._check_kwargs_or_keywordscCs4|jdurdS|jdkr|jS|jdkrdStd)zZ Validates that we only have a mix of "*arg" expansion and "keyword=arg". Nr3rz7Cannot have positional argument after keyword argument.)rWr r]rr\r9r9r:_check_starred_or_keywordss   z2_BaseExpressionWithArgs._check_starred_or_keywordscCs2|jdur|jS|jdkr|jS|jdkrdSdS)z\ Validates that we only have a mix of positional args and "*arg" expansion. Nr3r)rWr^r r]r\r9r9r:_check_positional s   z)_BaseExpressionWithArgs._check_positionalcs,t|j}|jD]}||p|}q dSrk)rrcr_rZ)r8 validatorr[rr9r:rc, s  z!_BaseExpressionWithArgs._validaterf)rGrHrIrJrmrZrrVrKr]rr r^r_rcrr9r9rr:rYs  $ rYcseZdZUdZeed<dZeeed<dZ ee ed<dZ ee ed<e dZeed<e dZeed <d ed effd d Zded dfddZded dfddZZS)Callz An expression representing a function call, such as ``do_math(1, 2)`` or ``picture.post_on_instagram()``. Function calls consist of a function name and a sequence of arguments wrapped in :class:`Arg` nodes. funcr9rZrhrir0whitespace_after_funcwhitespace_before_argsrrr3cr)z Calls have a close paren on the right side regardless of whether they're parenthesized as a whole. As a result, they are safe to use directly against an adjacent node to the right. TF)rnrorrartrprbrsrr9r:rt] s  z$Call._safe_to_use_with_word_operatorr2c Cs\tt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|t|d|j|dS)NrhrbrcrdrZri)rhrbrcrdrZri) rarrhrrbrcrdrZrir7r9r9r:r;k   z Call._visit_and_replace_childrenr=NcCs||?|j||j||d|j|t|jd}t|jD] \}}|j|||kdq)|dWddS1sGwYdS)NrZr_r r\) rlrbrBrcrArdr`rZr!)r8r=lastargr#r[r9r9r:rDy s      "zCall._codegen_impl)rGrHrIrJrqrKrZrrVrhrYrir[r+rrcr*rdrnryrtr,r;rrDrr9r9rr:ra= s  racseZdZUdZeed<dZeeed<dZ ee ed<e dZ eed<dfd d Zd eddfd dZdedd fddZZS)Awaitz An await expression. Await expressions are only valid inside the body of an asynchronous :class:`FunctionDef` or (as of Python 3.7) inside of an asynchronous :class:`GeneratorExp` nodes. rr9rhrir^whitespace_after_awaitr3Ncs4tt||jjr|jtjst ddSdS)Nz(Must have at least one space after await) rrgrcrhrrrtrnrprrbrr9r:rc szAwait._validater2c Cr)Nrhrhrri)rhrhrri)rgrrhrrhrrir7r9r9r:r;  z!Await._visit_and_replace_childrenr=cCsR|||d|j||j|WddS1s"wYdS)Nawait)rlrArhrBrrCr9r9r:rD s   "zAwait._codegen_implrf)rGrHrIrJrqrKrhrrYrir[r+rrhr*rcr,r;rrDrr9r9rr:rg s   rgcseZdZUdZeed<eed<eed<dZeeed<dZ ee ed<e dZ eed <e dZeed <e dZeed <e dZeed <d edefddZdfdd ZdeddfddZdeddfddZZS)IfExpz An if expression of the form ``body if test else orelse``. If statements are provided by :class:`If` and :class:`Else` nodes. testrOorelser9rhrir^whitespace_before_ifwhitespace_after_ifwhitespace_before_elsewhitespace_after_elserrr3cCs"|tjkr |j|S|j|Srk)rnrprOrtrmrsr9r9r:rt s   z%IfExp._safe_to_use_with_word_operatorNcstt||jjr|jtjst d|j jr%|j tj s%t d|j jr4|j tjs4t d|jjrC|jtj sEt ddSdS)N1Must have at least one space before 'if' keyword.0Must have at least one space after 'if' keyword.z3Must have at least one space before 'else' keyword.z2Must have at least one space after 'else' keyword.)rrkrcrnrrOrtrnrorrorlrprprqrmrbrr9r:rc s<   zIfExp._validater2cCtt|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) NrhrOrnrorlrprqrmri) rhrOrnrorlrprqrmri) rkrrhrrOrnrorlrprqrmrir7r9r9r:r; s&    z!IfExp._visit_and_replace_childrenr=cCs||=|j||j||d|j||j||j||d|j||j |WddS1sEwYdS)Nifelse) rlrOrBrnrArorlrprqrmrCr9r9r:rD s         "zIfExp._codegen_implrf)rGrHrIrJrqrKrhrrYrir[r+rrnr*rorprqrnryrtrcr,r;rrDrr9r9rr:rk s !rkc@sveZdZUdZeed<ejZe e efed<e dZ e ed<ddd Zd eddfd d ZddededdfddZdS)FromzD A ``from x`` stanza in a :class:`Yield` or :class:`Raise`. itemwhitespace_before_fromr^whitespace_after_fromr3NcCs6t|jtr|jjr|jtjstddSdSdS)Nz2Must have at least one space after 'from' keyword.) rrzr*rrxrtrnrprrbr9r9r:rc3 s   zFrom._validater2cCr()Nryrzrx)ryrzrx)rwrryrrzrxr7r9r9r:r;=   z From._visit_and_replace_childrenr0r= default_spacecCsx|j}t|tr||n|||||d|j||j|WddS1s5wYdS)Nfrom)ryrr*rBrArerzrx)r8r=r|ryr9r9r:rDH s      "zFrom._codegen_implrf)r0)rGrHrIrJrqrKrrryrr*r+rrzrcr,r;rrrDr9r9r9r:rw! s    rwcseZdZUdZdZeeeefe d<dZ e e e d<dZ e ee d<ejZeeefe d<dfd d Zd eddfd d ZdeddfddZZS)Yielda A yield expression similar to ``yield x`` or ``yield from fun()``. To learn more about the ways that yield can be used in generators, refer to `Python's language reference `__. Nrar9rhriwhitespace_after_yieldr3csjtt||j}t|tr-|jr/|j}t|trt dt|t r1| t j s3t ddSdSdSdS)Nz3Must have at least one space after 'yield' keyword.)rr~rcrrr*rrarwrrqrtrnrp)r8rrarr9r:rcm s*   zYield._validater2c Cs@tt|d|j|t|d|j|t|d|j|t|d|j|dS)Nrhrrari)rhrrari)r~rrhrrrrarir7r9r9r:r; riz!Yield._visit_and_replace_childrenr=cCs||O|d|j}t|tr||n |jdur#|d|j}t|tr3|j|ddn|durD||WddSWddSWddS1sWwYdS)Nyieldr^r0)r|)rlrArrr*rBrarw)r8r=rrar9r9r:rD s"          "zYield._codegen_implrf)rGrHrIrJrarrrqrwrKrhrrYrir[rrrr*rcr,r;rrDrr9r9rr:r~U s   r~c @sxeZdZUdZdZeed<ejZ e e efed<  dde de de d d fd d Ze  dde de de d d fd dZd S)_BaseElementImplzO An internal base class for :class:`Element` and :class:`DictElement`. r9rarFr=rdefault_comma_whitespacer3NcCsP|j}|tjur|r|r|ddS|ddSt|tr&||dSdS)zP Called by `_codegen_impl` in subclasses to generate the comma. r,N)rrrrArr#rB)r8r=rrrr9r9r:_codegen_comma s  z_BaseElementImpl._codegen_commacCsdSrkr9r8r=rrr9r9r:rD rz_BaseElementImpl._codegen_implFF)rGrHrIrJrmrqrKrrrrr#rryrrrDr9r9r9r:r s8  rc@rz) BaseElementzo An element of a literal list, tuple, or set. For elements of a literal dict, see BaseDictElement. r9Nr|r9r9r9r:r rrc@rz)BaseDictElementzc An element of a literal dict. For elements of a list, tuple, or set, see BaseElement. r9Nr|r9r9r9r:r rrc @sbeZdZUdZeed<ejZe e efed<de ddfddZ  dd e d ed edd fd dZd S)Elementz A simple value in a literal :class:`List`, :class:`Tuple`, or :class:`Set`. These a literal collection may also contain a :class:`StarredElement`. If you're using a literal :class:`Dict`, see :class:`DictElement` instead. rarr2r3cCr)Nrar)rar)rrrarrr7r9r9r:r; rz#Element._visit_and_replace_childrenFr=rrNcCsH|||j|Wdn1swY||||dSrk)rerarBrrr9r9r:rD s zElement._codegen_implr)rGrHrIrJrqrKrrrrr#r,r;rryrDr9r9r9r:r s  rc @seZdZUdZeed<eed<ejZe e efed<e dZ eed<e dZeed<d ed dfd d Z ddededed dfddZdS) DictElementa A simple ``key: value`` pair that represents a single entry in a literal :class:`Dict`. :class:`Dict` nodes may also contain a :class:`StarredDictElement`. If you're using a literal :class:`List`, :class:`Tuple`, or :class:`Set`, see :class:`Element` instead. keyrarr0whitespace_before_colonr^whitespace_after_colonr2r3c CsNtt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|dS)Nrrrrar)rrrrar)rrrrrrarrr7r9r9r:r; s  z'DictElement._visit_and_replace_childrenFr=rrNcCsv||%|j||j||d|j||j|Wdn1s-wY||||dSr)rerrBrrArrarrr9r9r:rD s     zDictElement._codegen_implr)rGrHrIrJrqrKrrrrr#r+rrr*rr,r;rryrDr9r9r9r:r s&  rc @seZdZUdZeed<ejZe e efed<dZ e e ed<dZe eed<edZeed<d ed dfd d Z ddededed dfddZdS)StarredElementa3 A starred ``*value`` element that expands to represent multiple values in a literal :class:`List`, :class:`Tuple`, or :class:`Set`. If you're using a literal :class:`Dict`, see :class:`StarredDictElement` instead. If this node owns parenthesis, those parenthesis wrap the leading asterisk, but not the trailing comma. For example:: StarredElement( cst.Name("el"), comma=cst.Comma(), lpar=[cst.LeftParen()], rpar=[cst.RightParen()], ) will generate:: (*el), rarr9rhrir0whitespace_before_valuer2r3c CsNtt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|dS)Nrhrrarir)rhrrarir) rrrhrrrarirrr7r9r9r:r;L s z*StarredElement._visit_and_replace_childrenFr=rrNcCs^|||d|j||j|Wdn1s!wY||||dSr+)rlrArrBrarrr9r9r:rDW   zStarredElement._codegen_implr)rGrHrIrJrqrKrrrrr#rhrrYrir[r+rrr*r,r;rryrDr9r9r9r:r' s& rc @steZdZUdZeed<ejZe e efed<e dZ eed<deddfdd Z dd ed ed eddfddZdS)StarredDictElementa A starred ``**value`` element that expands to represent multiple values in a literal :class:`Dict`. If you're using a literal :class:`List`, :class:`Tuple`, or :class:`Set`, see :class:`StarredElement` instead. Unlike :class:`StarredElement`, this node does not own left or right parenthesis, but the ``value`` field may still contain parenthesis. This is due to some asymmetry in Python's grammar. rarr0rr2r3cCs2tt|d|j|t|d|j|t|d|j|dS)Nrrar)rrar)rrrrarrr7r9r9r:r;{ s z.StarredDictElement._visit_and_replace_childrenFr=rrNcCs^|||d|j||j|Wdn1s!wY||||dS)Nr3)rerArrBrarrr9r9r:rD rz StarredDictElement._codegen_implr)rGrHrIrJrqrKrrrrr#r+rrr*r,r;rryrDr9r9r9r:rd s"   rcseZdZUdZeeed<edddZee ed<edddZ ee ed<d e d e ffd d Zdfdd Zded dfddZded d fddZZS)Tuplea) An immutable literal tuple. Tuples are often (but not always) parenthesized. :: Tuple([ Element(Integer("1")), Element(Integer("2")), StarredElement(Name("others")), ]) generates the following code:: (1, 2, *others) elementscCtfSrkrYr9r9r9r: zTuple.default_factoryrhcCrrkr[r9r9r9r:r rrirrr3csztt||r dS|j}|tjkr.|d}t|jtp-t|t o't |j dkp-|j |S|d}t|t p<|j |S)NTrr) rrrtrrnrorrr#rr`rira)r8rrr last_element first_elementrr9r:rt s"       z%Tuple._safe_to_use_with_word_operatorNcs:tt|t|jdkrt|jdkrtddSdS)Nrz3A zero-length tuple must be wrapped in parentheses.)rrrcr`rrhrrbrr9r:rc szTuple._validater2cC2tt|d|j|t|d|j|t|d|j|dS)Nrhrri)rhrri)rrrhrrir7r9r9r:r; s z!Tuple._visit_and_replace_childrenr=cCs||<|j}t|dkr|dj|dddnt|D]\}}|j||t|dkddqWddSWddS1sDwYdS)Nr_rTFrr)rlrr`rBr!r8r=ridxelr9r9r:rD s  "zTuple._codegen_implrf)rGrHrIrJrrrKrrhrYrir[rnryrtrcr,r;rrDrr9r9rr:r s   rc@eZdZUdZdZeZeed<e Z e ed<dZ e e ed<dZe eed<dedefd d Zed eded fd dZdS)BaseListzv A base class for :class:`List` and :class:`ListComp`, which both result in a list object when evaluated. r9rrrhrirrr3cCrrr9rsr9r9r:rt rz(BaseList._safe_to_use_with_word_operatorr=rjcc$|j|dV|j|dSrk)rrBrrCr9r9r: _bracketize  zBaseList._bracketizeN)rGrHrIrJrmr/rrrKrMrrhrrYrir[rnryrtrrrrr9r9r9r:r s rc@eZdZUdZeeed<eZ eed<e Z e ed<dZ ee ed<dZeeed<ded dfd d Zd ed d fddZd S)Lista; A mutable literal list. :: List([ Element(Integer("1")), Element(Integer("2")), StarredElement(Name("others")), ]) generates the following code:: [1, 2, *others] List comprehensions are represented with a :class:`ListComp` node. rrrr9rhrir2r3c CNtt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|dS)Nrhrrrri)rhrrrri)rrrhrrrrrir7r9r9r:r;" rz List._visit_and_replace_childrenr=Nc C||@||"|j}t|D]\}}|j||t|dkddqWdn1s0wYWddSWddS1sHwYdSNr_Tr)rlrrr!rBr`rr9r9r:rD+ PzList._codegen_impl)rGrHrIrJrrrKr/rrrMrrhrYrir[r,r;rrDr9r9r9r:r s   rc@r)_BaseSetOrDicta An abstract base class for :class:`BaseSet` and :class:`BaseDict`. Literal sets and dicts are syntactically similar (hence this shared base class), but are semantically different. This base class is an implementation detail and shouldn't be exported. r9lbracerbracerhrirrr3cCrrr9rsr9r9r:rtI rz._BaseSetOrDict._safe_to_use_with_word_operatorr=rjccrrk)rrBrrCr9r9r: _braceizeM rz_BaseSetOrDict._braceizeN)rGrHrIrJrmrUrrrKrWrrhrrYrir[rnryrtrrrrr9r9r9r:r6 s rc@rz)BaseSetz} An abstract base class for :class:`Set` and :class:`SetComp`, which both result in a set object when evaluated. r9Nr|r9r9r9r:rT rrcseZdZUdZeeed<eZ eed<e Z e ed<dZ ee ed<dZeeed<dfd d Zd eddfd dZdedd fddZZS)Seta7 A mutable literal set. :: Set([ Element(Integer("1")), Element(Integer("2")), StarredElement(Name("others")), ]) generates the following code:: {1, 2, *others} Set comprehensions are represented with a :class:`SetComp` node. rrrr9rhrir3Ncs(tt|t|jdkrtddS)NrzzA literal set must have at least one element. A zero-element set would be syntatically ambiguous with an empty dict, `{}`.)rrrcr`rrrbrr9r:rc~ s z Set._validater2c CrNrhrrrri)rhrrrri)rrrhrrrrrir7r9r9r:r; rzSet._visit_and_replace_childrenr=c Crrrlrrr!rBr`rr9r9r:rD rzSet._codegen_implrf)rGrHrIrJrrrKrUrrrWrrhrYrir[rcr,r;rrDrr9r9rr:r] s    rc@rz)BaseDictz An abstract base class for :class:`Dict` and :class:`DictComp`, which both result in a dict object when evaluated. r9Nr|r9r9r9r:r rrc@r)Dicta A literal dictionary. Key-value pairs are stored in ``elements`` using :class:`DictElement` nodes. It's possible to expand one dictionary into another, as in ``{k: v, **expanded}``. Expanded elements are stored as :class:`StarredDictElement` nodes. :: Dict([ DictElement(Name("k1"), Name("v1")), DictElement(Name("k2"), Name("v2")), StarredDictElement(Name("expanded")), ]) generates the following code:: {k1: v1, k2: v2, **expanded} rrrr9rhrir2r3c Crr)rrrhrrrrrir7r9r9r:r; rz Dict._visit_and_replace_childrenr=Nc Crrrrr9r9r:rD rzDict._codegen_impl)rGrHrIrJrrrKrUrrrWrrhrYrir[r,r;rrDr9r9r9r:r s   rc@seZdZUdZeed<eed<dZeded<dZ e ded<dZ e e ed <e d Zeed <e d Zeed <e d Zeed <e d Zeed<dddZdeddfddZdeddfddZdS)CompFora One ``for`` clause in a :class:`BaseComp`, or a nested hierarchy of ``for`` clauses. Nested loops in comprehensions are difficult to get right, but they can be thought of as a flat representation of nested clauses. ``elt for a in b for c in d if e`` can be thought of as:: for a in b: for c in d: if e: yield elt And that would form the following CST:: ListComp( elt=Name("elt"), for_in=CompFor( target=Name("a"), iter=Name("b"), ifs=[], inner_comp_for=CompFor( target=Name("c"), iter=Name("d"), ifs=[ CompIf( test=Name("e"), ), ], ), ), ) Normal ``for`` statements are provided by :class:`For`. riterr9CompIfifsN inner_for_in asynchronousr^rNwhitespace_after_forwhitespace_before_inwhitespace_after_inr3cCs|jjr|jtjstd|jjr|jtjstd|j jr-|j tjs-td|j }|j D]}|j jrC|tjsCtd|j }q3|j}|durg|j jri|tjsk|jr]dnd}td|ddSdSdS) 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.rrrdfor%Must have at least one space before ' ' keyword.)rrrrtrnrprrrorrrrNrlrr)r8 prev_expr if_clauserrWr9r9r:rc' sX      zCompFor._validater2cCstt|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) NrNrrrrrrrr) rNrrrrrrrr) rrrNrrrrrrrrrrr7r9r9r:r;X s.      z#CompFor._visit_and_replace_childrenr=cCs|j||j}|dur|||d|j||j||j||d|j||j||j }|D]}||q?|j }|durU||dSdS)Nrin) rNrBrrArrrrrrr)r8r=rrrrr9r9r:rDq s$          zCompFor._codegen_implrf)rGrHrIrJr{rKrqrrrrrr]r+rrNr*rrrrcr,r;rrDr9r9r9r:r s )  1rc@sleZdZUdZeed<edZe ed<edZ e ed<ddd Z d e ddfd d Z d eddfddZdS)rz A conditional clause in a :class:`CompFor`, used as part of a generator or comprehension expression. If the ``test`` fails, the current element in the :class:`CompFor` will be skipped. rlr^rNwhitespace_before_testr3NcCs&|jjr|jtjstddSdS)Nrs)rrrlrtrnrprrbr9r9r:rc s  zCompIf._validater2cCr)NrNrrl)rNrrl)rrrNrrlr7r9r9r:r; r{z"CompIf._visit_and_replace_childrenr=cCs2|j||d|j||j|dS)Nru)rNrBrArrlrCr9r9r:rD s   zCompIf._codegen_implrf)rGrHrIrJrqrKr+rrNr*rrcr,r;rrDr9r9r9r:r s   rc@seZdZUdZdZeed<dS)BaseCompz A base class for all comprehension and generator expressions, including :class:`GeneratorExp`, :class:`ListComp`, :class:`SetComp`, and :class:`DictComp`. r9for_inN)rGrHrIrJrmrrKr9r9r9r:r s  rcs8eZdZUdZdZeed<eed<d fdd ZZ S) BaseSimpleCompz The base class for :class:`ListComp`, :class:`SetComp`, and :class:`GeneratorExp`. :class:`DictComp` is not a :class:`BaseSimpleComp`, because it uses ``key`` and ``value``. r9eltrr3NcPtt||j}|jjr$|jtj s&|j rdnd}t d|ddSdSNrdrrr) rrrcrrNrrrtrnrorrr8rrWrr9r:rc   zBaseSimpleComp._validaterf) rGrHrIrJrmrqrKrrcrr9r9rr:r s rc@seZdZUdZeed<eed<edddZe e ed<edddZ e e ed <d e d efd d Zded dfddZded dfddZdS) GeneratorExpz A generator expression. ``elt`` represents the value yielded for each item in :attr:`CompFor.iter`. All ``for ... in ...`` and ``if ...`` clauses are stored as a recursive :class:`CompFor` data structure inside ``for_in``. rrcCrrkrr9r9r9r:r rzGeneratorExp.rrhcCrrkrr9r9r9r:r rrirrr3cCrrr9rsr9r9r:rt sz,GeneratorExp._safe_to_use_with_word_operatorr2c Cr)Nrhrrri)rhrrri)rrrhrrrrir7r9r9r:r;rz(GeneratorExp._visit_and_replace_childrenr=NcCrrk)rlrrBrrCr9r9r:rD rzGeneratorExp._codegen_impl)rGrHrIrJrqrKrrrhrrYrir[rnryrtr,r;rrDr9r9r9r:r s   rc@eZdZUdZeed<eed<eZ eed<e Z e ed<dZ e eed<dZe eed<d ed dfd d Zd ed dfddZdS)ListCompz A list comprehension. ``elt`` represents the value stored for each item in :attr:`CompFor.iter`. All ``for ... in ...`` and ``if ...`` clauses are stored as a recursive :class:`CompFor` data structure inside ``for_in``. rrrrr9rhrir2r3c C\tt|d|j|t|d|j|t|d|j|t|d|j|t|d|j|t|d|j|dS)Nrhrrrrri)rhrrrrri) rrrhrrrrrrir7r9r9r:r;*z$ListComp._visit_and_replace_childrenr=Nc C||2|||j||j|Wdn1s"wYWddSWddS1s:wYdSrk)rlrrrBrrCr9r9r:rD4 PzListComp._codegen_impl)rGrHrIrJrqrKrr/rrrMrrhrrYrir[r,r;rrDr9r9r9r:r   rc@r)SetCompz A set comprehension. ``elt`` represents the value stored for each item in :attr:`CompFor.iter`. All ``for ... in ...`` and ``if ...`` clauses are stored as a recursive :class:`CompFor` data structure inside ``for_in``. rrrrr9rhrir2r3c Cr)Nrhrrrrri)rhrrrrri) rrrhrrrrrrir7r9r9r:r;Trz#SetComp._visit_and_replace_childrenr=Nc Crrk)rlrrrBrrCr9r9r:rD^rzSetComp._codegen_impl)rGrHrIrJrqrKrrUrrrWrrhrrYrir[r,r;rrDr9r9r9r:r:rrcseZdZUdZeed<eed<eed<eZ eed<e Z e ed<dZ e eed<dZe eed <ed Zeed <ed Zeed <dfdd ZdeddfddZdeddfddZZS)DictCompz A dictionary comprehension. ``key`` and ``value`` represent the dictionary entry evaluated for each item. All ``for ... in ...`` and ``if ...`` clauses are stored as a recursive :class:`CompFor` data structure inside ``for_in``. rrarrrr9rhrir0rr^rr3Ncrr) rrrcrrNrrartrnrorrrrr9r:rcrzDictComp._validater2cCrt) Nrhrrrrrarrri) rhrrrrrarrri) rrrhrrrrrrarrrir7r9r9r:r;s  z$DictComp._visit_and_replace_childrenr=c Cs||I||+|j||j||d|j||j||j|Wdn1s9wYWddSWddS1sQwYdSr) rlrrrBrrArrarrCr9r9r:rDs     PzDictComp._codegen_implrf)rGrHrIrJrqrKrrUrrrWrrhrrYrir[r+rr*rrcr,r;rrDrr9r9rr:rds   rc@seZdZUdZeed<eed<dZeeed<dZ ee ed<e dZ eed<e dZeed <d ed dfd d Zded efddZded dfddZdS) NamedExpra= An expression that is also an assignment, such as ``x := y + z``. Affectionately known as the walrus operator, this expression allows you to make an assignment inside an expression. This greatly simplifies loops:: while line := read_some_line_or_none(): do_thing_with_line(line) rrar9rhrir^whitespace_before_walruswhitespace_after_walrusr2r3c Cr)Nrhrrrrari)rhrrrrari) rrrhrrrrrarir7r9r9r:r;rez%NamedExpr._visit_and_replace_childrenrrcCs>|tjkrt|jdkp|j|St|jdkp|j|SrR)rnror`rirartrhrrsr9r9r:rts z)NamedExpr._safe_to_use_with_word_operatorr=NcCsj||&|j||j||d|j||j|WddS1s.wYdS)Nz:=)rlrrBrrArrarCr9r9r:rDs     "zNamedExpr._codegen_impl)rGrHrIrJrqrKrhrrYrir[r+rrr*rr,r;rnryrtrrDr9r9r9r:rs    r)rabcrrastr contextlibr dataclassesrrenumrr tokenizer rr rr rtypingr rrrrrlibcst._add_slotsrlibcst._maybe_sentinelrlibcst._nodes.baserrrlibcst._nodes.internalrrrrrlibcst._nodes.oprrrr r!r"r#r$r%r&r'r(r)libcst._nodes.whitespacer*r+libcst._visitorsr,r/rMrUrWrYr[r]rgrnrqr{r~rrrrrrrrrrrrrrrrrrrrrrrr rrr$r*r,r.r7rNrVrYrargrkrwr~rrrrrrrrrrrrrrrrrrrrrrrrr9r9r9r:s     <   $#$# & _u_%W<3F7 #4 ?H%aMoOgF/i2F%  1;+T3 < //* !1((I