ClassDef¶

class astroid.nodes.ClassDef(name: str, lineno: int, col_offset: int, parent: NodeNG, *, end_lineno: int | None, end_col_offset: int | None)[source]¶

Bases: FilterStmtsBaseNode, LocalsDictNodeNG, Statement

Class representing an ast.ClassDef node.

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

ancestors(recurs: bool = True, context: InferenceContext | None = None) → Generator[ClassDef][source]¶

Iterate over the base classes in prefixed depth first order.

Parameters:: recurs – Whether to recurse or return direct ancestors only.
Returns:: The base classes

property basenames¶

The names of the parent classes

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

Type:: list(str)

bases: list[SuccessfulInferenceResult]¶: What the class inherits from.

block_range(lineno: int) → tuple[int, int][source]¶

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

Parameters:: lineno – Unused.
Returns:: The range of line numbers that this node belongs to,

property blockstart_tolineno¶

The line on which the beginning of this block ends.

Type:: int

body: list[NodeNG]¶: The contents of the class body.

bool_value(context: InferenceContext | None = None) → Literal[True][source]¶

Determine the boolean value of this node.

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

callable() → bool[source]¶

Whether this node defines something that is callable.

Returns:: Whether this defines something that is callable. For a ClassDef this is always True.

declared_metaclass(context: InferenceContext | None = None) → SuccessfulInferenceResult | None[source]¶

Return the explicit declared metaclass for the current class.

An explicit declared metaclass is defined by passing the metaclass keyword argument in the class definition line.

Returns:: The metaclass of this class, or None if one could not be found.

decorators = None¶: The decorators that are applied to this class.

display_type() → str[source]¶

A human readable type of this node.

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

doc_node: Const | None¶: The doc node associated with this node.

frame(*, future: Literal[None, True] = None) → Self[source]¶

The node’s frame node.

A frame node is a Module, FunctionDef, ClassDef or Lambda.

Returns:: The node itself.

get_children()[source]¶: Get the child nodes below this node.

getattr(name: str, context: InferenceContext | None = None, class_context: bool = True) → list[InferenceResult][source]¶

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 – The attribute to look for.
class_context – Whether the attribute can be accessed statically.

Returns:

The attribute.

Raises:

AttributeInferenceError – If the attribute cannot be inferred.

getitem(index, context: InferenceContext | None = None)[source]¶

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) → bool[source]¶

Whether this class directly inherits from the given node.

Parameters:: node (NodeNG) – The node to check for.
Returns:: Whether this class directly inherits from the given node.

has_dynamic_getattr(context: InferenceContext | None = None) → bool[source]¶

Check if the class has a custom __getattr__ or __getattribute__.

If any such method is found and it is not from builtins, nor from an extension module, then the function will return True.

Returns:: Whether the class has a custom __getattr__ or __getattribute__.

has_metaclass_hack() → bool[source]¶

hide = False¶

igetattr(name: str, context: InferenceContext | None = None, class_context: bool = True) → Iterator[InferenceResult][source]¶

Infer the possible values of the given variable.

Parameters:: name – The name of the variable to infer.
Returns:: The inferred possible values.

implicit_locals()[source]¶

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()[source]¶

Get the implicit metaclass of the current class.

This will return an instance of builtins.type.

Returns:: The metaclass.
Return type:: builtins.type

implicit_parameters() → Literal[1][source]¶

infer_binary_op(**kwargs: _P.kwargs) → Generator[InferenceResult]¶

infer_call_result(caller: SuccessfulInferenceResult | None, context: InferenceContext | None = None) → Iterator[InferenceResult][source]¶: infer what a class is returning when called

instance_attr(name, context: InferenceContext | None = None)[source]¶

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: InferenceContext | None = None)[source]¶

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() → Instance[source]¶

Get an Instance of the ClassDef node.

Returns:: An Instance of the ClassDef node

is_dataclass: bool¶: Whether this class is a dataclass.

is_subtype_of(type_name, context: InferenceContext | None = None) → bool[source]¶

Whether this class is a subtype of the given type.

Parameters:: type_name (str) – The name of the type of check against.
Returns:: Whether this class is a subtype of the given type.

keywords: list[node_classes.Keyword]¶

The keywords given to the class definition.

This is usually for PEP 3115 style metaclass declaration.

local_attr(name, context: InferenceContext | None = None)[source]¶

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: InferenceContext | None = None)[source]¶

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)

locals: dict[str, list[InferenceResult]]¶: A map of the name of a local variable to the node defining it.

metaclass(context: InferenceContext | None = None) → SuccessfulInferenceResult | None[source]¶

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.

methods()[source]¶

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: InferenceContext | None = None) → list[ClassDef][source]¶

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()[source]¶

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

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

name¶: The name of the class.

postinit(bases: list[SuccessfulInferenceResult], body: list[NodeNG], decorators: node_classes.Decorators | None, newstyle: bool | None = None, metaclass: NodeNG | None = None, keywords: list[node_classes.Keyword] | None = None, *, position: Position | None = None, doc_node: Const | None = None, type_params: list[nodes.TypeVar | nodes.ParamSpec | nodes.TypeVarTuple] | None = None) → None[source]¶

pytype() → Literal['builtins.type'][source]¶

Get the name of the type that this node represents.

Returns:: The name of the type.

scope_lookup(node: LookupMixIn, name: str, offset: int = 0) → tuple[LocalsDictNodeNG, list[nodes.NodeNG]][source]¶

Lookup where the given name is assigned.

Parameters:

node – The node to look for assignments up to. Any assignments after the given node are ignored.
name – The name to find assignments for.
offset – 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).

slots()[source]¶

special_attributes¶

The names of special attributes that this class has.

Type:: objectmodel.ClassModel

property type: Literal['class', 'exception', 'metaclass']¶

The class type for this node.

Possible values are: class, metaclass, exception.

Type:: str

type_params: list[nodes.TypeVar | nodes.ParamSpec | nodes.TypeVarTuple]¶

…

Type:: PEP 695 (Python 3.12+) type params, e.g. class MyClass[T]