.h UdZddlmZddlZddlZddlZddlZddlZddlm 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^ZGdde*jue*j^ZGddeSZGdde.ZGdde*jue*j^ZGdde*jue*jYe*j^ZGddeZGdde.ZGddeZGdde*jUZGdde.ZGdde.ZGdde*jYZGdde*jYZGdde.ZGdde*j^e*jrZGdde.ZGdde*jrZGddeZGddeZGddeZGdde*jYeZGddeZGdde*jYeZGdde*jYeZGd„deZeeBeeeeneeedeieeeiedĦ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 l/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/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]7}t|tj r|V!t ||Ed{V8||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_infernextinferUninferableBase)stmtr@eltinferreds r6rFrFUs* $u &&29 2 2Cd&&& #C11 1 1 1 1 1 1 1 1111DJJw'')9::H4111JJw''77 h 4 5 5 7NNNN#Hg66 6 6 6 6 6 6 6 6W - --r8 exceptionslist[str] | Noneci}i}|}|D]}d||<|||<|}|}|D]K}||vrAt|trK|I||\}}|||\} } d| |fvrdS| |krdSnt|tr||\}}|||\} } | |urw|dko| dko||} |dko | dko|||} |dko| dk} |dko| dk}t | | | |frdSn|dkr| dkr |||ucSdS|}MdS) 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 NtestFThandlersbodyorelse)node_ancestorsr1If locate_child TryExceptcatchany)stmt1stmt2rM 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_exclusiverhpsGMHH$$&& d!H$$&&.. = $##( : (:!%!2!28!!B!Bff---!55V##44$D),, :!%!2!28!!B!B''*,7"f,7$NN:665 &(="j0=$TN00<<6 *,C81C4(*Cv/C5<=;< $ $tt$z))f .B.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@rLs r6 _slice_valuerqs%* 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)ro.0elems r6 z_infer_slice..s' H H44 & H H H H H Hr8z'Could not infer slice used in subscriptmessagerCrpr@)rqlowerupperstepallslicerparent)rCr@rzr{r|s r6 _infer_slicers 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.rjz&Slice {index!r} cannot index containerrxNzIndex {index!s} out of rangeType error {error!r}zCould not use  as subscript index)r1Slicer __class__rDrrkr5 ValueErrorr IndexErrorr TypeErrorr)instancerDrpr@ 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. rrrrrN)rDsuper__init__selfrrrrrrs 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)rues r6 z/BaseContainer.from_elements..Ds0OOOQYq\\@q)))qOOOr8r)clsrDrCs r6 from_elementszBaseContainer.from_elements6s7suu <DIIOO$OOODI r8c|jS)zAn iterator over the elements this node contains. :returns: The contents of this node. :rtype: iterable(NodeNG) rrs r6iteredzBaseContainer.iteredGs 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_valueOs DIr8strcdS)eGet the name of the type that this node represents. :returns: The name of the type. Nrrs r6pytypezBaseContainer.pytypeVsr8c#$K|jEd{VdSr0rrs r6 get_childrenzBaseContainer.get_children]s&9r8NNN rrrrrrrrrrr-r)rDrr-rr0)r@rAr-r.r-r)__name__ __module__ __qualname____doc___astroid_fieldsrr classmethodrrrabcabstractmethodrr __classcell__rs@r6rr s88O"!% $  "&%)        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.lookupes"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.ilookupus6{{4(( u"$$E7E222r8N)rrr-r)rrrrrrrrr8r6rrbsM55Y[[ 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 | Nonerrrrrrrr-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. rNrrrrrrrrrrrs r6rzAssignName.__init__sI4!% + !!)      r8z'ClassVar[AssignedStmtsCall[AssignName]]assigned_stmtsNNNNrrrrrrrrrrrrr-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' rrNrrrrrrrrrrr-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' rrNrrrrrrrrrrr-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_nodes2s[ ++-- 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)varargkwargrrrrrNrrrrrr-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. rN) rrrrrrrrrrrr)rrrrrs r6rzArguments.__init__hs '''"( 8!& @ *  *O )G-/A 4 -P<>$U;=#S68 =?$ >@% 04D.2LLr8rlist[AssignName] | Nonerlist[NodeNG] | Nonerlist[AssignName]rlist[NodeNG | None] | Nonerlist[NodeNG | None]rrrrrrrrc||_||_||_|||_||_||_|||_|||_| |_| |_ | | |_ | | |_ | | |_ 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 && ! -*@D ' " .+BD ( 0.  (%6D " " .+BD ( # /,DD ) ) ) 0 /r8z&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.fromlinenos+ #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_args#s #% )-& = 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_onlyrrrrpposonly annotationdefaultargdefaults_offset default_indexrs r6_get_arguments_datazArguments._get_arguments_dataUs>@<>$& )-& = W9?D-1]CII:<<-H *'+}5Us4=7I7ICPTII7U5U'V $'(899 ; ;NE7"&">u"EtJ%'1133 ' F259CCEE&0'%:HW\ " "#DI.. 7 7JE3"&"25"94J%'1133 - X"%di..37U3V3V"V % 7 !B&&6}EQ<]KUUWWG",g!6HSX   ; 7.J%'1133 %/$6HT[ !%do66 8 8LE54U;J%'1133 &u-G"!++--#-w"7GEJ   : 5-J%'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)rargnamerrpidxs r6 default_valuezArguments.default_values~'4((+  3t99s4='9'99:Caxx}S))'4?33A6  !1%!8!D#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)recrPN)rr find_argnamerr0rs 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)rr0)rr1r5s r6r6zArguments.find_argnames' > ;Wdnc:: :zr8c#LK|jpdEd{V|jD]}||V |jpdEd{V|j |jEd{V|jEd{V|jpdD]}||V |jD]}||V |j |jV|j |jV|j D]}||V dSNr) rrrrrrrrrr)rrKs r6rzArguments.get_childrensC#)r)))))))/  C 9?""""""" = $} $ $ $ $ $ $ $?"""""""#)r  C #  C  ,' ' ' '   +& & & &.  C   r8r)rrrrrrr-r)NNNNNNNN)rrrrrrrrrrrrrrrrrrrrrrrrrrr-rrrr-r)r-r r-r.F)rrrrrrrrrrr+rrrr-r3r7r6rrrs@r6rr9s  .O (MLLL" $ RMRMRMRMRMRMRMx04=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)Nrr9)r#r1r=r0rDr)r1rr5ir*founds r6r0r0s~D//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(r1 default_seps r6rrst%% F |r TS]]2  "4 5 5F )& 1 1YY C 8 & &  c5 ! ! Y MM7l3844777 8 8 8 8hGK%4*"6"6"8"888# MM' " " "#^(;(;A./;2JJJ+^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]]rrNrrQrrrrrrrrr-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. NrrOrQrrrrQrrrrrrs r6rzAssignAttr.__init__/sS4$( ?$, : !!)      r8rOc||_dS)ztDo some setup after initialisation. :param expr: What has the attribute that is being assigned to. NrNrrOs r6rzAssignAttr.postinitWrr8z'ClassVar[AssignedStmtsCall[AssignAttr]]rc#K|jVdSr0rNrs r6rzAssignAttr.get_childrencir8rrQrrrrrrrrrrrr-rr0rOrr-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 rQfailNrrrrrrrrr-rctd|_ d|_ t|||||dSrNr)rQr^rrrs r6rzAssert.__init__tsS,$( :#' 9 !!)      r8rQr^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^rQ)rrQr^s r6rzAssert.postinits  r8c#@K|jV|j |jVdSdSr0r]rs r6rzAssert.get_childrens0i 9 )OOOOO ! r8rrr9)rQrr^rr-r rrrrrrrrrrs@r6r\r\gs'O"!% $ " "&%)" " " " " " " " Hr8r\ceZdZUdZdZdZ 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_annotationNrrrrrrrrr-rcg|_ d|_ d|_ t|||||dSr`)rgr5rirrrs r6rzAssign.__init__s^,&( ($( 8.2X !!)      r8rgrr5ric4|||_||_||_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)rgr5ri)rrgr5ris r6rzAssign.postinits&  "DL .r8z#ClassVar[AssignedStmtsCall[Assign]]rc#6K|jEd{V|jVdSr0rfrs r6rzAssign.get_childrens4<jr8cV|gt|jzSr0)r r5_get_assign_nodesrs r6rnzAssign._get_assign_nodess%vTZ99;;<<<>>>>>>r8rec\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)simpleNrrrrrrrrr-rcd|_ d|_ d|_ d|_ t |||||dSr`)rvr(r5rwrrrs r6rzAnnAssign.__init__sg,&* ()-?$( 8"& K !!)      r8rvrr(rwrlr5c>||_||_||_||_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)rvr(r5rw)rrvr(rwr5s r6rzAnnAssign.postinit:s$$ $  r8z&ClassVar[AssignedStmtsCall[AnnAssign]]rc#RK|jV|jV|j |jVdSdSr0rurs r6rzAnnAssign.get_childrenVsFko : !*      " !r8rrr0) rvrr(rrwrlr5rr-r rrrrrrrrrrrrs@r6rtrts8OM"!% $ ( "&%)( ( ( ( ( ( ( ( ^ $ .;:::r8rtceZdZUdZdZdZejd 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 rvr5oprNrrrrrrrrrrr-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)rvrr5rrrrrrrrrrs r6rzAugAssign.__init__lsa6&* (  %) 7 !!)      r8rvr5c"||_||_dS)zDo some setup after initialisation. :param target: What is being assigned to. :param value: The value being assigned to the variable. Nr~rrvr5s 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) rjcFg|]}t|tj|Srr1rBadBinaryOperationMessagerurs r6rz)AugAssign.type_errors..;fd&DEEr8)rrrr@resultss r6 type_errorszAugAssign.type_errorssd ++G+<>> import astroid >>> node = astroid.extract_node('a + b') >>> node leftrightrrNrrrrrrrrrrr-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) rjcFg|]}t|tj|Srrrs r6rz%BinOp.type_errors..rr8)rrrs r6rzBinOp.type_errorssd '''88G%     III rc#.K|jV|jVdSr0rrs r6rzBinOp.get_children's%ijr8c&t|jSr0rrrs r6 op_precedencezBinOp.op_precedence+TW%%r8r.c|jdkS)Nrrrs r6op_left_associativezBinOp.op_left_associative.sw$r8rrr9)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 rIrrNrrrrrrrrrrr-rct||_ g|_ t|||||dS)rrN)rrIrrrs r6rzBoolOp.__init__AsS4!$& 7 !!)      r8rIrc| ||_dSdS)znDo some setup after initialisation. :param values: The values being applied to the operator. NrrrIs r6rzBoolOp.postinitis   DKKK  r8c#$K|jEd{VdSr0rrs r6rzBoolOp.get_childrenq&;r8c&t|jSr0rrs r6rzBoolOp.op_precedencetrr8rrr0rIrr-r) rrrrrrrrrrrrrrs@r6rr3s"OM1Z1U;;;!!% $ % "&%)% % % % % % % <;% N!!!!!&&&&&&&r8rceZdZdZdS)BreakzClass representing an :class:`ast.Break` node. >>> import astroid >>> node = astroid.extract_node('break') >>> node Nrrrrrr8r6rrxr8rc~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/rkeywordsNrrrrrrrrr-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.postinits1  DI  $DMMM r8 list[Starred]c$d|jDS)z/The positional arguments that unpack something.c<g|]}t|t|Sr)r1Starred)rur*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*)rukeywords r6rzCall.kwargs..sLLLG 8K8K8K8Kr8)rrs r6kwargsz Call.kwargssMLt}LLLLr8c#PK|jV|jEd{V|jEd{VdSr0rrs r6rzCall.get_childrensKi9=         r8rr)r/rrrrrr-r)r-r)r-r) rrrrrrrpropertyrrrrrs@r6rrs3O"!% $ % "&%)% % % % % % % % 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 [('<=', ), ('<=', )] ropsNrrrrrrrrr-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_children sAi!X  MAz      r8c(|jddS)zsAn optimized version of list(get_children())[-1] :returns: The last child. :rtype: NodeNG r"rP)rrs r6 last_childzCompare.last_child-sx|Ar8rrr9)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' rviterifs)is_asyncTrrrrrNrrr-cd|_ d|_ g|_ d|_ t |dS)zD :param parent: The parent node in the syntax tree. Nr)rvrrrrrrrrs r6rzComprehension.__init__QsN&* 7#' 9!#N%) C '''''r8rvrrrr 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)rvrrr)rrvrrrs r6rzComprehension.postinitds)$  ?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_types  r8mystmt_base_nodes.Statement | Nonec||ur"t|ttfr|gdfSn|d|ur|gdfS|dfS)zmethod used in filter_stmtsTfutureF)r1rkr statement)r lookup_noderCrrs r6_get_filtered_stmtsz!Comprehension._get_filtered_stmtssh 6>>+t}55 +#}d** +^^4^ ( (F 2 264< e|r8c#HK|jV|jV|jEd{VdSr0rrs r6rzComprehension.get_childrens?ki8r8r0rrr-rr) rvrrrrrrrr-r)rr)rrrrrroptional_assignrrrrrrrrs@r6rr8s  0O!MO:LLL(((((((*!%"#' $ !!!!!0?>>> r8rceZdZUdZdZ d!dddd"fdZded<ded<fdZd#d$dZd%dZ dZ d&dZ d#d$d Z xZ S)'rkaClass 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 rrrrrrrrrr-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) rr5rrrrrrrs 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. rjzCould not use type rzCould not index z with NzIndex {index!r} out of rangerxrz (value=rE)r1rkr5rrrrmrbytesrrrrr)rrpr@ 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_getattrs 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)rrts r6rz Const.itered..$s ???DM$''???r8zCannot iterate over type )r1r5rrrmrs r6rz Const.iteredsP dj# & & @??DJ??? ?HD4D4DHHIIIr8rc4|jS)r)_proxiedqnamers r6rz Const.pytype's }""$$$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 rrrrrrrrrrrrr-rr0rr=r)rrrrrrrrrrrrrrrs@r6rkrks  &M "!% $ *&"&%)*&*&*&*&*&*&*&*&X21113333 ) ) ) ) )&A&A&A&A&AP J J J%%%%         r8rkceZdZdZdS)ContinuezClass representing an :class:`ast.Continue` node. >>> import astroid >>> node = astroid.extract_node('continue') >>> node Nrrr8r6rr7rr8rcNeZdZdZdZ 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(Nrrrrrrrrr-rcZ| t|||||dSrrrrs r6rzDecorators.__init__UsL,   !!)      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.postinitys  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. rv)rrrrs r6rzDecorators.scopesV{ 2$D111 1{! 9$DK888 8{!'')))r8c#$K|jEd{VdSr0r(rs r6rzDecorators.get_childrens&:r8rr)r)rr-rr-r*) rrrrrrrrrrrs@r6rrAs"!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] rNrPrNrrQrrrrrrrrr-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. NrrSrTs r6rzDelAttr.__init__sW4$(  %- > !!)      r8rOc||_dSzDo some setup after initialisation. :param expr: The name that this node represents. :type expr: Name or None NrNrVs r6rzDelAttr.postinit  r8c#K|jVdSr0rNrs r6rzDelAttr.get_childrenrXr8rrYr0rZ 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 rgNrrrrrrrrr-rcdg|_ t|||||dSr)rgrrrs r6rzDelete.__init__sI,&( $ !!)      r8rgrc| ||_dSdS)z\Do some setup after initialisation. :param targets: What is being deleted. Nr)rrgs r6rzDelete.postinit s  "DLLL  r8c#$K|jEd{VdSr0rrs r6rzDelete.get_children s&<r8rrr0)rgrr-rrcrs@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 itemsNrrrrrrrrr-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.postinitA 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)rukvs r6rz&Dict.from_elements..Z s]AqQ<< q!!y||#J=#3#3#3Kr8r )rr!rCs r6rzDict.from_elementsL sLsuu =DJJ!KKMMDJ  r8Literal['builtins.dict']cdS)rz builtins.dictrrs r6rz Dict.pytypeb 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_childreni 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"rPNr rs r6rzDict.last_childv s$ : %:b>!$ $tr8c$d|jDS)zAn iterator over the keys this node contains. :returns: The keys of this node. :rtype: iterable(NodeNG) cg|]\}}|Srr)rur-rs r6rzDict.itered.. s///a///r8r rs r6rz Dict.itered s 0/DJ////r8rp Const | Slicer@rArcddlm}|jD]\}}t|trR|||}t|t s< |||cS#ttf$rYhwxYw| |D]]}t|tj rt|tr+t|tr|j |j kr|ccS^t|)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.helpersr3r!r1 DictUnpackrrrrrHrrIrkr5)rrpr@r3r-r5inferred_value inferredkeys r6rz Dict.getitem s5 /.....* % %JC#z** !+E7!;!;!.$77)11%AAAAA(*;<H #yy11 % % k4+?@@k511%j6N6N%"(EK77$  % &&&s A##A76A7c*t|jSr)r.r!rs r6rzDict.bool_value rr8rr)r!r#r-rr0)r-r))rpr1r@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 r4Nrrrrrrrrr-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_lambdarprs r6rpz"Expr._get_yield_nodes_skip_lambdas sLz# Bz??AA A A A A A A A A A B Br8rrr0r5rr-r rrrrrrrrrprrs@r6r:r: s  !O"!% $  "&%)        BBBBBBBBr8r:ceZdZdZdS)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 Nrrr8r6rHrH rr8rHceZdZdZdZddZdS) 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=)rrrrrLrMrr8r6rJrJ s9KK FSSSSSSr8rJc~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 [] rmrrSrSNrrrrrrrrr-rcd|_ d|_ g|_ t|||||dSr`)rmrrSrrrs r6rzExceptHandler.__init__ sa,$(  (, @"$ ( !!)      r8z*ClassVar[AssignedStmtsCall[ExceptHandler]]rc#dK|j |jV|j |jV|jEd{VdSr0rPrs r6rzExceptHandler.get_childrenN sL 9 )OOO 9 )OOO9r8rmrAssignName | NonerSrc8||_||_| ||_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. NrP)rrmrrSs r6rzExceptHandler.postinitX s+   DIII  r8c\|jr |jjS|jr |jjS|jSPThe line on which the beginning of this block ends. :type: int )rtolinenormrrs r6blockstart_tolinenoz!ExceptHandler.blockstart_tolinenol s6 9 &9% % 9 &9% %{r8rMrNr.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)rurCrMs r6rwz&ExceptHandler.catch.. s*SSt49 *SSSSSSr8)rmrZr)rrMs `r6rYzExceptHandler.catchx sH 9  24SSSSty7P7P7R7RSSSSSSr8rr)rmrrrTrSrr-rrMrNr-r.)rrrrr_multi_line_block_fieldsrrrrr+rZrYrrs@r6rOrO s"/O("!% $ ( "&%)( ( ( ( ( ( ( ( T?>>>#"&$( (  _ TTTTTTTTr8rOceZdZdZdS)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` 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 rvrrSrTrhrSrTTNrrrrrrrrr-rcd|_ d|_ g|_ g|_ d|_ t |||||dSr`)rvrrSrTrirrrs r6rz For.__init__ sr,&* '#' *"$ 3$& =.2X !!)      r8rvrrSrrTricT||_||_|||_|||_||_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)rvrrSrTri)rrvrrSrTris r6rz For.postinit s:$   DI   DK.r8z ClassVar[AssignedStmtsCall[For]]rc|jjSrW)rrYrs r6rZzFor.blockstart_tolineno  y!!r8c#bK|jV|jV|jEd{V|jEd{VdSr0rcrs r6rzFor.get_children sYki9;r8rr)NNNNN) rvrrrrSrrTrrirr-r)rrrrrrqr^rrrrr+rZrrrs@r6rbrb s ;O.1O"!% $ + "&%)+ + + + + + + + `!%"$(&*)- /////45444""_"r8rbceZdZdZdS)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] Nrrr8r6rkrk sr8rkcHeZdZdZdZ 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] r4Nrrrrrrrrr-rcdd|_ t|||||dSr`r<rs r6rzAwait.__init__' sI,%)  !!)      r8r5c||_dS)zUDo some setup after initialisation. :param value: What to wait for. Nr4r?s r6rzAwait.postinitH r@r8c#K|jVdSr0r4rs r6rzAwait.get_childrenO rBr8rrr0rErcrs@r6rmrm s"!O"!% $  "&%)        Br8rmc:eZdZdZdZ dddddfdZxZS) ImportFromzClass representing an :class:`ast.ImportFrom` node. >>> import astroid >>> node = astroid.extract_node('from my_package import my_module') >>> node )modnamenameslevelrNrfromnamerrtlist[tuple[str, str | None]]rurrrrrrrr-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)rsrtrurr) rrvrtrurrrrrrs r6rzImportFrom.__init__^ si>$,  49  "'  !!)      r8)rNNN)rvrrtrwrurrrrrrrrrrrr-rrrrrrrrrs@r6rrrrS ss2M !!% $: "&%): : : : : : : : : : : : r8rrc|eZdZdZdZdZejd dddddfdZdddZ dZ xZ S) Attributez2Class representing an :class:`ast.Attribute` node.rNrPrNrrQrrrrrrrrr-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. NrrSrTs r6rzAttribute.__init__ sW4$(  %- ( !!)      r8rOc||_dSrrNrVs r6rzAttribute.postinit rr8c#K|jVdSr0rNrs r6rzAttribute.get_children rXr8rrYr0rZrrs@r6r{r{ s<<O!M1Z15AAA $!!% $ ( "&%)( ( ( ( ( ( ( BA( Tr8r{c>eZdZdZdZ dddddfdZdZxZS)GlobalzClass representing an :class:`ast.Global` node. >>> import astroid >>> node = astroid.extract_node('global a_global') >>> node rtNrrt list[str]rrrrrrrr-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. rNrtrrrrtrrrrrrs r6rzGlobal.__init__ sI2!& 1 !!)      r8c|Sr0rrs r6rzGlobal._infer_name  r8rrtrrrrrrrrrrrr-rrrrrrrrrrs@r6rr sM "!% $ " "&%)" " " " " " " " Hr8rceZdZdZdZdZ dddddfdZ dddZedZ dZ dZ dZ fdZ d dZd dZxZS)!rVzClass representing an :class:`ast.If` node. >>> import astroid >>> node = astroid.extract_node('if condition: print(True)') >>> node rQrSrTrdNrrrrrrrrr-rcd|_ g|_ g|_ d|_ t |||||dS)rNFr)rQrSrT is_orelserrrs r6rz If.__init__ sg,$( 5"$ ($& 1$S !!)      r8rQrSrrTc||_|||_|||_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)rQrSrTr1rrVrrrQrSrTs r6rz If.postinitA sc  DI   DK dk2 & & "44;3E+E+E!DNNN " "+E+Er8c|jjSrWrQrYrs r6rZzIf.blockstart_tolinenoW rhr8c||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"rP)rSrrY_elsed_block_rangerTrrs r6 block_rangezIf.block_range_ ss TYq\, , ,6> ! TYr]+ + +49R=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.12 stacklevelzsys.version_infoTF) warningswarnDeprecationWarningr1rQrr Subscriptr5r{r$r?s r6 is_sys_guardzIf.is_sys_guard} s   (       di ) ) INE%++ $ %++ 0A0AEW0W0Wtur8ctjdtdt|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.12rrr) rrrr1rQrr{r$endswithrs r6is_typing_guardzIf.is_typing_guard sn   (       Ii(  >i!!##,,_== >r8rrrQrrSrrTrr-rr=)rrrrrr^rrr+rZrrrrprrrrs@r6rVrV s*1O1"!% $ ( "&%)( ( ( ( ( ( ( ( X#$(&* """"",""_"YYY  HHH;;;;; <>>>>>>>>r8rVcVeZdZdZdZ dddddfdZ dddZdZddZxZ S)IfExpzClass representing an :class:`ast.IfExp` node. >>> import astroid >>> node = astroid.extract_node('value if condition else other') >>> node rNrrrrrrrrr-rcd|_ d|_ d|_ t|||||dSr`rQrSrTrrrs r6rzIfExp.__init__ s],$( 5#' (%) 1 !!)      r8rQrSrTc0||_||_||_dS)rNrrs r6rzIfExp.postinit s   r8c#@K|jV|jV|jVdSr0rrs r6rzIfExp.get_children s0iikr8Literal[False]cdS)NFrrs r6rzIfExp.op_left_associative s ur8rr)rQrrSrrTrr-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 rrwNrrt#list[tuple[str, str | None]] | Nonerrrrrrrr-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)rtrrrrrrrrrrrr-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 Nrrr8r6rr5 rr8rcNeZdZdZdZdZ dddddfdZdddZdZxZ S)KeywordzClass representing an :class:`ast.keyword` node. >>> import astroid >>> node = astroid.extract_node('function(a_kwarg=True)') >>> node >>> node.keywords [] r4rNrr*rrrrrrrrr-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*rrrrrrs r6rzKeyword.__init__M sS2 #-$( ? !!)      r8r5c||_dS)zuDo some setup after initialisation. :param value: The value being assigned to the keyword argument. Nr4r?s r6rzKeyword.postinitt r@r8c#K|jVdSr0r4rs r6rzKeyword.get_children{ rBr8r)r*rrrrrrrrrrrr-rr0rE rrrrrrrrrrrs@r6rr? 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 | Nonerrrrrrrr-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. rNrrrrrrrrrrrs 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 rjrrDrrpr@s r6rz List.getitem  "$ 5'JJJJr8rrrrrrrrrrrrrr-r)r-rr0r rrrrrrrrrrrs@r6r<r< 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] rNrrtrrrrrrrrr-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 rcauseNrrrrrrrrr-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.postinit7s r8r.ct|jsdStd|jDS)zCheck if this node raises a :class:`NotImplementedError`. :returns: Whether this node raises a :class:`NotImplementedError`. Fc3,K|]}|jdkVdS)NotImplementedErrorNr)rurs r6rwz/Raise.raises_not_implemented..Ls;  37DI. .      r8)rrZrrs r6raises_not_implementedzRaise.raises_not_implementedEsO x 5  ;?8;S;S;U;U      r8c#NK|j |jV|j |jVdSdSr0rrs r6rzRaise.get_childrenPs= 8 (NNN : !*      " !r8rrr9)rrrrr-rr=) rrrrrrrrrrrs@r6rrs'O"!% $ " "&%)" " " " " " " " L"#          r8rcTeZdZdZdZ dddddfdZdddZdZdZdZ xZ S)ReturnzClass representing an :class:`ast.Return` node. >>> import astroid >>> node = astroid.extract_node('return True') >>> node r4Nrrrrrrrrr-rcdd|_ t|||||dSr`r<rs r6rzReturn.__init__cr=r8r5c||_dS)z]Do some setup after initialisation. :param value: The value being returned. Nr4r?s r6rzReturn.postinitr@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 r8rrr0rE) rrrrrrrrrrrrs@r6rrXs!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 rzr{r|Nrrrrrrrrr-rcd|_ d|_ d|_ t|||||dSr`)rzr{r|rrrs r6rzSlice.__init__s],%) +$( +#' / !!)      r8rzr{r|c0||_||_||_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)rrzr{r|s 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) startstopr|rjN)rrzr{r|rrrQr@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.getattrs}$$Xw777r8c#nK|j |jV|j |jV|j |jVdSdSr0rrs r6rzSlice.get_childrensQ : !*    : !*    9 )OOOOO ! r8rr)rzrr{rr|rr-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 r4rNrrrrrrrrrrr-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.postinitVr@r8z$ClassVar[AssignedStmtsCall[Starred]]rc#K|jVdSr0r4rs r6rzStarred.get_childrenbrBr8rrr0rEr{rs@r6rr#s!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]]rNrrrrrrrrrrr-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__ts]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|jVdSr0r rs r6rzSubscript.get_childrens(jjr8rrr9)r5rr~rr-r) rrrrrrrrrrrrs@r6rrfs)OM,,,,#!!% $ ( "&%)( ( ( ( ( ( ( ( XCG     r8rc^eZdZdZdZdZ dddddfdZ dddZdZdZ dZ xZ S)rXaClass representing an :class:`ast.TryExcept` node. >>> import astroid >>> node = astroid.extract_node(''' try: do_something() except Exception as error: print("Error!") ''') >>> node rSrRrTNrrrrrrrrr-rcg|_ g|_ g|_ t|||||dSr)rSrRrTrrrs r6rzTryExcept.__init__s],#% A-/ %$& 1 !!)      r8rSrrRlist[ExceptHandler] | NonerTc@|||_|||_| ||_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)rrSrRrTs r6rzTryExcept.postinits7  DI  $DM   DKKK  r8c|Sr0rrs r6rzTryExcept._infer_namerr8cFd}|jD]|}|jr||jjkr||fcS|jdj|cxkr|jdjkrnn||jdjfcS||jdjdz }}|||j|S)rNrr"rP)rRrmrrSrYrrT)rrlast exhandlers r6rzTryExcept.block_ranges 8 8I~ &&IN,E"E"Ev~%%%~a +vTTTT9K9TTTTTTy~b1:::::| ~a(3a7&&vt{DAAAr8c#`K|jEd{V|jpdEd{V|jpdEd{VdSr;rrs r6rzTryExcept.get_childrensd9=&B&&&&&&&;$"$$$$$$$$$r8rr)rSrrRrrTrr-r rrrrrr^rrrrrrrs@r6rXrXs  5O="!% $ % "&%)% % % % % % % % R%)/3&* !!!!!*BBB(%%%%%%%r8rXcVeZdZdZdZdZ 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 rS finalbodyNrrrrrrrrr-rctg|_ g|_ t|||||dSr)rSrrrrs r6rzTryFinally.__init__.sS,/1 =')4 !!)      r8rSlist[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)rrSrs r6rzTryFinally.postinitRs*  DI  &DNNN ! r8c|jd}t|tr?|j|jkr/|j|cxkr |jkrnn||S|||jS)rr)rSr1rXrrYrrr)rrchilds r6rzTryFinally.block_rangebs !  ui ( ( - DO33&::::4?:::::$$V,, ,&&vt~>>>r8c#>K|jEd{V|jEd{VdSr0rrs r6rzTryFinally.get_childrenvs@9>!!!!!!!!!r8rrr9)rSr rrr-r) rrrrrr^rrrrrrs@r6rrs  ,O4"!% $ " "&%)" " " " " " " " L15)-''''' ???("""""""r8rcbeZdZdZdZdZdddddddfdZdddddddZdZddZ dZ xZ S)TryStarz0Class representing an :class:`ast.TryStar` node.rSrRrTrNrrrrrrrrr-rcg|_ g|_ g|_ g|_ t |||||dS)a :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)rSrRrTrrr)rrrrrrrs r6rzTryStar.__init__sg$#% A-/ %$& 1')4 !!)      r8rSrrRrrTrcR|r||_|r||_|r||_|r ||_dSdS)a"Do 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. :param finalbody: The contents of the ``finally`` block. Nr')rrSrRrTrs r6rzTryStar.postinitsN  DI  %$DM  ! DK  '&DNNN ' 'r8c|Sr0rrs r6rzTryStar._infer_namerr8rltuple[int, int]cB||jkr||fS|jrD|jdj|cxkr|jdjkrnn||jdjfS|jD]e}|jr||jjkr||fcS|jdj|cxkr|jdjkrnO||jdjfcSf|jra|jdjdz |kr||fS|jdj|cxkr|jdjkrnn||jdjfS|jra|jdjdz |kr||fS|jdj|cxkr|jdjkrnn||jdjfS||jfS)z=Get a range from a given line number to where this node ends.rr"rP)rrSrYrRrmrTr)rrrs r6rzTryStar.block_ranges T_ $ $6> ! 9 210FTTTTdim>TTTTTT49R=11 1 ; ;I~ &&IN,E"E"Ev~%%%~a +vTTTT9K9TTTTTTy~b1:::::U ; 8{1~(1,66v~%{1~(FNNNNdk"o6NNNNNNt{2777 > ;~a +a/699v~%~a +vTTTT9K9TTTTTTt~b1:::t}$$r8c#rK|jEd{V|jEd{V|jEd{V|jEd{VdSr0r'rs r6rzTryStar.get_childrenst9=       ;>!!!!!!!!!r8) rrrrrrrrrrr-r) rSrrRrrTrrrr-r)rrlr-r+rrs@r6r&r&{s::AOJ "!%!%%) $$ $ $ $ $ $ $ $ R%)/3&*)- ''''''.%%%%0"""""""r8r&cneZdZUdZdZ dddddfdZded< ded<ded<ddZdd dZxZ S)!r=zClass representing an :class:`ast.Tuple` node. >>> import astroid >>> node = astroid.extract_node('(1, 2, 3)') >>> node rNrrrrrrrrrrr-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-r0r0rrrs@r6r=r=sM#!!% $ " "&%)" " " " " " " " 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 operandrrNrrrrrrrrrrr-rct||_ d|_ t|||||dSr)rr6rrrs r6rzUnaryOp.__init__3sS4!&* 4 !!)      r8r6c||_dS)zlDo some setup after initialisation. :param operand: What the unary operator is applied to. Nr5)rr6s r6rzUnaryOp.postinit[s  r8zFClassVar[InferBinaryOperation[UnaryOp, util.BadUnaryOperationMessage]]_infer_unaryopr@rAcl ||}d|DS#t$rgcYSwxYw)rrjcFg|]}t|tj|Sr)r1rBadUnaryOperationMessagers r6rz'UnaryOp.type_errors..rs;fd&CDDr8)r9rrs r6rzUnaryOp.type_errorsgsd ))')::G%     III rc#K|jVdSr0r5rs r6rzUnaryOp.get_childrenzslr8c~|jdkrt|jStS)Nnot)rrrrrs r6rzUnaryOp.op_precedence}s3 7e   ) )ww$$&&&r8rrr0)r6rr-rr)rrrrrrrrrrrrrrrrs@r6r4r4's#OM1Z1U;;;!!% $ % "&%)% % % % % % % <;% N&'''''''''r8r4cxeZdZdZdZdZ 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 rrdNrrrrrrrrr-rcd|_ g|_ g|_ t|||||dSr`rrs r6rzWhile.__init__s],$( 0"$ '$& 1 !!)      r8rQrSrrTc<||_|||_| ||_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.postinits1  DI   DKKK  r8c|jjSrWrrs r6rZzWhile.blockstart_tolinenorhr8c8|||jS)r)rrTrs r6rzWhile.block_ranges&&vt{;;;r8c#PK|jV|jEd{V|jEd{VdSr0rrs r6rzWhile.get_childrenrr8c#K|jEd{VtEd{VdS)z1A While node can contain a Yield node in the testNrrs r6rpz#While._get_yield_nodes_skip_lambdasrr8rrr)rrrrrr^rrr+rZrrrprrs@r6rArAs  1O1"!% $ % "&%)% % % % % % % % R#$(&* !!!!!(""_" < < < ;;;;;;;;;r8rAczeZdZUdZdZdZdZ 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!rSrhrQNrrrrrrrrr-rcg|_ g|_ d|_ t|||||dSr`)r!rSrirrrs r6rz With.__init__s^,:< O"$ 1.2X !!)      r8r!)list[tuple[NodeNG, NodeNG | None]] | NonerSrric8|||_|||_||_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!rSri)rr!rSris r6rz With.postinit)s,  DJ  DI.r8z!ClassVar[AssignedStmtsCall[With]]rc2|jddjS)rXr"r)r!rYrs r6rZzWith.blockstart_tolinenoAs z"~a ))r8c#RK|jD]\}}|V|r|V|jEd{VdS)zoGet the child nodes below this node. :returns: The children. :rtype: iterable(NodeNG) NrJ)rrOvars r6rzWith.get_childrenIsX   ID#JJJ  9r8rr)r!rLrSrrirr-r)rrrrrrqr^rrrr+rZrrrs@r6rIrIs  (O.("!% $ % "&%)% % % % % % % % R<@$()- /////&6555**_*       r8rIceZdZdZdS) AsyncWithz7Asynchronous ``with`` built with the ``async`` keyword.Nrrr8r6rRrRVsAAAAr8rRcNeZdZdZdZ dddddfdZdddZdZdZxZ S)YieldzClass representing an :class:`ast.Yield` node. >>> import astroid >>> node = astroid.extract_node('yield True') >>> node r4Nrrrrrrrrr-rcdd|_ t|||||dSr`r<rs r6rzYield.__init__esI,%) ! !!)      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 r6rpz#Yield._get_yield_nodes_skip_lambdasrr8rrr0rErFrs@r6rTrTZs!O"!% $  "&%)        Br8rTceZdZdZdS) YieldFromz2Class representing an :class:`ast.YieldFrom` node.Nrrr8r6rZrZs<<<Represents the unpacking of dicts into dicts using :pep:`448`.Nrrr8r6r5r5sHHHHr8r5cPeZdZdZdZdZ dddddfdZddddZdZxZ 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) conversionNrrrrrrrrr-rcp| | d|_ t|||||dSr`)r_rrrs r6rzFormattedValue.__init__sd, 8  .2 !!)      r8)r_r5rr`rlr_JoinedStr | Nonec0||_||_||_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)r5r`r_)rr5r`r_s r6rzFormattedValue.postinits  $&r8c#@K|jV|j |jVdSdSr0r^rs r6rzFormattedValue.get_childrens:j   '" " " " " " ( 'r8rr)r5rr`rlr_rbr-rrrs@r6r]r]s  /O#M"!% $ - "&%)- - - - - - - - h)- ''''''(#######r8r]cHeZdZdZdZ dddddfdZdddZdZxZS) JoinedStrzRepresents a list of string expressions to be joined. >>> import astroid >>> node = astroid.extract_node('f"Format {type_}"') >>> node rNrrrrrrrrr-rcdg|_ t|||||dSr)rIrrrs r6rzJoinedStr.__init__sM,%'  !!)      r8rIrc| ||_dSdS)zDo some setup after initialisation. :param value: The string expressions to be joined. :type: list(FormattedValue or Const) Nrrs r6rzJoinedStr.postinit&s   DKKK  r8c#$K|jEd{VdSr0rrs r6rzJoinedStr.get_children0rr8rrr0rrcrs@r6rfrfs"O"!% $ " "&%)" " " " " " " " H!!!!!r8rfcreZdZUdZdZdZ 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~TNrrrrrrrrr-rc`| | t|||||dSrr rs r6rzNamedExpr.__init__DsU,  < !!)      r8rvrr5c"||_||_dSr0r~rs r6rzNamedExpr.postinitks  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)rrr1rrrr)rrs r6rzNamedExpr.framets{ 2$D111 1 dkIw #F G G @;% =( <<<<;%, D( 0BCCCC;%,22$2?? ?{   ---r8r*c|jst|t|jttt fro|jjst|j|jjjst|jj|jjjS|jSr )rrr1rrrrrs r6rzNamedExpr.scopes { 2$D111 1 dkIw #F G G 5;% =( <<<<;%, D( 0BCCCC;%,2244 4{  """r8rrrJcZ|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)rrrJs r6rszNamedExpr.set_locals. $ ))$55555r8rr)rvrr5rr-r)rrnr-ror)rrrJrr-r) rrrrrrrrrrrrsrrs@r6rkrk4s*OOH "!% $ % "&%)% % % % % % % % N;::: 04.......####& 6 6 6 6 6 6 6 6r8rkc(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)Nrurrs r6rz Unknown.qnamesyr8Nr@rAc+&KtjVdS)z4Inference on an Unknown node immediately terminates.N)rrErr@rs r6_inferzUnknown._infersr8)r-rvr0r)rrrrrrrzrr8r6rurusR Dr8ruc<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. )originalr4r}rr5NodeNG | util.UninferableBaser-rc||_ ||_ t|jj|jj|jjdS)N)rrr)r}r5rrrrr)rr}r5rs r6rzEvaluatedObject.__init__sZ ( ?49   ='}/='      r8Nr@rArr 4Generator[NodeNG | util.UninferableBase, None, None]c+K|jVdSr0r4rys r6rzzEvaluatedObject._infersjr8)r}rr5r~r-rr0)r@rArr r-r) rrrrrrrrrzrrs@r6r|r|sv D#OM       26r8r|cDeZdZdZdZdZ dddddfdZddZxZS)MatchzClass representing a :class:`ast.Match` node. >>> import astroid >>> node = astroid.extract_node(''' match x: case 200: ... case _: ... ''') >>> node subjectcases)rNrrrrrrrrr-rc\||t|||||dSNrr rs r6rzMatch.__init__sK  # !!)      r8rrrlist[MatchCase]c"||_||_dSr0r)rrrs r6rzMatch.postinits   r8rr)rrrrr-r) rrrrrr^rrrrs@r6rrs  +O)"!% $  "&%)        &r8rceZdZdZdS)Patternz!Base class for all Pattern nodes.Nrrr8r6rr s++++r8rcdeZdZUdZdZdZded<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] patternguardrSrQrrrrrNrrrr-cX|||t|dS)Nrr rs r6rzMatchCase.__init__&s6  !  '''''r8rrrrSrc0||_||_||_dSr0r)rrrrSs r6rzMatchCase.postinit,s   r8r)rrrrrSrr-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 r4Nrrrrrrrrr-rcX|t|||||dSrr rs r6rzMatchValue.__init__GsE  !!)      r8r5rc||_dSr0r4r?s r6rzMatchValue.postinitYs  r8rr)r5rr-rrrrrrrrrrs@r6rr8s  !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]rrrrrrrr-rcb||_t|||||dSrr<)rr5rrrrrrs r6rzMatchSingleton.__init__tsF  !!)      r8)r5rrrrrrrrrrrr-rryrs@r6rr]si(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 patternsNrrrrrrrrr-rcX|t|||||dSrr rs r6rzMatchSequence.__init__E $ !!)      r8r list[Pattern]c||_dSr0rrrs r6rzMatchSequence.postinit   r8rrrrr-rrrs@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 keysrrestNrrrrrrrrr-rc`|||t|||||dSrr rs r6rzMatchMapping.__init__sQ  $ $ !!)      r8rrrrrrTc0||_||_||_dSr0r)rrrrs r6rzMatchMapping.postinits    r8zlClassVar[Callable[[MatchMapping, AssignName, InferenceContext | None, None], Generator[NodeNG, None, None]]]rrr)rrrrrrTr-r rrrrrrrrrrs@r6rrs  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_attrsNrrrrrrrrr-rcd||||t|||||dSrr rs 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] rNrrrrrrrrr-rcX|t|||||dSrr rs r6rzMatchStar.__init__5rr8rrTc||_dSr0rrs r6rzMatchStar.postinitGs  r8ziClassVar[Callable[[MatchStar, AssignName, InferenceContext | None, None], Generator[NodeNG, None, None]]]rrr)rrTr-rrrs@r6rr&s   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 rrNrrrrrrrrr-rc\||t|||||dSrr rs r6rzMatchAs.__init__usK $ $ !!)      r8rPattern | NonerrTc"||_||_dSr0r)rrrs r6rzMatchAs.postinits   r8zgClassVar[Callable[[MatchAs, AssignName, InferenceContext | None, None], Generator[NodeNG, None, None]]]rrr)rrrrTr-rrrs@r6rrZs0*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 rNrrrrrrrrr-rcX|t|||||dSrr rs r6rzMatchOr.__init__rr8rrc||_dSr0rrs r6rzMatchOr.postinitrr8rrrrrs@r6rrs  $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.)rrr)r5rCelementselement element_nodes r6_create_basic_elementsrsG H&&$W-- "  %%%% Or8rIMapping[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!rrr)rIrCrr-r5key_node value_nodes r6_create_dict_itemsrsnSUHllnn00 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.)r1rrr3rJrL issubclassr<rr=rrrrrk)r5rCinitializer_clsrs r6rrs%(((( (  i''{{   0O/D#u#566"?$$0AABBB/4(("?$$,UH==>>> <<r8r=r0rr]r>rr<)r5rrCrr-r)rIrrCrr-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<rlAssignedStmtsCallInferBinaryOperationInferLHSr InferUnaryOpraise_if_nothing_inferredrFrhrLrorqrrParentAssignNodeABCMetarrNoChildrenNoder>rrAssignTypeNoderr0rr? Statementr\rertr}rrrrrrrkrrrrrr:rHrJMultiLineBlockNoderOr`MultiLineWithElseBlockNoderbrkrm ImportNoderrr{rrVrrrrrrrrrrrrrXrr&r=r4rArIrRrTrZr5r]rfrkrur|rrrrrrrrrrrr r2dictrGrmNotImplementedr.floatcomplexrr3rrrrrr8r6rs$ BAA""""""  8888888888SSSSSSSSSSSSSSSSSS$$$$$$$$0000000077777777,,,,,,+*****%%%%%%------((((((v))))))/......v)))))))DDDDDD//// ')6 * * *)1IJJJ!"ST!!"S!"      h'() U?N:;T4GHJ  h'() _dH5G,HHIK #(::;  %....&%.4FFFFFV&((6     HHHHHBUUUUUK0(ckUUUUr33333&333J<<<<<+[+:V<<<~2 2 2 2 2 k(+{7S2 2 2 j;4;4;4;4;4; %{;4;4;4|uuuuu *uuup    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[ ')>000fe>e>e>e>e> /1Fe>e>e>PKKKKKFKKK\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]"]"]"@b"b"b"b"b"k4k6Kb"b"b"JDKDKDKDKDKMDKDKDKNZ'Z'Z'Z'Z'fZ'Z'Z'zg;g;g;g;g;K 2K4Ig;g;g;Teeeee*eeePBBBBBBBB88888F888v========IIIII+IIIW#W#W#W#W#VW#W#W#t::::::::zu6u6u6u6u6 *u6u6u6pk("fB,,,,,K !;#A,,,^,,,,,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