astroid.inference

module documentation
(source)

This module contains a set of functions to handle inference on astroid trees.

Function infer_arguments Undocumented
Function infer_assign Infer a AssignName/AssignAttr: need to inspect the RHS part of the assign node.
Function infer_attribute Infer an Attribute node by using getattr on the associated object.
Function infer_augassign Undocumented
Function infer_binop Undocumented
Function infer_call Infer a Call node by trying to guess what the function returns.
Function infer_empty_node Undocumented
Function infer_end Inference's end for nodes that yield themselves on inference.
Function infer_functiondef Undocumented
Function infer_global Undocumented
Function infer_ifexp Support IfExp inference.
Function infer_import Infer an Import node: return the imported module/object.
Function infer_import_from Infer a ImportFrom node: return the imported module/object.
Function infer_map Undocumented
Function infer_name Infer a Name: use name lookup rules.
Function infer_sequence Undocumented
Function infer_subscript Inference for subscripts.
Function infer_unaryop Infer what an UnaryOp should return when evaluated.
Constant COMPARE_OPS Undocumented
Constant UNINFERABLE_OPS Undocumented
Type Alias GetFlowFactory Undocumented
Variable objects Undocumented
Function _aug_op Get an inference callable for an augmented binary operation.
Function _bin_op Get an inference callable for a normal binary operation.
Function _bin_op_or_union_type Create a new UnionType instance for binary or, e.g. int | str.
Function _do_compare If all possible combinations are either True or False, return that: >>> _do_compare([1, 2], '<=', [3, 4]) True >>> _do_compare([1, 2], '==', [3, 4]) False
Function _filter_operation_errors Undocumented
Function _get_aug_flow Get the flow for augmented binary operations.
Function _get_binop_contexts Get contexts for binary operations.
Function _get_binop_flow Get the flow for binary operations.
Function _higher_function_scope Search for the first function which encloses the given scope. This can be used for looking up in that function's scope, in case looking up in a lower scope for a particular name fails.
Function _infer_augassign Inference logic for augmented binary operations.
Function _infer_binary_operation Infer a binary operation between a left operand and a right operand.
Function _infer_binop Binary operation inference logic.
Function _infer_boolop Infer a boolean operation (and / or / not).
Function _infer_compare Chained comparison inference logic.
Function _infer_map Infer all values based on Dict.items.
Function _infer_old_style_string_formatting Infer the result of '"string" % ...'.
Function _infer_sequence_helper Infer all values based on _BaseContainer.elts.
Function _infer_unaryop Infer what an UnaryOp should return when evaluated.
Function _invoke_binop_inference Invoke binary operation inference on the given instance.
Function _is_not_implemented Check if the given const node is NotImplemented.
Function _populate_context_lookup Undocumented
Function _same_type Check if type1 is the same as type2.
Function _to_literal Undocumented
Function _update_with_replacement Delete nodes that equate to duplicate keys.
Constant _SUBSCRIPT_SENTINEL Undocumented
Type Variable _BaseContainerT Undocumented
Type Variable _FunctionDefT Undocumented
Type Variable _T Undocumented
@decorators.raise_if_nothing_inferred
def infer_arguments(self: nodes.Arguments, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Undocumented

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def infer_assign(self: nodes.AssignName|nodes.AssignAttr, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Infer a AssignName/AssignAttr: need to inspect the RHS part of the assign node.

def infer_attribute(self: nodes.Attribute|nodes.AssignAttr, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, InferenceErrorInfo]: (source)

Infer an Attribute node by using getattr on the associated object.

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def infer_augassign(self: nodes.AugAssign, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Undocumented

@decorators.yes_if_nothing_inferred
@decorators.path_wrapper
def infer_binop(self: nodes.BinOp, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Undocumented

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def infer_call(self: nodes.Call, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, InferenceErrorInfo]: (source)

Infer a Call node by trying to guess what the function returns.

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def infer_empty_node(self: nodes.EmptyNode, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Undocumented

def infer_end(self: _T, context: InferenceContext|None = None, **kwargs: Any) -> Iterator[_T]: (source)

Inference's end for nodes that yield themselves on inference. These are objects for which inference does not have any semantic, such as Module or Consts.

def infer_functiondef(self: _FunctionDefT, context: InferenceContext|None = None, **kwargs: Any) -> Generator[Property|_FunctionDefT, None, InferenceErrorInfo]: (source)

Undocumented

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def infer_global(self: nodes.Global, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Undocumented

@decorators.raise_if_nothing_inferred
def infer_ifexp(self: nodes.IfExp, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Support IfExp inference. If we can't infer the truthiness of the condition, we default to inferring both branches. Otherwise, we infer either branch depending on the condition.

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def infer_import(self: nodes.Import, context: InferenceContext|None = None, asname: bool = True, **kwargs: Any) -> Generator[nodes.Module, None, None]: (source)

Infer an Import node: return the imported module/object.

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def infer_import_from(self: nodes.ImportFrom, context: InferenceContext|None = None, asname: bool = True, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Infer a ImportFrom node: return the imported module/object.

def infer_map(self: nodes.Dict, context: InferenceContext|None = None) -> Iterator[nodes.Dict]: (source)

Undocumented

def infer_name(self: nodes.Name|nodes.AssignName, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, None]: (source)

Infer a Name: use name lookup rules.

@decorators.raise_if_nothing_inferred
def infer_sequence(self: _BaseContainerT, context: InferenceContext|None = None, **kwargs: Any) -> Iterator[_BaseContainerT]: (source)

Undocumented

def infer_subscript(self: nodes.Subscript, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, InferenceErrorInfo|None]: (source)

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.

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def infer_unaryop(self: nodes.UnaryOp, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, InferenceErrorInfo]: (source)

Infer what an UnaryOp should return when evaluated.

COMPARE_OPS: dict[str, Callable[[Any, Any], bool]] = (source)

Undocumented

Value
{'==': operator.eq,
 '!=': operator.ne,
 '<': operator.lt,
 '<=': operator.le,
 '>': operator.gt,
 '>=': operator.ge,
 'in': (lambda a, b: a in b),
...
UNINFERABLE_OPS: set[str] = (source)

Undocumented

Value
set(['is', 'is not'])
GetFlowFactory = (source)

Undocumented

Value
typing.Callable[[InferenceResult,
                 Optional[InferenceResult],
                 Union[nodes.AugAssign, nodes.BinOp],
                 InferenceResult,
                 Optional[InferenceResult],
                 InferenceContext,
                 InferenceContext],
...
objects = (source)

Undocumented

def _aug_op(instance: InferenceResult, opnode: nodes.AugAssign, op: str, other: InferenceResult, context: InferenceContext, reverse: bool = False) -> functools.partial[Generator[InferenceResult, None, None]]: (source)

Get an inference callable for an augmented binary operation.

def _bin_op(instance: InferenceResult, opnode: nodes.AugAssign|nodes.BinOp, op: str, other: InferenceResult, context: InferenceContext, reverse: bool = False) -> functools.partial[Generator[InferenceResult, None, None]]: (source)

Get an inference callable for a normal binary operation. If *reverse* is True, then the reflected method will be used instead.

def _bin_op_or_union_type(left: (bases.UnionType|nodes.ClassDef)|nodes.Const, right: (bases.UnionType|nodes.ClassDef)|nodes.Const) -> Generator[InferenceResult, None, None]: (source)

Create a new UnionType instance for binary or, e.g. int | str.

def _do_compare(left_iter: Iterable[nodes.NodeNG], op: str, right_iter: Iterable[nodes.NodeNG]) -> bool|util.UninferableBase: (source)

If all possible combinations are either True or False, return that: >>> _do_compare([1, 2], '<=', [3, 4]) True >>> _do_compare([1, 2], '==', [3, 4]) False If any item is uninferable, or if some combinations are True and some are False, return Uninferable: >>> _do_compare([1, 3], '<=', [2, 4]) util.Uninferable

def _filter_operation_errors(self: _T, infer_callable: Callable[[_T, InferenceContext|None], Generator[InferenceResult|util.BadOperationMessage, None, None]], context: InferenceContext|None, error: type[util.BadOperationMessage]) -> Generator[InferenceResult, None, None]: (source)

Undocumented

def _get_aug_flow(left: InferenceResult, left_type: InferenceResult|None, aug_opnode: nodes.AugAssign, right: InferenceResult, right_type: InferenceResult|None, context: InferenceContext, reverse_context: InferenceContext) -> list[functools.partial[Generator[InferenceResult, None, None]]]: (source)

Get the flow for augmented binary operations. The rules are a bit messy: * if left and right have the same type, then left.__augop__(right) is first tried and then left.__op__(right). * if left and right are unrelated typewise, then left.__augop__(right) is tried, then left.__op__(right) is tried and then right.__rop__(left) is tried. * if left is a subtype of right, then left.__augop__(right) is tried and then left.__op__(right). * if left is a supertype of right, then left.__augop__(right) is tried, then right.__rop__(left) and then left.__op__(right)

def _get_binop_contexts(context, left, right): (source)

Get contexts for binary operations. This will return two inference contexts, the first one for x.__op__(y), the other one for y.__rop__(x), where only the arguments are inversed.

def _get_binop_flow(left: InferenceResult, left_type: InferenceResult|None, binary_opnode: nodes.AugAssign|nodes.BinOp, right: InferenceResult, right_type: InferenceResult|None, context: InferenceContext, reverse_context: InferenceContext) -> list[functools.partial[Generator[InferenceResult, None, None]]]: (source)

Get the flow for binary operations. The rules are a bit messy: * if left and right have the same type, then only one method will be called, left.__op__(right) * if left and right are unrelated typewise, then first left.__op__(right) is tried and if this does not exist or returns NotImplemented, then right.__rop__(left) is tried. * if left is a subtype of right, then only left.__op__(right) is tried. * if left is a supertype of right, then right.__rop__(left) is first tried and then left.__op__(right)

def _higher_function_scope(node: nodes.NodeNG) -> nodes.FunctionDef|None: (source)

Search for the first function which encloses the given scope. This can be used for looking up in that function's scope, in case looking up in a lower scope for a particular name fails. :param node: A scope node. :returns: ``None``, if no parent function scope was found, otherwise an instance of :class:`astroid.nodes.scoped_nodes.Function`, which encloses the given node.

def _infer_augassign(self: nodes.AugAssign, context: InferenceContext|None = None) -> Generator[InferenceResult|util.BadBinaryOperationMessage, None, None]: (source)

Inference logic for augmented binary operations.

def _infer_binary_operation(left: InferenceResult, right: InferenceResult, binary_opnode: nodes.AugAssign|nodes.BinOp, context: InferenceContext, flow_factory: GetFlowFactory) -> Generator[InferenceResult|util.BadBinaryOperationMessage, None, None]: (source)

Infer a binary operation between a left operand and a right operand. This is used by both normal binary operations and augmented binary operations, the only difference is the flow factory used.

def _infer_binop(self: nodes.BinOp, context: InferenceContext|None = None) -> Generator[InferenceResult|util.BadBinaryOperationMessage, None, None]: (source)

Binary operation inference logic.

@decorators.raise_if_nothing_inferred
@decorators.path_wrapper
def _infer_boolop(self: nodes.BoolOp, context: InferenceContext|None = None, **kwargs: Any) -> Generator[InferenceResult, None, InferenceErrorInfo|None]: (source)

Infer a boolean operation (and / or / not). The function will calculate the boolean operation for all pairs generated through inference for each component node.

def _infer_compare(self: nodes.Compare, context: InferenceContext|None = None, **kwargs: Any) -> Generator[nodes.Const|util.UninferableBase, None, None]: (source)

Chained comparison inference logic.

def _infer_map(node: nodes.Dict, context: InferenceContext|None) -> dict[SuccessfulInferenceResult, SuccessfulInferenceResult]: (source)

Infer all values based on Dict.items.

def _infer_old_style_string_formatting(instance: nodes.Const, other: nodes.NodeNG, context: InferenceContext) -> tuple[util.UninferableBase|nodes.Const]: (source)

Infer the result of '"string" % ...'. TODO: Instead of returning Uninferable we should rely on the call to '%' to see if the result is actually uninferable.

def _infer_sequence_helper(node: _BaseContainerT, context: InferenceContext|None = None) -> list[SuccessfulInferenceResult]: (source)

Infer all values based on _BaseContainer.elts.

def _infer_unaryop(self: nodes.UnaryOp, context: InferenceContext|None = None) -> Generator[InferenceResult|util.BadUnaryOperationMessage, None, None]: (source)

Infer what an UnaryOp should return when evaluated.

def _invoke_binop_inference(instance: InferenceResult, opnode: nodes.AugAssign|nodes.BinOp, op: str, other: InferenceResult, context: InferenceContext, method_name: str) -> Generator[InferenceResult, None, None]: (source)

Invoke binary operation inference on the given instance.

def _is_not_implemented(const) -> bool: (source)

Check if the given const node is NotImplemented.

def _populate_context_lookup(call: nodes.Call, context: InferenceContext|None): (source)

Undocumented

def _same_type(type1, type2) -> bool: (source)

Check if type1 is the same as type2.

def _to_literal(node: nodes.NodeNG) -> Any: (source)

Undocumented

def _update_with_replacement(lhs_dict: dict[SuccessfulInferenceResult, SuccessfulInferenceResult], rhs_dict: dict[SuccessfulInferenceResult, SuccessfulInferenceResult]) -> dict[SuccessfulInferenceResult, SuccessfulInferenceResult]: (source)

Delete nodes that equate to duplicate keys. Since an astroid node doesn't 'equal' another node with the same value, this function uses the as_string method to make sure duplicate keys don't get through Note that both the key and the value are astroid nodes Fixes issue with DictUnpack causing duplicate keys in inferred Dict items :param lhs_dict: Dictionary to 'merge' nodes into :param rhs_dict: Dictionary with nodes to pull from :return : merged dictionary of nodes

_SUBSCRIPT_SENTINEL = (source)

Undocumented

Value
object()
_BaseContainerT = (source)

Undocumented

Value
TypeVar('_BaseContainerT',
        bound=nodes.BaseContainer)
_FunctionDefT = (source)

Undocumented

Value
TypeVar('_FunctionDefT',
        bound=nodes.FunctionDef)
_T = (source)

Undocumented

Value
TypeVar('_T')