KidZddlZddlmZddlmZmZddlmZm Z m Z m Z m Z m Z ddlmZddlmZegdZed d gezZegd ezZegd Zed dgZGddZGddZGddee ZGddeZGddee ZGddeeZGddee ZGdde eZGdd eZ Gd!d"eZ!Gd#d$eZ"Gd%d&eZ#Gd'd(e#Z$Gd)d*e#Z%Gd+d,eZ&Gd-d.eZ'Gd/d0eZ(Gd1d2Z)Gd3d4ee)Z*Gd5d6ee)Z+Gd7d8eeZ,Gd9d:e,Z-Gd;de,Z/Gd?d@e/Z0dAZ1GdBdCe/Z2GdDdEe2Z3GdFdGeZ4GdHdIe4Z5GdJdKe4Z6GdLdMe4Z7GdNdOe4Z8GdPdQe4Z9GdRdSeZ:GdTdUe:Z;GdVdWe:Z<GdXdYeZ=GdZd[e=Z>Gd\d]e=Z?Gd^d_e=Z@Gd`daeZAdbZBGdcddeeZCGdedfeZDGdgdheZEGdidjeZFeFZGGdkdleZHy)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_testrrc6eZdZUdZeed<ded<eed<dZy)DocstringMixintype list[Any]childrenparentc|jdk(r|jd}n|jdvrJ|j|jjddz}|jdk(rN|jd}n>|j}|jj}|j|}|sy||dz }|jdk(r|jd}|jd k(r|Sy) zN Returns the string leaf of a docstring. e.g. ``r'''foo'''``. file_inputrfuncdefclassdef:rNrstring)r"r$indexr%)selfnodercr.s b/workspace/moltex-experiments/.pixi/envs/default/lib/python3.12/site-packages/parso/python/tree.py get_doc_nodezDocstringMixin.get_doc_nodeJs 99 $==#D YY1 1==!4!4S!9A!=>DyyG#}}Q'++K""++AGGK(EUQY">"@AAr4c|j}|-|jdk(r|jdvr|j}|2t|j}|j t |z dzdfS|jS)z[ Basically calls :py:meth:`parso.tree.NodeOrLeaf.get_start_pos_of_prefix`. error_leaf)INDENTDEDENT ERROR_DEDENTr,r)get_previous_leafr" token_typer prefixlinelenrA)r/ previous_leafliness r2rJz"PythonLeaf.get_start_pos_of_prefixs ..0  $););|)K!,,0TT);;=M   ,E99s5z)A-q0 0$$$r4N)r5r6r7r8rLrJr!r4r2rGrGzsIB%r4rGc4eZdZdZdZedeeeffdZy)_LeafWithoutNewlinesz. Simply here to optimize performance. r!returnc^|j|jt|jzfSrI)rUcolumnrVvaluerKs r2rAz_LeafWithoutNewlines.end_poss"yy$++DJJ777r4N) r5r6r7rEr8propertyrintrAr!r4r2rZrZs/I 8sCx88r4rZceZdZdZy)PythonBaseNoder!Nr5r6r7r8r!r4r2rbrbIr4rbceZdZdZy) PythonNoder!Nrcr!r4r2rfrfrdr4rfceZdZdZy)PythonErrorNoder!Nrcr!r4r2rhrhrdr4rhceZdZdZy)PythonErrorLeafr!Nrcr!r4r2rjrjrdr4rjceZdZdZdZdZy) EndMarkerr! endmarkerczdt|jdt|jd|jdS)N)r"r5reprrTrArKs r2__repr__zEndMarker.__repr__s* J  dkk!2DLL  r4N)r5r6r7r8r"rrr!r4r2rlrlsI D r4rlceZdZdZdZdZdZy)Newlinez&Contains NEWLINE and ENDMARKER tokens.r!newlinec`dt|jdt|jdS)Nro: rp)r"r5rqr^rKs r2rrzNewline.__repr__s !$Z00$tzz2BCCr4N)r5r6r7rEr8r"rrr!r4r2rtrts0I DDr4rtc.eZdZdZdZdZdZddZd dZy) Nameza A string. Sometimes it is important to know if the string belongs to a name or not. r>r!c dt|jd|jd|jd|jd S)Nrorw@,rp)r"r5r^rUr]rKs r2rrz Name.__repr__s,#':#6#6 #'99dkk; ;r4c*|j|duS)z< Returns True if the name is being defined. )include_setitemN)get_definitionr/r~s r2 is_definitionzName.is_definitions""?"C4OOr4ch|j}|j}|dvr||jk(r|Sy|dk(r |jdk(r |jSy|]|jdk(ry|jtvr,||j |vr|S|r|jt vr|Sy|j}|]y)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"r>get_previous_sibling_GET_DEFINITION_TYPESget_defined_names_IMPORTS)r/import_name_alwaysr~r0type_s r2rzName.get_definitions{{  + +tyy   O #((*d2{{"yyG#yy11411/BBK%$))x*?K;;Dr4NF)FF) r5r6r7rEr"r8rrrrr!r4r2ryrys# DI;P r4ryceZdZdZy)Literalr!Nrcr!r4r2rrrdr4rceZdZdZdZy)Numbernumberr!Nr5r6r7r"r8r!r4r2rrs DIr4rc*eZdZdZdZedZdZy)Stringr-r!c`tjd|jjdS)Nz \w*(?=[\'"])r)rematchr^grouprKs r2 string_prefixzString.string_prefixs"xx4::1==r4ctjd|jtj}|j ddt |j d S)Nz('{3}|"{3}|'|")(.*)$)flagsr,)rsearchr^DOTALLrrV)r/rs r2 _get_payloadzString._get_payloadsI ' JJ))  {{1~3EKKN 3344r4N)r5r6r7r"r8r_rrr!r4r2rrs# DI >>5r4rceZdZdZdZdZy) FStringStringx f-strings contain f-string expressions and normal python strings. These are the string parts of f-strings. fstring_stringr!Nr5r6r7rEr"r8r!r4r2rrs DIr4rceZdZdZdZdZy) FStringStartr fstring_startr!Nrr!r4r2rrs DIr4rceZdZdZdZdZy) FStringEndr fstring_endr!Nrr!r4r2rr!s DIr4rc(eZdZUdZeed<dZdZy)_StringComparisonMixinr!r^cHt|tr|j|k(S||uS)ze Make comparisons with strings easy. Improves the readability of the parser. )r?r9r^r/others r2__eq__z_StringComparisonMixin.__eq__.s' eS !::& &u}r4c,t|jSrI)hashr^rKs r2__hash__z_StringComparisonMixin.__hash__8DJJr4N)r5r6r7r8rr:rrr!r4r2rr*sI J r4rceZdZdZdZy)Operatoroperatorr!Nrr!r4r2rr<s DIr4rceZdZdZdZy)Keywordkeywordr!Nrr!r4r2rrAs DIr4rcJeZdZdZdZfdZdZdZdZdZ dZ d Z xZ S) Scopez 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$t||yrIsuper__init__r/r$ __class__s r2rzScope.__init__N "r4c$|jdS)z9 Returns a generator of `funcdef` nodes. r)_search_in_scoperKs r2 iter_funcdefszScope.iter_funcdefsQs$$Y//r4c$|jdS)z: Returns a generator of `classdef` nodes. r*rrKs r2iter_classdefszScope.iter_classdefsWs$$Z00r4c&|jddS)zO Returns a generator of `import_name` and `import_from` nodes. rrrrKs r2 iter_importszScope.iter_imports]s$$]MBBr4c6fd|jS)Nc3K|D]A}|jvr||jtvs(|jEd{Cy7wrI)r"_FUNC_CONTAINERSr$)r$elementnamesscans r2rz$Scope._search_in_scope..scandsH#<<5(!M<<#33#G$4$4555 $6s*A A A A r$)r/rrs `@r2rzScope._search_in_scopecs 6DMM""r4c |jdS)zD Returns the part that is executed by the function. rrKs r2 get_suitezScope.get_suitems}}R  r4c  |jj}dt|jd|d|j dd|j dd S#t$rd}YIwxYw)Nrorwr{r-rp)r>r^AttributeErrorr"r5r@rA)r/r>s r2rrzScope.__repr__ss^ 99??D$(:#6#6#'>>!#4dll1oG G D sA A"!A") r5r6r7rEr8rrrrrrrr __classcell__rs@r2rrFs4 I#0 1 C #! Gr4rc6eZdZdZdZdZfdZdZdZxZ S)Modulez 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'c2t||d|_yrI)rrrrs r2rzModule.__init__s "r4c#K|jD]o}|jdk(s|jdk(s#|jD]:}|Dcgc]}|j}}t |dk(s+|ddk(s4|d<qycc}ww)zU :return: A list of future import names. :rtype: list of str rrr __future__r,N)rr"level get_pathsr^rV)r/imppathr>rs r2_iter_future_import_namesz Module._iter_future_import_namess}$$&Cxx=(SYY!^MMOD489DDTZZDE95zQ58|+C#Ah,':s'#B B B  B B 1B :B cv|j ifd|t|_|jS)z Returns all the :class:`Name` leafs that exist in this module. This includes both definitions and references of names. c |j}|D] }| y#t$rA|jdk(r/j|jg}|j |YyYywxYw)Nr>)r$rr" setdefaultr^append)r0r$childarrdctrecurses r2rz&Module.get_used_names..recursesf'#}}H "*"* &)yyF*!nnTZZ< 4(+)s AA)(A))rUsedNamesMapping)r/rrs @@r2get_used_nameszModule.get_used_namess=    #C ' DM/4D r4) r5r6r7rEr8r"rrrrrs@r2rr}s# !I D '  r4rceZdZdZdZy) Decorator decoratorr!Nrr!r4r2rrs DIr4rc&eZdZdZedZdZy) ClassOrFuncr!c |jdS)zR Returns the `Name` leaf that defines the function or class name. r,rrKs r2r>zClassOrFunc.names }}Qr4c|j}|jdk(r |j}|jdk(rD|jdjdk(r|jdjS|jddSgS)z4 :rtype: list of :class:`Decorator` rrr decoratorsNr,)r%r"r$)r/rs r2get_decoratorszClassOrFunc.get_decoratorssxKK >>_ ,!((I >>[ (!!!$))\9 ))!,555 ))"1--Ir4N)r5r6r7r8r_r>rr!r4r2rrsI   r4rc0eZdZdZdZdZfdZdZxZS)Classz> Used to store the parsed contents of a python class. r*r!c$t||yrIrrs r2rzClass.__init__rr4ct|jD]'\}}|dk(s |j|dz}|dk(ry|cSy)z Returns the `arglist` node that defines the super classes. It returns None if there are no arguments. (r,)N enumerater$)r/ir next_childs r2get_super_arglistzClass.get_super_arglistsJ "$--0HAu|!]]1q51 $!! 1 r4) r5r6r7rEr"r8rrrrs@r2rrs DI# r4rc |d}|jdvrt|g|gS|dk(r|gS|jdk(r|g}n |j}g}d}t |dgzdD]l\}}||dk(s|||}|s|ddk(rt |dk(s|ddk(s|ddk(r|D] } || _ ||z }n|jt|||}n|S#t$rgcYSwxYw) 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)r>fpdef*tfpdefNr,r|/) IndexErrorr"Paramr$rrVr%r) r% argslist_listfirstr$ new_childrenstartendrparam_childrenps r2_create_paramsrs#a  zz&&ugv&'' #w :: !wH~~H #Hv$5q9JC} !)%!4!%a(C/!$^!4!9$21$5$<-a0C7!/A'-AH"0$6 $++E.&,IJE:;  sC CCcteZdZdZdZdZfdZdZdZdZ e dZ d Z d Z d Zd Ze d ZxZS)Functionan 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!ct|||j}|jdd}t d|Dst |||jddyy)Nr,rc3<K|]}t|tywrIr?r .0rs r2 z$Function.__init__..-M9L:eU+9L)rr_find_parametersr$anyr)r/r$ parametersparameters_childrenrs r2rzFunction.__init__)sc "**, (11!B7M9LMM(6/)J  " %Nr4c`|jD]}|jdk(s|cStd)Nrz(A function should always have parameters)r$r" Exception)r/rs r2rzFunction._find_parameters2s/]]Ezz\) #BCCr4c6|jjSrI)rr$rKs r2_get_param_nodeszFunction._get_param_nodes8s$$&///r4ch|jDcgc]}|jdk(s|c}Scc}w)z. Returns a list of `Param()`. r)r$r")r/rs r2 get_paramszFunction.get_params;s2 002H2aaff6G2HHHs//c |jdSNr,rrKs r2r>z Function.nameA}}Qr4c2fd|jS)z6 Returns a generator of `yield_expr`. c3 K|D].}|jdvr |j}|Ed{0y7#t$r>|jdk(r,|jjdk(r|jn|YzwxYww)N)r*r)lambdefyield yield_expr)r"r$rr^r%)r$rnested_childrenrs r2rz'Function.iter_yield_exprs..scanIs#<<#EE 5&-&6&6O $O444$5&*}}/">>..,>")..0")M *s/B : B8BAB>BBBrr/rs @r2iter_yield_exprszFunction.iter_yield_exprsEs 5 DMM""r4c2fd|jS)z7 Returns a generator of `return_stmt`. c3K|D]`}|jdk(s|jdk(r|jdk(r||jtvsG|jEd{by7w)N return_stmtrr[r"r^_RETURN_STMT_CONTAINERSr$r$rrs r2rz(Function.iter_return_stmts..scan_s_#<<=0"<<94(9R!M<<#::#G$4$4555 $ 6A A, A,"A*#A,rr0s @r2iter_return_stmtszFunction.iter_return_stmts[ 6DMM""r4c2fd|jS)zi Returns a generator of `raise_stmt`. Includes raise statements inside try-except blocks c3K|D]`}|jdk(s|jdk(r|jdk(r||jtvsG|jEd{by7w)N raise_stmtrraiser5r7s r2rz'Function.iter_raise_stmts..scanms_#<<</"<<94'9Q!M<<#::#G$4$4555 $ 6r8rr0s @r2iter_raise_stmtszFunction.iter_raise_stmtsir:r4c:t|jdduS)zK :return bool: Checks if a function is a generator or not. N)nextr1rKs r2 is_generatorzFunction.is_generatorwsD))+T2$>>r4cpt|jD]\}}|dk(s |j|dzcSy)zW Returns the test node after `->` or `None` if there is no annotation. z->r,Nr)r/rrs r2 annotationzFunction.annotation}s: "$--0HAu}}}QU++1r4)r5r6r7rEr"r8rrr$r&r_r>r1r9r?rBrDrrs@r2rrsf  DID 0I   #, # #? r4rcVeZdZdZdZdZfdZedZdZ edZ dZ xZ S) Lambdaz Lambdas are basically trimmed functions, so give it the same interface. Children:: 0. *. for each argument x -2. -1. Node() representing body r,r!ctt| ||jdd}t d|Dst |||jddyy)Nr,c3<K|]}t|tywrIrrs r2rz"Lambda.__init__..rr)rrrr$rr)r/r$r rs r2rzLambda.__init__sR h&x0"mmAb1M9LMM"07J"KDMM!B Nr4ctd)zN Raises an AttributeError. Lambdas don't have a defined name. zlambda is not named.)rrKs r2r>z Lambda.names 344r4c |jddS)Nr,rHrrKs r2r$zLambda._get_param_nodess}}Qr""r4cy)zA Returns `None`, lambdas don't have annotations. Nr!rKs r2rDzLambda.annotations r4cPd|jjd|jdS)Nror{rp)rr5r@rKs r2rrzLambda.__repr__s NN33T^^DDr4) r5r6r7rEr"r8rr_r>r$rDrrrrs@r2rFrFsM  DIL55 # Er4rFceZdZdZy)Flowr!Nrcr!r4r2rOrOrdr4rOc&eZdZdZdZdZdZdZy)IfStmtrr!c#xKt|jD]\}}|dvs |j|dz yw)z E.g. returns all the `test` nodes that are named as x, below: if x: pass elif x: pass )elififr,Nr)r/rr1s r2get_test_nodeszIfStmt.get_test_nodess:dmm,DAqN"mmAE**-s ::c|j}tt|jD]&}|j|ks||jkry|cSy)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)r@reversedlistrUrA)r/r0r@ check_nodes r2get_corresponding_test_nodez"IfStmt.get_corresponding_test_nodesR NN "4(;(;(=#>?J##i/z111&%@r4ch|jD]#}|dk(s |j|jkDs#yy)z; Checks if a node is defined after `else`. elseTF)r$r@)r/r0r1s r2is_node_after_elsezIfStmt.is_node_after_elses1AF{>>AKK/ r4N)r5r6r7r"r8rUrZr]r!r4r2rQrQs DI +& r4rQceZdZdZdZy) WhileStmtrr!Nrr!r4r2r_r_ DIr4r_c"eZdZdZdZdZddZy)ForStmtrr!c |jdS)zE Returns the input node ``y`` from: ``for x in y:``. rrKs r2 get_testlistzForStmt.get_testlists}}Qr4c4t|jd|Sr(_defined_namesr$rs r2rzForStmt.get_defined_namesdmmA.@@r4Nr)r5r6r7r"r8rerr!r4r2rbrbs DI Ar4rbceZdZdZdZdZy)TryStmtrr!c#K|jD]-}|jdk(r|jd$|dk(s*d/yw)z Returns the ``test`` nodes found in ``except_clause`` nodes. Returns ``[None]`` for except clauses without an exception given. rr,exceptNr$r"r/r0s r2get_except_clause_testszTryStmt.get_except_clause_testss> MMDyyO+mmA&&! "s 6AAN)r5r6r7r"r8rpr!r4r2rkrks DI r4rkc"eZdZdZdZddZdZy)WithStmtrr!cg}|jdddD].}|jdk(s|t|jd|z }0|S)z} Returns the a list of `Name` that the with statement defines. The defined names are set after `as`. r,rHr with_item)r$r"rh)r/r~rrts r2rzWithStmt.get_defined_names sQ qAv.I~~, (:(:1(=OO/ r4c\|jd}| td|jdS)Nrtz2The name is not actually part of a with statement.r)r ValueErrorr$)r/r>r0s r2get_test_node_from_namez WithStmt.get_test_node_from_names2##K0 <QR R}}Qr4Nr)r5r6r7r"r8rrwr!r4r2rrrr s DI  r4rrc>eZdZUdZeed<eed<dZdZdZdZ y) Importr!r_aliasesc |j|}|jD]}||vs|d|j|dzcSt d#t$rYHwxYw)zo 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)rzKeyErrorrr.rv)r/r>rs r2get_path_for_namezImport.get_path_for_name%so  ==?4(DNN$Dt|1TZZ-122%FGG    sA AAcy)NFr!rKs r2 is_nestedzImport.is_nested6sr4c&|jddk(S)NrrrrKs r2is_star_importzImport.is_star_import9s}}R C''r4ctd)NzUse ImportFrom or ImportName)NotImplementedErrorrKs r2rzImport.get_defined_names<s!"@AAr4N) r5r6r7r8rr:r}rrrr!r4r2ryry s'INMH"(Br4rycDeZdZdZdZd dZdZdZedZ dZ dZ y ) ImportFromrr!c\|jDcgc] \}}|xs| c}}Scc}}w)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)r/r~r>aliass r2rzImportFrom.get_defined_namesDs1 261E1E1GH1G+$  1GHHHs(cBtd|jDS)z-Mapping from alias to its corresponding name.c3.K|] \}}|||fywrIr!)rr>rs r2rz&ImportFrom._aliases..Ns&*5KkdE(DM5Ks)dictrrKs r2rzzImportFrom._aliasesLs$*T5I5I5K** *r4c|jddD]}|dvsnjdk(r|jdddS|dk(rgS|gS)Nr,.z... dotted_namerimportrn)r/ns r2get_from_nameszImportFrom.get_from_namesQsUqr"A $# 66] "::cc? " (]I3Jr4cpd}|jddD]!}|dvr|t|jz } |S|S)&The level parameter of ``__import__``.rr,Nrr$rVr^)r/rrs r2rzImportFrom.level\sGqr"AL QWW% #  r4c# K|jd}|dk(r|jd}n|dk(ry|jdk(r|jddd}n|g}|D],}|jdk(r|df|jddd.yw)NrrrHrimport_as_namesrr>rn)r/lastas_namesas_names r2rzImportFrom._as_name_tuplesgs}}R  3;==$D S[  99) )}}SqS)HvHG||v%tm#&&ss++  sBBc|j}|jddk(r|gS|jDcgc] \}}||gz c}}Scc}}w)z The import paths defined in an import statement. Typically an array like this: ``[, ]``. :return list of list of Name: rr)rr$r)r/dottedr>rs r2rzImportFrom.get_pathsxsW$$& ==  #8O373G3G3IJ3IKD%$3IJJJsA Nr) r5r6r7r"r8rrzrr_rrrr!r4r2rr@s; DII* ," Kr4rcHeZdZdZdZdZd dZedZdZ dZ dZ d Z y ) ImportNamezBFor ``import_name`` nodes. Covers normal imports without ``from``.rr!cb|jDcgc]\}}|xs|dc}}Scc}}w)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)r/r~rrs r2rzImportName.get_defined_namess7 594I4I4KL4K[T5 a 4KLLLs+cy)rrr!rKs r2rzImportName.levelsr4cT|jDcgc]\}}| c}}Scc}}wrIrr/rrs r2rzImportName.get_pathss)(,(=(=(?@(?u(?@@@s $c#<K|jd}|jdk(r|jddd}n|g}|D]_}|jdk(r|jd}|jd}nd}|jdk(r|g|fJ|jddd|fayw)z9Generator of (list(path), alias) where alias may be None.r,dotted_as_namesNrdotted_as_namerr>rn)r/rrrrs r2rzImportName._dotted_as_namess--*   #4 4&//!4H'(HG||//((+!**1-||v%i&&&&ss+U22 sBBc t|jDcgc]\}}|t|dkDrdc}}Scc}}w)z This checks for the special case of nested imports, without aliases and from statement:: import foo.bar r,)boolrrVrs r2rzImportName.is_nestedsL$*?*?*A8*A;4}TQ*A89 98s= cBtd|jDS)z= :return list of Name: Returns all the alias c34K|]\}}| ||dfyw)Nrr!)rrrs r2rz&ImportName._aliases..s+*9P+$(DH%9Ps)rrrKs r2rzzImportName._aliasess&*9N9N9P** *r4Nr) r5r6r7rEr"r8rr_rrrrrzr!r4r2rrs>L DIMA3(9*r4rc<eZdZdZdZedZedZddZy)KeywordStatementz 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 d|jzS)z Keyword statements start with the keyword and end with `_stmt`. You can crosscheck this with the Python grammar. z%s_stmt)rrKs r2r"zKeywordStatement.types 4<<''r4c4|jdjSNr)r$r^rKs r2rzKeywordStatement.keywords}}Q%%%r4c|j}|dk(rt|jd|S|dvr|jdddSgS)Ndelr,)globalnonlocalr)rrhr$)r/r~rs r2rz"KeywordStatement.get_defined_namessL,, e !$--"2OD D , ,==A& & r4Nr) r5r6r7rEr8r_r"rrr!r4r2rrs9I ((&&r4rc eZdZdZedZy) AssertStmtr!c |jdSr(rrKs r2 assertionzAssertStmt.assertionr)r4N)r5r6r7r8r_rr!r4r2rrsI   r4rceZdZdZdZy) GlobalStmtr!c&|jdddS)Nr,rrrKs r2get_global_nameszGlobalStmt.get_global_namess}}QTT""r4N)r5r6r7r8rr!r4r2rrs I#r4rceZdZdZy) ReturnStmtr!Nrcr!r4r2rrrdr4rceZdZdZdZy) YieldExprr.r!Nrr!r4r2rrr`r4rcg}|jdvr(|jdddD]}|t||z }|S|jdvr|t|jd|z }|S|jdvr|jddk7r|jd }|jd d k(r |j|jd|S|jd d k(rl|rj|jddd D]U}|jd k(r!|j|jd|S|jdk(sC|j||S|S|j||S)zk 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_exprrH**rrr[trailerr>)r"r$rhr)currentr~rrrr0s r2rhrhsw 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 Lr4c(eZdZdZdZddZdZdZy)ExprStmtrr!c`g}|jdjdk(rt|jd|}tdt |jdz dDcgc]@}d|j|dzj vr t|j||D]}|Bc}}|zScc}}w)zG Returns a list of `Name` defined before the `=` sign. r, annassignrr=)r$r"rhrangerVr^)r/r~rrr>s r2rzExprStmt.get_defined_namess ==  K /"4==#3_EE1c$--014a8 8dmmAE*000&t}}Q'7I J 8    sAB*c|jd}|jdk(r8t|jdk(r|jd}|S|jd}|S)z*Returns the right-hand-side of the equals.rrrdr,r$r"rVros r2get_rhszExprStmt.get_rhs'sW}}R  99 #4==!Q&}}Q' }}Q' r4c#K|jd}|jdk(r(t|jdkry|jd}||jdddEd{y7w)zZ Returns a generator of `+=`, `=`, etc. or None if there is no operation. r,rrNrdrr/r s r2yield_operatorszExprStmt.yield_operators1sa a  :: $5>>"a'NN1%E ==A&&&sA A*"A(#A*Nr)r5r6r7r"r8rrrr!r4r2rrs DI  'r4rceZdZdZddZy) NamedExprrc4t|jd|Srrgrs r2rzNamedExpr.get_defined_namesCrir4Nr)r5r6r7r"rr!r4r2rr@s DAr4rceZdZdZdZdfd ZedZedZedZ dZ edZ dd Z ed Z d Zdfd Zd ZxZS)r z 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. rc2t||||_yrI)rrr%)r/r$r%rs r2rzParam.__init__Os " r4cT|jd}|dvrt|jSy)zc Is `0` in case of `foo`, `1` in case of `*foo` or `2` in case of `**foo`. rrrrrs r2 star_countzParam.star_countSs,  a  K u{{# #r4c|jddk(} |jdt|z dk(r|jdt|z Sy#t$rYywxYw)z{ The default is the test node that appears after the `=`. Is `None` in case no default is present. rr|rHrN)r$r`r )r/ has_commas r2defaultz Param.default^se MM"%,  }}R#i.01S8}}R#i.%8999  s8A AAc|j}|jdk(r?|jddk(sJt|jdk(sJ|jd}|Sy)zz The default is the test node that appears after `:`. Is `None` in case no annotation is present. rr,r+rdrN)_tfpdefr"r$rV)r/rrDs r2rDzParam.annotationks`  ;;( "??1%, ,,v'1, ,,+J r4cTt|jddv}|j|S)z1 tfpdef: see e.g. grammar36.txt. rr)r`r$)r/offsets r2rz Param._tfpdefzs+T]]1%45}}V$$r4c|jjdk(r|jjdS|jS)z/ The `Name` leaf of the param. rr)rr"r$rKs r2r>z Param.names; <<>  ( *<<>**1- -<<> !r4c|jgSrI)r>rs r2rzParam.get_defined_namess {r4cZ|jjj|} |jjjd}||kDr|dz} |jjjd}||kDr|dz}|dz S#t$rY@wxYw#t$rY|dz SwxYw)zB Property for the positional index of a paramter. rrrr,)r%r$r.rv)r/r.keyword_only_indexs r2position_indexzParam.position_indexs  $$**40 !%!5!5!;!;C!@ ))  !%!5!5!;!;C!@ )) qy     qy s#/B /B BB B*)B*c&|jddS)z= Returns the function/lambda of a parameter. r)r,)r rKs r2get_parent_functionzParam.get_parent_functions##Iy99r4c~|rt||S|j}|ddk(r|dd}|j||S)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. rr|N)include_prefix)rget_coder$_get_code_for_children)r/r include_commar$rs r2rzParam.get_codesV 7#N3 3== B<3 }H** )+  r4c|jdnd|jjz}dt|jdt |j |zdS)Nrz=%srorwrp)rrr"r5r9r)r/rs r2rrzParam.__repr__sI ,"%$,,:O:O:Q2Q!$Z00#dlln2E2OPPr4rIr)TT)r5r6r7rEr"rr_rrrDrr>rrrrrrrrs@r2r r Gs D    %""*:  $Qr4r ceZdZdZdZddZy) SyncCompForrr!c4t|jd|S)zN Returns the a list of `Name` that the comprehension defines. r,rgrs r2rzSyncCompFor.get_defined_namess dmmA.@@r4Nr)r5r6r7r"r8rr!r4r2rrs DIAr4rc4eZdZdZdZdZdZdZdZdZ y) rzO This class exists for the sole purpose of creating an immutable dict. c||_yrI_dict)r/rs r2rzUsedNamesMapping.__init__s  r4c |j|SrIr)r/keys r2 __getitem__zUsedNamesMapping.__getitem__szz#r4c,t|jSrI)rVrrKs r2__len__zUsedNamesMapping.__len__s4::r4c,t|jSrI)iterrrKs r2__iter__zUsedNamesMapping.__iter__rr4ct|SrI)idrKs r2rzUsedNamesMapping.__hash__s $xr4c ||uSrIr!rs r2rzUsedNamesMapping.__eq__s u}r4N) r5r6r7rErrrrrrr!r4r2rrs% r4r)IrErcollections.abcrtypingrr parso.treerrrr r r parso.python.prefixr parso.utilsr set_FLOW_CONTAINERSr6rrrr r<rGrZrbrfrhrjrlrtryrrrrrrrrrrrrrrrrrFrOrQr_rbrkrrryrrrrrrrrhrrr rCompForrr!r4r2rs*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 wr4