B Khhbd@snUdZddlZddlmZmZmZmZmZmZm Z m Z ej dkrNddlm Z n ddl m Z ej dkrrddlmZn ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZmZeeejZ e e!d<e dZ"e eefZ#e$Z%e$Z&ej'ej(ej)hZ*e e!d<e j+e j,e j-e j.e j/e j0e j1e j2e j3e j4h Z5e e!d<dZ6e e!d<dej7e6<ddhZ8e e!d<ej9ej:ej;ejhZ?e e!d<ej@ejAejBejCejDejEejFejGejHejIejJejKejLejMhZNe e!d<ejGejMhZOe e!d<eOejHhBZPe e!d<e jQe jRe jSe jTe jUhZVe e!d<e jWe jXe jYe jZe j[e j\e j]hZ^e e!d<e j_e j`e jae jbe jce jde jee jfe jge jhe jie jje jSe jke jlhZme e!d<e jne johZpe e!d<dd d!d"d#d$d%d&d'd(d)d*d+d,hZqe e!d-<e jre j[e jshZte e!d.<ejuejvejwejxejyejziZ{e e!d/<e|e{}Z~e e!d0<e|e{Ze e!d1<e~eBZe e!d2<eeje6hBZe e!d3<d4Zed5d6Gd7d8d8ee"Zeeed9d:d;Zee#eed<d=d>Zee#eee&ed?d@dAZee#ee&d<dBdCZee#ee#dDdEdFZe#e#ddGdHdIZee#dJdKdLZe#eed<dMdNZe#ed<dOdPZeedJdQdRZe#ed<dSdTZe#ed<dUdVZe#ed<dWdXZejuejvffeeeeee$e$fedYdZd[Ze#ed<d\d]Zde#eed_d`daZe#ed<dbdcZe#ed<dddeZeee&edfdgdhZeedJdidjZeed<dkdlZe#ed<dmdnZe#ed<dodpZeedJdqdrZeedJdsdtZeedJdudvZeedJdwdxZeedJdydzZeedJd{d|Zdeeed~ddZd5dee#eddddZe#ee#d<ddZeddJddZeeedddZeeedddZeeedddZeeedddZeeedddZeedJddZdS)z> blib2to3 Node/Leaf transformation-related utility functions. N)GenericIteratorListOptionalSetTupleTypeVarUnion))Final)r ) TypeGuard) mypyc_attr) CACHE_DIR)has_triple_quotes)pygram)token)NLLeafNode type_reprsymsT WHITESPACE STATEMENTSTANDALONE_COMMENTandorLOGIC_OPERATORS COMPARATORSMATH_OPERATORSSTARSVARARGS_SPECIALSVARARGS_PARENTSUNPACKING_PARENTSTEST_DESCENDANTS TYPED_NAMES=z+=z-=z*=z@=z/=z%=z&=z|=z^=z<<=z>>=z**=z//= ASSIGNMENTSIMPLICIT_TUPLEBRACKETOPENING_BRACKETSCLOSING_BRACKETSBRACKETSALWAYS_NO_SPACE7T)Zallow_interpreted_subclassesc@s8eZdZdZeeedddZeeedddZdS)VisitorzBBasic lib2to3 visitor that yields things of type `T` on `visit()`.)nodereturnccs`|jdkrtj|j}ntt|j}t|d|d}|rL||EdHn||EdHdS)azMain method to visit `node` and its children. It tries to find a `visit_*()` method for the given `node.type`, like `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects. If no dedicated `visit_*()` method is found, chooses `visit_default()` instead. Then yields objects of type `T` from the selected visitor. Zvisit_N)typertok_namestrrgetattr visit_default)selfr3nameZvisitfr=./tmp/pip-install-vv81h98y/black/black/nodes.pyvisits z Visitor.visitccs.t|tr*x|jD]}||EdHqWdS)zCDefault `visit_*()` implementation. Recurses to children of `node`.N) isinstancerchildrenr?)r;r3childr=r=r>r:s  zVisitor.visit_defaultN) __name__ __module__ __qualname____doc__LNrrr?r:r=r=r=r>r2sr2)leafcomplex_subscriptr4c CsPd}d}d}|j}|j}|j}|tkr*|S|tjkr8|S|dk sNtd||tjkrr|jtj tj tj hkrr|S|j }|st |} | r| jtkr|S|tjkr| jtjkr|S| jtjkr|s|S|S| jtjkr| jr| jjtjtjtjtjhkr|S| jjtjkr| jSn| jtjkrNt| tjkrNt| jtj krN|S| jtkrrt| ttBdr|Sn| jtjkr| jr| jjtj tj hkr|r|S|SnR| jr| jjtjkr| jtkr|S| jtj kr|jr|jjtj!kr|Sn|jtkr|S|jtjtjhkrB|r:|jtjkrL|Sn |jtjkrl|rL|jtjkrL|Sn|jtjkr|s|S|tjkr|jt"kr|Sn&|jtjkr|jS|jtjkrL|Sn|jt"kr|sLt |} | r| jtjkrL|SnJ|jtj#krf|tj$ks(|tj%kr,|S|sP|tj&ksJ|tj'krb|Sn|jtjkrL|Sn|jtjkr|tjkr|S|st |} | r| jtj$kr|Sn|jtjhtBkrL|Sn|jtj!kr|S|jtj(kr$|r|St |} | r| jtj ks| jtj&krL|Sn(|jtj)kr^|tj$krB|S|rL|jtj$krL|Sn|jtj tj hkr|s|jdk std|jjtj kr|S|S|sL|Sn|jtj*kr|rL|tj&krL|Snr|jtj+kr|rL|jtj,krL|SnH|jtjtjhkr|st |} | r8| jtkr<|S| j} | dk sPt| jtjkrv| jtj tj hkrv|S| jtjkr| jtjkr|Sn|tj-tj.tj/hkrL|Sn|jtj0kr|tj&kr|r|jtj&kr|Sn2|tj-krL|dkr|S|rL|jtj&krL|Sn0|jtj kr.|S|jtj1krL|tjkrL|S|S) zReturn whitespace prefix if needed for the given `leaf`. `complex_subscript` signals whether the given leaf is part of a subscription which has non-trivial arguments, like arithmetic expressions or function calls.  z Nz/INTERNAL ERROR: hand-made leaf without parent: )withinzsubscripts are always parentedimport)2r6parentvaluer0rCOMMENTAssertionErrorCOLONrZ subscriptZ subscriptlistZsliceop prev_siblingpreceding_leafr-COMMAEQUALarglistargument parameters varargslist typedargslistprefixSTAR parent_type star_exprr$ is_varargr%r&Zfactorr"ATZ decoratorr(trailerLPARRPARDOTLSQBZ dotted_nameclassdefatom dictsetmaker DOUBLESTARNAMENUMBERSTRING import_from except_clause) rHrINOSPACEZ DOUBLESPACEtpvprevZprevpZ prevp_parentr=r=r> whitespaces,       &     "      rv)r3r4cCsRxL|rL|j}|rDt|tr|Syt|dStk rBdSX|j}qWdS)z3Return the first leaf that precedes `node`, if any.N)rSr@rlistleaves IndexErrorrN)r3resr=r=r>rTs  rT)r3tokensr4cCsJ|sdS|ddkr|dkS|s$dS|j|dkr6dSt|j|ddS)a;Return if the `node` and its previous siblings match types against the provided list of tokens; the provided `node`has its type matched against the last element in the list. `None` can be used as the first element to declare that the start of the list is anchored at the start of its parent's children.TrwNF)r6prev_siblings_arerS)r3r|r=r=r>r}s r}cCs|dks|jdkrdS|jjS)z| Returns: @node.parent.type, if @node is not None and has a parent. OR None, otherwise. N)rNr6)r3r=r=r>r^sr^)ancestor descendantr4cCs"|}x|r|j|kr|j}qW|S)z:Return the child of `ancestor` that contains `descendant`.)rN)r~rr3r=r=r> child_towardss r) old_child new_childr4cCs.|j}|sdS|}|dk r*|||dS)z Side Effects: * If @old_child.parent is set, replace @old_child with @new_child in @old_child's underlying Node structure. OR * Otherwise, this function does nothing. N)rNremove insert_child)rrrNZ child_idxr=r=r> replace_childs r)rHr4cCsd|j}|}xT|r^|j}|dkr P|jdj|kr2P|jtjkr@P|jdk rX|jjtkrXP|}q W|S)zReturn `leaf` or one of its ancestors that is the topmost container of it. By "container" we mean a node where `leaf` is the very first child. Nr)r\rNrAr6rZ file_inputrSr/)rHZ same_prefix containerrNr=r=r> container_ofs rcCs*t|tr|S|jr"t|jdSdSdS)z(Returns the first leaf of the node tree.rN)r@rrA first_leaf_of)r3r=r=r>rs  rcCs|jtjtjtjtjhkS)z?Whether node is an arithmetic or a binary arithmetic expression)r6r arith_expr shift_exprxor_exprand_expr)r3r=r=r> is_arith_likes rcCs>t|jdtjtjtjgrdSt|jtjtjtjgr:dSdS)NTF) r}rNrNEWLINEINDENTr simple_stmtrYrR)rHr=r=r> is_docstring s rcCs>|jtjkois_empty_tuples rcCsv|jtjkrLt|}|dks(|jtjkr,dSt|jdkoJ|jdjtjkS|jt kott|jdkot|jdjtjkS)zMReturn True if `node` holds a tuple with one element, with or without parens.NFrr) r6rrhunwrap_singleton_parenthesis testlist_gexprrArrUr+)r3gexpr=r=r> is_one_tuple&s   rcCsD|jtjkrdSt|}|dks,|jtjkr0dStdd|jDS)zDReturn True if `node` holds a tuple that contains a walrus operator.FNcss|]}|jtjkVqdS)N)r6rnamedexpr_test).0rBr=r=r> >sz-is_tuple_containing_walrus..)r6rrhrranyrA)r3rr=r=r>is_tuple_containing_walrus6s  r)openingclosingrybracketsr4c Cs|j|jf|krdS|jd}x&t|D]\}}||kr(Pq(Wtdd}|d7}xd||dD]T}||krnP|j}||kr`|jtjkr`|d7}|jr`|jjtjtj hkr`|d7}Pq`W|dkS)zIReturn True if content between `opening` and `closing` is a one-sequence.Frz#Opening paren not found in `leaves`rNr) r6 bracket_depth enumerate LookupErrorrrUrNrrWr[) rrryrdepthZ_opening_indexrHZcommasrr=r=r>is_one_sequence_betweenAs*   rcCst|}|dk o|jtjkS)z7Return True iff `node` is of the shape ( test := test )N)rr6rr)r3innerr=r=r>is_walrus_assignmentfsrF)r3lastr4cCs|jtjkot|jdkr>|jdjtjkr>|jdjtjkp|rtt|jdkrt|jdjtjkrt|jdjtj kp|ot|jdko|jdjtjko|jdjtj kS)z?Return True iff `node` is a trailer valid in a simple decoratorrrrr ) r6rrbrrArrerkrcrd)r3rr=r=r>is_simple_decorator_trailerls rcCsp|jtjkrdS|jtjkrl|jrl|jdjtjkojttt|jddojt |jdkpjt|jdddSdS)a\Return True iff `node` could be a 'dotted name' decorator This function takes the node of the 'namedexpr_test' of the new decorator grammar and test if it would be valid under the old decorator grammar. The old grammar was: decorator: @ dotted_name [arguments] NEWLINE The new grammar is : decorator: @ namedexpr_test NEWLINE Trrrwr)rF) r6rrkrpowerrAallmaprr)r3r=r=r>is_simple_decorator_expressions  rcCsx|jtjkrdSt|r&|jdkr&dS|jtjkr6dSt|jdkrHdS|j\}}}|jtj krt|jtj krtt |SdS)zAReturn True if `node` holds a `yield` or `yield from` expression.TyieldFr ) r6rZ yield_expr is_name_tokenrOrhrrArrcrdis_yield)r3lparexprrparr=r=r>rs   r)rHrLr4cCs@|jtks|jsdS|j}|jtjkr6|js0dS|j}|j|kS)aFReturn True if `leaf` is a star or double star in a vararg or kwarg. If `within` includes VARARGS_PARENTS, this applies to function signatures. If `within` includes UNPACKING_PARENTS, it applies to right hand-side extended iterable unpacking (PEP 3132) and additional unpacking generalizations (PEP 448). F)r6r$rNrr_)rHrLrsr=r=r>r`s r`cCst|jod|jkS)zKReturn True if `leaf` is a multiline string that actually spans many lines. )rrO)rHr=r=r>is_multiline_stringsrcCsVt|jdksD|jdjtjksD|jdjtjksD|jdjtjkrHdSt|jdS)z2Return True if `node` is a suite with a stub body.rrr Fr)rrAr6rrrDEDENT is_stub_body)r3r=r=r> is_stub_suites rcCsdt|tr|jtjkrdSt|jdkr,dS|jd}|jtjkobt|jdkobtdd|jDS)zCReturn True if `node` is a simple statement containing an ellipsis.Frrr css|]}|ttjdkVqdS).N)rrre)rrHr=r=r>rszis_stub_body..) r@rr6rrrrArhr)r3rBr=r=r>rs  rcCspt|ts|jtjkrdS|jd|jd}}t|ton|jtjkon|jdkont|ton|jtj kon|jdkS)zGiven a `LN`, determines whether it's an atom `node` with invisible parens. Useful in dedupe-ing and normalizing parens. FrrwrJ) r@rr6rrhrArrcrOrd)r3firstrr=r=r>is_atom_with_invisible_parenss     rcCst|pt|S)N) is_empty_lpar is_empty_rpar)rHr=r=r> is_empty_parsrcCs|jtjko|jdkS)NrJ)r6rrcrO)rHr=r=r>rsrcCs|jtjko|jdkS)NrJ)r6rrdrO)rHr=r=r>rsrcCsP|j}|j}|j}t|tjkoL|dkr6|r6|jtjkpL|dkoL|oL|jtjkS)z9Return True if the given leaf starts an import statement.rMfrom) rNr6rOboolrrkr import_namern)rHrsrrrtr=r=r> is_import s rcCsRt|jtjko*|jdko*|jo*|jjtjkpPt|jtjkoN|j oN|j jtjkS)zDReturn True if the given leaf starts a with or async with statement.with) rr6rrkrOrNr with_stmtASYNCZ next_sibling)rHr=r=r>is_with_or_async_with_stmts   rcCs*t|jtjko&|jo&|jjtjtjhkS)zReturn True if the given leaf starts an async def/for/with statement. Note that `async def` can be either an `async_stmt` or `async_funcdef`, the latter is used when it has decorators. )rr6rrrNrZ async_stmtZ async_funcdef)rHr=r=r>is_async_stmt_or_funcdef&s rrJ)rHsuffixr4cCs(|j}|j}|tjthko&|d|S)zdReturn True if the given leaf is a special comment. Only returns true for type comments for now.z# type:)r6rOrrPr startswith)rHrrrrtr=r=r>is_type_comment3sr)visible)rNrBrr4cCshttj|rdnd}ttj|r"dnd}|j}d|_|p>d}ttj|||g}||_| ||dS)zWrap `child` in parentheses. This replaces `child` with an atom holding the parentheses and the old child. That requires moving the prefix. If `visible` is False, the leaves will be valueless (and thus invisible). (rJ)rN) rrrcrdr\rrrrhr)rNrBrrrr\indexrr=r=r>wrap_in_parentheses;s rcCs>t|jdkrdS|j\}}}|jtjkr6|jtjks:dS|S)zqReturns `wrapped` if `node` is of the shape ( wrapped ). Parenthesis can be optional. Returns None otherwiser N)rrAr6rrcrd)r3rwrappedrr=r=r>rMs  rcCs*|jtjkrd|_n|jtjkr&d|_dS)zMake sure parentheses are visible. They could be invisible as part of some statements (see :func:`normalize_invisible_parens` and :func:`visit_import_from`). rrN)r6rrcrOrd)rHr=r=r>ensure_visible[s  r)nlr4cCs |jtjkS)N)r6rrk)rr=r=r>rgsrcCs |jtjkS)N)r6rrc)rr=r=r> is_lpar_tokenksrcCs |jtjkS)N)r6rrd)rr=r=r> is_rpar_tokenosrcCs |jtjkS)N)r6rrm)rr=r=r>is_string_tokenssrcCs |jtjkS)N)r6rrl)rr=r=r>is_number_tokenwsrcCsN|j}xB|dk rH|jr(|jjtjkr(dS|jr@|jjtjkr@dS|j}qWdS)z6Returns whether this leaf is part of type annotations.NTF)rNrSr6rRARROWrtname)rHr~r=r=r>is_part_of_annotation{s  r)F)rJ)rFsystypingrrrrrrrr version_infor Ztyping_extensionsrZmypy_extensionsrZ black.cacherZ black.stringsrZblib2to3rZblib2to3.pgen2rZblib2to3.pytreerrrrZ initializeZpython_symbolsr__annotations__rrGintZLeafIDZNodeTyperrrrZif_stmtZ while_stmtZfor_stmtZtry_stmtrorZfuncdefrgZ match_stmtZ case_blockrrr7r LESSGREATEREQEQUALNOTEQUAL LESSEQUAL GREATEREQUALr!VBAR CIRCUMFLEXAMPER LEFTSHIFT RIGHTSHIFTPLUSMINUSr]SLASH DOUBLESLASHPERCENTraTILDErjr"r#r$rWrXrbr[rZr%rhriZ listmakerrZtestlist_star_exprZ subject_exprpatternr&testZlambdefZor_testZand_testZnot_testZ comparisonr_rrrrrZtermrr'rZ tname_starr(r*ZtestlistZexprlistr+rcrdrfRSQBLBRACERBRACEr,setkeysr-valuesr.r/rUr0rr2rr8rvrTr}r^rrrrrrrrrrrrrrr`rrrrrrrrrrrrrrrrrrrrr=r=r=r>s,(              "g