]jSrSSKrSSKJr SSKJrJr SSKJrJ r J r J r J r J r SSKJr SSKJr \"/SQ5r\"S S /5\-r\"/S Q5\-r\"/S Q5r\"S S/5r"SS5r"SS5r"SS\\ 5r"SS\5r"SS\\ 5r"SS\\5r"SS\\ 5r"SS\ \5r"SS \5r "S!S"\5r!"S#S$\5r""S%S&\5r#"S'S(\#5r$"S)S*\#5r%"S+S,\5r&"S-S.\5r'"S/S0\5r("S1S25r)"S3S4\\)5r*"S5S6\\)5r+"S7S8\\5r,"S9S:\,5r-"S;S<\5r."S=S>\,5r/"S?S@\/5r0SAr1"SBSC\/5r2"SDSE\25r3"SFSG\5r4"SHSI\45r5"SJSK\45r6"SLSM\45r7"SNSO\45r8"SPSQ\45r9"SRSS\5r:"STSU\:5r;"SVSW\:5r<"SXSY\5r="SZS[\=5r>"S\S]\=5r?"S^S_\=5r@"S`Sa\5rASbrB"ScSd\\5rC"SeSf\5rD"SgSh\5rE"SiSj\5rF\FrG"SkSl\5rHg)ma This is the syntax tree for Python 3 syntaxes. The classes represent syntax elements like functions and imports. All of the nodes can be traced back to the `Python grammar file `_. If you want to know how a tree is structured, just analyse that file (for each Python version it's a bit different). There's a lot of logic here that makes it easier for Jedi (and other libraries) to deal with a Python syntax tree. By using :py:meth:`parso.tree.NodeOrLeaf.get_code` on a module, you can get back the 1-to-1 representation of the input given to the parser. This is important if you want to refactor a parser tree. >>> from parso import parse >>> parser = parse('import os') >>> module = parser.get_root_node() >>> module Any subclasses of :class:`Scope`, including :class:`Module` has an attribute :attr:`iter_imports `: >>> list(module.iter_imports()) [] Changes to the Python Grammar ----------------------------- A few things have changed when looking at Python grammar files: - :class:`Param` does not exist in Python grammar files. It is essentially a part of a ``parameters`` node. |parso| splits it up to make it easier to analyse parameters. However this just makes it easier to deal with the syntax tree, it doesn't actually change the valid syntax. - A few nodes like `lambdef` and `lambdef_nocond` have been merged in the syntax tree to make it easier to do deal with them. Parser Tree Classes ------------------- N)Mapping)TupleAny)NodeBaseNodeLeaf ErrorNode ErrorLeafsearch_ancestor) split_prefix) split_lines)if_stmt while_stmtfor_stmttry_stmt with_stmt async_stmtsuiter simple_stmt)rr decorated async_funcdef) expr_stmt sync_comp_forrr import_name import_fromparamdel_stmtnamedexpr_testrrc>\rSrSr%Sr\\S'S\S'\\S'SrSr g) DocstringMixinDtype list[Any]childrenparentcURS:XaURSnOURS;aKURURRS5S-nURS:XaURSnOBURnURRnURU5nU(dgX4S- nURS:XaURSnURS :XaU$g) z> Returns the string leaf of a docstring. e.g. ``r'''foo'''``. file_inputrfuncdefclassdef:rNrstring)r#r%indexr&)selfnodercr/s N/home/mande/repo/quber/.venv/lib/python3.13/site-packages/parso/python/tree.py get_doc_nodeDocstringMixin.get_doc_nodeJs 99 $==#D YY1 1==!4!4S!9A!=>DyyG#}}Q'++K""++AGGK(EQYr"r6r3r@r@csI r6r@c$\rSrSrSrSrSrSrg) PythonLeafzr"c4[XR55$N)r get_start_pos_of_prefixr0s r3 _split_prefixPythonLeaf._split_prefix}sD">">"@AAr6c UR5nUb0URS:Xa URS;aUR5nUc2[UR5nUR [ U5- S-S4$UR$)zK Basically calls :py:meth:`parso.tree.NodeOrLeaf.get_start_pos_of_prefix`. error_leaf)INDENTDEDENT ERROR_DEDENTr-r)get_previous_leafr# token_typer prefixlinelenrF)r0 previous_leafliness r3rQ"PythonLeaf.get_start_pos_of_prefixs ..0  $););|)K!,,0TT);;=M   ,E99s5z)A-q0 0$$$r6N)r7r8r9r:r;rSrQr>r"r6r3rMrMzsIB%r6rMc>\rSrSrSrSr\S\\\44Sj5r Sr g)_LeafWithoutNewlinesz& Simply here to optimize performance. r"returnc^URUR[UR5-4$rP)r]columnr^valuerRs r3rF_LeafWithoutNewlines.end_poss"yy$++DJJ777r6N) r7r8r9r:rKr;propertyrintrFr>r"r6r3rcrcs/I 8sCx88r6rcc\rSrSrSrSrg)PythonBaseNoder"Nr7r8r9r:r;r>r"r6r3rmrmIr6rmc\rSrSrSrSrg) PythonNoder"Nror"r6r3rrrrrpr6rrc\rSrSrSrSrg)PythonErrorNoder"Nror"r6r3rururpr6ruc\rSrSrSrSrg)PythonErrorLeafr"Nror"r6r3rxrxrpr6rxc"\rSrSrSrSrSrSrg) EndMarkerr" endmarkercS[U5R<S[UR5<SUR<S3$)N)r#r7reprr\rFrRs r3__repr__EndMarker.__repr__s* J  dkk!2DLL  r6N)r7r8r9r:r;r#rr>r"r6r3r{r{sI D r6r{c&\rSrSrSrSrSrSrSrg)Newlinez&Contains NEWLINE and ENDMARKER tokens.r"newlinecdS[U5R<S[UR5<S3$)Nr: r)r#r7rrhrRs r3rNewline.__repr__s !$Z00$tzz2BCCr6N) r7r8r9r:rKr;r#rr>r"r6r3rrs0I DDr6rc:\rSrSrSrSrSrSrS SjrS Sjr Sr g) NamezU A string. Sometimes it is important to know if the string belongs to a name or not. rCr"c S[U5R<SUR<SUR<SUR<S3 $)Nrr@,r)r#r7rhr]rgrRs r3r Name.__repr__s,#':#6#6 #'99dkk; ;r6c$URUS9SL$)z, Returns True if the name is being defined. )include_setitemN)get_definitionr0rs r3 is_definitionName.is_definitions""?"C4OOr6cURnURnUS;aXR:XaU$gUS:Xa!UR5S:Xa UR$gUbjURS:XagUR[;a4XR U5;aU$U(aUR[ ;aU$gURnUbMjg)z Returns None if there's no definition for a name. :param import_name_always: Specifies if an import name is always a definition. Normally foo in `from foo import bar` is not a definition. r)N except_clauseasr)r&r#rCget_previous_sibling_GET_DEFINITION_TYPESget_defined_names_IMPORTS)r0import_name_alwaysrr1type_s r3rName.get_definitions{{  + +yy   O #((*d2{{"yyG#yy1111/BBK%$))x*?K;;Dr6NF)FF) r7r8r9r:rKr#r;rrrr>r"r6r3rrs# DI;P r6rc\rSrSrSrSrg)Literalr"Nror"r6r3rrrpr6rc\rSrSrSrSrSrg)Numbernumberr"Nr7r8r9r:r#r;r>r"r6r3rrs DIr6rc2\rSrSrSrSr\S5rSrSr g)Stringr.r"cb[R"SUR5RS5$)Nz \w*(?=[\'"])r)rematchrhgrouprRs r3 string_prefixString.string_prefixs"xx4::1==r6c[R"SUR[RS9nUR S5S[ UR S55*$)Nz('{3}|"{3}|'|")(.*)$)flagsr-)rsearchrhDOTALLrr^)r0rs r3 _get_payloadString._get_payloadsI ' JJ))  {{1~3EKKN 3344r6N) r7r8r9r:r#r;rjrrr>r"r6r3rrs# DI >>5r6rc \rSrSrSrSrSrSrg) FStringStringil f-strings contain f-string expressions and normal python strings. These are the string parts of f-strings. fstring_stringr"Nr7r8r9r:rKr#r;r>r"r6r3rrs DIr6rc \rSrSrSrSrSrSrg) FStringStartir fstring_startr"Nrr"r6r3rrs DIr6rc \rSrSrSrSrSrSrg) FStringEndi!r fstring_endr"Nrr"r6r3rr!s DIr6rc0\rSrSr%Sr\\S'SrSrSr g)_StringComparisonMixini*r"rhcP[U[5(aURU:H$XL$)zM Make comparisons with strings easy. Improves the readability of the parser. )rDr<rhr0others r3__eq___StringComparisonMixin.__eq__.s( eS ! !::& &}r6c,[UR5$rP)hashrhrRs r3__hash___StringComparisonMixin.__hash__8DJJr6N) r7r8r9r:r;rr=rrr>r"r6r3rr*sI J r6rc\rSrSrSrSrSrg)Operatori<operatorr"Nrr"r6r3rr<s DIr6rc\rSrSrSrSrSrg)KeywordiAkeywordr"Nrr"r6r3rrAs DIr6rcT^\rSrSrSrSrU4SjrSrSrSr Sr S r S r Sr U=r$) ScopeiFz Super class for the parser tree, which represents the state of a python text file. A Scope is either a function, class or lambda. r"c$>[TU]U5 grPsuper__init__r0r% __class__s r3rScope.__init__N "r6c$URS5$)z) Returns a generator of `funcdef` nodes. r*_search_in_scoperRs r3 iter_funcdefsScope.iter_funcdefsQs$$Y//r6c$URS5$)z* Returns a generator of `classdef` nodes. r+rrRs r3iter_classdefsScope.iter_classdefsWs$$Z00r6c&URSS5$)z? Returns a generator of `import_name` and `import_from` nodes. rrrrRs r3 iter_importsScope.iter_imports]s$$]MBBr6c8^^UU4SjmT"UR5$)Nc3># UHGnURT;aUv UR[;dM-T"UR5ShvN MI gN 7frP)r#_FUNC_CONTAINERSr%)r%elementnamesscans r3r$Scope._search_in_scope..scandsG#<<5(!M<<#33#G$4$4555 $6s,AAA Ar%)r0rrs `@r3rScope._search_in_scopecs 6DMM""r6c URS$)z4 Returns the part that is executed by the function. rrRs r3 get_suiteScope.get_suitems}}R  r6c URRnS[U5R<SU<SUR S<SUR S<S3 $![a SnNNf=f)Nrrrr-r)rCrhAttributeErrorr#r7rErF)r0rCs r3rScope.__repr__ss^ 99??D$(:#6#6#'>>!#4dll1oG G D sA A'&A')r7r8r9r:rKr;rrrrrrrr> __classcell__rs@r3rrFs: I#0 1 C #! GGr6rc@^\rSrSrSrSrSrU4SjrSrSr Sr U=r $)Modulei}z The top scope, which is always a module. Depending on the underlying parser this may be a full module or just a part of a module. ) _used_namesr(c2>[TU]U5 SUlgrP)rrrrs r3rModule.__init__s "r6c#6# UR5H|nURS:XdMURS:XdM'UR5HAnUVs/sHo3RPM nn[ U5S:XdM/USS:XdM:USv MC M~ gs snf7f)z= :return: A list of future import names. :rtype: list of str rrr __future__r-N)rr#level get_pathsrhr^)r0imppathrCrs r3_iter_future_import_names Module._iter_future_import_namessz$$&Cxx=(SYY!^MMOD489DDZZDE95zQ58|+C#Ah,':s'"BBBB&B9BBcz^^URc!0mUU4SjmT"U5 [T5UlUR$)zx Returns all the :class:`Name` leafs that exist in this module. This includes both definitions and references of names. c>URnUH nT"U5 M g![aB URS:Xa/TRUR/5nUR U5 ggf=f)NrC)r%rr# setdefaultrhappend)r1r%childarrdctrecurses r3r&Module.get_used_names..recursesf'#}}H "*"* &)yyF*!nnTZZ< 4(+)s !AA-,A-)rUsedNamesMapping)r0rrs @@r3get_used_namesModule.get_used_namess=    #C ' DM/4D r6) r7r8r9r:rKr;r#rr rr>rrs@r3rr}s( !I D '   r6rc\rSrSrSrSrSrg) Decoratori decoratorr"Nrr"r6r3rrs DIr6rc.\rSrSrSr\S5rSrSrg) ClassOrFuncir"c URS$)zB Returns the `Name` leaf that defines the function or class name. r-rrRs r3rCClassOrFunc.names }}Qr6cURnURS:Xa URnURS:XaEURSRS:XaURSR$URSS$/$)z$ :rtype: list of :class:`Decorator` rrr decoratorsNr-)r&r#r%)r0rs r3get_decoratorsClassOrFunc.get_decoratorssxKK >>_ ,!((I >>[ (!!!$))\9 ))!,555 ))"1--Ir6N) r7r8r9r:r;rjrCr#r>r"r6r3rrsI   r6rc:^\rSrSrSrSrSrU4SjrSrSr U=r $)Classiz6 Used to store the parsed contents of a python class. r+r"c$>[TU]U5 grPrrs r3rClass.__init__rr6c[UR5H)upUS:XdM URUS-nUS:Xa gUs $ g)zg Returns the `arglist` node that defines the super classes. It returns None if there are no arguments. (r-)N enumerater%)r0ir next_childs r3get_super_arglistClass.get_super_arglistsH "$--0HA|!]]1q51 $!! 1 r6) r7r8r9r:rKr#r;rr0r>rrs@r3r&r&s# DI#  r6r&cUSnURS;a[U/U5/$US:XaU/$URS:XaU/nO URn/nSn[ US/-S5HwupgUbUS:XdMX5UnU(dMUSS:Xa[ U5S:XdUSS:Xd USS:XaUH n X lM XH- nOUR[X55 UnMy U$![a /s$f=f) a `argslist_list` is a list that can contain an argslist as a first item, but most not. It's basically the items between the parameter brackets (which is at most one item). This function modifies the parser structure. It generates `Param` objects from the normal ast. Those param objects do not exist in a normal ast, but make the evaluation of the ast tree so much easier. You could also say that this function replaces the argslist node with a list of Param objects. r)rCfpdef*tfpdefNr-r/) IndexErrorr#Paramr%r-r^r&r) r& argslist_listfirstr% new_childrenstartendrparam_childrenps r3_create_paramsr@sa  zz&&ugv&'' #w :: !wH~~H #Hv$5q9JC} !)!4!>%a(C/!$^!4!9$21$5$<-a0C7!/A'-H"0$6 $++E.,IJE:;  sC C.-C.c~^\rSrSrSrSrSrU4SjrSrSr Sr \ S 5r S r S rS rS r\ S5rSrU=r$)FunctioniaF Used to store the parsed contents of a python function. Children:: 0. 1. 2. parameter list (including open-paren and close-paren s) 3. or 5. 4. or 6. Node() representing function body 3. -> (if annotation is also present) 4. annotation (if present) r*r"c>[TU]U5 UR5nURSSn[ SU55(d[ X#5URSS&gg)Nr-rc3B# UHn[U[5v M g7frPrDr8.0rs r3 $Function.__init__..-M9L:eU++9L)rr_find_parametersr%anyr@)r0r% parametersparameters_childrenrs r3rFunction.__init__)sc "**, (11!B7M9LMMM(6)J  " %Nr6cfURHnURS:XdMUs $ [S5e)NrNz(A function should always have parameters)r%r# Exception)r0rs r3rLFunction._find_parameters2s/]]Ezz\) #BCCr6c6UR5R$rP)rLr%rRs r3_get_param_nodesFunction._get_param_nodes8s$$&///r6cpUR5Vs/sHoRS:XdMUPM sn$s snf)z Returns a list of `Param()`. r)rUr#)r0r?s r3 get_paramsFunction.get_params;s0 002H2aff6G2HHHs33c URS$Nr-rrRs r3rC Function.nameA}}Qr6c4^U4SjmT"UR5$)z& Returns a generator of `yield_expr`. c3(># UH2nURS;aMURnT"U5ShvN M4 gN ![aF URS:Xa2URRS:XaURv M~Uv MMf=f7f)N)r+r*lambdefyield yield_expr)r#r%rrhr&)r%rnested_childrenrs r3r'Function.iter_yield_exprs..scanIs#<<#EE 5&-&6&6O $O444$5&*}}/">>..,>")..0")M 0*s;B ? B= BABBBBBBrr0rs @r3iter_yield_exprsFunction.iter_yield_exprsEs 5 DMM""r6c4^U4SjmT"UR5$)z' Returns a generator of `return_stmt`. c3># UHgnURS:Xd URS:XaURS:XaUv UR[;dMMT"UR5ShvN Mi gN 7f)N return_stmtrrer#rh_RETURN_STMT_CONTAINERSr%r%rrs r3r(Function.iter_return_stmts..scan_s^#<<=0"<<94(9R!M<<#::#G$4$4555 $ 6A A4A4(A2) A4rres @r3iter_return_stmtsFunction.iter_return_stmts[ 6DMM""r6c4^U4SjmT"UR5$)zY Returns a generator of `raise_stmt`. Includes raise statements inside try-except blocks c3># UHgnURS:Xd URS:XaURS:XaUv UR[;dMMT"UR5ShvN Mi gN 7f)N raise_stmtrraiserkrms r3r'Function.iter_raise_stmts..scanms^#<<</"<<94'9Q!M<<#::#G$4$4555 $ 6rorres @r3iter_raise_stmtsFunction.iter_raise_stmtsirrr6c:[UR5S5SL$)z; :return bool: Checks if a function is a generator or not. N)nextrfrRs r3 is_generatorFunction.is_generatorwsD))+T2$>>r6ct[UR5HupUS:XdM URUS-s $ g)zG Returns the test node after `->` or `None` if there is no annotation. z->r-Nr,)r0r.rs r3 annotationFunction.annotation}s8 "$--0HA}}}QU++1r6)r7r8r9r:rKr#r;rrLrUrXrjrCrfrprxr|rr>rrs@r3rBrBsf  DID 0I   #, # #? r6rBc`^\rSrSrSrSrSrU4Sjr\S5r Sr \S5r S r Sr U=r$) Lambdaiz Lambdas are basically trimmed functions, so give it the same interface. Children:: 0. *. for each argument x -2. -1. Node() representing body r`r"c>[[U] U5 URSSn[ SU55(d[ X5URSS&gg)Nr-c3B# UHn[U[5v M g7frPrErFs r3rH"Lambda.__init__..rJrK)rrBrr%rMr@)r0r%rOrs r3rLambda.__init__sR h&x0"mmAb1M9LMMM"0"KDMM!B Nr6c[S5e)z> Raises an AttributeError. Lambdas don't have a defined name. zlambda is not named.)rrRs r3rC Lambda.names 344r6c URSS$)Nr-rrrRs r3rULambda._get_param_nodess}}Qr""r6cg)z1 Returns `None`, lambdas don't have annotations. Nr"rRs r3rLambda.annotations r6cTSURR<SUR<S3$)Nrrr)rr7rErRs r3rLambda.__repr__s NN33T^^DDr6)r7r8r9r:rKr#r;rrjrCrUrrr>rrs@r3rrsS  DIL55 # EEr6rc\rSrSrSrSrg)Flowir"Nror"r6r3rrrpr6rc.\rSrSrSrSrSrSrSrSr g)IfStmtirr"c## [UR5H!upUS;dM URUS-v M# g7f)zp E.g. returns all the `test` nodes that are named as x, below: if x: pass elif x: pass )elififr-Nr,)r0r.r2s r3get_test_nodesIfStmt.get_test_nodess7dmm,DAN"mmAE**-s>>cURn[[UR555H(nURU:dMX#R:a gUs $ g)z Searches for the branch in which the node is and returns the corresponding test node (see function above). However if the node is in the test node itself and not in the suite return None. N)rEreversedlistrrF)r0r1rE check_nodes r3get_corresponding_test_node"IfStmt.get_corresponding_test_nodesP NN "4(;(;(=#>?J##i/111&%@r6crURH'nUS:XdM URUR:dM' g g)z+ Checks if a node is defined after `else`. elseTF)r%rE)r0r1r2s r3is_node_after_elseIfStmt.is_node_after_elses1AF{>>AKK/ r6N) r7r8r9r:r#r;rrrr>r"r6r3rrs DI +& r6rc\rSrSrSrSrSrg) WhileStmtirr"Nrr"r6r3rr DIr6rc,\rSrSrSrSrSrSSjrSrg)ForStmtirr"c URS$)z5 Returns the input node ``y`` from: ``for x in y:``. rrRs r3 get_testlistForStmt.get_testlists}}Qr6c4[URSU5$r[_defined_namesr%rs r3rForStmt.get_defined_namesdmmA.@@r6Nr) r7r8r9r:r#r;rrr>r"r6r3rrs DI Ar6rc"\rSrSrSrSrSrSrg)TryStmtirr"c## URH2nURS:XaURSv M&US:XdM.Sv M4 g7f)z Returns the ``test`` nodes found in ``except_clause`` nodes. Returns ``[None]`` for except clauses without an exception given. rr-exceptNr%r#r0r1s r3get_except_clause_testsTryStmt.get_except_clause_testss= MMDyyO+mmA&&! "s 7A AN)r7r8r9r:r#r;rr>r"r6r3rrs DI r6rc,\rSrSrSrSrSSjrSrSrg)WithStmti rr"c/nURSSS2H1nURS:XdMU[URSU5- nM3 U$)ze Returns the a list of `Name` that the with statement defines. The defined names are set after `as`. r-rr with_item)r%r#r)r0rrrs r3rWithStmt.get_defined_names sQ qAv.I~~, (:(:1(=OO/ r6c^URS5nUc [S5eURS$)Nrz2The name is not actually part of a with statement.r)r ValueErrorr%)r0rCr1s r3get_test_node_from_name WithStmt.get_test_node_from_names2##K0 <QR R}}Qr6Nr) r7r8r9r:r#r;rrr>r"r6r3rr s DI  r6rcF\rSrSr%Sr\\S'\\S'SrSrSr Sr Sr g ) Importi r"r _aliasescUR5UnUR5H!nX;dM USURU5S-s $ [ S5e![a NLf=f)zW The path is the list of names that leads to the searched name. :return list of Name: Nr-z+Name should be defined in the import itself)rKeyErrorr r/r)r0rCr s r3get_path_for_nameImport.get_path_for_name%sm  ==?4(DNN$D|1TZZ-122%FGG    sA A"!A"cg)NFr"rRs r3 is_nestedImport.is_nested6sr6c&URSS:H$)Nrr4rrRs r3is_star_importImport.is_star_import9s}}R C''r6c[S5e)NzUse ImportFrom or ImportName)NotImplementedErrorrRs r3rImport.get_defined_names<s!"@AAr6N) r7r8r9r:r;rr=rrrrr>r"r6r3rr s'INMH"(Br6rcN\rSrSrSrSrS SjrSrSr\ S5r Sr S r Sr g ) ImportFromi@rr"cjUR5VVs/sHup#U=(d UPM snn$s snnf)z Returns the a list of `Name` that the import defines. The defined names are set after `import` or in case an alias - `as` - is present that name is returned. )_as_name_tuples)r0rrCaliass r3rImportFrom.get_defined_namesDs/ 261E1E1GH1G+$  1GHHHs/cB[SUR555$)z-Mapping from alias to its corresponding name.c36# UHupUcM X!4v M g7frPr")rGrCrs r3rH&ImportFrom._aliases..Ns *5Kkd"UM5Ks  )dictrrRs r3rImportFrom._aliasesLs$*T5I5I5K** *r6cURSSH nUS;dM O WRS:XaURSSS2$US:Xa/$U/$)Nr-.z... dotted_namerimportr)r0ns r3get_from_namesImportFrom.get_from_namesQsUqr"A $# 66] "::cc? " (]I3Jr6cxSnURSSH$nUS;aU[UR5- nM# U$ U$)&The level parameter of ``__import__``.rr-Nrr%r^rh)r0rrs r3rImportFrom.level\sGqr"AL QWW% #  r6c## URSnUS:XaURSnOUS:XagURS:XaURSSS2nOU/nUH/nURS:XaUS4v MURSSS2v M1 g7f)Nrr+rr4import_as_namesrrCr)r0lastas_namesas_names r3rImportFrom._as_name_tuplesgs}}R  3;==$D S[  99) )}}SqS)HvHG||v%tm#&&ss++  sB B cUR5nURSS:XaU/$UR5VVs/sH up#X/-PM snn$s snnf)z The import paths defined in an import statement. Typically an array like this: ``[, ]``. :return list of list of Name: rr4)rr%r)r0dottedrCrs r3r ImportFrom.get_pathsxsS$$& ==  #8O373G3G3IJ3IKD3IJJJsANr)r7r8r9r:r#r;rrrrjrrr r>r"r6r3rr@s; DII* ," Kr6rcR\rSrSrSrSrSrS Sjr\S5r Sr Sr S r S r Srg ) ImportNameizBFor ``import_name`` nodes. Covers normal imports without ``from``.rr"cpUR5VVs/sHup#U=(d USPM snn$s snnf)z Returns the a list of `Name` that the import defines. The defined names is always the first name after `import` or in case an alias - `as` - is present that name is returned. r_dotted_as_names)r0rr rs r3rImportName.get_defined_namess5 594I4I4KL4K[T a 4KLLLs2cg)rrr"rRs r3rImportName.levelsr6cXUR5VVs/sHupUPM snn$s snnfrPrr0r rs r3r ImportName.get_pathss'(,(=(=(?@(?(?@@@s&c#H# URSnURS:XaURSSS2nOU/nUHcnURS:XaURSnURSnOSnURS:Xa U/U4v MMURSSS2U4v Me g7f)z9Generator of (list(path), alias) where alias may be None.r-dotted_as_namesNrdotted_as_namerrCr)r0rrrrs r3rImportName._dotted_as_namess--*   #4 4&//!4H'(HG||//((+!**1-||v%i&&&&ss+U22 sB B"c [UR5VVs/sHupUbM [U5S:dMSPM snn5$s snnf)zn This checks for the special case of nested imports, without aliases and from statement:: import foo.bar r-)boolrr^rs r3rImportName.is_nestedsN$*?*?*A8*A;4),TQ*A89 98s A A A cB[SUR555$)z- :return list of Name: Returns all the alias c3<# UHupUcM X!S4v M g7f)Nrr")rGr rs r3rH&ImportName._aliases..s%*9P+$&UH%9Ps  )rrrRs r3rImportName._aliasess&*9N9N9P** *r6Nr)r7r8r9r:rKr#r;rrjrr rrrr>r"r6r3rrs>L DIMA3(9*r6rcF\rSrSrSrSr\S5r\S5rSSjr Sr g) KeywordStatementiz For the following statements: `assert`, `del`, `global`, `nonlocal`, `raise`, `return`, `yield`. `pass`, `continue` and `break` are not in there, because they are just simple keywords and the parser reduces it to a keyword. r"c SUR-$)zr Keyword statements start with the keyword and end with `_stmt`. You can crosscheck this with the Python grammar. z%s_stmt)rrRs r3r#KeywordStatement.types 4<<''r6c4URSR$Nr)r%rhrRs r3rKeywordStatement.keywords}}Q%%%r6cURnUS:Xa[URSU5$US;aURSSS2$/$)Ndelr-)globalnonlocalr)rrr%)r0rrs r3r"KeywordStatement.get_defined_namessL,, e !$--"2OD D , ,==A& & r6Nr) r7r8r9r:rKr;rjr#rrr>r"r6r3r r s9I ((&&r6r c(\rSrSrSr\S5rSrg) AssertStmtir"c URS$r[rrRs r3 assertionAssertStmt.assertionr]r6N)r7r8r9r:r;rjrr>r"r6r3rrsI   r6rc\rSrSrSrSrSrg) GlobalStmtir"c&URSSS2$)Nr-rrrRs r3get_global_namesGlobalStmt.get_global_namess}}QTT""r6N)r7r8r9r:r;rr>r"r6r3rrs I#r6rc\rSrSrSrSrg) ReturnStmtir"Nror"r6r3rrrpr6rc\rSrSrSrSrSrg) YieldExprirbr"Nrr"r6r3r!r!rr6r!c/nURS;a)URSSS2HnU[X15- nM U$URS;aU[URSU5- nU$URS;aURSS:waURS nURS S :Xa URURS5 U$URS S :XauU(anURSSS 2HXnURS :Xa!URURS5 U$URS:XdMFURU5 U$ U$URU5 U$)z_ A helper function to find the defined names in statements, for loops and list comprehensions. )testlist_star_expr testlist_compexprlisttestlistNr)atom star_exprr-)power atom_exprr**rrr[trailerrC)r#r%rr)currentrrrr-r1s r3rrsu E||VV%%cc*E ^E; ;E+& L# . .  0 0 3_EE L / /   B 4 '&&r*G"c) W--a01 L!!!$+#,,RVV4DyyI- T]]1%56 L yyF* T* L5 L  W Lr6c2\rSrSrSrSrSSjrSrSrSr g) ExprStmtirr"cv/nURSRS:Xa[URSU5n[S[ UR5S- S5VVs/sHHnSURUS-R ;dM%[URUU5HnUPM MJ snnU-$s snnf)z7 Returns a list of `Name` defined before the `=` sign. r- annassignrr=)r%r#rranger^rh)r0rrr.rCs r3rExprStmt.get_defined_namess ==  K /"4==#3_EE1c$--014a8 8dmmAE*000 't}}Q'7I J 8    s $B5'B5cURSnURS:Xa9[UR5S:XaURSnU$URSnU$)z*Returns the right-hand-side of the equals.rr2rr-r%r#r^rs r3get_rhsExprStmt.get_rhs'sW}}R  99 #4==!Q&}}Q' }}Q' r6c## URSnURS:Xa)[UR5S::agURSnUv URSSS2ShvN gN7f)zJ Returns a generator of `+=`, `=`, etc. or None if there is no operation. r-r2rNrr8r0r:s r3yield_operatorsExprStmt.yield_operators1s` a  :: $5>>"a'NN1%E ==A&&&sA"A,$A*%A,Nr) r7r8r9r:r#r;rr9r=r>r"r6r3r0r0s DI  'r6r0c"\rSrSrSrSSjrSrg) NamedExpri@rc4[URSU5$r rrs r3rNamedExpr.get_defined_namesCrr6r"Nr)r7r8r9r:r#rr>r"r6r3r@r@@s DAr6r@c^\rSrSrSrSrSU4Sjjr\S5r\S5r \S5r Sr \S 5r SS jr \S 5rS rSU4S jjrSrSrU=r$)r8iGz It's a helper class that makes business logic with params much easier. The Python grammar defines no ``param`` node. It defines it in a different way that is not really suited to working with parameters. rc0>[TU]U5 X lgrP)rrr&)r0r%r&rs r3rParam.__init__Os " r6cXURSnUS;a[UR5$g)zK Is `0` in case of `foo`, `1` in case of `*foo` or `2` in case of `**foo`. rr4r+rr<s r3 star_countParam.star_countSs,  a  K u{{# #r6cURSS:HnURS[U5- S:XaURS[U5- $g![a gf=f)zc The default is the test node that appears after the `=`. Is `None` in case no default is present. rrrr3N)r%rkr7)r0 has_commas r3default Param.default^se MM"%,  }}R#i.01S8}}R#i.%8999  s9A AAcUR5nURS:XaAURSS:Xde[UR5S:XdeURSnU$g)zb The default is the test node that appears after `:`. Is `None` in case no annotation is present. r5r-r,rrN)_tfpdefr#r%r^)r0r5rs r3rParam.annotationks`  ;;( "??1%, ,,v'1, ,,+J r6cV[URSS;5nURU$)z! tfpdef: see e.g. grammar36.txt. rrG)rkr%)r0offsets r3rO Param._tfpdefzs+T]]1%45}}V$$r6cUR5RS:XaUR5RS$UR5$)z The `Name` leaf of the param. r5r)rOr#r%rRs r3rC Param.names; <<>  ( *<<>**1- -<<> !r6cUR/$rP)rCrs r3rParam.get_defined_namess {r6c^URRRU5nURRRS5nX:aUS-nURRRS5nX:aUS-nUS- $![a NAf=f![a US- $f=f)z2 Property for the positional index of a paramter. r4rr6r-)r&r%r/r)r0r/keyword_only_indexs r3position_indexParam.position_indexs  $$**40 !%!5!5!;!;C!@ )  !%!5!5!;!;C!@ ) qy     qy s#/B /B BB B,+B,c&URSS5$)z- Returns the function/lambda of a parameter. r*r`)r rRs r3get_parent_functionParam.get_parent_functions##Iy99r6c>U(a[TU]U5$URnUSS:XaUSSnURUUS9$)z Like all the other get_code functions, but includes the param `include_comma`. :param include_comma bool: If enabled includes the comma in the string output. rrN)include_prefix)rget_coder%_get_code_for_children)r0r` include_commar%rs r3raParam.get_codesV 7#N3 3== B<3 }H** )+  r6cURcSOSURR5-nS[U5R<S[ UR 55U-<S3$)Nrz=%srrr)rLrar#r7r<rO)r0rLs r3rParam.__repr__sI ,"%$,,:O:O:Q2Q!$Z00#dlln2E2OPPr6)r&rPr)TT)r7r8r9r:rKr#rrjrHrLrrOrCrrZr]rarr>rrs@r3r8r8Gs D    %""*:  $QQr6r8c&\rSrSrSrSrSSjrSrg) SyncCompForirr"c4[URSU5$)z> Returns the a list of `Name` that the comprehension defines. r-rrs r3rSyncCompFor.get_defined_namess dmmA.@@r6Nr)r7r8r9r:r#r;rr>r"r6r3rhrhs DIAr6rhc<\rSrSrSrSrSrSrSrSr Sr S r g ) rizG This class exists for the sole purpose of creating an immutable dict. cXlgrP_dict)r0rs r3rUsedNamesMapping.__init__s r6c URU$rPrm)r0keys r3 __getitem__UsedNamesMapping.__getitem__szz#r6c,[UR5$rP)r^rnrRs r3__len__UsedNamesMapping.__len__s4::r6c,[UR5$rP)iterrnrRs r3__iter__UsedNamesMapping.__iter__rr6c[U5$rP)idrRs r3rUsedNamesMapping.__hash__s $xr6cXL$rPr"rs r3rUsedNamesMapping.__eq__s }r6rmN) r7r8r9r:rKrrrruryrrr>r"r6r3rrs% r6r)IrKrcollections.abcrtypingrr parso.treerrrr r r parso.python.prefixr parso.utilsr set_FLOW_CONTAINERSrlrrrr r@rMrcrmrrrurxr{rrrrrrrrrrrrrrrr&r@rBrrrrrrrrrrr rrrr!rr0r@r8rhCompForrr"r6r3rs*X #RR,#<=w 67:JJ:  }- .>.%d%08:8[(dk9i $ DjD1 1hjW 5W5"J:  $#%; "$: 4GNN4Gn3 U3 l %6K0*Zm{m`*EX*EZ>*T*Z Ad A d   t .B^B@CKCKL8*8*v~> ! #!#! :('~~('VAAwQNwQt A. A wr6