X ~d d Z ddlmZ ddlZddlZddlZddlZddlZddlm Z m
Z
ddl m Z ddl
mZmZmZmZmZ ddlmZ ddlmZ dd lmZ dd
lmZmZmZm Z m Z dd l m Z m Z m!Z!m"Z" dd l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z, dd
l-m.Z. ddl/m0Z0m1Z1m2Z2 ddl3m4Z4 ddl5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;mm?Z? ddl@mAZA ddlBmCZCmDZDmEZE ejF dk r
ddl mGZG ddl
mHZH n ddlImHZH ddlJmKZG erddlmLZL dZM eNdd h ZO ejP d ZQ eNh d ZR ed ZSd ZTdCd%ZUd& ZVd' ZW G d( d)e= ZX G d* d+e< ZY G d, d-e< ZZ G d. d/e< Z[ G d0 d1e< Z\d2 Z] G d3 d4e9j^ e= Z_ G d5 d6e9j` e9ja e_ Zb G d7 d8eb ZcdDdEd<ZddDdFd>ZedDd?Zfd@ Zg G dA dBe9j^ e=e9ja ZhdS )Gz
This module contains the classes for "scoped" node, i.e. which are opening a
new local scope in the language definition : Module, ClassDef, FunctionDef (and
Lambda, GeneratorExp, DictComp and SetComp to some extent).
) annotationsN) GeneratorIterator) lru_cache)
TYPE_CHECKINGClassVarNoReturnTypeVaroverloadbases)
decorators)util)IS_PYPYPY38 PY38_PLUS PY39_PLUSPYPY_7_3_11_PLUS) CallContextInferenceContextbind_context_to_node copy_context) AstroidBuildingErrorAstroidTypeErrorAttributeInferenceErrorDuplicateBasesErrorInconsistentMroErrorInferenceErrorMroErrorStatementMissingTooManyLevelsError)lookup)
ClassModel
FunctionModel ModuleModel)AstroidManager) ArgumentsConstNodeNG _base_nodes node_classes)ComprehensionScopeLocalsDictNodeNG)builtin_lookup)Position)
InferBinaryOpInferenceResultSuccessfulInferenceResult) )cached_property)Literal)cachedproperty)nodes)__iter__ __getitem__ Exception
BaseExceptionobjects> classmethod staticmethodbuiltins.classmethodbuiltins.staticmethod_Tc g } d | D } | s|S | D ]!}|d }| D ]}||dd v rd} n n"|st d| || | | | D ]}|d |k r|d= s)zMerges MROs in *sequences* to a single MRO using the C3 algorithm.
Adapted from http://www.python.org/download/releases/2.3/mro/.
Tc g | ]}||S rE ).0ss y/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/astroid/nodes/scoped_nodes/scoped_nodes.py
z _c3_merge..R s ///1Q/Q/// r NzTCannot create a consistent method resolution order for MROs {mros} of class {cls!r}.messagemrosclscontext)r append) sequencesrO rP results1 candidates2seqs rH _c3_mergerX J s F// /// M B1I
122&& $IE ' '4
i C1v""F7rJ rR list[list[ClassDef]]returnNonec V | dd }| d }t | D ]!\ }}| dk r|} n"dS t | D ]'\ }}||k r t d |D r n(dS | | | | dS )a A class can inherit from typing.Generic directly, as base,
and as base of bases. The merged MRO must however only contain the last entry.
To prepare for _c3_merge, remove some typing.Generic entries from
sequences if multiple are present.
This method will check if Generic is in inferred_bases and also
part of bases_mro. If true, remove it from inferred_bases
as well as its entry the bases_mro.
Format sequences: [[self]] + bases_mro + [inferred_bases]
rK typing.GenericNc 3 F K | ] }| d k V dS )r^ NqnamerF bases rH z+clean_typing_generic_mro.. s0 @@Dtzz|| //@@@@@@rJ ) enumeratera anypop)rR bases_mroinferred_basesirc position_in_inferred_basesrW s rH clean_typing_generic_mrorl p s !B$I r]N ^,, 4 ::<<+ + +)* & E , I&& 3 * * * @@C@@@ @ @ E 1222
MM,-----rJ c # @ K | D ]}d |D }t t t t | |r-|d %|d dk rt d| || fdt t || D V d S )Nc V g | ]&}|j r|j | fnd 'S N)namelinenora rF nodes rH rI z(clean_duplicates_mro.. s@
CG49 >T[$**,, ' '$
rJ r z,Duplicates found in MROs {mros} for {cls!r}.rL c < g | ]\ }\ }}| | |k |S ro rE )rF rj rs rp
last_indexs rH rI z(clean_duplicates_mro.. s?
propertyr? )
isinstance FunctionDeftyper
BoundMethod
UnboundMethod)nklasss rH function_to_methodr si ![!! * 6] " "$Q.. . 6Z H 6^ # #&q)) ) HrJ c & e Zd ZU dZdZdZded< dZded< dZded < dZ d
ed < e
Z h d Z d
Z
dZded< ded< ded< ded< ej d dRdS fd!
ZdTdd"dUd%ZedVd& Zej dWd( Zd) Zd* Zd+ ZdXd,ZdYd.ZdZd/Z d[d\d3Z dTd\d4Z d]d6Z e d7d8d^d: Z e d_d= Z dd8d`d@Z dA Z!dB Z"dZ#d]dCZ$ dadbdIZ%dcdJZ&dK Z'dL Z(dTdddMZ)dN Z*dd8dedQZ+ xZ,S )fModulezClass representing an :class:`ast.Module` node.
>>> import astroid
>>> node = astroid.extract_node('import astroid')
>>> node
>>> node.parent
)doc_nodebodyr
Literal[0]
fromlinenorq Nzstr | bytes | None
file_bytes
str | None
file_encoding> __doc____file____name____path__ __package__)rp docfilepathpackage pure_pythonfuture_imports)localsglobalsr[
col_offset
end_linenoend_col_offsetparent'Use the postinit arg 'doc_node' insteadr Trp strr r r list[str] | Noner bool | Noner rZ c || _ || _ || _ || _ || _ || _ | i x| _ | _ g | _ d| _ t | _ t
d| dS )a
:param name: The name of the module.
:param doc: The module docstring.
:param file: The path to the file that this ast has been extracted from.
:param path:
:param package: Whether the node represents a package or a module.
:param parent: The parent node in the syntax tree.
:param pure_python: Whether the ast was built from source.
Nr )rq r )rp _docr r r r r r r r setr super__init__) selfrp r r r r r r __class__s rH r zModule.__init__ s 4 % # @&4 :U%'' dlS68 )&*
5(+.
&11111rJ )r r Const | Nonec B || _ || _ |r|j | _ dS dS )zDo some setup after initialisation.
:param body: The contents of the module.
:type body: list(NodeNG) or None
:param doc_node: The doc node associated with this node.
N)r r valuer )r r r s rH postinitzModule.postinit+ s1
' DIII ' 'rJ c H t j dt d | j S )zThe module docstring.zHThe 'Module.doc' attribute is deprecated, use 'Module.doc_node' instead.
stacklevelwarningswarnDeprecationWarningr r s rH r z
Module.doc7 s2
-
yrJ r c L t j dt d || _ d S )NzPSetting the 'Module.doc' attribute is deprecated, use 'Module.doc_node' instead.r r r r r s rH r z
Module.docB s3
-
rJ c | j t j | j S | j t | j d }|S d S )Nrb)r ioBytesIOr open)r streams rH _get_streamzModule._get_streamL s? ? &:do.. . 9 $)T**FMtrJ c * | S )zaGet a stream to the underlying file or bytes.
:type: file or io.BytesIO or None
)r r s rH r z
Module.streamU s
!!!rJ c | j | j fS )zGet a range from where this node starts to where this node ends.
:param lineno: Unused.
:type lineno: int
:returns: The range of line numbers that this node belongs to.
:rtype: tuple(int, int)
r tolinenor rq s rH block_rangezModule.block_range\
--rJ c || j v r5|| j vr, | | | fS # t $ r | dfcY S w xY w| ||| S )at Lookup where the given variable is assigned.
:param node: The node to look for assignments up to.
Any assignments after the given node are ignored.
:type node: NodeNG
:param name: The name of the variable to find assignments for.
:type name: str
:param offset: The line offset to filter statements up to.
:type offset: int
:returns: This scope node and the list of assignments associated to the
given name according to the scope where it has been found (locals,
globals or builtin).
:rtype: tuple(str, list(NodeNG))
rE ) scope_attrsr getattrr
_scope_lookup)r rs rp offsets rH scope_lookupzModule.scope_lookupg sz $ 4# # #DK(?(?
T\\$ / ///*
Rx
!!$f555s + <<Literal['builtins.module']c dS )eGet the name of the type that this node represents.
:returns: The name of the type.
zbuiltins.modulerE r s rH pytypez
Module.pytype s
! rJ c dS )jA human readable type of this node.
:returns: The type of this node.
:rtype: str
r rE r s rH display_typezModule.display_type s xrJ FrP InferenceContext | Nonec |st | || g }|| j v }|| j v r |s |s | j | g}n_|s|r| j | }nM| j rF | |d g}n,# t t f$ r}t | || |d }~ww xY wd |D }|r|S t | || )Ntarget attributerP T)
relative_onlyc F g | ] }t |t j | S rE )r r+ DelNamerF r s rH rI z"Module.getattr.. * OOO:a 9M+N+NO!OOOrJ )r r special_attributesr" r
import_moduler SyntaxError)r rp rP
ignore_localsrS name_in_localsexcs rH r zModule.getattr s, X)wWWW W , 4* * *= * *-44T::;FF > [&FF
\
,,T,FFG(+6
- 4
POVOOO M%TT7SSSSs #A< <B%
B B%c t | }||_ t j | || || S # t
$ r&}t
t | | || |d}~ww xY w)zInfer the possible values of the given variable.
:param name: The name of the variable to infer.
:type name: str
:returns: The inferred possible values.
:rtype: iterable(NodeNG) or None
framer N)r
lookupnamer
_infer_stmtsr r r r r rp rP errors rH igetattrzModule.igetattr s w'' ! %dll4&A&A7RVWWW W& E
44
s *A
A3
!A..A3boolc H | j duo| j d S )zCheck if this module has been build from a .py file.
If so, the module contains a complete representation,
including the code.
:returns: Whether the module has been built from a .py file.
Nz.py)r endswithr s rH
fully_definedzModule.fully_defined s& y$B););E)B)BBrJ .futurer c d S ro rE r r s rH statementzModule.statement rJ
Literal[True]r c d S ro rE r s rH r zModule.statement r rJ Literal[None, True]Module | NoReturnc b |rt | t j dt d | S )aJ The first parent node, including self, marked as statement node.
When called on a :class:`Module` with the future parameter this raises an error.
TODO: Deprecate the future parameter and only raise StatementMissing
:raises StatementMissing: If no self has no parent attribute and future is True
)r zIn astroid 3.0.0 NodeNG.statement() will return either a nodes.Statement or raise a StatementMissing exception. nodes.Module will no longer be considered a statement. This behaviour can already be triggered by passing 'future=True' to a statement() call.r r )r r r r r s rH r zModule.statement sJ 0"$/// /
>
rJ c dS )zThe previous sibling statement.
:returns: The previous sibling statement node.
:rtype: NodeNG or None
NrE r s rH previous_siblingzModule.previous_sibling rJ c dS )z|The next sibling statement node.
:returns: The next sibling statement node.
:rtype: NodeNG or None
NrE r s rH next_siblingzModule.next_sibling r rJ c | j S )zWhether :pep:`328` absolute import behaviour has been enabled.
:returns: Whether :pep:`328` has been enabled.
)_absolute_import_activatedr s rH absolute_import_activatedz Module.absolute_import_activated s
..rJ modnamer level
int | None use_cachec |r|d}| || } t || S # t $ r |r Y nw xY wt | S )ax Get the ast for a given module as if imported from this module.
:param modname: The name of the module to "import".
:param relative_only: Whether to only consider relative imports.
:param level: The level of relative import.
:param use_cache: Whether to use the astroid_cache of modules.
:returns: The imported module ast.
Nr )r )relative_to_absolute_namer& ast_from_module_namer )r r r r r
absmodnames rH r zModule.import_module s & U]E33GUCC
!##88i 9
$
44W===s "A
AAc @ | r||S |rE| j r'|dz
}| j d| d }n| j rt
j t
j | j d dz snt
j t
j | j d dz | d d z r|dz
}d}n!| j d| d }|r4| j d |k rt || j n0| j r| j }n!| j dd d }|r |s|S | d| S |S ) a Get the absolute module name for a relative import.
The relative import can be implicit or explicit.
:param modname: The module name to convert.
:param level: The level of relative import.
:returns: The absolute module name.
:raises TooManyLevelsError: When the relative import refers to a
module too far above this one.
NrK .r z /__init__.py/ )r rp ) r r rp rsplitr osexistsdirnamesplitcountr! )r r r package_names rH r z Module.relative_to_absolute_name s & ) ) + +
N 7|
? #y / /U ; ;A >
?rwty|'D'D~'UVV
? GNNGOODIaL11C7'--:L:LQ:OO
? ! #y / /U ; ;A >
F --55(u49EEEE
\ 7 9LL 9++C33A6L /
$##"..W.. .rJ c d | D } | d }n# t $ r |cY S w xY w t | }n&# t t
f$ r |cY S t $ r |cY S w xY wg } t | }n# t t
f$ r |cY S w xY wt |t j
t j f s|S dd}|j D ]} || r|
|j ( t | }n# t t
f$ r Y ^w xY w || r|
|j |S )a The list of imported names when this module is 'wildcard imported'.
It doesn't include the '__builtins__' name which is added by the
current CPython implementation of wildcard imports.
:returns: The list of imported names.
:rtype: list(str)
c < g | ]}| d |S _
startswithrF rp s rH rI z0Module.wildcard_import_names..Y s) LLLDts7K7KL4LLLrJ __all__rZ r c j t | t j ot | j t S ro )r r+ r( r r )rs s rH str_constz/Module.wildcard_import_names..str_constq s' dL$677WJtzSVB? !E EEc > d | D S )zThe list of the names that are publicly available in this module.
:returns: The list of public names.
:rtype: list(str)
c < g | ]}| d |S r r r s rH rI z'Module.public_names.. s) IIIDOOC4H4HIIIIrJ )r$ r s rH public_nameszModule.public_names s! JIIIIIrJ c dS )zDetermine the boolean value of this node.
:returns: The boolean value of this node.
For a :class:`Module` this is always ``True``.
TrE r rP s rH
bool_valuezModule.bool_value trJ c # $ K | j E d {V d S ro r r s rH get_childrenzModule.get_children s& 9 rJ r rB c | S zThe node's frame node.
A frame node is a :class:`Module`, :class:`FunctionDef`,
:class:`ClassDef` or :class:`Lambda`.
:returns: The node itself.
rE r s rH r z Module.frame rJ )NNNNNT)rp r r r r r r r r r r r[ r r rZ r[ ro )r r rZ r r r rZ r[ r )rZ r rZ r )NFrP r r# )r r[ rZ r )r r rZ r )r r rZ r )FNT)
r r r r r r r r rZ r )r r r r rZ r rP r rZ r r rB r r rZ rB )-r
__module__ __qualname__r _astroid_fieldsr __annotations__rq r r r% r r
_other_fields_other_other_fieldsdecorators_moddeprecate_argumentsr r r~ r setterr r r r r r r r r r r r r r r r r r3 r6 r9 r= r
__classcell__r s @rH r r s +O J FF@ &*J))))8 $M$$$$ % ? QPPKLM 0LLL'^',UVVV !% ##'=2 =2 =2 =2 =2 =2 WV=2B
'd
'
'
'
'
'
' X Z Z " " " . . .6 6 6 62! ! ! ! LQT T T T T2 (C C C C *- X X :> * "& / / / / $ > > > > >D0 0 0 0d0 0 0dJ J J :> rJ r c Z e Zd ZdZdZdZdZ dddd fd Zddd ZdddZ d Z
xZ S ) GeneratorExpzClass representing an :class:`ast.GeneratorExp` node.
>>> import astroid
>>> node = astroid.extract_node('(thing for thing in things if thing)')
>>> node
elt
generatorsr Nr r c d i | _ t ||||| dS a
:param lineno: The line that this node appears on in the source code.
:type lineno: int or None
:param col_offset: The column that this node appears on in the
source code.
:type col_offset: int or None
:param parent: The parent node in the syntax tree.
:type parent: NodeNG or None
:param end_lineno: The last line this node appears on in the source code.
:type end_lineno: Optional[int]
:param end_col_offset: The end column this node appears on in the
source code. Note: This is after the last symbol.
:type end_col_offset: Optional[int]
rq r r r r Nr r r r rq r r r r r s rH r zGeneratorExp.__init__ I 6 S
!!)
rJ rW list[nodes.Comprehension] | Nonec 8 || _ | g | _ dS || _ dS zDo some setup after initialisation.
:param elt: The element that forms the output of the expression.
:type elt: NodeNG or None
:param generators: The generators that are looped through.
NrU r rV rW s rH r zGeneratorExp.postinit ' DOOO (DOOOrJ rP r rZ r c dS )zDetermine the boolean value of this node.
:returns: The boolean value of this node.
For a :class:`GeneratorExp` this is always ``True``.
TrE r8 s rH r9 zGeneratorExp.bool_value r: rJ c # 6 K | j V | j E d {V d S ro rU r s rH r= zGeneratorExp.get_children 1 h?"""""""""rJ NNNNNrW r` ro rP r rZ r r rH rI r rJ rM rV r r r9 r= rQ rR s @rH rT rT s ,O%
C $
$
$
$
$
$
$
$
L ) ) ) ) ) # # # # # # #rJ rT c f e Zd ZdZdZdZdZ dZ dddd fd Z ddd Z ddd Z
d
Z xZ S )DictCompzClass representing an :class:`ast.DictComp` node.
>>> import astroid
>>> node = astroid.extract_node('{k:v for k, v in things if k > v}')
>>> node
keyr rW rX NrY c d i | _ t ||||| dS r[ r] r^ s rH r zDictComp.__init__ r_ rJ rW r` c F || _ || _ | g | _ dS || _ dS )a Do some setup after initialisation.
:param key: What produces the keys.
:type key: NodeNG or None
:param value: What produces the values.
:type value: NodeNG or None
:param generators: The generators that are looped through.
Nro )r rp r rW s rH r zDictComp.postinit- s.
DOOO (DOOOrJ rP r c t j S )zDetermine the boolean value of this node.
:returns: The boolean value of this node.
For a :class:`DictComp` this is always :class:`Uninferable`.
:rtype: Uninferable
r Uninferabler8 s rH r9 zDictComp.bool_valueD
rJ c # H K | j V | j V | j E d {V d S ro ro r s rH r= zDictComp.get_childrenM s? hj?"""""""""rJ rh rj ro rE )
r rH rI r rJ rM rp r r r r9 r= rQ rR s @rH rn rn s 5O%
C
E $
$
$
$
$
$
$
$
P
7; ) ) ) ) ). # # # # # # #rJ rn c Z e Zd ZdZdZdZdZ dddd fd Zddd Zddd Z d
Z
xZ S )SetCompzClass representing an :class:`ast.SetComp` node.
>>> import astroid
>>> node = astroid.extract_node('{thing for thing in things if thing}')
>>> node
rU rX NrY c d i | _ t ||||| dS r[ r] r^ s rH r zSetComp.__init__e r_ rJ rW r` c 8 || _ | g | _ dS || _ dS rb rU rc s rH r zSetComp.postinit rd rJ rP r c t j S )zDetermine the boolean value of this node.
:returns: The boolean value of this node.
For a :class:`SetComp` this is always :class:`Uninferable`.
:rtype: Uninferable
rt r8 s rH r9 zSetComp.bool_value rv rJ c # 6 K | j V | j E d {V d S ro rU r s rH r= zSetComp.get_children rg rJ rh ri rj ro rE rl rR s @rH ry ry T s ,O%
C $
$
$
$
$
$
$
$
L ) ) ) ) ) # # # # # # #rJ ry c Z e Zd ZdZdZdZdZ dddd fd Zddd Zddd Z d
Z
xZ S )ListCompzClass representing an :class:`ast.ListComp` node.
>>> import astroid
>>> node = astroid.extract_node('[thing for thing in things if thing]')
>>> node
rU rX NrY c d i | _ t ||||| d S )Nr\ r] r^ s rH r zListComp.__init__ sI L
!!)
rJ rW r` c 8 || _ | g | _ dS || _ dS )a Do some setup after initialisation.
:param elt: The element that forms the output of the expression.
:type elt: NodeNG or None
:param generators: The generators that are looped through.
:type generators: list(Comprehension) or None
NrU rc s rH r zListComp.postinit s' DOOO (DOOOrJ rP r c t j S )zDetermine the boolean value of this node.
:returns: The boolean value of this node.
For a :class:`ListComp` this is always :class:`Uninferable`.
:rtype: Uninferable
rt r8 s rH r9 zListComp.bool_value rv rJ c # 6 K | j V | j E d {V d S ro rU r s rH r= zListComp.get_children rg rJ rh ri rj ro rE rl rR s @rH r r s ,O%
C
(
)
)
)
)
) # # # # # # #rJ r c t | t sdS | j sdS t | | j d }n# t
$ r Y dS w xY wt |t j r|j }t |t r.|
d rdS |
d rdS t |t r|j sdS |j j D ]}t |t j r|j t v r |j c S t |t j rFt |j t j r'|j j dk r|j t v r |j c S dS )z_Detect decorator call chaining and see if the end result is a
static or a classmethod.
Nr@ r> rA r? builtins)r r r r& infer_call_resultr r
Instance_proxiedClassDef
is_subtype_ofr r8 r+ Namerp BUILTIN_DESCRIPTORS Attributeexprattrname)rs rS decorators rH _infer_decorator_callchainr s dK ( ( t ; td,,T[994@@ tt&%.)) ! &(## " 6 7 7 ! = 7 8 8 "!>&+&& * 4 *0
*
*I)\%677
* >%888$>)))9l&<==
* y~|/@AA
* N':55 &*=== )))) 4s (A
AAc e Zd ZdZdZdZdZdZ e Z d)dZ
e d*d
Z d+d d d fd
Z
d,dZd-dZd.dZd/dZd0dZd1d2dZd3d Zd1d4d Zd Zd d d5d%Z d1d6d(Z xZS )7LambdazClass representing an :class:`ast.Lambda` node.
>>> import astroid
>>> node = astroid.extract_node('lambda arg: arg + 1')
>>> node
l.1 at 0x7f23b2e41518>
argsr rX zTrZ r c dS )Nr rE r s rH implicit_parameterszLambda.implicit_parameters! qrJ Literal['method', 'function']c | j j rI| j j d j dk r.t | j t rdS dS )zuWhether this is a method or function.
:returns: 'method' if this is a method, 'function' otherwise.
r r methodfunction)r argumentsrp r r scoper r s rH r z Lambda.type$ sR 9 49#6q#9#>&#H#H$+++--x88
xzrJ NrY c i | _ | g | _ i | _ t ||||| dS r[ )r r instance_attrsr r r^ s rH r zLambda.__init__/ sh 6 L 4
8:
!!)
rJ r r' c " || _ || _ dS )zDo some setup after initialisation.
:param args: The arguments that the function takes.
:param body: The contents of the function body.
:type body: list(NodeNG)
Nr )r r r s rH r zLambda.postinit` s rJ 6Literal['bultins.instancemethod', 'builtins.function']c d| j v rdS dS )r r zbuiltins.instancemethodzbuiltins.functionr r s rH r z
Lambda.pytypek s
ty ,,""rJ r c d| j v rdS dS )r r MethodFunctionr r s rH r zLambda.display_typet s ty 8zrJ r c dS )zWhether this node defines something that is callable.
:returns: Whether this defines something that is callable
For a :class:`Lambda` this is always ``True``.
TrE r s rH callablezLambda.callable~ r: rJ list[str]c 4 | j j rt | j j }ng }| j j r | | j j |d | j j D z
}| j j r | | j j |S )a Get the names of each of the arguments, including that
of the collections of variable-length arguments ("args", "kwargs",
etc.), as well as positional-only and keyword-only arguments.
:returns: The names of the arguments.
:rtype: list(str)
c g | ] }|j
S rE rp )rF rV s rH rI z#Lambda.argnames.. s ;;;s#(;;;rJ )r r _rec_get_namesvarargrQ
kwonlyargskwarg)r r{ s rH argnameszLambda.argnames s 9 "49#677EEE 9 + LL) * * *
;;di&:;;;; 9? * LL ) ) ) rJ rP r c 6 | j | S )zqInfer what the function returns when called.
:param caller: Unused
:type caller: object
)r r* )r callerrP s rH r zLambda.infer_call_result s yw'''rJ r c || j j v s|| j j v r | j d }d}n| }| ||| S )aa Lookup where the given names is assigned.
:param node: The node to look for assignments up to.
Any assignments after the given node are ignored.
:type node: NodeNG
:param name: The name to find assignments for.
:type name: str
:param offset: The line offset to filter statements up to.
:type offset: int
:returns: This scope node and the list of assignments associated to the
given name according to the scope where it has been found (locals,
globals or builtin).
:rtype: tuple(str, list(NodeNG))
Tr r] )r defaults kw_defaultsr r r )r rs rp r r s rH r zLambda.scope_lookup sc $ 49% % %1F)F)FK%%T%22E FF E""4v666rJ c dS )zDetermine the boolean value of this node.
:returns: The boolean value of this node.
For a :class:`Lambda` this is always ``True``.
TrE r8 s rH r9 zLambda.bool_value r: rJ c # . K | j V | j V d S ro r r s rH r= zLambda.get_children s iirJ r r rB r r c | S r? rE r s rH r z Lambda.frame r@ rJ rp list[NodeNG]c |st | || g }|| j v r
| j | }|| j v r-| | j | |r|S t | | )Nr )r r )r r r rQ r" )r rp rP found_attrss rH r zLambda.getattr s X)wWWW W 4& & & -d3K 4* * * t 6 = =d C C D D D %TTBBBBrJ )rZ r )rZ r rh )r r' )rZ r rD )rZ r )rZ r ro rE rC rk rG )rp r rP r rZ r )r rH rI r rJ rM rp is_lambdar$ r r r~ r r r r r r r r r r9 r= r r rQ rR s @rH r r s 'O% DI& A X /
/
/
/
/
/
/
/
b # # # # & ( ( ( ( (7 7 7 78 :> =A
C
C
C
C
C
C
C
C
CrJ r c e Zd ZU dZdZdZdZdZded< dZ dZ
dZ dZ dZ
d ZdZ ej d
d=ddd d> fd Z d?dddd@dZedAd Zej dBd ZedCd ZedDd ZedEd" Zed# ZdFd%Z d& Z dGdHd)Z dId+Z ej dGdHd, Z!dId-Z"dJdId/Z#dId0Z$dGdHd1Z%dKdHd2Z&dGdLd3Z'd4 Z(dM fd6 Z)dd7dNd<Z* xZ+S )Or zClass representing an :class:`ast.FunctionDef`.
>>> import astroid
>>> node = astroid.extract_node('''
... def my_func(arg):
... return arg + 1
... ''')
>>> node
)r r returnsr r r< N node_classes.Decorators | Noner T)rp r position)r _typetype_comment_returnstype_comment_argsr r rY r r c || _ || _ d| _ i | _ t ||||| |r.| d }| || dS dS )a
:param name: The name of the function.
:type name: str or None
:param doc: The function docstring.
:param lineno: The line that this node appears on in the source code.
:type lineno: int or None
:param col_offset: The column that this node appears on in the
source code.
:type col_offset: int or None
:param parent: The parent node in the syntax tree.
:type parent: NodeNG or None
:param end_lineno: The last line this node appears on in the source code.
:type end_lineno: Optional[int]
:param end_col_offset: The end column this node appears on in the
source code. Note: This is after the last symbol.
:type end_col_offset: Optional[int]
Nr\ Tr )rp r r r r r r set_local)
r rp r rq r r r r r r s
rH r zFunctionDef.__init__ s F
%&*
5
!!)
(LLL--E OOD$ ' ' ' ' ' ( (rJ r r r r' r Position | Noner r c || _ || _ || _ || _ || _ || _ || _ || _ |r|j | _ dS dS )a Do some setup after initialisation.
:param args: The arguments that the function takes.
:param body: The contents of the function body.
:type body: list(NodeNG)
:param decorators: The decorators that are applied to this
method or function.
:type decorators: Decorators or None
:params type_comment_returns:
The return type annotation passed via a type comment.
:params type_comment_args:
The args type annotation passed via a type comment.
:params position:
Position of function keyword(s) and name.
:param doc_node:
The doc node associated with this node.
N)
r r r r r r r r r r ) r r r r r r r r r s rH r zFunctionDef.postinitP s] > $ $8!!2
' DIII ' 'rJ rZ c H t j dt d | j S )zThe function docstring.zRThe 'FunctionDef.doc' attribute is deprecated, use 'FunctionDef.doc_node' instead.r r r r s rH r zFunctionDef.docz s2
2
yrJ r r[ c L t j dt d || _ d S )NzZSetting the 'FunctionDef.doc' attribute is deprecated, use 'FunctionDef.doc_node' instead.r r r r s rH r zFunctionDef.doc s3
2
rJ list[node_classes.Call]c \ | j d }t |t sg S g }| D ]}t |j t j rt |j j t j r|j
D ]}t |t j s |j | j k r. || j }t |t r4| d |k r| |j # t $ r Y w xY w|S )a The extra decorators that this function can have.
Additional decorators are considered when they are used as
assignments, as in ``method = staticmethod(method)``.
The property will return all the callables that are used for
decoration.
Tr )r r r r _get_assign_nodesr r+ Callfuncr targets
AssignNamerp r rQ r% )r r r assign assign_nodemeths rH extra_decoratorsz FunctionDef.extra_decorators sM !!!..%** I.0
--// < < >% G G & - -fl ; ; ; $ ! ! ! ! s
D
D('D(r c | j D ]#}|j j t v r|j j c S $| j d }d}t
|t r)| j dk rdS | j dk rdS | j dk rdS d}| j s|S | j j D ]}t
|t j r|j t v r |j c S t
|t j rFt
|j
t j r'|j
j d k r|j t v r |j c S t
|t j rT t! |j }n# t$ t& f$ r Y w xY wt) | }||c S | D ]}t) | }||c c S t
|t s/| D ]L}t
|t s| d r dS | d r d
S M# t$ $ r Y w xY w|S )ztThe function type for this node.
Possible values are: method, function, staticmethod, classmethod.
Tr r __new__r> __init_subclass____class_getitem__r r Nr@ rA r? )r r rp r r r r r r r8 r+ r r r r r r& r* r r( r ancestorsr ) r r r type_namers currentr r1 ancestors rH r zFunctionDef.type s . + +I~"&999 ~**** : !!!.. eX & & !yI%%$}y ///$}y ///$} I O) * * D$ 122
%9 333 9$$$4 !788
% ty,*;<<
% INj00M%888}$$$$ 122
!
"49??#4#4 5 5GG&
6 H 27;;$ LLL
$
2 2H 6x @ @E ( $ %h99 ! $,$6$6$8$8 2 2 )(H = = % $#112HII 1#0====#112IJJ 2#1>>>>2 22 "
s7 &E22FF *I AI(II
IIr c n | j }| j &|t d | j j D z
}|S ). sA 48
+a/ rJ )rq r sumr8 r s rH r zFunctionDef.fromlineno sQ
? & c <@O r r> r r s rH r zFunctionDef.is_boundK s
y 555rJ Fc | j rd| j j D ]W} t | }n# t t
f$ r Y 8w xY w|r| dv r dS X| j D ]U}t |t j
r |r dS | r dS |ot |t j c S |rdS dS )a Check if the method is abstract.
A method is considered abstract if any of the following is true:
* The only statement is 'raise NotImplementedError'
* The only statement is 'raise ' and any_raise_is_abstract is True
* The only statement is 'pass' and pass_is_abstract is True
* The method is annotated with abc.astractproperty/abc.abstractmethod
:returns: Whether the method is abstract.
> abc.abstractmethodabc.abstractpropertyTF)
r r8 r& r* r r( ra r r r+ Raiseraises_not_implementedPass)r pass_is_abstractany_raise_is_abstractrs r1
child_nodes rH is_abstractzFunctionDef.is_abstractR s ?
-
#DJJLL 1 1HH&
6 H 0 0 5 ! ! 44 ) R RJ*l&899
( 44 4466 44#Q
:|?P(Q(Q Q Q Q 4us !9A
A
c ` t t | d S )zhCheck if this is a generator function.
:returns: Whether this is a generator function.
F)r r& _get_yield_nodes_skip_lambdasr s rH is_generatorzFunctionDef.is_generatorv s(
D;;==uEEFFFrJ c # & K | t j D ]n}|j ,t j d }||_ |j |_ |V 5| | k r!|j | E d{V odS )zInfer what the function yields when called
:returns: What the function yields
:rtype: iterable(NodeNG or Uninferable) or None
Nr ) nodes_of_classr+ Yieldr r( r rq r r* )r rP yield_consts rH infer_yield_resultz FunctionDef.infer_yield_result} s )),*<== ? ?F|#$*400 % %} 4''!<--g->>>>>>>>> ? ?rJ c # K | rAt | t r
t j }n t j } || }|V dS | j dk r|t | j j dk rr| j j et |j t r4t |j j d d }nmt |j t r/t |j d d }n$t dt |j t |t r fd|j dd D }n1# t" $ r$}t% |j dd |d}~ww xY wt! d
}d |_ | |_ | d |D g g |
|V dS | } t | d }
|
sT| j r>| d d rt2 j V nt7 j d V dS t% d t; j |
f| D ]_} | j t7 j d V | j E d{V B# t$ $ r t2 j V Y \w xY wdS )zInfer what the function returns when called.
:returns: What the function returns.
:rtype: iterable(NodeNG or Uninferable) or None
)generator_initial_contextNwith_metaclassrK r z0caller.args was neither Arguments nor list; got c g | ]A}t d | D BS )c 3 R K | ]"}t |t r|j |V #d S ro r r( r rF bs rH rd z;FunctionDef.infer_call_result... sF !$.q%$8$8 >?W_ =L___ rJ r )r& r* clone)rF argrP s rH rI z1FunctionDef.infer_call_result.. sg # # # %(YYw}}Y%G%G # # #rJ rs rP temporary_classr Tc F g | ] }t |t j | S rE r r UninferableBaserb s rH rI z1FunctionDef.infer_call_result.. s; )$0D E E rJ )r
r r metaclass)r r z0The function does not have any return statements) r r AsyncFunctionDefr
AsyncGeneratorr rp lenr r r' r& r* list TypeErrorr r r( r hider r _get_return_nodes_skip_functionsr r r ru r+ r( itertoolschainr ) r r rP
generator_clsrS r class_basese new_classr first_return
returnnodes ` rH r z FunctionDef.infer_call_result sx $ 011
0 % 4
%
"]47KKKFLLL F
I) ) )"DIN##q(( ,&+y11
!1!!4!:!:7!C!CT J J FK..
Q !5!5g!>!> E E ZtFKGXGXZZ )X..
W# # # # $*;qrr?# # #KK % W W W(fk!""owOOOUVVW $*; < < < !% #' "" $/
! ' # 7799GT** Uy
##TQU#VV 3 *****&,T22222 !STT T#/ >>>>>>>>>% + + + ******+
+ +s* $F
F.
F))F.) K
K%$K%c dS )zDetermine the boolean value of this node.
:returns: The boolean value of this node.
For a :class:`FunctionDef` this is always ``True``.
TrE r8 s rH r9 zFunctionDef.bool_value r: rJ c # v K | j | j V | j V | j | j V | j E d {V d S ro )r r r r r s rH r= zFunctionDef.get_children s] ? &/ ! ! !i < #, 9 rJ r c |dk r5| j d }t |t r| |gfS t ||| S )z(Lookup where the given name is assigned.r Tr )r r r r r r )r rs rp r r r s rH r zFunctionDef.scope_lookup sb ;
K%%T%22E%**
%eW}$ww##D$777rJ r r rB r r c | S r? rE r s rH r zFunctionDef.frame r@ rJ NNNNNr r )NNNN)r r' r r r r r r rA rB )rZ r rD rZ r )rZ r ro rE r# )TFri rF rC rG ),r rH rI r rJ _multi_line_block_fieldsr r rK is_functiontype_annotationr r rL rM r rN rO r r r~ r rP r5 r r r r r r r r cachedr r r r r r r9 r= r r rQ rR s @rH r r sU LO ( G15J5555EK O \/M
E'^',UVVV
8( 8( 8( 8( 8( 8( 8( 8( WV8(| 6: ! (' %)!%(' (' (' (' (' ('T X Z Z & & & _&P C C C _CJ
_
" " _"+ + + + . . .
*6 6 6 6" " " " "HG G G G? ? ? ? ?"R+ R+ R+ R+ R+h
8
8
8
8
8
8 :> rJ r c e Zd ZdZdS )r a Class representing an :class:`ast.FunctionDef` node.
A :class:`AsyncFunctionDef` is an asynchronous function
created 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]
N)r rH rI r rE rJ rH r r s rJ r r{ r r c |g }| D ]L}t |t j rt |j | 2| |j M|S )z#return a list of all argument names)r r+ r+ r r- rQ rp )r r{ r s rH r r sa } # # c<- . . # 38U + + + + LL " " " " LrJ r c | j dk rdS |t }| j D ]} | D ]}| }||v r| | t
|t j r dS || u rSt
|t si|j dk r dS t || r dS # t $ r Y w xY wdS )z>Return if the given class can be
used as a metaclass.
r TNFr ) rp r r
r* ra r r r r r
_is_metaclassr )r seenrc baseobj baseobj_names rH r9 r9 + s
zVt |uu ::<<
&}} 4'' &&& gu~66 ! 555e## !'844 =K// 444 $// 444
" H 5s$ A C
'C
4C
C
CCc | j | j S t | rd| _ n| j d rd| _ n|t }| }||v r d| _ dS | | | d D ]<}t || }|dk r$|dk rt | s.|j | _ n=| j d| _ | j S )z]return a ClassDef node type to differ metaclass and exception
from 'regular' classes
Nr r; exceptionclassF)recurs)
r r9 rp r r ra r r _class_typer )r r
klass_namerc rp s rH rA rA K s
{ {U ! [ ) ) ! I[[]]
" "!EK7
j!!!OO5O11 D tY//Dw;&&}U/C/C& "i
{ ;rJ c | d }|Qt |t s<|j d}n|j d }|t |t <|S )zGet the class that wraps the given node.
We consider that a class wraps a node if the class
is a parent for the said node.
:returns: The class that wraps the given node
:rtype: ClassDef or None
Tr N)r r r r )rs r s rH get_wrapping_classrD m sq
JJdJ # #E
Juh$?$?
< EEL&&d&33E
Juh$?$?
LrJ c H e Zd ZU dZdZdZ e Z dZdZ de
d< dZ dZ e
ed Zd Zd
ZdZ ej d dfddd dg fd Zde
d< e
dhd Zej did ZdjdZd Z dkddddld Zdmdnd#ZdZ e
ed$ Z e do fd& Z e d' Z d( Z dpd*Z!dqd,Z"drd.Z#dmdsd/Z$d0 Z%dmdnd1Z&dtd3Z'e
d4 Z( dudvd8Z)dmdnd9Z*dmdnd:Z+drd;Z,dmdnd<Z-dmdnd=Z.dwd?Z/ dxdydCZ0 e1dDE dF Z2dG Z3 dxdzdIZ4dmdsdJZ5dmdndKZ6dL Z7dM Z8dN Z9 dmd{dOZ: d|d}dRZ;dmd{dSZdV Z?ej@ dW ZAdmdndXZBdmdndYZCdmd~d[ZDdmdd]ZEd^ ZFej@ d_ ZGdd`ddeZH xZIS )r a
Class representing an :class:`ast.ClassDef` node.
>>> import astroid
>>> node = astroid.extract_node('''
class Thing:
def my_meth(self, arg):
return arg + self.offset
''')
>>> node
)r r
keywordsr r N
NodeNG | None
_metaclassFz\The class type for this node.
Possible values are: class, metaclass, exception.
:type: strr )rp r is_dataclassr )r _newstyler rY r r c i | _ i | _ g | _ g | _ g | _ || _ || _ d| _ d| _ t
||||| |*| d || |
D ]\ }} | | | dS )a
:param name: The name of the class.
:type name: str or None
:param doc: The class docstring.
:param lineno: The line that this node appears on in the source code.
:type lineno: int or None
:param col_offset: The column that this node appears on in the
source code.
:type col_offset: int or None
:param parent: The parent node in the syntax tree.
:type parent: NodeNG or None
:param end_lineno: The last line this node appears on in the source code.
:type end_lineno: Optional[int]
:param end_col_offset: The end column this node appears on in the
source code. Note: This is after the last symbol.
:type end_col_offset: Optional[int]
NFr\ Tr )r r rF r
r rp r r rI r r r r implicit_localsadd_local_node) r rp r rq r r r r
local_namers r s rH r zClassDef.__init__ s
F ! L
$&
+
"&*
5"'0
!!)
LLL % % / /d ; ; ; $ 4 4 6 6 2 2 J j 1 1 1 1 2 2rJ z!ClassVar[InferBinaryOp[ClassDef]]infer_binary_oprZ c H t j dt d | j S )zThe class docstring.zLThe 'ClassDef.doc' attribute is deprecated, use 'ClassDef.doc_node' instead.r r r r s rH r z ClassDef.doc s2
/
yrJ r r[ c L t j dt d || _ d S )NzZSetting the 'ClassDef.doc' attribute is deprecated, use 'ClassDef.doc_node.value' instead.r r r r s rH r z ClassDef.doc s3
5
rJ
Literal[1]c dS )NrK rE r s rH r z ClassDef.implicit_parameters r rJ c H d| j j ff}|d| j j ffz
}|S )zGet implicitly defined class definition locals.
:returns: the the name and Const pair for each local
:rtype: tuple(tuple(str, node_classes.Const), ...)
rH rI )r attr___module__attr___qualname__)r locals_s rH rL zClassDef.implicit_locals s4 !$"9"IJL^T%<%NOQQrJ r r r r r r c ||| _ || _ || _ || _ ||| _ ||| _ || _ || _ |r|j | _ dS dS )a Do some setup after initialisation.
:param bases: What the class inherits from.
:type bases: list(NodeNG)
:param body: The contents of the class body.
:type body: list(NodeNG)
:param decorators: The decorators that are applied to this class.
:type decorators: Decorators or None
:param newstyle: Whether this is a new style class or not.
:type newstyle: bool or None
:param metaclass: The metaclass of this class.
:param keywords: The keywords given to the class definition.
:type keywords: list(Keyword) or None
:param position: Position of class keyword and name.
:param doc_node: The doc node associated with this node.
N)
rF r
r r rJ rH r r r r ) r r
r r newstyler rF r r s rH r zClassDef.postinit+ sn F $DM
$ %DN 'DO
' DIII ' 'rJ rP r c b |t }| j | j S | d| D ] }| | r d| _ n!| }|/t |t r| | | _ | j d| _ | j S )NFr@ rP T)r rJ r _newstyle_impldeclared_metaclassr r )r rP rc r s rH r\ zClassDef._newstyle_impl\ s ?&((G > %> !NN%NAA D""7++
!%
'')) E8! ! "DN~ rJ z=Whether this is a new style class or not
:type: bool or Noner c t rt rDt r=t s6| j }| j &|t
d | j j D z
}|S t j S )r Nc 3 : K | ]}|j |j z
d z V dS r r rr s rH rd z&ClassDef.fromlineno..} sA 8* * rJ c | j | j fS r r r s rH r zClassDef.block_range r rJ -Literal['builtins.type', 'builtins.classobj']c | j rdS dS )r
builtins.typezbuiltins.classobj)rY r s rH r zClassDef.pytype s
= #"?""rJ r c dS )r ClassrE r s rH r zClassDef.display_type s wrJ r c dS )zWhether this node defines something that is callable.
:returns: Whether this defines something that is callable.
For a :class:`ClassDef` this is always ``True``.
TrE r s rH r zClassDef.callable r: rJ c | k rdS t fd| | D S )zWhether this class is a subtype of the given type.
:param type_name: The name of the type of check against.
:type type_name: str
:returns: Whether this class is a subtype of the given type.
Tc 3 H K | ] }| k V d S ro r` )rF ancr s rH rd z)ClassDef.is_subtype_of.. s0 WW399;;)+WWWWWWrJ r )ra rf r )r r rP s ` rH r zClassDef.is_subtype_of sN ::<<9 $ $4WWWWt~~g~7V7VWWWWWWrJ c t |j d | }n/# t $ r"}t |j d | |d }~ww xY wt |t j r"t |j t r|j }n t j S t | } t |j d | }n/# t $ r"}t |j d | |d }~ww xY wt |t j
t j f rkg }| D ]L} t | | d }
|
r$ |j t
j | |
M||_ n t j S t |j d | } n# t t f$ r d } Y nw xY w| rkt | t j rQ| j D ]I\ } }
t | t j r*t | j t r|
g|j | j < J|j |_ |S )Nr r rK r )originalr r )r& r r* r( r r r+ r( r r r ru r r+ r, iteredrQ EvaluatedObjectr
Dictitemsr r )r r rP name_noder' rp rS r& r
rc r1 membersattrr s rH _infer_type_callzClassDef._infer_type_call s N V[^ 1 1' : :;;II N N N fk!ngFFFA M N i !3 4 4 $ OS:
:
$ ?DD# #$ N v{1~ 3 3G < <==KK N N N fk!ngFFFA M N kL$6 8I#J K K
$E#**,,
7
; ;TBB EL$4d(SSS !FLL
# # 6;q>//8899GG
. GGG 8z'<+<== 8 &}
8
8 e dL$677 8JtzSV -0
A AA 7-C% %
D/ D D2-G G65G6c # 0 K | d| r4t |j dk r | || }|V dS d} | | }|,d|j v r#t
| d| }n# t t f$ r Y nw xY w|rR|
dk r:t || }||j _
| || E d{V dS | V dS )z+infer what a class is returning when calledrd r3 Nr __call__zbuiltins.type.__call__)r r r rt r r r& r r r( ra r callcontextcalleer instantiate_class)r r rP rS dunder_callr s rH r zClassDef.infer_call_result sU ow 7 7 C .( s8 LL 4t 4 4LLLLLLrJ Tr r] )
r r r+
Decoratorsr& builtins_modulerf r
r r )r rs rp r lookup_upper_framer s ` rH r zClassDef.scope_lookup
s .
t{L$; < <
9((88
LLLLLLL L L ! " K%%T%22E FFE""4v666rJ c $ d | j D S )zThe names of the parent classes
Names are given in the order they appear in the class definition.
:type: list(str)
c 6 g | ]}| S rE ) as_string)rF bnodes rH rI z&ClassDef.basenames..H s" :::e!!:::rJ r r s rH basenameszClassDef.basenames@ s ;:tz::::rJ Tr@ Generator[ClassDef, None, None]c # K | h}|t }| j s7| dk r t d d d V dS | j D ]}| 5 | | D ]}t
|t s#t
|t j r|j }n:|j
s ||v rF| | |V |sb| d| D ]&}|| u r n ||v r
| | |V 'n# t $ r Y ddd w xY w ddd n # 1 swxY w Y dS )zIterate over the base classes in prefixed depth first order.
:param recurs: Whether to recurse or return direct ancestors only.
:returns: The base classes
Nbuiltins.objectobjectrK r Tr[ )r r
ra r. restore_pathr* r r r r r! r r r )r r@ rP yieldedstmtr; grandpas rH r zClassDef.ancestorsJ s & ?&((Gz djjll.? ? ? **1-a0 0 0 0 FJ D%%''
#'::g#6#6 * * )'8 < < ) )'5> B B )*1*: ( &| * &' 1 1 ( #KK 0 0 0")MMM % % $'.'8'8g'8'V'V * *G &$ % &' 1 1 ( #KK 0 0 0")MMMM)** & 1
. +*
s7 2E4B6D+*E+
E5EEEE E c # K | | dd }n&# t $ r | | }Y nw xY w|D ]
}||v r|V dS )zIterate over the parents that define the given name.
:param name: The name to find definitions for.
:type name: str
:returns: The parents that define the given name.
:rtype: iterable(NodeNG)
rK Nr )mror r )r rp rP r astroids rH local_attr_ancestorsz ClassDef.local_attr_ancestorsw s 8 ))!""-II 8 8 8 w77III 8 ! Gw
s " AAc # V K | | D ]}||j v r|V dS )a Iterate over the parents that define the given name as an attribute.
:param name: The name to find definitions for.
:type name: str
:returns: The parents that define the given name as
an instance attribute.
:rtype: iterable(NodeNG)
r N)r r )r rp rP r s rH instance_attr_ancestorsz ClassDef.instance_attr_ancestors sG ~~g~66 Gw---
rJ c || j v S )zWhether this class directly inherits from the given node.
:param node: The node to check for.
:type node: NodeNG
:returns: Whether this class directly inherits from the given node.
r )r rs s rH has_basezClassDef.has_base s tz!!rJ c g }|| j v r| j | }n3t | || d }|r
|j | }d |D }|r|S t | || )ah Get the list of assign nodes associated to the given name.
Assignments are looked for in both this class and in parents.
:returns: The list of assignments to the given name.
:rtype: list(NodeNG)
:raises AttributeInferenceError: If no attribute with this name
can be found in this class or parent classes.
Nc F g | ] }t |t j | S rE r r+ DelAttrr s rH rI z'ClassDef.local_attr.. r rJ r )r r& r r )r rp rP rS
class_nodes rH
local_attrzClassDef.local_attr s 4; [&FF d 7 7g F FMMJ
1#*40OOVOOO M%TT7SSSSrJ c t | j |g }| || D ]}||j | z
}d |D }|r|S t | || )ak Get the list of nodes associated to the given attribute name.
Assignments are looked for in both this class and in parents.
:returns: The list of assignments to the given name.
:rtype: list(NodeNG)
:raises AttributeInferenceError: If no attribute with this name
can be found in this class or parent classes.
c F g | ] }t |t j | S rE r r s rH rI z*ClassDef.instance_attr.. r rJ r )r r getr r )r rp rP valuesr s rH
instance_attrzClassDef.instance_attr s d)--dB7788 66tWEE 6 6J j/5 5FFOOVOOO M%TT7SSSSrJ bases.Instancec t d | D rt | S n# t $ r Y nw xY wt j | S )zGet an :class:`Instance` of the :class:`ClassDef` node.
:returns: An :class:`Instance` of the :class:`ClassDef` node
c 3 2 K | ]}|j t v V d S ro )rp EXCEPTION_BASE_CLASSES)rF rO s rH rd z-ClassDef.instantiate_class.. s* LL#38 55LLLLLLrJ )rf r r= ExceptionInstancer r
r r s rH ry zClassDef.instantiate_class sy
LLLLLLL
7 00666
7 D ~d###s AA
AArp
class_context list[SuccessfulInferenceResult]c |st | || t | j |g }| d| D ] }||j |g z
}!|| j v r,|r*|s(| j | g}|dk r||z
}|S |r|| || z
}| D ]{}t |t j r_| d }t |t j
r/|j (| | | ||st | || |S )a Get an attribute from this class, using Python's attribute semantic.
This method doesn't look in the :attr:`instance_attrs` dictionary
since it is done by an :class:`Instance` proxy at inference time.
It may return an :class:`Uninferable` object if
the attribute has not been
found, but a ``__getattr__`` or ``__getattribute__`` method is defined.
If ``class_context`` is given, then it is considered that the
attribute is accessed from a class context,
e.g. ClassDef.attribute, otherwise it might have been accessed
from an instance as well. If ``class_context`` is used in that
case, then a lookup in the implicit metaclass and the explicit
metaclass will be done.
:param name: The attribute to look for.
:param class_context: Whether the attribute can be accessed statically.
:returns: The attribute.
:raises AttributeInferenceError: If the attribute cannot be inferred.
r Tr[ __bases__r )r r r r r r r" _metaclass_lookup_attributecopyr r+ r r AnnAssignr rg index) r rp rP r r classnoderS r r s rH r zClassDef.getattr s 8 X)wWWW W 37t{tR7P7P2Q2Q tW EE 5 5I i&**444 4FF 4* * *} *V *-44T::;F{"" & M F d66tWEE EF [[]] 4 4E% !899
4 d33 dL$:;; 4
@RJJv||E 2 2333 X)wWWW W
rJ i )maxsizec N t }| }t | }| | }||fD ]X}|rT|| k rNt |t
r9| ||| }| t | Y|S )zASearch the given name in the implicit and the explicit metaclass.r )r implicit_metaclassr r r r _get_attribute_from_metaclassupdate)r rp rP attrs
implicit_metar rO cls_attributess rH r z$ClassDef._metaclass_lookup_attribute
s //11
w''NN7N33 !9- 2 2C
2sd{{z#x'@'@{!%!C!CCw!W!W S 0 0111 rJ c # K | ||d }n# t $ r Y d S w xY wt j ||| D ]}t |t
s|V t |t j r|V ;|j dk r)t | p| }t j
|| V o|j dk r|V t j
|| V d S )NT)rP r r r> r? ) r r r
r r r r= Propertyr rD r )r rO rp rP r rs r s rH r z&ClassDef._get_attribute_from_metaclass&
s# KKgTKJJEE& FF &ugSAAA 4 4D dK00
$ 011
yM)) +4008D'e444444n,,
'd333333' 4 4s
++Iterator[InferenceResult]c # T
K t | }||_ | | } | ||| }t | dk r8|d |dd }}|
|g
fd|D z }t
j ||| D ] }t |t j
sYt |t j r? |j d| t j V b# t $ r |V Y rw xY wt |t j rg|j }|s | | | E d{V |r9|j |u r | | | E d{V |V t+ || V dS # t $ re} | d
s$| | rt j V n!t1 t3 | | || | Y d} ~ dS d} ~ ww xY w) zInfer the possible values of the given variable.
:param name: The name of the variable to infer.
:returns: The inferred possible values.
r )r rK r Nc \ g | ](}|j r |j k &|)S rE )r r )rF rs first_scopes rH rI z%ClassDef.igetattr..[
sH - - - {- (,{'8'8':':k'I'I 'I'I'IrJ r __get__)r rP __r )r r r r r r r
r r r+ r( r r r ru r r= r r r r r r has_dynamic_getattrr r ) r rp rP r r
attributes
first_attrr1 r r r s @rH r zClassDef.igetattrA
s w'' !NN7N33 6 dG= QQJ :"")3A
122J
( . . 0 0 (\ - - - - *- - -
" .z7$ O O O
=
=!(L,>?? =J enE E =/ )11)WEEE # ..... 3 ' ' ' &' '*:;; = ' 0H( '#+#=#=#' $> $ $ # 'x'<'<'>'>)'K'K $,#=#=#' $> $ $ ',Xt<<<<< B1F8 #D
>F8
D F8 D BF8 8
H'AH""H'c d } || d| d S # t $ r= | d| d } || cY S # t $ r Y nw xY wY nw xY wdS )a0 Check if the class has a custom __getattr__ or __getattribute__.
If any such method is found and it is not from
builtins, nor from an extension module, then the function
will return True.
:returns: Whether the class has a custom __getattr__ or __getattribute__.
c b | }|j dk ot |dd S )Nr r )rootrp r )rs r s rH _valid_getattrz4ClassDef.has_dynamic_getattr.._valid_getattr
s- 99;;D9
*Qwt]D/Q/Q QrJ __getattr__r __getattribute__F)r r )r rP r getattributes rH r z ClassDef.has_dynamic_getattr
s R R R !>$,,}g"F"Fq"IJJ J&
#||,> H H K %~l33333*
us2 $*
A1&A A1
A+(A1*A++A10A1c t | d }nu# t $ rh}t | t r7 | d }n2# t $ r t | | |w xY wt | | |Y d}~nd}~ww xY w|d }t
|| }t |g| |_ t |
| | t j S # t $ r? t |t j r#| dk r t" r| cY S t$ $ r t j cY S w xY w)aA Return the inference of a subscript.
This is basically looking up the method in the metaclass and calling it.
:returns: The inferred value of a subscript to this class.
:rtype: NodeNG
:raises AstroidTypeError: If this class does not define a
``__getitem__`` method.
r: r r Nr )r rx rd )r" r r r r r r r rw r& r r ru r) r+ EmptyNoder r r )r r rP methodsr r new_contexts rH getitemzClassDef.getitem
s L T=11GG& L L L$))
L
P "ll+> ? ?GG / P P P*gFFFCOP 'D'BBBK GGGG L +7D99 "-E76"J"J"J $00{CCTEUVV V 6<#9::
KKMM_44 5 $ $ $# # # # $sD
BB A B A&&B B8-C& &AE-EEc # K i }t j t | f | D ]1}| D ]}|j |v r d||j < |V 2dS )zIterate over all of the method defined in this class and its parents.
:returns: The methods defined on the class.
:rtype: iterable(FunctionDef)
N)r# r$ iterr mymethodsrp )r doner r s rH r zClassDef.methods
s tTG}}dnn6F6FGG G ))++
9$$ "&TY
rJ c # j K | D ]}t |t r|V dS )zIterate over all of the method defined in this class only.
:returns: The methods defined on the class.
:rtype: iterable(FunctionDef)
N)r r r )r members rH r zClassDef.mymethods
sE kkmm F&+..
rJ c J | j rt d d d S dS )a< Get the implicit metaclass of the current class.
For newstyle classes, this will return an instance of builtins.type.
For oldstyle classes, it will simply return None, since there's
no implicit metaclass there.
:returns: The metaclass.
:rtype: builtins.type or None
r rK r N)rY r. r s rH r zClassDef.implicit_metaclass
s+ = 0!&))!,Q/ /trJ c t | j D ]]} | | D ]3}t |t r |j r|j | _ d| _ n4N# t $ r Y Zw xY w| j rK t d | j | D S # t t f$ r Y dS w xY wdS )a Return the explicit declared metaclass for the current class.
An explicit declared metaclass is defined
either by passing the ``metaclass`` keyword argument
in the class definition line (Python 3) or (Python 2) by
having a ``__metaclass__`` class attribute, or if there are
no explicit bases but there is a global ``__metaclass__`` variable.
:returns: The metaclass of this class,
or None if one could not be found.
r Tc 3 N K | ] }t |t j |V !d S ro r rr s rH rd z.ClassDef.declared_metaclass.. sI %dD,@AA rJ N)
r
r* r r r! rH _metaclass_hackr r& r( )r rP rc r; s rH r] zClassDef.declared_metaclass
s
J D
#zz'z : : G!'844 *1*</3, !
?
$ 5 5g 5 F F
#M2
tt
ts$ A
A
A#"A#.1B B54B5r: set[ClassDef] | Nonec |t }| | | | }|6| | D ] }||vr| | }| n |S Nr )r r r] r _find_metaclass)r r: rP r r s rH r zClassDef._find_metaclass$ s <55D '''88 = ...99
%% " 2 24 8 8E ( rJ c . | | S )zGet the metaclass of this class.
If this class does not define explicitly a metaclass,
then the first defined metaclass in ancestors will be used
instead.
:returns: The metaclass of this class.
r )r r8 s rH r zClassDef.metaclass4 s ##G#444rJ c | j S ro )r r s rH has_metaclass_hackzClassDef.has_metaclass_hack? s ##rJ c # K d| j vrdS | d D ];}t D ])} | | n# t $ r Y &w xY w5t |t j r |j r|V [t |d slt |t j
rd |j D }n| }t |t j r|s|c S |D ]k} | D ]C}t |t j rt |j t s7|j s?|V D\# t" $ r Y hw xY w=dS )z+Return an iterator with the inferred slots. __slots__Nrm c g | ]
}|d S rC rE )rF items rH rI z$ClassDef._islots..\ s :::d$q':::rJ )r r ITER_METHODSr r r r+ r( r hasattrro rp rm r r r* r r )r slotsr r rV r1 s rH _islotszClassDef._islotsB s dk ) )4]];// + + E$
MM$'''E. H % !344
; KKK5(++
% !233
(::ek::: &$"677
$'IIKK ' ' ) $l&8 %!+HNC!@!@% % '~ % $ &' & H
ts$ A
AA5AE
EEc | j st d | } t | }n@# t $ r3}|j r!|j d dvr|j d cY d }~S Y d }~d S d }~ww xY w|gt
| z S )N8The concept of slots is undefined for old-style classes.r )r N)rY NotImplementedErrorr r& r( r r )r r firstr s rH _slotszClassDef._slotsu s } %J
KKEE x
#CHQKz 9 9x{""""""44444
we$$s <
A9"A4(A94A9c J d d}| j st d | }n"# t $ r}t d |d}~ww xY wt || }t d |D sdS t
t | d
S )
aY Get all the slots for this node.
:returns: The names of slots for this class.
If the class doesn't define any slot, through the ``__slots__``
variable, then this function will return a None.
Also, it will return None in the case the slots were not inferred.
:rtype: list(str) or None
r list[ClassDef]rZ $Iterator[node_classes.NodeNG | None]c 3 K | D ]P}| dk r | }n# t $ r Y =w xY w| |E d {V Ld V Qd S )Nr )ra r r )r rO cls_slotss rH
grouped_slotsz%ClassDef.slots..grouped_slots s
99;;"333 #
II* H ( ((((((((( JJJJ
s 6
AAr z)Cannot get slots while parsing mro fails.Nc 3 K | ]}|d uV d S ro rE )rF slots rH rd z!ClassDef.slots.. s' 664t#666666rJ c | j S ro )r )r s rH z ClassDef.slots.. s 4: rJ )rp )r r rZ r )rY r r r r allsortedr )r r r r' r s rH r zClassDef.slots s } %J
((**CC %;
]]3''((6666666 4c%jj&=&=>>>>s 1
AA Ac #
K |t }| j s7| dk r t d d d V d S | j D ]} t d | | D }n# t t f$ r Y Vw xY wt |t j
r|j }t |t s|j
s|V |j E d {V d S )Nr r rK r c 3 R K | ]"}t |t r|j |V #d S ro r r s rH rd z+ClassDef._inferred_bases.. sF &q% 0 0 67W_ 5D___ rJ r )r r
ra r. r& r* r r r( r r r r r! )r rP r r; s rH _inferred_baseszClassDef._inferred_bases sE ?&((Gz djjll.? ? ? **1-a0 0 0 0 FJ ) )D
!ZZ
Z @ @
#M2
'5>22
+!* gx00
<
)
"=((((((((# ) )s ?BB/.B/c t | | }g }|D ]{}|| u r | | }| | 4# t $ r; t | | }| | Y xw xY w| gg|z |gz }t t
|| | }t | t || | S r ) r r _compute_mrorQ r r r| rl rX )r rP ri rh rc r r unmerged_mros rH r zClassDef._compute_mro s d 2 27 2 C CDD " , ,Dt||
,'''88 %%%%&
,
,
, ! !@!@ A A +++++
, x)+~.>> 0 tW M MNN ... tW555s +A AB! B!r c . | | S )a* Get the method resolution order, using C3 linearization.
:returns: The list of ancestors, sorted by the mro.
:rtype: list(NodeNG)
:raises DuplicateBasesError: Duplicate bases in the same class base
:raises InconsistentMroError: A class' MRO is inconsistent
r )r r8 s rH r z ClassDef.mro s 111rJ r c dS )zDetermine the boolean value of this node.
:returns: The boolean value of this node.
For a :class:`ClassDef` this is always ``True``.
TrE r8 s rH r9 zClassDef.bool_value r: rJ c # K | j | j V | j E d {V | j
| j E d {V | j E d {V d S ro )r r
rF r r s rH r= zClassDef.get_children sx ? &/ ! ! !: = $} $ $ $ $ $ $ $9 rJ c | d | j D }t t j | S )Nc 3 > K | ]}| V d S ro )r )rF r s rH rd z-ClassDef._get_assign_nodes.. s? !
!
/9J ( ( * *!
!
!
!
!
!
rJ )r r r# r$
from_iterable)r children_assign_nodess rH r zClassDef._get_assign_nodes
sD !
!
=AY!
!
!
IO112GHHIIIrJ r r rB r r c | S r? rE r s rH r zClassDef.frame r@ rJ r/ r0 rA rB )rZ rR rh )r rG r r r r ro rE r1 )rZ rb rD r# rF rC )TN)r@ r rP r rZ r )rZ r )NT)rp r rP r r r rZ r )rp r rP r r r rZ r )rP r rZ rG ri )r: r rP r rZ rG )rP r rZ r rk rG )Jr rH rI r rJ r r# r r rH rK r r! r~ rA r rL rM rJ rN rO r r rP r rL r r\ rY r5 r r r r r r r rt r r r r r r r r r ry r r r r r r r r r r r] r r r r r r5 r r r r r9 r= r r rQ rR s @rH r r s
NOJ $
E $J$$$$O D 8
D @M1I'^',UVVV
Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 WVQ2f 7666
X Z Z " #'/' %)!%/' /' /' /' /' /'b $ Ix
Q H
"
"
"
"
" _
" _ . . .# # # # X X X X X. . .`+ + + + +:17 17 17 17f ; ; X; GK+ + + + + Z * " " " "T T T T T.T T T T T, $ $ $ $ ,0 " 9 9 9 9 9v Yt
4 4 4< ,0 " H H H H H T 23$ 3$ 3$ 3$ 3$j 26# # # # #L UY 5 5 5 5 5$ $ $1 1 1f% % %" *? *? *?X%) %) %) %) %)N6 6 6 6 602 2 2 2 2 J J J :> rJ r )rR rY rZ r[ ro )r{ r rZ r r# )ir
__future__r r r# r sysr collections.abcr r functoolsr typingr r r r
r r r
r rN r
astroid.constr r r r r astroid.contextr r r r astroid.exceptionsr r r r r r r r r! !astroid.interpreter.dunder_lookupr" astroid.interpreter.objectmodelr# r$ r% astroid.managerr&
astroid.nodesr' r( r) r* r+ astroid.nodes.scoped_nodes.mixinr, r- astroid.nodes.scoped_nodes.utilsr. astroid.nodes.utilsr/ astroid.typingr0 r1 r2 version_infor5 r6 typing_extensionsastroid.decoratorsr7 r8 r frozensetr lazy_importr= r rB rX rl r| r r rT rn ry r r FilterStmtsBaseNoder MultiLineBlockNode Statementr r r r9 rA rD r rE rJ rH r s
# " " " " "
/ / / / / / / / G G G G G G G G G G G G G G 0 0 0 0 0 0 O O O O O O O O O O O O O O
5 4 4 4 4 4 R R R R R R R R R R * * * * * * M M M M M M M M M M M M M M Q Q Q Q Q Q Q Q ; ; ; ; ; ; ( ( ( ( ( ( T T T T T T T T T Tv )))))) ))))))DDDDDD + "K #ABB
$
9
%
% iTTT
WT]]# # #L!. !. !. !.H
(
h h h h h
h h hVP# P# P# P# P#% P# P# P#f`# `# `# `# `#! `# `# `#FQ# Q# Q# Q# Q# Q# Q# Q#hA# A# A# A# A#! A# A# A#H" " "JRC RC RC RC RC[
,.> RC RC RCjc c c c c+0+2G c c cL { & @ D ([ [ [ [ [#%5{7L[ [ [ [ [rJ