cUdZddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZmZmZmZmZmZmZddlmZmZddlmZmZdd lmZmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(dd l)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4ej5dkrddlm6Z6nddl7m6Z6er ddlm8Z8ddl)m9Z9ej5dkrddl m:Z:nddl;medej?Z@edZAee>eAeeeejBeCgefZDee>eegej ee3e@fddffZEee>eegej e3dee2ffZFee>eGge0fZHejIddd ZJddd#ZKeLZMddd$ZNddd%ZOddd&ZPGd'd(e*jQeejR)ZSGd*d+e.ZTGd,d-e*jUeTe*jQZVGd.d/e*jUeTe*jQZWGd0d1e*jUeTZXGd2d3e*jYZZdd5Z[ ddd9Z\Gd:d;e*jQZ]Gd<d=e*j^Z_Gd>d?e*jYe*j^Z`Gd@dAe*jYe*j^ZaGdBdCe*jYe*j^ZbGdDdEe.ZcGdFdGe.ZdGdHdIe*jUe*j^ZeGdJdKe.ZfGdLdMe.ZgGdNdOe.ZhGdPdQe*jUeZiGdRdSe*jUe*j^ZjGdTdUe.ZkGdVdWe*jQZlGdXdYe*jYe*j^ZmGdZd[e.eZnGd\d]e*j^ZoGd^d_e*jUZpGd`dae*jUZqGdbdce*jre*jYe*j^ZsGdddee.ZtGdfdge*jue*jYe*j^ZvGdhdievZwGdjdke.ZxGdldme*jyZzGdndoe.Z{Gdpdqe*jUe*j^Z|Gdrdse*jue*j^Z}Gdtdue.Z~Gdvdwe*jyZGdxdye.ZGdzd{e.ZGd|d}eSZBGd~de*jUe*j^ZGdde*jUe*j^ZGdde*j^ZGdde*j^ZGddeSZGdde.ZGdde*jQZGdde.ZGdde*jue*j^ZGdde*jue*j^ZGddeSZGdde.ZGdde*jue*j^ZGdde*jue*jYe*j^ZGddeZGdde.ZGddeZGdde*jUZGdde.ZGdde.ZGdde*jYZGdde*jYZGdde.ZGdde*j^ZGdde.ZGdde*jrZGddeZGddeZGddeZGdde*jYeZGddeZGdde*jYeZGdde*jYeZGddeZeeBeeeeneeedeieeeied¦eieeieCeieeieeieGeieeii Zded<ddʄZdd΄ZddфZdS)z;Module for some node classes. More nodes in scoped_nodes.py) annotationsN) GeneratorIterableMapping) lru_cache) TYPE_CHECKINGAnyCallableClassVarOptionalTypeVarUnion) decoratorsutil)Instance _infer_stmts)_EMPTY_OBJECT_MARKERContext)InferenceContext)AstroidIndexErrorAstroidTypeErrorAstroidValueErrorInferenceError NoDefaultParentMissingError)AstroidManager) _base_nodes) OP_PRECEDENCE)NodeNG)ConstFactoryResult InferBinaryOpInferenceErrorInfoInferenceResultSuccessfulInferenceResult))Literalnodes)LocalsDictNodeNG)cached_property)cachedpropertyreturnboolcFt|ttSN) isinstancetuple CONST_CLSvalues :lib/python3.11/site-packages/astroid/nodes/node_classes.py _is_constr79s eU9-- . .._NodesT)bound_BadOpMessageT)ListTuple AssignName AssignAttrNcontextInferenceContext | Nonec#Kt|ttfr8|jD]+}|tjur|Vt ||Ed{V,||dSt||tj}||ur |V||dS||D]+}|tjur|Vt ||Ed{V,||dS)zrecursively generate nodes inferred by the given statement. If the inferred value is a list or a tuple, recurse on the elements N)noder@) r1r<r=eltsr Uninferable unpack_infernextinfer)stmtr@eltinferreds r6rFrFUs) $u &&29 2 2Cd&&  #C11 1 1 1 1 1 1 1 1111DJJw'')9::H42111JJw''77 t' ' 7NNNN#Hg66 6 6 6 6 6 6 6 6W - --r8 exceptionslist[str] | Nonec i}i}|}|D]}d||<|||<|}|}|D]B}||vr8t|trB|@||d|||durdSnt|tr||\}}|||\} } | |urw|dko| dko||} |dko | dko|||} |dko| dk} |dko| dk}t | | | |frdSn|dkr| dkr |||ucSdS|}DdS)areturn true if the two given statements are mutually exclusive `exceptions` may be a list of exception names. If specified, discard If branches and check one of the statement is in an exception handler catching one of the given exceptions. algorithm : 1) index stmt1's parents 2) climb among stmt2's parents until we find a common parent 3) if the common parent is a If or TryExcept statement, look if nodes are in exclusive branches NThandlersbodyorelseF)node_ancestorsr1If locate_child TryExceptcatchany)stmt1stmt2rL stmt1_parentschildrenpreviousrCc2attrc2nodec1attrc1node first_in_body_caught_by_handlers!second_in_body_caught_by_handlersfirst_in_else_other_in_handlers second_in_else_other_in_handlerss r6 are_exclusiverfps8MHH$$&& d!H$$&&** = ( $##$ : $ :%%h//2,,Xd^<!B!B':*,7"f,7$NN:665 &(="j0=$TN00<<6 *,C81C4(*Cv/C5<=;< $ $tt$z):f .B:#8D>999955 5r8ct|tr1t|jtt dfr|jSn|dS t ||}t|tr0t|jtt dfr|jSn#ttf$rYnwxYwtS)z'Get the value of the given slice index.Nr@) r1Constr5inttyperGrHr StopIteration_SLICE_SENTINEL)indexr@rKs r6 _slice_valueros%* ekCd#4 5 5 ;    *t  *EKKK8899H(E** *hnsDJJ.?@@*#>)  .    D  s #B55C C c t|j|}t|j|}t|j|}t d|||fDrt |||St d||j|)Nc3(K|] }|tuVdSr0)rm.0elems r6 z_infer_slice..s' H H44 & H H H H H Hr8z'Could not infer slice used in subscriptmessagerCrnr@)rolowerupperstepallslicerparent)rCr@rxryrzs r6 _infer_slicer~s W - -E W - -E  7 + +D H HE5$3G H H HHH)UE4((( 9 k    r8c t|tr@t||}|}|||_|j|_|St|t r ||jSnh#t$r}td||||d}~wt$r}td||||d}~wt$r}td||||d}~wwxYwtd|d) zHGet a slice or an item, using the given *index*, for the given sequence.rhz&Slice {index!r} cannot index containerrvNzIndex {index!s} out of rangeType error {error!r}zCould not use  as subscript index)r1Slicer~ __class__rDr}rir5 ValueErrorr IndexErrorr TypeErrorr)instancerDrnr@ index_slicenew_clsexcs r6_container_getitemrsY eU # # &ug>>>K((**G ,GL%_GNN eU # # % $ $ % <       2       *PW     FEFFF G GGs6AA:!A:: CB C%B99 CCCceZdZdZdZ dddddfdZddZeddZdZ dddZ e j d dZ dZxZS)! BaseContainerz.Base class for Set, FrozenSet, Tuple and List.rDN end_linenoend_col_offsetlineno int | None col_offsetr} NodeNG | Nonerrr-Nonecdg|_ t|||||dS :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rrrrr}N)rDsuper__init__selfrrr}rrrs r6rzBaseContainer.__init__ sI,#% ' !!)      r8rD list[NodeNG]c||_dS)zoDo some setup after initialisation. :param elts: The list of elements the that node contains. Nr)rrDs r6postinitzBaseContainer.postinit+  r8cP|}|g|_nd|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 NcNg|]"}t|rt|n|#Sr7 const_factory)rses r6 z/BaseContainer.from_elements..@s0OOOQYq\\@q)))qOOOr8r)clsrDrCs r6 from_elementszBaseContainer.from_elements2s;suu  PDIIOO$OOODI r8c|jS)zAn iterator over the elements this node contains. :returns: The contents of this node. :rtype: iterable(NodeNG) rrs r6iteredzBaseContainer.iteredCs yr8r@rAr.c*t|jS)zeDetermine the boolean value of this node. :returns: The boolean value of this node. )r.rDrr@s r6 bool_valuezBaseContainer.bool_valueKs DIr8strcdS)eGet the name of the type that this node represents. :returns: The name of the type. Nrrs r6pytypezBaseContainer.pytypeRsr8c#$K|jEd{VdSr0rrs r6 get_childrenzBaseContainer.get_childrenYs&9r8NNN rrrrr}rrrrrr-r)rDrr-rr0)r@rAr-r.r-r)__name__ __module__ __qualname____doc___astroid_fieldsrr classmethodrrrabcabstractmethodrr __classcell__rs@r6rrs88O"!% $  "&%)        B[      r8r) metaclassc@eZdZdZed dZdZdS) LookupMixInz+Mixin to look up a name in the right scope.namerr-%tuple[LocalsDictNodeNG, list[NodeNG]]cR|||S)a#Lookup 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. :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). )scope scope_lookuprrs r6lookupzLookupMixIn.lookupas"zz||((t444r8cp||\}}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 )rrr)rrframestmtsr@s r6ilookupzLookupMixIn.ilookupqs6{{4(( u"$$E7E222r8N)rrr-r)rrrrrrrrr8r6rr^sM55Y[[ 5 5 5[ 5 3 3 3 3 3r8rc~eZdZUdZdZded<ejd dddddfdZded<xZ S)r>aVariation 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. >>> import astroid >>> node = astroid.extract_node('variable = range(10)') >>> node >>> list(node.get_children()) [, ] >>> list(node.get_children())[0].as_string() 'variable' rzClassVar[InferLHS[AssignName]] infer_lhsrNrr str | Nonerrrr}rrrr-rcd||_ t|||||dS)a :param name: The name that is assigned to. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rNrrrrrrrr}rrrs r6rzAssignName.__init__sI4!% + !!)      r8z'ClassVar[AssignedStmtsCall[AssignName]]assigned_stmtsNNNNrrrrrrr}rrrrrr-r) rrrr _other_fields__annotations__r!deprecate_default_argument_valuesrrrs@r6r>r>s  M----1Z1u=== !!% $ " "&%)" " " " " " " >=" H<;;;r8r>cheZdZdZdZejd dddddfdZxZS)DelNameahVariation of :class:`ast.Delete` representing deletion of a name. A :class:`DelName` is the name of something that is deleted. >>> import astroid >>> node = astroid.extract_node("del variable #@") >>> list(node.get_children()) [] >>> list(node.get_children())[0].as_string() 'variable' rrNrrrrrrr}rrrr-rcd||_ t|||||dS)a :param name: The name that is being deleted. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rNrrs r6rzDelName.__init__sI4!% - !!)      r8rr rrrrrrrrrrs@r6rrs  M1Z1u=== !!% $ " "&%)" " " " " " " >=" " " " " r8rcneZdZdZdZejd dddddfdZdZxZ S)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`. >>> import astroid >>> node = astroid.extract_node('range(10)') >>> node >>> list(node.get_children()) [, ] >>> list(node.get_children())[0].as_string() 'range' rrNrrrrrrr}rrrr-rcd||_ t|||||dS)a  :param name: The name that this node refers to. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rNrrs r6rz Name.__init__ sI4!% 0 !!)      r8c#tK|V|D]}|Ed{VdSr0)r_get_name_nodes)r child_nodes r6rzName._get_name_nodes.s[ ++-- 4 4J!1133 3 3 3 3 3 3 3 3 4 4r8rr) rrrrrrrrrrrs@r6rrs  M1Z1u=== !!% $ " "&%)" " " " " " " >=" H4444444r8rceZdZUdZdZdZded<ded<ded<ded< d6d7fd Z d8d9d#Zd$ed%< d&Z e fd'Z e d(Z d d)d:d-Z d;d/Zd0Zd ArgumentsaRClass representing an :class:`ast.arguments` node. An :class:`Arguments` node represents that arguments in a function definition. >>> import astroid >>> node = astroid.extract_node('def foo(bar): pass') >>> node >>> node.args ) argsdefaults kwonlyargs posonlyargsposonlyargs_annotations kw_defaultsrvarargannotationkwargannotationkwonlyargs_annotationstype_comment_argstype_comment_kwonlyargstype_comment_posonlyargs)varargkwargrrrrrNrrrr}rr-ct|||_ ||_ | | | g|_ | | g|_ g|_ g|_ g|_ g|_ d|_ d|_ dS)z :param vararg: The name of the variable length arguments. :param kwarg: The name of the variable length keyword arguments. :param parent: The parent node in the syntax tree. r}N) rrrrrrrrrrrr)rrrr}rs r6rzArguments.__init__ds '''"( 8!& @ *  *O )G-/A -Z -P<>$U;=#S68 =?$ >@% 04D.2LLr8rlist[AssignName] | Nonerlist[NodeNG] | Nonerlist[AssignName]rlist[NodeNG | None]rrrlist[NodeNG | None] | Nonerrrrrrc||_||_||_|||_||_||_|||_|||_| |_| |_ | | |_ | | |_ | | |_ dSdS)a Do some setup after initialisation. :param args: The names of the required arguments. :param defaults: The default values for arguments that can be passed positionally. :param kwonlyargs: The keyword arguments that cannot be passed positionally. :param posonlyargs: The arguments that can only be passed positionally. :param kw_defaults: The default values for keyword arguments that cannot be passed positionally. :param annotations: The type annotations of arguments that can be passed positionally. :param kwonlyargs_annotations: The type annotations of arguments that cannot be passed positionally. This should always be passed in Python 3. :param posonlyargs_annotations: The type annotations of arguments that can only be passed positionally. This should always be passed in Python 3. :param varargannotation: The type annotation for the variable length arguments. :param kwargannotation: The type annotation for the variable length keyword arguments. :param type_comment_args: The type annotation, passed by a type comment, of each argument. :param type_comment_args: The type annotation, passed by a type comment, of each keyword only argument. :param type_comment_args: The type annotation, passed by a type comment, of each positional argument. N) rrrrrrrrrrrrr)rrrrrrrrrrrrrrs r6rzArguments.postinitst   $  +*D && ! A*@D ' " C+BD ( 0.  7%6D " " C+BD ( # E,DD ) ) ) E Er8z&ClassVar[AssignedStmtsCall[Arguments]]rc|j|ur|SdSr0rrrrs r6 _infer_namezArguments._infer_names ;%  Ktr8cbtj}t||jjpdS)zaThe first line that this node appears on in the source code. :type: int or None r)r fromlinenomaxr})rrrs r6rzArguments.fromlineno s+ #64;16Q777r8cbttj|jpd|jpdS)zYGet all the arguments for this node, including positional only and positional and keywordr)list itertoolschainrrrs r6 argumentszArguments.argumentss,IOT%5%;dio2NNOOOr8skippable_namesrset[str] | Nonerc Xg}g}|j}|jrW|jpg}|jt| d}|jdt|jt|z }|jrE|t |j||j||d|jr:|t |j|t|dd||jr|d|j|j rQ|js|d|t |j |j |j ||j r|d|j d |S)zoGet the arguments formatted as string. :returns: The formatted arguments. :rtype: str Nr /r***, )rrlenrappend _format_argsrgetattrrrrrrjoin)rrresultpositional_only_defaultspositional_or_keyword_defaultsrs r6 format_argszArguments.format_argss #% )-& = W9?D-1]CII:<<-H *'+}5Us4=7I7ICPTII7U5U'V $    MM$,0$3     MM#    9  MMI2D-66$3     ; - MM+dk++ , , , ? ; # c""" MMO$/$3     : - MM+tz++ , , ,yy   r8Ytuple[dict[str, tuple[str | None, str | None]], dict[str, tuple[str | None, str | None]]]ci}i}g}|j}|jrW|jpg}|jt| d}|jdt|jt|z }t|jD]R\}}|j|d} }||}|r||} || f||j<St|jD]\}} |j|d} }||}|rQt|jt|z } || z } | dkr"|| || } || f|| j<|j r)|j }||}|df||j <t|j D]W\}} |j |}||}|j |} | | } || f|| j<X|jr)|j}||}|df||j<||fS)ayGet the arguments as dictionary with information about typing and defaults. The return tuple contains a dictionary for positional and keyword arguments with their typing and their default value, if any. The method follows a similar order as format_args but instead of formatting into a string it returns the data that is used to do so. N)rrr enumeraterr as_stringrrrrrrrrr)rpos_onlykw_onlyrrrrnposonly annotationdefaultargdefaults_offset default_indexrs r6_get_arguments_datazArguments._get_arguments_dataMs>@<>$& )-& = W9?D-1]CII:<<-H *'+}5Us4=7I7ICPTII7U5U'V $'(899 ; ;NE7"&">u"EtJ 4'1133 ' F259CCEE&0'%:HW\ " "#DI.. 7 7JE3"&"25"94J 4'1133 - X"%di..37U3V3V"V % 7 !B&X6}EX=]KUUWWG",g!6HSX   ; 7.J 4'1133 %/$6HT[ !%do66 8 8LE54U;J 4'1133 &u-G .!++--#-w"7GEJ   : 5-J 4'1133 #-t"4GDJ   r8cN|j}t||d}|:|t|t|jz z }|dkr |j|St||jd}||j| |j|St |j|)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)funcr)r  _find_argrrrrrr})rargnamerrnidxs r6 default_valuezArguments.default_values~'4((+  *3t99s4='9'99:Cax *}S))'4?33A6  +!1%!8 +#E* *T[w7777r8r.c||jkrdS||jkrdS||dddup%|jot ||jddduS)zCheck if the given name is defined in the arguments. :param name: The name to check for. :type name: str :returns: Whether the given name is defined in the arguments, T)recrON)rr find_argnamerr.rs r6 is_argumentzArguments.is_arguments 4;  4 4:  4   d  - -a 0 < JJ$T:::1=TI r8Fc@|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)r r.)rr/r3s r6r4zArguments.find_argnames' > ;Wdnc:: :zr8c#HK|jpdEd{V|jD]}||V |jpdEd{V|j |jEd{V|jEd{V|jD]}||V |jD]}||V |j |jV|j |jV|j D]}||V dSNr) rrrrrrrrrr)rrJs r6rzArguments.get_childrensP#)r)))))))/  C  9?""""""" = %} $ $ $ $ $ $ $?"""""""#  C  #  C    (' ' ' '   '& & & &.  C    r8r)rrrrr}rr-r)NNNNNNNN)rrrrrrrrrrrrrrrrrrrrrrrrrrr-rrrr-r)r-rr-r.F)rrrrrrrrrrr+rr rr+r1r5r4rrrs@r6rr5s  .O (MLLL" $ NMNMNMNMNMNMNMp04=A>B*.)-8<>B?CLELELELELE\;::: 8888_8PP_PAE0!0!0!0!0!0!dC!C!C!C!J888(    $"r8rFct|D]O\}}t|tr$|r!t||j}|d|cS>|j|kr||fcSPdS)Nrr7)r!r1r=r.rDr)r/rr3ir(founds r6r.r.sD//3 c5 ! !  !!'38448! LLL X  c6MMM  :r8rrrc|t}g}|dS|g}|t|t|z }tj||}t |D]\}\}} |j|vrt |tr,|dt|j dS|j} d} | | d| zz } d} || |?||kr9|||z .|dxx| |||z  zz cc<d |S) N()=z: z = r r) setrr  zip_longestr!rr1r=rrrDr"r) rrrrvaluesdefault_offsetpackedr>r(r&r/ default_seps r6rrs %% F r 3TS]]2  "4 5 5F )& 1 1YY C 8 &   c5 ! ! Y MM7l3844777 8 8 8 8hGK $4*"6"6"8"888# MM' " " " Y^(; YA./Y2JJJ+^9K0L0V0V0X0X"XXJJJ 99V  r8ceZdZUdZdZdZded<ejd dddddfdZ dddZ ded< dZ xZ S)r?aVariation of :class:`ast.Assign` representing assignment to an attribute. >>> import astroid >>> node = astroid.extract_node('self.attribute = range(10)') >>> node >>> list(node.get_children()) [, ] >>> list(node.get_children())[0].as_string() 'self.attribute' exprattrnamezClassVar[InferLHS[AssignAttr]]rrNrrOrrrrr}rrrr-rctd|_ ||_ t|||||dS)a :param attrname: The name of the attribute being assigned to. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. NrrMrOrrrrOrrr}rrrs r6rzAssignAttr.__init__'sS4$( ?$, : !!)      r8rMc||_dS)ztDo some setup after initialisation. :param expr: What has the attribute that is being assigned to. NrLrrMs r6rzAssignAttr.postinitOrr8z'ClassVar[AssignedStmtsCall[AssignAttr]]rc#K|jVdSr0rLrs r6rzAssignAttr.get_children[ir8rrOrrrrrr}rrrrrr-rr0rMrr-r) rrrrrrrrrrrrrrs@r6r?r?s   O!M----1Z15AAA $!!% $ % "&%)% % % % % % % BA% N<;;;r8r?cHeZdZdZdZ dddddfdZdddZdZxZS)AssertaClass representing an :class:`ast.Assert` node. An :class:`Assert` node represents an assert statement. >>> import astroid >>> node = astroid.extract_node('assert len(things) == 10, "Not enough things"') >>> node testfailNrrrrr}rrrr-rctd|_ d|_ t|||||dSrNr)r\r]rrrs r6rzAssert.__init__lsS,$( :#' 9 !!)      r8r\r]c"||_||_dS)zDo some setup after initialisation. :param test: The test that passes or fails the assertion. :param fail: The message shown when the assertion fails. N)r]r\)rr\r]s r6rzAssert.postinits  r8c#@K|jV|j |jVdSdSr0r[rs r6rzAssert.get_childrens4i 9 )OOOOO  r8rrr7)r\rr]rr-r rrrrrrrrrrs@r6rZrZ_s'O"!% $ " "&%)" " " " " " " " Hr8rZceZdZUdZdZdZ dddddfdZ dddZded< dZ e j dZ dZ xZS)AssignaClass representing an :class:`ast.Assign` node. An :class:`Assign` is a statement where something is explicitly asssigned to. >>> import astroid >>> node = astroid.extract_node('variable = range(10)') >>> node targetsr5type_annotationNrrrrr}rrrr-rcg|_ d|_ d|_ t|||||dSr_)rfr5rhrrrs r6rzAssign.__init__s^,&( ($( 8.2X !!)      r8rfrr5rhc4|||_||_||_dS)zDo some setup after initialisation. :param targets: What is being assigned to. :param value: The value being assigned to the variables. :param type_annotation: N)rfr5rh)rrfr5rhs r6rzAssign.postinits(  #"DL .r8z#ClassVar[AssignedStmtsCall[Assign]]rc#6K|jEd{V|jVdSr0rers r6rzAssign.get_childrens4<jr8cV|gt|jzSr0)r r5_get_assign_nodesrs r6rmzAssign._get_assign_nodess%vTZ99;;<<<>>>>>>r8rdc\eZdZUdZdZdZ dddddfdZ dddZded< dZ xZ S) AnnAssigna Class representing an :class:`ast.AnnAssign` node. An :class:`AnnAssign` is an assignment with a type annotation. >>> import astroid >>> node = astroid.extract_node('variable: List[int] = range(10)') >>> node targetr&r5)simpleNrrrrr}rrrr-rcd|_ d|_ d|_ d|_ t |||||dSr_)rur&r5rvrrrs r6rzAnnAssign.__init__sg,&* ()-?$( 8"& K !!)      r8rurr&rvrjr5c>||_||_||_||_dS)aQDo some setup after initialisation. :param target: What is being assigned to. :param annotation: The type annotation of what is being assigned to. :param simple: Whether :attr:`target` is a pure name or a complex statement. :param value: The value being assigned to the variables. N)rur&r5rv)rrur&rvr5s r6rzAnnAssign.postinit2s$$ $  r8z&ClassVar[AssignedStmtsCall[AnnAssign]]rc#RK|jV|jV|j |jVdSdSr0rtrs r6rzAnnAssign.get_childrenNsJko : *       r8rrr0) rurr&rrvrjr5rr-r rrrrrrrrrrrrs@r6rsrss8OM"!% $ ( "&%)( ( ( ( ( ( ( ( ^ $ .;:::r8rsceZdZUdZdZdZejd ddddd fdZ d!d"dZ de d< de d<d#d$dZ dZ fdZ xZS)% AugAssignzClass representing an :class:`ast.AugAssign` node. An :class:`AugAssign` is an assignment paired with an operator. >>> import astroid >>> node = astroid.extract_node('variable += 1') >>> node rur5oprNrrrrrrr}rrrr-rcd|_ ||_ d|_ t|||||dS)aH :param op: The operator that is being combined with the assignment. This includes the equals sign. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. Nr)rurr5rrrrrrr}rrrs r6rzAugAssign.__init__dsa6&* (  %) 7 !!)      r8rur5c"||_||_dS)zDo some setup after initialisation. :param target: What is being assigned to. :param value: The value being assigned to the variable. Nr}rrur5s r6rzAugAssign.postinits  r8z&ClassVar[AssignedStmtsCall[AugAssign]]rzIClassVar[InferBinaryOperation[AugAssign, util.BadBinaryOperationMessage]]_infer_augassignr@rAcl ||}d|DS#t$rgcYSwxYw)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) rhcFg|]}t|tj|Srr1rBadBinaryOperationMessagersrs r6rz)AugAssign.type_errors..;fd&DEEr8)rrrr@resultss r6 type_errorszAugAssign.type_errorssd ++G+<>> import astroid >>> node = astroid.extract_node('a + b') >>> node leftrightr~rNrrrrrrr}rrrr-rcd|_ ||_ d|_ t|||||dS :param op: The operator. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. Nr)rrrrrrs r6rzBinOp.__init__s]4$( E $( F !!)      r8rrc"||_||_dS)zDo some setup after initialisation. :param left: What is being applied to the operator on the left side. :param right: What is being applied to the operator on the right side. Nr)rrrs r6rzBinOp.postinits  r8zEClassVar[InferBinaryOperation[BinOp, util.BadBinaryOperationMessage]] _infer_binopr@rAcl ||}d|DS#t$rgcYSwxYw)%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) rhcFg|]}t|tj|Srrrs r6rz%BinOp.type_errors..rr8)rrrs r6rzBinOp.type_errors sd '''88G%     III rc#.K|jV|jVdSr0rrs r6rzBinOp.get_childrens%ijr8c&t|jSr0rrrs r6 op_precedencezBinOp.op_precedence#TW%%r8r.c|jdkS)Nrr~rs r6op_left_associativezBinOp.op_left_associative&sw$r8rrr7)rrrrr-rr0rr;)rrrrrrrrrrrrrrrrrs@r6rrs (OM1Z1U;;;!!% $ ( "&%)( ( ( ( ( ( ( <;( TXWWW&&&&r8rceZdZdZdZdZejd dddddfdZdddZ dZ dZ xZ S)BoolOpzClass representing an :class:`ast.BoolOp` node. A :class:`BoolOp` is an application of a boolean operator. >>> import astroid >>> node = astroid.extract_node('a and b') >>> node rGr~rNrrrrrrr}rrrr-rct||_ g|_ t|||||dS)rrN)rrGrrrs r6rzBoolOp.__init__9sS4!$& 7 !!)      r8rGrc| ||_dSdS)znDo some setup after initialisation. :param values: The values being applied to the operator. NrrrGs r6rzBoolOp.postinitas!  ! DKKK ! !r8c#$K|jEd{VdSr0rrs r6rzBoolOp.get_childreni&;r8c&t|jSr0rrs r6rzBoolOp.op_precedencelrr8rrr0rGrr-r) rrrrrrrrrrrrrrs@r6rr+s"OM1Z1U;;;!!% $ % "&%)% % % % % % % <;% N!!!!!&&&&&&&r8rceZdZdZdS)BreakzClass representing an :class:`ast.Break` node. >>> import astroid >>> node = astroid.extract_node('break') >>> node Nrrrrrr8r6rrpr8rc~eZdZdZdZ dddddfdZ dddZeddZeddZ dZ xZ S)CallzClass representing an :class:`ast.Call` node. A :class:`Call` node is a call to a function, method, etc. >>> import astroid >>> node = astroid.extract_node('function()') >>> node r-rkeywordsNrrrrr}rrrr-rcd|_ g|_ g|_ t|||||dSr_)r-rrrrrs r6rz Call.__init__s],$( #"$ ?') < !!)      r8r-rrrlist[Keyword] | Nonec<||_|||_| ||_dSdS)zDo some setup after initialisation. :param func: What is being called. :param args: The positional arguments being given to the call. :param keywords: The keyword arguments being given to the call. Nr)rr-rrs r6rz Call.postinits7  DI  %$DMMM % %r8 list[Starred]c$d|jDS)z/The positional arguments that unpack something.c<g|]}t|t|Sr)r1Starred)rsr(s r6rz!Call.starargs..s'EEEJsG,D,DEEEEr8)rrs r6starargsz Call.starargssFEtyEEEEr8 list[Keyword]c$d|jDS)z,The keyword arguments that unpack something.c g|] }|j | Sr0r()rskeywords r6rzCall.kwargs..sLLLG LLLLr8)rrs r6kwargsz Call.kwargssMLt}LLLLr8c#PK|jV|jEd{V|jEd{VdSr0rrs r6rzCall.get_childrensKi9=         r8rr)r-rrrrrr-r)r-r)r-r) rrrrrrrpropertyrrrrrs@r6rrzs3O"!% $ % "&%)% % % % % % % % R#$()- %%%%%(FFFXFMMMXM!!!!!!!r8rcReZdZdZdZ dddddfdZ dddZdZdZxZ S)CompareaLClass representing an :class:`ast.Compare` node. A :class:`Compare` node indicates a comparison. >>> import astroid >>> node = astroid.extract_node('a <= b <= c') >>> node >>> node.ops [('<=', ), ('<=', )] ropsNrrrrr}rrrr-rctd|_ g|_ t|||||dSr_)rrrrrs r6rzCompare.__init__sS,$( K-/Q !!)      r8rrlist[tuple[str, NodeNG]] | Nonec*||_| ||_dSdS)zDo some setup after initialisation. :param left: The value at the left being applied to a comparison operator. :param ops: The remainder of the operators and their relevant right hand value. Nr)rrrs r6rzCompare.postinits(  DHHH  r8c#>K|jV|jD] \}}|V dS)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) Nr)r_ comparators r6rzCompare.get_childrensAi!X  MAz      r8c(|jddS)zsAn optimized version of list(get_children())[-1] :returns: The last child. :rtype: NodeNG r rO)rrs r6 last_childzCompare.last_child%sx|Ar8rrr7)rrrrr-r) rrrrrrrrrrrs@r6rrs  &O"!% $ " "&%)" " " " " " " " L#/3"   r8rceZdZUdZdZdZdZ ded<ded<ded<ded <ddfd Z dd dZ ded< dZ d!dZ dZ xZ S)" ComprehensionaClass representing an :class:`ast.comprehension` node. A :class:`Comprehension` indicates the loop inside any type of comprehension including generator expressions. >>> import astroid >>> 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' ruiterifs)is_asyncTrrrrrNr}rr-cd|_ d|_ g|_ d|_ t |dS)zD :param parent: The parent node in the syntax tree. Nr)rurrrrrrr}rs r6rzComprehension.__init__IsN&* 7#' 9!#N%) C '''''r8rurrrr bool | NonecB||_||_|||_||_dS)abDo some setup after initialisation. :param target: What is assigned to by the comprehension. :param iter: What is iterated over by the comprehension. :param ifs: The contents of any if statements that filter the comprehension. :param is_async: Whether this is an asynchronous comprehension or not. N)rurrr)rrurrrs r6rzComprehension.postinit\s,$   DH  r8z*ClassVar[AssignedStmtsCall[Comprehension]]rc|S)zwThe type of assignment that this node performs. :returns: The assignment type. :rtype: NodeNG rrs r6 assign_typezComprehension.assign_typeys  r8mystmt_base_nodes.Statement | Nonec||ur"t|ttfr|gdfSn|d|ur|gdfS|dfS)zmethod used in filter_stmtsTfutureF)r1rir statement)r lookup_noderCrrs r6_get_filtered_stmtsz!Comprehension._get_filtered_stmtssm 6> +t}55 +#}d** +^^4^ ( (F 2 64< e|r8c#HK|jV|jV|jEd{VdSr0rrs r6rzComprehension.get_childrens?ki8r8r0r}rr-rr) rurrrrrrrr-r)rr)rrrrrroptional_assignrrrrrrrrs@r6rr0s  0O!MO:LLL(((((((*!%"#' $ !!!!!0?>>> r8rceZdZUdZdZ d!dddd"fdZded<ded<fdZd#d$dZd%dZ dZ d&dZ d#d$d Z xZ S)'riaClass representing any constant including num, str, bool, None, bytes. >>> import astroid >>> node = astroid.extract_node('(5, "This is a string.", True, None, b"bytes")') >>> node >>> list(node.get_children()) [, , , , ] )r5kindNrr5r rrrr}rrrrrr-rc||_ ||_ t|||||t j|ddS)a} :param value: The value that the constant represents. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param kind: The string prefix. "u" for u-prefixed strings and ``None`` otherwise. Python 3.8+ only. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rN)r5rrrr) rr5rrr}rrrrs r6rzConst.__init__sd8  5 $ f !!)     $%%%%%r8zClassVar[InferUnaryOp[Const]]infer_unary_opzClassVar[InferBinaryOp[Const]]infer_binary_opc`|dkrtt|S)Nr5)AttributeErrorr __getattr__)rrrs r6rzConst.__getattr__s/ 7? ! ww""4(((r8r@rAcVt|tr|j}nGt|trt ||}n t dt |d t|jttfrt|j|Sno#t$r }td|jd||d}~wt$r}td||||d}~wt$r}t d ||||d}~wwxYwt |d |jd ) 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. rhzCould not use type rzCould not index z with NzIndex {index!r} out of rangervrz (value=rC)r1rir5rr~rrkrbytesrrrrr)rrnr@ index_valuers r6getitemz Const.getitems eU # # +KK u % % &ug>>>KK#Fd5kkFFF  $*sEl33 6TZ 4555 6   #F4:FF{FF    #6        ".TPW   $??$*???@@@s0&:B"" D,C DC(( D5D  Dr.cdS)zCheck if the node has a custom __getattr__ or __getattribute__. :returns: Whether the class has a custom __getattr__ or __getattribute__. For a :class:`Const` this is always ``False``. Frrs r6has_dynamic_getattrzConst.has_dynamic_getattr s ur8ct|jtrd|jDStdt |j)zAn iterator over the elements this node contains. :returns: The contents of this node. :rtype: iterable(Const) :raises TypeError: If this node does not represent something that is iterable. c,g|]}t|Sr)rrrs r6rz Const.itered..s ???DM$''???r8zCannot iterate over type )r1r5rrrkrs r6rz Const.iteredsP dj# & & @??DJ??? ?HD4D4DHHIIIr8rc4|jS)r)_proxiedqnamers r6rz Const.pytypes }""$$$r8c*t|jSzzDetermine the boolean value of this node. :returns: The boolean value of this node. :rtype: bool )r.r5rs r6rzConst.bool_value& DJr8r)r5r rrrrr}rrrrrrrr-rr0rr;r)rrrrrrrrrrrrrrrs@r6riris  &M "!% $ *&"&%)*&*&*&*&*&*&*&*&X21113333 ) ) ) ) )&A&A&A&A&AP J J J%%%%         r8riceZdZdZdS)ContinuezClass representing an :class:`ast.Continue` node. >>> import astroid >>> node = astroid.extract_node('continue') >>> node Nrrr8r6rr/rr8rcNeZdZdZdZ dddddfdZddZddZdZxZ S) DecoratorsaA node representing a list of decorators. A :class:`Decorators` is the decorators that are applied to a method or function. >>> import astroid >>> node = astroid.extract_node(''' @property def my_property(self): return 3 ''') >>> node >>> list(node.get_children())[0] r(Nrrrrr}rrrr-rcZ| t|||||dSrrrrs r6rzDecorators.__init__MsL,   !!)      r8r)rc||_dS)zDo some setup after initialisation. :param nodes: The decorators that this node contains. :type nodes: list(Name or Call) Nr()rr)s r6rzDecorators.postinitqs  r8r*c|jst||jjst|j|jjSzThe first parent node defining a new scope. These can be Module, FunctionDef, ClassDef, Lambda, or GeneratorExp nodes. :returns: The first parent scope node. ru)r}rrrs r6rzDecorators.scopeysV{ 2$D111 1{! 9$DK888 8{!'')))r8c#$K|jEd{VdSr0r(rs r6rzDecorators.get_childrens&:r8rr)r)rr-rr-r*) rrrrrrrrrrrs@r6rr9s"!O"!% $ " "&%)" " " " " " " " H * * * *r8rc|eZdZdZdZdZejd dddddfdZdddZ dZ xZ S)DelAttraVariation of :class:`ast.Delete` representing deletion of an attribute. >>> import astroid >>> node = astroid.extract_node('del self.attr') >>> node >>> list(node.get_children())[0] rLrNrNrrOrrrrr}rrrr-rctd|_ ||_ t|||||dS)a :param attrname: The name of the attribute that is being deleted. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. NrrQrRs r6rzDelAttr.__init__sW4$(  %- > !!)      r8rMc||_dSzDo some setup after initialisation. :param expr: The name that this node represents. :type expr: Name or None NrLrTs r6rzDelAttr.postinit  r8c#K|jVdSr0rLrs r6rzDelAttr.get_childrenrVr8rrWr0rX rrrrrrrrrrrrrs@r6rrs O!M1Z15AAA $!!% $ ( "&%)( ( ( ( ( ( ( BA( Tr8rcHeZdZdZdZ dddddfdZdddZdZxZS)DeletezClass representing an :class:`ast.Delete` node. A :class:`Delete` is a ``del`` statement this is deleting something. >>> import astroid >>> node = astroid.extract_node('del self.attr') >>> node rfNrrrrr}rrrr-rcdg|_ t|||||dSr)rfrrrs r6rzDelete.__init__sI,&( $ !!)      r8rfrc| ||_dSdS)z\Do some setup after initialisation. :param targets: What is being deleted. Nr)rrfs r6rzDelete.postinits!  #"DLLL # #r8c#$K|jEd{VdSr0rrs r6rzDelete.get_children s&<r8rrr0)rfrr-rrbrs@r6rrs#O"!% $  "&%)        B#####       r8rceZdZUdZdZ d!dddd"fdZd#dZded<ed$dZ d%dZ dZ dZ dZ d$d&dZd$d'd ZxZS)(DictzClass representing an :class:`ast.Dict` node. A :class:`Dict` is a dictionary that is created with ``{}`` syntax. >>> import astroid >>> node = astroid.extract_node('{1: "1"}') >>> node itemsNrrrrr}rrrr-rcdg|_ t|||||dSr)r rrrs r6rz Dict.__init__ sN0   ? !!)      r8r Alist[tuple[SuccessfulInferenceResult, SuccessfulInferenceResult]]c||_dS)ztDo some setup after initialisation. :param items: The key-value pairs contained in the dictionary. Nr)rr s r6rz Dict.postinit9 s r8zClassVar[InferUnaryOp[Dict]]rct|}|g|_n#d|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 Ncg|]C\}}t|t|t|rt|n|fDSrr)rskvs r6rz&Dict.from_elements..R s]AqQ<< q!!y||#J=#3#3#3Kr8r)rr rCs r6rzDict.from_elementsD sOsuu  DJJ!KKMMDJ  r8Literal['builtins.dict']cdS)rz builtins.dictrrs r6rz Dict.pytypeZ r8c#4K|jD] \}}|V|VdS)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) Nr)rkeyr5s r6rzDict.get_childrena s;*  JCIIIKKKK  r8c:|jr|jddSdS)zAn optimized version of list(get_children())[-1] :returns: The last child, or None if no children exist. :rtype: NodeNG or None r rONrrs r6rzDict.last_childn s$ : %:b>!$ $tr8c$d|jDS)zAn iterator over the keys this node contains. :returns: The keys of this node. :rtype: iterable(NodeNG) cg|]\}}|Srr)rsr,rs r6rzDict.itered..~ s///a///r8rrs r6rz Dict.iteredx s 0/DJ////r8rn Const | Slicer@rArcddlm}|jD]\}}t|trR|||}t|t s< |||cS#ttf$rYhwxYw| |D]Q}|tj urt|tr+t|tr|j |j kr|ccSRt|)aTGet an item from this node. :param index: The node to use as a subscript index. :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. r) safe_infer)astroid.helpersr2r r1 DictUnpackrrrrrHrrErir5)rrnr@r2r,r5inferred_value inferredkeys r6rz Dict.getitem s2 /.....* % %JC#z** !+E7!;!;!.$77)11%AAAAA(*;<H #yy11 % % $"22k511%j6N6N%"(EK7%$  % &&&s A##A76A7c*t|jSr)r.r rs r6rzDict.bool_value rr8rr)r r"r-rr0)r-r()rnr0r@rAr-rr)rrrrrrrrrrrrrrrrrrs@r6rr s.!O"!% $ ! "&%)! ! ! ! ! ! ! ! F1000[*   000HL"'"'"'"'"'H         r8rcNeZdZdZdZ dddddfdZdddZdZdZxZ S)Expra6Class representing an :class:`ast.Expr` node. An :class:`Expr` is any expression that does not have its value used or stored. >>> import astroid >>> node = astroid.extract_node('method()') >>> node >>> node.parent r4Nrrrrr}rrrr-rcdd|_ t|||||dSr_r5rrrs r6rz Expr.__init__ I,%) ' !!)      r8r5c||_dS)z]Do some setup after initialisation. :param value: What the expression does. Nr4rr5s r6rz Expr.postinit   r8c#K|jVdSr0r4rs r6rzExpr.get_children jr8c#dK|jjs!|jEd{VdSdSr0)r5 is_lambdarors r6roz"Expr._get_yield_nodes_skip_lambdas sLz# Bz??AA A A A A A A A A A B Br8rrr0r5rr-r rrrrrrrrrorrs@r6r9r9 s  !O"!% $  "&%)        BBBBBBBBr8r9ceZdZdZdS)EllipsiszClass representing an :class:`ast.Ellipsis` node. An :class:`Ellipsis` is the ``...`` syntax. Deprecated since v2.6.0 - Use :class:`Const` instead. Will be removed with the release v2.7.0 Nrrr8r6rGrG rr8rGceZdZdZdZddZdS) EmptyNodezAHolds an arbitrary object in the :attr:`LocalsDictNodeNG.locals`.Nr-r.c0|jduo |jtuSr0)objectrrs r6has_underlying_objectzEmptyNode.has_underlying_object s{$&R4;>R+RRr8r;)rrrrrKrLrr8r6rIrI s9KK FSSSSSSr8rIc~eZdZUdZdZdZ dddddfdZded< dZ dd dZ e dZ d!dZ xZ S)" ExceptHandleraClass representing an :class:`ast.ExceptHandler`. node. An :class:`ExceptHandler` is an ``except`` block on a try-except. >>> import astroid >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") ''') >>> node >>> node.handlers [] rkrrQrQNrrrrr}rrrr-rcd|_ d|_ g|_ t|||||dSr_)rkrrQrrrs r6rzExceptHandler.__init__ sa,$(  (, @"$ ( !!)      r8z*ClassVar[AssignedStmtsCall[ExceptHandler]]rc#dK|j |jV|j |jV|jEd{VdSr0rOrs r6rzExceptHandler.get_childrenF sP 9 )OOO 9 )OOO9r8rkrAssignName | NonerQrc8||_||_| ||_dSdS)a Do 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. :param body:The contents of the block. NrO)rrkrrQs r6rzExceptHandler.postinitP s/   DIII  r8c\|jr |jjS|jr |jjS|jSPThe line on which the beginning of this block ends. :type: int )rtolinenorkrrs r6blockstart_tolinenoz!ExceptHandler.blockstart_tolinenod s6 9 &9% % 9 &9% %{r8rLrMr.c~|jdStfd|jDS)zzCheck if this node handles any of the given :param exceptions: The names of the exceptions to check for. NTc3*K|] }|jvVdSr0r)rsrCrLs r6ruz&ExceptHandler.catch..w s*SSt49 *SSSSSSr8)rkrXr)rrLs `r6rWzExceptHandler.catchp sL 9   4SSSSty7P7P7R7RSSSSSSr8rr)rkrrrSrQrr-rrLrMr-r.)rrrrr_multi_line_block_fieldsrrrrr+rYrWrrs@r6rNrN s"/O("!% $ ( "&%)( ( ( ( ( ( ( ( T?>>>#"&$( (  _ TTTTTTTTr8rNceZdZdZdS)ExtSlicezClass representing an :class:`ast.ExtSlice` node. An :class:`ExtSlice` is a complex slice expression. Deprecated since v2.6.0 - Now part of the :class:`Subscript` node. Will be removed with the release of v2.7.0 Nrrr8r6r_r_z rr8r_ceZdZUdZdZdZdZdZ dddddfdZ dd dZ de d< e dZ dZ xZS)!ForzClass representing an :class:`ast.For` node. >>> import astroid >>> node = astroid.extract_node('for thing in things: print(thing)') >>> node rurrQrRrgrQrRTNrrrrr}rrrr-rcd|_ d|_ g|_ g|_ d|_ t |||||dSr_)rurrQrRrhrrrs r6rz For.__init__ sr,&* '#' *"$ 3$& =.2X !!)      r8rurrQrrRrhcT||_||_|||_|||_||_dS)aDo some setup after initialisation. :param target: What the loop assigns to. :param iter: What the loop iterates over. :param body: The contents of the body of the loop. :param orelse: The contents of the ``else`` block of the loop. N)rurrQrRrh)rrurrQrRrhs r6rz For.postinit s>$   DI  ! DK.r8z ClassVar[AssignedStmtsCall[For]]rc|jjSrV)rrXrs r6rYzFor.blockstart_tolineno  y!!r8c#bK|jV|jV|jEd{V|jEd{VdSr0rbrs r6rzFor.get_children sYki9;r8rr)NNNNN) rurrrrQrrRrrhrr-r)rrrrrrpr]rrrrr+rYrrrs@r6rara s ;O.1O"!% $ + "&%)+ + + + + + + + `!%"$(&*)- /////45444""_"r8raceZdZdZdS)AsyncForaClass representing an :class:`ast.AsyncFor` node. An :class:`AsyncFor` is an asynchronous :class:`For` built with the ``async`` keyword. >>> import astroid >>> node = astroid.extract_node(''' async def func(things): async for thing in things: print(thing) ''') >>> node >>> node.body[0] Nrrr8r6rjrj sr8rjcHeZdZdZdZ dddddfdZdddZdZxZS)AwaitaClass representing an :class:`ast.Await` node. An :class:`Await` is the ``await`` keyword. >>> import astroid >>> node = astroid.extract_node(''' async def func(things): await other_func() ''') >>> node >>> node.body[0] >>> list(node.body[0].get_children())[0] r4Nrrrrr}rrrr-rcdd|_ t|||||dSr_r;rs r6rzAwait.__init__ sI,%)  !!)      r8r5c||_dS)zUDo some setup after initialisation. :param value: What to wait for. Nr4r>s r6rzAwait.postinit@ r?r8c#K|jVdSr0r4rs r6rzAwait.get_childrenG rAr8rrr0rDrbrs@r6rlrl s"!O"!% $  "&%)        Br8rlc:eZdZdZdZ dddddfdZxZS) ImportFromzClass representing an :class:`ast.ImportFrom` node. >>> import astroid >>> node = astroid.extract_node('from my_package import my_module') >>> node )modnamenameslevelrNrfromnamerrslist[tuple[str, str | None]]rtrrrr}rrrr-rc||_ ||_ ||_ t|||||dS)a :param fromname: The module that is being imported from. :param names: What is being imported from the module. :param level: The level of relative import. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rN)rrrsrtrr) rrursrtrrr}rrrs r6rzImportFrom.__init__V si>$,  49  "'  !!)      r8)rNNN)rurrsrvrtrrrrrr}rrrrrr-rrrrrrrrrs@r6rqrqK ss2M !!% $: "&%): : : : : : : : : : : : r8rqc|eZdZdZdZdZejd dddddfdZdddZ dZ xZ S) Attributez2Class representing an :class:`ast.Attribute` node.rLrNrNrrOrrrrr}rrrr-rctd|_ ||_ t|||||dS)a :param attrname: The name of the attribute. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. NrrQrRs r6rzAttribute.__init__ sW4$(  %- ( !!)      r8rMc||_dSrrLrTs r6rzAttribute.postinit rr8c#K|jVdSr0rLrs r6rzAttribute.get_children rVr8rrWr0rXrrs@r6rzrz s<<O!M1Z15AAA $!!% $ ( "&%)( ( ( ( ( ( ( BA( Tr8rzc>eZdZdZdZ dddddfdZdZxZS)GlobalzClass representing an :class:`ast.Global` node. >>> import astroid >>> node = astroid.extract_node('global a_global') >>> node rsNrrs list[str]rrrr}rrrr-rcd||_ t|||||dS)a  :param names: The names being declared as global. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rNrsrrrrsrrr}rrrs r6rzGlobal.__init__ sI2!& 1 !!)      r8c|Sr0rrs r6rzGlobal._infer_name  r8rrsrrrrrr}rrrrrr-rrrrrrrrrrs@r6rr sM "!% $ " "&%)" " " " " " " " Hr8rceZdZdZdZdZ dddddfdZ dddZedZ dZ dZ dZ fdZ d dZd dZxZS)!rTzClass representing an :class:`ast.If` node. >>> import astroid >>> node = astroid.extract_node('if condition: print(True)') >>> node r\rQrRrcNrrrrr}rrrr-rcd|_ g|_ g|_ d|_ t |||||dS)rNFr)r\rQrR is_orelserrrs r6rz If.__init__ sg,$( 5"$ ($& 1$S !!)      r8r\rQrrRc||_|||_|||_t|jt r||jjvr d|_dSdSdS)Do some setup after initialisation. :param test: The condition that the statement tests. :param body: The contents of the block. :param orelse: The contents of the ``else`` block. NT)r\rQrRr1r}rTrrr\rQrRs r6rz If.postinit9 sm  DI  ! DK dk2 & & "44;3E+E "!DNNN " " " "r8c|jjSrVr\rXrs r6rYzIf.blockstart_tolinenoO rgr8c||jdjkr||fS||jdjkr||jdjfS|||j|jdjdz S)8Get 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) rr rO)rQrrX_elsed_block_rangerRrrs r6 block_rangezIf.block_rangeW sw TYq\, , "6> ! TYr]+ + 249R=11 1&&vt{DIaL>> import astroid >>> node = astroid.extract_node(''' import sys if sys.version_info > (3, 8): from typing import Literal else: from typing_extensions import Literal ''') >>> node.is_sys_guard() True zThe 'is_sys_guard' function is deprecated and will be removed in astroid 3.0.0 It has been moved to pylint and can be imported from 'pylint.checkers.utils' starting with pylint 2.12zsys.version_infoTF) warningswarnDeprecationWarningr1r\rr Subscriptr5rzr"r>s r6 is_sys_guardzIf.is_sys_guardu s   (     di ) ) INE%++ $ %++ 0A0AEW0W tur8ctjdtt|jt t fo+|jdS)aReturn True if IF stmt is a typing guard. >>> import astroid >>> node = astroid.extract_node(''' from typing import TYPE_CHECKING if TYPE_CHECKING: from xyz import a ''') >>> node.is_typing_guard() True zThe 'is_typing_guard' function is deprecated and will be removed in astroid 3.0.0 It has been moved to pylint and can be imported from 'pylint.checkers.utils' starting with pylint 2.12r) rrrr1r\rrzr"endswithrs r6is_typing_guardzIf.is_typing_guard sf   (      Ii(  >i!!##,,_== >r8rrr\rrQrrRrr-rr;)rrrrrr]rrr+rYrrrrorrrrs@r6rTrT s*1O1"!% $ ( "&%)( ( ( ( ( ( ( ( X#$(&* """"",""_"YYY  HHH;;;;; :>>>>>>>>r8rTcVeZdZdZdZ dddddfdZ dddZdZddZxZ S)IfExpzClass representing an :class:`ast.IfExp` node. >>> import astroid >>> node = astroid.extract_node('value if condition else other') >>> node rNrrrrr}rrrr-rcd|_ d|_ d|_ t|||||dSr_r\rQrRrrrs r6rzIfExp.__init__ s],$( 5#' (%) 1 !!)      r8r\rQrRc0||_||_||_dS)rNrrs r6rzIfExp.postinit s   r8c#@K|jV|jV|jVdSr0rrs r6rzIfExp.get_children s0iikr8Literal[False]cdS)NFrrs r6rzIfExp.op_left_associative s ur8rr)r\rrQrrRrr-r)r-r) rrrrrrrrrrrs@r6rr s1O"!% $ % "&%)% % % % % % % % R#" $ $ r8rcheZdZdZdZejd dddddfdZxZS)ImportzClass representing an :class:`ast.Import` node. >>> import astroid >>> node = astroid.extract_node('import astroid') >>> node rrvNrrs#list[tuple[str, str | None]] | Nonerrrr}rrrr-rch|pg|_ t|||||dS)a :param names: The names being imported. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rNrrs r6rzImport.__init__ sQ449;B  !!)      r8r)rsrrrrrr}rrrrrr-rrrs@r6rr sM1Z18VWWW6:!!% $ & "&%)& & & & & & & XW& & & & & r8rceZdZdZdS)IndexzClass representing an :class:`ast.Index` node. An :class:`Index` is a simple subscript. Deprecated since v2.6.0 - Now part of the :class:`Subscript` node. Will be removed with the release of v2.7.0 Nrrr8r6rr+ rr8rcNeZdZdZdZdZ dddddfdZdddZdZxZ S)KeywordzClass representing an :class:`ast.keyword` node. >>> import astroid >>> node = astroid.extract_node('function(a_kwarg=True)') >>> node >>> node.keywords [] r4rNrr(rrrrr}rrrr-rct||_ d|_ t|||||dS)a :param arg: The argument being assigned to. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. Nr)r(r5rr)rr(rrr}rrrs r6rzKeyword.__init__C sS2 #-$( ? !!)      r8r5c||_dS)zuDo some setup after initialisation. :param value: The value being assigned to the keyword argument. Nr4r>s r6rzKeyword.postinitj r?r8c#K|jVdSr0r4rs r6rzKeyword.get_childrenq rAr8r)r(rrrrrr}rrrrrr-rr0rD rrrrrrrrrrrs@r6rr5 s!OM!!% $ % "&%)% % % % % % % % Nr8rcneZdZUdZdZ dddddfdZded< ded<ded<ddZdd dZxZ S)!r<zClass representing an :class:`ast.List` node. >>> import astroid >>> node = astroid.extract_node('[1, 2, 3]') >>> node ctxNrrContext | Nonerrrr}rrrr-rcd||_ t|||||dS) :param ctx: Whether the list is assigned to or loaded from. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rNrrrrrrrr}rrrs r6rz List.__init__ sI2$'= !!)      r8z!ClassVar[AssignedStmtsCall[List]]rzClassVar[InferUnaryOp[List]]rzClassVar[InferBinaryOp[List]]rLiteral['builtins.list']cdS)rz builtins.listrrs r6rz List.pytype r*r8r@rAc2t||j||SzGet an item from this node. :param index: The node to use as a subscript index. :type index: Const or Slice rhrrDrrnr@s r6rz List.getitem  "$ 5'JJJJr8rrrrrrrr}rrrrrr-r)r-rr0r rrrrrrrrrrrs@r6r<r<u sM#!!% $ " "&%)" " " " " " " " H655510002222KKKKKKKKKr8r<c>eZdZdZdZ dddddfdZdZxZS)Nonlocala Class representing an :class:`ast.Nonlocal` node. >>> import astroid >>> node = astroid.extract_node(''' def function(): nonlocal var ''') >>> node >>> node.body[0] rNrrsrrrrr}rrrr-rcd||_ t|||||dS)a :param names: The names being declared as not local. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rNrrs r6rzNonlocal.__init__ sI2!& 4 !!)      r8c|Sr0rrs r6rzNonlocal._infer_name rr8rrrrs@r6rr s  M "!% $ " "&%)" " " " " " " " Hr8rceZdZdZdS)PasszClass representing an :class:`ast.Pass` node. >>> import astroid >>> node = astroid.extract_node('pass') >>> node Nrrr8r6rr rr8rcTeZdZdZdZ dddddfdZ dddZddZdZxZ S)RaisezClass representing an :class:`ast.Raise` node. >>> import astroid >>> node = astroid.extract_node('raise RuntimeError("Something bad happened!")') >>> node rcauseNrrrrr}rrrr-rctd|_ d|_ t|||||dSr_)rrrrrs r6rzRaise.__init__ sS,#'#$( 9 !!)      r8rrc"||_||_dS)zDo some setup after initialisation. :param exc: What is being raised. :param cause: The exception being used to raise this one. Nr)rrrs r6rzRaise.postinit-s r8r.ct|jsdStd|jDS)zCheck if this node raises a :class:`NotImplementedError`. :returns: Whether this node raises a :class:`NotImplementedError`. Fc3,K|]}|jdkVdS)NotImplementedErrorNr)rsrs r6ruz/Raise.raises_not_implemented..Bs;  37DI. .      r8)rrXrrs r6raises_not_implementedzRaise.raises_not_implemented;sO x 5  ;?8;S;S;U;U      r8c#NK|j |jV|j |jVdSdSr0rrs r6rzRaise.get_childrenFsC 8 (NNN : *       r8rrr7)rrrrr-rr;) rrrrrrrrrrrs@r6rr s'O"!% $ " "&%)" " " " " " " " L"#          r8rcTeZdZdZdZ dddddfdZdddZdZdZdZ xZ S)ReturnzClass representing an :class:`ast.Return` node. >>> import astroid >>> node = astroid.extract_node('return True') >>> node r4Nrrrrr}rrrr-rcdd|_ t|||||dSr_r;rs r6rzReturn.__init__Yr<r8r5c||_dS)z]Do some setup after initialisation. :param value: The value being returned. Nr4r>s r6rzReturn.postinitzr?r8c#.K|j |jVdSdSr0r4rs r6rzReturn.get_children. : *       r8c6t|jtSr0)r1r5r=rs r6is_tuple_returnzReturn.is_tuple_returns$*e,,,r8c#K|VdSr0rrs r6 _get_return_nodes_skip_functionsz'Return._get_return_nodes_skip_functions r8rrr0rD) rrrrrrrrrrrrs@r6rrNs!O"!% $  "&%)        B---r8rc&eZdZUdZded<ddZdS) SetzClass representing an :class:`ast.Set` node. >>> import astroid >>> node = astroid.extract_node('{1, 2, 3}') >>> node zClassVar[InferUnaryOp[Set]]rr-Literal['builtins.set']cdS)rz builtins.setrrs r6rz Set.pytypes ~r8N)r-r)rrrrrrrr8r6rrsB0///r8rceZdZdZdZ dddddfdZ dddZdZed dZ d!dZ d"d#dZ d"d#dZ dZ xZS)$rzClass representing an :class:`ast.Slice` node. >>> import astroid >>> node = astroid.extract_node('things[1:3]') >>> node >>> node.slice rxryrzNrrrrr}rrrr-rcd|_ d|_ d|_ t|||||dSr_)rxryrzrrrs r6rzSlice.__init__s],%) +$( +#' / !!)      r8rxryrzc0||_||_||_dS)zDo some setup after initialisation. :param lower: The lower index in the slice. :param upper: The upper index in the slice. :param step: The step to take between index. Nr)rrxryrzs r6rzSlice.postinits   r8c:|st|}||_|S|S)z7Wrap the empty attributes of the Slice in a Const node.)rr})rattrconsts r6_wrap_attributezSlice._wrap_attributes( !$''EELL r8nodes.ClassDefc^tj}|ddS)Nr|r)rbuiltins_moduler)rbuiltinss r6rzSlice._proxieds)!##3((++r8Literal['builtins.slice']cdS)rzbuiltins.slicerrs r6rz Slice.pytype  r8r@rAc#K|dkr||jVdS|dkr||jVdS|dkr||jVdS|||Ed{VdS)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) startstoprzrhN)rrxryrzrrrOr@s r6igetattrzSlice.igetattrs w  ?&&tz22 2 2 2 2 2   ?&&tz22 2 2 2 2 2   ?&&ty11 1 1 1 1 1||Hg|>> > > > > > > > > >r8c8|j||Sr0)rrrs r6rz Slice.getattr s}$$Xw777r8c#nK|j |jV|j |jV|j |jVdSdSr0rrs r6rzSlice.get_childrensY : *    : *    9 )OOOOO  r8rr)rxrryrrzrr-r)r-r)r-rr0r)rrrrrrrrr+rrrrrrrs@r6rrs1O"!% $ % "&%)% % % % % % % % R $#" $,,,_,    ?????$88888r8rc\eZdZUdZdZdZ dddddfdZdddZded< dZ xZ S)rzClass representing an :class:`ast.Starred` node. >>> import astroid >>> node = astroid.extract_node('*args') >>> node r4rNrrrrrrr}rrrr-rctd|_ ||_ t|||||dS)rNr)r5rrrrs r6rzStarred.__init__%sS2%) %#&E !!)      r8r5c||_dS)z[Do some setup after initialisation. :param value: What is being unpacked. Nr4r>s r6rzStarred.postinitLr?r8z$ClassVar[AssignedStmtsCall[Starred]]rc#K|jVdSr0r4rs r6rzStarred.get_childrenXrAr8rrr0rDrzrs@r6rrs!OM#!!% $ % "&%)% % % % % % % % N9888r8rc\eZdZUdZdZdZded< dddddfdZ dddZdZ xZ S)rzClass representing an :class:`ast.Subscript` node. >>> import astroid >>> node = astroid.extract_node('things[1:3]') >>> node r5r|rzClassVar[InferLHS[Subscript]]rNrrrrrrr}rrrr-rcd|_ d|_ ||_ t|||||dS)a! :param ctx: Whether the subscripted item is assigned to or loaded from. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. Nr)r5r|rrrrs r6rzSubscript.__init__js]2%) $$( -#&I !!)      r8r5r|c"||_||_dS)zDo some setup after initialisation. :param value: What is being indexed. :param slice: The slice being used to lookup. Nr)rr5r|s r6rzSubscript.postinits  r8c#.K|jV|jVdSr0rrs r6rzSubscript.get_childrens(jjr8rrr7)r5rr|rr-r) rrrrrrrrrrrrs@r6rr\s)OM,,,,#!!% $ ( "&%)( ( ( ( ( ( ( ( XCG     r8rc^eZdZdZdZdZ dddddfdZ dddZdZdZ dZ xZ S)rVaClass representing an :class:`ast.TryExcept` node. >>> import astroid >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") ''') >>> node rQrPrRNrrrrr}rrrr-rcg|_ g|_ g|_ t|||||dSr)rQrPrRrrrs r6rzTryExcept.__init__s],#% A-/ %$& 1 !!)      r8rQrrPlist[ExceptHandler] | NonerRc@|||_|||_| ||_dSdS)zDo some setup after initialisation. :param body: The contents of the block to catch exceptions from. :param handlers: The exception handlers. :param orelse: The contents of the ``else`` block. Nr )rrQrPrRs r6rzTryExcept.postinits?  DI  %$DM  ! DKKK ! !r8c|Sr0rrs r6rzTryExcept._infer_namerr8cFd}|jD]|}|jr||jjkr||fcS|jdj|cxkr|jdjkrnn||jdjfcS||jdjdz }}|||j|S)rNrr rO)rPrkrrQrXrrR)rrlast exhandlers r6rzTryExcept.block_ranges 8 8I~ &&IN,E"E &v~%%%~a +v ; ; ; ;9K9T ; ; ; ; ;y~b1::::: 8 ~a(3a7&&vt{DAAAr8c#`K|jEd{V|jpdEd{V|jpdEd{VdSr9r rs r6rzTryExcept.get_children sd9=&B&&&&&&&;$"$$$$$$$$$r8rr)rQrrPrrRrr-r) rrrrrr]rrrrrrrs@r6rVrVs  5O="!% $ % "&%)% % % % % % % % R%)/3&* !!!!!*BBB(%%%%%%%r8rVcVeZdZdZdZdZ dddddfdZ dddZdZdZ xZ S) TryFinallya3Class representing an :class:`ast.TryFinally` node. >>> import astroid >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") finally: print("Cleanup!") ''') >>> node rQ finalbodyNrrrrr}rrrr-rctg|_ g|_ t|||||dSr)rQrrrrs r6rzTryFinally.__init__$sS,/1 =')4 !!)      r8rQlist[NodeNG | TryExcept] | Nonerrc.|||_| ||_dSdS)zDo some setup after initialisation. :param body: The try-except that the finally is attached to. :param finalbody: The contents of the ``finally`` block. Nr)rrQrs r6rzTryFinally.postinitHs0  DI  '&DNNN ' 'r8c|jd}t|tr?|j|jkr/|j|cxkr |jkrnn||S|||jS)rr)rQr1rVrrXrrr)rrchilds r6rzTryFinally.block_rangeXs !  ui ( ( - DO3 -& - - - -,0? - - - - - $$V,, ,&&vt~>>>r8c#>K|jEd{V|jEd{VdSr0rrs r6rzTryFinally.get_childrenls@9>!!!!!!!!!r8rrr7)rQrrrr-r) rrrrrr]rrrrrrs@r6rrs  ,O4"!% $ " "&%)" " " " " " " " L15)-''''' ???("""""""r8rcneZdZUdZdZ dddddfdZded< ded<ded<ddZdd dZxZ S)!r=zClass representing an :class:`ast.Tuple` node. >>> import astroid >>> node = astroid.extract_node('(1, 2, 3)') >>> node rNrrrrrrr}rrrr-rcd||_ t|||||dS)a :param ctx: Whether the tuple is assigned to or loaded from. :param lineno: The line that this node appears on in the source code. :param col_offset: The column that this node appears on in the source code. :param parent: The parent node in the syntax tree. :param end_lineno: The last line this node appears on in the source code. :param end_col_offset: The end column this node appears on in the source code. Note: This is after the last symbol. rNrrs r6rzTuple.__init__|sI2$'> !!)      r8z"ClassVar[AssignedStmtsCall[Tuple]]rzClassVar[InferUnaryOp[Tuple]]rzClassVar[InferBinaryOp[Tuple]]rLiteral['builtins.tuple']cdS)rzbuiltins.tuplerrs r6rz Tuple.pytyperr8r@rAc2t||j||Srrrs r6rz Tuple.getitemrr8rr)r-r"r0rrrs@r6r=r=qsM#!!% $ " "&%)" " " " " " " " H766621113333    KKKKKKKKKr8r=ceZdZUdZdZdZejd dddddfdZdddZ de d<dd dZ dZ fdZ xZS)!UnaryOpzClass representing an :class:`ast.UnaryOp` node. >>> import astroid >>> node = astroid.extract_node('-5') >>> node operandr~rNrrrrrrr}rrrr-rct||_ d|_ t|||||dSr)rr(rrrs r6rzUnaryOp.__init__sS4!&* 4 !!)      r8r(c||_dS)zlDo some setup after initialisation. :param operand: What the unary operator is applied to. Nr')rr(s r6rzUnaryOp.postinits  r8zFClassVar[InferBinaryOperation[UnaryOp, util.BadUnaryOperationMessage]]_infer_unaryopr@rAcl ||}d|DS#t$rgcYSwxYw)rrhcFg|]}t|tj|Sr)r1rBadUnaryOperationMessagers r6rz'UnaryOp.type_errors..s;fd&CDDr8)r+rrs r6rzUnaryOp.type_errorssd ))')::G%     III rc#K|jVdSr0r'rs r6rzUnaryOp.get_children slr8c~|jdkrt|jStS)Nnot)rrrrrs r6rzUnaryOp.op_precedences5 7e  * ) )ww$$&&&r8rrr0)r(rr-rr)rrrrrrrrrrrrrrrrs@r6r&r&s#OM1Z1U;;;!!% $ % "&%)% % % % % % % <;% N&'''''''''r8r&cxeZdZdZdZdZ dddddfdZ dddZedZ dZ dZ fdZ xZ S)WhilezClass representing an :class:`ast.While` node. >>> import astroid >>> node = astroid.extract_node(''' while condition(): print("True") ''') >>> node rrcNrrrrr}rrrr-rcd|_ g|_ g|_ t|||||dSr_rrs r6rzWhile.__init__$s],$( 0"$ '$& 1 !!)      r8r\rQrrRc<||_|||_| ||_dSdS)zDo some setup after initialisation. :param test: The condition that the loop tests. :param body: The contents of the loop. :param orelse: The contents of the ``else`` block. Nrrs r6rzWhile.postinitKs7  DI  ! DKKK ! !r8c|jjSrVrrs r6rYzWhile.blockstart_tolineno_rgr8c8|||jS)r)rrRrs r6rzWhile.block_rangegs&&vt{;;;r8c#PK|jV|jEd{V|jEd{VdSr0rrs r6rzWhile.get_childrensrr8c#K|jEd{VtEd{VdS)z1A While node can contain a Yield node in the testNrrs r6roz#While._get_yield_nodes_skip_lambdasyrr8rrr)rrrrrr]rrr+rYrrrorrs@r6r3r3s  1O1"!% $ % "&%)% % % % % % % % R#$(&* !!!!!(""_" < < < ;;;;;;;;;r8r3czeZdZUdZdZdZdZ dddddfdZ dddZde d< e dZ dZ xZ S)WithzClass representing an :class:`ast.With` node. >>> import astroid >>> node = astroid.extract_node(''' with open(file_path) as file_: print(file_.read()) ''') >>> node r rQrgrPNrrrrr}rrrr-rcg|_ g|_ d|_ t|||||dSr_)r rQrhrrrs r6rz With.__init__s^,:< O"$ 1.2X !!)      r8r )list[tuple[NodeNG, NodeNG | None]] | NonerQrrhc8|||_|||_||_dS)zDo some setup after initialisation. :param items: The pairs of context managers and the names they are assigned to. :param body: The contents of the ``with`` block. N)r rQrh)rr rQrhs r6rz With.postinits0  DJ  DI.r8z!ClassVar[AssignedStmtsCall[With]]rc2|jddjS)rWr r)r rXrs r6rYzWith.blockstart_tolinenos z"~a ))r8c#RK|jD]\}}|V|r|V|jEd{VdS)zoGet the child nodes below this node. :returns: The children. :rtype: iterable(NodeNG) Nr<)rrMvars r6rzWith.get_childrensX   ID#JJJ  9r8rr)r r>rQrrhrr-r)rrrrrrpr]rrrr+rYrrrs@r6r;r;s  (O.("!% $ % "&%)% % % % % % % % R<@$()- /////&6555**_*       r8r;ceZdZdZdS) AsyncWithz7Asynchronous ``with`` built with the ``async`` keyword.Nrrr8r6rDrDsAAAAr8rDcNeZdZdZdZ dddddfdZdddZdZdZxZ S)YieldzClass representing an :class:`ast.Yield` node. >>> import astroid >>> node = astroid.extract_node('yield True') >>> node r4Nrrrrr}rrrr-rcdd|_ t|||||dSr_r;rs r6rzYield.__init__sI,%) ! !!)      r8r5c||_dS)zWDo some setup after initialisation. :param value: The value to yield. Nr4r>s r6rzYield.postinitr?r8c#.K|j |jVdSdSr0r4rs r6rzYield.get_childrenrr8c#K|VdSr0rrs r6roz#Yield._get_yield_nodes_skip_lambdas"rr8rrr0rDrErs@r6rFrFs!O"!% $  "&%)        Br8rFceZdZdZdS) YieldFromz2Class representing an :class:`ast.YieldFrom` node.Nrrr8r6rLrL&s<<<Represents the unpacking of dicts into dicts using :pep:`448`.Nrrr8r6r4r4*sHHHHr8r4cPeZdZdZdZdZ dddddfdZ dddZdZxZ S)FormattedValueaPClass representing an :class:`ast.FormattedValue` node. Represents a :pep:`498` format string. >>> import astroid >>> node = astroid.extract_node('f"Format {type_}"') >>> node >>> node.values [, ] r5 format_spec) conversionNrrrrr}rrrr-rcz| d|_ d|_ t|||||dSr_)rRrQrrrs r6rzFormattedValue.__init__>se, 8&* +/  !!)      r8r5rrRrQc0||_||_||_dS)a2Do some setup after initialisation. :param value: The value to be formatted into the string. :param conversion: The type of formatting to be applied to the value. :param format_spec: The formatting to be applied to the value. :type format_spec: JoinedStr or None N)r5rRrQ)rr5rRrQs r6rzFormattedValue.postinitos  $&r8c#@K|jV|j |jVdSdSr0rPrs r6rzFormattedValue.get_childrens>j   #" " " " " " # #r8rrr7)r5rrRrrQrr-rrrs@r6rOrO.s  /O#M"!% $ / "&%)/ / / / / / / / h"&%) '''''&#######r8rOcHeZdZdZdZ dddddfdZdddZdZxZS) JoinedStrzRepresents a list of string expressions to be joined. >>> import astroid >>> node = astroid.extract_node('f"Format {type_}"') >>> node rNrrrrr}rrrr-rcdg|_ t|||||dSr)rGrrrs r6rzJoinedStr.__init__sM,%'  !!)      r8rGrc| ||_dSdS)zDo some setup after initialisation. :param value: The string expressions to be joined. :type: list(FormattedValue or Const) Nrrs r6rzJoinedStr.postinits!  ! DKKK ! !r8c#$K|jEd{VdSr0rrs r6rzJoinedStr.get_childrenrr8rrr0rrbrs@r6rWrWs"O"!% $ " "&%)" " " " " " " " H!!!!!r8rWcreZdZUdZdZdZ d!dddd"fdZd#dZded< ddd$dZ d%dZ d&d Z xZ S)' NamedExprzRepresents the assignment from the assignment expression >>> import astroid >>> module = astroid.parse('if a := 1: pass') >>> module.body[0].test r}TNrrrrr}rrrr-rc`| | t|||||dSrrrs r6rzNamedExpr.__init__sU,  < !!)      r8rurr5c"||_||_dSr0r}rs r6rzNamedExpr.postinits  r8z&ClassVar[AssignedStmtsCall[NamedExpr]]rrrLiteral[None, True]@nodes.FunctionDef | nodes.Module | nodes.ClassDef | nodes.Lambdac|jst|t|jttt frq|jjst|j|jjjst|jj|jjjdS|jdS)zThe first parent frame node. A frame node is a :class:`Module`, :class:`FunctionDef`, or :class:`ClassDef`. :returns: The first parent frame node. r Tr)r}rr1rrrr)rrs r6rzNamedExpr.frames{ 2$D111 1 dkIw #F G G @;% =( <<<<;%, D( 0BCCCC;%,22$2?? ?{   ---r8r*c|jst|t|jttt fro|jjst|j|jjjst|jj|jjjS|jSr )r}rr1rrrrrs r6rzNamedExpr.scopes { 2$D111 1 dkIw #F G G 5;% =( <<<<;%, D( 0BCCCC;%,2244 4{  """r8rrrIcZ|d||dS)a{Define that the given name is declared in the given statement node. NamedExpr's in Arguments, Keyword or Comprehension are evaluated in their parent's parent scope. So we add to their frame's locals. .. seealso:: :meth:`scope` :param name: The name that is being defined. :param stmt: The statement that defines the given name. TrN)r set_local)rrrIs r6rdzNamedExpr.set_local0s. $ ))$55555r8rr)rurr5rr-r)rr_r-r`r)rrrIrr-r) rrrrrrrrrrrrdrrs@r6r\r\s*OOH "!% $ % "&%)% % % % % % % % N;::: 04.......####& 6 6 6 6 6 6 6 6r8r\c(eZdZdZdZd dZd d dZdS) 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. r-Literal['Unknown']cdS)Nrfrrs r6rz Unknown.qnameGsyr8Nr@rAc+&KtjVdS)z4Inference on an Unknown node immediately terminates.N)rrErr@rs r6_inferzUnknown._inferJsr8)r-rgr0r)rrrrrrrkrr8r6rfrf>sR Dr8rfc<eZdZdZdZdZdZdfd Z dddZxZ S)EvaluatedObjectzContains an object that has already been inferred This class is useful to pre-evaluate a particular node, with the resulting class acting as the non-evaluated node. )originalr4rnrr5NodeNG | type[util.Uninferable]r-rc||_ ||_ t|jj|jj|jjdS)N)rrr})rnr5rrrrr})rrnr5rs r6rzEvaluatedObject.__init__Zs\!) ?6;   ='}/='      r8Nr@rArr 6Generator[NodeNG | type[util.Uninferable], None, None]c+K|jVdSr0r4rjs r6rkzEvaluatedObject._inferisjr8)rnrr5ror-rr0)r@rArr r-rq) rrrrrrrrrkrrs@r6rmrmOsv D#OM       26r8rmc@eZdZdZdZ dddddfdZddZxZS)MatchzClass representing a :class:`ast.Match` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 200: ... case _: ... ''') >>> node subjectcasesNrrrrr}rrrr-rc\||t|||||dSNrrrs r6rzMatch.__init__sK  # !!)      r8rvrrwlist[MatchCase]c"||_||_dSr0ru)rrvrws r6rzMatch.postinits   r8rr)rvrrwrzr-rrrrrrrrrrs@r6rtrtrs  +O"!% $  "&%)        &r8rtceZdZdZdS)Patternz!Base class for all Pattern nodes.Nrrr8r6r~r~s++++r8r~cdeZdZUdZdZdZded<ded<ded<ded<d d dfdZddZxZ S) MatchCasezClass representing a :class:`ast.match_case` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 200: ... ''') >>> node.cases[0] patternguardrQrPrrrrrNrr}rr-cX|||t|dS)Nrrrs r6rzMatchCase.__init__s6  !  '''''r8rr~rrQrc0||_||_||_dSr0r)rrrrQs r6rzMatchCase.postinits   r8r)rr~rrrQrr-r) rrrrrr]rrrrrs@r6rrs  3O(LLL26((((((((        r8rc@eZdZdZdZ dddddfdZddZxZS) MatchValuezClass representing a :class:`ast.MatchValue` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 200: ... ''') >>> node.cases[0].pattern r4Nrrrrr}rrrr-rcX|t|||||dSryrrs r6rzMatchValue.__init__sE  !!)      r8r5rc||_dSr0r4r>s r6rzMatchValue.postinits  r8rr)r5rr-rr|rs@r6rrs  !O"!% $  "&%)        $r8rc6eZdZdZdZdddddddfdZxZS)MatchSingletonaClass representing a :class:`ast.MatchSingleton` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case True: ... case False: ... case None: ... ''') >>> node.cases[0].pattern >>> node.cases[1].pattern >>> node.cases[2].pattern r4Nrr5Literal[True, False, None]rrrrrr}rr-rcb||_t|||||dSryr;)rr5rrrrr}rs r6rzMatchSingleton.__init__sF  !!)      r8)r5rrrrrrrrrr}rr-rrxrs@r6rrsi(M "!%!%%) $            r8rc@eZdZdZdZ dddddfdZddZxZS) MatchSequenceahClass representing a :class:`ast.MatchSequence` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case [1, 2]: ... case (1, 2, *_): ... ''') >>> node.cases[0].pattern >>> node.cases[1].pattern patternsNrrrrr}rrrr-rcX|t|||||dSryrrs r6rzMatchSequence.__init__.E $ !!)      r8r list[Pattern]c||_dSr0rrrs r6rzMatchSequence.postinit@   r8rrrrr-rr|rs@r6rrs $O"!% $  "&%)        $!!!!!!!!r8rcLeZdZUdZdZ dddddfdZddZded<xZS) MatchMappingaClass representing a :class:`ast.MatchMapping` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case {1: "Hello", 2: "World", 3: _, **rest}: ... ''') >>> node.cases[0].pattern keysrrestNrrrrr}rrrr-rc`|||t|||||dSryrrs r6rzMatchMapping.__init__SsQ  $ $ !!)      r8rrrrrrSc0||_||_||_dSr0r)rrrrs r6rzMatchMapping.postinitgs    r8zlClassVar[Callable[[MatchMapping, AssignName, InferenceContext | None, None], Generator[NodeNG, None, None]]]rrr)rrrrrrSr-r rrrrrrrrrrs@r6rrDs  3O"!% $  "&%)        (        r8rcDeZdZdZdZdZ dddddfdZddZxZS) MatchClassarClass representing a :class:`ast.MatchClass` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case Point2D(0, 0): ... case Point3D(x=0, y=0, z=0): ... ''') >>> node.cases[0].pattern >>> node.cases[1].pattern )rr kwd_patterns) kwd_attrsNrrrrr}rrrr-rcd||||t|||||dSryrrs r6rzMatchClass.__init__sW  $ ! ( !!)      r8rrrrrrrc>||_||_||_||_dSr0)rrrr)rrrrrs r6rzMatchClass.postinits'  "(r8rr) rrrrrrrrr-r) rrrrrrrrrrs@r6rrs :O"M"!% $  "&%)        * ) ) ) ) ) ) ) )r8rcLeZdZUdZdZ dddddfdZddZded<xZS) MatchStarzClass representing a :class:`ast.MatchStar` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case [1, *_]: ... ''') >>> node.cases[0].pattern.patterns[1] rNrrrrr}rrrr-rcX|t|||||dSryrrs r6rzMatchStar.__init__rr8rrSc||_dSr0rrs r6rzMatchStar.postinits  r8ziClassVar[Callable[[MatchStar, AssignName, InferenceContext | None, None], Generator[NodeNG, None, None]]]rrr)rrSr-rrrs@r6rrs   O"!% $  "&%)        $    r8rcLeZdZUdZdZ dddddfdZddZded<xZS)MatchAsa=Class representing a :class:`ast.MatchAs` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case [1, a]: ... case {'key': b}: ... case Point2D(0, 0) as c: ... case d: ... ''') >>> node.cases[0].pattern.patterns[1] >>> node.cases[1].pattern.patterns[0] >>> node.cases[2].pattern >>> node.cases[3].pattern rrNrrrrr}rrrr-rc\||t|||||dSryrrs r6rzMatchAs.__init__sK $ $ !!)      r8rPattern | NonerrSc"||_||_dSr0r)rrrs r6rzMatchAs.postinits   r8zgClassVar[Callable[[MatchAs, AssignName, InferenceContext | None, None], Generator[NodeNG, None, None]]]rrr)rrrrSr-rrrs@r6rrs0*O"!% $  "&%)        &    r8rc@eZdZdZdZ dddddfdZddZxZS)MatchOrzClass representing a :class:`ast.MatchOr` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 400 | 401 | 402: ... ''') >>> node.cases[0].pattern rNrrrrr}rrrr-rcX|t|||||dSryrrs r6rzMatchOr.__init__Crr8rrc||_dSr0rrs r6rzMatchOr.postinitUrr8rrrr|rs@r6rr4s  $O"!% $  "&%)        $!!!!!!!!r8r.zdict[type, type[NodeNG]]r3r5 Iterable[Any]rCList | Set | Tuplercjg}|D]-}t|}||_||.|S)zACreate a list of nodes to function as the elements of a new node.)rr}r)r5rCelementselement element_nodes r6_create_basic_elementsrnsG H&&$W-- "  %%%% Or8rGMapping[Any, Any]r"cg}|D]H\}}t|}||_t|}||_|||fI|S)zHCreate a list of node pairs to function as the items of a new dict node.)r rr}r)rGrCrr,r5key_node value_nodes r6_create_dict_itemsrzsnSUHllnn00 U %%"5))  :.//// Or8r r ct|trJ|jtvrt }||_|St|j}t |tttfr/|}| t|||St |tr/|}| t|||St|S)z*Return an astroid node for a python value.)r1rrr3rIrK issubclassr<rr=rrrrri)r5rCinitializer_clsrs r6rrs%(((((  i'{{   0O/D#u#566"?$$0AABBB/4(("?$$,UH==>>> <<r8r;r0rr\r<rr:)r5rrCrr-r)rGrrCrr-r")r5r r-r )r __future__rrr systypingrcollections.abcrrr functoolsrrr r r r r rastroidrr astroid.basesrr astroid.constrrastroid.contextrastroid.exceptionsrrrrrrastroid.managerr astroid.nodesrastroid.nodes.constrastroid.nodes.node_ngrastroid.typingr r!r"r#r$ version_infor'typing_extensionsr)r*r+astroid.decoratorsr,r7r9BadOperationMessager;AssignedStmtsPossibleNoder<rjAssignedStmtsCallInferBinaryOperationInferLHSr InferUnaryOpraise_if_nothing_inferredrFrfrKrmror~rParentAssignNodeABCMetarrNoChildrenNoder>rrAssignTypeNoderr.rr? StatementrZrdrsr|rrrrrrrirrrrrr9rGrIMultiLineBlockNoderNr_MultiLineWithElseBlockNoderarjrl ImportNoderqrzrrTrrrrrrrrrrrrrVrr=r&r3r;rDrFrLr4rOrWr\rfrmrtr~rrrrrrrrrr r2dictrErkNotImplementedr.floatcomplexrr3rrrrrr8r6rs BAA""""""  8888888888SSSSSSSSSSSSSSSSSS$$$$$$$$0000000077777777,,,,,,+*****%%%%%%------((((((v*))))))/......vE)))))))DDDDDD//// ')6 * * *)1IJJJ!"ST!!"S!"      h'() U?N:;T4GHJ  h'() _dH5G,HHIK #(::;  %....&%.4BBBBBN&((6     HHHHHBUUUUUK0(ckUUUUr33333&333J<<<<<+[+:V<<<~2 2 2 2 2 k(+{7S2 2 2 j;4;4;4;4;4; %{;4;4;4|qqqqq *qqqh    OS@GGGGG-GGGT?????[ "???DV>V>V>V>V>[ ')>V>V>V>rYYYYY *K,AYYYxm;m;m;m;m; *K,Am;m;m;`bbbbbFbbbJB&B&B&B&B&VB&B&B&JK & (=W!W!W!W!W!6W!W!W!tXXXXXfXXXxeeeeeFeeePT T T T T K &T T T n{);+@NNNNNNNNbBBBBBk*BBBJ7 7 7 7 7 [ ')>7 7 7 ta a a a a 68a a a H=B=B=B=B=B; =B=B=B@{)SSSSS *SSSwTwTwTwTwT"K$> @UwTwTwTtvqqqqq*qqqhs&=====F===@E E E E E 'E E E P::::::::z00000[ ')>000fc>c>c>c>c> /1Fc>c>c>LKKKKKFKKK\1 1 1 1 1 [ #1 1 1 hF=====f===@DKDKDKDKDK=DKDKDKN55555{);+@555p; %{'<MMMMMK !MMM`;;;;;[ ";;;|-&wwwwwFwwwt@@@@@k*@@@FGGGGGGGGTh%h%h%h%h% 6 8Mh%h%h%V]"]"]"]"]"79N]"]"]"@DKDKDKDKDKMDKDKDKNZ'Z'Z'Z'Z'fZ'Z'Z'zg;g;g;g;g;K 2K4Ig;g;g;Teeeee*eeePBBBBBBBB88888F888v========IIIII+IIIX#X#X#X#X#VX#X#X#v::::::::zu6u6u6u6u6 *u6u6u6pk("fF+++++K !+++\,,,,,f,,,$$$$$ .$$$N""""""""J( ( ( ( ( W( ( ( V&!&!&!&!&!G&!&!&!R;;;;;;-w;;;|4)4)4)4)4)4)4)4)n11111 *G111hDDDDDk('DDDN"!"!"!"!"!g"!"!"!T $ 5$DJJD%DIIu% 5 U 5' "        r8