B S\@sdZddlZddlZddlZddlZddlmZddlmZ ddl m Z ddl m Z ddl m Zddl mZdd l mZdd l mZdd l mZdd l mZejZeZejdd dZdddZeZdddZdddZdddZdde dgdgdgdgdgdgdgd gd!gd"d#gd$d%gd&d'd(d)d*gd+gd,gd-ggDZ!Gd.d/d/Z"Gd0d1d1e"Z#Gd2d3d3ej$e"e j%ej&d4Z'Gd5d6d6Z(Gd7d8d8ej)e(ej$e"Z*Gd9d:d:ej)e(ej$e"Z+Gd;d<dd>ej-e"Z.dd@dAZ/ddBdCZ0GdDdEdEej$e"Z1GdFdGdGe#Z2GdHdIdIej-e#Z3GdJdKdKej-e#Z4GdLdMdMej-e#Z5GdNdOdOe"Z6GdPdQdQe"Z7GdRdSdSe"Z8GdTdUdUej)e#Z9GdVdWdWe"Z:GdXdde"Z;GdYdZdZe"ZGd_d`d`e"Z?Gdadbdbej$e"Z@Gdcddddej-e#ZAGdedfdfe"e j%ZBGdgdhdhe#ZCGdidjdjej)e"ZDGdkdldlej)e"ZEGdmdndnejFej-e#ZGGdodpdpe#ZHGdqdrdre"ZIGdsdtdtejFejJej-e#ZKGdudvdveKZLGdwd-d-e"ZMGdxdydyej)ejNe#ZOGdzd{d{e"ZPGd|d}d}ej)e#ZQGd~ddejFejJe#ZRGddde"ZSGdddej)ejNe#ZTGddde"ZUGddde"ZVGddde'ZWGdddej)e#ZXGdddej)e#ZYGddde#ZZGddde#Z[Gddde#Z\Gddde'Z]Gddde"Z^Gdddej$e"Z_Gddde"Z`GdddejFejJe#ZaGdddejFejJe#ZbGddde'ZcGdd+d+e"ZdGdddejFejJe#ZeGdddejFejJej-e#ZfGdddefZgGddde"ZhGdddehZiGdddej)e"ZjGddde"ZkGddde"ZlGdddej-e"ZmeneWeoecepeBeqe]erde=erese=iZtddZueuddZvddZweWeveceveBewe]eve=ddiZxddZyddZzdS)zsz_infer_slice..z'Could not infer slice used in subscript)messager r,r) r-lowerupperstepallslicerAstroidTypeErrorr)r rr2r3r4rrr _infer_slices    r8c CsyLt|tr6t||d}|}|||_|j|_|St|trJ||jSWnjtk r}zt j d|||d|Wdd}~XYn6t k r}zt j d|||d|Wdd}~XYnXt d|dS)zHGet a slice or an item, using the given *index*, for the given sequence.)rzIndex {index!s} out of range)r1r r,rNzType error {error!r}z#Could not use %s as subscript index) r Slicer8 __class__rrr&r' IndexErrorrAstroidIndexError TypeErrorr7)instancerr,rZ index_sliceZnew_clsexcrrr_container_getitems*     r@cCs i|]\}}|D] }||qqSrr)r.Z precedenceopsoprrr srCZLambdaIfExporandnotCompare|^&z<>+-*@/z//%UnaryOpz**Awaitc@seZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdXddZdYddZd d Zd d Zd dZddZddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Z e!j"d)d*Z#e!j"d+d,Z$d-d.Z%d/d0Z&d1d2Z'dZd3d4Z(e!j)d5d6Z*d7d8Z+d9d:Z,d;d<Z-d=d>Z.d[d?d@Z/dAdBZ0dCdDZ1dEdFZ2dGdHZ3dIdJZ4dKdLZ5d\dPdQZ6dRdSZ7dTdUZ8dVdWZ9dS)]NodeNGzm A node of the new Abstract Syntax Tree (AST). This is the base class for all Astroid node classes. FNrcCs||_||_||_dS)aa :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)lineno col_offsetr)selfrUrVrrrr__init__9s zNodeNG.__init__cKs|dk r|j||}|jdk rHy|j||f|Stjk rFYnX|sZ|j|f|S||j|j|jf}||j krt |j |S| ||j|f|}t |tjS)aVGet a generator of the inferred values. This is the main entry point to the inference system. .. seealso:: :ref:`inference` If the instance has some explicit inference function set, it will be called instead of the default interface. :returns: The inferred values. :rtype: iterable N)Z extra_contextget_explicit_inferencerZUseInferenceDefault_inferZ lookupnameZ callcontextZ boundnoderiterZcache_generatorr Zlimit_inferenceMANAGERZmax_inferable_values)rWrkwargskeygenrrrrIs   z NodeNG.infercs6ddh}tfdd|Dr2tdtddSdS)zGet a name for nice representation. This is either :attr:`name`, :attr:`attrname`, or the empty string. :returns: The nice name. :rtype: str nameattrnamec3s|]}|jkVqdS)N)_astroid_fields)r.ra)rWrrr0ssz$NodeNG._repr_name..)r5getattr)rWnamesr)rWr _repr_namejszNodeNG._repr_namec Cs|}t|j}|r0d}t|t|d}nd}t|d}g}x|j|jD]~}t||}dt||}tj|d|d d} | dg} x&| ddD]} | d || qW| d |d | fqRW|||d d | |d S)Nz%(cname)s.%(rname)s(%(fields)s)z%(cname)s(%(fields)s)rP)indentwidthTr z%s=%srdz, )cnamernamefields) rgr)__name__len _other_fieldsrcrepprintpformat splitlinesappendjoin) rWrnrmstringZ alignmentresultfieldr'rklinesinnerlinerrr__str__ws(    zNodeNG.__str__cCs4|}|rd}nd}|t|j||jt|dS)Nz.<%(cname)s.%(rname)s l.%(lineno)s at 0x%(id)x>z$<%(cname)s l.%(lineno)s at 0x%(id)x>)rmrnrUid)rgr)rp fromlinenor)rWrnrxrrr__repr__szNodeNG.__repr__cCst|d|jj}||S)z(Visit this node using the given visitor.Zvisit_)rer:rpr2)rWZvisitorfuncrrracceptsz NodeNG.acceptccsHxB|jD]8}t||}|dkr qt|ttfr:|EdHq|VqWdS)zoGet the child nodes below this node. :returns: The children. :rtype: iterable(NodeNG) N)rcrer listtuple)rWrzattrrrr get_childrens   zNodeNG.get_childrencCsFx@|jdddD],}t||}|s&qt|ttfr<|dS|SWdS)zAn optimized version of list(get_children())[-1] :returns: The last child, or None if no children exist. :rtype: NodeNG or None N)rcrer rr)rWrzrrrr last_childs zNodeNG.last_childcCs*|j}x|dk r$||krdS|j}qWdS)a Check if this node is the parent of the given node. :param node: The node to check if it is the child. :type node: NodeNG :returns: True if this node is the parent of the given node, False otherwise. :rtype: bool NTF)r)rWr rrrr parent_ofs   zNodeNG.parent_ofcCs|jr |S|jS)zThe first parent node, including self, marked as statement node. :returns: The first parent statement. :rtype: NodeNG ) is_statementr statement)rWrrrrszNodeNG.statementcCs |jS)zThe first parent frame node. A frame node is a :class:`Module`, :class:`FunctionDef`, or :class:`ClassDef`. :returns: The first parent frame node. :rtype: Module or FunctionDef or ClassDef )rframe)rWrrrrs z NodeNG.framecCs |jS)zThe first parent node defining a new scope. :returns: The first parent scope node. :rtype: Module or FunctionDef or ClassDef or Lambda or GenExpr )rscope)rWrrrrsz NodeNG.scopecCs|jr|jS|S)zjReturn the root node of the syntax tree. :returns: The root node. :rtype: Module )rroot)rWrrrrs z NodeNG.rootcCsdx@|jD]6}t||}||kr$|gSt|ttfr||kr|SqWd}t|t|t|fdS)a_Search for the sequence that contains this child. :param child: The child node to search sequences for. :type child: NodeNG :returns: The sequence containing the given child node. :rtype: iterable(NodeNG) :raises AstroidError: If no sequence could be found that contains the given child. z"Could not find %s in %s's childrenN)rcrer rrr AstroidErrorrepr)rWchildrznode_or_sequencemsgrrrchild_sequences  zNodeNG.child_sequencecCsjxF|jD]<}t||}||kr&||fSt|ttfr||kr||fSqWd}t|t|t|fdS)aFind the field of this node that contains the given child. :param child: The child node to search fields for. :type child: NodeNG :returns: A tuple of the name of the field that contains the child, and the sequence or node that contains the child node. :rtype: tuple(str, iterable(NodeNG) or NodeNG) :raises AstroidError: If no field could be found that contains the given child. z"Could not find %s in %s's childrenN)rcrer rrrrr)rWrrzrrrrrr!s   zNodeNG.locate_childcCs |jS)z|The next sibling statement node. :returns: The next sibling statement node. :rtype: NodeNG or None )r next_sibling)rWrrrr1szNodeNG.next_siblingcCs |jS)zThe previous sibling statement. :returns: The previous sibling statement node. :rtype: NodeNG or None )rprevious_sibling)rWrrrr9szNodeNG.previous_siblingcCsj|}|j}d}xN|D]F}||ks8td||f|j}|j|krJP||dkr||f}qW|dS)aGet the node closest to this one from the given list of nodes. :param nodes: The list of nodes to search. All of these nodes must belong to the same module as this one. The list should be sorted by the line number of the nodes, smallest first. :type nodes: iterable(NodeNG) :returns: The node closest to this one in the source code, or None if one could not be found. :rtype: NodeNG or None )Nrz,nodes %s and %s are not from the same modulerr)rrAssertionError)rWnodesZmyrootmylinenonearestr rUrrrrAs     zNodeNG.nearestcCs|jdkr|S|jS)zaThe first line that this node appears on in the source code. :type: int or None N)rU_fixed_source_line)rWrrrr_s zNodeNG.fromlinenocCs(|js d}n|}|dkr"|jS|jS)z`The last line that this node appears on in the source code. :type: int or None N)rcrrtolineno)rWZ lastchildrrrrjs zNodeNG.tolinenocCsl|j}|}y$x|dkr*t|}|j}qWWn8tk rf|j}x|r`|dkr`|j}|j}qFWYnX|S)aAttempt to find the line that this node appears on. We need this method since not all nodes have :attr:`lineno` set. :returns: The line number of this node, or None if this could not be determined. :rtype: int or None N)rUrr StopIterationr)rWr}Z_noderrrrzs   zNodeNG._fixed_source_linecCs ||jfS)a@Get a range from the given line number to where this node ends. :param lineno: The line number to start the range at. :type lineno: int :returns: The range of line numbers that this node belongs to, starting at the given line number. :rtype: tuple(int, int or None) )r)rWrUrrr block_ranges zNodeNG.block_rangecCs|j||dS)aWDefine that the given name is declared in the given statement node. This definition is stored on the parent scope node. .. seealso:: :meth:`scope` :param name: The name that is being defined. :type name: str :param stmt: The statement that defines the given name. :type stmt: NodeNG N)r set_local)rWrarrrrrs zNodeNG.set_localccstt||r|V|dkr@x"|D]}|||EdHq"WdSx.|D]"}t||rZqJ|||EdHqJWdS)aGet the nodes (including this one or below) of the given type. :param klass: The type of node to search for. :type klass: builtins.type :param skip_klass: A type of node to ignore. This is useful to ignore subclasses of :attr:`klass`. :type skip_klass: builtins.type :returns: The node of the given type. :rtype: iterable(NodeNG) N)r rnodes_of_class)rWklassZ skip_klass child_noderrrrs  zNodeNG.nodes_of_classcCsgS)Nr)rWrrr_get_assign_nodesszNodeNG._get_assign_nodesccs$x|D]}|EdHq WdS)N)r_get_name_nodes)rWrrrrrszNodeNG._get_name_nodesccsdEdHdS)Nrr)rWrrr _get_return_nodes_skip_functionssz'NodeNG._get_return_nodes_skip_functionsccsdEdHdS)Nrr)rWrrr_get_yield_nodes_skip_lambdassz$NodeNG._get_yield_nodes_skip_lambdascCsdS)Nr)rWrrarrr _infer_nameszNodeNG._infer_namecCstjd||ddS)z3we don't know how to resolve a statement by defaultz#No inference function for {node!r}.)r rN)rr*)rWrrrrr[sz NodeNG._infercCs t|S)zGet a list of the inferred values. .. seealso:: :ref:`inference` :returns: The inferred values. :rtype: list )rr)rWrrrrszNodeNG.inferredcCs|S)zInstantiate an instance of the defined class. .. note:: On anything other than a :class:`ClassDef` this will return self. :returns: An instance of the defined class. :rtype: object r)rWrrrinstantiate_classs zNodeNG.instantiate_classcCsdS)zCheck if this node inherits from the given type. :param node: The node defining the base to look for. Usually this is a :class:`Name` node. :type node: NodeNG Fr)rWr rrrhas_baseszNodeNG.has_basecCsdS)zWhether this node defines something that is callable. :returns: True if this defines something that is callable, False otherwise. :rtype: bool Fr)rWrrrcallableszNodeNG.callablecCsdS)NFr)rWr'rrreqsz NodeNG.eqcCs t|S)zoGet the source code that this node represents. :returns: The source code. :rtype: str )rZto_code)rWrrrr szNodeNG.as_string rric sttd fdd ttd fdd }td fdd }g} || td| S) aGet a string representation of the AST from this node. :param ids: If true, includes the ids with the node type names. :type ids: bool :param include_linenos: If true, includes the line numbers and column offsets. :type include_linenos: bool :param ast_state: If true, includes information derived from the whole AST like local and global variables. :type ast_state: bool :param indent: A string to use to indent the output string. :type indent: str :param max_depth: If set to a positive integer, won't return nodes deeper than max_depth in the string. :type max_depth: int :param max_width: Attempt to format the output string to stay within this number of characters, but can exceed it under some circumstances. Only positive integer values are valid, the default is 80. :type max_width: int :returns: The string representation of the AST. :rtype: str rdrcs\tj|ttddd}||d|fdd|ddDt|dkS)zOutputs a representation of a non-tuple/list, non-node that's contained within an AST, including strings. r)rkTrcsg|] }|qSrr)r.r}) cur_indentrr Asz8NodeNG.repr_tree.._repr_tree..N)rsrtmaxrqrurvextend)r rydonerdepthr{) max_width)rr _repr_tree8s  z$NodeNG.repr_tree.._repr_treecs|7}|d|sd}nt|dkr>|d||||}nt|dkr|d||||}|sn|dn|d|||d||||p|}nf|d||x8|d d D](}||||||d||qW|d ||||d }|d |S) zFOutputs a representation of a sequence that's contained within an AST.[Frrrhz, z,  NrT])rvrq)r ryrrrbrokenr)rrjrr _repr_seqEs.          z#NodeNG.repr_tree.._repr_seqcs||kr,|dt|jt|fdS||rP|krP|ddS|d7}|7}r|dt|jt|fn|dt|jg}r|d||j||jr||j|sd}nt |dkr|d|d t ||d ||||}n|d ||xN|d d D]>}|d|t |||||||d ||q8W|d|d t ||d ||||d}|d|S)z4Outputs a strings representation of an astroid node.z( z%s()rUrVz%s=rrNrz, T)) rvr)rpraddrrrrc_other_other_fieldsrqre)r ryrrrrorrz)r ast_stateidsinclude_linenosrj max_depthrr _repr_nodedsN           z$NodeNG.repr_tree.._repr_node)rdr)rdr)rdr)_singledispatchregisterrrrTsetrw) rWrrrrjrrrrryr)rrrrrjrrr repr_trees& /zNodeNG.repr_treecCstjS)akDetermine the boolean value of this node. The boolean value of a node can have three possible values: * False: For instance, empty data structures, False, empty strings, instances which return explicitly False from the __nonzero__ / __bool__ method. * True: Most of constructs are True by default: classes, functions, modules etc * Uninferable: The inference engine is uncertain of the node's value. :returns: The boolean value of this node. :rtype: bool or Uninferable )r r)rWrrr bool_valueszNodeNG.bool_valuecCst|jjttS)N) OP_PRECEDENCErYr:rprq)rWrrr op_precedenceszNodeNG.op_precedencecCsdS)NTr)rWrrrop_left_associativeszNodeNG.op_left_associative)NNN)N)N)N)FFFrrri):rp __module__ __qualname____doc__roptional_assign is_function is_lambdarUrVrrcrrrrZrXrrgr~rrrrrrrrrrr!rrrrcachedpropertyrrrrrrcachedrrrrrr[rrrrrrrrrrrrrrrTsr   !               rTc@s$eZdZdZdZddZddZdS) Statementz&Statement node adding a few attributesTcCs<|j|}||}y ||dStk r6YnXdS)z|The next sibling statement node. :returns: The next sibling statement node. :rtype: NodeNG or None rN)rrr,r;)rWstmtsr,rrrrs    zStatement.next_siblingcCs.|j|}||}|dkr*||dSdS)zThe previous sibling statement. :returns: The previous sibling statement node. :rtype: NodeNG or None rN)rrr,)rWrr,rrrrs    zStatement.previous_siblingN)rprrrrrrrrrrrs rcsbeZdZdZdZdfdd ZddZeddd Zd d Z d d Z e j ddZ ddZZS)_BaseContainerz.Base class for Set, FrozenSet, Tuple and List.)rNcsg|_tt||||dS)aa :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rsuperrrX)rWrUrVr)r:rrrXs z_BaseContainer.__init__cCs ||_dS)zDo some setup after initialisation. :param elts: The list of elements the that node contains. :type elts: list(NodeNG) N)r)rWrrrrpostinitsz_BaseContainer.postinitcCs*|}|dkrg|_ndd|D|_|S)aCreate a node of this type from the given list of elements. :param elts: The list of elements that the node should contain. :type elts: list(NodeNG) :returns: A new node containing the given elements. :rtype: NodeNG NcSsg|] }t|qSr) const_factory)r.errrr sz1_BaseContainer.from_constants..)r)clsrr rrrfrom_constantss z_BaseContainer.from_constantscCs|jS)zAn iterator over the elements this node contains. :returns: The contents of this node. :rtype: iterable(NodeNG) )r)rWrrritered sz_BaseContainer.iteredcCs t|jS)zDetermine the boolean value of this node. :returns: The boolean value of this node. :rtype: bool or Uninferable )boolr)rWrrrrsz_BaseContainer.bool_valuecCsdS)zyGet the name of the type that this node represents. :returns: The name of the type. :rtype: str Nr)rWrrrpytypesz_BaseContainer.pytypeccs|jEdHdS)N)r)rWrrrr$sz_BaseContainer.get_children)NNN)N)rprrrrcrXr classmethodrrrabcabstractmethodrr __classcell__rr)r:rrs r) metaclassc@s:eZdZdZeddddZddZdd Zd d ZdS) LookupMixInz+Mixin to look up a name in the right scope.N)maxsizecCs|||S)adLookup where the given variable is assigned. The lookup starts from self's scope. If self is not a frame itself and the name is found in the inner frame locals, statements will be filtered to remove ignorable statements according to self's location. :param name: The name of the variable to find assignments for. :type name: str :returns: The scope node and the list of assignments associated to the given name according to the scope where it has been found (locals, globals or builtin). :rtype: tuple(str, list(NodeNG)) )rZ scope_lookup)rWrarrrlookup+szLookupMixIn.lookupcCs$||\}}t}t|||S)a Lookup the inferred values of the given variable. :param name: The variable name to find values for. :type name: str :returns: The inferred values of the statements returned from :meth:`lookup`. :rtype: iterable )r contextmodZInferenceContextrZ _infer_stmts)rWrarrrrrrilookup=s zLookupMixIn.ilookupcsBdd|D}t|dkr>tdd|Dr>fdd|D}|S)NcSsg|]}||fqSr)r)r.r rrrrLsz=LookupMixIn._get_filtered_node_statements..rcss|]\}}t|tVqdS)N)r ExceptHandler)r._rrrrr0Psz.cs"g|]\}}|r||fqSr)r)r.r r)rWrrrSs)rqr5)rWr statementsr)rWr_get_filtered_node_statementsKs z)LookupMixIn._get_filtered_node_statementsc Cs6|dkr|j}n$|}||kr<|jr<|j}|}||krt|jdk rt|jdk sht||j|}nd}g}g}||} x| D]\} } | j|krdkrnnP|| krt|rqt| dst| | | j f| } | |rP| || ||\}} | rP| j }|rF| |rF| g}| jg}qy|| j}Wntk rlYnbX|| | rq|st||| s| jr| dks| j||jkr||=||=t| tr|s| j|jkrg}g}nt| trg}g}qt|| s|| || jqW|S)apFilter the given list of statements to remove ignorable statements. If self is not a frame itself and the name is found in the inner frame locals, statements will be filtered to remove ignorable statements according to self's location. :param stmts: The statements to filter. :type stmts: list(NodeNG) :param frame: The frame that all of the given statements belong to. :type frame: NodeNG :param offset: The line offset to filter statements up to. :type offset: int :returns: The filtered statements. :rtype: list(NodeNG) rNr assign_typeZPartialFunction)rrrrrris_from_decoratorhasattrrlocalsrr_get_filtered_stmtsrrr, ValueErrorr%rqnamerar AssignNameDelNamerv)rWrroffsetZmyframemystmtrZ_stmtsZ _stmt_parentsrr rrrrZpindexrrr _filter_stmtsWsr          zLookupMixIn._filter_stmts) rprrrrrrrrrrrrr(s  rcs&eZdZdZdZdfdd ZZS)raVariation of :class:`ast.Assign` representing assignment to a name. An :class:`AssignName` is the name of something that is assigned to. This includes variables defined in a function signature or in a loop. >>> node = astroid.extract_node('variable = range(10)') >>> node >>> list(node.get_children()) [, ] >>> list(node.get_children())[0].as_string() 'variable' )raNcs||_tt||||dS)a :param name: The name that is assigned to. :type name: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rarrrX)rWrarUrVr)r:rrrXszAssignName.__init__)NNNN)rprrrrrrXrrr)r:rrsrcs&eZdZdZdZdfdd ZZS)raQVariation of :class:`ast.Delete` representing deletion of a name. A :class:`DelName` is the name of something that is deleted. >>> node = astroid.extract_node("del variable #@") >>> list(node.get_children()) [] >>> list(node.get_children())[0].as_string() 'variable' )raNcs||_tt||||dS)a :param name: The name that is being deleted. :type name: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rarrrX)rWrarUrVr)r:rrrX(szDelName.__init__)NNNN)rprrrrrrXrrr)r:rrs rcs.eZdZdZdZdfdd ZddZZS) NameaClass representing an :class:`ast.Name` node. A :class:`Name` node is something that is named, but not covered by :class:`AssignName` or :class:`DelName`. >>> node = astroid.extract_node('range(10)') >>> node >>> list(node.get_children()) [, ] >>> list(node.get_children())[0].as_string() 'range' )raNcs||_tt||||dS)a :param name: The name that this node refers to. :type name: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rarrrX)rWrarUrVr)r:rrrXQsz Name.__init__ccs*|Vx|D]}|EdHqWdS)N)rr)rWrrrrrhszName._get_name_nodes)NNNN)rprrrrrrXrrrr)r:rr@s rcseZdZdZdZdZdZdZdfdd ZdddZ d d Z e j fd d Z d dZddZddZdddZddZZS) Argumentsa;Class representing an :class:`ast.arguments` node. An :class:`Arguments` node represents that arguments in a function definition. >>> node = astroid.extract_node('def foo(bar): pass') >>> node >>> node.args )argsdefaults kwonlyargs kw_defaults annotationsvarargannotationkwargannotationkwonlyargs_annotationsN)varargkwargcsFtt|j|d||_||_g|_g|_g|_g|_g|_ g|_ dS)a9 :param vararg: The name of the variable length arguments. :type vararg: str or None :param kwarg: The name of the variable length keyword arguments. :type kwarg: str or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None )rN) rrrXrrrrrrrr)rWrrr)r:rrrXs zArguments.__init__c Cs4||_||_||_||_||_||_||_||_dS)aDo some setup after initialisation. :param args: The names of the required arguments. :type args: list(AssignName) :param defaults: The default values for arguments that can be passed positionally. :type defaults: list(NodeNG) :param kwonlyargs: The keyword arguments that cannot be passed positionally. :type kwonlyargs: list(AssignName) :param kw_defaults: The default values for keyword arguments that cannot be passed positionally. :type kw_defaults: list(NodeNG) :param annotations: The type annotations of arguments that can be passed positionally. :type annotations: list(NodeNG) :param kwonlyargs_annotations: The type annotations of arguments that cannot be passed positionally. This should always be passed in Python 3. :type kwonlyargs_annotations: list(NodeNG) :param varargannotation: The type annotation for the variable length arguments. :type varargannotation: NodeNG :param kwargannotation: The type annotation for the variable length keyword arguments. :type kwargannotation: NodeNG N)rrrrrrrr) rWrrrrrrrrrrrrs-zArguments.postinitcCs|j|kr|SdS)N)r)rWrrarrrrs zArguments._infer_namecstt|j}t||jjpdS)zaThe first line that this node appears on in the source code. :type: int or None r)rrrrr)rWrU)r:rrrs zArguments.fromlinenoc Csg}|jr(|t|j|jt|dd|jr>|d|j|jrl|jsT|d|t|j|j|j|j r|d|j d |S)zoGet the arguments formatted as string. :returns: The formatted arguments. :rtype: str rNz*%srNz**%sz, ) rrv _format_argsrrerrrrrrw)rWryrrr format_argss  zArguments.format_argscCst||jd}|dk rB|t|jt|j}|dkrB|j|St||jd}|dk rr|j|dk rr|j|Stj|j|ddS)zGet the default value for an argument. :param argname: The name of the argument to get the default value for. :type argname: str :raises NoDefault: If there is no default value defined for the given argument. rN)rra) _find_argrrqrrrrZ NoDefaultr)rWargnameiidxrrr default_value9s   zArguments.default_valuecCsL||jkrdS||jkrdS||dddk pJ|joJt||jdddk S)zCheck if the given name is defined in the arguments. :param name: The name to check for. :type name: str :returns: True if the given name is defined in the arguments, False otherwise. :rtype: bool TrN)rr find_argnamerr)rWrarrr is_argumentLs  zArguments.is_argumentFcCs|jrt||j|SdS)aGet the index and :class:`AssignName` node for given name. :param argname: The name of the argument to search for. :type argname: str :param rec: Whether or not to include arguments in unpacked tuples in the search. :type rec: bool :returns: The index and node for the argument. :rtype: tuple(str or None, AssignName or None) )NN)rr)rWrrecrrrr `s zArguments.find_argnameccs|jpdEdH|jEdH|jEdHx|jD]}|dk r0|Vq0Wx|jD]}|dk rN|VqNW|jdk rv|jV|jdk r|jVx|jD]}|dk r|VqWdS)Nr)rrrrrrrr)rWrrrrrqs          zArguments.get_children)NNN)NNN)F)rprrrrcrrrrrXrrrrrrr r r rrrr)r:rros   C -  rFcCsXxRt|D]F\}}t|tr>|rPt||j}|ddk rP|Sq |j|kr ||fSq WdS)Nr)NN) enumerater rrrra)rrrr argfoundrrrrs     rc Csg}|dkrdS|dkrg}|dk r4t|t|}t||}xt|D]\}\}}t|trv|dt|jqJ|j } |dk r| d| 7} || |dk rJ||krJ|||dk rJ|dd||| 7<qJWd |S)Nrdz(%s):r=z, ) rq itertools zip_longestrr rrvrrrarrw) rrrvaluesZdefault_offsetZpackedr r annotationrrrrrs&   $rcs@eZdZdZdZdZdZd fdd Zd ddZd d Z Z S) AssignAttrazVariation of :class:`ast.Assign` representing assignment to an attribute. >>> node = astroid.extract_node('self.attribute = range(10)') >>> node >>> list(node.get_children()) [, ] >>> list(node.get_children())[0].as_string() 'self.attribute' )expr)rbNcs||_tt||||dS)a :param attrname: The name of the attribute being assigned to. :type attrname: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rbrrrX)rWrbrUrVr)r:rrrXszAssignAttr.__init__cCs ||_dS)zDo some setup after initialisation. :param expr: What has the attribute that is being assigned to. :type expr: NodeNG or None N)r)rWrrrrrszAssignAttr.postinitccs |jVdS)N)r)rWrrrrszAssignAttr.get_children)NNNN)N) rprrrrcrrrrXrrrrr)r:rrs  rc@s.eZdZdZdZdZdZdddZddZdS) AssertzClass representing an :class:`ast.Assert` node. An :class:`Assert` node represents an assert statement. >>> node = astroid.extract_node('assert len(things) == 10, "Not enough things"') >>> node )testfailNcCs||_||_dS)zDo some setup after initialisation. :param test: The test that passes or fails the assertion. :type test: NodeNG or None :param fail: The message shown when the assertion fails. :type fail: NodeNG or None N)rr)rWrrrrrrs zAssert.postinitccs|jV|jdk r|jVdS)N)rr)rWrrrrs zAssert.get_children)NN) rprrrrcrrrrrrrrrs  rc@sLeZdZdZdZdZdZdZdZd ddZ ddZ e j d d Z d d ZdS)AssignzClass representing an :class:`ast.Assign` node. An :class:`Assign` is a statement where something is explicitly asssigned to. >>> node = astroid.extract_node('variable = range(10)') >>> node )targetsr')type_annotationNcCs||_||_||_dS)zDo some setup after initialisation. :param targets: What is being assigned to. :type targets: list(NodeNG) or None :param value: The value being assigned to the variables. :type: NodeNG or None N)rr'r)rWrr'rrrrr+s zAssign.postinitccs|jEdH|jVdS)N)rr')rWrrrr8s zAssign.get_childrencCs|gt|jS)N)rr'r)rWrrrr=szAssign._get_assign_nodesccs|jEdHdS)N)r'r)rWrrrrAsz$Assign._get_yield_nodes_skip_lambdas)NNN)rprrrrcrrr'rrrrrrrrrrrrs  rc@s:eZdZdZdZdZdZdZdZdZ d ddZ ddZ dS) AnnAssignzClass representing an :class:`ast.AnnAssign` node. An :class:`AnnAssign` is an assignment with a type annotation. >>> node = astroid.extract_node('variable: List[int] = range(10)') >>> node )targetrr')simpleNcCs||_||_||_||_dS)aDo some setup after initialisation. :param target: What is being assigned to. :type target: NodeNG :param annotation: The type annotation of what is being assigned to. :type: NodeNG :param simple: Whether :attr:`target` is a pure name or a complex statement. :type simple: int :param value: The value being assigned to the variables. :type: NodeNG or None N)r!rr'r")rWr!rr"r'rrrrfszAnnAssign.postinitccs&|jV|jV|jdk r"|jVdS)N)r!rr')rWrrrr{s zAnnAssign.get_children)N) rprrrrcrrr!rr'r"rrrrrrr Es r csXeZdZdZdZdZdZdZdfdd ZdddZ dd d Z dd d Z d dZ Z S) AugAssignzClass representing an :class:`ast.AugAssign` node. An :class:`AugAssign` is an assignment paired with an operator. >>> node = astroid.extract_node('variable += 1') >>> node )r!r')rBNcs||_tt||||dS)a :param op: The operator that is being combined with the assignment. This includes the equals sign. :type op: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rBrr#rX)rWrBrUrVr)r:rrrXszAugAssign.__init__cCs||_||_dS)zDo some setup after initialisation. :param target: What is being assigned to. :type target: NodeNG or None :param value: The value being assigned to the variable. :type: NodeNG or None N)r!r')rWr!r'rrrrs zAugAssign.postinitcCstdS)N)NotImplementedError)rWrrrr_infer_augassignszAugAssign._infer_augassigncCs6y|j|d}dd|DStjk r0gSXdS)a&Get a list of type errors which can occur during inference. Each TypeError is represented by a :class:`BadBinaryOperationMessage` , which holds the original exception. :returns: The list of possible type errors. :rtype: list(BadBinaryOperationMessage) )rcSsg|]}t|tjr|qSr)r r BadBinaryOperationMessage)r.ryrrrrsz)AugAssign.type_errors..N)r%rr*)rWrresultsrrr type_errorss  zAugAssign.type_errorsccs|jV|jVdS)N)r!r')rWrrrrszAugAssign.get_children)NNNN)NN)N)N)rprrrrcrrr!r'rXrr%r(rrrr)r:rr#s  r#c@s"eZdZdZdZdZdddZdS)RepraClass representing an :class:`ast.Repr` node. A :class:`Repr` node represents the backtick syntax, which is a deprecated alias for :func:`repr` removed in Python 3. >>> node = astroid.extract_node('`variable`') >>> node )r'NcCs ||_dS)zDo some setup after initialisation. :param value: What is having :func:`repr` called on it. :type value: NodeNG or None N)r')rWr'rrrrsz Repr.postinit)N)rprrrrcr'rrrrrr)s r)csheZdZdZdZdZdZdZdfdd ZdddZ dd d Z dd d Z d dZ ddZ ddZZS)BinOpzClass representing an :class:`ast.BinOp` node. A :class:`BinOp` node is an application of a binary operator. >>> node = astroid.extract_node('a + b') >>> node )leftright)rBNcs||_tt||||dS)a :param op: The operator. :type: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rBrr*rX)rWrBrUrVr)r:rrrXszBinOp.__init__cCs||_||_dS)aDo some setup after initialisation. :param left: What is being applied to the operator on the left side. :type left: NodeNG or None :param right: What is being applied to the operator on the right side. :type right: NodeNG or None N)r+r,)rWr+r,rrrr%s zBinOp.postinitcCstdS)N)r$)rWrrrr _infer_binop2szBinOp._infer_binopcCs6y|j|d}dd|DStjk r0gSXdS)a%Get a list of type errors which can occur during inference. Each TypeError is represented by a :class:`BadBinaryOperationMessage`, which holds the original exception. :returns: The list of possible type errors. :rtype: list(BadBinaryOperationMessage) )rcSsg|]}t|tjr|qSr)r r r&)r.ryrrrrAsz%BinOp.type_errors..N)r-rr*)rWrr'rrrr(5s  zBinOp.type_errorsccs|jV|jVdS)N)r+r,)rWrrrrHszBinOp.get_childrencCs t|jS)N)rrB)rWrrrrLszBinOp.op_precedencecCs |jdkS)Nz**)rB)rWrrrrOszBinOp.op_left_associative)NNNN)NN)N)N)rprrrrcrrr+r,rXrr-r(rrrrrr)r:rr*s  r*csHeZdZdZdZdZdZd fdd ZdddZd d Z d d Z Z S)BoolOpzClass representing an :class:`ast.BoolOp` node. A :class:`BoolOp` is an application of a boolean operator. >>> node = astroid.extract_node('a and b') >>> node )r)rBNcs||_tt||||dS)a :param op: The operator. :type: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rBrr.rX)rWrBrUrVr)r:rrrXfszBoolOp.__init__cCs ||_dS)zDo some setup after initialisation. :param values: The values being applied to the operator. :type values: list(NodeNG) or None N)r)rWrrrrr}szBoolOp.postinitccs|jEdHdS)N)r)rWrrrrszBoolOp.get_childrencCs t|jS)N)rrB)rWrrrrszBoolOp.op_precedence)NNNN)N) rprrrrcrrrrXrrrrrr)r:rr.Ts r.c@seZdZdZdS)BreakzClass representing an :class:`ast.Break` node. >>> node = astroid.extract_node('break') >>> node N)rprrrrrrrr/sr/c@sJeZdZdZdZdZdZdZd ddZe ddZ e dd Z d d Z dS) CallzClass representing an :class:`ast.Call` node. A :class:`Call` node is a call to a function, method, etc. >>> node = astroid.extract_node('function()') >>> node )rrkeywordsNcCs||_||_||_dS)abDo some setup after initialisation. :param func: What is being called. :type func: NodeNG or None :param args: The positional arguments being given to the call. :type args: list(NodeNG) or None :param keywords: The keyword arguments being given to the call. :type keywords: list(NodeNG) or None N)rrr1)rWrrr1rrrrs z Call.postinitcCs|jpg}dd|DS)zVThe positional arguments that unpack something. :type: list(Starred) cSsg|]}t|tr|qSr)r Starred)r.rrrrrsz!Call.starargs..)r)rWrrrrstarargss z Call.starargscCs|jpg}dd|DS)zSThe keyword arguments that unpack something. :type: list(Keyword) cSsg|]}|jdkr|qS)N)r)r.keywordrrrrszCall.kwargs..)r1)rWr1rrrr^s z Call.kwargsccs(|jV|jEdH|jpdEdHdS)Nr)rrr1)rWrrrrs zCall.get_children)NNN) rprrrrcrrr1rpropertyr3r^rrrrrr0s  r0c@s6eZdZdZdZdZdZd ddZddZdd Z dS) rHa5Class representing an :class:`ast.Compare` node. A :class:`Compare` node indicates a comparison. >>> node = astroid.extract_node('a <= b <= c') >>> node >>> node.ops [('<=', ), ('<=', )] )r+rANcCs||_||_dS)aHDo some setup after initialisation. :param left: The value at the left being applied to a comparison operator. :type left: NodeNG or None :param ops: The remainder of the operators and their relevant right hand value. :type ops: list(tuple(str, NodeNG)) or None N)r+rA)rWr+rArrrrs zCompare.postinitccs&|jVx|jD]\}}|VqWdS)zGet the child nodes below this node. Overridden to handle the tuple fields and skip returning the operator strings. :returns: The children. :rtype: iterable(NodeNG) N)r+rA)rWrZ comparatorrrrr s zCompare.get_childrencCs|jddS)zsAn optimized version of list(get_children())[-1] :returns: The last child. :rtype: NodeNG rr)rA)rWrrrr szCompare.last_child)NN) rprrrrcr+rArrrrrrrrHs   cs`eZdZdZdZdZdZdZdZdZ dfdd Z dddZ d Z d d Z d d ZddZZS) ComprehensionaClass representing an :class:`ast.comprehension` node. A :class:`Comprehension` indicates the loop inside any type of comprehension including generator expressions. >>> node = astroid.extract_node('[x for x in some_values]') >>> list(node.get_children()) [, ] >>> list(node.get_children())[1].as_string() 'for x in some_values' )r!r\ifs)is_asyncNcstt|||_dS)zi :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rr6rXr)rWr)r:rrrX< szComprehension.__init__cCs||_||_||_||_dS)aDo some setup after initialisation. :param target: What is assigned to by the comprehension. :type target: NodeNG or None :param iter: What is iterated over by the comprehension. :type iter: NodeNG or None :param ifs: The contents of any if statements that filter the comprehension. :type ifs: list(NodeNG) or None :param is_async: Whether this is an asynchronous comprehension or not. :type: bool or None N)r!r\r7r8)rWr!r\r7r8rrrrE szComprehension.postinitTcCs|S)zwThe type of assignment that this node performs. :returns: The assignment type. :rtype: NodeNG r)rWrrrr` szComprehension.assign_typecCs@||kr"t|ttfr8|gdfSn||kr8|gdfS|dfS)zmethod used in filter_stmtsTF)r r&rr)rWZ lookup_noder rrrrrrh s    z!Comprehension._get_filtered_stmtsccs |jV|jV|jEdHdS)N)r!r\r7)rWrrrrv szComprehension.get_children)N)NNNN)rprrrrcrrr!r\r7r8rXrrrrrrrr)r:rr6 s  r6cs\eZdZdZdZdfdd ZfddZddd Zd d Zd d Z ddZ ddZ Z S)r&aClass representing any constant including num, str, bool, None, bytes. >>> node = astroid.extract_node('(5, "This is a string.", True, None, b"bytes")') >>> node >>> list(node.get_children()) [, , , , ] )r'Ncs||_tt||||dS)a :param value: The value that the constant represents. :type value: object :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)r'rr&rX)rWr'rUrVr)r:rrrX szConst.__init__cs|dkr tt|S)Nr')AttributeErrorr __getattr__)rWra)r:rrr: szConst.__getattr__c Cst|tr|j}n,t|tr*t||d}ntdt|y"t|jt t fr^t|j|SWnjt k r}ztj d|||d|Wdd}~XYn6t k r}ztjd|||d|Wdd}~XYnXtd||jfdS)a%Get an item from this node if subscriptable. :param index: The node to use as a subscript index. :type index: Const or Slice :raises AstroidTypeError: When the given index cannot be used as a subscript index, or if this node is not subscriptable. )rz(Could not use type {} as subscript indexzIndex {index!r} out of range)r1r r,rNzType error {error!r}z %r (value=%s))r r&r'r9r8rr7formatr)strbytesr;r<r=)rWr,rZ index_valuer?rrrgetitem s*   z Const.getitemcCsdS)aCheck if the node has a custom __getattr__ or __getattribute__. :returns: True if the class has a custom __getattr__ or __getattribute__, False otherwise. For a :class:`Const` this is always ``False``. :rtype: bool Fr)rWrrrhas_dynamic_getattr szConst.has_dynamic_getattrcCst|jtr|jStdS)zAn iterator over the elements this node contains. :returns: The contents of this node. :rtype: iterable(str) :raises TypeError: If this node does not represent something that is iterable. N)r r'r<r=)rWrrrr s z Const.iteredcCs |jS)zyGet the name of the type that this node represents. :returns: The name of the type. :rtype: str )_proxiedr)rWrrrr sz Const.pytypecCs t|jS)zzDetermine the boolean value of this node. :returns: The boolean value of this node. :rtype: bool )rr')rWrrrr szConst.bool_value)NNN)N) rprrrrrrXr:r>r?rrrrrr)r:rr&} s  $  r&c@seZdZdZdS)ContinuezClass representing an :class:`ast.Continue` node. >>> node = astroid.extract_node('continue') >>> node N)rprrrrrrrrA srAc@s0eZdZdZdZdZddZddZdd ZdS) DecoratorsaA node representing a list of decorators. A :class:`Decorators` is the decorators that are applied to a method or function. >>> node = astroid.extract_node(''' @property def my_property(self): return 3 ''') >>> node >>> list(node.get_children())[0] )rNcCs ||_dS)zDo some setup after initialisation. :param nodes: The decorators that this node contains. :type nodes: list(Name or Call) N)r)rWrrrrr szDecorators.postinitcCs |jjS)zThe first parent node defining a new scope. :returns: The first parent scope node. :rtype: Module or FunctionDef or ClassDef or Lambda or GenExpr )rr)rWrrrr# szDecorators.scopeccs|jEdHdS)N)r)rWrrrr, szDecorators.get_children) rprrrrcrrrrrrrrrB s  rBcs@eZdZdZdZdZdZd fdd Zd ddZd d Z Z S) DelAttraVariation of :class:`ast.Delete` representing deletion of an attribute. >>> node = astroid.extract_node('del self.attr') >>> node >>> list(node.get_children())[0] )r)rbNcs||_tt||||dS)a :param attrname: The name of the attribute that is being deleted. :type attrname: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rbrrCrX)rWrbrUrVr)r:rrrXB szDelAttr.__init__cCs ||_dS)zDo some setup after initialisation. :param expr: The name that this node represents. :type expr: Name or None N)r)rWrrrrrY szDelAttr.postinitccs |jVdS)N)r)rWrrrra szDelAttr.get_children)NNNN)N) rprrrrcrrrrXrrrrr)r:rrC0 s rCc@s*eZdZdZdZdZdddZddZdS) DeletezClass representing an :class:`ast.Delete` node. A :class:`Delete` is a ``del`` statement this is deleting something. >>> node = astroid.extract_node('del self.attr') >>> node )rNcCs ||_dS)zDo some setup after initialisation. :param targets: What is being deleted. :type targets: list(NodeNG) or None N)r)rWrrrrrv szDelete.postinitccs|jEdHdS)N)r)rWrrrr~ szDelete.get_children)N)rprrrrcrrrrrrrrDe s  rDcsneZdZdZdZdfdd ZddZeddd Zd d Z d d Z ddZ ddZ dddZ ddZZS)DictzClass representing an :class:`ast.Dict` node. A :class:`Dict` is a dictionary that is created with ``{}`` syntax. >>> node = astroid.extract_node('{1: "1"}') >>> node )itemsNcsg|_tt||||dS)aa :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rFrrErX)rWrUrVr)r:rrrX s z Dict.__init__cCs ||_dS)zDo some setup after initialisation. :param items: The key-value pairs contained in the dictionary. :type items: list(tuple(NodeNG, NodeNG)) N)rF)rWrFrrrr sz Dict.postinitcCs.|}|dkrg|_ndd|D|_|S)zCreate a :class:`Dict` of constants from a live dictionary. :param items: The items to store in the node. :type items: dict :returns: The created dictionary node. :rtype: Dict NcSs g|]\}}t|t|fqSr)r)r.kvrrrr sz'Dict.from_constants..)rF)rrFr rrrr s zDict.from_constantscCsdtS)zyGet the name of the type that this node represents. :returns: The name of the type. :rtype: str z%s.dict)BUILTINS)rWrrrr sz Dict.pytypeccs$x|jD]\}}|V|VqWdS)zGet the key and value nodes below this node. Children are returned in the order that they are defined in the source code, key first then the value. :returns: The children. :rtype: iterable(NodeNG) N)rF)rWr_r'rrrr s zDict.get_childrencCs|jr|jddSdS)zAn optimized version of list(get_children())[-1] :returns: The last child, or None if no children exist. :rtype: NodeNG or None rrN)rF)rWrrrr szDict.last_childcCsdd|jDS)zAn iterator over the keys this node contains. :returns: The keys of this node. :rtype: iterable(NodeNG) cSsg|] \}}|qSrr)r.r_rrrrr szDict.itered..)rF)rWrrrr sz Dict.iteredc Csx|jD]\}}t|trFy |||Stjtjfk rDwYnXxB||D]4}|tj krbqRt|t rRt|t rR|j |j krR|SqRWqWt|dS)axGet an item from this node. :param index: The node to use as a subscript index. :type index: Const or Slice :raises AstroidTypeError: When the given index cannot be used as a subscript index, or if this node is not subscriptable. :raises AstroidIndexError: If the given index does not exist in the dictionary. N) rFr DictUnpackr>rr7r<rr rr&r')rWr,rr_r'Z inferredkeyrrrr> s      z Dict.getitemcCs t|jS)zzDetermine the boolean value of this node. :returns: The boolean value of this node. :rtype: bool )rrF)rWrrrr szDict.bool_value)NNN)N)N)rprrrrcrXrrrrrrrr>rrrr)r:rrE s    rEc@s2eZdZdZdZdZd ddZddZdd ZdS) ExpraClass representing an :class:`ast.Expr` node. An :class:`Expr` is any expression that does not have its value used or stored. >>> node = astroid.extract_node('method()') >>> node >>> node.parent )r'NcCs ||_dS)zDo some setup after initialisation. :param value: What the expression does. :type value: NodeNG or None N)r')rWr'rrrr sz Expr.postinitccs |jVdS)N)r')rWrrrr$ szExpr.get_childrenccs|jjs|jEdHdS)N)r'rr)rWrrrr' sz"Expr._get_yield_nodes_skip_lambdas)N) rprrrrcr'rrrrrrrrK s   rKc@seZdZdZddZdS)EllipsiszClass representing an :class:`ast.Ellipsis` node. An :class:`Ellipsis` is the ``...`` syntax. >>> node = astroid.extract_node('...') >>> node cCsdS)zDetermine the boolean value of this node. :returns: The boolean value of this node. For an :class:`Ellipsis` this is always ``True``. :rtype: bool Tr)rWrrrr6 szEllipsis.bool_valueN)rprrrrrrrrrL, srLc@seZdZdZdZdS) EmptyNodezAHolds an arbitrary object in the :attr:`LocalsDictNodeNG.locals`.N)rprrrobjectrrrrrM@ srMc@sLeZdZdZdZdZdZdZdZddZ d ddZ e j d d Z d d ZdS)raClass representing an :class:`ast.ExceptHandler`. node. An :class:`ExceptHandler` is an ``except`` block on a try-except. >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") ''') >>> node >>> >>> node.handlers [] )r)rar)rNccs4|jdk r|jV|jdk r$|jV|jEdHdS)N)r)rar)rWrrrri s   zExceptHandler.get_childrencCs||_||_||_dS)aYDo some setup after initialisation. :param type: The types that the block handles. :type type: Tuple or NodeNG or None :param name: The name that the caught exception is assigned to. :type name: AssignName or None :param body:The contents of the block. :type body: list(NodeNG) or None N)r)rar)rWr)rarrrrrs s zExceptHandler.postinitcCs"|jr|jjS|jr|jjS|jS)zPThe line on which the beginning of this block ends. :type: int )rarr)rU)rWrrrblockstart_tolineno s z!ExceptHandler.blockstart_tolinenocCs<|jdks|dkrdSx |jD]}|j|kr"dSq"WdS)zCheck if this node handles any of the given exceptions. If ``exceptions`` is empty, this will default to ``True``. :param exceptions: The name of the exceptions to check for. :type exceptions: list(str) NTF)r)rra)rWrr rrrr# s  zExceptHandler.catch)NNN)rprrrrc_multi_line_block_fieldsr)rarrrrrrOr#rrrrrF s  rc@s*eZdZdZdZdZdZdZdddZdS)ExeczClass representing the ``exec`` statement. >>> node = astroid.extract_node('exec "True"') >>> node )rglobalsrNcCs||_||_||_dS)aNDo some setup after initialisation. :param expr: The expression to be executed. :type expr: NodeNG or None :param globals:The globals dictionary to execute with. :type globals: NodeNG or None :param locals: The locals dictionary to execute with. :type locals: NodeNG or None N)rrRr)rWrrRrrrrr s z Exec.postinit)NNN) rprrrrcrrRrrrrrrrQ s rQc@s"eZdZdZdZdZdddZdS)ExtSlicea Class representing an :class:`ast.ExtSlice` node. An :class:`ExtSlice` is a complex slice expression. >>> node = astroid.extract_node('l[1:3, 5]') >>> node >>> node.slice )dimsNcCs ||_dS)zDo some setup after initialisation. :param dims: The simple dimensions that form the complete slice. :type dims: list(NodeNG) or None N)rT)rWrTrrrr szExtSlice.postinit)N)rprrrrcrTrrrrrrS s rSc@sTeZdZdZdZdZdZdZdZdZ dZ dZ d ddZ dZ ejd d Zd d ZdS)ForzClass representing an :class:`ast.For` node. >>> node = astroid.extract_node('for thing in things: print(thing)') >>> node )r!r\rr)r)rrNcCs"||_||_||_||_||_dS)aDo some setup after initialisation. :param target: What the loop assigns to. :type target: NodeNG or None :param iter: What the loop iterates over. :type iter: NodeNG or None :param body: The contents of the body of the loop. :type body: list(NodeNG) or None :param orelse: The contents of the ``else`` block of the loop. :type orelse: list(NodeNG) or None N)r!r\rrr)rWr!r\rrrrrrr s z For.postinitTcCs|jjS)zPThe line on which the beginning of this block ends. :type: int )r\r)rWrrrrO0 szFor.blockstart_tolinenoccs,|jV|jV|jEdH|jEdHdS)N)r!r\rr)rWrrrr8 s zFor.get_children)NNNNN)rprrrrcrrPr!r\rrrrrrrrOrrrrrrU s  rUc@seZdZdZdS)AsyncForaClass representing an :class:`ast.AsyncFor` node. An :class:`AsyncFor` is an asynchronous :class:`For` built with the ``async`` keyword. >>> node = astroid.extract_node(''' async def func(things): async for thing in things: print(thing) ''') >>> node >>> node.body[0] N)rprrrrrrrrV@ srVc@s*eZdZdZdZdZdddZddZdS) rSaClass representing an :class:`ast.Await` node. An :class:`Await` is the ``await`` keyword. >>> node = astroid.extract_node(''' async def func(things): await other_func() ''') >>> node >>> node.body[0] >>> list(node.body[0].get_children())[0] )r'NcCs ||_dS)zyDo some setup after initialisation. :param value: What to wait for. :type value: NodeNG or None N)r')rWr'rrrrj szAwait.postinitccs |jVdS)N)r')rWrrrrr szAwait.get_children)N)rprrrrcr'rrrrrrrSR s  cs&eZdZdZdZdfdd ZZS) ImportFromzClass representing an :class:`ast.ImportFrom` node. >>> node = astroid.extract_node('from my_package import my_module') >>> node )modnamerflevelrNcs*||_||_||_tt||||dS)a :param fromname: The module that is being imported from. :type fromname: str or None :param names: What is being imported from the module. :type names: list(tuple(str, str or None)) :param level: The level of relative import. :type level: int :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rXrfrYrrWrX)rWZfromnamerfrYrUrVr)r:rrrX s  zImportFrom.__init__)rNNN)rprrrrrrXrrr)r:rrWv srWcs@eZdZdZdZdZdZd fdd Zd ddZd d Z Z S) Attributez2Class representing an :class:`ast.Attribute` node.)r)rbNcs||_tt||||dS)a :param attrname: The name of the attribute. :type attrname: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rbrrZrX)rWrbrUrVr)r:rrrX szAttribute.__init__cCs ||_dS)zDo some setup after initialisation. :param expr: The name that this node represents. :type expr: Name or None N)r)rWrrrrr szAttribute.postinitccs |jVdS)N)r)rWrrrr szAttribute.get_children)NNNN)N) rprrrrcrrrrXrrrrr)r:rrZ s rZcs.eZdZdZdZdfdd ZddZZS) GlobalzClass representing an :class:`ast.Global` node. >>> node = astroid.extract_node('global a_global') >>> node )rfNcs||_tt||||dS)a :param names: The names being declared as global. :type names: list(str) :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rfrr[rX)rWrfrUrVr)r:rrrX szGlobal.__init__cCs|S)Nr)rWrrarrrr szGlobal._infer_name)NNN)rprrrrrrXrrrr)r:rr[ sr[c@sTeZdZdZdZdZdZdZdZdddZ e j ddZ d d Z d d Zd dZdS)r zClass representing an :class:`ast.If` node. >>> node = astroid.extract_node('if condition: print(True)') >>> node )rrr)rrNcCs||_||_||_dS)aNDo some setup after initialisation. :param test: The condition that the statement tests. :type test: NodeNG or None :param body: The contents of the block. :type body: list(NodeNG) or None :param orelse: The contents of the ``else`` block. :type orelse: list(NodeNG) or None N)rrr)rWrrrrrrr! s z If.postinitcCs|jjS)zPThe line on which the beginning of this block ends. :type: int )rr)rWrrrrO1 szIf.blockstart_tolinenocCsT||jdjkr||fS||jdjkr8||jdjfS|||j|jdjdS)a8Get a range from the given line number to where this node ends. :param lineno: The line number to start the range at. :type lineno: int :returns: The range of line numbers that this node belongs to, starting at the given line number. :rtype: tuple(int, int) rrr)rrr_elsed_block_ranger)rWrUrrrr9 s zIf.block_rangeccs$|jV|jEdH|jEdHdS)N)rrr)rWrrrrI s zIf.get_childrencCst|jdkot|jdtS)Nrr)rqrr r )rWrrrhas_elif_blockO szIf.has_elif_block)NNN)rprrrrcrPrrrrrrrOrrr]rrrrr  s r c@s:eZdZdZdZdZdZdZd ddZddZ dd Z dS) rDzClass representing an :class:`ast.IfExp` node. >>> node = astroid.extract_node('value if condition else other') >>> node )rrrNcCs||_||_||_dS)aNDo some setup after initialisation. :param test: The condition that the statement tests. :type test: NodeNG or None :param body: The contents of the block. :type body: list(NodeNG) or None :param orelse: The contents of the ``else`` block. :type orelse: list(NodeNG) or None N)rrr)rWrrrrrrrl s zIfExp.postinitccs|jV|jV|jVdS)N)rrr)rWrrrr| szIfExp.get_childrencCsdS)NFr)rWrrrr szIfExp.op_left_associative)NNN) rprrrrcrrrrrrrrrrrDS s cs&eZdZdZdZdfdd ZZS)ImportzClass representing an :class:`ast.Import` node. >>> node = astroid.extract_node('import astroid') >>> node )rfNcs||_tt||||dS)a :param names: The names being imported. :type names: list(tuple(str, str or None)) or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rfrr^rX)rWrfrUrVr)r:rrrX s zImport.__init__)NNNN)rprrrrrrXrrr)r:rr^ sr^c@s*eZdZdZdZdZdddZddZdS) IndexzClass representing an :class:`ast.Index` node. An :class:`Index` is a simple subscript. >>> node = astroid.extract_node('things[1]') >>> node >>> node.slice )r'NcCs ||_dS)zDo some setup after initialisation. :param value: The value to subscript with. :type value: NodeNG or None N)r')rWr'rrrr szIndex.postinitccs |jVdS)N)r')rWrrrr szIndex.get_children)N)rprrrrcr'rrrrrrr_ s   r_cs@eZdZdZdZdZdZd fdd Zd ddZd d Z Z S) KeywordzClass representing an :class:`ast.keyword` node. >>> node = astroid.extract_node('function(a_kwarg=True)') >>> node >>> node.keywords [] )r')rNcs||_tt||||dS)a :param arg: The argument being assigned to. :type arg: Name or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rrr`rX)rWrrUrVr)r:rrrX szKeyword.__init__cCs ||_dS)zDo some setup after initialisation. :param value: The value being assigned to the ketword argument. :type value: NodeNG or None N)r')rWr'rrrr szKeyword.postinitccs |jVdS)N)r')rWrrrr szKeyword.get_children)NNNN)N) rprrrrcrrr'rXrrrrr)r:rr` s r`cs8eZdZdZdZd fdd ZddZd dd ZZS) rzClass representing an :class:`ast.List` node. >>> node = astroid.extract_node('[1, 2, 3]') >>> node )ctxNcs||_tt||||dS)a :param ctx: Whether the list is assigned to or loaded from. :type ctx: Context or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rarrrX)rWrarUrVr)r:rrrX sz List.__init__cCsdtS)zyGet the name of the type that this node represents. :returns: The name of the type. :rtype: str z%s.list)rI)rWrrrr!sz List.pytypecCst||j||dS)zGet an item from this node. :param index: The node to use as a subscript index. :type index: Const or Slice )r)r@r)rWr,rrrrr>)sz List.getitem)NNNN)N) rprrrrrrXrr>rrr)r:rrs rcs.eZdZdZdZdfdd ZddZZS) Nonlocala Class representing an :class:`ast.Nonlocal` node. >>> node = astroid.extract_node(''' def function(): nonlocal var ''') >>> node >>> node.body[0] )rfNcs||_tt||||dS)a :param names: The names being declared as not local. :type names: list(str) :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rfrrbrX)rWrfrUrVr)r:rrrXAszNonlocal.__init__cCs|S)Nr)rWrrarrrrXszNonlocal._infer_name)NNN)rprrrrrrXrrrr)r:rrb2s rbc@seZdZdZdS)PasszClass representing an :class:`ast.Pass` node. >>> node = astroid.extract_node('pass') >>> node N)rprrrrrrrrc\srccs8eZdZdZdZdZdZdfdd Zd ddZZ S) PrintzClass representing an :class:`ast.Print` node. >>> node = astroid.extract_node('print "A message"') >>> node )destrNcs||_tt||||dS)a :param nl: Whether to print a new line. :type nl: bool or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)nlrrdrX)rWrfrUrVr)r:rrrXyszPrint.__init__cCs||_||_dS)zDo some setup after initialisation. :param dest: Where to print to. :type dest: NodeNG or None :param values: What to print. :type values: list(NodeNG) or None N)rer)rWrerrrrrs zPrint.postinit)NNNN)NN) rprrrrcrerrXrrrr)r:rrdes rdc@s6eZdZdZdZdZdZd ddZddZdd Z dS) RaisezClass representing an :class:`ast.Raise` node. >>> node = astroid.extract_node('raise RuntimeError("Something bad happened!")') >>> node N)r?causecCs||_||_dS)zDo some setup after initialisation. :param exc: What is being raised. :type exc: NodeNG or None :param cause: The exception being used to raise this one. :type cause: NodeNG or None N)r?rh)rWr?rhrrrrs zRaise.postinitcCs0|js dSx |jD]}|jdkrdSqWdS)zCheck if this node raises a :class:`NotImplementedError`. :returns: True if this node raises a :class:`NotImplementedError`, False otherwise. :rtype: bool Fr$T)r?rra)rWrarrrraises_not_implementeds  zRaise.raises_not_implementedccs(|jdk r|jV|jdk r$|jVdS)N)r?rh)rWrrrrs  zRaise.get_children)NN) rprrrr?rcrhrrirrrrrrgs rgc@s:eZdZdZdZdZd ddZddZdd Zd d Z dS) ReturnzClass representing an :class:`ast.Return` node. >>> node = astroid.extract_node('return True') >>> node )r'NcCs ||_dS)zDo some setup after initialisation. :param value: The value being returned. :type value: NodeNG or None N)r')rWr'rrrrszReturn.postinitccs|jdk r|jVdS)N)r')rWrrrrs zReturn.get_childrencCs t|jtS)N)r r'r)rWrrris_tuple_returnszReturn.is_tuple_returnccs |VdS)Nr)rWrrrrsz'Return._get_return_nodes_skip_functions)N) rprrrrcr'rrrkrrrrrrjs rjc@seZdZdZddZdS)SetzClass representing an :class:`ast.Set` node. >>> node = astroid.extract_node('{1, 2, 3}') >>> node cCsdtS)zyGet the name of the type that this node represents. :returns: The name of the type. :rtype: str z%s.set)rI)rWrrrrsz Set.pytypeN)rprrrrrrrrrlsrlc@sdeZdZdZdZdZdZdZdddZddZ e j dd Z d d Z dd d ZdddZddZdS)r9zClass representing an :class:`ast.Slice` node. >>> node = astroid.extract_node('things[1:3]') >>> node >>> node.slice )r2r3r4NcCs||_||_||_dS)a:Do some setup after initialisation. :param lower: The lower index in the slice. :value lower: NodeNG or None :param upper: The upper index in the slice. :value upper: NodeNG or None :param step: The step to take between index. :param step: NodeNG or None N)r2r3r4)rWr2r3r4rrrr!s zSlice.postinitcCs|st|}||_|S|S)z7Wrap the empty attributes of the Slice in a Const node.)rr)rWrZconstrrr_wrap_attribute1s zSlice._wrap_attributecCstj}|ddS)Nr6r)r]Zbuiltins_modulere)rWbuiltinsrrrr@9szSlice._proxiedcCsdtS)zyGet the name of the type that this node represents. :returns: The name of the type. :rtype: str z%s.slice)rI)rWrrrr>sz Slice.pytypeccs`|dkr||jVnD|dkr0||jVn,|dkrH||jVn|j||dEdHdS)zInfer the possible values of the given attribute on the slice. :param attrname: The name of the attribute to infer. :type attrname: str :returns: The inferred possible values. :rtype: iterable(NodeNG) startstopr4)rN)rmr2r3r4re)rWrbrrrrigetattrFs zSlice.igetattrcCs|j||S)N)r@re)rWrbrrrrreXsz Slice.getattrccs:|jdk r|jV|jdk r$|jV|jdk r6|jVdS)N)r2r3r4)rWrrrr[s    zSlice.get_children)NNN)N)N)rprrrrcr2r3r4rrmrrr@rrqrerrrrrr9s   r9cs@eZdZdZdZdZdZd fdd Zd ddZd d Z Z S) r2zClass representing an :class:`ast.Starred` node. >>> node = astroid.extract_node('*args') >>> node )r')raNcs ||_tt|j|||ddS)a :param ctx: Whether the list is assigned to or loaded from. :type ctx: Context or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None )rUrVrN)rarr2rX)rWrarUrVr)r:rrrXvs zStarred.__init__cCs ||_dS)zDo some setup after initialisation. :param value: What is being unpacked. :type value: NodeNG or None N)r')rWr'rrrrszStarred.postinitccs |jVdS)N)r')rWrrrrszStarred.get_children)NNNN)N) rprrrrcrrr'rXrrrrr)r:rr2fs r2csDeZdZdZdZdZdZdZd fdd Zd ddZ d d Z Z S) SubscriptzClass representing an :class:`ast.Subscript` node. >>> node = astroid.extract_node('things[1:3]') >>> node )r'r6)raNcs ||_tt|j|||ddS)a :param ctx: Whether the subscripted item is assigned to or loaded from. :type ctx: Context or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None )rUrVrN)rarrrrX)rWrarUrVr)r:rrrXs zSubscript.__init__cCs||_||_dS)zDo some setup after initialisation. :param value: What is being indexed. :type value: NodeNG or None :param slice: The slice being used to lookup. :type slice: NodeNG or None N)r'r6)rWr'r6rrrrs zSubscript.postinitccs|jV|jVdS)N)r'r6)rWrrrrszSubscript.get_children)NNNN)NN) rprrrrcrrr'r6rXrrrrr)r:rrrs rrc@sFeZdZdZdZdZdZdZdZd ddZ ddZ dd Z d d Z dS) r"aClass representing an :class:`ast.TryExcept` node. >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") ''') >>> node )rrrNcCs||_||_||_dS)alDo some setup after initialisation. :param body: The contents of the block to catch exceptions from. :type body: list(NodeNG) or None :param handlers: The exception handlers. :type handlers: list(ExceptHandler) or None :param orelse: The contents of the ``else`` block. :type orelse: list(NodeNG) or None N)rrr)rWrrrrrrrs zTryExcept.postinitcCs|S)Nr)rWrrarrrr szTryExcept._infer_namecCsd}xx|jD]n}|jr*||jjkr*||fS|jdj|krN|jdjkrbnn||jdjfS|dkr |jdjd}q W|||j|S)a8Get a range from the given line number to where this node ends. :param lineno: The line number to start the range at. :type lineno: int :returns: The range of line numbers that this node belongs to, starting at the given line number. :rtype: tuple(int, int) Nrrr)rr)rrrr\r)rWrUZlastZ exhandlerrrrr s  (zTryExcept.block_rangeccs0|jEdH|jpdEdH|jp$dEdHdS)Nr)rrr)rWrrrr!s zTryExcept.get_children)NNN) rprrrrcrPrrrrrrrrrrrr"s  r"c@s:eZdZdZdZdZdZdZd ddZddZ dd Z dS) TryFinallyaClass representing an :class:`ast.TryFinally` node. >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") finally: print("Cleanup!") ''') >>> node )r finalbodyNcCs||_||_dS)aDo some setup after initialisation. :param body: The try-except that the finally is attached to. :type body: list(TryExcept) or None :param finalbody: The contents of the ``finally`` block. :type finalbody: list(NodeNG) or None N)rrt)rWrrtrrrrDs zTryFinally.postinitcCsT|jd}t|trF|j|jkrF|j|kr8|jkrFnn ||S|||jS)a8Get a range from the given line number to where this node ends. :param lineno: The line number to start the range at. :type lineno: int :returns: The range of line numbers that this node belongs to, starting at the given line number. :rtype: tuple(int, int) r)rr r"rrrr\rt)rWrUrrrrrPs    zTryFinally.block_rangeccs|jEdH|jEdHdS)N)rrt)rWrrrrds zTryFinally.get_children)NN) rprrrrcrPrrtrrrrrrrrs(s  rscs8eZdZdZdZd fdd ZddZd dd ZZS) rzClass representing an :class:`ast.Tuple` node. >>> node = astroid.extract_node('(1, 2, 3)') >>> node )raNcs||_tt||||dS)a :param ctx: Whether the tuple is assigned to or loaded from. :type ctx: Context or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rarrrX)rWrarUrVr)r:rrrXsszTuple.__init__cCsdtS)zyGet the name of the type that this node represents. :returns: The name of the type. :rtype: str z%s.tuple)rI)rWrrrrsz Tuple.pytypecCst||j||dS)zGet an item from this node. :param index: The node to use as a subscript index. :type index: Const or Slice )r)r@r)rWr,rrrrr>sz Tuple.getitem)NNNN)N) rprrrrrrXrr>rrr)r:rris rcs`eZdZdZdZdZdZdfdd ZdddZdd d Z dd d Z d dZ fddZ Z S)rRzClass representing an :class:`ast.UnaryOp` node. >>> node = astroid.extract_node('-5') >>> node )operand)rBNcs||_tt||||dS)a :param op: The operator. :type: str or None :param lineno: The line that this node appears on in the source code. :type lineno: int or None :param col_offset: The column that this node appears on in the source code. :type col_offset: int or None :param parent: The parent node in the syntax tree. :type parent: NodeNG or None N)rBrrRrX)rWrBrUrVr)r:rrrXszUnaryOp.__init__cCs ||_dS)zDo some setup after initialisation. :param operand: What the unary operator is applied to. :type operand: NodeNG or None N)ru)rWrurrrrszUnaryOp.postinitcCstdS)N)r$)rWrrrr_infer_unaryopszUnaryOp._infer_unaryopcCs6y|j|d}dd|DStjk r0gSXdS)a%Get a list of type errors which can occur during inference. Each TypeError is represented by a :class:`BadBinaryOperationMessage`, which holds the original exception. :returns: The list of possible type errors. :rtype: list(BadBinaryOperationMessage) )rcSsg|]}t|tjr|qSr)r r ZBadUnaryOperationMessage)r.ryrrrrsz'UnaryOp.type_errors..N)rvrr*)rWrr'rrrr(s  zUnaryOp.type_errorsccs |jVdS)N)ru)rWrrrrszUnaryOp.get_childrencs|jdkrt|jStS)NrG)rBrrr)rW)r:rrrs  zUnaryOp.op_precedence)NNNN)N)N)N)rprrrrcrrrurXrrvr(rrrrr)r:rrRs  c@sLeZdZdZdZdZdZdZdZd ddZ e j ddZ d d Z d d ZdS)WhilezClass representing an :class:`ast.While` node. >>> node = astroid.extract_node(''' while condition(): print("True") ''') >>> node )rrr)rrNcCs||_||_||_dS)aHDo some setup after initialisation. :param test: The condition that the loop tests. :type test: NodeNG or None :param body: The contents of the loop. :type body: list(NodeNG) or None :param orelse: The contents of the ``else`` block. :type orelse: list(NodeNG) or None N)rrr)rWrrrrrrrs zWhile.postinitcCs|jjS)zPThe line on which the beginning of this block ends. :type: int )rr)rWrrrrOszWhile.blockstart_tolinenocCs|||jS)a8Get a range from the given line number to where this node ends. :param lineno: The line number to start the range at. :type lineno: int :returns: The range of line numbers that this node belongs to, starting at the given line number. :rtype: tuple(int, int) )r\r)rWrUrrrr s zWhile.block_rangeccs$|jV|jEdH|jEdHdS)N)rrr)rWrrrr,s zWhile.get_children)NNN)rprrrrcrPrrrrrrrOrrrrrrrws   rwc@sHeZdZdZdZdZdZdZdZdZ d ddZ e j dd Z d d ZdS) WithzClass representing an :class:`ast.With` node. >>> node = astroid.extract_node(''' with open(file_path) as file_: print(file_.read()) ''') >>> node )rFr)r)rNcCs||_||_||_dS)a9Do some setup after initialisation. :param items: The pairs of context managers and the names they are assigned to. :type items: list(tuple(NodeNG, AssignName or None)) or None :param body: The contents of the ``with`` block. :type body: list(NodeNG) or None N)rFrr)rWrFrrrrrrVs z With.postinitcCs|jddjS)zPThe line on which the beginning of this block ends. :type: int rr)rFr)rWrrrrOdszWith.blockstart_tolinenoccs4x"|jD]\}}|V|r|VqW|jEdHdS)zoGet the child nodes below this node. :returns: The children. :rtype: iterable(NodeNG) N)rFr)rWrvarrrrrls  zWith.get_children)NNN)rprrrrcrrPrFrrrrrrOrrrrrrx3s rxc@seZdZdZdS) AsyncWithz7Asynchronous ``with`` built with the ``async`` keyword.N)rprrrrrrrrzysrzc@s2eZdZdZdZdZd ddZddZdd ZdS) YieldzClass representing an :class:`ast.Yield` node. >>> node = astroid.extract_node('yield True') >>> node )r'NcCs ||_dS)z{Do some setup after initialisation. :param value: The value to yield. :type value: NodeNG or None N)r')rWr'rrrrszYield.postinitccs|jdk r|jVdS)N)r')rWrrrrs zYield.get_childrenccs |VdS)Nr)rWrrrrsz#Yield._get_yield_nodes_skip_lambdas)N) rprrrrcr'rrrrrrrr{}s  r{c@seZdZdZdS) YieldFromz2Class representing an :class:`ast.YieldFrom` node.N)rprrrrrrrr|sr|c@seZdZdZdS)rJz>Represents the unpacking of dicts into dicts using :pep:`448`.N)rprrrrrrrrJsrJc@s2eZdZdZdZdZdZdZdddZddZ dS) FormattedValuea9Class representing an :class:`ast.FormattedValue` node. Represents a :pep:`498` format string. >>> node = astroid.extract_node('f"Format {type_}"') >>> node >>> node.values [, ] )r' format_specNcCs||_||_||_dS)atDo some setup after initialisation. :param value: The value to be formatted into the string. :type value: NodeNG :param conversion: The type of formatting to be applied to the value. :type conversion: int or None :param format_spec: The formatting to be applied to the value. :type format_spec: JoinedStr or None N)r' conversionr~)rWr'rr~rrrrs zFormattedValue.postinitccs|jV|jdk r|jVdS)N)r'r~)rWrrrrs zFormattedValue.get_children)NN) rprrrrcr'rr~rrrrrrr}s  r}c@s*eZdZdZdZdZdddZddZdS) JoinedStrzRepresents a list of string expressions to be joined. >>> node = astroid.extract_node('f"Format {type_}"') >>> node )rNcCs ||_dS)zDo some setup after initialisation. :param value: The string expressions to be joined. :type: list(FormattedValue or Const) or None N)r)rWrrrrrszJoinedStr.postinitccs|jEdHdS)N)r)rWrrrrszJoinedStr.get_children)N)rprrrrcrrrrrrrrs  rc@s&eZdZdZdZddZdddZdS)UnknownzThis node represents a node in a constructed AST where introspection is not possible. At the moment, it's only used in the args attribute of FunctionDef nodes where function signature introspection failed. cCsdS)Nrr)rWrrrrsz Unknown.qnameNcks tjVdS)z4Inference on an Unknown node immediately terminates.N)r r)rWrr^rrrrsz Unknown.infer)N)rprrrrarrrrrrrsrcCs*ttttttf}x|D] }tt|<qWdS)z?update constant classes, so the keys of CONST_CLS can be reusedN)rr(floatcomplexr<r=r& CONST_CLS)ZklassesZklsrrr_update_const_classess rcCs|}|||S)N)r)rr'r>rrr_two_step_initialization!s rcCs t|trt|}t||S)N)r rrrFr)rr'rrr_dict_initialization's  rcCs||S)Nr)rr'rrr2src Cspt|trtt|ttttfr&g}n|}yt|j}t |}|||St t fk rjt }||_ |SXdS)z)return an astroid node for a python valueN)r rTrrrrrrr:_CONST_CLS_CONSTRUCTORSKeyErrorr9rMrN)r'rZinitializer_clsZ initializerr rrrr6s  rcCs,|j}x |dk r&t|trdS|j}qWdS)z9Return True if the given node is the child of a decoratorNTF)rr rB)r rrrrrRs    r)N)N)N)N)N)F)NN){rrrnZ builtins_modrrs functoolsrrrZastroidrrrrrrr r r rprIZAstroidManagerr]Zraise_if_nothing_inferredrr%rNr+r-r8r@rrrTrZParentAssignTypeMixinZInstanceABCMetarrZNoChildrenMixinrrrZAssignTypeMixinrrrrrrr r#r)r*r.r/r0rHr6r&rArBrCrDrErKrLrMZMultiLineBlockMixinrrQrSZBlockRangeMixInrUrVrSZImportFromMixinrWrZr[r rDr^r_r`rrbrcrdrgrjrlr9r2rrr"rsrrRrwrxrzr{r|rJr}rrrrrrr)NotImplementedrrrrrrrrrrrs"            L    ?# OF * '/ 7)7>Y]8 E>e} -5$Y+ V$>.%L4%52* 86"`5@MA2PH B: