Nodes

Every available node class.

See also

ast documentation

All nodes inherit from NodeNG.

For a list of available nodes see Nodes.

Nodes

AnnAssign([lineno, col_offset, parent])	Class representing an ast.AnnAssign node.
Arguments([vararg, kwarg, parent])	Class representing an ast.arguments node.
Assert([lineno, col_offset, parent])	Class representing an ast.Assert node.
Assign([lineno, col_offset, parent])	Class representing an ast.Assign node.
AssignAttr([attrname, lineno, col_offset, …])	Variation of ast.Assign representing assignment to an attribute.
AssignName([name, lineno, col_offset, parent])	Variation of ast.Assign representing assignment to a name.
AsyncFor([lineno, col_offset, parent])	Class representing an ast.AsyncFor node.
AsyncFunctionDef([name, doc, lineno, …])	Class representing an ast.FunctionDef node.
AsyncWith([lineno, col_offset, parent])	Asynchronous with built with the async keyword.
Attribute([attrname, lineno, col_offset, parent])	Class representing an ast.Attribute node.
AugAssign([op, lineno, col_offset, parent])	Class representing an ast.AugAssign node.
Await([lineno, col_offset, parent])	Class representing an ast.Await node.
BinOp([op, lineno, col_offset, parent])	Class representing an ast.BinOp node.
BoolOp([op, lineno, col_offset, parent])	Class representing an ast.BoolOp node.
Break([lineno, col_offset, parent])	Class representing an ast.Break node.
Call([lineno, col_offset, parent])	Class representing an ast.Call node.
ClassDef([name, doc, lineno, col_offset, parent])	Class representing an ast.ClassDef node.
Compare([lineno, col_offset, parent])	Class representing an ast.Compare node.
Comprehension([parent])	Class representing an ast.comprehension node.
Const(value[, lineno, col_offset, parent, kind])	Class representing any constant including num, str, bool, None, bytes.
Continue([lineno, col_offset, parent])	Class representing an ast.Continue node.
Decorators([lineno, col_offset, parent])	A node representing a list of decorators.
DelAttr([attrname, lineno, col_offset, parent])	Variation of ast.Delete representing deletion of an attribute.
DelName([name, lineno, col_offset, parent])	Variation of ast.Delete representing deletion of a name.
Delete([lineno, col_offset, parent])	Class representing an ast.Delete node.
Dict([lineno, col_offset, parent])	Class representing an ast.Dict node.
DictComp([lineno, col_offset, parent])	Class representing an ast.DictComp node.
DictUnpack([lineno, col_offset, parent])	Represents the unpacking of dicts into dicts using PEP 448.
Ellipsis([lineno, col_offset, parent])	Class representing an ast.Ellipsis node.
EmptyNode([lineno, col_offset, parent])	Holds an arbitrary object in the LocalsDictNodeNG.locals.
ExceptHandler([lineno, col_offset, parent])	Class representing an ast.ExceptHandler.
Exec([lineno, col_offset, parent])	Class representing the exec statement.
Expr([lineno, col_offset, parent])	Class representing an ast.Expr node.
ExtSlice([lineno, col_offset, parent])	Class representing an ast.ExtSlice node.
For([lineno, col_offset, parent])	Class representing an ast.For node.
FormattedValue([lineno, col_offset, parent])	Class representing an ast.FormattedValue node.
FunctionDef([name, doc, lineno, col_offset, …])	Class representing an ast.FunctionDef.
GeneratorExp([lineno, col_offset, parent])	Class representing an ast.GeneratorExp node.
Global(names[, lineno, col_offset, parent])	Class representing an ast.Global node.
If([lineno, col_offset, parent])	Class representing an ast.If node.
IfExp([lineno, col_offset, parent])	Class representing an ast.IfExp node.
Import([names, lineno, col_offset, parent])	Class representing an ast.Import node.
ImportFrom(fromname, names[, level, lineno, …])	Class representing an ast.ImportFrom node.
Index([lineno, col_offset, parent])	Class representing an ast.Index node.
JoinedStr([lineno, col_offset, parent])	Represents a list of string expressions to be joined.
Keyword([arg, lineno, col_offset, parent])	Class representing an ast.keyword node.
Lambda([lineno, col_offset, parent])	Class representing an ast.Lambda node.
List([ctx, lineno, col_offset, parent])	Class representing an ast.List node.
ListComp([lineno, col_offset, parent])	Class representing an ast.ListComp node.
Match([lineno, col_offset, parent])	Class representing a ast.Match node.
MatchAs([lineno, col_offset, parent])	Class representing a ast.MatchAs node.
MatchCase([lineno, col_offset, parent])	Class representing a ast.match_case node.
MatchClass([lineno, col_offset, parent])	Class representing a ast.MatchClass node.
MatchMapping([lineno, col_offset, parent])	Class representing a ast.MatchMapping node.
MatchOr([lineno, col_offset, parent])	Class representing a ast.MatchOr node.
MatchSequence([lineno, col_offset, parent])	Class representing a ast.MatchSequence node.
MatchSingleton(lineno, col_offset, parent, …)	Class representing a ast.MatchSingleton node.
MatchStar(lineno, col_offset, parent, *, name)	Class representing a ast.MatchStar node.
MatchValue([lineno, col_offset, parent])	Class representing a ast.MatchValue node.
Module(name, doc[, file, package, parent, …])	Class representing an ast.Module node.
Name([name, lineno, col_offset, parent])	Class representing an ast.Name node.
Nonlocal(names[, lineno, col_offset, parent])	Class representing an ast.Nonlocal node.
Pass([lineno, col_offset, parent])	Class representing an ast.Pass node.
Print([nl, lineno, col_offset, parent])	Class representing an ast.Print node.
Raise([lineno, col_offset, parent])	Class representing an ast.Raise node.
Repr([lineno, col_offset, parent])	Class representing an ast.Repr node.
Return([lineno, col_offset, parent])	Class representing an ast.Return node.
Set([lineno, col_offset, parent])	Class representing an ast.Set node.
SetComp([lineno, col_offset, parent])	Class representing an ast.SetComp node.
Slice([lineno, col_offset, parent])	Class representing an ast.Slice node.
Starred([ctx, lineno, col_offset, parent])	Class representing an ast.Starred node.
Subscript([ctx, lineno, col_offset, parent])	Class representing an ast.Subscript node.
TryExcept([lineno, col_offset, parent])	Class representing an ast.TryExcept node.
TryFinally([lineno, col_offset, parent])	Class representing an ast.TryFinally node.
Tuple([ctx, lineno, col_offset, parent])	Class representing an ast.Tuple node.
UnaryOp([op, lineno, col_offset, parent])	Class representing an ast.UnaryOp node.
Unknown([lineno, col_offset, parent])	This node represents a node in a constructed AST where introspection is not possible.
While([lineno, col_offset, parent])	Class representing an ast.While node.
With([lineno, col_offset, parent])	Class representing an ast.With node.
Yield([lineno, col_offset, parent])	Class representing an ast.Yield node.
YieldFrom([lineno, col_offset, parent])	Class representing an ast.YieldFrom node.

class astroid.nodes.AnnAssign(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.AssignTypeMixin, astroid.node_classes.Statement

Class representing an ast.AnnAssign node.

An AnnAssign is an assignment with a type annotation.

>>> node = astroid.extract_node('variable: List[int] = range(10)')
>>> node
<AnnAssign l.1 at 0x7effe1d4c630>

annotation = None

The type annotation of what is being assigned to.

Type:NodeNG

assigned_stmts(node=None, context=None, assign_path=None)

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(target, annotation, simple, value=None)

Do some setup after initialisation.

Parameters:

• target (NodeNG) – What is being assigned to.
• annotation – The type annotation of what is being assigned to.
• simple (int) – Whether target is a pure name or a complex statement.
• value – The value being assigned to the variables.

Type:

NodeNG

Type:

NodeNG or None

simple = None

Whether target is a pure name or a complex statement.

Type:int

target = None

What is being assigned to.

Type:NodeNG or None

value = None

The value being assigned to the variables.

Type:NodeNG or None

class astroid.nodes.Arguments(vararg=None, kwarg=None, parent=None)

Bases: astroid.mixins.AssignTypeMixin, astroid.node_classes.NodeNG

Class representing an ast.arguments node.

An Arguments node represents that arguments in a function definition.

>>> node = astroid.extract_node('def foo(bar): pass')
>>> node
<FunctionDef.foo l.1 at 0x7effe1db8198>
>>> node.args
<Arguments l.1 at 0x7effe1db82e8>

annotations = None

The type annotations of arguments that can be passed positionally.

Type:list(NodeNG)

args = None

The names of the required arguments.

Type:list(AssignName)

arguments

<wrapped by the cachedproperty decorator> Get all the arguments for this node, including positional only and positional and keyword

assigned_stmts(node=None, context=None, assign_path=None)

default_value(argname)

Get the default value for an argument.

Parameters:argname (str) – The name of the argument to get the default value for. Raises:NoDefault – If there is no default value defined for the given argument.

defaults = None

The default values for arguments that can be passed positionally.

Type:list(NodeNG)

find_argname(argname, rec=False)

Get the index and AssignName node for given name.

Parameters:

• argname (str) – The name of the argument to search for.
• rec (bool) – Whether or not to include arguments in unpacked tuples in the search.

Returns:

The index and node for the argument.

Return type:

tuple(str or None, AssignName or None)

format_args()

Get the arguments formatted as string.

Returns:The formatted arguments. Return type:str

fromlineno

<wrapped by the cachedproperty decorator> The first line that this node appears on in the source code.

type:int or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

is_argument(name)

Check if the given name is defined in the arguments.

Parameters:name (str) – The name to check for. Returns:True if the given name is defined in the arguments, False otherwise. Return type:bool

kw_defaults = None

The default values for keyword arguments that cannot be passed positionally.

Type:list(NodeNG)

kwarg = None

The name of the variable length keyword arguments.

Type:str or None

kwargannotation = None

The type annotation for the variable length keyword arguments.

Type:NodeNG

kwonlyargs = None

The keyword arguments that cannot be passed positionally.

Type:list(AssignName)

kwonlyargs_annotations = None

The type annotations of arguments that cannot be passed positionally.

Type:list(NodeNG)

posonlyargs = None

The arguments that can only be passed positionally.

Type:list(AssignName)

posonlyargs_annotations = None

The type annotations of arguments that can only be passed positionally.

Type:list(NodeNG)

postinit(args, defaults, kwonlyargs, kw_defaults, annotations, posonlyargs=None, kwonlyargs_annotations=None, posonlyargs_annotations=None, varargannotation=None, kwargannotation=None, type_comment_args=None, type_comment_kwonlyargs=None, type_comment_posonlyargs=None)

Do some setup after initialisation.

Parameters:

• args (list(AssignName)) – The names of the required arguments.
• defaults (list(NodeNG)) – The default values for arguments that can be passed positionally.
• kwonlyargs (list(AssignName)) – The keyword arguments that cannot be passed positionally.
• posonlyargs – The arguments that can only be passed positionally.
• kw_defaults (list(NodeNG)) – The default values for keyword arguments that cannot be passed positionally.
• annotations (list(NodeNG)) – The type annotations of arguments that can be passed positionally.
• kwonlyargs_annotations (list(NodeNG)) – The type annotations of arguments that cannot be passed positionally. This should always be passed in Python 3.
• posonlyargs_annotations (list(NodeNG)) – The type annotations of arguments that can only be passed positionally. This should always be passed in Python 3.
• varargannotation (NodeNG) – The type annotation for the variable length arguments.
• kwargannotation (NodeNG) – The type annotation for the variable length keyword arguments.
• type_comment_args (list(NodeNG or None)) – The type annotation, passed by a type comment, of each argument.
• type_comment_args – The type annotation, passed by a type comment, of each keyword only argument.
• type_comment_args – The type annotation, passed by a type comment, of each positional argument.

type_comment_args = None

The type annotation, passed by a type comment, of each argument.

If an argument does not have a type comment, the value for that argument will be None.

Type:list(NodeNG or None)

type_comment_kwonlyargs = None

The type annotation, passed by a type comment, of each keyword only argument.

If an argument does not have a type comment, the value for that argument will be None.

Type:list(NodeNG or None)

type_comment_posonlyargs = None

The type annotation, passed by a type comment, of each positional argument.

If an argument does not have a type comment, the value for that argument will be None.

Type:list(NodeNG or None)

vararg = None

The name of the variable length arguments.

Type:str or None

varargannotation = None

The type annotation for the variable length arguments.

Type:NodeNG

class astroid.nodes.Assert(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.Statement

Class representing an ast.Assert node.

An Assert node represents an assert statement.

>>> node = astroid.extract_node('assert len(things) == 10, "Not enough things"')
>>> node
<Assert l.1 at 0x7effe1d527b8>

fail = None

The message shown when the assertion fails.

Type:NodeNG or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(test=None, fail=None)

Do some setup after initialisation.

Parameters:

• test (NodeNG or None) – The test that passes or fails the assertion.
• fail (NodeNG or None) – The message shown when the assertion fails.

test = None

The test that passes or fails the assertion.

Type:NodeNG or None

class astroid.nodes.Assign(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.AssignTypeMixin, astroid.node_classes.Statement

Class representing an ast.Assign node.

An Assign is a statement where something is explicitly asssigned to.

>>> node = astroid.extract_node('variable = range(10)')
>>> node
<Assign l.1 at 0x7effe1db8550>

assigned_stmts(node=None, context=None, assign_path=None)

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(targets=None, value=None, type_annotation=None)

Do some setup after initialisation.

Parameters:

• targets (list(NodeNG) or None) – What is being assigned to.
• value – The value being assigned to the variables.

Type:

NodeNG or None

targets = None

What is being assigned to.

Type:list(NodeNG) or None

type_annotation = None

If present, this will contain the type annotation passed by a type comment

Type:NodeNG or None

value = None

The value being assigned to the variables.

Type:NodeNG or None

class astroid.nodes.AssignAttr(attrname=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.ParentAssignTypeMixin, astroid.node_classes.NodeNG

Variation of ast.Assign representing assignment to an attribute.

>>> node = astroid.extract_node('self.attribute = range(10)')
>>> node
<Assign l.1 at 0x7effe1d521d0>
>>> list(node.get_children())
[<AssignAttr.attribute l.1 at 0x7effe1d52320>, <Call l.1 at 0x7effe1d522e8>]
>>> list(node.get_children())[0].as_string()
'self.attribute'

assigned_stmts(node=None, context=None, assign_path=None)

attrname = None

The name of the attribute being assigned to.

Type:str or None

expr = None

What has the attribute that is being assigned to.

Type:NodeNG or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

infer_lhs(context=None)

infer an Attribute node by using getattr on the associated object

postinit(expr=None)

Do some setup after initialisation.

Parameters:expr (NodeNG or None) – What has the attribute that is being assigned to.

class astroid.nodes.AssignName(name=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.LookupMixIn, astroid.mixins.ParentAssignTypeMixin, astroid.node_classes.NodeNG

Variation of ast.Assign representing assignment to a name.

An AssignName is the name of something that is assigned to. This includes variables defined in a function signature or in a loop.

>>> node = astroid.extract_node('variable = range(10)')
>>> node
<Assign l.1 at 0x7effe1db8550>
>>> list(node.get_children())
[<AssignName.variable l.1 at 0x7effe1db8748>, <Call l.1 at 0x7effe1db8630>]
>>> list(node.get_children())[0].as_string()
'variable'

assigned_stmts(node=None, context=None, assign_path=None)

infer_lhs(context=None)

infer a Name: use name lookup rules

name = None

The name that is assigned to.

Type:str or None

class astroid.nodes.AsyncFor(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.For

Class representing an ast.AsyncFor node.

An AsyncFor is an asynchronous For built with the async keyword.

>>> node = astroid.extract_node('''
async def func(things):
    async for thing in things:
        print(thing)
''')
>>> node
<AsyncFunctionDef.func l.2 at 0x7f23b2e416d8>
>>> node.body[0]
<AsyncFor l.3 at 0x7f23b2e417b8>

class astroid.nodes.AsyncFunctionDef(name=None, doc=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.scoped_nodes.FunctionDef

Class representing an ast.FunctionDef node.

A AsyncFunctionDef is an asynchronous function created with the async keyword.

>>> node = astroid.extract_node('''
async def func(things):
    async for thing in things:
        print(thing)
''')
>>> node
<AsyncFunctionDef.func l.2 at 0x7f23b2e416d8>
>>> node.body[0]
<AsyncFor l.3 at 0x7f23b2e417b8>

class astroid.nodes.AsyncWith(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.With

Asynchronous with built with the async keyword.

class astroid.nodes.Attribute(attrname=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Attribute node.

attrname = None

The name of the attribute.

Type:str or None

expr = None

The name that this node represents.

Type:Name or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(expr=None)

Do some setup after initialisation.

Parameters:expr (Name or None) – The name that this node represents.

class astroid.nodes.AugAssign(op=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.AssignTypeMixin, astroid.node_classes.Statement

Class representing an ast.AugAssign node.

An AugAssign is an assignment paired with an operator.

>>> node = astroid.extract_node('variable += 1')
>>> node
<AugAssign l.1 at 0x7effe1db4d68>

assigned_stmts(node=None, context=None, assign_path=None)

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

op = None

The operator that is being combined with the assignment.

This includes the equals sign.

Type:str or None

postinit(target=None, value=None)

Do some setup after initialisation.

Parameters:

• target (NodeNG or None) – What is being assigned to.
• value – The value being assigned to the variable.

Type:

NodeNG or None

target = None

What is being assigned to.

Type:NodeNG or None

type_errors(context=None)

Get a list of type errors which can occur during inference.

Each TypeError is represented by a BadBinaryOperationMessage , which holds the original exception.

Returns:The list of possible type errors. Return type:list(BadBinaryOperationMessage)

value = None

The value being assigned to the variable.

Type:NodeNG or None

class astroid.nodes.Await(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Await node.

An Await is the await keyword.

>>> node = astroid.extract_node('''
async def func(things):
    await other_func()
''')
>>> node
<AsyncFunctionDef.func l.2 at 0x7f23b2e41748>
>>> node.body[0]
<Expr l.3 at 0x7f23b2e419e8>
>>> list(node.body[0].get_children())[0]
<Await l.3 at 0x7f23b2e41a20>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(value=None)

Do some setup after initialisation.

Parameters:value (NodeNG or None) – What to wait for.

value = None

What to wait for.

Type:NodeNG or None

class astroid.nodes.BinOp(op=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.BinOp node.

A BinOp node is an application of a binary operator.

>>> node = astroid.extract_node('a + b')
>>> node
<BinOp l.1 at 0x7f23b2e8cfd0>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

left = None

What is being applied to the operator on the left side.

Type:NodeNG or None

op = None

The operator.

Type:str or None

op_left_associative()

op_precedence()

postinit(left=None, right=None)

Do some setup after initialisation.

Parameters:

• left (NodeNG or None) – What is being applied to the operator on the left side.
• right (NodeNG or None) – What is being applied to the operator on the right side.

right = None

What is being applied to the operator on the right side.

Type:NodeNG or None

type_errors(context=None)

Get a list of type errors which can occur during inference.

Each TypeError is represented by a BadBinaryOperationMessage, which holds the original exception.

Returns:The list of possible type errors. Return type:list(BadBinaryOperationMessage)

class astroid.nodes.BoolOp(op=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.BoolOp node.

A BoolOp is an application of a boolean operator.

>>> node = astroid.extract_node('a and b')
>>> node
<BinOp l.1 at 0x7f23b2e71c50>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

op = None

The operator.

Type:str or None

op_precedence()

postinit(values=None)

Do some setup after initialisation.

Parameters:values (list(NodeNG) or None) – The values being applied to the operator.

values = None

The values being applied to the operator.

Type:list(NodeNG) or None

class astroid.nodes.Break(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.Statement

Class representing an ast.Break node.

>>> node = astroid.extract_node('break')
>>> node
<Break l.1 at 0x7f23b2e9e5c0>

class astroid.nodes.Call(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Call node.

A Call node is a call to a function, method, etc.

>>> node = astroid.extract_node('function()')
>>> node
<Call l.1 at 0x7f23b2e71eb8>

args = None

The positional arguments being given to the call.

Type:list(NodeNG) or None

func = None

What is being called.

Type:NodeNG or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

keywords = None

The keyword arguments being given to the call.

Type:list(NodeNG) or None

kwargs

The keyword arguments that unpack something.

Type:list(Keyword)

postinit(func=None, args=None, keywords=None)

Do some setup after initialisation.

Parameters:

• func (NodeNG or None) – What is being called.
• args (list(NodeNG) or None) – The positional arguments being given to the call.
• keywords (list(NodeNG) or None) – The keyword arguments being given to the call.

starargs

The positional arguments that unpack something.

Type:list(Starred)

class astroid.nodes.ClassDef(name=None, doc=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.FilterStmtsMixin, astroid.scoped_nodes.LocalsDictNodeNG, astroid.node_classes.Statement

Class representing an ast.ClassDef node.

>>> node = astroid.extract_node('''
class Thing:
    def my_meth(self, arg):
        return arg + self.offset
''')
>>> node
<ClassDef.Thing l.2 at 0x7f23b2e9e748>

ancestors(recurs=True, context=None)

Iterate over the base classes in prefixed depth first order.

Parameters:recurs (bool) – Whether to recurse or return direct ancestors only. Returns:The base classes Return type:iterable(NodeNG)

basenames

The names of the parent classes

Names are given in the order they appear in the class definition.

Type:list(str)

bases = None

What the class inherits from.

Type:list(NodeNG)

block_range(lineno)

Get a range from the given line number to where this node ends.

Parameters:lineno (int) – Unused. Returns:The range of line numbers that this node belongs to, Return type:tuple(int, int)

blockstart_tolineno

<wrapped by the cachedproperty decorator> The line on which the beginning of this block ends.

type:int

body = None

The contents of the class body.

Type:list(NodeNG)

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. For a ClassDef this is always True. Return type:bool

callable()

Whether this node defines something that is callable.

Returns:True if this defines something that is callable, False otherwise. For a ClassDef this is always True. Return type:bool

declared_metaclass(context=None)

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. Return type:NodeNG or None

decorators = None

The decorators that are applied to this class.

Type:Decorators or None

display_type()

A human readable type of this node.

Returns:The type of this node. Return type:str

doc = None

The class’ docstring.

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

getattr(name, context=None, class_context=True)

Get an attribute from this class, using Python’s attribute semantic.

This method doesn’t look in the instance_attrs dictionary since it is done by an Instance proxy at inference time. It may return an 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.

Parameters:

• name (str) – The attribute to look for.
• class_context (bool) – Whether the attribute can be accessed statically.

Returns:

The attribute.

Return type:

list(NodeNG)

Raises:

AttributeInferenceError – If the attribute cannot be inferred.

getitem(index, context=None)

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. Return type:NodeNG Raises:AstroidTypeError – If this class does not define a __getitem__ method.

has_base(node)

Whether this class directly inherits from the given node.

Parameters:node (NodeNG) – The node to check for. Returns:True if this class directly inherits from the given node. Return type:bool

has_dynamic_getattr(context=None)

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:True if the class has a custom __getattr__ or __getattribute__, False otherwise. Return type:bool

has_metaclass_hack()

hide = False

igetattr(name, context=None, class_context=True)

Infer the possible values of the given variable.

Parameters:name (str) – The name of the variable to infer. Returns:The inferred possible values. Return type:iterable(NodeNG or Uninferable)

implicit_locals()

Get implicitly defined class definition locals.

Returns:the the name and Const pair for each local Return type:tuple(tuple(str, node_classes.Const), ..)

implicit_metaclass()

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. Return type:builtins.type or None

implicit_parameters()

infer_binary_op(opnode, operator, other, context, method)

infer_call_result(caller, context=None)

infer what a class is returning when called

instance_attr(name, context=None)

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. Return type:list(NodeNG) Raises:AttributeInferenceError – If no attribute with this name can be found in this class or parent classes.

instance_attr_ancestors(name, context=None)

Iterate over the parents that define the given name as an attribute.

Parameters:name (str) – The name to find definitions for. Returns:The parents that define the given name as an instance attribute. Return type:iterable(NodeNG)

instantiate_class()

Get an Instance of the ClassDef node.

Returns:An Instance of the ClassDef node, or self if this is not possible. Return type:Instance or ClassDef

is_subtype_of(type_name, context=None)

Whether this class is a subtype of the given type.

Parameters:type_name (str) – The name of the type of check against. Returns:True if this class is a subtype of the given type, False otherwise. Return type:bool

keywords = None

The keywords given to the class definition.

This is usually for PEP 3115 style metaclass declaration.

Type:list(Keyword) or None

local_attr(name, context=None)

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. Return type:list(NodeNG) Raises:AttributeInferenceError – If no attribute with this name can be found in this class or parent classes.

local_attr_ancestors(name, context=None)

Iterate over the parents that define the given name.

Parameters:name (str) – The name to find definitions for. Returns:The parents that define the given name. Return type:iterable(NodeNG)

metaclass(context=None)

Get 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. Return type:NodeNG or None

methods()

Iterate over all of the method defined in this class and its parents.

Returns:The methods defined on the class. Return type:iterable(FunctionDef)

mro(context=None) → List[astroid.scoped_nodes.ClassDef]

Get the method resolution order, using C3 linearization.

Returns:

The list of ancestors, sorted by the mro.

Return type:

list(NodeNG)

Raises:

• DuplicateBasesError – Duplicate bases in the same class base
• InconsistentMroError – A class’ MRO is inconsistent

mymethods()

Iterate over all of the method defined in this class only.

Returns:The methods defined on the class. Return type:iterable(FunctionDef)

name = None

The name of the class.

newstyle

Whether this is a new style class or not

Type:bool or None

postinit(bases, body, decorators, newstyle=None, metaclass=None, keywords=None)

Do some setup after initialisation.

Parameters:

• bases (list(NodeNG)) – What the class inherits from.
• body (list(NodeNG)) – The contents of the class body.
• decorators (Decorators or None) – The decorators that are applied to this class.
• newstyle (bool or None) – Whether this is a new style class or not.
• metaclass (NodeNG or None) – The metaclass of this class.
• keywords (list(Keyword) or None) – The keywords given to the class definition.

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

scope_lookup(node, name, offset=0)

Lookup where the given name is assigned.

Parameters:

• node (NodeNG) – The node to look for assignments up to. Any assignments after the given node are ignored.
• name (str) – The name to find assignments for.
• offset (int) – The line offset to filter statements up to.

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).

Return type:

tuple(str, list(NodeNG))

slots()

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. Return type:list(str) or None

special_attributes

The names of special attributes that this class has.

Type:objectmodel.ClassModel

type

The class type for this node.

Possible values are: class, metaclass, exception.

Type:str

class astroid.nodes.Compare(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Compare node.

A Compare node indicates a comparison.

>>> node = astroid.extract_node('a <= b <= c')
>>> node
<Compare l.1 at 0x7f23b2e9e6d8>
>>> node.ops
[('<=', <Name.b l.1 at 0x7f23b2e9e2b0>), ('<=', <Name.c l.1 at 0x7f23b2e9e390>)]

get_children()

Get the child nodes below this node.

Overridden to handle the tuple fields and skip returning the operator strings.

Returns:The children. Return type:iterable(NodeNG)

last_child()

An optimized version of list(get_children())[-1]

Returns:The last child. Return type:NodeNG

left = None

The value at the left being applied to a comparison operator.

Type:NodeNG or None

ops = None

The remainder of the operators and their relevant right hand value.

Type:list(tuple(str, NodeNG)) or None

postinit(left=None, ops=None)

Do some setup after initialisation.

Parameters:

• left (NodeNG or None) – The value at the left being applied to a comparison operator.
• ops (list(tuple(str, NodeNG)) or None) – The remainder of the operators and their relevant right hand value.

class astroid.nodes.Comprehension(parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.comprehension node.

A Comprehension indicates the loop inside any type of comprehension including generator expressions.

>>> node = astroid.extract_node('[x for x in some_values]')
>>> list(node.get_children())
[<Name.x l.1 at 0x7f23b2e352b0>, <Comprehension l.1 at 0x7f23b2e35320>]
>>> list(node.get_children())[1].as_string()
'for x in some_values'

assign_type()

The type of assignment that this node performs.

Returns:The assignment type. Return type:NodeNG

assigned_stmts(node=None, context=None, assign_path=None)

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

ifs = None

The contents of any if statements that filter the comprehension.

Type:list(NodeNG) or None

is_async = None

Whether this is an asynchronous comprehension or not.

Type:bool or None

iter = None

What is iterated over by the comprehension.

Type:NodeNG or None

optional_assign = True

Whether this node optionally assigns a variable.

Type:bool

postinit(target=None, iter=None, ifs=None, is_async=None)

Do some setup after initialisation.

Parameters:

• target (NodeNG or None) – What is assigned to by the comprehension.
• iter (NodeNG or None) – What is iterated over by the comprehension.
• ifs (list(NodeNG) or None) – The contents of any if statements that filter the comprehension.
• is_async – Whether this is an asynchronous comprehension or not.

Type:

bool or None

target = None

What is assigned to by the comprehension.

Type:NodeNG or None

class astroid.nodes.Const(value, lineno=None, col_offset=None, parent=None, kind=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.NodeNG, astroid.bases.Instance

Class representing any constant including num, str, bool, None, bytes.

>>> node = astroid.extract_node('(5, "This is a string.", True, None, b"bytes")')
>>> node
<Tuple.tuple l.1 at 0x7f23b2e358d0>
>>> list(node.get_children())
[<Const.int l.1 at 0x7f23b2e35940>,
<Const.str l.1 at 0x7f23b2e35978>,
<Const.bool l.1 at 0x7f23b2e359b0>,
<Const.NoneType l.1 at 0x7f23b2e359e8>,
<Const.bytes l.1 at 0x7f23b2e35a20>]

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. Return type:bool

getitem(index, context=None)

Get an item from this node if subscriptable.

Parameters:index (Const or Slice) – 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.

has_dynamic_getattr()

Check if the node has a custom __getattr__ or __getattribute__.

Returns:True if the class has a custom __getattr__ or __getattribute__, False otherwise. For a Const this is always False. Return type:bool

infer_binary_op(opnode, operator, other, context, _)

infer_unary_op(op)

itered()

An iterator over the elements this node contains.

Returns:The contents of this node. Return type:iterable(Const) Raises:TypeError – If this node does not represent something that is iterable.

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

class astroid.nodes.Continue(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.Statement

Class representing an ast.Continue node.

>>> node = astroid.extract_node('continue')
>>> node
<Continue l.1 at 0x7f23b2e35588>

class astroid.nodes.Decorators(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

A node representing a list of decorators.

A Decorators is the decorators that are applied to a method or function.

>>> node = astroid.extract_node('''
@property
def my_property(self):
    return 3
''')
>>> node
<FunctionDef.my_property l.2 at 0x7f23b2e35d30>
>>> list(node.get_children())[0]
<Decorators l.1 at 0x7f23b2e35d68>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

nodes = None

The decorators that this node contains.

Type:list(Name or Call) or None

postinit(nodes)

Do some setup after initialisation.

Parameters:nodes (list(Name or Call)) – The decorators that this node contains.

scope()

The first parent node defining a new scope.

Returns:The first parent scope node. Return type:Module or FunctionDef or ClassDef or Lambda or GenExpr

class astroid.nodes.DelAttr(attrname=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.ParentAssignTypeMixin, astroid.node_classes.NodeNG

Variation of ast.Delete representing deletion of an attribute.

>>> node = astroid.extract_node('del self.attr')
>>> node
<Delete l.1 at 0x7f23b2e35f60>
>>> list(node.get_children())[0]
<DelAttr.attr l.1 at 0x7f23b2e411d0>

attrname = None

The name of the attribute that is being deleted.

Type:str or None

expr = None

The name that this node represents.

Type:Name or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(expr=None)

Do some setup after initialisation.

Parameters:expr (Name or None) – The name that this node represents.

class astroid.nodes.DelName(name=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.LookupMixIn, astroid.mixins.ParentAssignTypeMixin, astroid.node_classes.NodeNG

Variation of ast.Delete representing deletion of a name.

A DelName is the name of something that is deleted.

>>> node = astroid.extract_node("del variable #@")
>>> list(node.get_children())
[<DelName.variable l.1 at 0x7effe1da4d30>]
>>> list(node.get_children())[0].as_string()
'variable'

name = None

The name that is being deleted.

Type:str or None

class astroid.nodes.Delete(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.AssignTypeMixin, astroid.node_classes.Statement

Class representing an ast.Delete node.

A Delete is a del statement this is deleting something.

>>> node = astroid.extract_node('del self.attr')
>>> node
<Delete l.1 at 0x7f23b2e35f60>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(targets=None)

Do some setup after initialisation.

Parameters:targets (list(NodeNG) or None) – What is being deleted.

targets = None

What is being deleted.

Type:list(NodeNG) or None

class astroid.nodes.Dict(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG, astroid.objects.DictInstance

Class representing an ast.Dict node.

A Dict is a dictionary that is created with {} syntax.

>>> node = astroid.extract_node('{1: "1"}')
>>> node
<Dict.dict l.1 at 0x7f23b2e35cc0>

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. Return type:bool

classmethod from_elements(items=None)

Create a Dict of constants from a live dictionary.

Parameters:items (dict) – The items to store in the node. Returns:The created dictionary node. Return type:Dict

get_children()

Get 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. Return type:iterable(NodeNG)

getitem(index, context=None)

Get an item from this node.

Parameters:

index (Const or Slice) – 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.
• AstroidIndexError – If the given index does not exist in the dictionary.

infer_unary_op(op)

items = None

The key-value pairs contained in the dictionary.

Type:list(tuple(NodeNG, NodeNG))

itered()

An iterator over the keys this node contains.

Returns:The keys of this node. Return type:iterable(NodeNG)

last_child()

An optimized version of list(get_children())[-1]

Returns:The last child, or None if no children exist. Return type:NodeNG or None

postinit(items)

Do some setup after initialisation.

Parameters:items (list(tuple(NodeNG, NodeNG))) – The key-value pairs contained in the dictionary.

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

class astroid.nodes.DictComp(lineno=None, col_offset=None, parent=None)

Bases: astroid.scoped_nodes.ComprehensionScope

Class representing an ast.DictComp node.

>>> node = astroid.extract_node('{k:v for k, v in things if k > v}')
>>> node
<DictComp l.1 at 0x7f23b2e41d68>

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. For a DictComp this is always Uninferable. Return type:Uninferable

generators = None

The generators that are looped through.

Type:list(Comprehension) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

key = None

What produces the keys.

Type:NodeNG or None

postinit(key=None, value=None, generators=None)

Do some setup after initialisation.

Parameters:

• key (NodeNG or None) – What produces the keys.
• value (NodeNG or None) – What produces the values.
• generators (list(Comprehension) or None) – The generators that are looped through.

value = None

What produces the values.

Type:NodeNG or None

class astroid.nodes.DictUnpack(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.NodeNG

Represents the unpacking of dicts into dicts using PEP 448.

class astroid.nodes.Ellipsis(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.NodeNG

Class representing an ast.Ellipsis node.

An Ellipsis is the ... syntax.

>>> node = astroid.extract_node('...')
>>> node
<Ellipsis l.1 at 0x7f23b2e35160>

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. For an Ellipsis this is always True. Return type:bool

class astroid.nodes.EmptyNode(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.NodeNG

Holds an arbitrary object in the LocalsDictNodeNG.locals.

has_underlying_object()

object = None

class astroid.nodes.ExceptHandler(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.MultiLineBlockMixin, astroid.mixins.AssignTypeMixin, astroid.node_classes.Statement

Class representing an ast.ExceptHandler. node.

An ExceptHandler is an except block on a try-except.

>>> node = astroid.extract_node('''
    try:
        do_something()
    except Exception as error:
        print("Error!")
    ''')
>>> node
<TryExcept l.2 at 0x7f23b2e9d908>
>>> >>> node.handlers
[<ExceptHandler l.4 at 0x7f23b2e9e860>]

assigned_stmts(node=None, context=None, assign_path=None)

blockstart_tolineno

<wrapped by the cachedproperty decorator> The line on which the beginning of this block ends.

type:int

body = None

The contents of the block.

Type:list(NodeNG) or None

catch(exceptions)

Check if this node handles any of the given exceptions.

If exceptions is empty, this will default to True.

Parameters:exceptions (list(str)) – The name of the exceptions to check for.

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

name = None

The name that the caught exception is assigned to.

Type:AssignName or None

postinit(type=None, name=None, body=None)

Do some setup after initialisation.

Parameters:

• type (Tuple or NodeNG or None) – The types that the block handles.
• name (AssignName or None) – The name that the caught exception is assigned to.

:param body:The contents of the block. :type body: list(NodeNG) or None

type = None

The types that the block handles.

Type:Tuple or NodeNG or None

class astroid.nodes.Exec(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.Statement

Class representing the exec statement.

>>> node = astroid.extract_node('exec "True"')
>>> node
<Exec l.1 at 0x7f0e8106c6d0>

expr = None

The expression to be executed.

Type:NodeNG or None

globals = None

The globals dictionary to execute with.

Type:NodeNG or None

locals = None

The locals dictionary to execute with.

Type:NodeNG or None

postinit(expr=None, globals=None, locals=None)

Do some setup after initialisation.

Parameters:expr (NodeNG or None) – The expression to be executed.

:param globals:The globals dictionary to execute with. :type globals: NodeNG or None

Parameters:locals (NodeNG or None) – The locals dictionary to execute with.

class astroid.nodes.Expr(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.Statement

Class representing an ast.Expr node.

An Expr is any expression that does not have its value used or stored.

>>> node = astroid.extract_node('method()')
>>> node
<Call l.1 at 0x7f23b2e352b0>
>>> node.parent
<Expr l.1 at 0x7f23b2e35278>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(value=None)

Do some setup after initialisation.

Parameters:value (NodeNG or None) – What the expression does.

value = None

What the expression does.

Type:NodeNG or None

class astroid.nodes.ExtSlice(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.ExtSlice node.

An ExtSlice is a complex slice expression.

>>> node = astroid.extract_node('l[1:3, 5]')
>>> node
<Subscript l.1 at 0x7f23b2e9e550>
>>> node.slice
<ExtSlice l.1 at 0x7f23b7b05ef0>

dims = None

The simple dimensions that form the complete slice.

Type:list(NodeNG) or None

postinit(dims=None)

Do some setup after initialisation.

Parameters:dims (list(NodeNG) or None) – The simple dimensions that form the complete slice.

class astroid.nodes.For(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.MultiLineBlockMixin, astroid.mixins.BlockRangeMixIn, astroid.mixins.AssignTypeMixin, astroid.node_classes.Statement

Class representing an ast.For node.

>>> node = astroid.extract_node('for thing in things: print(thing)')
>>> node
<For l.1 at 0x7f23b2e8cf28>

assigned_stmts(node=None, context=None, assign_path=None)

blockstart_tolineno

<wrapped by the cachedproperty decorator> The line on which the beginning of this block ends.

type:int

body = None

The contents of the body of the loop.

Type:list(NodeNG) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

iter = None

What the loop iterates over.

Type:NodeNG or None

optional_assign = True

Whether this node optionally assigns a variable.

This is always True for For nodes.

Type:bool

orelse = None

The contents of the else block of the loop.

Type:list(NodeNG) or None

postinit(target=None, iter=None, body=None, orelse=None, type_annotation=None)

Do some setup after initialisation.

Parameters:

• target (NodeNG or None) – What the loop assigns to.
• iter (NodeNG or None) – What the loop iterates over.
• body (list(NodeNG) or None) – The contents of the body of the loop.
• orelse (list(NodeNG) or None) – The contents of the else block of the loop.

target = None

What the loop assigns to.

Type:NodeNG or None

type_annotation = None

If present, this will contain the type annotation passed by a type comment

Type:NodeNG or None

class astroid.nodes.FormattedValue(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.FormattedValue node.

Represents a PEP 498 format string.

>>> node = astroid.extract_node('f"Format {type_}"')
>>> node
<JoinedStr l.1 at 0x7f23b2e4ed30>
>>> node.values
[<Const.str l.1 at 0x7f23b2e4eda0>, <FormattedValue l.1 at 0x7f23b2e4edd8>]

conversion = None

The type of formatting to be applied to the value.

See also

ast.FormattedValue

Type:int or None

format_spec = None

The formatting to be applied to the value.

See also

ast.FormattedValue

Type:JoinedStr or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(value, conversion=None, format_spec=None)

Do some setup after initialisation.

Parameters:

• value (NodeNG) – The value to be formatted into the string.
• conversion (int or None) – The type of formatting to be applied to the value.
• format_spec (JoinedStr or None) – The formatting to be applied to the value.

value = None

The value to be formatted into the string.

Type:NodeNG or None

class astroid.nodes.FunctionDef(name=None, doc=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.MultiLineBlockMixin, astroid.node_classes.Statement, astroid.scoped_nodes.Lambda

Class representing an ast.FunctionDef.

>>> node = astroid.extract_node('''
... def my_func(arg):
...     return arg + 1
... ''')
>>> node
<FunctionDef.my_func l.2 at 0x7f23b2e71e10>

block_range(lineno)

Get a range from the given line number to where this node ends.

Parameters:lineno (int) – Unused. Returns:The range of line numbers that this node belongs to, Return type:tuple(int, int)

blockstart_tolineno

<wrapped by the cachedproperty decorator> The line on which the beginning of this block ends.

type:int

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. For a FunctionDef this is always True. Return type:bool

decoratornames(context=None)

Get the qualified names of each of the decorators on this function.

Parameters:context – An inference context that can be passed to inference functions Returns:The names of the decorators. Return type:set(str)

decorators = None

The decorators that are applied to this method or function.

Type:Decorators or None

doc = None

The function’s docstring.

extra_decorators

<wrapped by the cachedproperty decorator> 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.

type:list(NodeNG)

fromlineno

<wrapped by the cachedproperty decorator> The first line that this node appears on in the source code.

type:int or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

getattr(name, context=None)

this method doesn’t look in the instance_attrs dictionary since it’s done by an Instance proxy at inference time.

igetattr(name, context=None)

Inferred getattr, which returns an iterator of inferred statements.

infer_call_result(caller=None, context=None)

Infer what the function returns when called.

Returns:What the function returns. Return type:iterable(NodeNG or Uninferable) or None

is_abstract(pass_is_abstract=True, any_raise_is_abstract=False)

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 <SomeException>’ 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:True if the method is abstract, False otherwise. Return type:bool

is_bound()

Check if the function is bound to an instance or class.

Returns:True if the function is bound to an instance or class, False otherwise. Return type:bool

is_function = True

Whether this node indicates a function.

For a FunctionDef this is always True.

Type:bool

is_generator()

Check if this is a generator function.

Returns:True is this is a generator function, False otherwise. Return type:bool

is_method()

Check if this function node represents a method.

Returns:True if this is a method, False otherwise. Return type:bool

postinit(args, body, decorators=None, returns=None, type_comment_returns=None, type_comment_args=None)

Do some setup after initialisation.

Parameters:

• args (Arguments or list) – The arguments that the function takes.
• body (list(NodeNG)) – The contents of the function body.
• decorators (Decorators or None) – The decorators that are applied to this method or function.

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.

returns = None

scope_lookup(node, name, offset=0)

Lookup where the given name is assigned.

special_attributes

The names of special attributes that this function has.

Type:objectmodel.FunctionModel

type

<wrapped by the cachedproperty decorator> The function type for this node.

Possible values are: method, function, staticmethod, classmethod.

type:str

type_annotation = None

If present, this will contain the type annotation passed by a type comment

Type:NodeNG or None

type_comment_args = None

If present, this will contain the type annotation for arguments passed by a type comment

type_comment_returns = None

If present, this will contain the return type annotation, passed by a type comment

class astroid.nodes.GeneratorExp(lineno=None, col_offset=None, parent=None)

Bases: astroid.scoped_nodes.ComprehensionScope

Class representing an ast.GeneratorExp node.

>>> node = astroid.extract_node('(thing for thing in things if thing)')
>>> node
<GeneratorExp l.1 at 0x7f23b2e4e400>

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. For a GeneratorExp this is always True. Return type:bool

elt = None

The element that forms the output of the expression.

Type:NodeNG or None

generators = None

The generators that are looped through.

Type:list(Comprehension) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(elt=None, generators=None)

Do some setup after initialisation.

Parameters:

• elt (NodeNG or None) – The element that forms the output of the expression.
• generators (list(Comprehension) or None) – The generators that are looped through.

class astroid.nodes.Global(names, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.Statement

Class representing an ast.Global node.

>>> node = astroid.extract_node('global a_global')
>>> node
<Global l.1 at 0x7f23b2e9de10>

names = None

The names being declared as global.

Type:list(str)

class astroid.nodes.If(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.MultiLineBlockMixin, astroid.mixins.BlockRangeMixIn, astroid.node_classes.Statement

Class representing an ast.If node.

>>> node = astroid.extract_node('if condition: print(True)')
>>> node
<If l.1 at 0x7f23b2e9dd30>

block_range(lineno)

Get a range from the given line number to where this node ends.

Parameters:lineno (int) – The line number to start the range at. Returns:The range of line numbers that this node belongs to, starting at the given line number. Return type:tuple(int, int)

blockstart_tolineno

<wrapped by the cachedproperty decorator> The line on which the beginning of this block ends.

type:int

body = None

The contents of the block.

Type:list(NodeNG) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

has_elif_block()

orelse = None

The contents of the else block.

Type:list(NodeNG) or None

postinit(test=None, body=None, orelse=None)

Do some setup after initialisation.

Parameters:

• test (NodeNG or None) – The condition that the statement tests.
• body (list(NodeNG) or None) – The contents of the block.
• orelse (list(NodeNG) or None) – The contents of the else block.

test = None

The condition that the statement tests.

Type:NodeNG or None

class astroid.nodes.IfExp(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.IfExp node.

>>> node = astroid.extract_node('value if condition else other')
>>> node
<IfExp l.1 at 0x7f23b2e9dbe0>

body = None

The contents of the block.

Type:list(NodeNG) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

op_left_associative()

orelse = None

The contents of the else block.

Type:list(NodeNG) or None

postinit(test=None, body=None, orelse=None)

Do some setup after initialisation.

Parameters:

• test (NodeNG or None) – The condition that the statement tests.
• body (list(NodeNG) or None) – The contents of the block.
• orelse (list(NodeNG) or None) – The contents of the else block.

test = None

The condition that the statement tests.

Type:NodeNG or None

class astroid.nodes.Import(names=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.mixins.ImportFromMixin, astroid.node_classes.Statement

Class representing an ast.Import node.

>>> node = astroid.extract_node('import astroid')
>>> node
<Import l.1 at 0x7f23b2e4e5c0>

names = None

The names being imported.

Each entry is a tuple of the name being imported, and the alias that the name is assigned to (if any).

Type:list(tuple(str, str or None)) or None

class astroid.nodes.ImportFrom(fromname, names, level=0, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.mixins.ImportFromMixin, astroid.node_classes.Statement

Class representing an ast.ImportFrom node.

>>> node = astroid.extract_node('from my_package import my_module')
>>> node
<ImportFrom l.1 at 0x7f23b2e415c0>

level = None

The level of relative import.

Essentially this is the number of dots in the import. This is always 0 for absolute imports.

Type:int

modname = None

The module that is being imported from.

This is None for relative imports.

Type:str or None

names = None

What is being imported from the module.

Each entry is a tuple of the name being imported, and the alias that the name is assigned to (if any).

Type:list(tuple(str, str or None))

class astroid.nodes.Index(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Index node.

An Index is a simple subscript.

>>> node = astroid.extract_node('things[1]')
>>> node
<Subscript l.1 at 0x7f23b2e9e2b0>
>>> node.slice
<Index l.1 at 0x7f23b2e9e6a0>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(value=None)

Do some setup after initialisation.

Parameters:value (NodeNG or None) – The value to subscript with.

value = None

The value to subscript with.

Type:NodeNG or None

class astroid.nodes.JoinedStr(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Represents a list of string expressions to be joined.

>>> node = astroid.extract_node('f"Format {type_}"')
>>> node
<JoinedStr l.1 at 0x7f23b2e4ed30>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(values=None)

Do some setup after initialisation.

Parameters:value – The string expressions to be joined. Type:list(FormattedValue or Const) or None

values = None

The string expressions to be joined.

Type:list(FormattedValue or Const) or None

class astroid.nodes.Keyword(arg=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.keyword node.

>>> node = astroid.extract_node('function(a_kwarg=True)')
>>> node
<Call l.1 at 0x7f23b2e9e320>
>>> node.keywords
[<Keyword l.1 at 0x7f23b2e9e9b0>]

arg = None

The argument being assigned to.

Type:Name or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(value=None)

Do some setup after initialisation.

Parameters:value (NodeNG or None) – The value being assigned to the ketword argument.

value = None

The value being assigned to the keyword argument.

Type:NodeNG or None

class astroid.nodes.Lambda(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.FilterStmtsMixin, astroid.scoped_nodes.LocalsDictNodeNG

Class representing an ast.Lambda node.

>>> node = astroid.extract_node('lambda arg: arg + 1')
>>> node
<Lambda.<lambda> l.1 at 0x7f23b2e41518>

argnames()

Get the names of each of the arguments.

Returns:The names of the arguments. Return type:list(str)

args = None

The arguments that the function takes.

Type:Arguments or list

body = None

The contents of the function body.

Type:list(NodeNG)

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. For a Lambda this is always True. Return type:bool

callable()

Whether this node defines something that is callable.

Returns:True if this defines something that is callable, False otherwise. For a Lambda this is always True. Return type:bool

display_type()

A human readable type of this node.

Returns:The type of this node. Return type:str

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

implicit_parameters()

infer_call_result(caller, context=None)

Infer what the function returns when called.

Parameters:caller (object) – Unused

is_lambda = True

name = '<lambda>'

postinit(args, body)

Do some setup after initialisation.

Parameters:

• args (Arguments) – The arguments that the function takes.
• body (list(NodeNG)) – The contents of the function body.

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

scope_lookup(node, name, offset=0)

Lookup where the given names is assigned.

Parameters:

• node (NodeNG) – The node to look for assignments up to. Any assignments after the given node are ignored.
• name (str) – The name to find assignments for.
• offset (int) – The line offset to filter statements up to.

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).

Return type:

tuple(str, list(NodeNG))

type

Whether this is a method or function.

Returns:‘method’ if this is a method, ‘function’ otherwise. Return type:str

class astroid.nodes.List(ctx=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes._BaseContainer

Class representing an ast.List node.

>>> node = astroid.extract_node('[1, 2, 3]')
>>> node
<List.list l.1 at 0x7f23b2e9e128>

assigned_stmts(node=None, context=None, assign_path=None)

ctx = None

Whether the list is assigned to or loaded from.

Type:Context or None

getitem(index, context=None)

Get an item from this node.

Parameters:index (Const or Slice) – The node to use as a subscript index.

infer_binary_op(opnode, operator, other, context, method)

infer_unary_op(op)

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

class astroid.nodes.ListComp(lineno=None, col_offset=None, parent=None)

Bases: astroid.scoped_nodes._ListComp, astroid.scoped_nodes.ComprehensionScope

Class representing an ast.ListComp node.

>>> node = astroid.extract_node('[thing for thing in things if thing]')
>>> node
<ListComp l.1 at 0x7f23b2e418d0>

class astroid.nodes.Match(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing a ast.Match node.

cases = None

get_children() → Generator[astroid.node_classes.NodeNG, None, None]

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(*, subject: Optional[astroid.node_classes.NodeNG] = None, cases: Optional[List[MatchCase]] = None) → None

subject = None

class astroid.nodes.MatchAs(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing a ast.MatchAs node.

get_children() → Generator[Union[astroid.node_classes.MatchValue, astroid.node_classes.MatchSingleton, astroid.node_classes.MatchSequence, astroid.node_classes.MatchMapping, astroid.node_classes.MatchClass, astroid.node_classes.MatchStar, astroid.node_classes.MatchAs, astroid.node_classes.MatchOr], None, None]

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

name = None

pattern = None

postinit(*, pattern: Optional[PatternTypes] = None, name: Optional[str] = None) → None

class astroid.nodes.MatchCase(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing a ast.match_case node.

body = None

get_children() → Generator[astroid.node_classes.NodeNG, None, None]

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

guard = None

pattern = None

postinit(*, pattern=None, guard: Optional[astroid.node_classes.NodeNG] = None, body: Optional[List[astroid.node_classes.NodeNG]] = None) → None

class astroid.nodes.MatchClass(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing a ast.MatchClass node.

cls = None

get_children() → Generator[astroid.node_classes.NodeNG, None, None]

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

kwd_attrs = None

kwd_patterns = None

patterns = None

postinit(*, cls: Optional[astroid.node_classes.NodeNG] = None, patterns: Optional[List[PatternTypes]] = None, kwd_attrs: Optional[List[str]] = None, kwd_patterns: Optional[List[PatternTypes]] = None) → None

class astroid.nodes.MatchMapping(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing a ast.MatchMapping node.

get_children() → Generator[astroid.node_classes.NodeNG, None, None]

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

keys = None

patterns = None

postinit(*, keys=None, patterns: Optional[List[PatternTypes]] = None, rest: Optional[str] = None) → None

rest = None

class astroid.nodes.MatchOr(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing a ast.MatchOr node.

get_children() → Generator[Union[astroid.node_classes.MatchValue, astroid.node_classes.MatchSingleton, astroid.node_classes.MatchSequence, astroid.node_classes.MatchMapping, astroid.node_classes.MatchClass, astroid.node_classes.MatchStar, astroid.node_classes.MatchAs, astroid.node_classes.MatchOr], None, None]

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

patterns = None

postinit(*, patterns: Optional[List[PatternTypes]]) → None

class astroid.nodes.MatchSequence(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing a ast.MatchSequence node.

get_children() → Generator[Union[astroid.node_classes.MatchValue, astroid.node_classes.MatchSingleton, astroid.node_classes.MatchSequence, astroid.node_classes.MatchMapping, astroid.node_classes.MatchClass, astroid.node_classes.MatchStar, astroid.node_classes.MatchAs, astroid.node_classes.MatchOr], None, None]

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

patterns = None

postinit(*, patterns: Optional[List[PatternTypes]]) → None

class astroid.nodes.MatchSingleton(lineno: int, col_offset: int, parent: astroid.node_classes.NodeNG, *, value: typing_extensions.Literal[True, False, None][True, False, None])

Bases: astroid.node_classes.NodeNG

Class representing a ast.MatchSingleton node.

class astroid.nodes.MatchStar(lineno: int, col_offset: int, parent: astroid.node_classes.NodeNG, *, name: Optional[str])

Bases: astroid.node_classes.NodeNG

Class representing a ast.MatchStar node.

name = None

class astroid.nodes.MatchValue(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing a ast.MatchValue node.

get_children() → Generator[astroid.node_classes.NodeNG, None, None]

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(*, value: astroid.node_classes.NodeNG) → None

value = None

class astroid.nodes.Module(name, doc, file=None, path: Optional[List[str]] = None, package=None, parent=None, pure_python=True)

Bases: astroid.scoped_nodes.LocalsDictNodeNG

Class representing an ast.Module node.

>>> node = astroid.extract_node('import astroid')
>>> node
<Import l.1 at 0x7f23b2e4e5c0>
>>> node.parent
<Module l.0 at 0x7f23b2e4eda0>

absolute_import_activated()

Whether PEP 328 absolute import behaviour has been enabled.

Returns:True if PEP 328 has been enabled, False otherwise. Return type:bool

block_range(lineno)

Get a range from where this node starts to where this node ends.

Parameters:lineno (int) – Unused. Returns:The range of line numbers that this node belongs to. Return type:tuple(int, int)

body = None

The contents of the module.

Type:list(NodeNG) or None

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. For a Module this is always True. Return type:bool

display_type()

A human readable type of this node.

Returns:The type of this node. Return type:str

file = None

The path to the file that this ast has been extracted from.

This will be None when the representation has been built from a built-in module.

Type:str or None

file_bytes = None

The string/bytes that this ast was built from.

Type:str or bytes or None

file_encoding = None

The encoding of the source file.

This is used to get unicode out of a source file. Python 2 only.

Type:str or None

fromlineno = 0

The first line that this node appears on in the source code.

Type:int or None

fully_defined()

Check if this module has been build from a .py file.

If so, the module contains a complete representation, including the code.

Returns:True if the module has been built from a .py file. Return type:bool

future_imports = None

The imports from __future__.

Type:set(str) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

getattr(name, context=None, ignore_locals=False)

globals = None

A map of the name of a global variable to the node defining the global.

Type:dict(str, NodeNG)

igetattr(name, context=None)

Infer the possible values of the given variable.

Parameters:name (str) – The name of the variable to infer. Returns:The inferred possible values. Return type:iterable(NodeNG) or None

import_module(modname, relative_only=False, level=None)

Get the ast for a given module as if imported from this module.

Parameters:

• modname (str) – The name of the module to “import”.
• relative_only (bool) – Whether to only consider relative imports.
• level (int or None) – The level of relative import.

Returns:

The imported module ast.

Return type:

NodeNG

lineno = 0

The line that this node appears on in the source code.

Type:int or None

name = None

The name of the module.

Type:str or None

next_sibling()

The next sibling statement node.

Returns:The next sibling statement node. Return type:NodeNG or None

package = None

Whether the node represents a package or a module.

Type:bool or None

postinit(body=None)

Do some setup after initialisation.

Parameters:body (list(NodeNG) or None) – The contents of the module.

previous_sibling()

The previous sibling statement.

Returns:The previous sibling statement node. Return type:NodeNG or None

public_names()

The list of the names that are publicly available in this module.

Returns:The list of publc names. Return type:list(str)

pure_python = None

Whether the ast was built from source.

Type:bool or None

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

relative_to_absolute_name(modname, level)

Get the absolute module name for a relative import.

The relative import can be implicit or explicit.

Parameters:

• modname (str) – The module name to convert.
• level (int) – The level of relative import.

Returns:

The absolute module name.

Return type:

str

Raises:

TooManyLevelsError – When the relative import refers to a module too far above this one.

scope_attrs = {'__doc__', '__file__', '__name__', '__package__', '__path__'}

The names of module attributes available through the global scope.

Type:str(str)

scope_lookup(node, name, offset=0)

Lookup where the given variable is assigned.

Parameters:

• node (NodeNG) – The node to look for assignments up to. Any assignments after the given node are ignored.
• name (str) – The name of the variable to find assignments for.
• offset (int) – The line offset to filter statements up to.

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).

Return type:

tuple(str, list(NodeNG))

special_attributes

The names of special attributes that this module has.

Type:objectmodel.ModuleModel

statement()

The first parent node, including self, marked as statement node.

Returns:The first parent statement. Return type:NodeNG

stream()

Get a stream to the underlying file or bytes.

Type:file or io.BytesIO or None

wildcard_import_names()

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. Return type:list(str)

class astroid.nodes.Name(name=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.LookupMixIn, astroid.node_classes.NodeNG

Class representing an ast.Name node.

A Name node is something that is named, but not covered by AssignName or DelName.

>>> node = astroid.extract_node('range(10)')
>>> node
<Call l.1 at 0x7effe1db8710>
>>> list(node.get_children())
[<Name.range l.1 at 0x7effe1db86a0>, <Const.int l.1 at 0x7effe1db8518>]
>>> list(node.get_children())[0].as_string()
'range'

name = None

The name that this node refers to.

Type:str or None

class astroid.nodes.Nonlocal(names, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.Statement

Class representing an ast.Nonlocal node.

>>> node = astroid.extract_node('''
def function():
    nonlocal var
''')
>>> node
<FunctionDef.function l.2 at 0x7f23b2e9e208>
>>> node.body[0]
<Nonlocal l.3 at 0x7f23b2e9e908>

names = None

The names being declared as not local.

Type:list(str)

class astroid.nodes.Pass(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.NoChildrenMixin, astroid.node_classes.Statement

Class representing an ast.Pass node.

>>> node = astroid.extract_node('pass')
>>> node
<Pass l.1 at 0x7f23b2e9e748>

class astroid.nodes.Print(nl=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.Statement

Class representing an ast.Print node.

>>> node = astroid.extract_node('print "A message"')
>>> node
<Print l.1 at 0x7f0e8101d290>

dest = None

Where to print to.

Type:NodeNG or None

nl = None

Whether to print a new line.

Type:bool or None

postinit(dest=None, values=None)

Do some setup after initialisation.

Parameters:

• dest (NodeNG or None) – Where to print to.
• values (list(NodeNG) or None) – What to print.

values = None

What to print.

Type:list(NodeNG) or None

class astroid.nodes.Raise(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.Statement

Class representing an ast.Raise node.

>>> node = astroid.extract_node('raise RuntimeError("Something bad happened!")')
>>> node
<Raise l.1 at 0x7f23b2e9e828>

cause = None

The exception being used to raise this one.

Type:NodeNG or None

exc = None

What is being raised.

Type:NodeNG or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(exc=None, cause=None)

Do some setup after initialisation.

Parameters:

• exc (NodeNG or None) – What is being raised.
• cause (NodeNG or None) – The exception being used to raise this one.

raises_not_implemented()

Check if this node raises a NotImplementedError.

Returns:True if this node raises a NotImplementedError, False otherwise. Return type:bool

class astroid.nodes.Repr(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Repr node.

A Repr node represents the backtick syntax, which is a deprecated alias for repr() removed in Python 3.

>>> node = astroid.extract_node('`variable`')
>>> node
<Repr l.1 at 0x7fa0951d75d0>

postinit(value=None)

Do some setup after initialisation.

Parameters:value (NodeNG or None) – What is having repr() called on it.

value = None

What is having repr() called on it.

Type:NodeNG or None

class astroid.nodes.Return(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.Statement

Class representing an ast.Return node.

>>> node = astroid.extract_node('return True')
>>> node
<Return l.1 at 0x7f23b8211908>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

is_tuple_return()

postinit(value=None)

Do some setup after initialisation.

Parameters:value (NodeNG or None) – The value being returned.

value = None

The value being returned.

Type:NodeNG or None

class astroid.nodes.Set(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes._BaseContainer

Class representing an ast.Set node.

>>> node = astroid.extract_node('{1, 2, 3}')
>>> node
<Set.set l.1 at 0x7f23b2e71d68>

infer_unary_op(op)

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

class astroid.nodes.SetComp(lineno=None, col_offset=None, parent=None)

Bases: astroid.scoped_nodes.ComprehensionScope

Class representing an ast.SetComp node.

>>> node = astroid.extract_node('{thing for thing in things if thing}')
>>> node
<SetComp l.1 at 0x7f23b2e41898>

bool_value(context=None)

Determine the boolean value of this node.

Returns:The boolean value of this node. For a SetComp this is always Uninferable. Return type:Uninferable

elt = None

The element that forms the output of the expression.

Type:NodeNG or None

generators = None

The generators that are looped through.

Type:list(Comprehension) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(elt=None, generators=None)

Do some setup after initialisation.

Parameters:

• elt (NodeNG or None) – The element that forms the output of the expression.
• generators (list(Comprehension) or None) – The generators that are looped through.

class astroid.nodes.Slice(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Slice node.

>>> node = astroid.extract_node('things[1:3]')
>>> node
<Subscript l.1 at 0x7f23b2e71f60>
>>> node.slice
<Slice l.1 at 0x7f23b2e71e80>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

getattr(attrname, context=None)

igetattr(attrname, context=None)

Infer the possible values of the given attribute on the slice.

Parameters:attrname (str) – The name of the attribute to infer. Returns:The inferred possible values. Return type:iterable(NodeNG)

lower = None

The lower index in the slice.

Type:NodeNG or None

postinit(lower=None, upper=None, step=None)

Do some setup after initialisation.

Parameters:

• lower – The lower index in the slice.
• upper – The upper index in the slice.
• step – The step to take between index.
• step – NodeNG or None

Value lower:

NodeNG or None

Value upper:

NodeNG or None

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

step = None

The step to take between indexes.

Type:NodeNG or None

upper = None

The upper index in the slice.

Type:NodeNG or None

class astroid.nodes.Starred(ctx=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.ParentAssignTypeMixin, astroid.node_classes.NodeNG

Class representing an ast.Starred node.

>>> node = astroid.extract_node('*args')
>>> node
<Starred l.1 at 0x7f23b2e41978>

assigned_stmts(node=None, context=None, assign_path=None)

Parameters:

• self – nodes.Starred
• node – a node related to the current underlying Node.
• context – Inference context used for caching already inferred objects
• assign_path – A list of indices, where each index specifies what item to fetch from the inference results.

ctx = None

Whether the starred item is assigned to or loaded from.

Type:Context or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(value=None)

Do some setup after initialisation.

Parameters:value (NodeNG or None) – What is being unpacked.

value = None

What is being unpacked.

Type:NodeNG or None

class astroid.nodes.Subscript(ctx=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Subscript node.

>>> node = astroid.extract_node('things[1:3]')
>>> node
<Subscript l.1 at 0x7f23b2e71f60>

ctx = None

Whether the subscripted item is assigned to or loaded from.

Type:Context or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

infer_lhs(context=None)

Inference for subscripts

We’re understanding if the index is a Const or a slice, passing the result of inference to the value’s getitem method, which should handle each supported index type accordingly.

postinit(value=None, slice=None)

Do some setup after initialisation.

Parameters:

• value (NodeNG or None) – What is being indexed.
• slice (NodeNG or None) – The slice being used to lookup.

slice = None

The slice being used to lookup.

Type:NodeNG or None

value = None

What is being indexed.

Type:NodeNG or None

class astroid.nodes.TryExcept(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.MultiLineBlockMixin, astroid.mixins.BlockRangeMixIn, astroid.node_classes.Statement

Class representing an ast.TryExcept node.

>>> node = astroid.extract_node('''
    try:
        do_something()
    except Exception as error:
        print("Error!")
    ''')
>>> node
<TryExcept l.2 at 0x7f23b2e9d908>

block_range(lineno)

Get a range from the given line number to where this node ends.

Parameters:lineno (int) – The line number to start the range at. Returns:The range of line numbers that this node belongs to, starting at the given line number. Return type:tuple(int, int)

body = None

The contents of the block to catch exceptions from.

Type:list(NodeNG) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

handlers = None

The exception handlers.

Type:list(ExceptHandler) or None

orelse = None

The contents of the else block.

Type:list(NodeNG) or None

postinit(body=None, handlers=None, orelse=None)

Do some setup after initialisation.

Parameters:

• body (list(NodeNG) or None) – The contents of the block to catch exceptions from.
• handlers (list(ExceptHandler) or None) – The exception handlers.
• orelse (list(NodeNG) or None) – The contents of the else block.

class astroid.nodes.TryFinally(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.MultiLineBlockMixin, astroid.mixins.BlockRangeMixIn, astroid.node_classes.Statement

Class representing an ast.TryFinally node.

>>> node = astroid.extract_node('''
try:
    do_something()
except Exception as error:
    print("Error!")
finally:
    print("Cleanup!")
''')
>>> node
<TryFinally l.2 at 0x7f23b2e41d68>

block_range(lineno)

Get a range from the given line number to where this node ends.

Parameters:lineno (int) – The line number to start the range at. Returns:The range of line numbers that this node belongs to, starting at the given line number. Return type:tuple(int, int)

body = None

The try-except that the finally is attached to.

Type:list(TryExcept) or None

finalbody = None

The contents of the finally block.

Type:list(NodeNG) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(body=None, finalbody=None)

Do some setup after initialisation.

Parameters:

• body (list(TryExcept) or None) – The try-except that the finally is attached to.
• finalbody (list(NodeNG) or None) – The contents of the finally block.

class astroid.nodes.Tuple(ctx=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes._BaseContainer

Class representing an ast.Tuple node.

>>> node = astroid.extract_node('(1, 2, 3)')
>>> node
<Tuple.tuple l.1 at 0x7f23b2e41780>

assigned_stmts(node=None, context=None, assign_path=None)

ctx = None

Whether the tuple is assigned to or loaded from.

Type:Context or None

getitem(index, context=None)

Get an item from this node.

Parameters:index (Const or Slice) – The node to use as a subscript index.

infer_binary_op(opnode, operator, other, context, method)

infer_unary_op(op)

pytype()

Get the name of the type that this node represents.

Returns:The name of the type. Return type:str

class astroid.nodes.UnaryOp(op=None, lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.UnaryOp node.

>>> node = astroid.extract_node('-5')
>>> node
<UnaryOp l.1 at 0x7f23b2e4e198>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

op = None

The operator.

Type:str or None

op_precedence()

operand = None

What the unary operator is applied to.

Type:NodeNG or None

postinit(operand=None)

Do some setup after initialisation.

Parameters:operand (NodeNG or None) – What the unary operator is applied to.

type_errors(context=None)

Get a list of type errors which can occur during inference.

Each TypeError is represented by a BadBinaryOperationMessage, which holds the original exception.

Returns:The list of possible type errors. Return type:list(BadBinaryOperationMessage)

class astroid.nodes.Unknown(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.AssignTypeMixin, astroid.node_classes.NodeNG

This 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.

infer(context=None, **kwargs)

Inference on an Unknown node immediately terminates.

name = 'Unknown'

qname()

class astroid.nodes.While(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.MultiLineBlockMixin, astroid.mixins.BlockRangeMixIn, astroid.node_classes.Statement

Class representing an ast.While node.

>>> node = astroid.extract_node('''
while condition():
    print("True")
''')
>>> node
<While l.2 at 0x7f23b2e4e390>

block_range(lineno)

Get a range from the given line number to where this node ends.

Parameters:lineno (int) – The line number to start the range at. Returns:The range of line numbers that this node belongs to, starting at the given line number. Return type:tuple(int, int)

blockstart_tolineno

<wrapped by the cachedproperty decorator> The line on which the beginning of this block ends.

type:int

body = None

The contents of the loop.

Type:list(NodeNG) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

orelse = None

The contents of the else block.

Type:list(NodeNG) or None

postinit(test=None, body=None, orelse=None)

Do some setup after initialisation.

Parameters:

• test (NodeNG or None) – The condition that the loop tests.
• body (list(NodeNG) or None) – The contents of the loop.
• orelse (list(NodeNG) or None) – The contents of the else block.

test = None

The condition that the loop tests.

Type:NodeNG or None

class astroid.nodes.With(lineno=None, col_offset=None, parent=None)

Bases: astroid.mixins.MultiLineBlockMixin, astroid.mixins.BlockRangeMixIn, astroid.mixins.AssignTypeMixin, astroid.node_classes.Statement

Class representing an ast.With node.

>>> node = astroid.extract_node('''
with open(file_path) as file_:
    print(file_.read())
''')
>>> node
<With l.2 at 0x7f23b2e4e710>

assigned_stmts(node=None, context=None, assign_path=None)

Infer names and other nodes from a with statement.

This enables only inference for name binding in a with statement. For instance, in the following code, inferring func will return the ContextManager class, not whatever __enter__ returns. We are doing this intentionally, because we consider that the context manager result is whatever __enter__ returns and what it is binded using the as keyword.

class ContextManager(object):

def __enter__(self):

return 42

with ContextManager() as f:

pass

# ContextManager().infer() will return ContextManager # f.infer() will return 42.

Parameters:

• self – nodes.With
• node – The target of the assignment, as (a, b) in with foo as (a, b).
• context – Inference context used for caching already inferred objects
• assign_path – A list of indices, where each index specifies what item to fetch from the inference results.

blockstart_tolineno

<wrapped by the cachedproperty decorator> The line on which the beginning of this block ends.

type:int

body = None

The contents of the with block.

Type:list(NodeNG) or None

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

items = None

The pairs of context managers and the names they are assigned to.

Type:list(tuple(NodeNG, AssignName or None)) or None

postinit(items=None, body=None, type_annotation=None)

Do some setup after initialisation.

Parameters:

• items (list(tuple(NodeNG, AssignName or None)) or None) – The pairs of context managers and the names they are assigned to.
• body (list(NodeNG) or None) – The contents of the with block.

type_annotation = None

If present, this will contain the type annotation passed by a type comment

Type:NodeNG or None

class astroid.nodes.Yield(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.NodeNG

Class representing an ast.Yield node.

>>> node = astroid.extract_node('yield True')
>>> node
<Yield l.1 at 0x7f23b2e4e5f8>

get_children()

Get the child nodes below this node.

Returns:The children. Return type:iterable(NodeNG)

postinit(value=None)

Do some setup after initialisation.

Parameters:value (NodeNG or None) – The value to yield.

value = None

The value to yield.

Type:NodeNG or None

class astroid.nodes.YieldFrom(lineno=None, col_offset=None, parent=None)

Bases: astroid.node_classes.Yield

Class representing an ast.YieldFrom node.