Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-27 02:38
📄 __init__.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Python Abstract Syntax Tree New Generation. The aim of this module is to provide a common base representation of python source code for projects such as pychecker, pyreverse, pylint... Well, actually the development of this library is essentially governed by pylint's needs. It mimics the class defined in the python's _ast module with some additional methods and attributes. New nodes instances are not fully compatible with python's _ast. Instance attributes are added by a builder object, which can either generate extended ast (let's call them astroid ;) by visiting an existent ast tree or by inspecting living object. Methods are added by monkey patching ast classes. Main modules are: * nodes and scoped_nodes for more information about methods and attributes added to different node classes * the manager contains a high level object to get astroid trees from source files and living objects. It maintains a cache of previously constructed tree for quick access * builder contains the class responsible to build astroid trees """ import functools import tokenize from importlib import import_module # isort: off # We have an isort: off on '__version__' because the packaging need to access # the version before the dependencies are installed (in particular 'wrapt' # that is imported in astroid.inference) from astroid.__pkginfo__ import __version__, version from astroid.nodes import node_classes, scoped_nodes # isort: on from astroid import inference, raw_building from astroid.astroid_manager import MANAGER from astroid.bases import BaseInstance, BoundMethod, Instance, UnboundMethod from astroid.brain.helpers import register_module_extender from astroid.builder import extract_node, parse from astroid.const import BRAIN_MODULES_DIRECTORY, PY310_PLUS, Context, Del, Load, Store from astroid.exceptions import ( AstroidBuildingError, AstroidBuildingException, AstroidError, AstroidImportError, AstroidIndexError, AstroidSyntaxError, AstroidTypeError, AstroidValueError, AttributeInferenceError, BinaryOperationError, DuplicateBasesError, InconsistentMroError, InferenceError, InferenceOverwriteError, MroError, NameInferenceError, NoDefault, NotFoundError, OperationError, ParentMissingError, ResolveError, StatementMissing, SuperArgumentTypeError, SuperError, TooManyLevelsError, UnaryOperationError, UnresolvableName, UseInferenceDefault, ) from astroid.inference_tip import _inference_tip_cached, inference_tip from astroid.objects import ExceptionInstance # isort: off # It's impossible to import from astroid.nodes with a wildcard, because # there is a cyclic import that prevent creating an __all__ in astroid/nodes # and we need astroid/scoped_nodes and astroid/node_classes to work. So # importing with a wildcard would clash with astroid/nodes/scoped_nodes # and astroid/nodes/node_classes. from astroid.nodes import ( # pylint: disable=redefined-builtin (Ellipsis) CONST_CLS, AnnAssign, Arguments, Assert, Assign, AssignAttr, AssignName, AsyncFor, AsyncFunctionDef, AsyncWith, Attribute, AugAssign, Await, BinOp, BoolOp, Break, Call, ClassDef, Compare, Comprehension, ComprehensionScope, Const, Continue, Decorators, DelAttr, Delete, DelName, Dict, DictComp, DictUnpack, Ellipsis, EmptyNode, EvaluatedObject, ExceptHandler, Expr, ExtSlice, For, FormattedValue, FunctionDef, GeneratorExp, Global, If, IfExp, Import, ImportFrom, Index, JoinedStr, Keyword, Lambda, List, ListComp, Match, MatchAs, MatchCase, MatchClass, MatchMapping, MatchOr, MatchSequence, MatchSingleton, MatchStar, MatchValue, Module, Name, NamedExpr, NodeNG, Nonlocal, Pass, Raise, Return, Set, SetComp, Slice, Starred, Subscript, TryExcept, TryFinally, TryStar, Tuple, UnaryOp, Unknown, While, With, Yield, YieldFrom, are_exclusive, builtin_lookup, unpack_infer, function_to_method, ) # isort: on from astroid.util import Uninferable # Performance hack for tokenize. See https://bugs.python.org/issue43014 # Adapted from https://github.com/PyCQA/pycodestyle/pull/993 if ( not PY310_PLUS and callable(getattr(tokenize, "_compile", None)) and getattr(tokenize._compile, "__wrapped__", None) is None # type: ignore[attr-defined] ): tokenize._compile = functools.lru_cache()(tokenize._compile) # type: ignore[attr-defined] # load brain plugins for module in BRAIN_MODULES_DIRECTORY.iterdir(): if module.suffix == ".py": import_module(f"astroid.brain.{module.stem}")	4.98 KB	2026-01-20 12:58
📄 __pkginfo__.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt __version__ = "2.15.6" version = __version__	274 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 _ast.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt from __future__ import annotations import ast import sys import types from collections.abc import Callable from functools import partial from typing import NamedTuple from astroid.const import PY38_PLUS, Context if sys.version_info >= (3, 8): # On Python 3.8, typed_ast was merged back into `ast` _ast_py3: types.ModuleType \| None = ast else: try: import typed_ast.ast3 as _ast_py3 except ImportError: _ast_py3 = None class FunctionType(NamedTuple): argtypes: list[ast.expr] returns: ast.expr class ParserModule(NamedTuple): module: types.ModuleType unary_op_classes: dict[type[ast.unaryop], str] cmp_op_classes: dict[type[ast.cmpop], str] bool_op_classes: dict[type[ast.boolop], str] bin_op_classes: dict[type[ast.operator], str] context_classes: dict[type[ast.expr_context], Context] def parse(self, string: str, type_comments: bool = True) -> ast.Module: parse_func: Callable[[str], ast.Module] if self.module is _ast_py3: if PY38_PLUS: parse_func = partial(self.module.parse, type_comments=type_comments) else: parse_func = partial( self.module.parse, feature_version=sys.version_info.minor ) else: parse_func = self.module.parse return parse_func(string) def parse_function_type_comment(type_comment: str) -> FunctionType \| None: """Given a correct type comment, obtain a FunctionType object.""" if _ast_py3 is None: return None func_type = _ast_py3.parse(type_comment, "<type_comment>", "func_type") # type: ignore[attr-defined] return FunctionType(argtypes=func_type.argtypes, returns=func_type.returns) def get_parser_module(type_comments: bool = True) -> ParserModule: parser_module = ast if type_comments and _ast_py3: parser_module = _ast_py3 unary_op_classes = _unary_operators_from_module(parser_module) cmp_op_classes = _compare_operators_from_module(parser_module) bool_op_classes = _bool_operators_from_module(parser_module) bin_op_classes = _binary_operators_from_module(parser_module) context_classes = _contexts_from_module(parser_module) return ParserModule( parser_module, unary_op_classes, cmp_op_classes, bool_op_classes, bin_op_classes, context_classes, ) def _unary_operators_from_module( module: types.ModuleType, ) -> dict[type[ast.unaryop], str]: return {module.UAdd: "+", module.USub: "-", module.Not: "not", module.Invert: "~"} def _binary_operators_from_module( module: types.ModuleType, ) -> dict[type[ast.operator], str]: binary_operators = { module.Add: "+", module.BitAnd: "&", module.BitOr: "\|", module.BitXor: "^", module.Div: "/", module.FloorDiv: "//", module.MatMult: "@", module.Mod: "%", module.Mult: "", module.Pow: "*", module.Sub: "-", module.LShift: "<<", module.RShift: ">>", } return binary_operators def _bool_operators_from_module( module: types.ModuleType, ) -> dict[type[ast.boolop], str]: return {module.And: "and", module.Or: "or"} def _compare_operators_from_module( module: types.ModuleType, ) -> dict[type[ast.cmpop], str]: return { module.Eq: "==", module.Gt: ">", module.GtE: ">=", module.In: "in", module.Is: "is", module.IsNot: "is not", module.Lt: "<", module.LtE: "<=", module.NotEq: "!=", module.NotIn: "not in", } def _contexts_from_module( module: types.ModuleType, ) -> dict[type[ast.expr_context], Context]: return { module.Load: Context.Load, module.Store: Context.Store, module.Del: Context.Del, module.Param: Context.Store, }	4.05 KB	2026-01-20 12:58
📄 _backport_stdlib_names.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """ Shim to support Python versions < 3.10 that don't have sys.stdlib_module_names These values were created by cherry-picking the commits from https://bugs.python.org/issue42955 into each version, but may be updated manually if changes are needed. """ import sys # TODO: Remove this file when Python 3.9 is no longer supported PY_3_7 = frozenset( { "__future__", "_abc", "_ast", "_asyncio", "_bisect", "_blake2", "_bootlocale", "_bz2", "_codecs", "_codecs_cn", "_codecs_hk", "_codecs_iso2022", "_codecs_jp", "_codecs_kr", "_codecs_tw", "_collections", "_collections_abc", "_compat_pickle", "_compression", "_contextvars", "_crypt", "_csv", "_ctypes", "_curses", "_curses_panel", "_datetime", "_dbm", "_decimal", "_dummy_thread", "_elementtree", "_functools", "_gdbm", "_hashlib", "_heapq", "_imp", "_io", "_json", "_locale", "_lsprof", "_lzma", "_markupbase", "_md5", "_msi", "_multibytecodec", "_multiprocessing", "_opcode", "_operator", "_osx_support", "_pickle", "_posixsubprocess", "_py_abc", "_pydecimal", "_pyio", "_queue", "_random", "_sha1", "_sha256", "_sha3", "_sha512", "_signal", "_sitebuiltins", "_socket", "_sqlite3", "_sre", "_ssl", "_stat", "_string", "_strptime", "_struct", "_symtable", "_thread", "_threading_local", "_tkinter", "_tracemalloc", "_uuid", "_warnings", "_weakref", "_weakrefset", "_winapi", "abc", "aifc", "antigravity", "argparse", "array", "ast", "asynchat", "asyncio", "asyncore", "atexit", "audioop", "base64", "bdb", "binascii", "binhex", "bisect", "builtins", "bz2", "cProfile", "calendar", "cgi", "cgitb", "chunk", "cmath", "cmd", "code", "codecs", "codeop", "collections", "colorsys", "compileall", "concurrent", "configparser", "contextlib", "contextvars", "copy", "copyreg", "crypt", "csv", "ctypes", "curses", "dataclasses", "datetime", "dbm", "decimal", "difflib", "dis", "distutils", "doctest", "dummy_threading", "email", "encodings", "ensurepip", "enum", "errno", "faulthandler", "fcntl", "filecmp", "fileinput", "fnmatch", "formatter", "fractions", "ftplib", "functools", "gc", "genericpath", "getopt", "getpass", "gettext", "glob", "grp", "gzip", "hashlib", "heapq", "hmac", "html", "http", "idlelib", "imaplib", "imghdr", "imp", "importlib", "inspect", "io", "ipaddress", "itertools", "json", "keyword", "lib2to3", "linecache", "locale", "logging", "lzma", "macpath", "mailbox", "mailcap", "marshal", "math", "mimetypes", "mmap", "modulefinder", "msilib", "msvcrt", "multiprocessing", "netrc", "nis", "nntplib", "nt", "ntpath", "nturl2path", "numbers", "opcode", "operator", "optparse", "os", "ossaudiodev", "parser", "pathlib", "pdb", "pickle", "pickletools", "pipes", "pkgutil", "platform", "plistlib", "poplib", "posix", "posixpath", "pprint", "profile", "pstats", "pty", "pwd", "py_compile", "pyclbr", "pydoc", "pydoc_data", "pyexpat", "queue", "quopri", "random", "re", "readline", "reprlib", "resource", "rlcompleter", "runpy", "sched", "secrets", "select", "selectors", "shelve", "shlex", "shutil", "signal", "site", "smtpd", "smtplib", "sndhdr", "socket", "socketserver", "spwd", "sqlite3", "sre_compile", "sre_constants", "sre_parse", "ssl", "stat", "statistics", "string", "stringprep", "struct", "subprocess", "sunau", "symbol", "symtable", "sys", "sysconfig", "syslog", "tabnanny", "tarfile", "telnetlib", "tempfile", "termios", "textwrap", "this", "threading", "time", "timeit", "tkinter", "token", "tokenize", "trace", "traceback", "tracemalloc", "tty", "turtle", "turtledemo", "types", "typing", "unicodedata", "unittest", "urllib", "uu", "uuid", "venv", "warnings", "wave", "weakref", "webbrowser", "winreg", "winsound", "wsgiref", "xdrlib", "xml", "xmlrpc", "zipapp", "zipfile", "zipimport", "zlib", } ) PY_3_8 = frozenset( PY_3_7 - { "macpath", } \| { "_posixshmem", "_statistics", "_xxsubinterpreters", } ) PY_3_9 = frozenset( PY_3_8 - { "_dummy_thread", "dummy_threading", } \| { "_aix_support", "_bootsubprocess", "_peg_parser", "_zoneinfo", "graphlib", "zoneinfo", } ) if sys.version_info[:2] == (3, 7): stdlib_module_names = PY_3_7 elif sys.version_info[:2] == (3, 8): stdlib_module_names = PY_3_8 elif sys.version_info[:2] == (3, 9): stdlib_module_names = PY_3_9 else: raise AssertionError("This module is only intended as a backport for Python <= 3.9")	6.85 KB	2026-01-20 12:58
📄 _cache.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt from __future__ import annotations from typing import Any class CacheManager: """Manager of caches, to be used as a singleton.""" def __init__(self) -> None: self.dict_caches: list[dict[Any, Any]] = [] def clear_all_caches(self) -> None: """Clear all caches.""" for dict_cache in self.dict_caches: dict_cache.clear() def add_dict_cache(self, cache: dict[Any, Any]) -> None: """Add a dictionary cache to the manager.""" self.dict_caches.append(cache) CACHE_MANAGER = CacheManager()	786 B	2026-01-20 12:58
📄 arguments.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt from __future__ import annotations from astroid import nodes from astroid.bases import Instance from astroid.context import CallContext, InferenceContext from astroid.exceptions import InferenceError, NoDefault from astroid.util import Uninferable, UninferableBase class CallSite: """Class for understanding arguments passed into a call site. It needs a call context, which contains the arguments and the keyword arguments that were passed into a given call site. In order to infer what an argument represents, call :meth:`infer_argument` with the corresponding function node and the argument name. :param callcontext: An instance of :class:`astroid.context.CallContext`, that holds the arguments for the call site. :param argument_context_map: Additional contexts per node, passed in from :attr:`astroid.context.Context.extra_context` :param context: An instance of :class:`astroid.context.Context`. """ def __init__( self, callcontext: CallContext, argument_context_map=None, context: InferenceContext \| None = None, ): if argument_context_map is None: argument_context_map = {} self.argument_context_map = argument_context_map args = callcontext.args keywords = callcontext.keywords self.duplicated_keywords: set[str] = set() self._unpacked_args = self._unpack_args(args, context=context) self._unpacked_kwargs = self._unpack_keywords(keywords, context=context) self.positional_arguments = [ arg for arg in self._unpacked_args if not isinstance(arg, UninferableBase) ] self.keyword_arguments = { key: value for key, value in self._unpacked_kwargs.items() if not isinstance(value, UninferableBase) } @classmethod def from_call(cls, call_node, context: InferenceContext \| None = None): """Get a CallSite object from the given Call node. context will be used to force a single inference path. """ # Determine the callcontext from the given `context` object if any. context = context or InferenceContext() callcontext = CallContext(call_node.args, call_node.keywords) return cls(callcontext, context=context) def has_invalid_arguments(self): """Check if in the current CallSite were passed invalid arguments. This can mean multiple things. For instance, if an unpacking of an invalid object was passed, then this method will return True. Other cases can be when the arguments can't be inferred by astroid, for example, by passing objects which aren't known statically. """ return len(self.positional_arguments) != len(self._unpacked_args) def has_invalid_keywords(self) -> bool: """Check if in the current CallSite were passed invalid keyword arguments. For instance, unpacking a dictionary with integer keys is invalid ({1:2}), because the keys must be strings, which will make this method to return True. Other cases where this might return True if objects which can't be inferred were passed. """ return len(self.keyword_arguments) != len(self._unpacked_kwargs) def _unpack_keywords(self, keywords, context: InferenceContext \| None = None): values = {} context = context or InferenceContext() context.extra_context = self.argument_context_map for name, value in keywords: if name is None: # Then it's an unpacking operation () try: inferred = next(value.infer(context=context)) except InferenceError: values[name] = Uninferable continue except StopIteration: continue if not isinstance(inferred, nodes.Dict): # Not something we can work with. values[name] = Uninferable continue for dict_key, dict_value in inferred.items: try: dict_key = next(dict_key.infer(context=context)) except InferenceError: values[name] = Uninferable continue except StopIteration: continue if not isinstance(dict_key, nodes.Const): values[name] = Uninferable continue if not isinstance(dict_key.value, str): values[name] = Uninferable continue if dict_key.value in values: # The name is already in the dictionary values[dict_key.value] = Uninferable self.duplicated_keywords.add(dict_key.value) continue values[dict_key.value] = dict_value else: values[name] = value return values def _unpack_args(self, args, context: InferenceContext \| None = None): values = [] context = context or InferenceContext() context.extra_context = self.argument_context_map for arg in args: if isinstance(arg, nodes.Starred): try: inferred = next(arg.value.infer(context=context)) except InferenceError: values.append(Uninferable) continue except StopIteration: continue if isinstance(inferred, UninferableBase): values.append(Uninferable) continue if not hasattr(inferred, "elts"): values.append(Uninferable) continue values.extend(inferred.elts) else: values.append(arg) return values def infer_argument(self, funcnode, name, context): # noqa: C901 """Infer a function argument value according to the call context. Arguments: funcnode: The function being called. name: The name of the argument whose value is being inferred. context: Inference context object """ if name in self.duplicated_keywords: raise InferenceError( "The arguments passed to {func!r} have duplicate keywords.", call_site=self, func=funcnode, arg=name, context=context, ) # Look into the keywords first, maybe it's already there. try: return self.keyword_arguments[name].infer(context) except KeyError: pass # Too many arguments given and no variable arguments. if len(self.positional_arguments) > len(funcnode.args.args): if not funcnode.args.vararg and not funcnode.args.posonlyargs: raise InferenceError( "Too many positional arguments " "passed to {func!r} that does " "not have *args.", call_site=self, func=funcnode, arg=name, context=context, ) positional = self.positional_arguments[: len(funcnode.args.args)] vararg = self.positional_arguments[len(funcnode.args.args) :] argindex = funcnode.args.find_argname(name)[0] kwonlyargs = {arg.name for arg in funcnode.args.kwonlyargs} kwargs = { key: value for key, value in self.keyword_arguments.items() if key not in kwonlyargs } # If there are too few positionals compared to # what the function expects to receive, check to see # if the missing positional arguments were passed # as keyword arguments and if so, place them into the # positional args list. if len(positional) < len(funcnode.args.args): for func_arg in funcnode.args.args: if func_arg.name in kwargs: arg = kwargs.pop(func_arg.name) positional.append(arg) if argindex is not None: boundnode = getattr(context, "boundnode", None) # 2. first argument of instance/class method if argindex == 0 and funcnode.type in {"method", "classmethod"}: # context.boundnode is None when an instance method is called with # the class, e.g. MyClass.method(obj, ...). In this case, self # is the first argument. if boundnode is None and funcnode.type == "method" and positional: return positional[0].infer(context=context) if boundnode is None: # XXX can do better ? boundnode = funcnode.parent.frame(future=True) if isinstance(boundnode, nodes.ClassDef): # Verify that we're accessing a method # of the metaclass through a class, as in # `cls.metaclass_method`. In this case, the # first argument is always the class. method_scope = funcnode.parent.scope() if method_scope is boundnode.metaclass(): return iter((boundnode,)) if funcnode.type == "method": if not isinstance(boundnode, Instance): boundnode = boundnode.instantiate_class() return iter((boundnode,)) if funcnode.type == "classmethod": return iter((boundnode,)) # if we have a method, extract one position # from the index, so we'll take in account # the extra parameter represented by `self` or `cls` if funcnode.type in {"method", "classmethod"} and boundnode: argindex -= 1 # 2. search arg index try: return self.positional_arguments[argindex].infer(context) except IndexError: pass if funcnode.args.kwarg == name: # It wants all the keywords that were passed into # the call site. if self.has_invalid_keywords(): raise InferenceError( "Inference failed to find values for all keyword arguments " "to {func!r}: {unpacked_kwargs!r} doesn't correspond to " "{keyword_arguments!r}.", keyword_arguments=self.keyword_arguments, unpacked_kwargs=self._unpacked_kwargs, call_site=self, func=funcnode, arg=name, context=context, ) kwarg = nodes.Dict( lineno=funcnode.args.lineno, col_offset=funcnode.args.col_offset, parent=funcnode.args, ) kwarg.postinit( [(nodes.const_factory(key), value) for key, value in kwargs.items()] ) return iter((kwarg,)) if funcnode.args.vararg == name: # It wants all the args that were passed into # the call site. if self.has_invalid_arguments(): raise InferenceError( "Inference failed to find values for all positional " "arguments to {func!r}: {unpacked_args!r} doesn't " "correspond to {positional_arguments!r}.", positional_arguments=self.positional_arguments, unpacked_args=self._unpacked_args, call_site=self, func=funcnode, arg=name, context=context, ) args = nodes.Tuple( lineno=funcnode.args.lineno, col_offset=funcnode.args.col_offset, parent=funcnode.args, ) args.postinit(vararg) return iter((args,)) # Check if it's a default parameter. try: return funcnode.args.default_value(name).infer(context) except NoDefault: pass raise InferenceError( "No value found for argument {arg} to {func!r}", call_site=self, func=funcnode, arg=name, context=context, )	12.65 KB	2026-01-20 12:58
📄 astroid_manager.py """ This file contain the global astroid MANAGER. It prevents a circular import that happened when the only possibility to import it was from astroid.__init__.py. This AstroidManager is a singleton/borg so it's possible to instantiate an AstroidManager() directly. """ # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt from astroid.manager import AstroidManager MANAGER = AstroidManager()	572 B	2026-01-20 12:58
📄 bases.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """This module contains base classes and functions for the nodes and some inference utils. """ from __future__ import annotations import collections import collections.abc import sys from collections.abc import Sequence from typing import TYPE_CHECKING, Any, ClassVar from astroid import decorators, nodes from astroid.const import PY310_PLUS from astroid.context import ( CallContext, InferenceContext, bind_context_to_node, copy_context, ) from astroid.exceptions import ( AstroidTypeError, AttributeInferenceError, InferenceError, NameInferenceError, ) from astroid.typing import InferBinaryOp, InferenceErrorInfo, InferenceResult from astroid.util import Uninferable, UninferableBase, lazy_descriptor, lazy_import if sys.version_info >= (3, 8): from typing import Literal else: from typing_extensions import Literal if TYPE_CHECKING: from astroid.constraint import Constraint objectmodel = lazy_import("interpreter.objectmodel") helpers = lazy_import("helpers") manager = lazy_import("manager") # TODO: check if needs special treatment BOOL_SPECIAL_METHOD = "__bool__" BUILTINS = "builtins" # TODO Remove in 2.8 PROPERTIES = {"builtins.property", "abc.abstractproperty"} if PY310_PLUS: PROPERTIES.add("enum.property") # List of possible property names. We use this list in order # to see if a method is a property or not. This should be # pretty reliable and fast, the alternative being to check each # decorator to see if its a real property-like descriptor, which # can be too complicated. # Also, these aren't qualified, because each project can # define them, we shouldn't expect to know every possible # property-like decorator! POSSIBLE_PROPERTIES = { "cached_property", "cachedproperty", "lazyproperty", "lazy_property", "reify", "lazyattribute", "lazy_attribute", "LazyProperty", "lazy", "cache_readonly", "DynamicClassAttribute", } def _is_property(meth, context: InferenceContext \| None = None) -> bool: decoratornames = meth.decoratornames(context=context) if PROPERTIES.intersection(decoratornames): return True stripped = { name.split(".")[-1] for name in decoratornames if not isinstance(name, UninferableBase) } if any(name in stripped for name in POSSIBLE_PROPERTIES): return True # Lookup for subclasses of property if not meth.decorators: return False for decorator in meth.decorators.nodes or (): inferred = helpers.safe_infer(decorator, context=context) if inferred is None or isinstance(inferred, UninferableBase): continue if inferred.__class__.__name__ == "ClassDef": for base_class in inferred.bases: if base_class.__class__.__name__ != "Name": continue module, _ = base_class.lookup(base_class.name) if module.name == "builtins" and base_class.name == "property": return True return False class Proxy: """A simple proxy object. Note: Subclasses of this object will need a custom __getattr__ if new instance attributes are created. See the Const class """ _proxied: nodes.ClassDef \| nodes.Lambda \| Proxy \| None = ( None # proxied object may be set by class or by instance ) def __init__( self, proxied: nodes.ClassDef \| nodes.Lambda \| Proxy \| None = None ) -> None: if proxied is None: # This is a hack to allow calling this __init__ during bootstrapping of # builtin classes and their docstrings. # For Const, Generator, and UnionType nodes the _proxied attribute # is set during bootstrapping # as we first need to build the ClassDef that they can proxy. # Thus, if proxied is None self should be a Const or Generator # as that is the only way _proxied will be correctly set as a ClassDef. assert isinstance(self, (nodes.Const, Generator, UnionType)) else: self._proxied = proxied def __getattr__(self, name): if name == "_proxied": return self.__class__._proxied if name in self.__dict__: return self.__dict__[name] return getattr(self._proxied, name) def infer( # type: ignore[return] self, context: InferenceContext \| None = None, *kwargs: Any ) -> collections.abc.Generator[InferenceResult, None, InferenceErrorInfo \| None]: yield self def _infer_stmts( stmts: Sequence[nodes.NodeNG \| UninferableBase \| Instance], context: InferenceContext \| None, frame: nodes.NodeNG \| Instance \| None = None, ) -> collections.abc.Generator[InferenceResult, None, None]: """Return an iterator on statements inferred by each statement in stmts.""" inferred = False constraint_failed = False if context is not None: name = context.lookupname context = context.clone() constraints = context.constraints.get(name, {}) else: name = None constraints = {} context = InferenceContext() for stmt in stmts: if isinstance(stmt, UninferableBase): yield stmt inferred = True continue # 'context' is always InferenceContext and Instances get '_infer_name' from ClassDef context.lookupname = stmt._infer_name(frame, name) # type: ignore[union-attr] try: stmt_constraints: set[Constraint] = set() for constraint_stmt, potential_constraints in constraints.items(): if not constraint_stmt.parent_of(stmt): stmt_constraints.update(potential_constraints) for inf in stmt.infer(context=context): if all(constraint.satisfied_by(inf) for constraint in stmt_constraints): yield inf inferred = True else: constraint_failed = True except NameInferenceError: continue except InferenceError: yield Uninferable inferred = True if not inferred and constraint_failed: yield Uninferable elif not inferred: raise InferenceError( "Inference failed for all members of {stmts!r}.", stmts=stmts, frame=frame, context=context, ) def _infer_method_result_truth(instance, method_name, context): # Get the method from the instance and try to infer # its return's truth value. meth = next(instance.igetattr(method_name, context=context), None) if meth and hasattr(meth, "infer_call_result"): if not meth.callable(): return Uninferable try: context.callcontext = CallContext(args=[], callee=meth) for value in meth.infer_call_result(instance, context=context): if isinstance(value, UninferableBase): return value try: inferred = next(value.infer(context=context)) except StopIteration as e: raise InferenceError(context=context) from e return inferred.bool_value() except InferenceError: pass return Uninferable class BaseInstance(Proxy): """An instance base class, which provides lookup methods for potential instances. """ special_attributes = None def display_type(self) -> str: return "Instance of" def getattr(self, name, context: InferenceContext \| None = None, lookupclass=True): try: values = self._proxied.instance_attr(name, context) except AttributeInferenceError as exc: if self.special_attributes and name in self.special_attributes: return [self.special_attributes.lookup(name)] if lookupclass: # Class attributes not available through the instance # unless they are explicitly defined. return self._proxied.getattr(name, context, class_context=False) raise AttributeInferenceError( target=self, attribute=name, context=context ) from exc # since we've no context information, return matching class members as # well if lookupclass: try: return values + self._proxied.getattr( name, context, class_context=False ) except AttributeInferenceError: pass return values def igetattr(self, name, context: InferenceContext \| None = None): """Inferred getattr.""" if not context: context = InferenceContext() try: context.lookupname = name # avoid recursively inferring the same attr on the same class if context.push(self._proxied): raise InferenceError( message="Cannot infer the same attribute again", node=self, context=context, ) # XXX frame should be self._proxied, or not ? get_attr = self.getattr(name, context, lookupclass=False) yield from _infer_stmts( self._wrap_attr(get_attr, context), context, frame=self ) except AttributeInferenceError: try: # fallback to class.igetattr since it has some logic to handle # descriptors # But only if the _proxied is the Class. if self._proxied.__class__.__name__ != "ClassDef": raise attrs = self._proxied.igetattr(name, context, class_context=False) yield from self._wrap_attr(attrs, context) except AttributeInferenceError as error: raise InferenceError(vars(error)) from error def _wrap_attr(self, attrs, context: InferenceContext \| None = None): """Wrap bound methods of attrs in a InstanceMethod proxies.""" for attr in attrs: if isinstance(attr, UnboundMethod): if _is_property(attr): yield from attr.infer_call_result(self, context) else: yield BoundMethod(attr, self) elif hasattr(attr, "name") and attr.name == "<lambda>": if attr.args.arguments and attr.args.arguments[0].name == "self": yield BoundMethod(attr, self) continue yield attr else: yield attr def infer_call_result( self, caller: nodes.Call \| Proxy, context: InferenceContext \| None = None ): """Infer what a class instance is returning when called.""" context = bind_context_to_node(context, self) inferred = False # If the call is an attribute on the instance, we infer the attribute itself if isinstance(caller, nodes.Call) and isinstance(caller.func, nodes.Attribute): for res in self.igetattr(caller.func.attrname, context): inferred = True yield res # Otherwise we infer the call to the __call__ dunder normally for node in self._proxied.igetattr("__call__", context): if isinstance(node, UninferableBase) or not node.callable(): continue for res in node.infer_call_result(caller, context): inferred = True yield res if not inferred: raise InferenceError(node=self, caller=caller, context=context) class Instance(BaseInstance): """A special node representing a class instance.""" _proxied: nodes.ClassDef # pylint: disable=unnecessary-lambda special_attributes = lazy_descriptor(lambda: objectmodel.InstanceModel()) def __init__(self, proxied: nodes.ClassDef \| None) -> None: super().__init__(proxied) infer_binary_op: ClassVar[InferBinaryOp[Instance]] def __repr__(self) -> str: return "<Instance of {}.{} at 0x{}>".format( self._proxied.root().name, self._proxied.name, id(self) ) def __str__(self) -> str: return f"Instance of {self._proxied.root().name}.{self._proxied.name}" def callable(self) -> bool: try: self._proxied.getattr("__call__", class_context=False) return True except AttributeInferenceError: return False def pytype(self) -> str: return self._proxied.qname() def display_type(self) -> str: return "Instance of" def bool_value(self, context: InferenceContext \| None = None): """Infer the truth value for an Instance. The truth value of an instance is determined by these conditions: if it implements __bool__ on Python 3 or __nonzero__ on Python 2, then its bool value will be determined by calling this special method and checking its result. * when this method is not defined, __len__() is called, if it is defined, and the object is considered true if its result is nonzero. If a class defines neither __len__() nor __bool__(), all its instances are considered true. """ context = context or InferenceContext() context.boundnode = self try: result = _infer_method_result_truth(self, BOOL_SPECIAL_METHOD, context) except (InferenceError, AttributeInferenceError): # Fallback to __len__. try: result = _infer_method_result_truth(self, "__len__", context) except (AttributeInferenceError, InferenceError): return True return result def getitem(self, index, context: InferenceContext \| None = None): new_context = bind_context_to_node(context, self) if not context: context = new_context method = next(self.igetattr("__getitem__", context=context), None) # Create a new CallContext for providing index as an argument. new_context.callcontext = CallContext(args=[index], callee=method) if not isinstance(method, BoundMethod): raise InferenceError( "Could not find __getitem__ for {node!r}.", node=self, context=context ) if len(method.args.arguments) != 2: # (self, index) raise AstroidTypeError( "__getitem__ for {node!r} does not have correct signature", node=self, context=context, ) return next(method.infer_call_result(self, new_context), None) class UnboundMethod(Proxy): """A special node representing a method not bound to an instance.""" # pylint: disable=unnecessary-lambda special_attributes = lazy_descriptor(lambda: objectmodel.UnboundMethodModel()) def __repr__(self) -> str: frame = self._proxied.parent.frame(future=True) return "<{} {} of {} at 0x{}".format( self.__class__.__name__, self._proxied.name, frame.qname(), id(self) ) def implicit_parameters(self) -> Literal[0]: return 0 def is_bound(self) -> Literal[False]: return False def getattr(self, name, context: InferenceContext \| None = None): if name in self.special_attributes: return [self.special_attributes.lookup(name)] return self._proxied.getattr(name, context) def igetattr(self, name, context: InferenceContext \| None = None): if name in self.special_attributes: return iter((self.special_attributes.lookup(name),)) return self._proxied.igetattr(name, context) def infer_call_result(self, caller, context): """ The boundnode of the regular context with a function called on ``object.__new__`` will be of type ``object``, which is incorrect for the argument in general. If no context is given the ``object.__new__`` call argument will be correctly inferred except when inside a call that requires the additional context (such as a classmethod) of the boundnode to determine which class the method was called from """ # If we're unbound method __new__ of a builtin, the result is an # instance of the class given as first argument. if self._proxied.name == "__new__": qname = self._proxied.parent.frame(future=True).qname() # Avoid checking builtins.type: _infer_type_new_call() does more validation if qname.startswith("builtins.") and qname != "builtins.type": return self._infer_builtin_new(caller, context) return self._proxied.infer_call_result(caller, context) def _infer_builtin_new( self, caller: nodes.Call, context: InferenceContext, ) -> collections.abc.Generator[ nodes.Const \| Instance \| UninferableBase, None, None ]: if not caller.args: return # Attempt to create a constant if len(caller.args) > 1: value = None if isinstance(caller.args[1], nodes.Const): value = caller.args[1].value else: inferred_arg = next(caller.args[1].infer(), None) if isinstance(inferred_arg, nodes.Const): value = inferred_arg.value if value is not None: yield nodes.const_factory(value) return node_context = context.extra_context.get(caller.args[0]) for inferred in caller.args[0].infer(context=node_context): if isinstance(inferred, UninferableBase): yield inferred if isinstance(inferred, nodes.ClassDef): yield Instance(inferred) raise InferenceError def bool_value(self, context: InferenceContext \| None = None) -> Literal[True]: return True class BoundMethod(UnboundMethod): """A special node representing a method bound to an instance.""" # pylint: disable=unnecessary-lambda special_attributes = lazy_descriptor(lambda: objectmodel.BoundMethodModel()) def __init__(self, proxy, bound): super().__init__(proxy) self.bound = bound def implicit_parameters(self) -> Literal[0, 1]: if self.name == "__new__": # __new__ acts as a classmethod but the class argument is not implicit. return 0 return 1 def is_bound(self) -> Literal[True]: return True def _infer_type_new_call(self, caller, context): # noqa: C901 """Try to infer what type.__new__(mcs, name, bases, attrs) returns. In order for such call to be valid, the metaclass needs to be a subtype of ``type``, the name needs to be a string, the bases needs to be a tuple of classes """ # pylint: disable=import-outside-toplevel; circular import from astroid.nodes import Pass # Verify the metaclass try: mcs = next(caller.args[0].infer(context=context)) except StopIteration as e: raise InferenceError(context=context) from e if mcs.__class__.__name__ != "ClassDef": # Not a valid first argument. return None if not mcs.is_subtype_of("builtins.type"): # Not a valid metaclass. return None # Verify the name try: name = next(caller.args[1].infer(context=context)) except StopIteration as e: raise InferenceError(context=context) from e if name.__class__.__name__ != "Const": # Not a valid name, needs to be a const. return None if not isinstance(name.value, str): # Needs to be a string. return None # Verify the bases try: bases = next(caller.args[2].infer(context=context)) except StopIteration as e: raise InferenceError(context=context) from e if bases.__class__.__name__ != "Tuple": # Needs to be a tuple. return None try: inferred_bases = [next(elt.infer(context=context)) for elt in bases.elts] except StopIteration as e: raise InferenceError(context=context) from e if any(base.__class__.__name__ != "ClassDef" for base in inferred_bases): # All the bases needs to be Classes return None # Verify the attributes. try: attrs = next(caller.args[3].infer(context=context)) except StopIteration as e: raise InferenceError(context=context) from e if attrs.__class__.__name__ != "Dict": # Needs to be a dictionary. return None cls_locals = collections.defaultdict(list) for key, value in attrs.items: try: key = next(key.infer(context=context)) except StopIteration as e: raise InferenceError(context=context) from e try: value = next(value.infer(context=context)) except StopIteration as e: raise InferenceError(context=context) from e # Ignore non string keys if key.__class__.__name__ == "Const" and isinstance(key.value, str): cls_locals[key.value].append(value) # Build the class from now. cls = mcs.__class__( name=name.value, lineno=caller.lineno, col_offset=caller.col_offset, parent=caller, ) empty = Pass() cls.postinit( bases=bases.elts, body=[empty], decorators=[], newstyle=True, metaclass=mcs, keywords=[], ) cls.locals = cls_locals return cls def infer_call_result(self, caller, context: InferenceContext \| None = None): context = bind_context_to_node(context, self.bound) if ( self.bound.__class__.__name__ == "ClassDef" and self.bound.name == "type" and self.name == "__new__" and len(caller.args) == 4 ): # Check if we have a ``type.__new__(mcs, name, bases, attrs)`` call. new_cls = self._infer_type_new_call(caller, context) if new_cls: return iter((new_cls,)) return super().infer_call_result(caller, context) def bool_value(self, context: InferenceContext \| None = None) -> Literal[True]: return True class Generator(BaseInstance): """A special node representing a generator. Proxied class is set once for all in raw_building. """ _proxied: nodes.ClassDef special_attributes = lazy_descriptor(objectmodel.GeneratorModel) def __init__( self, parent=None, generator_initial_context: InferenceContext \| None = None ): super().__init__() self.parent = parent self._call_context = copy_context(generator_initial_context) @decorators.cached def infer_yield_types(self): yield from self.parent.infer_yield_result(self._call_context) def callable(self) -> Literal[False]: return False def pytype(self) -> Literal["builtins.generator"]: return "builtins.generator" def display_type(self) -> str: return "Generator" def bool_value(self, context: InferenceContext \| None = None) -> Literal[True]: return True def __repr__(self) -> str: return f"<Generator({self._proxied.name}) l.{self.lineno} at 0x{id(self)}>" def __str__(self) -> str: return f"Generator({self._proxied.name})" class AsyncGenerator(Generator): """Special node representing an async generator.""" def pytype(self) -> Literal["builtins.async_generator"]: return "builtins.async_generator" def display_type(self) -> str: return "AsyncGenerator" def __repr__(self) -> str: return f"<AsyncGenerator({self._proxied.name}) l.{self.lineno} at 0x{id(self)}>" def __str__(self) -> str: return f"AsyncGenerator({self._proxied.name})" class UnionType(BaseInstance): """Special node representing new style typing unions. Proxied class is set once for all in raw_building. """ _proxied: nodes.ClassDef def __init__( self, left: UnionType \| nodes.ClassDef \| nodes.Const, right: UnionType \| nodes.ClassDef \| nodes.Const, parent: nodes.NodeNG \| None = None, ) -> None: super().__init__() self.parent = parent self.left = left self.right = right def callable(self) -> Literal[False]: return False def bool_value(self, context: InferenceContext \| None = None) -> Literal[True]: return True def pytype(self) -> Literal["types.UnionType"]: return "types.UnionType" def display_type(self) -> str: return "UnionType" def __repr__(self) -> str: return f"<UnionType({self._proxied.name}) l.{self.lineno} at 0x{id(self)}>" def __str__(self) -> str: return f"UnionType({self._proxied.name})"	24.99 KB	2026-01-20 12:58
📁 brain	-	2026-03-21 15:45
📄 builder.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """The AstroidBuilder makes astroid from living object and / or from _ast. The builder is not thread safe and can't be used to parse different sources at the same time. """ from __future__ import annotations import ast import os import textwrap import types from collections.abc import Iterator, Sequence from io import TextIOWrapper from tokenize import detect_encoding from typing import TYPE_CHECKING from astroid import bases, modutils, nodes, raw_building, rebuilder, util from astroid._ast import ParserModule, get_parser_module from astroid.exceptions import AstroidBuildingError, AstroidSyntaxError, InferenceError from astroid.manager import AstroidManager if TYPE_CHECKING: from astroid import objects else: objects = util.lazy_import("objects") # The name of the transient function that is used to # wrap expressions to be extracted when calling # extract_node. _TRANSIENT_FUNCTION = "__" # The comment used to select a statement to be extracted # when calling extract_node. _STATEMENT_SELECTOR = "#@" MISPLACED_TYPE_ANNOTATION_ERROR = "misplaced type annotation" def open_source_file(filename: str) -> tuple[TextIOWrapper, str, str]: # pylint: disable=consider-using-with with open(filename, "rb") as byte_stream: encoding = detect_encoding(byte_stream.readline)[0] stream = open(filename, newline=None, encoding=encoding) data = stream.read() return stream, encoding, data def _can_assign_attr(node: nodes.ClassDef, attrname: str \| None) -> bool: try: slots = node.slots() except NotImplementedError: pass else: if slots and attrname not in {slot.value for slot in slots}: return False return node.qname() != "builtins.object" class AstroidBuilder(raw_building.InspectBuilder): """Class for building an astroid tree from source code or from a live module. The param manager specifies the manager class which should be used. If no manager is given, then the default one will be used. The param apply_transforms determines if the transforms should be applied after the tree was built from source or from a live object, by default being True. """ def __init__( self, manager: AstroidManager \| None = None, apply_transforms: bool = True ) -> None: super().__init__(manager) self._apply_transforms = apply_transforms def module_build( self, module: types.ModuleType, modname: str \| None = None ) -> nodes.Module: """Build an astroid from a living module instance.""" node = None path = getattr(module, "__file__", None) loader = getattr(module, "__loader__", None) # Prefer the loader to get the source rather than assuming we have a # filesystem to read the source file from ourselves. if loader: modname = modname or module.__name__ source = loader.get_source(modname) if source: node = self.string_build(source, modname, path=path) if node is None and path is not None: path_, ext = os.path.splitext(modutils._path_from_filename(path)) if ext in {".py", ".pyc", ".pyo"} and os.path.exists(path_ + ".py"): node = self.file_build(path_ + ".py", modname) if node is None: # this is a built-in module # get a partial representation by introspection node = self.inspect_build(module, modname=modname, path=path) if self._apply_transforms: # We have to handle transformation by ourselves since the # rebuilder isn't called for builtin nodes node = self._manager.visit_transforms(node) assert isinstance(node, nodes.Module) return node def file_build(self, path: str, modname: str \| None = None) -> nodes.Module: """Build astroid from a source code file (i.e. from an ast). path is expected to be a python source file """ try: stream, encoding, data = open_source_file(path) except OSError as exc: raise AstroidBuildingError( "Unable to load file {path}:\n{error}", modname=modname, path=path, error=exc, ) from exc except (SyntaxError, LookupError) as exc: raise AstroidSyntaxError( "Python 3 encoding specification error or unknown encoding:\n" "{error}", modname=modname, path=path, error=exc, ) from exc except UnicodeError as exc: # wrong encoding # detect_encoding returns utf-8 if no encoding specified raise AstroidBuildingError( "Wrong or no encoding specified for {filename}.", filename=path ) from exc with stream: # get module name if necessary if modname is None: try: modname = ".".join(modutils.modpath_from_file(path)) except ImportError: modname = os.path.splitext(os.path.basename(path))[0] # build astroid representation module, builder = self._data_build(data, modname, path) return self._post_build(module, builder, encoding) def string_build( self, data: str, modname: str = "", path: str \| None = None ) -> nodes.Module: """Build astroid from source code string.""" module, builder = self._data_build(data, modname, path) module.file_bytes = data.encode("utf-8") return self._post_build(module, builder, "utf-8") def _post_build( self, module: nodes.Module, builder: rebuilder.TreeRebuilder, encoding: str ) -> nodes.Module: """Handles encoding and delayed nodes after a module has been built.""" module.file_encoding = encoding self._manager.cache_module(module) # post tree building steps after we stored the module in the cache: for from_node in builder._import_from_nodes: if from_node.modname == "__future__": for symbol, _ in from_node.names: module.future_imports.add(symbol) self.add_from_names_to_locals(from_node) # handle delayed assattr nodes for delayed in builder._delayed_assattr: self.delayed_assattr(delayed) # Visit the transforms if self._apply_transforms: module = self._manager.visit_transforms(module) return module def _data_build( self, data: str, modname: str, path: str \| None ) -> tuple[nodes.Module, rebuilder.TreeRebuilder]: """Build tree node from data and add some informations.""" try: node, parser_module = _parse_string(data, type_comments=True) except (TypeError, ValueError, SyntaxError) as exc: raise AstroidSyntaxError( "Parsing Python code failed:\n{error}", source=data, modname=modname, path=path, error=exc, ) from exc if path is not None: node_file = os.path.abspath(path) else: node_file = "<?>" if modname.endswith(".__init__"): modname = modname[:-9] package = True else: package = ( path is not None and os.path.splitext(os.path.basename(path))[0] == "__init__" ) builder = rebuilder.TreeRebuilder(self._manager, parser_module, data) module = builder.visit_module(node, modname, node_file, package) return module, builder def add_from_names_to_locals(self, node: nodes.ImportFrom) -> None: """Store imported names to the locals. Resort the locals if coming from a delayed node """ def _key_func(node: nodes.NodeNG) -> int: return node.fromlineno or 0 def sort_locals(my_list: list[nodes.NodeNG]) -> None: my_list.sort(key=_key_func) assert node.parent # It should always default to the module for name, asname in node.names: if name == "*": try: imported = node.do_import_module() except AstroidBuildingError: continue for name in imported.public_names(): node.parent.set_local(name, node) sort_locals(node.parent.scope().locals[name]) # type: ignore[arg-type] else: node.parent.set_local(asname or name, node) sort_locals(node.parent.scope().locals[asname or name]) # type: ignore[arg-type] def delayed_assattr(self, node: nodes.AssignAttr) -> None: """Visit a AssAttr node. This adds name to locals and handle members definition. """ try: frame = node.frame(future=True) for inferred in node.expr.infer(): if isinstance(inferred, util.UninferableBase): continue try: # pylint: disable=unidiomatic-typecheck # We want a narrow check on the # parent type, not all of its subclasses if ( type(inferred) == bases.Instance or type(inferred) == objects.ExceptionInstance ): inferred = inferred._proxied iattrs = inferred.instance_attrs if not _can_assign_attr(inferred, node.attrname): continue elif isinstance(inferred, bases.Instance): # Const, Tuple or other containers that inherit from # `Instance` continue elif isinstance(inferred, (bases.Proxy, util.UninferableBase)): continue elif inferred.is_function: iattrs = inferred.instance_attrs else: iattrs = inferred.locals except AttributeError: # XXX log error continue values = iattrs.setdefault(node.attrname, []) if node in values: continue # get assign in __init__ first XXX useful ? if ( frame.name == "__init__" and values and values[0].frame(future=True).name != "__init__" ): values.insert(0, node) else: values.append(node) except InferenceError: pass def build_namespace_package_module(name: str, path: Sequence[str]) -> nodes.Module: # TODO: Typing: Remove the cast to list and just update typing to accept Sequence return nodes.Module(name, path=list(path), package=True) def parse( code: str, module_name: str = "", path: str \| None = None, apply_transforms: bool = True, ) -> nodes.Module: """Parses a source string in order to obtain an astroid AST from it. :param str code: The code for the module. :param str module_name: The name for the module, if any :param str path: The path for the module :param bool apply_transforms: Apply the transforms for the give code. Use it if you don't want the default transforms to be applied. """ code = textwrap.dedent(code) builder = AstroidBuilder( manager=AstroidManager(), apply_transforms=apply_transforms ) return builder.string_build(code, modname=module_name, path=path) def _extract_expressions(node: nodes.NodeNG) -> Iterator[nodes.NodeNG]: """Find expressions in a call to _TRANSIENT_FUNCTION and extract them. The function walks the AST recursively to search for expressions that are wrapped into a call to _TRANSIENT_FUNCTION. If it finds such an expression, it completely removes the function call node from the tree, replacing it by the wrapped expression inside the parent. :param node: An astroid node. :type node: astroid.bases.NodeNG :yields: The sequence of wrapped expressions on the modified tree expression can be found. """ if ( isinstance(node, nodes.Call) and isinstance(node.func, nodes.Name) and node.func.name == _TRANSIENT_FUNCTION ): real_expr = node.args[0] assert node.parent real_expr.parent = node.parent # Search for node in all _astng_fields (the fields checked when # get_children is called) of its parent. Some of those fields may # be lists or tuples, in which case the elements need to be checked. # When we find it, replace it by real_expr, so that the AST looks # like no call to _TRANSIENT_FUNCTION ever took place. for name in node.parent._astroid_fields: child = getattr(node.parent, name) if isinstance(child, list): for idx, compound_child in enumerate(child): if compound_child is node: child[idx] = real_expr elif child is node: setattr(node.parent, name, real_expr) yield real_expr else: for child in node.get_children(): yield from _extract_expressions(child) def _find_statement_by_line(node: nodes.NodeNG, line: int) -> nodes.NodeNG \| None: """Extracts the statement on a specific line from an AST. If the line number of node matches line, it will be returned; otherwise its children are iterated and the function is called recursively. :param node: An astroid node. :type node: astroid.bases.NodeNG :param line: The line number of the statement to extract. :type line: int :returns: The statement on the line, or None if no statement for the line can be found. :rtype: astroid.bases.NodeNG or None """ if isinstance(node, (nodes.ClassDef, nodes.FunctionDef, nodes.MatchCase)): # This is an inaccuracy in the AST: the nodes that can be # decorated do not carry explicit information on which line # the actual definition (class/def), but .fromline seems to # be close enough. node_line = node.fromlineno else: node_line = node.lineno if node_line == line: return node for child in node.get_children(): result = _find_statement_by_line(child, line) if result: return result return None def extract_node(code: str, module_name: str = "") -> nodes.NodeNG \| list[nodes.NodeNG]: """Parses some Python code as a module and extracts a designated AST node. Statements: To extract one or more statement nodes, append #@ to the end of the line Examples: >>> def x(): >>> def y(): >>> return 1 #@ The return statement will be extracted. >>> class X(object): >>> def meth(self): #@ >>> pass The function object 'meth' will be extracted. Expressions: To extract arbitrary expressions, surround them with the fake function call __(...). After parsing, the surrounded expression will be returned and the whole AST (accessible via the returned node's parent attribute) will look like the function call was never there in the first place. Examples: >>> a = __(1) The const node will be extracted. >>> def x(d=__(foo.bar)): pass The node containing the default argument will be extracted. >>> def foo(a, b): >>> return 0 < __(len(a)) < b The node containing the function call 'len' will be extracted. If no statements or expressions are selected, the last toplevel statement will be returned. If the selected statement is a discard statement, (i.e. an expression turned into a statement), the wrapped expression is returned instead. For convenience, singleton lists are unpacked. :param str code: A piece of Python code that is parsed as a module. Will be passed through textwrap.dedent first. :param str module_name: The name of the module. :returns: The designated node from the parse tree, or a list of nodes. """ def _extract(node: nodes.NodeNG \| None) -> nodes.NodeNG \| None: if isinstance(node, nodes.Expr): return node.value return node requested_lines: list[int] = [] for idx, line in enumerate(code.splitlines()): if line.strip().endswith(_STATEMENT_SELECTOR): requested_lines.append(idx + 1) tree = parse(code, module_name=module_name) if not tree.body: raise ValueError("Empty tree, cannot extract from it") extracted: list[nodes.NodeNG \| None] = [] if requested_lines: extracted = [_find_statement_by_line(tree, line) for line in requested_lines] # Modifies the tree. extracted.extend(_extract_expressions(tree)) if not extracted: extracted.append(tree.body[-1]) extracted = [_extract(node) for node in extracted] extracted_without_none = [node for node in extracted if node is not None] if len(extracted_without_none) == 1: return extracted_without_none[0] return extracted_without_none def _extract_single_node(code: str, module_name: str = "") -> nodes.NodeNG: """Call extract_node while making sure that only one value is returned.""" ret = extract_node(code, module_name) if isinstance(ret, list): return ret[0] return ret def _parse_string( data: str, type_comments: bool = True ) -> tuple[ast.Module, ParserModule]: parser_module = get_parser_module(type_comments=type_comments) try: parsed = parser_module.parse(data + "\n", type_comments=type_comments) except SyntaxError as exc: # If the type annotations are misplaced for some reason, we do not want # to fail the entire parsing of the file, so we need to retry the parsing without # type comment support. if exc.args[0] != MISPLACED_TYPE_ANNOTATION_ERROR or not type_comments: raise parser_module = get_parser_module(type_comments=False) parsed = parser_module.parse(data + "\n", type_comments=False) return parsed, parser_module	18.35 KB	2026-01-20 12:58
📄 const.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt import enum import sys from pathlib import Path PY38 = sys.version_info[:2] == (3, 8) PY38_PLUS = sys.version_info >= (3, 8) PY39_PLUS = sys.version_info >= (3, 9) PY310_PLUS = sys.version_info >= (3, 10) PY311_PLUS = sys.version_info >= (3, 11) BUILTINS = "builtins" # TODO Remove in 2.8 WIN32 = sys.platform == "win32" IS_PYPY = sys.implementation.name == "pypy" IS_JYTHON = sys.implementation.name == "jython" # pylint: disable-next=no-member PYPY_7_3_11_PLUS = IS_PYPY and sys.pypy_version_info >= (7, 3, 11) # type: ignore[attr-defined] class Context(enum.Enum): Load = 1 Store = 2 Del = 3 # TODO Remove in 3.0 in favor of Context Load = Context.Load Store = Context.Store Del = Context.Del ASTROID_INSTALL_DIRECTORY = Path(__file__).parent BRAIN_MODULES_DIRECTORY = ASTROID_INSTALL_DIRECTORY / "brain" _EMPTY_OBJECT_MARKER = object()	1.07 KB	2026-01-20 12:58
📄 constraint.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Classes representing different types of constraints on inference values.""" from __future__ import annotations import sys from abc import ABC, abstractmethod from collections.abc import Iterator from typing import Union from astroid import bases, nodes, util from astroid.typing import InferenceResult if sys.version_info >= (3, 11): from typing import Self else: from typing_extensions import Self _NameNodes = Union[nodes.AssignAttr, nodes.Attribute, nodes.AssignName, nodes.Name] class Constraint(ABC): """Represents a single constraint on a variable.""" def __init__(self, node: nodes.NodeNG, negate: bool) -> None: self.node = node """The node that this constraint applies to.""" self.negate = negate """True if this constraint is negated. E.g., "is not" instead of "is".""" @classmethod @abstractmethod def match( cls: type[Self], node: _NameNodes, expr: nodes.NodeNG, negate: bool = False ) -> Self \| None: """Return a new constraint for node matched from expr, if expr matches the constraint pattern. If negate is True, negate the constraint. """ @abstractmethod def satisfied_by(self, inferred: InferenceResult) -> bool: """Return True if this constraint is satisfied by the given inferred value.""" class NoneConstraint(Constraint): """Represents an "is None" or "is not None" constraint.""" CONST_NONE: nodes.Const = nodes.Const(None) @classmethod def match( cls: type[Self], node: _NameNodes, expr: nodes.NodeNG, negate: bool = False ) -> Self \| None: """Return a new constraint for node matched from expr, if expr matches the constraint pattern. Negate the constraint based on the value of negate. """ if isinstance(expr, nodes.Compare) and len(expr.ops) == 1: left = expr.left op, right = expr.ops[0] if op in {"is", "is not"} and ( _matches(left, node) and _matches(right, cls.CONST_NONE) ): negate = (op == "is" and negate) or (op == "is not" and not negate) return cls(node=node, negate=negate) return None def satisfied_by(self, inferred: InferenceResult) -> bool: """Return True if this constraint is satisfied by the given inferred value.""" # Assume true if uninferable if isinstance(inferred, util.UninferableBase): return True # Return the XOR of self.negate and matches(inferred, self.CONST_NONE) return self.negate ^ _matches(inferred, self.CONST_NONE) def get_constraints( expr: _NameNodes, frame: nodes.LocalsDictNodeNG ) -> dict[nodes.If, set[Constraint]]: """Returns the constraints for the given expression. The returned dictionary maps the node where the constraint was generated to the corresponding constraint(s). Constraints are computed statically by analysing the code surrounding expr. Currently this only supports constraints generated from if conditions. """ current_node: nodes.NodeNG \| None = expr constraints_mapping: dict[nodes.If, set[Constraint]] = {} while current_node is not None and current_node is not frame: parent = current_node.parent if isinstance(parent, nodes.If): branch, _ = parent.locate_child(current_node) constraints: set[Constraint] \| None = None if branch == "body": constraints = set(_match_constraint(expr, parent.test)) elif branch == "orelse": constraints = set(_match_constraint(expr, parent.test, invert=True)) if constraints: constraints_mapping[parent] = constraints current_node = parent return constraints_mapping ALL_CONSTRAINT_CLASSES = frozenset((NoneConstraint,)) """All supported constraint types.""" def _matches(node1: nodes.NodeNG \| bases.Proxy, node2: nodes.NodeNG) -> bool: """Returns True if the two nodes match.""" if isinstance(node1, nodes.Name) and isinstance(node2, nodes.Name): return node1.name == node2.name if isinstance(node1, nodes.Attribute) and isinstance(node2, nodes.Attribute): return node1.attrname == node2.attrname and _matches(node1.expr, node2.expr) if isinstance(node1, nodes.Const) and isinstance(node2, nodes.Const): return node1.value == node2.value return False def _match_constraint( node: _NameNodes, expr: nodes.NodeNG, invert: bool = False ) -> Iterator[Constraint]: """Yields all constraint patterns for node that match.""" for constraint_cls in ALL_CONSTRAINT_CLASSES: constraint = constraint_cls.match(node, expr, invert) if constraint: yield constraint	4.92 KB	2026-01-20 12:58
📄 context.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Various context related utilities, including inference and call contexts.""" from __future__ import annotations import contextlib import pprint from typing import TYPE_CHECKING, Dict, Optional, Sequence, Tuple if TYPE_CHECKING: from astroid import constraint, nodes from astroid.nodes.node_classes import Keyword, NodeNG _InferenceCache = Dict[ Tuple["NodeNG", Optional[str], Optional[str], Optional[str]], Sequence["NodeNG"] ] _INFERENCE_CACHE: _InferenceCache = {} def _invalidate_cache() -> None: _INFERENCE_CACHE.clear() class InferenceContext: """Provide context for inference. Store already inferred nodes to save time Account for already visited nodes to stop infinite recursion """ __slots__ = ( "path", "lookupname", "callcontext", "boundnode", "extra_context", "constraints", "_nodes_inferred", ) max_inferred = 100 def __init__( self, path=None, nodes_inferred: list[int] \| None = None, ): if nodes_inferred is None: self._nodes_inferred = [0] else: self._nodes_inferred = nodes_inferred self.path = path or set() """ :type: set(tuple(NodeNG, optional(str))) Path of visited nodes and their lookupname Currently this key is ``(node, context.lookupname)`` """ self.lookupname: str \| None = None """The original name of the node. e.g. foo = 1 The inference of 'foo' is nodes.Const(1) but the lookup name is 'foo' """ self.callcontext: CallContext \| None = None """The call arguments and keywords for the given context.""" self.boundnode = None """ :type: optional[NodeNG] The bound node of the given context e.g. the bound node of object.__new__(cls) is the object node """ self.extra_context = {} """ :type: dict(NodeNG, Context) Context that needs to be passed down through call stacks for call arguments """ self.constraints: dict[str, dict[nodes.If, set[constraint.Constraint]]] = {} """The constraints on nodes.""" @property def nodes_inferred(self) -> int: """ Number of nodes inferred in this context and all its clones/descendents. Wrap inner value in a mutable cell to allow for mutating a class variable in the presence of __slots__ """ return self._nodes_inferred[0] @nodes_inferred.setter def nodes_inferred(self, value: int) -> None: self._nodes_inferred[0] = value @property def inferred(self) -> _InferenceCache: """ Inferred node contexts to their mapped results. Currently the key is ``(node, lookupname, callcontext, boundnode)`` and the value is tuple of the inferred results """ return _INFERENCE_CACHE def push(self, node) -> bool: """Push node into inference path. :return: Whether node is already in context path. Allows one to see if the given node has already been looked at for this inference context """ name = self.lookupname if (node, name) in self.path: return True self.path.add((node, name)) return False def clone(self) -> InferenceContext: """Clone inference path. For example, each side of a binary operation (BinOp) starts with the same context but diverge as each side is inferred so the InferenceContext will need be cloned """ # XXX copy lookupname/callcontext ? clone = InferenceContext(self.path.copy(), nodes_inferred=self._nodes_inferred) clone.callcontext = self.callcontext clone.boundnode = self.boundnode clone.extra_context = self.extra_context clone.constraints = self.constraints.copy() return clone @contextlib.contextmanager def restore_path(self): path = set(self.path) yield self.path = path def __str__(self) -> str: state = ( f"{field}={pprint.pformat(getattr(self, field), width=80 - len(field))}" for field in self.__slots__ ) return "{}({})".format(type(self).__name__, ",\n ".join(state)) class CallContext: """Holds information for a call site.""" __slots__ = ("args", "keywords", "callee") def __init__( self, args: list[NodeNG], keywords: list[Keyword] \| None = None, callee: NodeNG \| None = None, ): self.args = args # Call positional arguments if keywords: arg_value_pairs = [(arg.arg, arg.value) for arg in keywords] else: arg_value_pairs = [] self.keywords = arg_value_pairs # Call keyword arguments self.callee = callee # Function being called def copy_context(context: InferenceContext \| None) -> InferenceContext: """Clone a context if given, or return a fresh context.""" if context is not None: return context.clone() return InferenceContext() def bind_context_to_node(context: InferenceContext \| None, node) -> InferenceContext: """Give a context a boundnode to retrieve the correct function name or attribute value with from further inference. Do not use an existing context since the boundnode could then be incorrectly propagated higher up in the call stack. :param node: Node to do name lookups from :type node NodeNG: :returns: A new context :rtype: InferenceContext """ context = copy_context(context) context.boundnode = node return context	5.85 KB	2026-01-20 12:58
📄 decorators.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """A few useful function/method decorators.""" from __future__ import annotations import functools import inspect import sys import warnings from collections.abc import Callable, Generator from typing import TypeVar import wrapt from astroid import _cache, util from astroid.context import InferenceContext from astroid.exceptions import InferenceError if sys.version_info >= (3, 10): from typing import ParamSpec else: from typing_extensions import ParamSpec _R = TypeVar("_R") _P = ParamSpec("_P") @wrapt.decorator def cached(func, instance, args, kwargs): """Simple decorator to cache result of method calls without args.""" cache = getattr(instance, "__cache", None) if cache is None: instance.__cache = cache = {} _cache.CACHE_MANAGER.add_dict_cache(cache) try: return cache[func] except KeyError: cache[func] = result = func(args, kwargs) return result # TODO: Remove when support for 3.7 is dropped # TODO: astroid 3.0 -> move class behind sys.version_info < (3, 8) guard class cachedproperty: """Provides a cached property equivalent to the stacking of @cached and @property, but more efficient. After first usage, the <property_name> becomes part of the object's __dict__. Doing: del obj.<property_name> empties the cache. Idea taken from the pyramid_ framework and the mercurial_ project. .. _pyramid: http://pypi.python.org/pypi/pyramid .. _mercurial: http://pypi.python.org/pypi/Mercurial """ __slots__ = ("wrapped",) def __init__(self, wrapped): if sys.version_info >= (3, 8): warnings.warn( "cachedproperty has been deprecated and will be removed in astroid 3.0 for Python 3.8+. " "Use functools.cached_property instead.", DeprecationWarning, stacklevel=2, ) try: wrapped.__name__ except AttributeError as exc: raise TypeError(f"{wrapped} must have a __name__ attribute") from exc self.wrapped = wrapped @property def __doc__(self): doc = getattr(self.wrapped, "__doc__", None) return "<wrapped by the cachedproperty decorator>%s" % ( "\n%s" % doc if doc else "" ) def __get__(self, inst, objtype=None): if inst is None: return self val = self.wrapped(inst) setattr(inst, self.wrapped.__name__, val) return val def path_wrapper(func): """Return the given infer function wrapped to handle the path. Used to stop inference if the node has already been looked at for a given `InferenceContext` to prevent infinite recursion """ @functools.wraps(func) def wrapped( node, context: InferenceContext \| None = None, _func=func, kwargs ) -> Generator: """Wrapper function handling context.""" if context is None: context = InferenceContext() if context.push(node): return yielded = set() for res in _func(node, context, kwargs): # unproxy only true instance, not const, tuple, dict... if res.__class__.__name__ == "Instance": ares = res._proxied else: ares = res if ares not in yielded: yield res yielded.add(ares) return wrapped @wrapt.decorator def yes_if_nothing_inferred(func, instance, args, kwargs): generator = func(args, *kwargs) try: yield next(generator) except StopIteration: # generator is empty yield util.Uninferable return yield from generator @wrapt.decorator def raise_if_nothing_inferred(func, instance, args, kwargs): generator = func(args, kwargs) try: yield next(generator) except StopIteration as error: # generator is empty if error.args: # pylint: disable=not-a-mapping raise InferenceError(error.args[0]) from error raise InferenceError( "StopIteration raised without any error information." ) from error except RecursionError as error: raise InferenceError( f"RecursionError raised with limit {sys.getrecursionlimit()}." ) from error yield from generator # Expensive decorators only used to emit Deprecation warnings. # If no other than the default DeprecationWarning are enabled, # fall back to passthrough implementations. if util.check_warnings_filter(): # noqa: C901 def deprecate_default_argument_values( astroid_version: str = "3.0", *arguments: str ) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: """Decorator which emits a DeprecationWarning if any arguments specified are None or not passed at all. Arguments should be a key-value mapping, with the key being the argument to check and the value being a type annotation as string for the value of the argument. To improve performance, only used when DeprecationWarnings other than the default one are enabled. """ # Helpful links # Decorator for DeprecationWarning: https://stackoverflow.com/a/49802489 # Typing of stacked decorators: https://stackoverflow.com/a/68290080 def deco(func: Callable[_P, _R]) -> Callable[_P, _R]: """Decorator function.""" @functools.wraps(func) def wrapper(args: _P.args, *kwargs: _P.kwargs) -> _R: """Emit DeprecationWarnings if conditions are met.""" keys = list(inspect.signature(func).parameters.keys()) for arg, type_annotation in arguments.items(): try: index = keys.index(arg) except ValueError: raise ValueError( f"Can't find argument '{arg}' for '{args[0].__class__.__qualname__}'" ) from None if ( # Check kwargs # - if found, check it's not None (arg in kwargs and kwargs[arg] is None) # Check args # - make sure not in kwargs # - len(args) needs to be long enough, if too short # arg can't be in args either # - args[index] should not be None or arg not in kwargs and ( index == -1 or len(args) <= index or (len(args) > index and args[index] is None) ) ): warnings.warn( f"'{arg}' will be a required argument for " f"'{args[0].__class__.__qualname__}.{func.__name__}'" f" in astroid {astroid_version} " f"('{arg}' should be of type: '{type_annotation}')", DeprecationWarning, stacklevel=2, ) return func(args, kwargs) return wrapper return deco def deprecate_arguments( astroid_version: str = "3.0", arguments: str ) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: """Decorator which emits a DeprecationWarning if any arguments specified are passed. Arguments should be a key-value mapping, with the key being the argument to check and the value being a string that explains what to do instead of passing the argument. To improve performance, only used when DeprecationWarnings other than the default one are enabled. """ def deco(func: Callable[_P, _R]) -> Callable[_P, _R]: @functools.wraps(func) def wrapper(args: _P.args, kwargs: _P.kwargs) -> _R: keys = list(inspect.signature(func).parameters.keys()) for arg, note in arguments.items(): try: index = keys.index(arg) except ValueError: raise ValueError( f"Can't find argument '{arg}' for '{args[0].__class__.__qualname__}'" ) from None if arg in kwargs or len(args) > index: warnings.warn( f"The argument '{arg}' for " f"'{args[0].__class__.__qualname__}.{func.__name__}' is deprecated " f"and will be removed in astroid {astroid_version} ({note})", DeprecationWarning, stacklevel=2, ) return func(args, kwargs) return wrapper return deco else: def deprecate_default_argument_values( astroid_version: str = "3.0", arguments: str ) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: """Passthrough decorator to improve performance if DeprecationWarnings are disabled. """ def deco(func: Callable[_P, _R]) -> Callable[_P, _R]: """Decorator function.""" return func return deco def deprecate_arguments( astroid_version: str = "3.0", **arguments: str ) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: """Passthrough decorator to improve performance if DeprecationWarnings are disabled. """ def deco(func: Callable[_P, _R]) -> Callable[_P, _R]: """Decorator function.""" return func return deco	9.85 KB	2026-01-20 12:58
📄 exceptions.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """This module contains exceptions used in the astroid library.""" from __future__ import annotations from collections.abc import Sequence from typing import TYPE_CHECKING, Any from astroid import util if TYPE_CHECKING: from astroid import arguments, bases, nodes, objects from astroid.context import InferenceContext __all__ = ( "AstroidBuildingError", "AstroidBuildingException", "AstroidError", "AstroidImportError", "AstroidIndexError", "AstroidSyntaxError", "AstroidTypeError", "AstroidValueError", "AttributeInferenceError", "BinaryOperationError", "DuplicateBasesError", "InconsistentMroError", "InferenceError", "InferenceOverwriteError", "MroError", "NameInferenceError", "NoDefault", "NotFoundError", "OperationError", "ParentMissingError", "ResolveError", "StatementMissing", "SuperArgumentTypeError", "SuperError", "TooManyLevelsError", "UnaryOperationError", "UnresolvableName", "UseInferenceDefault", ) class AstroidError(Exception): """Base exception class for all astroid related exceptions. AstroidError and its subclasses are structured, intended to hold objects representing state when the exception is thrown. Field values are passed to the constructor as keyword-only arguments. Each subclass has its own set of standard fields, but use your best judgment to decide whether a specific exception instance needs more or fewer fields for debugging. Field values may be used to lazily generate the error message: self.message.format() will be called with the field names and values supplied as keyword arguments. """ def __init__(self, message: str = "", kws: Any) -> None: super().__init__(message) self.message = message for key, value in kws.items(): setattr(self, key, value) def __str__(self) -> str: return self.message.format(vars(self)) class AstroidBuildingError(AstroidError): """Exception class when we are unable to build an astroid representation. Standard attributes: modname: Name of the module that AST construction failed for. error: Exception raised during construction. """ def __init__( self, message: str = "Failed to import module {modname}.", modname: str \| None = None, error: Exception \| None = None, source: str \| None = None, path: str \| None = None, cls: type \| None = None, class_repr: str \| None = None, kws: Any, ) -> None: self.modname = modname self.error = error self.source = source self.path = path self.cls = cls self.class_repr = class_repr super().__init__(message, kws) class AstroidImportError(AstroidBuildingError): """Exception class used when a module can't be imported by astroid.""" class TooManyLevelsError(AstroidImportError): """Exception class which is raised when a relative import was beyond the top-level. Standard attributes: level: The level which was attempted. name: the name of the module on which the relative import was attempted. """ def __init__( self, message: str = "Relative import with too many levels " "({level}) for module {name!r}", level: int \| None = None, name: str \| None = None, kws: Any, ) -> None: self.level = level self.name = name super().__init__(message, kws) class AstroidSyntaxError(AstroidBuildingError): """Exception class used when a module can't be parsed.""" def __init__( self, message: str, modname: str \| None, error: Exception, path: str \| None, source: str \| None = None, ) -> None: super().__init__(message, modname, error, source, path) class NoDefault(AstroidError): """Raised by function's `default_value` method when an argument has no default value. Standard attributes: func: Function node. name: Name of argument without a default. """ def __init__( self, message: str = "{func!r} has no default for {name!r}.", func: nodes.FunctionDef \| None = None, name: str \| None = None, kws: Any, ) -> None: self.func = func self.name = name super().__init__(message, kws) class ResolveError(AstroidError): """Base class of astroid resolution/inference error. ResolveError is not intended to be raised. Standard attributes: context: InferenceContext object. """ def __init__( self, message: str = "", context: InferenceContext \| None = None, kws: Any ) -> None: self.context = context super().__init__(message, kws) class MroError(ResolveError): """Error raised when there is a problem with method resolution of a class. Standard attributes: mros: A sequence of sequences containing ClassDef nodes. cls: ClassDef node whose MRO resolution failed. context: InferenceContext object. """ def __init__( self, message: str, mros: list[nodes.ClassDef], cls: nodes.ClassDef, context: InferenceContext \| None = None, kws: Any, ) -> None: self.mros = mros self.cls = cls self.context = context super().__init__(message, kws) def __str__(self) -> str: mro_names = ", ".join(f"({', '.join(b.name for b in m)})" for m in self.mros) return self.message.format(mros=mro_names, cls=self.cls) class DuplicateBasesError(MroError): """Error raised when there are duplicate bases in the same class bases.""" class InconsistentMroError(MroError): """Error raised when a class's MRO is inconsistent.""" class SuperError(ResolveError): """Error raised when there is a problem with a super call. Standard attributes: super_: The Super instance that raised the exception. context: InferenceContext object. """ def __init__(self, message: str, super_: objects.Super, kws: Any) -> None: self.super_ = super_ super().__init__(message, kws) def __str__(self) -> str: return self.message.format(vars(self.super_)) class InferenceError(ResolveError): # pylint: disable=too-many-instance-attributes """Raised when we are unable to infer a node. Standard attributes: node: The node inference was called on. context: InferenceContext object. """ def __init__( # pylint: disable=too-many-arguments self, message: str = "Inference failed for {node!r}.", node: nodes.NodeNG \| bases.Instance \| None = None, context: InferenceContext \| None = None, target: nodes.NodeNG \| bases.Instance \| None = None, targets: nodes.Tuple \| None = None, attribute: str \| None = None, unknown: nodes.NodeNG \| bases.Instance \| None = None, assign_path: list[int] \| None = None, caller: nodes.Call \| None = None, stmts: Sequence[nodes.NodeNG \| bases.Instance] \| None = None, frame: nodes.LocalsDictNodeNG \| None = None, call_site: arguments.CallSite \| None = None, func: nodes.FunctionDef \| None = None, arg: str \| None = None, positional_arguments: list \| None = None, unpacked_args: list \| None = None, keyword_arguments: dict \| None = None, unpacked_kwargs: dict \| None = None, kws: Any, ) -> None: self.node = node self.context = context self.target = target self.targets = targets self.attribute = attribute self.unknown = unknown self.assign_path = assign_path self.caller = caller self.stmts = stmts self.frame = frame self.call_site = call_site self.func = func self.arg = arg self.positional_arguments = positional_arguments self.unpacked_args = unpacked_args self.keyword_arguments = keyword_arguments self.unpacked_kwargs = unpacked_kwargs super().__init__(message, kws) # Why does this inherit from InferenceError rather than ResolveError? # Changing it causes some inference tests to fail. class NameInferenceError(InferenceError): """Raised when a name lookup fails, corresponds to NameError. Standard attributes: name: The name for which lookup failed, as a string. scope: The node representing the scope in which the lookup occurred. context: InferenceContext object. """ def __init__( self, message: str = "{name!r} not found in {scope!r}.", name: str \| None = None, scope: nodes.LocalsDictNodeNG \| None = None, context: InferenceContext \| None = None, kws: Any, ) -> None: self.name = name self.scope = scope self.context = context super().__init__(message, kws) class AttributeInferenceError(ResolveError): """Raised when an attribute lookup fails, corresponds to AttributeError. Standard attributes: target: The node for which lookup failed. attribute: The attribute for which lookup failed, as a string. context: InferenceContext object. """ def __init__( self, message: str = "{attribute!r} not found on {target!r}.", attribute: str = "", target: nodes.NodeNG \| bases.Instance \| None = None, context: InferenceContext \| None = None, mros: list[nodes.ClassDef] \| None = None, super_: nodes.ClassDef \| None = None, cls: nodes.ClassDef \| None = None, kws: Any, ) -> None: self.attribute = attribute self.target = target self.context = context self.mros = mros self.super_ = super_ self.cls = cls super().__init__(message, kws) class UseInferenceDefault(Exception): """Exception to be raised in custom inference function to indicate that it should go back to the default behaviour. """ class _NonDeducibleTypeHierarchy(Exception): """Raised when is_subtype / is_supertype can't deduce the relation between two types. """ class AstroidIndexError(AstroidError): """Raised when an Indexable / Mapping does not have an index / key.""" def __init__( self, message: str = "", node: nodes.NodeNG \| bases.Instance \| None = None, index: nodes.Subscript \| None = None, context: InferenceContext \| None = None, kws: Any, ) -> None: self.node = node self.index = index self.context = context super().__init__(message, kws) class AstroidTypeError(AstroidError): """Raised when a TypeError would be expected in Python code.""" def __init__( self, message: str = "", node: nodes.NodeNG \| bases.Instance \| None = None, index: nodes.Subscript \| None = None, context: InferenceContext \| None = None, kws: Any, ) -> None: self.node = node self.index = index self.context = context super().__init__(message, **kws) class AstroidValueError(AstroidError): """Raised when a ValueError would be expected in Python code.""" class InferenceOverwriteError(AstroidError): """Raised when an inference tip is overwritten. Currently only used for debugging. """ class ParentMissingError(AstroidError): """Raised when a node which is expected to have a parent attribute is missing one. Standard attributes: target: The node for which the parent lookup failed. """ def __init__(self, target: nodes.NodeNG) -> None: self.target = target super().__init__(message=f"Parent not found on {target!r}.") class StatementMissing(ParentMissingError): """Raised when a call to node.statement() does not return a node. This is because a node in the chain does not have a parent attribute and therefore does not return a node for statement(). Standard attributes: target: The node for which the parent lookup failed. """ def __init__(self, target: nodes.NodeNG) -> None: super(ParentMissingError, self).__init__( message=f"Statement not found on {target!r}" ) # Backwards-compatibility aliases OperationError = util.BadOperationMessage UnaryOperationError = util.BadUnaryOperationMessage BinaryOperationError = util.BadBinaryOperationMessage SuperArgumentTypeError = SuperError UnresolvableName = NameInferenceError NotFoundError = AttributeInferenceError AstroidBuildingException = AstroidBuildingError	12.78 KB	2026-01-20 12:58
📄 filter_statements.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """_filter_stmts and helper functions. This method gets used in LocalsDictnodes.NodeNG._scope_lookup. It is not considered public. """ from __future__ import annotations from astroid import nodes def _get_filtered_node_statements( base_node: nodes.NodeNG, stmt_nodes: list[nodes.NodeNG] ) -> list[tuple[nodes.NodeNG, nodes.Statement]]: statements = [(node, node.statement(future=True)) for node in stmt_nodes] # Next we check if we have ExceptHandlers that are parent # of the underlying variable, in which case the last one survives if len(statements) > 1 and all( isinstance(stmt, nodes.ExceptHandler) for _, stmt in statements ): statements = [ (node, stmt) for node, stmt in statements if stmt.parent_of(base_node) ] return statements def _is_from_decorator(node) -> bool: """Return whether the given node is the child of a decorator.""" return any(isinstance(parent, nodes.Decorators) for parent in node.node_ancestors()) def _get_if_statement_ancestor(node: nodes.NodeNG) -> nodes.If \| None: """Return the first parent node that is an If node (or None).""" for parent in node.node_ancestors(): if isinstance(parent, nodes.If): return parent return None def _filter_stmts(base_node: nodes.NodeNG, stmts, frame, offset): """Filter the given list of statements to remove ignorable statements. If base_node is not a frame itself and the name is found in the inner frame locals, statements will be filtered to remove ignorable statements according to base_node's location. :param stmts: The statements to filter. :type stmts: list(nodes.NodeNG) :param frame: The frame that all of the given statements belong to. :type frame: nodes.NodeNG :param offset: The line offset to filter statements up to. :type offset: int :returns: The filtered statements. :rtype: list(nodes.NodeNG) """ # if offset == -1, my actual frame is not the inner frame but its parent # # class A(B): pass # # we need this to resolve B correctly if offset == -1: myframe = base_node.frame().parent.frame() else: myframe = base_node.frame() # If the frame of this node is the same as the statement # of this node, then the node is part of a class or # a function definition and the frame of this node should be the # the upper frame, not the frame of the definition. # For more information why this is important, # see Pylint issue #295. # For example, for 'b', the statement is the same # as the frame / scope: # # def test(b=1): # ... if ( base_node.parent and base_node.statement(future=True) is myframe and myframe.parent ): myframe = myframe.parent.frame() mystmt: nodes.Statement \| None = None if base_node.parent: mystmt = base_node.statement(future=True) # line filtering if we are in the same frame # # take care node may be missing lineno information (this is the case for # nodes inserted for living objects) if myframe is frame and mystmt and mystmt.fromlineno is not None: assert mystmt.fromlineno is not None, mystmt mylineno = mystmt.fromlineno + offset else: # disabling lineno filtering mylineno = 0 _stmts = [] _stmt_parents = [] statements = _get_filtered_node_statements(base_node, stmts) for node, stmt in statements: # line filtering is on and we have reached our location, break if stmt.fromlineno and stmt.fromlineno > mylineno > 0: break # Ignore decorators with the same name as the # decorated function # Fixes issue #375 if mystmt is stmt and _is_from_decorator(base_node): continue if node.has_base(base_node): break if isinstance(node, nodes.EmptyNode): # EmptyNode does not have assign_type(), so just add it and move on _stmts.append(node) continue assign_type = node.assign_type() _stmts, done = assign_type._get_filtered_stmts(base_node, node, _stmts, mystmt) if done: break optional_assign = assign_type.optional_assign if optional_assign and assign_type.parent_of(base_node): # we are inside a loop, loop var assignment is hiding previous # assignment _stmts = [node] _stmt_parents = [stmt.parent] continue if isinstance(assign_type, nodes.NamedExpr): # If the NamedExpr is in an if statement we do some basic control flow inference if_parent = _get_if_statement_ancestor(assign_type) if if_parent: # If the if statement is within another if statement we append the node # to possible statements if _get_if_statement_ancestor(if_parent): optional_assign = False _stmts.append(node) _stmt_parents.append(stmt.parent) # If the if statement is first-level and not within an orelse block # we know that it will be evaluated elif not if_parent.is_orelse: _stmts = [node] _stmt_parents = [stmt.parent] # Else we do not known enough about the control flow to be 100% certain # and we append to possible statements else: _stmts.append(node) _stmt_parents.append(stmt.parent) else: _stmts = [node] _stmt_parents = [stmt.parent] # XXX comment various branches below!!! try: pindex = _stmt_parents.index(stmt.parent) except ValueError: pass else: # we got a parent index, this means the currently visited node # is at the same block level as a previously visited node if _stmts[pindex].assign_type().parent_of(assign_type): # both statements are not at the same block level continue # if currently visited node is following previously considered # assignment and both are not exclusive, we can drop the # previous one. For instance in the following code :: # # if a: # x = 1 # else: # x = 2 # print x # # we can't remove neither x = 1 nor x = 2 when looking for 'x' # of 'print x'; while in the following :: # # x = 1 # x = 2 # print x # # we can remove x = 1 when we see x = 2 # # moreover, on loop assignment types, assignment won't # necessarily be done if the loop has no iteration, so we don't # want to clear previous assignments if any (hence the test on # optional_assign) if not (optional_assign or nodes.are_exclusive(_stmts[pindex], node)): del _stmt_parents[pindex] del _stmts[pindex] # If base_node and node are exclusive, then we can ignore node if nodes.are_exclusive(base_node, node): continue # An AssignName node overrides previous assignments if: # 1. node's statement always assigns # 2. node and base_node are in the same block (i.e., has the same parent as base_node) if isinstance(node, (nodes.NamedExpr, nodes.AssignName)): if isinstance(stmt, nodes.ExceptHandler): # If node's statement is an ExceptHandler, then it is the variable # bound to the caught exception. If base_node is not contained within # the exception handler block, node should override previous assignments; # otherwise, node should be ignored, as an exception variable # is local to the handler block. if stmt.parent_of(base_node): _stmts = [] _stmt_parents = [] else: continue elif not optional_assign and mystmt and stmt.parent is mystmt.parent: _stmts = [] _stmt_parents = [] elif isinstance(node, nodes.DelName): # Remove all previously stored assignments _stmts = [] _stmt_parents = [] continue # Add the new assignment _stmts.append(node) if isinstance(node, nodes.Arguments) or isinstance( node.parent, nodes.Arguments ): # Special case for _stmt_parents when node is a function parameter; # in this case, stmt is the enclosing FunctionDef, which is what we # want to add to _stmt_parents, not stmt.parent. This case occurs when # node is an Arguments node (representing varargs or kwargs parameter), # and when node.parent is an Arguments node (other parameters). # See issue #180. _stmt_parents.append(stmt) else: _stmt_parents.append(stmt.parent) return _stmts	9.42 KB	2026-01-20 12:58
📄 helpers.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Various helper utilities.""" from __future__ import annotations from collections.abc import Generator from astroid import bases, manager, nodes, objects, raw_building, util from astroid.context import CallContext, InferenceContext from astroid.exceptions import ( AstroidTypeError, AttributeInferenceError, InferenceError, MroError, _NonDeducibleTypeHierarchy, ) from astroid.nodes import scoped_nodes from astroid.typing import InferenceResult, SuccessfulInferenceResult def _build_proxy_class(cls_name: str, builtins: nodes.Module) -> nodes.ClassDef: proxy = raw_building.build_class(cls_name) proxy.parent = builtins return proxy def _function_type( function: nodes.Lambda \| bases.UnboundMethod, builtins: nodes.Module ) -> nodes.ClassDef: if isinstance(function, scoped_nodes.Lambda): if function.root().name == "builtins": cls_name = "builtin_function_or_method" else: cls_name = "function" elif isinstance(function, bases.BoundMethod): cls_name = "method" else: cls_name = "function" return _build_proxy_class(cls_name, builtins) def _object_type( node: SuccessfulInferenceResult, context: InferenceContext \| None = None ) -> Generator[InferenceResult \| None, None, None]: astroid_manager = manager.AstroidManager() builtins = astroid_manager.builtins_module context = context or InferenceContext() for inferred in node.infer(context=context): if isinstance(inferred, scoped_nodes.ClassDef): if inferred.newstyle: metaclass = inferred.metaclass(context=context) if metaclass: yield metaclass continue yield builtins.getattr("type")[0] elif isinstance(inferred, (scoped_nodes.Lambda, bases.UnboundMethod)): yield _function_type(inferred, builtins) elif isinstance(inferred, scoped_nodes.Module): yield _build_proxy_class("module", builtins) elif isinstance(inferred, nodes.Unknown): raise InferenceError elif isinstance(inferred, util.UninferableBase): yield inferred elif isinstance(inferred, (bases.Proxy, nodes.Slice, objects.Super)): yield inferred._proxied else: # pragma: no cover raise AssertionError(f"We don't handle {type(inferred)} currently") def object_type( node: SuccessfulInferenceResult, context: InferenceContext \| None = None ) -> InferenceResult \| None: """Obtain the type of the given node. This is used to implement the ``type`` builtin, which means that it's used for inferring type calls, as well as used in a couple of other places in the inference. The node will be inferred first, so this function can support all sorts of objects, as long as they support inference. """ try: types = set(_object_type(node, context)) except InferenceError: return util.Uninferable if len(types) > 1 or not types: return util.Uninferable return list(types)[0] def _object_type_is_subclass( obj_type, class_or_seq, context: InferenceContext \| None = None ): if not isinstance(class_or_seq, (tuple, list)): class_seq = (class_or_seq,) else: class_seq = class_or_seq if isinstance(obj_type, util.UninferableBase): return util.Uninferable # Instances are not types class_seq = [ item if not isinstance(item, bases.Instance) else util.Uninferable for item in class_seq ] # strict compatibility with issubclass # issubclass(type, (object, 1)) evaluates to true # issubclass(object, (1, type)) raises TypeError for klass in class_seq: if isinstance(klass, util.UninferableBase): raise AstroidTypeError("arg 2 must be a type or tuple of types") for obj_subclass in obj_type.mro(): if obj_subclass == klass: return True return False def object_isinstance(node, class_or_seq, context: InferenceContext \| None = None): """Check if a node 'isinstance' any node in class_or_seq. :param node: A given node :param class_or_seq: Union[nodes.NodeNG, Sequence[nodes.NodeNG]] :rtype: bool :raises AstroidTypeError: if the given ``classes_or_seq`` are not types """ obj_type = object_type(node, context) if isinstance(obj_type, util.UninferableBase): return util.Uninferable return _object_type_is_subclass(obj_type, class_or_seq, context=context) def object_issubclass(node, class_or_seq, context: InferenceContext \| None = None): """Check if a type is a subclass of any node in class_or_seq. :param node: A given node :param class_or_seq: Union[Nodes.NodeNG, Sequence[nodes.NodeNG]] :rtype: bool :raises AstroidTypeError: if the given ``classes_or_seq`` are not types :raises AstroidError: if the type of the given node cannot be inferred or its type's mro doesn't work """ if not isinstance(node, nodes.ClassDef): raise TypeError(f"{node} needs to be a ClassDef node") return _object_type_is_subclass(node, class_or_seq, context=context) def safe_infer( node: nodes.NodeNG \| bases.Proxy, context: InferenceContext \| None = None ) -> InferenceResult \| None: """Return the inferred value for the given node. Return None if inference failed or if there is some ambiguity (more than one node has been inferred). """ try: inferit = node.infer(context=context) value = next(inferit) except (InferenceError, StopIteration): return None try: next(inferit) return None # None if there is ambiguity on the inferred node except InferenceError: return None # there is some kind of ambiguity except StopIteration: return value def has_known_bases(klass, context: InferenceContext \| None = None) -> bool: """Return whether all base classes of a class could be inferred.""" try: return klass._all_bases_known except AttributeError: pass for base in klass.bases: result = safe_infer(base, context=context) # TODO: check for A->B->A->B pattern in class structure too? if ( not isinstance(result, scoped_nodes.ClassDef) or result is klass or not has_known_bases(result, context=context) ): klass._all_bases_known = False return False klass._all_bases_known = True return True def _type_check(type1, type2) -> bool: if not all(map(has_known_bases, (type1, type2))): raise _NonDeducibleTypeHierarchy if not all([type1.newstyle, type2.newstyle]): return False try: return type1 in type2.mro()[:-1] except MroError as e: # The MRO is invalid. raise _NonDeducibleTypeHierarchy from e def is_subtype(type1, type2) -> bool: """Check if type1 is a subtype of type2.""" return _type_check(type1=type2, type2=type1) def is_supertype(type1, type2) -> bool: """Check if type2 is a supertype of type1.""" return _type_check(type1, type2) def class_instance_as_index(node: SuccessfulInferenceResult) -> nodes.Const \| None: """Get the value as an index for the given instance. If an instance provides an __index__ method, then it can be used in some scenarios where an integer is expected, for instance when multiplying or subscripting a list. """ context = InferenceContext() try: for inferred in node.igetattr("__index__", context=context): if not isinstance(inferred, bases.BoundMethod): continue context.boundnode = node context.callcontext = CallContext(args=[], callee=inferred) for result in inferred.infer_call_result(node, context=context): if isinstance(result, nodes.Const) and isinstance(result.value, int): return result except InferenceError: pass return None def object_len(node, context: InferenceContext \| None = None): """Infer length of given node object. :param Union[nodes.ClassDef, nodes.Instance] node: :param node: Node to infer length of :raises AstroidTypeError: If an invalid node is returned from __len__ method or no __len__ method exists :raises InferenceError: If the given node cannot be inferred or if multiple nodes are inferred or if the code executed in python would result in a infinite recursive check for length :rtype int: Integer length of node """ # pylint: disable=import-outside-toplevel; circular import from astroid.objects import FrozenSet inferred_node = safe_infer(node, context=context) # prevent self referential length calls from causing a recursion error # see https://github.com/PyCQA/astroid/issues/777 node_frame = node.frame(future=True) if ( isinstance(node_frame, scoped_nodes.FunctionDef) and node_frame.name == "__len__" and hasattr(inferred_node, "_proxied") and inferred_node._proxied == node_frame.parent ): message = ( "Self referential __len__ function will " "cause a RecursionError on line {} of {}".format( node.lineno, node.root().file ) ) raise InferenceError(message) if inferred_node is None or isinstance(inferred_node, util.UninferableBase): raise InferenceError(node=node) if isinstance(inferred_node, nodes.Const) and isinstance( inferred_node.value, (bytes, str) ): return len(inferred_node.value) if isinstance(inferred_node, (nodes.List, nodes.Set, nodes.Tuple, FrozenSet)): return len(inferred_node.elts) if isinstance(inferred_node, nodes.Dict): return len(inferred_node.items) node_type = object_type(inferred_node, context=context) if not node_type: raise InferenceError(node=node) try: len_call = next(node_type.igetattr("__len__", context=context)) except StopIteration as e: raise AstroidTypeError(str(e)) from e except AttributeInferenceError as e: raise AstroidTypeError( f"object of type '{node_type.pytype()}' has no len()" ) from e inferred = len_call.infer_call_result(node, context) if isinstance(inferred, util.UninferableBase): raise InferenceError(node=node, context=context) result_of_len = next(inferred, None) if ( isinstance(result_of_len, nodes.Const) and result_of_len.pytype() == "builtins.int" ): return result_of_len.value if ( result_of_len is None or isinstance(result_of_len, bases.Instance) and result_of_len.is_subtype_of("builtins.int") ): # Fake a result as we don't know the arguments of the instance call. return 0 raise AstroidTypeError( f"'{result_of_len}' object cannot be interpreted as an integer" )	11.07 KB	2026-01-20 12:58
📄 inference.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """This module contains a set of functions to handle inference on astroid trees.""" from __future__ import annotations import ast import functools import itertools import operator import typing from collections.abc import Callable, Generator, Iterable, Iterator from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union from astroid import bases, constraint, decorators, helpers, nodes, protocols, util from astroid.const import PY310_PLUS from astroid.context import ( CallContext, InferenceContext, bind_context_to_node, copy_context, ) from astroid.exceptions import ( AstroidBuildingError, AstroidError, AstroidIndexError, AstroidTypeError, AstroidValueError, AttributeInferenceError, InferenceError, NameInferenceError, _NonDeducibleTypeHierarchy, ) from astroid.interpreter import dunder_lookup from astroid.manager import AstroidManager from astroid.typing import ( InferenceErrorInfo, InferenceResult, SuccessfulInferenceResult, ) if TYPE_CHECKING: from astroid.objects import Property # Prevents circular imports objects = util.lazy_import("objects") _T = TypeVar("_T") _BaseContainerT = TypeVar("_BaseContainerT", bound=nodes.BaseContainer) _FunctionDefT = TypeVar("_FunctionDefT", bound=nodes.FunctionDef) GetFlowFactory = typing.Callable[ [ InferenceResult, Optional[InferenceResult], Union[nodes.AugAssign, nodes.BinOp], InferenceResult, Optional[InferenceResult], InferenceContext, InferenceContext, ], "list[functools.partial[Generator[InferenceResult, None, None]]]", ] # .infer method ############################################################### def infer_end( self: _T, context: InferenceContext \| None = None, kwargs: Any ) -> Iterator[_T]: """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. """ yield self # We add ignores to all assignments to methods # See https://github.com/python/mypy/issues/2427 nodes.Module._infer = infer_end nodes.ClassDef._infer = infer_end nodes.Lambda._infer = infer_end # type: ignore[assignment] nodes.Const._infer = infer_end # type: ignore[assignment] nodes.Slice._infer = infer_end # type: ignore[assignment] def _infer_sequence_helper( node: _BaseContainerT, context: InferenceContext \| None = None ) -> list[SuccessfulInferenceResult]: """Infer all values based on _BaseContainer.elts.""" values = [] for elt in node.elts: if isinstance(elt, nodes.Starred): starred = helpers.safe_infer(elt.value, context) if not starred: raise InferenceError(node=node, context=context) if not hasattr(starred, "elts"): raise InferenceError(node=node, context=context) values.extend(_infer_sequence_helper(starred)) elif isinstance(elt, nodes.NamedExpr): value = helpers.safe_infer(elt.value, context) if not value: raise InferenceError(node=node, context=context) values.append(value) else: values.append(elt) return values @decorators.raise_if_nothing_inferred def infer_sequence( self: _BaseContainerT, context: InferenceContext \| None = None, kwargs: Any, ) -> Iterator[_BaseContainerT]: has_starred_named_expr = any( isinstance(e, (nodes.Starred, nodes.NamedExpr)) for e in self.elts ) if has_starred_named_expr: values = _infer_sequence_helper(self, context) new_seq = type(self)( lineno=self.lineno, col_offset=self.col_offset, parent=self.parent ) new_seq.postinit(values) yield new_seq else: yield self nodes.List._infer = infer_sequence # type: ignore[assignment] nodes.Tuple._infer = infer_sequence # type: ignore[assignment] nodes.Set._infer = infer_sequence # type: ignore[assignment] def infer_map( self: nodes.Dict, context: InferenceContext \| None = None ) -> Iterator[nodes.Dict]: if not any(isinstance(k, nodes.DictUnpack) for k, _ in self.items): yield self else: items = _infer_map(self, context) new_seq = type(self)(self.lineno, self.col_offset, self.parent) new_seq.postinit(list(items.items())) yield new_seq def _update_with_replacement( lhs_dict: dict[SuccessfulInferenceResult, SuccessfulInferenceResult], rhs_dict: dict[SuccessfulInferenceResult, SuccessfulInferenceResult], ) -> dict[SuccessfulInferenceResult, SuccessfulInferenceResult]: """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 """ combined_dict = itertools.chain(lhs_dict.items(), rhs_dict.items()) # Overwrite keys which have the same string values string_map = {key.as_string(): (key, value) for key, value in combined_dict} # Return to dictionary return dict(string_map.values()) def _infer_map( node: nodes.Dict, context: InferenceContext \| None ) -> dict[SuccessfulInferenceResult, SuccessfulInferenceResult]: """Infer all values based on Dict.items.""" values: dict[SuccessfulInferenceResult, SuccessfulInferenceResult] = {} for name, value in node.items: if isinstance(name, nodes.DictUnpack): double_starred = helpers.safe_infer(value, context) if not double_starred: raise InferenceError if not isinstance(double_starred, nodes.Dict): raise InferenceError(node=node, context=context) unpack_items = _infer_map(double_starred, context) values = _update_with_replacement(values, unpack_items) else: key = helpers.safe_infer(name, context=context) safe_value = helpers.safe_infer(value, context=context) if any(not elem for elem in (key, safe_value)): raise InferenceError(node=node, context=context) # safe_value is SuccessfulInferenceResult as bool(Uninferable) == False values = _update_with_replacement(values, {key: safe_value}) return values nodes.Dict._infer = infer_map # type: ignore[assignment] def _higher_function_scope(node: nodes.NodeNG) -> nodes.FunctionDef \| None: """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. """ current = node while current.parent and not isinstance(current.parent, nodes.FunctionDef): current = current.parent if current and current.parent: return current.parent # type: ignore[no-any-return] return None def infer_name( self: nodes.Name \| nodes.AssignName, context: InferenceContext \| None = None, kwargs: Any, ) -> Generator[InferenceResult, None, None]: """Infer a Name: use name lookup rules.""" frame, stmts = self.lookup(self.name) if not stmts: # Try to see if the name is enclosed in a nested function # and use the higher (first function) scope for searching. parent_function = _higher_function_scope(self.scope()) if parent_function: _, stmts = parent_function.lookup(self.name) if not stmts: raise NameInferenceError( name=self.name, scope=self.scope(), context=context ) context = copy_context(context) context.lookupname = self.name context.constraints[self.name] = constraint.get_constraints(self, frame) return bases._infer_stmts(stmts, context, frame) # pylint: disable=no-value-for-parameter # The order of the decorators here is important # See https://github.com/PyCQA/astroid/commit/0a8a75db30da060a24922e05048bc270230f5 nodes.Name._infer = decorators.raise_if_nothing_inferred( decorators.path_wrapper(infer_name) ) nodes.AssignName.infer_lhs = infer_name # won't work with a path wrapper @decorators.raise_if_nothing_inferred @decorators.path_wrapper def infer_call( self: nodes.Call, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[InferenceResult, None, InferenceErrorInfo]: """Infer a Call node by trying to guess what the function returns.""" callcontext = copy_context(context) callcontext.boundnode = None if context is not None: callcontext.extra_context = _populate_context_lookup(self, context.clone()) for callee in self.func.infer(context): if isinstance(callee, util.UninferableBase): yield callee continue try: if hasattr(callee, "infer_call_result"): callcontext.callcontext = CallContext( args=self.args, keywords=self.keywords, callee=callee ) yield from callee.infer_call_result(caller=self, context=callcontext) except InferenceError: continue return InferenceErrorInfo(node=self, context=context) nodes.Call._infer = infer_call # type: ignore[assignment] @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]: """Infer an Import node: return the imported module/object.""" context = context or InferenceContext() name = context.lookupname if name is None: raise InferenceError(node=self, context=context) try: if asname: yield self.do_import_module(self.real_name(name)) else: yield self.do_import_module(name) except AstroidBuildingError as exc: raise InferenceError(node=self, context=context) from exc nodes.Import._infer = infer_import @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]: """Infer a ImportFrom node: return the imported module/object.""" context = context or InferenceContext() name = context.lookupname if name is None: raise InferenceError(node=self, context=context) if asname: try: name = self.real_name(name) except AttributeInferenceError as exc: # See https://github.com/PyCQA/pylint/issues/4692 raise InferenceError(node=self, context=context) from exc try: module = self.do_import_module() except AstroidBuildingError as exc: raise InferenceError(node=self, context=context) from exc try: context = copy_context(context) context.lookupname = name stmts = module.getattr(name, ignore_locals=module is self.root()) return bases._infer_stmts(stmts, context) except AttributeInferenceError as error: raise InferenceError( str(error), target=self, attribute=name, context=context ) from error nodes.ImportFrom._infer = infer_import_from # type: ignore[assignment] def infer_attribute( self: nodes.Attribute \| nodes.AssignAttr, context: InferenceContext \| None = None, kwargs: Any, ) -> Generator[InferenceResult, None, InferenceErrorInfo]: """Infer an Attribute node by using getattr on the associated object.""" for owner in self.expr.infer(context): if isinstance(owner, util.UninferableBase): yield owner continue context = copy_context(context) old_boundnode = context.boundnode try: context.boundnode = owner if isinstance(owner, (nodes.ClassDef, bases.Instance)): frame = owner if isinstance(owner, nodes.ClassDef) else owner._proxied context.constraints[self.attrname] = constraint.get_constraints( self, frame=frame ) yield from owner.igetattr(self.attrname, context) except ( AttributeInferenceError, InferenceError, AttributeError, ): pass finally: context.boundnode = old_boundnode return InferenceErrorInfo(node=self, context=context) # The order of the decorators here is important # See https://github.com/PyCQA/astroid/commit/0a8a75db30da060a24922e05048bc270230f5 nodes.Attribute._infer = decorators.raise_if_nothing_inferred( decorators.path_wrapper(infer_attribute) ) # won't work with a path wrapper nodes.AssignAttr.infer_lhs = decorators.raise_if_nothing_inferred(infer_attribute) @decorators.raise_if_nothing_inferred @decorators.path_wrapper def infer_global( self: nodes.Global, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[InferenceResult, None, None]: if context is None or context.lookupname is None: raise InferenceError(node=self, context=context) try: return bases._infer_stmts(self.root().getattr(context.lookupname), context) except AttributeInferenceError as error: raise InferenceError( str(error), target=self, attribute=context.lookupname, context=context ) from error nodes.Global._infer = infer_global # type: ignore[assignment] _SUBSCRIPT_SENTINEL = object() def infer_subscript( self: nodes.Subscript, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[InferenceResult, None, InferenceErrorInfo \| 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. """ found_one = False for value in self.value.infer(context): if isinstance(value, util.UninferableBase): yield util.Uninferable return None for index in self.slice.infer(context): if isinstance(index, util.UninferableBase): yield util.Uninferable return None # Try to deduce the index value. index_value = _SUBSCRIPT_SENTINEL if value.__class__ == bases.Instance: index_value = index elif index.__class__ == bases.Instance: instance_as_index = helpers.class_instance_as_index(index) if instance_as_index: index_value = instance_as_index else: index_value = index if index_value is _SUBSCRIPT_SENTINEL: raise InferenceError(node=self, context=context) try: assigned = value.getitem(index_value, context) except ( AstroidTypeError, AstroidIndexError, AstroidValueError, AttributeInferenceError, AttributeError, ) as exc: raise InferenceError(node=self, context=context) from exc # Prevent inferring if the inferred subscript # is the same as the original subscripted object. if self is assigned or isinstance(assigned, util.UninferableBase): yield util.Uninferable return None yield from assigned.infer(context) found_one = True if found_one: return InferenceErrorInfo(node=self, context=context) return None # The order of the decorators here is important # See https://github.com/PyCQA/astroid/commit/0a8a75db30da060a24922e05048bc270230f5 nodes.Subscript._infer = decorators.raise_if_nothing_inferred( # type: ignore[assignment] decorators.path_wrapper(infer_subscript) ) nodes.Subscript.infer_lhs = decorators.raise_if_nothing_inferred(infer_subscript) @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]: """Infer a boolean operation (and / or / not). The function will calculate the boolean operation for all pairs generated through inference for each component node. """ values = self.values if self.op == "or": predicate = operator.truth else: predicate = operator.not_ try: inferred_values = [value.infer(context=context) for value in values] except InferenceError: yield util.Uninferable return None for pair in itertools.product(inferred_values): if any(isinstance(item, util.UninferableBase) for item in pair): # Can't infer the final result, just yield Uninferable. yield util.Uninferable continue bool_values = [item.bool_value() for item in pair] if any(isinstance(item, util.UninferableBase) for item in bool_values): # Can't infer the final result, just yield Uninferable. yield util.Uninferable continue # Since the boolean operations are short circuited operations, # this code yields the first value for which the predicate is True # and if no value respected the predicate, then the last value will # be returned (or Uninferable if there was no last value). # This is conforming to the semantics of `and` and `or`: # 1 and 0 -> 1 # 0 and 1 -> 0 # 1 or 0 -> 1 # 0 or 1 -> 1 value = util.Uninferable for value, bool_value in zip(pair, bool_values): if predicate(bool_value): yield value break else: yield value return InferenceErrorInfo(node=self, context=context) nodes.BoolOp._infer = _infer_boolop # UnaryOp, BinOp and AugAssign inferences 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]: for result in infer_callable(self, context): if isinstance(result, error): # For the sake of .infer(), we don't care about operation # errors, which is the job of pylint. So return something # which shows that we can't infer the result. yield util.Uninferable else: yield result def _infer_unaryop( self: nodes.UnaryOp, context: InferenceContext \| None = None ) -> Generator[InferenceResult \| util.BadUnaryOperationMessage, None, None]: """Infer what an UnaryOp should return when evaluated.""" for operand in self.operand.infer(context): try: yield operand.infer_unary_op(self.op) except TypeError as exc: # The operand doesn't support this operation. yield util.BadUnaryOperationMessage(operand, self.op, exc) except AttributeError as exc: meth = protocols.UNARY_OP_METHOD[self.op] if meth is None: # `not node`. Determine node's boolean # value and negate its result, unless it is # Uninferable, which will be returned as is. bool_value = operand.bool_value() if not isinstance(bool_value, util.UninferableBase): yield nodes.const_factory(not bool_value) else: yield util.Uninferable else: if not isinstance(operand, (bases.Instance, nodes.ClassDef)): # The operation was used on something which # doesn't support it. yield util.BadUnaryOperationMessage(operand, self.op, exc) continue try: try: methods = dunder_lookup.lookup(operand, meth) except AttributeInferenceError: yield util.BadUnaryOperationMessage(operand, self.op, exc) continue meth = methods[0] inferred = next(meth.infer(context=context), None) if ( isinstance(inferred, util.UninferableBase) or not inferred.callable() ): continue context = copy_context(context) context.boundnode = operand context.callcontext = CallContext(args=[], callee=inferred) call_results = inferred.infer_call_result(self, context=context) result = next(call_results, None) if result is None: # Failed to infer, return the same type. yield operand else: yield result except AttributeInferenceError as inner_exc: # The unary operation special method was not found. yield util.BadUnaryOperationMessage(operand, self.op, inner_exc) except InferenceError: yield util.Uninferable @decorators.raise_if_nothing_inferred @decorators.path_wrapper def infer_unaryop( self: nodes.UnaryOp, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[InferenceResult, None, InferenceErrorInfo]: """Infer what an UnaryOp should return when evaluated.""" yield from _filter_operation_errors( self, _infer_unaryop, context, util.BadUnaryOperationMessage ) return InferenceErrorInfo(node=self, context=context) nodes.UnaryOp._infer_unaryop = _infer_unaryop nodes.UnaryOp._infer = infer_unaryop def _is_not_implemented(const) -> bool: """Check if the given const node is NotImplemented.""" return isinstance(const, nodes.Const) and const.value is NotImplemented def _infer_old_style_string_formatting( instance: nodes.Const, other: nodes.NodeNG, context: InferenceContext ) -> tuple[util.UninferableBase \| nodes.Const]: """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. """ if isinstance(other, nodes.Tuple): if util.Uninferable in other.elts: return (util.Uninferable,) inferred_positional = [helpers.safe_infer(i, context) for i in other.elts] if all(isinstance(i, nodes.Const) for i in inferred_positional): values = tuple(i.value for i in inferred_positional) else: values = None elif isinstance(other, nodes.Dict): values: dict[Any, Any] = {} for pair in other.items: key = helpers.safe_infer(pair[0], context) if not isinstance(key, nodes.Const): return (util.Uninferable,) value = helpers.safe_infer(pair[1], context) if not isinstance(value, nodes.Const): return (util.Uninferable,) values[key.value] = value.value elif isinstance(other, nodes.Const): values = other.value else: return (util.Uninferable,) try: return (nodes.const_factory(instance.value % values),) except (TypeError, KeyError, ValueError): return (util.Uninferable,) def _invoke_binop_inference( instance: InferenceResult, opnode: nodes.AugAssign \| nodes.BinOp, op: str, other: InferenceResult, context: InferenceContext, method_name: str, ) -> Generator[InferenceResult, None, None]: """Invoke binary operation inference on the given instance.""" methods = dunder_lookup.lookup(instance, method_name) context = bind_context_to_node(context, instance) method = methods[0] context.callcontext.callee = method if ( isinstance(instance, nodes.Const) and isinstance(instance.value, str) and op == "%" ): return iter(_infer_old_style_string_formatting(instance, other, context)) try: inferred = next(method.infer(context=context)) except StopIteration as e: raise InferenceError(node=method, context=context) from e if isinstance(inferred, util.UninferableBase): raise InferenceError if not isinstance( instance, (nodes.Const, nodes.Tuple, nodes.List, nodes.ClassDef, bases.Instance) ): raise InferenceError # pragma: no cover # Used as a failsafe return instance.infer_binary_op(opnode, op, other, context, inferred) def _aug_op( instance: InferenceResult, opnode: nodes.AugAssign, op: str, other: InferenceResult, context: InferenceContext, reverse: bool = False, ) -> functools.partial[Generator[InferenceResult, None, None]]: """Get an inference callable for an augmented binary operation.""" method_name = protocols.AUGMENTED_OP_METHOD[op] return functools.partial( _invoke_binop_inference, instance=instance, op=op, opnode=opnode, other=other, context=context, method_name=method_name, ) 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]]: """Get an inference callable for a normal binary operation. If reverse* is True, then the reflected method will be used instead. """ if reverse: method_name = protocols.REFLECTED_BIN_OP_METHOD[op] else: method_name = protocols.BIN_OP_METHOD[op] return functools.partial( _invoke_binop_inference, instance=instance, op=op, opnode=opnode, other=other, context=context, method_name=method_name, ) def _bin_op_or_union_type( left: bases.UnionType \| nodes.ClassDef \| nodes.Const, right: bases.UnionType \| nodes.ClassDef \| nodes.Const, ) -> Generator[InferenceResult, None, None]: """Create a new UnionType instance for binary or, e.g. int \| str.""" yield bases.UnionType(left, right) def _get_binop_contexts(context, left, right): """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. """ # The order is important, since the first one should be # left.__op__(right). for arg in (right, left): new_context = context.clone() new_context.callcontext = CallContext(args=[arg]) new_context.boundnode = None yield new_context def _same_type(type1, type2) -> bool: """Check if type1 is the same as type2.""" return type1.qname() == type2.qname() 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]]]: """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) """ op = binary_opnode.op if _same_type(left_type, right_type): methods = [_bin_op(left, binary_opnode, op, right, context)] elif helpers.is_subtype(left_type, right_type): methods = [_bin_op(left, binary_opnode, op, right, context)] elif helpers.is_supertype(left_type, right_type): methods = [ _bin_op(right, binary_opnode, op, left, reverse_context, reverse=True), _bin_op(left, binary_opnode, op, right, context), ] else: methods = [ _bin_op(left, binary_opnode, op, right, context), _bin_op(right, binary_opnode, op, left, reverse_context, reverse=True), ] if ( PY310_PLUS and op == "\|" and ( isinstance(left, (bases.UnionType, nodes.ClassDef)) or isinstance(left, nodes.Const) and left.value is None ) and ( isinstance(right, (bases.UnionType, nodes.ClassDef)) or isinstance(right, nodes.Const) and right.value is None ) ): methods.extend([functools.partial(_bin_op_or_union_type, left, right)]) return methods 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]]]: """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) """ bin_op = aug_opnode.op.strip("=") aug_op = aug_opnode.op if _same_type(left_type, right_type): methods = [ _aug_op(left, aug_opnode, aug_op, right, context), _bin_op(left, aug_opnode, bin_op, right, context), ] elif helpers.is_subtype(left_type, right_type): methods = [ _aug_op(left, aug_opnode, aug_op, right, context), _bin_op(left, aug_opnode, bin_op, right, context), ] elif helpers.is_supertype(left_type, right_type): methods = [ _aug_op(left, aug_opnode, aug_op, right, context), _bin_op(right, aug_opnode, bin_op, left, reverse_context, reverse=True), _bin_op(left, aug_opnode, bin_op, right, context), ] else: methods = [ _aug_op(left, aug_opnode, aug_op, right, context), _bin_op(left, aug_opnode, bin_op, right, context), _bin_op(right, aug_opnode, bin_op, left, reverse_context, reverse=True), ] return methods 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]: """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. """ context, reverse_context = _get_binop_contexts(context, left, right) left_type = helpers.object_type(left) right_type = helpers.object_type(right) methods = flow_factory( left, left_type, binary_opnode, right, right_type, context, reverse_context ) for method in methods: try: results = list(method()) except AttributeError: continue except AttributeInferenceError: continue except InferenceError: yield util.Uninferable return else: if any(isinstance(result, util.UninferableBase) for result in results): yield util.Uninferable return if all(map(_is_not_implemented, results)): continue not_implemented = sum( 1 for result in results if _is_not_implemented(result) ) if not_implemented and not_implemented != len(results): # Can't infer yet what this is. yield util.Uninferable return yield from results return # The operation doesn't seem to be supported so let the caller know about it yield util.BadBinaryOperationMessage(left_type, binary_opnode.op, right_type) def _infer_binop( self: nodes.BinOp, context: InferenceContext \| None = None ) -> Generator[InferenceResult \| util.BadBinaryOperationMessage, None, None]: """Binary operation inference logic.""" left = self.left right = self.right # we use two separate contexts for evaluating lhs and rhs because # 1. evaluating lhs may leave some undesired entries in context.path # which may not let us infer right value of rhs context = context or InferenceContext() lhs_context = copy_context(context) rhs_context = copy_context(context) lhs_iter = left.infer(context=lhs_context) rhs_iter = right.infer(context=rhs_context) for lhs, rhs in itertools.product(lhs_iter, rhs_iter): if any(isinstance(value, util.UninferableBase) for value in (rhs, lhs)): # Don't know how to process this. yield util.Uninferable return try: yield from _infer_binary_operation(lhs, rhs, self, context, _get_binop_flow) except _NonDeducibleTypeHierarchy: yield util.Uninferable @decorators.yes_if_nothing_inferred @decorators.path_wrapper def infer_binop( self: nodes.BinOp, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[InferenceResult, None, None]: return _filter_operation_errors( self, _infer_binop, context, util.BadBinaryOperationMessage ) nodes.BinOp._infer_binop = _infer_binop nodes.BinOp._infer = infer_binop COMPARE_OPS: dict[str, Callable[[Any, Any], bool]] = { "==": operator.eq, "!=": operator.ne, "<": operator.lt, "<=": operator.le, ">": operator.gt, ">=": operator.ge, "in": lambda a, b: a in b, "not in": lambda a, b: a not in b, } UNINFERABLE_OPS = { "is", "is not", } def _to_literal(node: nodes.NodeNG) -> Any: # Can raise SyntaxError or ValueError from ast.literal_eval # Can raise AttributeError from node.as_string() as not all nodes have a visitor # Is this the stupidest idea or the simplest idea? return ast.literal_eval(node.as_string()) def _do_compare( left_iter: Iterable[nodes.NodeNG], op: str, right_iter: Iterable[nodes.NodeNG] ) -> bool \| util.UninferableBase: """ 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 """ retval: bool \| None = None if op in UNINFERABLE_OPS: return util.Uninferable op_func = COMPARE_OPS[op] for left, right in itertools.product(left_iter, right_iter): if isinstance(left, util.UninferableBase) or isinstance( right, util.UninferableBase ): return util.Uninferable try: left, right = _to_literal(left), _to_literal(right) except (SyntaxError, ValueError, AttributeError): return util.Uninferable try: expr = op_func(left, right) except TypeError as exc: raise AstroidTypeError from exc if retval is None: retval = expr elif retval != expr: return util.Uninferable # (or both, but "True \| False" is basically the same) assert retval is not None return retval # it was all the same value def _infer_compare( self: nodes.Compare, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[nodes.Const \| util.UninferableBase, None, None]: """Chained comparison inference logic.""" retval: bool \| util.UninferableBase = True ops = self.ops left_node = self.left lhs = list(left_node.infer(context=context)) # should we break early if first element is uninferable? for op, right_node in ops: # eagerly evaluate rhs so that values can be re-used as lhs rhs = list(right_node.infer(context=context)) try: retval = _do_compare(lhs, op, rhs) except AstroidTypeError: retval = util.Uninferable break if retval is not True: break # short-circuit lhs = rhs # continue if retval is util.Uninferable: yield retval # type: ignore[misc] else: yield nodes.Const(retval) nodes.Compare._infer = _infer_compare # type: ignore[assignment] def _infer_augassign( self: nodes.AugAssign, context: InferenceContext \| None = None ) -> Generator[InferenceResult \| util.BadBinaryOperationMessage, None, None]: """Inference logic for augmented binary operations.""" context = context or InferenceContext() rhs_context = context.clone() lhs_iter = self.target.infer_lhs(context=context) rhs_iter = self.value.infer(context=rhs_context) for lhs, rhs in itertools.product(lhs_iter, rhs_iter): if any(isinstance(value, util.UninferableBase) for value in (rhs, lhs)): # Don't know how to process this. yield util.Uninferable return try: yield from _infer_binary_operation( left=lhs, right=rhs, binary_opnode=self, context=context, flow_factory=_get_aug_flow, ) except _NonDeducibleTypeHierarchy: yield util.Uninferable @decorators.raise_if_nothing_inferred @decorators.path_wrapper def infer_augassign( self: nodes.AugAssign, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[InferenceResult, None, None]: return _filter_operation_errors( self, _infer_augassign, context, util.BadBinaryOperationMessage ) nodes.AugAssign._infer_augassign = _infer_augassign nodes.AugAssign._infer = infer_augassign # End of binary operation inference. @decorators.raise_if_nothing_inferred def infer_arguments( self: nodes.Arguments, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[InferenceResult, None, None]: if context is None or context.lookupname is None: raise InferenceError(node=self, context=context) return protocols._arguments_infer_argname(self, context.lookupname, context) nodes.Arguments._infer = infer_arguments # type: ignore[assignment] @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]: """Infer a AssignName/AssignAttr: need to inspect the RHS part of the assign node. """ if isinstance(self.parent, nodes.AugAssign): return self.parent.infer(context) stmts = list(self.assigned_stmts(context=context)) return bases._infer_stmts(stmts, context) nodes.AssignName._infer = infer_assign nodes.AssignAttr._infer = infer_assign @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]: if not self.has_underlying_object(): yield util.Uninferable else: try: yield from AstroidManager().infer_ast_from_something( self.object, context=context ) except AstroidError: yield util.Uninferable nodes.EmptyNode._infer = infer_empty_node # type: ignore[assignment] def _populate_context_lookup(call: nodes.Call, context: InferenceContext \| None): # Allows context to be saved for later # for inference inside a function context_lookup: dict[InferenceResult, InferenceContext] = {} if context is None: return context_lookup for arg in call.args: if isinstance(arg, nodes.Starred): context_lookup[arg.value] = context else: context_lookup[arg] = context keywords = call.keywords if call.keywords is not None else [] for keyword in keywords: context_lookup[keyword.value] = context return context_lookup @decorators.raise_if_nothing_inferred def infer_ifexp( self: nodes.IfExp, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[InferenceResult, None, None]: """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. """ both_branches = False # We use two separate contexts for evaluating lhs and rhs because # evaluating lhs may leave some undesired entries in context.path # which may not let us infer right value of rhs. context = context or InferenceContext() lhs_context = copy_context(context) rhs_context = copy_context(context) try: test = next(self.test.infer(context=context.clone())) except (InferenceError, StopIteration): both_branches = True else: if not isinstance(test, util.UninferableBase): if test.bool_value(): yield from self.body.infer(context=lhs_context) else: yield from self.orelse.infer(context=rhs_context) else: both_branches = True if both_branches: yield from self.body.infer(context=lhs_context) yield from self.orelse.infer(context=rhs_context) nodes.IfExp._infer = infer_ifexp # type: ignore[assignment] def infer_functiondef( self: _FunctionDefT, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[Property \| _FunctionDefT, None, InferenceErrorInfo]: if not self.decorators or not bases._is_property(self): yield self return InferenceErrorInfo(node=self, context=context) # When inferring a property, we instantiate a new `objects.Property` object, # which in turn, because it inherits from `FunctionDef`, sets itself in the locals # of the wrapping frame. This means that every time we infer a property, the locals # are mutated with a new instance of the property. To avoid this, we detect this # scenario and avoid passing the `parent` argument to the constructor. parent_frame = self.parent.frame(future=True) property_already_in_parent_locals = self.name in parent_frame.locals and any( isinstance(val, objects.Property) for val in parent_frame.locals[self.name] ) # We also don't want to pass parent if the definition is within a Try node if isinstance(self.parent, (nodes.TryExcept, nodes.TryFinally, nodes.If)): property_already_in_parent_locals = True prop_func = objects.Property( function=self, name=self.name, lineno=self.lineno, parent=self.parent if not property_already_in_parent_locals else None, col_offset=self.col_offset, ) if property_already_in_parent_locals: prop_func.parent = self.parent prop_func.postinit(body=[], args=self.args, doc_node=self.doc_node) yield prop_func return InferenceErrorInfo(node=self, context=context) nodes.FunctionDef._infer = infer_functiondef	44.06 KB	2026-01-20 12:58
📄 inference_tip.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Transform utilities (filters and decorator).""" from __future__ import annotations import typing from collections.abc import Iterator import wrapt from astroid.exceptions import InferenceOverwriteError, UseInferenceDefault from astroid.nodes import NodeNG from astroid.typing import InferenceResult, InferFn _cache: dict[tuple[InferFn, NodeNG], list[InferenceResult] \| None] = {} def clear_inference_tip_cache() -> None: """Clear the inference tips cache.""" _cache.clear() @wrapt.decorator def _inference_tip_cached( func: InferFn, instance: None, args: typing.Any, kwargs: typing.Any ) -> Iterator[InferenceResult]: """Cache decorator used for inference tips.""" node = args[0] try: result = _cache[func, node] # If through recursion we end up trying to infer the same # func + node we raise here. if result is None: raise UseInferenceDefault() except KeyError: _cache[func, node] = None result = _cache[func, node] = list(func(args, *kwargs)) assert result return iter(result) def inference_tip(infer_function: InferFn, raise_on_overwrite: bool = False) -> InferFn: """Given an instance specific inference function, return a function to be given to AstroidManager().register_transform to set this inference function. :param bool raise_on_overwrite: Raise an `InferenceOverwriteError` if the inference tip will overwrite another. Used for debugging Typical usage .. sourcecode:: python AstroidManager().register_transform(Call, inference_tip(infer_named_tuple), predicate) .. Note:: Using an inference tip will override any previously set inference tip for the given node. Use a predicate in the transform to prevent excess overwrites. """ def transform(node: NodeNG, infer_function: InferFn = infer_function) -> NodeNG: if ( raise_on_overwrite and node._explicit_inference is not None and node._explicit_inference is not infer_function ): raise InferenceOverwriteError( "Inference already set to {existing_inference}. " "Trying to overwrite with {new_inference} for {node}".format( existing_inference=infer_function, new_inference=node._explicit_inference, node=node, ) ) # pylint: disable=no-value-for-parameter node._explicit_inference = _inference_tip_cached(infer_function) return node return transform	2.82 KB	2026-01-20 12:58
📁 interpreter	-	2026-03-21 15:45
📄 manager.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """astroid manager: avoid multiple astroid build of a same module when possible by providing a class responsible to get astroid representation from various source and using a cache of built modules) """ from __future__ import annotations import collections import os import types import zipimport from collections.abc import Callable, Iterator, Sequence from importlib.util import find_spec, module_from_spec from typing import Any, ClassVar from astroid import nodes from astroid._cache import CACHE_MANAGER from astroid.const import BRAIN_MODULES_DIRECTORY from astroid.context import InferenceContext, _invalidate_cache from astroid.exceptions import AstroidBuildingError, AstroidImportError from astroid.interpreter._import import spec, util from astroid.modutils import ( NoSourceFile, _cache_normalize_path_, file_info_from_modpath, get_source_file, is_module_name_part_of_extension_package_whitelist, is_python_source, is_stdlib_module, load_module_from_name, modpath_from_file, ) from astroid.transforms import TransformVisitor from astroid.typing import AstroidManagerBrain, InferenceResult ZIP_IMPORT_EXTS = (".zip", ".egg", ".whl", ".pyz", ".pyzw") def safe_repr(obj: Any) -> str: try: return repr(obj) except Exception: # pylint: disable=broad-except return "???" class AstroidManager: """Responsible to build astroid from files or modules. Use the Borg (singleton) pattern. """ name = "astroid loader" brain: AstroidManagerBrain = { "astroid_cache": {}, "_mod_file_cache": {}, "_failed_import_hooks": [], "always_load_extensions": False, "optimize_ast": False, "extension_package_whitelist": set(), "_transform": TransformVisitor(), } max_inferable_values: ClassVar[int] = 100 def __init__(self) -> None: # NOTE: cache entries are added by the [re]builder self.astroid_cache = AstroidManager.brain["astroid_cache"] self._mod_file_cache = AstroidManager.brain["_mod_file_cache"] self._failed_import_hooks = AstroidManager.brain["_failed_import_hooks"] self.extension_package_whitelist = AstroidManager.brain[ "extension_package_whitelist" ] self._transform = AstroidManager.brain["_transform"] @property def always_load_extensions(self) -> bool: return AstroidManager.brain["always_load_extensions"] @always_load_extensions.setter def always_load_extensions(self, value: bool) -> None: AstroidManager.brain["always_load_extensions"] = value @property def optimize_ast(self) -> bool: return AstroidManager.brain["optimize_ast"] @optimize_ast.setter def optimize_ast(self, value: bool) -> None: AstroidManager.brain["optimize_ast"] = value @property def register_transform(self): # This and unregister_transform below are exported for convenience return self._transform.register_transform @property def unregister_transform(self): return self._transform.unregister_transform @property def builtins_module(self) -> nodes.Module: return self.astroid_cache["builtins"] def visit_transforms(self, node: nodes.NodeNG) -> InferenceResult: """Visit the transforms and apply them to the given node.""" return self._transform.visit(node) def ast_from_file( self, filepath: str, modname: str \| None = None, fallback: bool = True, source: bool = False, ) -> nodes.Module: """Given a module name, return the astroid object.""" try: filepath = get_source_file(filepath, include_no_ext=True) source = True except NoSourceFile: pass if modname is None: try: modname = ".".join(modpath_from_file(filepath)) except ImportError: modname = filepath if ( modname in self.astroid_cache and self.astroid_cache[modname].file == filepath ): return self.astroid_cache[modname] if source: # pylint: disable=import-outside-toplevel; circular import from astroid.builder import AstroidBuilder return AstroidBuilder(self).file_build(filepath, modname) if fallback and modname: return self.ast_from_module_name(modname) raise AstroidBuildingError("Unable to build an AST for {path}.", path=filepath) def ast_from_string( self, data: str, modname: str = "", filepath: str \| None = None ) -> nodes.Module: """Given some source code as a string, return its corresponding astroid object. """ # pylint: disable=import-outside-toplevel; circular import from astroid.builder import AstroidBuilder return AstroidBuilder(self).string_build(data, modname, filepath) def _build_stub_module(self, modname: str) -> nodes.Module: # pylint: disable=import-outside-toplevel; circular import from astroid.builder import AstroidBuilder return AstroidBuilder(self).string_build("", modname) def _build_namespace_module( self, modname: str, path: Sequence[str] ) -> nodes.Module: # pylint: disable=import-outside-toplevel; circular import from astroid.builder import build_namespace_package_module return build_namespace_package_module(modname, path) def _can_load_extension(self, modname: str) -> bool: if self.always_load_extensions: return True if is_stdlib_module(modname): return True return is_module_name_part_of_extension_package_whitelist( modname, self.extension_package_whitelist ) def ast_from_module_name( # noqa: C901 self, modname: str \| None, context_file: str \| None = None, use_cache: bool = True, ) -> nodes.Module: """Given a module name, return the astroid object.""" if modname is None: raise AstroidBuildingError("No module name given.") # Sometimes we don't want to use the cache. For example, when we're # importing a module with the same name as the file that is importing # we want to fallback on the import system to make sure we get the correct # module. if modname in self.astroid_cache and use_cache: return self.astroid_cache[modname] if modname == "__main__": return self._build_stub_module(modname) if context_file: old_cwd = os.getcwd() os.chdir(os.path.dirname(context_file)) try: found_spec = self.file_from_module_name(modname, context_file) if found_spec.type == spec.ModuleType.PY_ZIPMODULE: module = self.zip_import_data(found_spec.location) if module is not None: return module elif found_spec.type in ( spec.ModuleType.C_BUILTIN, spec.ModuleType.C_EXTENSION, ): if ( found_spec.type == spec.ModuleType.C_EXTENSION and not self._can_load_extension(modname) ): return self._build_stub_module(modname) try: named_module = load_module_from_name(modname) except Exception as e: raise AstroidImportError( "Loading {modname} failed with:\n{error}", modname=modname, path=found_spec.location, ) from e return self.ast_from_module(named_module, modname) elif found_spec.type == spec.ModuleType.PY_COMPILED: raise AstroidImportError( "Unable to load compiled module {modname}.", modname=modname, path=found_spec.location, ) elif found_spec.type == spec.ModuleType.PY_NAMESPACE: return self._build_namespace_module( modname, found_spec.submodule_search_locations or [] ) elif found_spec.type == spec.ModuleType.PY_FROZEN: if found_spec.location is None: return self._build_stub_module(modname) # For stdlib frozen modules we can determine the location and # can therefore create a module from the source file return self.ast_from_file(found_spec.location, modname, fallback=False) if found_spec.location is None: raise AstroidImportError( "Can't find a file for module {modname}.", modname=modname ) return self.ast_from_file(found_spec.location, modname, fallback=False) except AstroidBuildingError as e: for hook in self._failed_import_hooks: try: return hook(modname) except AstroidBuildingError: pass raise e finally: if context_file: os.chdir(old_cwd) def zip_import_data(self, filepath: str) -> nodes.Module \| None: if zipimport is None: return None # pylint: disable=import-outside-toplevel; circular import from astroid.builder import AstroidBuilder builder = AstroidBuilder(self) for ext in ZIP_IMPORT_EXTS: try: eggpath, resource = filepath.rsplit(ext + os.path.sep, 1) except ValueError: continue try: # pylint: disable-next=no-member importer = zipimport.zipimporter(eggpath + ext) zmodname = resource.replace(os.path.sep, ".") if importer.is_package(resource): zmodname = zmodname + ".__init__" module = builder.string_build( importer.get_source(resource), zmodname, filepath ) return module except Exception: # pylint: disable=broad-except continue return None def file_from_module_name( self, modname: str, contextfile: str \| None ) -> spec.ModuleSpec: try: value = self._mod_file_cache[(modname, contextfile)] except KeyError: try: value = file_info_from_modpath( modname.split("."), context_file=contextfile ) except ImportError as e: # pylint: disable-next=redefined-variable-type value = AstroidImportError( "Failed to import module {modname} with error:\n{error}.", modname=modname, # we remove the traceback here to save on memory usage (since these exceptions are cached) error=e.with_traceback(None), ) self._mod_file_cache[(modname, contextfile)] = value if isinstance(value, AstroidBuildingError): # we remove the traceback here to save on memory usage (since these exceptions are cached) raise value.with_traceback(None) # pylint: disable=no-member return value def ast_from_module( self, module: types.ModuleType, modname: str \| None = None ) -> nodes.Module: """Given an imported module, return the astroid object.""" modname = modname or module.__name__ if modname in self.astroid_cache: return self.astroid_cache[modname] try: # some builtin modules don't have __file__ attribute filepath = module.__file__ if is_python_source(filepath): # Type is checked in is_python_source return self.ast_from_file(filepath, modname) # type: ignore[arg-type] except AttributeError: pass # pylint: disable=import-outside-toplevel; circular import from astroid.builder import AstroidBuilder return AstroidBuilder(self).module_build(module, modname) def ast_from_class(self, klass: type, modname: str \| None = None) -> nodes.ClassDef: """Get astroid for the given class.""" if modname is None: try: modname = klass.__module__ except AttributeError as exc: raise AstroidBuildingError( "Unable to get module for class {class_name}.", cls=klass, class_repr=safe_repr(klass), modname=modname, ) from exc modastroid = self.ast_from_module_name(modname) ret = modastroid.getattr(klass.__name__)[0] assert isinstance(ret, nodes.ClassDef) return ret def infer_ast_from_something( self, obj: object, context: InferenceContext \| None = None ) -> Iterator[InferenceResult]: """Infer astroid for the given class.""" if hasattr(obj, "__class__") and not isinstance(obj, type): klass = obj.__class__ elif isinstance(obj, type): klass = obj else: raise AstroidBuildingError( # pragma: no cover "Unable to get type for {class_repr}.", cls=None, class_repr=safe_repr(obj), ) try: modname = klass.__module__ except AttributeError as exc: raise AstroidBuildingError( "Unable to get module for {class_repr}.", cls=klass, class_repr=safe_repr(klass), ) from exc except Exception as exc: raise AstroidImportError( "Unexpected error while retrieving module for {class_repr}:\n" "{error}", cls=klass, class_repr=safe_repr(klass), ) from exc try: name = klass.__name__ except AttributeError as exc: raise AstroidBuildingError( "Unable to get name for {class_repr}:\n", cls=klass, class_repr=safe_repr(klass), ) from exc except Exception as exc: raise AstroidImportError( "Unexpected error while retrieving name for {class_repr}:\n{error}", cls=klass, class_repr=safe_repr(klass), ) from exc # take care, on living object __module__ is regularly wrong :( modastroid = self.ast_from_module_name(modname) if klass is obj: for inferred in modastroid.igetattr(name, context): yield inferred else: for inferred in modastroid.igetattr(name, context): yield inferred.instantiate_class() def register_failed_import_hook(self, hook: Callable[[str], nodes.Module]) -> None: """Registers a hook to resolve imports that cannot be found otherwise. `hook` must be a function that accepts a single argument `modname` which contains the name of the module or package that could not be imported. If `hook` can resolve the import, must return a node of type `astroid.Module`, otherwise, it must raise `AstroidBuildingError`. """ self._failed_import_hooks.append(hook) def cache_module(self, module: nodes.Module) -> None: """Cache a module if no module with the same name is known yet.""" self.astroid_cache.setdefault(module.name, module) def bootstrap(self) -> None: """Bootstrap the required AST modules needed for the manager to work. The bootstrap usually involves building the AST for the builtins module, which is required by the rest of astroid to work correctly. """ from astroid import raw_building # pylint: disable=import-outside-toplevel raw_building._astroid_bootstrapping() def clear_cache(self) -> None: """Clear the underlying caches, bootstrap the builtins module and re-register transforms. """ # import here because of cyclic imports # pylint: disable=import-outside-toplevel from astroid.inference_tip import clear_inference_tip_cache from astroid.interpreter.objectmodel import ObjectModel from astroid.nodes.node_classes import LookupMixIn from astroid.nodes.scoped_nodes import ClassDef clear_inference_tip_cache() _invalidate_cache() # inference context cache self.astroid_cache.clear() # NB: not a new TransformVisitor() AstroidManager.brain["_transform"].transforms = collections.defaultdict(list) CACHE_MANAGER.clear_all_caches() for lru_cache in ( LookupMixIn.lookup, _cache_normalize_path_, util.is_namespace, ObjectModel.attributes, ClassDef._metaclass_lookup_attribute, ): lru_cache.cache_clear() # type: ignore[attr-defined] self.bootstrap() # Reload brain plugins. During initialisation this is done in astroid.__init__.py for module in BRAIN_MODULES_DIRECTORY.iterdir(): if module.suffix == ".py": module_spec = find_spec(f"astroid.brain.{module.stem}") assert module_spec module_object = module_from_spec(module_spec) assert module_spec.loader module_spec.loader.exec_module(module_object)	17.54 KB	2026-01-20 12:58
📄 mixins.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """This module contains some mixins for the different nodes.""" import warnings from astroid.nodes._base_nodes import AssignTypeNode as AssignTypeMixin from astroid.nodes._base_nodes import FilterStmtsBaseNode as FilterStmtsMixin from astroid.nodes._base_nodes import ImportNode as ImportFromMixin from astroid.nodes._base_nodes import MultiLineBlockNode as MultiLineBlockMixin from astroid.nodes._base_nodes import MultiLineWithElseBlockNode as BlockRangeMixIn from astroid.nodes._base_nodes import NoChildrenNode as NoChildrenMixin from astroid.nodes._base_nodes import ParentAssignNode as ParentAssignTypeMixin __all__ = ( "AssignTypeMixin", "BlockRangeMixIn", "FilterStmtsMixin", "ImportFromMixin", "MultiLineBlockMixin", "NoChildrenMixin", "ParentAssignTypeMixin", ) warnings.warn( "The 'astroid.mixins' module is deprecated and will become private in astroid 3.0.0", DeprecationWarning, stacklevel=2, )	1.15 KB	2026-01-20 12:58
📄 modutils.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Python modules manipulation utility functions. :type PY_SOURCE_EXTS: tuple(str) :var PY_SOURCE_EXTS: list of possible python source file extension :type STD_LIB_DIRS: set of str :var STD_LIB_DIRS: directories where standard modules are located :type BUILTIN_MODULES: dict :var BUILTIN_MODULES: dictionary with builtin module names has key """ from __future__ import annotations import importlib import importlib.machinery import importlib.util import io import itertools import logging import os import sys import sysconfig import types import warnings from collections.abc import Callable, Iterable, Sequence from contextlib import redirect_stderr, redirect_stdout from functools import lru_cache from pathlib import Path from astroid.const import IS_JYTHON, IS_PYPY, PY310_PLUS from astroid.interpreter._import import spec, util if PY310_PLUS: from sys import stdlib_module_names else: from astroid._backport_stdlib_names import stdlib_module_names logger = logging.getLogger(__name__) if sys.platform.startswith("win"): PY_SOURCE_EXTS = ("py", "pyw") PY_COMPILED_EXTS = ("dll", "pyd") else: PY_SOURCE_EXTS = ("py",) PY_COMPILED_EXTS = ("so",) # TODO: Adding `platstdlib` is a fix for a workaround in virtualenv. At some point we should # revisit whether this is still necessary. See https://github.com/PyCQA/astroid/pull/1323. STD_LIB_DIRS = {sysconfig.get_path("stdlib"), sysconfig.get_path("platstdlib")} if os.name == "nt": STD_LIB_DIRS.add(os.path.join(sys.prefix, "dlls")) try: # real_prefix is defined when running inside virtual environments, # created with the virtualenv library. # Deprecated in virtualenv==16.7.9 # See: https://github.com/pypa/virtualenv/issues/1622 STD_LIB_DIRS.add(os.path.join(sys.real_prefix, "dlls")) # type: ignore[attr-defined] except AttributeError: # sys.base_exec_prefix is always defined, but in a virtual environment # created with the stdlib venv module, it points to the original # installation, if the virtual env is activated. try: STD_LIB_DIRS.add(os.path.join(sys.base_exec_prefix, "dlls")) except AttributeError: pass if IS_PYPY and sys.version_info < (3, 8): # PyPy stores the stdlib in two places: sys.prefix/lib_pypy and sys.prefix/lib-python/3 # sysconfig.get_path on PyPy returns the first, but without an underscore so we patch this manually. # Beginning with 3.8 the stdlib is only stored in: sys.prefix/pypy{py_version_short} STD_LIB_DIRS.add(str(Path(sysconfig.get_path("stdlib")).parent / "lib_pypy")) STD_LIB_DIRS.add(str(Path(sysconfig.get_path("stdlib")).parent / "lib-python/3")) # TODO: This is a fix for a workaround in virtualenv. At some point we should revisit # whether this is still necessary. See https://github.com/PyCQA/astroid/pull/1324. STD_LIB_DIRS.add(str(Path(sysconfig.get_path("platstdlib")).parent / "lib_pypy")) STD_LIB_DIRS.add( str(Path(sysconfig.get_path("platstdlib")).parent / "lib-python/3") ) if os.name == "posix": # Need the real prefix if we're in a virtualenv, otherwise # the usual one will do. # Deprecated in virtualenv==16.7.9 # See: https://github.com/pypa/virtualenv/issues/1622 try: prefix: str = sys.real_prefix # type: ignore[attr-defined] except AttributeError: prefix = sys.prefix def _posix_path(path: str) -> str: base_python = "python%d.%d" % sys.version_info[:2] return os.path.join(prefix, path, base_python) STD_LIB_DIRS.add(_posix_path("lib")) if sys.maxsize > 2**32: # This tries to fix a problem with /usr/lib64 builds, # where systems are running both 32-bit and 64-bit code # on the same machine, which reflects into the places where # standard library could be found. More details can be found # here http://bugs.python.org/issue1294959. # An easy reproducing case would be # https://github.com/PyCQA/pylint/issues/712#issuecomment-163178753 STD_LIB_DIRS.add(_posix_path("lib64")) EXT_LIB_DIRS = {sysconfig.get_path("purelib"), sysconfig.get_path("platlib")} BUILTIN_MODULES = dict.fromkeys(sys.builtin_module_names, True) class NoSourceFile(Exception): """Exception raised when we are not able to get a python source file for a precompiled file. """ def _normalize_path(path: str) -> str: """Resolve symlinks in path and convert to absolute path. Note that environment variables and ~ in the path need to be expanded in advance. This can be cached by using _cache_normalize_path. """ return os.path.normcase(os.path.realpath(path)) def _path_from_filename(filename: str, is_jython: bool = IS_JYTHON) -> str: if not is_jython: return filename head, has_pyclass, _ = filename.partition("$py.class") if has_pyclass: return head + ".py" return filename def _handle_blacklist( blacklist: Sequence[str], dirnames: list[str], filenames: list[str] ) -> None: """Remove files/directories in the black list. dirnames/filenames are usually from os.walk """ for norecurs in blacklist: if norecurs in dirnames: dirnames.remove(norecurs) elif norecurs in filenames: filenames.remove(norecurs) @lru_cache() def _cache_normalize_path_(path: str) -> str: return _normalize_path(path) def _cache_normalize_path(path: str) -> str: """Normalize path with caching.""" # _module_file calls abspath on every path in sys.path every time it's # called; on a larger codebase this easily adds up to half a second just # assembling path components. This cache alleviates that. if not path: # don't cache result for '' return _normalize_path(path) return _cache_normalize_path_(path) def load_module_from_name(dotted_name: str) -> types.ModuleType: """Load a Python module from its name. :type dotted_name: str :param dotted_name: python name of a module or package :raise ImportError: if the module or package is not found :rtype: module :return: the loaded module """ try: return sys.modules[dotted_name] except KeyError: pass # Capture and log anything emitted during import to avoid # contaminating JSON reports in pylint with redirect_stderr(io.StringIO()) as stderr, redirect_stdout( io.StringIO() ) as stdout: module = importlib.import_module(dotted_name) stderr_value = stderr.getvalue() if stderr_value: logger.error( "Captured stderr while importing %s:\n%s", dotted_name, stderr_value ) stdout_value = stdout.getvalue() if stdout_value: logger.info( "Captured stdout while importing %s:\n%s", dotted_name, stdout_value ) return module def load_module_from_modpath(parts: Sequence[str]) -> types.ModuleType: """Load a python module from its split name. :param parts: python name of a module or package split on '.' :raise ImportError: if the module or package is not found :return: the loaded module """ return load_module_from_name(".".join(parts)) def load_module_from_file(filepath: str) -> types.ModuleType: """Load a Python module from it's path. :type filepath: str :param filepath: path to the python module or package :raise ImportError: if the module or package is not found :rtype: module :return: the loaded module """ modpath = modpath_from_file(filepath) return load_module_from_modpath(modpath) def check_modpath_has_init(path: str, mod_path: list[str]) -> bool: """Check there are some __init__.py all along the way.""" modpath: list[str] = [] for part in mod_path: modpath.append(part) path = os.path.join(path, part) if not _has_init(path): old_namespace = util.is_namespace(".".join(modpath)) if not old_namespace: return False return True def _get_relative_base_path(filename: str, path_to_check: str) -> list[str] \| None: """Extracts the relative mod path of the file to import from. Check if a file is within the passed in path and if so, returns the relative mod path from the one passed in. If the filename is no in path_to_check, returns None Note this function will look for both abs and realpath of the file, this allows to find the relative base path even if the file is a symlink of a file in the passed in path Examples: _get_relative_base_path("/a/b/c/d.py", "/a/b") -> ["c","d"] _get_relative_base_path("/a/b/c/d.py", "/dev") -> None """ importable_path = None path_to_check = os.path.normcase(path_to_check) abs_filename = os.path.abspath(filename) if os.path.normcase(abs_filename).startswith(path_to_check): importable_path = abs_filename real_filename = os.path.realpath(filename) if os.path.normcase(real_filename).startswith(path_to_check): importable_path = real_filename # if "var" in path_to_check: # breakpoint() if importable_path: base_path = os.path.splitext(importable_path)[0] relative_base_path = base_path[len(path_to_check) :] return [pkg for pkg in relative_base_path.split(os.sep) if pkg] return None def modpath_from_file_with_callback( filename: str, path: Sequence[str] \| None = None, is_package_cb: Callable[[str, list[str]], bool] \| None = None, ) -> list[str]: filename = os.path.expanduser(_path_from_filename(filename)) paths_to_check = sys.path.copy() if path: paths_to_check += path for pathname in itertools.chain( paths_to_check, map(_cache_normalize_path, paths_to_check) ): if not pathname: continue modpath = _get_relative_base_path(filename, pathname) if not modpath: continue assert is_package_cb is not None if is_package_cb(pathname, modpath[:-1]): return modpath raise ImportError( "Unable to find module for {} in {}".format(filename, ", \n".join(sys.path)) ) def modpath_from_file(filename: str, path: Sequence[str] \| None = None) -> list[str]: """Get the corresponding split module's name from a filename. This function will return the name of a module or package split on `.`. :type filename: str :param filename: file's path for which we want the module's name :type Optional[List[str]] path: Optional list of path where the module or package should be searched (use sys.path if nothing or None is given) :raise ImportError: if the corresponding module's name has not been found :rtype: list(str) :return: the corresponding split module's name """ return modpath_from_file_with_callback(filename, path, check_modpath_has_init) def file_from_modpath( modpath: list[str], path: Sequence[str] \| None = None, context_file: str \| None = None, ) -> str \| None: return file_info_from_modpath(modpath, path, context_file).location def file_info_from_modpath( modpath: list[str], path: Sequence[str] \| None = None, context_file: str \| None = None, ) -> spec.ModuleSpec: """Given a mod path (i.e. split module / package name), return the corresponding file. Giving priority to source file over precompiled file if it exists. :param modpath: split module's name (i.e name of a module or package split on '.') (this means explicit relative imports that start with dots have empty strings in this list!) :param path: optional list of path where the module or package should be searched (use sys.path if nothing or None is given) :param context_file: context file to consider, necessary if the identifier has been introduced using a relative import unresolvable in the actual context (i.e. modutils) :raise ImportError: if there is no such module in the directory :return: the path to the module's file or None if it's an integrated builtin module such as 'sys' """ if context_file is not None: context: str \| None = os.path.dirname(context_file) else: context = context_file if modpath[0] == "xml": # handle _xmlplus try: return _spec_from_modpath(["_xmlplus"] + modpath[1:], path, context) except ImportError: return _spec_from_modpath(modpath, path, context) elif modpath == ["os", "path"]: # FIXME: currently ignoring search_path... return spec.ModuleSpec( name="os.path", location=os.path.__file__, type=spec.ModuleType.PY_SOURCE, ) return _spec_from_modpath(modpath, path, context) def get_module_part(dotted_name: str, context_file: str \| None = None) -> str: """Given a dotted name return the module part of the name : >>> get_module_part('astroid.as_string.dump') 'astroid.as_string' :param dotted_name: full name of the identifier we are interested in :param context_file: context file to consider, necessary if the identifier has been introduced using a relative import unresolvable in the actual context (i.e. modutils) :raise ImportError: if there is no such module in the directory :return: the module part of the name or None if we have not been able at all to import the given name XXX: deprecated, since it doesn't handle package precedence over module (see #10066) """ # os.path trick if dotted_name.startswith("os.path"): return "os.path" parts = dotted_name.split(".") if context_file is not None: # first check for builtin module which won't be considered latter # in that case (path != None) if parts[0] in BUILTIN_MODULES: if len(parts) > 2: raise ImportError(dotted_name) return parts[0] # don't use += or insert, we want a new list to be created ! path: list[str] \| None = None starti = 0 if parts[0] == "": assert ( context_file is not None ), "explicit relative import, but no context_file?" path = [] # prevent resolving the import non-relatively starti = 1 # for all further dots: change context while starti < len(parts) and parts[starti] == "": starti += 1 assert ( context_file is not None ), "explicit relative import, but no context_file?" context_file = os.path.dirname(context_file) for i in range(starti, len(parts)): try: file_from_modpath( parts[starti : i + 1], path=path, context_file=context_file ) except ImportError: if i < max(1, len(parts) - 2): raise return ".".join(parts[:i]) return dotted_name def get_module_files( src_directory: str, blacklist: Sequence[str], list_all: bool = False ) -> list[str]: """Given a package directory return a list of all available python module's files in the package and its subpackages. :param src_directory: path of the directory corresponding to the package :param blacklist: iterable list of files or directories to ignore. :param list_all: get files from all paths, including ones without __init__.py :return: the list of all available python module's files in the package and its subpackages """ files: list[str] = [] for directory, dirnames, filenames in os.walk(src_directory): if directory in blacklist: continue _handle_blacklist(blacklist, dirnames, filenames) # check for __init__.py if not list_all and "__init__.py" not in filenames: dirnames[:] = () continue for filename in filenames: if _is_python_file(filename): src = os.path.join(directory, filename) files.append(src) return files def get_source_file(filename: str, include_no_ext: bool = False) -> str: """Given a python module's file name return the matching source file name (the filename will be returned identically if it's already an. absolute path to a python source file...) :param filename: python module's file name :raise NoSourceFile: if no source file exists on the file system :return: the absolute path of the source file if it exists """ filename = os.path.abspath(_path_from_filename(filename)) base, orig_ext = os.path.splitext(filename) for ext in PY_SOURCE_EXTS: source_path = f"{base}.{ext}" if os.path.exists(source_path): return source_path if include_no_ext and not orig_ext and os.path.exists(base): return base raise NoSourceFile(filename) def is_python_source(filename: str \| None) -> bool: """Return: True if the filename is a python source file.""" if not filename: return False return os.path.splitext(filename)[1][1:] in PY_SOURCE_EXTS def is_stdlib_module(modname: str) -> bool: """Return: True if the modname is in the standard library""" return modname.split(".")[0] in stdlib_module_names def module_in_path(modname: str, path: str \| Iterable[str]) -> bool: """Try to determine if a module is imported from one of the specified paths :param modname: name of the module :param path: paths to consider :return: true if the module: - is located on the path listed in one of the directory in `paths` """ modname = modname.split(".")[0] try: filename = file_from_modpath([modname]) except ImportError: # Import failed, we can't check path if we don't know it return False if filename is None: # No filename likely means it's compiled in, or potentially a namespace return False filename = _normalize_path(filename) if isinstance(path, str): return filename.startswith(_cache_normalize_path(path)) return any(filename.startswith(_cache_normalize_path(entry)) for entry in path) def is_standard_module(modname: str, std_path: Iterable[str] \| None = None) -> bool: """Try to guess if a module is a standard python module (by default, see `std_path` parameter's description). :param modname: name of the module we are interested in :param std_path: list of path considered has standard :return: true if the module: - is located on the path listed in one of the directory in `std_path` - is a built-in module """ warnings.warn( "is_standard_module() is deprecated. Use, is_stdlib_module() or module_in_path() instead", DeprecationWarning, stacklevel=2, ) modname = modname.split(".")[0] try: filename = file_from_modpath([modname]) except ImportError: # import failed, i'm probably not so wrong by supposing it's # not standard... return False # modules which are not living in a file are considered standard # (sys and __builtin__ for instance) if filename is None: # we assume there are no namespaces in stdlib return not util.is_namespace(modname) filename = _normalize_path(filename) for path in EXT_LIB_DIRS: if filename.startswith(_cache_normalize_path(path)): return False if std_path is None: std_path = STD_LIB_DIRS return any(filename.startswith(_cache_normalize_path(path)) for path in std_path) def is_relative(modname: str, from_file: str) -> bool: """Return true if the given module name is relative to the given file name. :param modname: name of the module we are interested in :param from_file: path of the module from which modname has been imported :return: true if the module has been imported relatively to `from_file` """ if not os.path.isdir(from_file): from_file = os.path.dirname(from_file) if from_file in sys.path: return False return bool( importlib.machinery.PathFinder.find_spec( modname.split(".", maxsplit=1)[0], [from_file] ) ) # internal only functions ##################################################### def _spec_from_modpath( modpath: list[str], path: Sequence[str] \| None = None, context: str \| None = None, ) -> spec.ModuleSpec: """Given a mod path (i.e. split module / package name), return the corresponding spec. this function is used internally, see `file_from_modpath`'s documentation for more information """ assert modpath location = None if context is not None: try: found_spec = spec.find_spec(modpath, [context]) location = found_spec.location except ImportError: found_spec = spec.find_spec(modpath, path) location = found_spec.location else: found_spec = spec.find_spec(modpath, path) if found_spec.type == spec.ModuleType.PY_COMPILED: try: assert found_spec.location is not None location = get_source_file(found_spec.location) return found_spec._replace( location=location, type=spec.ModuleType.PY_SOURCE ) except NoSourceFile: return found_spec._replace(location=location) elif found_spec.type == spec.ModuleType.C_BUILTIN: # integrated builtin module return found_spec._replace(location=None) elif found_spec.type == spec.ModuleType.PKG_DIRECTORY: assert found_spec.location is not None location = _has_init(found_spec.location) return found_spec._replace(location=location, type=spec.ModuleType.PY_SOURCE) return found_spec def _is_python_file(filename: str) -> bool: """Return true if the given filename should be considered as a python file. .pyc and .pyo are ignored """ return filename.endswith((".py", ".so", ".pyd", ".pyw")) def _has_init(directory: str) -> str \| None: """If the given directory has a valid __init__ file, return its path, else return None. """ mod_or_pack = os.path.join(directory, "__init__") for ext in PY_SOURCE_EXTS + ("pyc", "pyo"): if os.path.exists(mod_or_pack + "." + ext): return mod_or_pack + "." + ext return None def is_namespace(specobj: spec.ModuleSpec) -> bool: return specobj.type == spec.ModuleType.PY_NAMESPACE def is_directory(specobj: spec.ModuleSpec) -> bool: return specobj.type == spec.ModuleType.PKG_DIRECTORY def is_module_name_part_of_extension_package_whitelist( module_name: str, package_whitelist: set[str] ) -> bool: """ Returns True if one part of the module name is in the package whitelist. >>> is_module_name_part_of_extension_package_whitelist('numpy.core.umath', {'numpy'}) True """ parts = module_name.split(".") return any( ".".join(parts[:x]) in package_whitelist for x in range(1, len(parts) + 1) )	22.96 KB	2026-01-20 12:58
📄 node_classes.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt # pylint: disable=unused-import import warnings from astroid.nodes.node_classes import ( # pylint: disable=redefined-builtin (Ellipsis) CONST_CLS, AnnAssign, Arguments, Assert, Assign, AssignAttr, AssignName, AsyncFor, AsyncWith, Attribute, AugAssign, Await, BaseContainer, BinOp, BoolOp, Break, Call, Compare, Comprehension, Const, Continue, Decorators, DelAttr, Delete, DelName, Dict, DictUnpack, Ellipsis, EmptyNode, EvaluatedObject, ExceptHandler, Expr, ExtSlice, For, FormattedValue, Global, If, IfExp, Import, ImportFrom, Index, JoinedStr, Keyword, List, LookupMixIn, Match, MatchAs, MatchCase, MatchClass, MatchMapping, MatchOr, MatchSequence, MatchSingleton, MatchStar, MatchValue, Name, NamedExpr, NodeNG, Nonlocal, Pass, Pattern, Raise, Return, Set, Slice, Starred, Subscript, TryExcept, TryFinally, TryStar, Tuple, UnaryOp, Unknown, While, With, Yield, YieldFrom, are_exclusive, const_factory, unpack_infer, ) # We cannot create a __all__ here because it would create a circular import # Please remove astroid/scoped_nodes.py\|astroid/node_classes.py in autoflake # exclude when removing this file. warnings.warn( "The 'astroid.node_classes' module is deprecated and will be replaced by " "'astroid.nodes' in astroid 3.0.0", DeprecationWarning, stacklevel=2, )	1.8 KB	2026-01-20 12:58
📁 nodes	-	2026-03-21 15:45
📄 objects.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """ Inference objects are a way to represent composite AST nodes, which are used only as inference results, so they can't be found in the original AST tree. For instance, inferring the following frozenset use, leads to an inferred FrozenSet: Call(func=Name('frozenset'), args=Tuple(...)) """ from __future__ import annotations import sys from collections.abc import Generator from typing import Any, TypeVar from astroid import bases, decorators, util from astroid.context import InferenceContext from astroid.exceptions import ( AttributeInferenceError, InferenceError, MroError, SuperError, ) from astroid.manager import AstroidManager from astroid.nodes import node_classes, scoped_nodes objectmodel = util.lazy_import("interpreter.objectmodel") if sys.version_info >= (3, 8): from functools import cached_property from typing import Literal else: from typing_extensions import Literal from astroid.decorators import cachedproperty as cached_property _T = TypeVar("_T") class FrozenSet(node_classes.BaseContainer): """Class representing a FrozenSet composite node.""" def pytype(self) -> Literal["builtins.frozenset"]: return "builtins.frozenset" def _infer(self, context: InferenceContext \| None = None, *kwargs: Any): yield self @cached_property def _proxied(self): # pylint: disable=method-hidden ast_builtins = AstroidManager().builtins_module return ast_builtins.getattr("frozenset")[0] class Super(node_classes.NodeNG): """Proxy class over a super call. This class offers almost the same behaviour as Python's super, which is MRO lookups for retrieving attributes from the parents. The mro_pointer* is the place in the MRO from where we should start looking, not counting it. mro_type is the object which provides the MRO, it can be both a type or an instance. self_class is the class where the super call is, while scope is the function where the super call is. """ # pylint: disable=unnecessary-lambda special_attributes = util.lazy_descriptor(lambda: objectmodel.SuperModel()) def __init__(self, mro_pointer, mro_type, self_class, scope): self.type = mro_type self.mro_pointer = mro_pointer self._class_based = False self._self_class = self_class self._scope = scope super().__init__() def _infer(self, context: InferenceContext \| None = None, kwargs: Any): yield self def super_mro(self): """Get the MRO which will be used to lookup attributes in this super.""" if not isinstance(self.mro_pointer, scoped_nodes.ClassDef): raise SuperError( "The first argument to super must be a subtype of " "type, not {mro_pointer}.", super_=self, ) if isinstance(self.type, scoped_nodes.ClassDef): # `super(type, type)`, most likely in a class method. self._class_based = True mro_type = self.type else: mro_type = getattr(self.type, "_proxied", None) if not isinstance(mro_type, (bases.Instance, scoped_nodes.ClassDef)): raise SuperError( "The second argument to super must be an " "instance or subtype of type, not {type}.", super_=self, ) if not mro_type.newstyle: raise SuperError("Unable to call super on old-style classes.", super_=self) mro = mro_type.mro() if self.mro_pointer not in mro: raise SuperError( "The second argument to super must be an " "instance or subtype of type, not {type}.", super_=self, ) index = mro.index(self.mro_pointer) return mro[index + 1 :] @cached_property def _proxied(self): ast_builtins = AstroidManager().builtins_module return ast_builtins.getattr("super")[0] def pytype(self) -> Literal["builtins.super"]: return "builtins.super" def display_type(self) -> str: return "Super of" @property def name(self): """Get the name of the MRO pointer.""" return self.mro_pointer.name def qname(self) -> Literal["super"]: return "super" def igetattr( # noqa: C901 self, name: str, context: InferenceContext \| None = None ): """Retrieve the inferred values of the given attribute name.""" # '__class__' is a special attribute that should be taken directly # from the special attributes dict if name == "__class__": yield self.special_attributes.lookup(name) return try: mro = self.super_mro() # Don't let invalid MROs or invalid super calls # leak out as is from this function. except SuperError as exc: raise AttributeInferenceError( ( "Lookup for {name} on {target!r} because super call {super!r} " "is invalid." ), target=self, attribute=name, context=context, super_=exc.super_, ) from exc except MroError as exc: raise AttributeInferenceError( ( "Lookup for {name} on {target!r} failed because {cls!r} has an " "invalid MRO." ), target=self, attribute=name, context=context, mros=exc.mros, cls=exc.cls, ) from exc found = False for cls in mro: if name not in cls.locals: continue found = True for inferred in bases._infer_stmts([cls[name]], context, frame=self): if not isinstance(inferred, scoped_nodes.FunctionDef): yield inferred continue # We can obtain different descriptors from a super depending # on what we are accessing and where the super call is. if inferred.type == "classmethod": yield bases.BoundMethod(inferred, cls) elif self._scope.type == "classmethod" and inferred.type == "method": yield inferred elif self._class_based or inferred.type == "staticmethod": yield inferred elif isinstance(inferred, Property): function = inferred.function try: yield from function.infer_call_result( caller=self, context=context ) except InferenceError: yield util.Uninferable elif bases._is_property(inferred): # TODO: support other descriptors as well. try: yield from inferred.infer_call_result(self, context) except InferenceError: yield util.Uninferable else: yield bases.BoundMethod(inferred, cls) # Only if we haven't found any explicit overwrites for the # attribute we look it up in the special attributes if not found and name in self.special_attributes: yield self.special_attributes.lookup(name) return if not found: raise AttributeInferenceError(target=self, attribute=name, context=context) def getattr(self, name, context: InferenceContext \| None = None): return list(self.igetattr(name, context=context)) class ExceptionInstance(bases.Instance): """Class for instances of exceptions. It has special treatment for some of the exceptions's attributes, which are transformed at runtime into certain concrete objects, such as the case of .args. """ @cached_property def special_attributes(self): qname = self.qname() instance = objectmodel.BUILTIN_EXCEPTIONS.get( qname, objectmodel.ExceptionInstanceModel ) return instance()(self) class DictInstance(bases.Instance): """Special kind of instances for dictionaries. This instance knows the underlying object model of the dictionaries, which means that methods such as .values or .items can be properly inferred. """ # pylint: disable=unnecessary-lambda special_attributes = util.lazy_descriptor(lambda: objectmodel.DictModel()) # Custom objects tailored for dictionaries, which are used to # disambiguate between the types of Python 2 dict's method returns # and Python 3 (where they return set like objects). class DictItems(bases.Proxy): __str__ = node_classes.NodeNG.__str__ __repr__ = node_classes.NodeNG.__repr__ class DictKeys(bases.Proxy): __str__ = node_classes.NodeNG.__str__ __repr__ = node_classes.NodeNG.__repr__ class DictValues(bases.Proxy): __str__ = node_classes.NodeNG.__str__ __repr__ = node_classes.NodeNG.__repr__ class PartialFunction(scoped_nodes.FunctionDef): """A class representing partial function obtained via functools.partial.""" @decorators.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead") def __init__( self, call, name=None, doc=None, lineno=None, col_offset=None, parent=None ): # TODO: Pass end_lineno and end_col_offset as well super().__init__(name, lineno=lineno, col_offset=col_offset, parent=None) # Assigned directly to prevent triggering the DeprecationWarning. self._doc = doc # A typical FunctionDef automatically adds its name to the parent scope, # but a partial should not, so defer setting parent until after init self.parent = parent self.filled_args = call.positional_arguments[1:] self.filled_keywords = call.keyword_arguments wrapped_function = call.positional_arguments[0] inferred_wrapped_function = next(wrapped_function.infer()) if isinstance(inferred_wrapped_function, PartialFunction): self.filled_args = inferred_wrapped_function.filled_args + self.filled_args self.filled_keywords = { inferred_wrapped_function.filled_keywords, self.filled_keywords, } self.filled_positionals = len(self.filled_args) def infer_call_result(self, caller=None, context: InferenceContext \| None = None): if context: current_passed_keywords = { keyword for (keyword, _) in context.callcontext.keywords } for keyword, value in self.filled_keywords.items(): if keyword not in current_passed_keywords: context.callcontext.keywords.append((keyword, value)) call_context_args = context.callcontext.args or [] context.callcontext.args = self.filled_args + call_context_args return super().infer_call_result(caller=caller, context=context) def qname(self) -> str: return self.__class__.__name__ # TODO: Hack to solve the circular import problem between node_classes and objects # This is not needed in 2.0, which has a cleaner design overall node_classes.Dict.__bases__ = (node_classes.NodeNG, DictInstance) class Property(scoped_nodes.FunctionDef): """Class representing a Python property.""" @decorators.deprecate_arguments(doc="Use the postinit arg 'doc_node' instead") def __init__( self, function, name=None, doc=None, lineno=None, col_offset=None, parent=None ): self.function = function super().__init__(name, lineno=lineno, col_offset=col_offset, parent=parent) # Assigned directly to prevent triggering the DeprecationWarning. self._doc = doc # pylint: disable=unnecessary-lambda special_attributes = util.lazy_descriptor(lambda: objectmodel.PropertyModel()) type = "property" def pytype(self) -> Literal["builtins.property"]: return "builtins.property" def infer_call_result(self, caller=None, context: InferenceContext \| None = None): raise InferenceError("Properties are not callable") def _infer( self: _T, context: InferenceContext \| None = None, kwargs: Any ) -> Generator[_T, None, None]: yield self	12.46 KB	2026-01-20 12:58
📄 protocols.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """This module contains a set of functions to handle python protocols for nodes where it makes sense. """ from __future__ import annotations import collections import itertools import operator as operator_mod from collections.abc import Callable, Generator, Iterator, Sequence from typing import Any, TypeVar from astroid import arguments, bases, decorators, helpers, nodes, util from astroid.const import Context from astroid.context import InferenceContext, copy_context from astroid.exceptions import ( AstroidIndexError, AstroidTypeError, AttributeInferenceError, InferenceError, NoDefault, ) from astroid.nodes import node_classes from astroid.typing import ( ConstFactoryResult, InferenceResult, SuccessfulInferenceResult, ) raw_building = util.lazy_import("raw_building") objects = util.lazy_import("objects") _TupleListNodeT = TypeVar("_TupleListNodeT", nodes.Tuple, nodes.List) def _reflected_name(name) -> str: return "__r" + name[2:] def _augmented_name(name) -> str: return "__i" + name[2:] _CONTEXTLIB_MGR = "contextlib.contextmanager" BIN_OP_METHOD = { "+": "__add__", "-": "__sub__", "/": "__truediv__", "//": "__floordiv__", "": "__mul__", "": "__pow__", "%": "__mod__", "&": "__and__", "\|": "__or__", "^": "__xor__", "<<": "__lshift__", ">>": "__rshift__", "@": "__matmul__", } REFLECTED_BIN_OP_METHOD = { key: _reflected_name(value) for (key, value) in BIN_OP_METHOD.items() } AUGMENTED_OP_METHOD = { key + "=": _augmented_name(value) for (key, value) in BIN_OP_METHOD.items() } UNARY_OP_METHOD = { "+": "__pos__", "-": "__neg__", "~": "__invert__", "not": None, # XXX not '__nonzero__' } _UNARY_OPERATORS: dict[str, Callable[[Any], Any]] = { "+": operator_mod.pos, "-": operator_mod.neg, "~": operator_mod.invert, "not": operator_mod.not_, } def _infer_unary_op(obj: Any, op: str) -> ConstFactoryResult: """Perform unary operation on `obj`, unless it is `NotImplemented`. Can raise TypeError if operation is unsupported. """ if obj is NotImplemented: value = obj else: func = _UNARY_OPERATORS[op] value = func(obj) return nodes.const_factory(value) nodes.Tuple.infer_unary_op = lambda self, op: _infer_unary_op(tuple(self.elts), op) nodes.List.infer_unary_op = lambda self, op: _infer_unary_op(self.elts, op) nodes.Set.infer_unary_op = lambda self, op: _infer_unary_op(set(self.elts), op) nodes.Const.infer_unary_op = lambda self, op: _infer_unary_op(self.value, op) nodes.Dict.infer_unary_op = lambda self, op: _infer_unary_op(dict(self.items), op) # Binary operations BIN_OP_IMPL = { "+": lambda a, b: a + b, "-": lambda a, b: a - b, "/": lambda a, b: a / b, "//": lambda a, b: a // b, "": lambda a, b: a * b, "": lambda a, b: ab, "%": lambda a, b: a % b, "&": lambda a, b: a & b, "\|": lambda a, b: a \| b, "^": lambda a, b: a ^ b, "<<": lambda a, b: a << b, ">>": lambda a, b: a >> b, "@": operator_mod.matmul, } for _KEY, _IMPL in list(BIN_OP_IMPL.items()): BIN_OP_IMPL[_KEY + "="] = _IMPL @decorators.yes_if_nothing_inferred def const_infer_binary_op( self: nodes.Const, opnode: nodes.AugAssign \| nodes.BinOp, operator: str, other: InferenceResult, context: InferenceContext, _: SuccessfulInferenceResult, ) -> Generator[ConstFactoryResult \| util.UninferableBase, None, None]: not_implemented = nodes.Const(NotImplemented) if isinstance(other, nodes.Const): if ( operator == "*" and isinstance(self.value, (int, float)) and isinstance(other.value, (int, float)) and (self.value > 1e5 or other.value > 1e5) ): yield not_implemented return try: impl = BIN_OP_IMPL[operator] try: yield nodes.const_factory(impl(self.value, other.value)) except TypeError: # ArithmeticError is not enough: float >> float is a TypeError yield not_implemented except Exception: # pylint: disable=broad-except yield util.Uninferable except TypeError: yield not_implemented elif isinstance(self.value, str) and operator == "%": # TODO(cpopa): implement string interpolation later on. yield util.Uninferable else: yield not_implemented nodes.Const.infer_binary_op = const_infer_binary_op def _multiply_seq_by_int( self: _TupleListNodeT, opnode: nodes.AugAssign \| nodes.BinOp, value: int, context: InferenceContext, ) -> _TupleListNodeT: node = self.__class__(parent=opnode) if value > 1e8: node.elts = [util.Uninferable] return node filtered_elts = ( helpers.safe_infer(elt, context) or util.Uninferable for elt in self.elts if not isinstance(elt, util.UninferableBase) ) node.elts = list(filtered_elts) value return node def _filter_uninferable_nodes( elts: Sequence[InferenceResult], context: InferenceContext ) -> Iterator[SuccessfulInferenceResult]: for elt in elts: if isinstance(elt, util.UninferableBase): yield nodes.Unknown() else: for inferred in elt.infer(context): if not isinstance(inferred, util.UninferableBase): yield inferred else: yield nodes.Unknown() @decorators.yes_if_nothing_inferred def tl_infer_binary_op( self: _TupleListNodeT, opnode: nodes.AugAssign \| nodes.BinOp, operator: str, other: InferenceResult, context: InferenceContext, method: SuccessfulInferenceResult, ) -> Generator[_TupleListNodeT \| nodes.Const \| util.UninferableBase, None, None]: """Infer a binary operation on a tuple or list. The instance on which the binary operation is performed is a tuple or list. This refers to the left-hand side of the operation, so: 'tuple() + 1' or '[] + A()' """ # For tuples and list the boundnode is no longer the tuple or list instance context.boundnode = None not_implemented = nodes.Const(NotImplemented) if isinstance(other, self.__class__) and operator == "+": node = self.__class__(parent=opnode) node.elts = list( itertools.chain( _filter_uninferable_nodes(self.elts, context), _filter_uninferable_nodes(other.elts, context), ) ) yield node elif isinstance(other, nodes.Const) and operator == "": if not isinstance(other.value, int): yield not_implemented return yield _multiply_seq_by_int(self, opnode, other.value, context) elif isinstance(other, bases.Instance) and operator == "": # Verify if the instance supports __index__. as_index = helpers.class_instance_as_index(other) if not as_index: yield util.Uninferable elif not isinstance(as_index.value, int): # pragma: no cover # already checked by class_instance_as_index() but faster than casting raise AssertionError("Please open a bug report.") else: yield _multiply_seq_by_int(self, opnode, as_index.value, context) else: yield not_implemented nodes.Tuple.infer_binary_op = tl_infer_binary_op nodes.List.infer_binary_op = tl_infer_binary_op @decorators.yes_if_nothing_inferred def instance_class_infer_binary_op( self: bases.Instance \| nodes.ClassDef, opnode: nodes.AugAssign \| nodes.BinOp, operator: str, other: InferenceResult, context: InferenceContext, method: SuccessfulInferenceResult, ) -> Generator[InferenceResult, None, None]: return method.infer_call_result(self, context) bases.Instance.infer_binary_op = instance_class_infer_binary_op nodes.ClassDef.infer_binary_op = instance_class_infer_binary_op # assignment ################################################################## """The assigned_stmts method is responsible to return the assigned statement (e.g. not inferred) according to the assignment type. The `assign_path` argument is used to record the lhs path of the original node. For instance if we want assigned statements for 'c' in 'a, (b,c)', assign_path will be [1, 1] once arrived to the Assign node. The `context` argument is the current inference context which should be given to any intermediary inference necessary. """ def _resolve_looppart(parts, assign_path, context): """Recursive function to resolve multiple assignments on loops.""" assign_path = assign_path[:] index = assign_path.pop(0) for part in parts: if isinstance(part, util.UninferableBase): continue if not hasattr(part, "itered"): continue try: itered = part.itered() except TypeError: continue try: if isinstance(itered[index], (nodes.Const, nodes.Name)): itered = [part] except IndexError: pass for stmt in itered: index_node = nodes.Const(index) try: assigned = stmt.getitem(index_node, context) except (AttributeError, AstroidTypeError, AstroidIndexError): continue if not assign_path: # we achieved to resolved the assignment path, # don't infer the last part yield assigned elif isinstance(assigned, util.UninferableBase): break else: # we are not yet on the last part of the path # search on each possibly inferred value try: yield from _resolve_looppart( assigned.infer(context), assign_path, context ) except InferenceError: break @decorators.raise_if_nothing_inferred def for_assigned_stmts( self: nodes.For \| nodes.Comprehension, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: if isinstance(self, nodes.AsyncFor) or getattr(self, "is_async", False): # Skip inferring of async code for now return { "node": self, "unknown": node, "assign_path": assign_path, "context": context, } if assign_path is None: for lst in self.iter.infer(context): if isinstance(lst, (nodes.Tuple, nodes.List)): yield from lst.elts else: yield from _resolve_looppart(self.iter.infer(context), assign_path, context) return { "node": self, "unknown": node, "assign_path": assign_path, "context": context, } nodes.For.assigned_stmts = for_assigned_stmts nodes.Comprehension.assigned_stmts = for_assigned_stmts def sequence_assigned_stmts( self: nodes.Tuple \| nodes.List, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: if assign_path is None: assign_path = [] try: index = self.elts.index(node) # type: ignore[arg-type] except ValueError as exc: raise InferenceError( "Tried to retrieve a node {node!r} which does not exist", node=self, assign_path=assign_path, context=context, ) from exc assign_path.insert(0, index) return self.parent.assigned_stmts( node=self, context=context, assign_path=assign_path ) nodes.Tuple.assigned_stmts = sequence_assigned_stmts nodes.List.assigned_stmts = sequence_assigned_stmts def assend_assigned_stmts( self: nodes.AssignName \| nodes.AssignAttr, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: return self.parent.assigned_stmts(node=self, context=context) nodes.AssignName.assigned_stmts = assend_assigned_stmts nodes.AssignAttr.assigned_stmts = assend_assigned_stmts def _arguments_infer_argname( self, name: str \| None, context: InferenceContext ) -> Generator[InferenceResult, None, None]: # arguments information may be missing, in which case we can't do anything # more if not (self.arguments or self.vararg or self.kwarg): yield util.Uninferable return functype = self.parent.type # first argument of instance/class method if ( self.arguments and getattr(self.arguments[0], "name", None) == name and functype != "staticmethod" ): cls = self.parent.parent.scope() is_metaclass = isinstance(cls, nodes.ClassDef) and cls.type == "metaclass" # If this is a metaclass, then the first argument will always # be the class, not an instance. if context.boundnode and isinstance(context.boundnode, bases.Instance): cls = context.boundnode._proxied if is_metaclass or functype == "classmethod": yield cls return if functype == "method": yield cls.instantiate_class() return if context and context.callcontext: callee = context.callcontext.callee while hasattr(callee, "_proxied"): callee = callee._proxied if getattr(callee, "name", None) == self.parent.name: call_site = arguments.CallSite(context.callcontext, context.extra_context) yield from call_site.infer_argument(self.parent, name, context) return if name == self.vararg: vararg = nodes.const_factory(()) vararg.parent = self if not self.arguments and self.parent.name == "__init__": cls = self.parent.parent.scope() vararg.elts = [cls.instantiate_class()] yield vararg return if name == self.kwarg: kwarg = nodes.const_factory({}) kwarg.parent = self yield kwarg return # if there is a default value, yield it. And then yield Uninferable to reflect # we can't guess given argument value try: context = copy_context(context) yield from self.default_value(name).infer(context) yield util.Uninferable except NoDefault: yield util.Uninferable def arguments_assigned_stmts( self: nodes.Arguments, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: try: node_name = node.name # type: ignore[union-attr] except AttributeError: # Added to handle edge cases where node.name is not defined. # https://github.com/PyCQA/astroid/pull/1644#discussion_r901545816 node_name = None # pragma: no cover if context and context.callcontext: callee = context.callcontext.callee while hasattr(callee, "_proxied"): callee = callee._proxied else: return _arguments_infer_argname(self, node_name, context) if node and getattr(callee, "name", None) == node.frame(future=True).name: # reset call context/name callcontext = context.callcontext context = copy_context(context) context.callcontext = None args = arguments.CallSite(callcontext, context=context) return args.infer_argument(self.parent, node_name, context) return _arguments_infer_argname(self, node_name, context) nodes.Arguments.assigned_stmts = arguments_assigned_stmts @decorators.raise_if_nothing_inferred def assign_assigned_stmts( self: nodes.AugAssign \| nodes.Assign \| nodes.AnnAssign, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: if not assign_path: yield self.value return None yield from _resolve_assignment_parts( self.value.infer(context), assign_path, context ) return { "node": self, "unknown": node, "assign_path": assign_path, "context": context, } def assign_annassigned_stmts( self: nodes.AnnAssign, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: for inferred in assign_assigned_stmts(self, node, context, assign_path): if inferred is None: yield util.Uninferable else: yield inferred nodes.Assign.assigned_stmts = assign_assigned_stmts nodes.AnnAssign.assigned_stmts = assign_annassigned_stmts nodes.AugAssign.assigned_stmts = assign_assigned_stmts def _resolve_assignment_parts(parts, assign_path, context): """Recursive function to resolve multiple assignments.""" assign_path = assign_path[:] index = assign_path.pop(0) for part in parts: assigned = None if isinstance(part, nodes.Dict): # A dictionary in an iterating context try: assigned, _ = part.items[index] except IndexError: return elif hasattr(part, "getitem"): index_node = nodes.Const(index) try: assigned = part.getitem(index_node, context) except (AstroidTypeError, AstroidIndexError): return if not assigned: return if not assign_path: # we achieved to resolved the assignment path, don't infer the # last part yield assigned elif isinstance(assigned, util.UninferableBase): return else: # we are not yet on the last part of the path search on each # possibly inferred value try: yield from _resolve_assignment_parts( assigned.infer(context), assign_path, context ) except InferenceError: return @decorators.raise_if_nothing_inferred def excepthandler_assigned_stmts( self: nodes.ExceptHandler, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: for assigned in node_classes.unpack_infer(self.type): if isinstance(assigned, nodes.ClassDef): assigned = objects.ExceptionInstance(assigned) yield assigned return { "node": self, "unknown": node, "assign_path": assign_path, "context": context, } nodes.ExceptHandler.assigned_stmts = excepthandler_assigned_stmts def _infer_context_manager(self, mgr, context): try: inferred = next(mgr.infer(context=context)) except StopIteration as e: raise InferenceError(node=mgr) from e if isinstance(inferred, bases.Generator): # Check if it is decorated with contextlib.contextmanager. func = inferred.parent if not func.decorators: raise InferenceError( "No decorators found on inferred generator %s", node=func ) for decorator_node in func.decorators.nodes: decorator = next(decorator_node.infer(context=context), None) if isinstance(decorator, nodes.FunctionDef): if decorator.qname() == _CONTEXTLIB_MGR: break else: # It doesn't interest us. raise InferenceError(node=func) try: yield next(inferred.infer_yield_types()) except StopIteration as e: raise InferenceError(node=func) from e elif isinstance(inferred, bases.Instance): try: enter = next(inferred.igetattr("__enter__", context=context)) except (InferenceError, AttributeInferenceError, StopIteration) as exc: raise InferenceError(node=inferred) from exc if not isinstance(enter, bases.BoundMethod): raise InferenceError(node=enter) yield from enter.infer_call_result(self, context) else: raise InferenceError(node=mgr) @decorators.raise_if_nothing_inferred def with_assigned_stmts( self: nodes.With, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: """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. Arguments: 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. """ try: mgr = next(mgr for (mgr, vars) in self.items if vars == node) except StopIteration: return None if assign_path is None: yield from _infer_context_manager(self, mgr, context) else: for result in _infer_context_manager(self, mgr, context): # Walk the assign_path and get the item at the final index. obj = result for index in assign_path: if not hasattr(obj, "elts"): raise InferenceError( "Wrong type ({targets!r}) for {node!r} assignment", node=self, targets=node, assign_path=assign_path, context=context, ) try: obj = obj.elts[index] except IndexError as exc: raise InferenceError( "Tried to infer a nonexistent target with index {index} " "in {node!r}.", node=self, targets=node, assign_path=assign_path, context=context, ) from exc except TypeError as exc: raise InferenceError( "Tried to unpack a non-iterable value in {node!r}.", node=self, targets=node, assign_path=assign_path, context=context, ) from exc yield obj return { "node": self, "unknown": node, "assign_path": assign_path, "context": context, } nodes.With.assigned_stmts = with_assigned_stmts @decorators.raise_if_nothing_inferred def named_expr_assigned_stmts( self: nodes.NamedExpr, node: node_classes.AssignedStmtsPossibleNode, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: """Infer names and other nodes from an assignment expression.""" if self.target == node: yield from self.value.infer(context=context) else: raise InferenceError( "Cannot infer NamedExpr node {node!r}", node=self, assign_path=assign_path, context=context, ) nodes.NamedExpr.assigned_stmts = named_expr_assigned_stmts @decorators.yes_if_nothing_inferred def starred_assigned_stmts( # noqa: C901 self: nodes.Starred, node: node_classes.AssignedStmtsPossibleNode = None, context: InferenceContext \| None = None, assign_path: list[int] \| None = None, ) -> Any: """ Arguments: 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. """ # pylint: disable=too-many-locals,too-many-statements def _determine_starred_iteration_lookups( starred: nodes.Starred, target: nodes.Tuple, lookups: list[tuple[int, int]] ) -> None: # Determine the lookups for the rhs of the iteration itered = target.itered() for index, element in enumerate(itered): if ( isinstance(element, nodes.Starred) and element.value.name == starred.value.name ): lookups.append((index, len(itered))) break if isinstance(element, nodes.Tuple): lookups.append((index, len(element.itered()))) _determine_starred_iteration_lookups(starred, element, lookups) stmt = self.statement(future=True) if not isinstance(stmt, (nodes.Assign, nodes.For)): raise InferenceError( "Statement {stmt!r} enclosing {node!r} must be an Assign or For node.", node=self, stmt=stmt, unknown=node, context=context, ) if context is None: context = InferenceContext() if isinstance(stmt, nodes.Assign): value = stmt.value lhs = stmt.targets[0] if not isinstance(lhs, nodes.BaseContainer): yield util.Uninferable return if sum(1 for _ in lhs.nodes_of_class(nodes.Starred)) > 1: raise InferenceError( "Too many starred arguments in the assignment targets {lhs!r}.", node=self, targets=lhs, unknown=node, context=context, ) try: rhs = next(value.infer(context)) except (InferenceError, StopIteration): yield util.Uninferable return if isinstance(rhs, util.UninferableBase) or not hasattr(rhs, "itered"): yield util.Uninferable return try: elts = collections.deque(rhs.itered()) # type: ignore[union-attr] except TypeError: yield util.Uninferable return # Unpack iteratively the values from the rhs of the assignment, # until the find the starred node. What will remain will # be the list of values which the Starred node will represent # This is done in two steps, from left to right to remove # anything before the starred node and from right to left # to remove anything after the starred node. for index, left_node in enumerate(lhs.elts): if not isinstance(left_node, nodes.Starred): if not elts: break elts.popleft() continue lhs_elts = collections.deque(reversed(lhs.elts[index:])) for right_node in lhs_elts: if not isinstance(right_node, nodes.Starred): if not elts: break elts.pop() continue # We're done unpacking. packed = nodes.List( ctx=Context.Store, parent=self, lineno=lhs.lineno, col_offset=lhs.col_offset, ) packed.postinit(elts=list(elts)) yield packed break if isinstance(stmt, nodes.For): try: inferred_iterable = next(stmt.iter.infer(context=context)) except (InferenceError, StopIteration): yield util.Uninferable return if isinstance(inferred_iterable, util.UninferableBase) or not hasattr( inferred_iterable, "itered" ): yield util.Uninferable return try: itered = inferred_iterable.itered() # type: ignore[union-attr] except TypeError: yield util.Uninferable return target = stmt.target if not isinstance(target, nodes.Tuple): raise InferenceError( "Could not make sense of this, the target must be a tuple", context=context, ) lookups: list[tuple[int, int]] = [] _determine_starred_iteration_lookups(self, target, lookups) if not lookups: raise InferenceError( "Could not make sense of this, needs at least a lookup", context=context ) # Make the last lookup a slice, since that what we want for a Starred node last_element_index, last_element_length = lookups[-1] is_starred_last = last_element_index == (last_element_length - 1) lookup_slice = slice( last_element_index, None if is_starred_last else (last_element_length - last_element_index), ) last_lookup = lookup_slice for element in itered: # We probably want to infer the potential values for each element in an # iterable, but we can't infer a list of all values, when only a list of # step values are expected: # # for a, b in [...]: # b # # b* should now point to just the elements at that particular iteration step, # which astroid can't know about. found_element = None for index, lookup in enumerate(lookups): if not hasattr(element, "itered"): break if index + 1 is len(lookups): cur_lookup: slice \| int = last_lookup else: # Grab just the index, not the whole length cur_lookup = lookup[0] try: itered_inner_element = element.itered() element = itered_inner_element[cur_lookup] except IndexError: break except TypeError: # Most likely the itered() call failed, cannot make sense of this yield util.Uninferable return else: found_element = element unpacked = nodes.List( ctx=Context.Store, parent=self, lineno=self.lineno, col_offset=self.col_offset, ) unpacked.postinit(elts=found_element or []) yield unpacked return yield util.Uninferable nodes.Starred.assigned_stmts = starred_assigned_stmts @decorators.yes_if_nothing_inferred def match_mapping_assigned_stmts( self: nodes.MatchMapping, node: nodes.AssignName, context: InferenceContext \| None = None, assign_path: None = None, ) -> Generator[nodes.NodeNG, None, None]: """Return empty generator (return -> raises StopIteration) so inferred value is Uninferable. """ return yield nodes.MatchMapping.assigned_stmts = match_mapping_assigned_stmts @decorators.yes_if_nothing_inferred def match_star_assigned_stmts( self: nodes.MatchStar, node: nodes.AssignName, context: InferenceContext \| None = None, assign_path: None = None, ) -> Generator[nodes.NodeNG, None, None]: """Return empty generator (return -> raises StopIteration) so inferred value is Uninferable. """ return yield nodes.MatchStar.assigned_stmts = match_star_assigned_stmts @decorators.yes_if_nothing_inferred def match_as_assigned_stmts( self: nodes.MatchAs, node: nodes.AssignName, context: InferenceContext \| None = None, assign_path: None = None, ) -> Generator[nodes.NodeNG, None, None]: """Infer MatchAs as the Match subject if it's the only MatchCase pattern else raise StopIteration to yield Uninferable. """ if ( isinstance(self.parent, nodes.MatchCase) and isinstance(self.parent.parent, nodes.Match) and self.pattern is None ): yield self.parent.parent.subject nodes.MatchAs.assigned_stmts = match_as_assigned_stmts	32.2 KB	2026-01-20 12:58
📄 raw_building.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """this module contains a set of functions to create astroid trees from scratch (build_* functions) or from living object (object_build_* functions) """ from __future__ import annotations import builtins import inspect import io import logging import os import sys import types import warnings from collections.abc import Iterable from contextlib import redirect_stderr, redirect_stdout from typing import Any, Union from astroid import bases, nodes from astroid.const import _EMPTY_OBJECT_MARKER, IS_PYPY from astroid.manager import AstroidManager from astroid.nodes import node_classes logger = logging.getLogger(__name__) _FunctionTypes = Union[ types.FunctionType, types.MethodType, types.BuiltinFunctionType, types.WrapperDescriptorType, types.MethodDescriptorType, types.ClassMethodDescriptorType, ] # the keys of CONST_CLS eg python builtin types _CONSTANTS = tuple(node_classes.CONST_CLS) _BUILTINS = vars(builtins) TYPE_NONE = type(None) TYPE_NOTIMPLEMENTED = type(NotImplemented) TYPE_ELLIPSIS = type(...) def _attach_local_node(parent, node, name: str) -> None: node.name = name # needed by add_local_node parent.add_local_node(node) def _add_dunder_class(func, member) -> None: """Add a __class__ member to the given func node, if we can determine it.""" python_cls = member.__class__ cls_name = getattr(python_cls, "__name__", None) if not cls_name: return cls_bases = [ancestor.__name__ for ancestor in python_cls.__bases__] ast_klass = build_class(cls_name, cls_bases, python_cls.__doc__) func.instance_attrs["__class__"] = [ast_klass] def attach_dummy_node(node, name: str, runtime_object=_EMPTY_OBJECT_MARKER) -> None: """create a dummy node and register it in the locals of the given node with the specified name """ enode = nodes.EmptyNode() enode.object = runtime_object _attach_local_node(node, enode, name) def attach_const_node(node, name: str, value) -> None: """create a Const node and register it in the locals of the given node with the specified name """ if name not in node.special_attributes: _attach_local_node(node, nodes.const_factory(value), name) def attach_import_node(node, modname: str, membername: str) -> None: """create a ImportFrom node and register it in the locals of the given node with the specified name """ from_node = nodes.ImportFrom(modname, [(membername, None)]) _attach_local_node(node, from_node, membername) def build_module(name: str, doc: str \| None = None) -> nodes.Module: """create and initialize an astroid Module node""" node = nodes.Module(name, pure_python=False, package=False) node.postinit( body=[], doc_node=nodes.Const(value=doc) if doc else None, ) return node def build_class( name: str, basenames: Iterable[str] = (), doc: str \| None = None ) -> nodes.ClassDef: """Create and initialize an astroid ClassDef node.""" node = nodes.ClassDef(name) node.postinit( bases=[nodes.Name(name=base, parent=node) for base in basenames], body=[], decorators=None, doc_node=nodes.Const(value=doc) if doc else None, ) return node def build_function( name: str, args: list[str] \| None = None, posonlyargs: list[str] \| None = None, defaults: list[Any] \| None = None, doc: str \| None = None, kwonlyargs: list[str] \| None = None, kwonlydefaults: list[Any] \| None = None, ) -> nodes.FunctionDef: """create and initialize an astroid FunctionDef node""" # first argument is now a list of decorators func = nodes.FunctionDef(name) argsnode = nodes.Arguments(parent=func) # If args is None we don't have any information about the signature # (in contrast to when there are no arguments and args == []). We pass # this to the builder to indicate this. if args is not None: arguments = [nodes.AssignName(name=arg, parent=argsnode) for arg in args] else: arguments = None default_nodes: list[nodes.NodeNG] \| None = [] if defaults is not None: for default in defaults: default_node = nodes.const_factory(default) default_node.parent = argsnode default_nodes.append(default_node) else: default_nodes = None kwonlydefault_nodes: list[nodes.NodeNG \| None] \| None = [] if kwonlydefaults is not None: for kwonlydefault in kwonlydefaults: kwonlydefault_node = nodes.const_factory(kwonlydefault) kwonlydefault_node.parent = argsnode kwonlydefault_nodes.append(kwonlydefault_node) else: kwonlydefault_nodes = None argsnode.postinit( args=arguments, defaults=default_nodes, kwonlyargs=[ nodes.AssignName(name=arg, parent=argsnode) for arg in kwonlyargs or () ], kw_defaults=kwonlydefault_nodes, annotations=[], posonlyargs=[ nodes.AssignName(name=arg, parent=argsnode) for arg in posonlyargs or () ], ) func.postinit( args=argsnode, body=[], doc_node=nodes.Const(value=doc) if doc else None, ) if args: register_arguments(func) return func def build_from_import(fromname: str, names: list[str]) -> nodes.ImportFrom: """create and initialize an astroid ImportFrom import statement""" return nodes.ImportFrom(fromname, [(name, None) for name in names]) def register_arguments(func: nodes.FunctionDef, args: list \| None = None) -> None: """add given arguments to local args is a list that may contains nested lists (i.e. def func(a, (b, c, d)): ...) """ # If no args are passed in, get the args from the function. if args is None: if func.args.vararg: func.set_local(func.args.vararg, func.args) if func.args.kwarg: func.set_local(func.args.kwarg, func.args) args = func.args.args # If the function has no args, there is nothing left to do. if args is None: return for arg in args: if isinstance(arg, nodes.AssignName): func.set_local(arg.name, arg) else: register_arguments(func, arg.elts) def object_build_class( node: nodes.Module \| nodes.ClassDef, member: type, localname: str ) -> nodes.ClassDef: """create astroid for a living class object""" basenames = [base.__name__ for base in member.__bases__] return _base_class_object_build(node, member, basenames, localname=localname) def _get_args_info_from_callable( member: _FunctionTypes, ) -> tuple[list[str], list[str], list[Any], list[str], list[Any]]: """Returns args, posonlyargs, defaults, kwonlyargs. :note: currently ignores the return annotation. """ signature = inspect.signature(member) args: list[str] = [] defaults: list[Any] = [] posonlyargs: list[str] = [] kwonlyargs: list[str] = [] kwonlydefaults: list[Any] = [] for param_name, param in signature.parameters.items(): if param.kind == inspect.Parameter.POSITIONAL_ONLY: posonlyargs.append(param_name) elif param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD: args.append(param_name) elif param.kind == inspect.Parameter.VAR_POSITIONAL: args.append(param_name) elif param.kind == inspect.Parameter.VAR_KEYWORD: args.append(param_name) elif param.kind == inspect.Parameter.KEYWORD_ONLY: kwonlyargs.append(param_name) if param.default is not inspect.Parameter.empty: kwonlydefaults.append(param.default) continue if param.default is not inspect.Parameter.empty: defaults.append(param.default) return args, posonlyargs, defaults, kwonlyargs, kwonlydefaults def object_build_function( node: nodes.Module \| nodes.ClassDef, member: _FunctionTypes, localname: str ) -> None: """create astroid for a living function object""" ( args, posonlyargs, defaults, kwonlyargs, kwonly_defaults, ) = _get_args_info_from_callable(member) func = build_function( getattr(member, "__name__", None) or localname, args, posonlyargs, defaults, member.__doc__, kwonlyargs=kwonlyargs, kwonlydefaults=kwonly_defaults, ) node.add_local_node(func, localname) def object_build_datadescriptor( node: nodes.Module \| nodes.ClassDef, member: type, name: str ) -> nodes.ClassDef: """create astroid for a living data descriptor object""" return _base_class_object_build(node, member, [], name) def object_build_methoddescriptor( node: nodes.Module \| nodes.ClassDef, member: _FunctionTypes, localname: str, ) -> None: """create astroid for a living method descriptor object""" # FIXME get arguments ? func = build_function( getattr(member, "__name__", None) or localname, doc=member.__doc__ ) node.add_local_node(func, localname) _add_dunder_class(func, member) def _base_class_object_build( node: nodes.Module \| nodes.ClassDef, member: type, basenames: list[str], name: str \| None = None, localname: str \| None = None, ) -> nodes.ClassDef: """create astroid for a living class object, with a given set of base names (e.g. ancestors) """ class_name = name or getattr(member, "__name__", None) or localname assert isinstance(class_name, str) klass = build_class( class_name, basenames, member.__doc__, ) klass._newstyle = isinstance(member, type) node.add_local_node(klass, localname) try: # limit the instantiation trick since it's too dangerous # (such as infinite test execution...) # this at least resolves common case such as Exception.args, # OSError.errno if issubclass(member, Exception): instdict = member().__dict__ else: raise TypeError except TypeError: pass else: for item_name, obj in instdict.items(): valnode = nodes.EmptyNode() valnode.object = obj valnode.parent = klass valnode.lineno = 1 klass.instance_attrs[item_name] = [valnode] return klass def _build_from_function( node: nodes.Module \| nodes.ClassDef, name: str, member: _FunctionTypes, module: types.ModuleType, ) -> None: # verify this is not an imported function try: code = member.__code__ # type: ignore[union-attr] except AttributeError: # Some implementations don't provide the code object, # such as Jython. code = None filename = getattr(code, "co_filename", None) if filename is None: assert isinstance(member, object) object_build_methoddescriptor(node, member, name) elif filename != getattr(module, "__file__", None): attach_dummy_node(node, name, member) else: object_build_function(node, member, name) def _safe_has_attribute(obj, member: str) -> bool: """Required because unexpected RunTimeError can be raised. See https://github.com/PyCQA/astroid/issues/1958 """ try: return hasattr(obj, member) except Exception: # pylint: disable=broad-except return False class InspectBuilder: """class for building nodes from living object this is actually a really minimal representation, including only Module, FunctionDef and ClassDef nodes and some others as guessed. """ def __init__(self, manager_instance: AstroidManager \| None = None) -> None: self._manager = manager_instance or AstroidManager() self._done: dict[types.ModuleType \| type, nodes.Module \| nodes.ClassDef] = {} self._module: types.ModuleType def inspect_build( self, module: types.ModuleType, modname: str \| None = None, path: str \| None = None, ) -> nodes.Module: """build astroid from a living module (i.e. using inspect) this is used when there is no python source code available (either because it's a built-in module or because the .py is not available) """ self._module = module if modname is None: modname = module.__name__ try: node = build_module(modname, module.__doc__) except AttributeError: # in jython, java modules have no __doc__ (see #109562) node = build_module(modname) if path is None: node.path = node.file = path else: node.path = [os.path.abspath(path)] node.file = node.path[0] node.name = modname self._manager.cache_module(node) node.package = hasattr(module, "__path__") self._done = {} self.object_build(node, module) return node def object_build( self, node: nodes.Module \| nodes.ClassDef, obj: types.ModuleType \| type ) -> None: """recursive method which create a partial ast from real objects (only function, class, and method are handled) """ if obj in self._done: return None self._done[obj] = node for name in dir(obj): # inspect.ismethod() and inspect.isbuiltin() in PyPy return # the opposite of what they do in CPython for __class_getitem__. pypy__class_getitem__ = IS_PYPY and name == "__class_getitem__" try: with warnings.catch_warnings(): warnings.simplefilter("ignore") member = getattr(obj, name) except AttributeError: # damned ExtensionClass.Base, I know you're there ! attach_dummy_node(node, name) continue if inspect.ismethod(member) and not pypy__class_getitem__: member = member.__func__ if inspect.isfunction(member): _build_from_function(node, name, member, self._module) elif inspect.isbuiltin(member) or pypy__class_getitem__: if self.imported_member(node, member, name): continue object_build_methoddescriptor(node, member, name) elif inspect.isclass(member): if self.imported_member(node, member, name): continue if member in self._done: class_node = self._done[member] assert isinstance(class_node, nodes.ClassDef) if class_node not in node.locals.get(name, ()): node.add_local_node(class_node, name) else: class_node = object_build_class(node, member, name) # recursion self.object_build(class_node, member) if name == "__class__" and class_node.parent is None: class_node.parent = self._done[self._module] elif inspect.ismethoddescriptor(member): object_build_methoddescriptor(node, member, name) elif inspect.isdatadescriptor(member): object_build_datadescriptor(node, member, name) elif isinstance(member, _CONSTANTS): attach_const_node(node, name, member) elif inspect.isroutine(member): # This should be called for Jython, where some builtin # methods aren't caught by isbuiltin branch. _build_from_function(node, name, member, self._module) elif _safe_has_attribute(member, "__all__"): module = build_module(name) _attach_local_node(node, module, name) # recursion self.object_build(module, member) else: # create an empty node so that the name is actually defined attach_dummy_node(node, name, member) return None def imported_member(self, node, member, name: str) -> bool: """verify this is not an imported class or handle it""" # /!\ some classes like ExtensionClass doesn't have a __module__ # attribute ! Also, this may trigger an exception on badly built module # (see http://www.logilab.org/ticket/57299 for instance) try: modname = getattr(member, "__module__", None) except TypeError: modname = None if modname is None: if name in {"__new__", "__subclasshook__"}: # Python 2.5.1 (r251:54863, Sep 1 2010, 22:03:14) # >>> print object.__new__.__module__ # None modname = builtins.__name__ else: attach_dummy_node(node, name, member) return True # On PyPy during bootstrapping we infer _io while _module is # builtins. In CPython _io names itself io, see http://bugs.python.org/issue18602 # Therefore, this basically checks whether we are not in PyPy. if modname == "_io" and not self._module.__name__ == "builtins": return False real_name = {"gtk": "gtk_gtk"}.get(modname, modname) if real_name != self._module.__name__: # check if it sounds valid and then add an import node, else use a # dummy node try: with redirect_stderr(io.StringIO()) as stderr, redirect_stdout( io.StringIO() ) as stdout: getattr(sys.modules[modname], name) stderr_value = stderr.getvalue() if stderr_value: logger.error( "Captured stderr while getting %s from %s:\n%s", name, sys.modules[modname], stderr_value, ) stdout_value = stdout.getvalue() if stdout_value: logger.info( "Captured stdout while getting %s from %s:\n%s", name, sys.modules[modname], stdout_value, ) except (KeyError, AttributeError): attach_dummy_node(node, name, member) else: attach_import_node(node, modname, name) return True return False # astroid bootstrapping ###################################################### _CONST_PROXY: dict[type, nodes.ClassDef] = {} def _set_proxied(const) -> nodes.ClassDef: # TODO : find a nicer way to handle this situation; return _CONST_PROXY[const.value.__class__] def _astroid_bootstrapping() -> None: """astroid bootstrapping the builtins module""" # this boot strapping is necessary since we need the Const nodes to # inspect_build builtins, and then we can proxy Const builder = InspectBuilder() astroid_builtin = builder.inspect_build(builtins) for cls, node_cls in node_classes.CONST_CLS.items(): if cls is TYPE_NONE: proxy = build_class("NoneType") proxy.parent = astroid_builtin elif cls is TYPE_NOTIMPLEMENTED: proxy = build_class("NotImplementedType") proxy.parent = astroid_builtin elif cls is TYPE_ELLIPSIS: proxy = build_class("Ellipsis") proxy.parent = astroid_builtin else: proxy = astroid_builtin.getattr(cls.__name__)[0] assert isinstance(proxy, nodes.ClassDef) if cls in (dict, list, set, tuple): node_cls._proxied = proxy else: _CONST_PROXY[cls] = proxy # Set the builtin module as parent for some builtins. nodes.Const._proxied = property(_set_proxied) _GeneratorType = nodes.ClassDef(types.GeneratorType.__name__) _GeneratorType.parent = astroid_builtin generator_doc_node = ( nodes.Const(value=types.GeneratorType.__doc__) if types.GeneratorType.__doc__ else None ) _GeneratorType.postinit( bases=[], body=[], decorators=None, doc_node=generator_doc_node, ) bases.Generator._proxied = _GeneratorType builder.object_build(bases.Generator._proxied, types.GeneratorType) if hasattr(types, "AsyncGeneratorType"): _AsyncGeneratorType = nodes.ClassDef(types.AsyncGeneratorType.__name__) _AsyncGeneratorType.parent = astroid_builtin async_generator_doc_node = ( nodes.Const(value=types.AsyncGeneratorType.__doc__) if types.AsyncGeneratorType.__doc__ else None ) _AsyncGeneratorType.postinit( bases=[], body=[], decorators=None, doc_node=async_generator_doc_node, ) bases.AsyncGenerator._proxied = _AsyncGeneratorType builder.object_build(bases.AsyncGenerator._proxied, types.AsyncGeneratorType) if hasattr(types, "UnionType"): _UnionTypeType = nodes.ClassDef(types.UnionType.__name__) _UnionTypeType.parent = astroid_builtin union_type_doc_node = ( nodes.Const(value=types.UnionType.__doc__) if types.UnionType.__doc__ else None ) _UnionTypeType.postinit( bases=[], body=[], decorators=None, doc_node=union_type_doc_node, ) bases.UnionType._proxied = _UnionTypeType builder.object_build(bases.UnionType._proxied, types.UnionType) builtin_types = ( types.GetSetDescriptorType, types.GeneratorType, types.MemberDescriptorType, TYPE_NONE, TYPE_NOTIMPLEMENTED, types.FunctionType, types.MethodType, types.BuiltinFunctionType, types.ModuleType, types.TracebackType, ) for _type in builtin_types: if _type.__name__ not in astroid_builtin: klass = nodes.ClassDef(_type.__name__) klass.parent = astroid_builtin klass.postinit( bases=[], body=[], decorators=None, doc_node=nodes.Const(value=_type.__doc__) if _type.__doc__ else None, ) builder.object_build(klass, _type) astroid_builtin[_type.__name__] = klass _astroid_bootstrapping()	22.34 KB	2026-01-20 12:58
📄 rebuilder.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """This module contains utilities for rebuilding an _ast tree in order to get a single Astroid representation. """ from __future__ import annotations import ast import sys import token from collections.abc import Callable, Generator from io import StringIO from tokenize import TokenInfo, generate_tokens from typing import TYPE_CHECKING, TypeVar, Union, cast, overload from astroid import nodes from astroid._ast import ParserModule, get_parser_module, parse_function_type_comment from astroid.const import IS_PYPY, PY38, PY38_PLUS, PY39_PLUS, Context from astroid.manager import AstroidManager from astroid.nodes import NodeNG from astroid.nodes.utils import Position from astroid.typing import SuccessfulInferenceResult if sys.version_info >= (3, 8): from typing import Final else: from typing_extensions import Final REDIRECT: Final[dict[str, str]] = { "arguments": "Arguments", "comprehension": "Comprehension", "ListCompFor": "Comprehension", "GenExprFor": "Comprehension", "excepthandler": "ExceptHandler", "keyword": "Keyword", "match_case": "MatchCase", } T_Doc = TypeVar( "T_Doc", "ast.Module", "ast.ClassDef", Union["ast.FunctionDef", "ast.AsyncFunctionDef"], ) _FunctionT = TypeVar("_FunctionT", nodes.FunctionDef, nodes.AsyncFunctionDef) _ForT = TypeVar("_ForT", nodes.For, nodes.AsyncFor) _WithT = TypeVar("_WithT", nodes.With, nodes.AsyncWith) NodesWithDocsType = Union[nodes.Module, nodes.ClassDef, nodes.FunctionDef] # noinspection PyMethodMayBeStatic class TreeRebuilder: """Rebuilds the _ast tree to become an Astroid tree.""" def __init__( self, manager: AstroidManager, parser_module: ParserModule \| None = None, data: str \| None = None, ) -> None: self._manager = manager self._data = data.split("\n") if data else None self._global_names: list[dict[str, list[nodes.Global]]] = [] self._import_from_nodes: list[nodes.ImportFrom] = [] self._delayed_assattr: list[nodes.AssignAttr] = [] self._visit_meths: dict[type[ast.AST], Callable[[ast.AST, NodeNG], NodeNG]] = {} if parser_module is None: self._parser_module = get_parser_module() else: self._parser_module = parser_module self._module = self._parser_module.module def _get_doc(self, node: T_Doc) -> tuple[T_Doc, ast.Constant \| ast.Str \| None]: """Return the doc ast node.""" try: if node.body and isinstance(node.body[0], self._module.Expr): first_value = node.body[0].value if isinstance(first_value, self._module.Str) or ( PY38_PLUS and isinstance(first_value, self._module.Constant) and isinstance(first_value.value, str) ): doc_ast_node = first_value node.body = node.body[1:] # The ast parser of python < 3.8 sets col_offset of multi-line strings to -1 # as it is unable to determine the value correctly. We reset this to None. if doc_ast_node.col_offset == -1: doc_ast_node.col_offset = None return node, doc_ast_node except IndexError: pass # ast built from scratch return node, None def _get_context( self, node: ( ast.Attribute \| ast.List \| ast.Name \| ast.Subscript \| ast.Starred \| ast.Tuple ), ) -> Context: return self._parser_module.context_classes.get(type(node.ctx), Context.Load) def _get_position_info( self, node: ast.ClassDef \| ast.FunctionDef \| ast.AsyncFunctionDef, parent: nodes.ClassDef \| nodes.FunctionDef \| nodes.AsyncFunctionDef, ) -> Position \| None: """Return position information for ClassDef and FunctionDef nodes. In contrast to AST positions, these only include the actual keyword(s) and the class / function name. >>> @decorator >>> async def some_func(var: int) -> None: >>> ^^^^^^^^^^^^^^^^^^^ """ if not self._data: return None end_lineno: int \| None = getattr(node, "end_lineno", None) if node.body: end_lineno = node.body[0].lineno # pylint: disable-next=unsubscriptable-object data = "\n".join(self._data[node.lineno - 1 : end_lineno]) start_token: TokenInfo \| None = None keyword_tokens: tuple[int, ...] = (token.NAME,) if isinstance(parent, nodes.AsyncFunctionDef): search_token = "async" elif isinstance(parent, nodes.FunctionDef): search_token = "def" else: search_token = "class" for t in generate_tokens(StringIO(data).readline): if ( start_token is not None and t.type == token.NAME and t.string == node.name ): break if t.type in keyword_tokens: if t.string == search_token: start_token = t continue if t.string in {"def"}: continue start_token = None else: return None return Position( lineno=node.lineno + start_token.start[0] - 1, col_offset=start_token.start[1], end_lineno=node.lineno + t.end[0] - 1, end_col_offset=t.end[1], ) def _fix_doc_node_position(self, node: NodesWithDocsType) -> None: """Fix start and end position of doc nodes for Python < 3.8.""" if not self._data or not node.doc_node or node.lineno is None: return if PY38_PLUS: return lineno = node.lineno or 1 # lineno of modules is 0 end_range: int \| None = node.doc_node.lineno if IS_PYPY and not PY39_PLUS: end_range = None # pylint: disable-next=unsubscriptable-object data = "\n".join(self._data[lineno - 1 : end_range]) found_start, found_end = False, False open_brackets = 0 skip_token: set[int] = {token.NEWLINE, token.INDENT, token.NL, token.COMMENT} if isinstance(node, nodes.Module): found_end = True for t in generate_tokens(StringIO(data).readline): if found_end is False: if ( found_start is False and t.type == token.NAME and t.string in {"def", "class"} ): found_start = True elif found_start is True and t.type == token.OP: if t.exact_type == token.COLON and open_brackets == 0: found_end = True elif t.exact_type == token.LPAR: open_brackets += 1 elif t.exact_type == token.RPAR: open_brackets -= 1 continue if t.type in skip_token: continue if t.type == token.STRING: break return else: return node.doc_node.lineno = lineno + t.start[0] - 1 node.doc_node.col_offset = t.start[1] node.doc_node.end_lineno = lineno + t.end[0] - 1 node.doc_node.end_col_offset = t.end[1] def _reset_end_lineno(self, newnode: nodes.NodeNG) -> None: """Reset end_lineno and end_col_offset attributes for PyPy 3.8. For some nodes, these are either set to -1 or only partially assigned. To keep consistency across astroid and pylint, reset all. This has been fixed in PyPy 3.9. For reference, an (incomplete) list of nodes with issues: - ClassDef - For - FunctionDef - While - Call - If - Decorators - TryExcept - With - TryFinally - Assign """ newnode.end_lineno = None newnode.end_col_offset = None for child_node in newnode.get_children(): self._reset_end_lineno(child_node) def visit_module( self, node: ast.Module, modname: str, modpath: str, package: bool ) -> nodes.Module: """Visit a Module node by returning a fresh instance of it. Note: Method not called by 'visit' """ node, doc_ast_node = self._get_doc(node) newnode = nodes.Module( name=modname, file=modpath, path=[modpath], package=package, parent=None, ) newnode.postinit( [self.visit(child, newnode) for child in node.body], doc_node=self.visit(doc_ast_node, newnode), ) self._fix_doc_node_position(newnode) if IS_PYPY and PY38: self._reset_end_lineno(newnode) return newnode if TYPE_CHECKING: # noqa: C901 @overload def visit(self, node: ast.arg, parent: NodeNG) -> nodes.AssignName: ... @overload def visit(self, node: ast.arguments, parent: NodeNG) -> nodes.Arguments: ... @overload def visit(self, node: ast.Assert, parent: NodeNG) -> nodes.Assert: ... @overload def visit( self, node: ast.AsyncFunctionDef, parent: NodeNG ) -> nodes.AsyncFunctionDef: ... @overload def visit(self, node: ast.AsyncFor, parent: NodeNG) -> nodes.AsyncFor: ... @overload def visit(self, node: ast.Await, parent: NodeNG) -> nodes.Await: ... @overload def visit(self, node: ast.AsyncWith, parent: NodeNG) -> nodes.AsyncWith: ... @overload def visit(self, node: ast.Assign, parent: NodeNG) -> nodes.Assign: ... @overload def visit(self, node: ast.AnnAssign, parent: NodeNG) -> nodes.AnnAssign: ... @overload def visit(self, node: ast.AugAssign, parent: NodeNG) -> nodes.AugAssign: ... @overload def visit(self, node: ast.BinOp, parent: NodeNG) -> nodes.BinOp: ... @overload def visit(self, node: ast.BoolOp, parent: NodeNG) -> nodes.BoolOp: ... @overload def visit(self, node: ast.Break, parent: NodeNG) -> nodes.Break: ... @overload def visit(self, node: ast.Call, parent: NodeNG) -> nodes.Call: ... @overload def visit(self, node: ast.ClassDef, parent: NodeNG) -> nodes.ClassDef: ... @overload def visit(self, node: ast.Continue, parent: NodeNG) -> nodes.Continue: ... @overload def visit(self, node: ast.Compare, parent: NodeNG) -> nodes.Compare: ... @overload def visit(self, node: ast.comprehension, parent: NodeNG) -> nodes.Comprehension: ... @overload def visit(self, node: ast.Delete, parent: NodeNG) -> nodes.Delete: ... @overload def visit(self, node: ast.Dict, parent: NodeNG) -> nodes.Dict: ... @overload def visit(self, node: ast.DictComp, parent: NodeNG) -> nodes.DictComp: ... @overload def visit(self, node: ast.Expr, parent: NodeNG) -> nodes.Expr: ... @overload def visit(self, node: ast.ExceptHandler, parent: NodeNG) -> nodes.ExceptHandler: ... @overload def visit(self, node: ast.For, parent: NodeNG) -> nodes.For: ... @overload def visit(self, node: ast.ImportFrom, parent: NodeNG) -> nodes.ImportFrom: ... @overload def visit(self, node: ast.FunctionDef, parent: NodeNG) -> nodes.FunctionDef: ... @overload def visit(self, node: ast.GeneratorExp, parent: NodeNG) -> nodes.GeneratorExp: ... @overload def visit(self, node: ast.Attribute, parent: NodeNG) -> nodes.Attribute: ... @overload def visit(self, node: ast.Global, parent: NodeNG) -> nodes.Global: ... @overload def visit(self, node: ast.If, parent: NodeNG) -> nodes.If: ... @overload def visit(self, node: ast.IfExp, parent: NodeNG) -> nodes.IfExp: ... @overload def visit(self, node: ast.Import, parent: NodeNG) -> nodes.Import: ... @overload def visit(self, node: ast.JoinedStr, parent: NodeNG) -> nodes.JoinedStr: ... @overload def visit( self, node: ast.FormattedValue, parent: NodeNG ) -> nodes.FormattedValue: ... if sys.version_info >= (3, 8): @overload def visit(self, node: ast.NamedExpr, parent: NodeNG) -> nodes.NamedExpr: ... if sys.version_info < (3, 9): # Not used in Python 3.9+ @overload def visit(self, node: ast.ExtSlice, parent: nodes.Subscript) -> nodes.Tuple: ... @overload def visit(self, node: ast.Index, parent: nodes.Subscript) -> NodeNG: ... @overload def visit(self, node: ast.keyword, parent: NodeNG) -> nodes.Keyword: ... @overload def visit(self, node: ast.Lambda, parent: NodeNG) -> nodes.Lambda: ... @overload def visit(self, node: ast.List, parent: NodeNG) -> nodes.List: ... @overload def visit(self, node: ast.ListComp, parent: NodeNG) -> nodes.ListComp: ... @overload def visit( self, node: ast.Name, parent: NodeNG ) -> nodes.Name \| nodes.Const \| nodes.AssignName \| nodes.DelName: ... @overload def visit(self, node: ast.Nonlocal, parent: NodeNG) -> nodes.Nonlocal: ... if sys.version_info < (3, 8): # Not used in Python 3.8+ @overload def visit(self, node: ast.Ellipsis, parent: NodeNG) -> nodes.Const: ... @overload def visit(self, node: ast.NameConstant, parent: NodeNG) -> nodes.Const: ... @overload def visit(self, node: ast.Str, parent: NodeNG) -> nodes.Const: ... @overload def visit(self, node: ast.Bytes, parent: NodeNG) -> nodes.Const: ... @overload def visit(self, node: ast.Num, parent: NodeNG) -> nodes.Const: ... @overload def visit(self, node: ast.Constant, parent: NodeNG) -> nodes.Const: ... @overload def visit(self, node: ast.Pass, parent: NodeNG) -> nodes.Pass: ... @overload def visit(self, node: ast.Raise, parent: NodeNG) -> nodes.Raise: ... @overload def visit(self, node: ast.Return, parent: NodeNG) -> nodes.Return: ... @overload def visit(self, node: ast.Set, parent: NodeNG) -> nodes.Set: ... @overload def visit(self, node: ast.SetComp, parent: NodeNG) -> nodes.SetComp: ... @overload def visit(self, node: ast.Slice, parent: nodes.Subscript) -> nodes.Slice: ... @overload def visit(self, node: ast.Subscript, parent: NodeNG) -> nodes.Subscript: ... @overload def visit(self, node: ast.Starred, parent: NodeNG) -> nodes.Starred: ... @overload def visit( self, node: ast.Try, parent: NodeNG ) -> nodes.TryExcept \| nodes.TryFinally: ... if sys.version_info >= (3, 11): @overload def visit(self, node: ast.TryStar, parent: NodeNG) -> nodes.TryStar: ... @overload def visit(self, node: ast.Tuple, parent: NodeNG) -> nodes.Tuple: ... @overload def visit(self, node: ast.UnaryOp, parent: NodeNG) -> nodes.UnaryOp: ... @overload def visit(self, node: ast.While, parent: NodeNG) -> nodes.While: ... @overload def visit(self, node: ast.With, parent: NodeNG) -> nodes.With: ... @overload def visit(self, node: ast.Yield, parent: NodeNG) -> nodes.Yield: ... @overload def visit(self, node: ast.YieldFrom, parent: NodeNG) -> nodes.YieldFrom: ... if sys.version_info >= (3, 10): @overload def visit(self, node: ast.Match, parent: NodeNG) -> nodes.Match: ... @overload def visit(self, node: ast.match_case, parent: NodeNG) -> nodes.MatchCase: ... @overload def visit(self, node: ast.MatchValue, parent: NodeNG) -> nodes.MatchValue: ... @overload def visit( self, node: ast.MatchSingleton, parent: NodeNG ) -> nodes.MatchSingleton: ... @overload def visit( self, node: ast.MatchSequence, parent: NodeNG ) -> nodes.MatchSequence: ... @overload def visit( self, node: ast.MatchMapping, parent: NodeNG ) -> nodes.MatchMapping: ... @overload def visit(self, node: ast.MatchClass, parent: NodeNG) -> nodes.MatchClass: ... @overload def visit(self, node: ast.MatchStar, parent: NodeNG) -> nodes.MatchStar: ... @overload def visit(self, node: ast.MatchAs, parent: NodeNG) -> nodes.MatchAs: ... @overload def visit(self, node: ast.MatchOr, parent: NodeNG) -> nodes.MatchOr: ... @overload def visit(self, node: ast.pattern, parent: NodeNG) -> nodes.Pattern: ... @overload def visit(self, node: ast.AST, parent: NodeNG) -> NodeNG: ... @overload def visit(self, node: None, parent: NodeNG) -> None: ... def visit(self, node: ast.AST \| None, parent: NodeNG) -> NodeNG \| None: if node is None: return None cls = node.__class__ if cls in self._visit_meths: visit_method = self._visit_meths[cls] else: cls_name = cls.__name__ visit_name = "visit_" + REDIRECT.get(cls_name, cls_name).lower() visit_method = getattr(self, visit_name) self._visit_meths[cls] = visit_method return visit_method(node, parent) def _save_assignment(self, node: nodes.AssignName \| nodes.DelName) -> None: """Save assignment situation since node.parent is not available yet.""" if self._global_names and node.name in self._global_names[-1]: node.root().set_local(node.name, node) else: assert node.parent assert node.name node.parent.set_local(node.name, node) def visit_arg(self, node: ast.arg, parent: NodeNG) -> nodes.AssignName: """Visit an arg node by returning a fresh AssName instance.""" return self.visit_assignname(node, parent, node.arg) def visit_arguments(self, node: ast.arguments, parent: NodeNG) -> nodes.Arguments: """Visit an Arguments node by returning a fresh instance of it.""" vararg: str \| None = None kwarg: str \| None = None newnode = nodes.Arguments( node.vararg.arg if node.vararg else None, node.kwarg.arg if node.kwarg else None, parent, ) args = [self.visit(child, newnode) for child in node.args] defaults = [self.visit(child, newnode) for child in node.defaults] varargannotation: NodeNG \| None = None kwargannotation: NodeNG \| None = None posonlyargs: list[nodes.AssignName] = [] if node.vararg: vararg = node.vararg.arg varargannotation = self.visit(node.vararg.annotation, newnode) if node.kwarg: kwarg = node.kwarg.arg kwargannotation = self.visit(node.kwarg.annotation, newnode) if PY38: # In Python 3.8 'end_lineno' and 'end_col_offset' # for 'kwonlyargs' don't include the annotation. for arg in node.kwonlyargs: if arg.annotation is not None: arg.end_lineno = arg.annotation.end_lineno arg.end_col_offset = arg.annotation.end_col_offset kwonlyargs = [self.visit(child, newnode) for child in node.kwonlyargs] kw_defaults = [self.visit(child, newnode) for child in node.kw_defaults] annotations = [self.visit(arg.annotation, newnode) for arg in node.args] kwonlyargs_annotations = [ self.visit(arg.annotation, newnode) for arg in node.kwonlyargs ] posonlyargs_annotations: list[NodeNG \| None] = [] if PY38_PLUS: posonlyargs = [self.visit(child, newnode) for child in node.posonlyargs] posonlyargs_annotations = [ self.visit(arg.annotation, newnode) for arg in node.posonlyargs ] type_comment_args = [ self.check_type_comment(child, parent=newnode) for child in node.args ] type_comment_kwonlyargs = [ self.check_type_comment(child, parent=newnode) for child in node.kwonlyargs ] type_comment_posonlyargs: list[NodeNG \| None] = [] if PY38_PLUS: type_comment_posonlyargs = [ self.check_type_comment(child, parent=newnode) for child in node.posonlyargs ] newnode.postinit( args=args, defaults=defaults, kwonlyargs=kwonlyargs, posonlyargs=posonlyargs, kw_defaults=kw_defaults, annotations=annotations, kwonlyargs_annotations=kwonlyargs_annotations, posonlyargs_annotations=posonlyargs_annotations, varargannotation=varargannotation, kwargannotation=kwargannotation, type_comment_args=type_comment_args, type_comment_kwonlyargs=type_comment_kwonlyargs, type_comment_posonlyargs=type_comment_posonlyargs, ) # save argument names in locals: assert newnode.parent if vararg: newnode.parent.set_local(vararg, newnode) if kwarg: newnode.parent.set_local(kwarg, newnode) return newnode def visit_assert(self, node: ast.Assert, parent: NodeNG) -> nodes.Assert: """Visit a Assert node by returning a fresh instance of it.""" newnode = nodes.Assert( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) msg: NodeNG \| None = None if node.msg: msg = self.visit(node.msg, newnode) newnode.postinit(self.visit(node.test, newnode), msg) return newnode def check_type_comment( self, node: ( ast.Assign \| ast.arg \| ast.For \| ast.AsyncFor \| ast.With \| ast.AsyncWith ), parent: ( nodes.Assign \| nodes.Arguments \| nodes.For \| nodes.AsyncFor \| nodes.With \| nodes.AsyncWith ), ) -> NodeNG \| None: type_comment = getattr(node, "type_comment", None) # Added in Python 3.8 if not type_comment: return None try: type_comment_ast = self._parser_module.parse(type_comment) except SyntaxError: # Invalid type comment, just skip it. return None # For '# type: # any comment' ast.parse returns a Module node, # without any nodes in the body. if not type_comment_ast.body: return None type_object = self.visit(type_comment_ast.body[0], parent=parent) if not isinstance(type_object, nodes.Expr): return None return type_object.value def check_function_type_comment( self, node: ast.FunctionDef \| ast.AsyncFunctionDef, parent: NodeNG ) -> tuple[NodeNG \| None, list[NodeNG]] \| None: type_comment = getattr(node, "type_comment", None) # Added in Python 3.8 if not type_comment: return None try: type_comment_ast = parse_function_type_comment(type_comment) except SyntaxError: # Invalid type comment, just skip it. return None if not type_comment_ast: return None returns: NodeNG \| None = None argtypes: list[NodeNG] = [ self.visit(elem, parent) for elem in (type_comment_ast.argtypes or []) ] if type_comment_ast.returns: returns = self.visit(type_comment_ast.returns, parent) return returns, argtypes def visit_asyncfunctiondef( self, node: ast.AsyncFunctionDef, parent: NodeNG ) -> nodes.AsyncFunctionDef: return self._visit_functiondef(nodes.AsyncFunctionDef, node, parent) def visit_asyncfor(self, node: ast.AsyncFor, parent: NodeNG) -> nodes.AsyncFor: return self._visit_for(nodes.AsyncFor, node, parent) def visit_await(self, node: ast.Await, parent: NodeNG) -> nodes.Await: newnode = nodes.Await( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit(value=self.visit(node.value, newnode)) return newnode def visit_asyncwith(self, node: ast.AsyncWith, parent: NodeNG) -> nodes.AsyncWith: return self._visit_with(nodes.AsyncWith, node, parent) def visit_assign(self, node: ast.Assign, parent: NodeNG) -> nodes.Assign: """Visit a Assign node by returning a fresh instance of it.""" newnode = nodes.Assign( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) type_annotation = self.check_type_comment(node, parent=newnode) newnode.postinit( targets=[self.visit(child, newnode) for child in node.targets], value=self.visit(node.value, newnode), type_annotation=type_annotation, ) return newnode def visit_annassign(self, node: ast.AnnAssign, parent: NodeNG) -> nodes.AnnAssign: """Visit an AnnAssign node by returning a fresh instance of it.""" newnode = nodes.AnnAssign( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( target=self.visit(node.target, newnode), annotation=self.visit(node.annotation, newnode), simple=node.simple, value=self.visit(node.value, newnode), ) return newnode @overload def visit_assignname( self, node: ast.AST, parent: NodeNG, node_name: str ) -> nodes.AssignName: ... @overload def visit_assignname(self, node: ast.AST, parent: NodeNG, node_name: None) -> None: ... def visit_assignname( self, node: ast.AST, parent: NodeNG, node_name: str \| None ) -> nodes.AssignName \| None: """Visit a node and return a AssignName node. Note: Method not called by 'visit' """ if node_name is None: return None newnode = nodes.AssignName( name=node_name, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) self._save_assignment(newnode) return newnode def visit_augassign(self, node: ast.AugAssign, parent: NodeNG) -> nodes.AugAssign: """Visit a AugAssign node by returning a fresh instance of it.""" newnode = nodes.AugAssign( op=self._parser_module.bin_op_classes[type(node.op)] + "=", lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.target, newnode), self.visit(node.value, newnode) ) return newnode def visit_binop(self, node: ast.BinOp, parent: NodeNG) -> nodes.BinOp: """Visit a BinOp node by returning a fresh instance of it.""" newnode = nodes.BinOp( op=self._parser_module.bin_op_classes[type(node.op)], lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.left, newnode), self.visit(node.right, newnode) ) return newnode def visit_boolop(self, node: ast.BoolOp, parent: NodeNG) -> nodes.BoolOp: """Visit a BoolOp node by returning a fresh instance of it.""" newnode = nodes.BoolOp( op=self._parser_module.bool_op_classes[type(node.op)], lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit([self.visit(child, newnode) for child in node.values]) return newnode def visit_break(self, node: ast.Break, parent: NodeNG) -> nodes.Break: """Visit a Break node by returning a fresh instance of it.""" return nodes.Break( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) def visit_call(self, node: ast.Call, parent: NodeNG) -> nodes.Call: """Visit a CallFunc node by returning a fresh instance of it.""" newnode = nodes.Call( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( func=self.visit(node.func, newnode), args=[self.visit(child, newnode) for child in node.args], keywords=[self.visit(child, newnode) for child in node.keywords], ) return newnode def visit_classdef( self, node: ast.ClassDef, parent: NodeNG, newstyle: bool = True ) -> nodes.ClassDef: """Visit a ClassDef node to become astroid.""" node, doc_ast_node = self._get_doc(node) newnode = nodes.ClassDef( name=node.name, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) metaclass = None for keyword in node.keywords: if keyword.arg == "metaclass": metaclass = self.visit(keyword, newnode).value break decorators = self.visit_decorators(node, newnode) newnode.postinit( [self.visit(child, newnode) for child in node.bases], [self.visit(child, newnode) for child in node.body], decorators, newstyle, metaclass, [ self.visit(kwd, newnode) for kwd in node.keywords if kwd.arg != "metaclass" ], position=self._get_position_info(node, newnode), doc_node=self.visit(doc_ast_node, newnode), ) self._fix_doc_node_position(newnode) return newnode def visit_continue(self, node: ast.Continue, parent: NodeNG) -> nodes.Continue: """Visit a Continue node by returning a fresh instance of it.""" return nodes.Continue( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) def visit_compare(self, node: ast.Compare, parent: NodeNG) -> nodes.Compare: """Visit a Compare node by returning a fresh instance of it.""" newnode = nodes.Compare( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.left, newnode), [ ( self._parser_module.cmp_op_classes[op.__class__], self.visit(expr, newnode), ) for (op, expr) in zip(node.ops, node.comparators) ], ) return newnode def visit_comprehension( self, node: ast.comprehension, parent: NodeNG ) -> nodes.Comprehension: """Visit a Comprehension node by returning a fresh instance of it.""" newnode = nodes.Comprehension(parent) newnode.postinit( self.visit(node.target, newnode), self.visit(node.iter, newnode), [self.visit(child, newnode) for child in node.ifs], bool(node.is_async), ) return newnode def visit_decorators( self, node: ast.ClassDef \| ast.FunctionDef \| ast.AsyncFunctionDef, parent: NodeNG, ) -> nodes.Decorators \| None: """Visit a Decorators node by returning a fresh instance of it. Note: Method not called by 'visit' """ if not node.decorator_list: return None # /!\ node is actually an _ast.FunctionDef node while # parent is an astroid.nodes.FunctionDef node if sys.version_info >= (3, 8): # Set the line number of the first decorator for Python 3.8+. lineno = node.decorator_list[0].lineno end_lineno = node.decorator_list[-1].end_lineno end_col_offset = node.decorator_list[-1].end_col_offset else: lineno = node.lineno end_lineno = None end_col_offset = None newnode = nodes.Decorators( lineno=lineno, col_offset=node.col_offset, end_lineno=end_lineno, end_col_offset=end_col_offset, parent=parent, ) newnode.postinit([self.visit(child, newnode) for child in node.decorator_list]) return newnode def visit_delete(self, node: ast.Delete, parent: NodeNG) -> nodes.Delete: """Visit a Delete node by returning a fresh instance of it.""" newnode = nodes.Delete( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit([self.visit(child, newnode) for child in node.targets]) return newnode def _visit_dict_items( self, node: ast.Dict, parent: NodeNG, newnode: nodes.Dict ) -> Generator[tuple[NodeNG, NodeNG], None, None]: for key, value in zip(node.keys, node.values): rebuilt_key: NodeNG rebuilt_value = self.visit(value, newnode) if not key: # Extended unpacking rebuilt_key = nodes.DictUnpack( lineno=rebuilt_value.lineno, col_offset=rebuilt_value.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(rebuilt_value, "end_lineno", None), end_col_offset=getattr(rebuilt_value, "end_col_offset", None), parent=parent, ) else: rebuilt_key = self.visit(key, newnode) yield rebuilt_key, rebuilt_value def visit_dict(self, node: ast.Dict, parent: NodeNG) -> nodes.Dict: """Visit a Dict node by returning a fresh instance of it.""" newnode = nodes.Dict( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) items: list[tuple[SuccessfulInferenceResult, SuccessfulInferenceResult]] = list( self._visit_dict_items(node, parent, newnode) ) newnode.postinit(items) return newnode def visit_dictcomp(self, node: ast.DictComp, parent: NodeNG) -> nodes.DictComp: """Visit a DictComp node by returning a fresh instance of it.""" newnode = nodes.DictComp( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.key, newnode), self.visit(node.value, newnode), [self.visit(child, newnode) for child in node.generators], ) return newnode def visit_expr(self, node: ast.Expr, parent: NodeNG) -> nodes.Expr: """Visit a Expr node by returning a fresh instance of it.""" newnode = nodes.Expr( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit(self.visit(node.value, newnode)) return newnode def visit_excepthandler( self, node: ast.ExceptHandler, parent: NodeNG ) -> nodes.ExceptHandler: """Visit an ExceptHandler node by returning a fresh instance of it.""" newnode = nodes.ExceptHandler( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.type, newnode), self.visit_assignname(node, newnode, node.name), [self.visit(child, newnode) for child in node.body], ) return newnode @overload def _visit_for( self, cls: type[nodes.For], node: ast.For, parent: NodeNG ) -> nodes.For: ... @overload def _visit_for( self, cls: type[nodes.AsyncFor], node: ast.AsyncFor, parent: NodeNG ) -> nodes.AsyncFor: ... def _visit_for( self, cls: type[_ForT], node: ast.For \| ast.AsyncFor, parent: NodeNG ) -> _ForT: """Visit a For node by returning a fresh instance of it.""" col_offset = node.col_offset if IS_PYPY and not PY39_PLUS and isinstance(node, ast.AsyncFor) and self._data: # pylint: disable-next=unsubscriptable-object col_offset = self._data[node.lineno - 1].index("async") newnode = cls( lineno=node.lineno, col_offset=col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) type_annotation = self.check_type_comment(node, parent=newnode) newnode.postinit( target=self.visit(node.target, newnode), iter=self.visit(node.iter, newnode), body=[self.visit(child, newnode) for child in node.body], orelse=[self.visit(child, newnode) for child in node.orelse], type_annotation=type_annotation, ) return newnode def visit_for(self, node: ast.For, parent: NodeNG) -> nodes.For: return self._visit_for(nodes.For, node, parent) def visit_importfrom( self, node: ast.ImportFrom, parent: NodeNG ) -> nodes.ImportFrom: """Visit an ImportFrom node by returning a fresh instance of it.""" names = [(alias.name, alias.asname) for alias in node.names] newnode = nodes.ImportFrom( fromname=node.module or "", names=names, level=node.level or None, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) # store From names to add them to locals after building self._import_from_nodes.append(newnode) return newnode @overload def _visit_functiondef( self, cls: type[nodes.FunctionDef], node: ast.FunctionDef, parent: NodeNG ) -> nodes.FunctionDef: ... @overload def _visit_functiondef( self, cls: type[nodes.AsyncFunctionDef], node: ast.AsyncFunctionDef, parent: NodeNG, ) -> nodes.AsyncFunctionDef: ... def _visit_functiondef( self, cls: type[_FunctionT], node: ast.FunctionDef \| ast.AsyncFunctionDef, parent: NodeNG, ) -> _FunctionT: """Visit an FunctionDef node to become astroid.""" self._global_names.append({}) node, doc_ast_node = self._get_doc(node) lineno = node.lineno if PY38_PLUS and node.decorator_list: # Python 3.8 sets the line number of a decorated function # to be the actual line number of the function, but the # previous versions expected the decorator's line number instead. # We reset the function's line number to that of the # first decorator to maintain backward compatibility. # It's not ideal but this discrepancy was baked into # the framework for years. lineno = node.decorator_list[0].lineno newnode = cls( name=node.name, lineno=lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) decorators = self.visit_decorators(node, newnode) returns: NodeNG \| None if node.returns: returns = self.visit(node.returns, newnode) else: returns = None type_comment_args = type_comment_returns = None type_comment_annotation = self.check_function_type_comment(node, newnode) if type_comment_annotation: type_comment_returns, type_comment_args = type_comment_annotation newnode.postinit( args=self.visit(node.args, newnode), body=[self.visit(child, newnode) for child in node.body], decorators=decorators, returns=returns, type_comment_returns=type_comment_returns, type_comment_args=type_comment_args, position=self._get_position_info(node, newnode), doc_node=self.visit(doc_ast_node, newnode), ) self._fix_doc_node_position(newnode) self._global_names.pop() return newnode def visit_functiondef( self, node: ast.FunctionDef, parent: NodeNG ) -> nodes.FunctionDef: return self._visit_functiondef(nodes.FunctionDef, node, parent) def visit_generatorexp( self, node: ast.GeneratorExp, parent: NodeNG ) -> nodes.GeneratorExp: """Visit a GeneratorExp node by returning a fresh instance of it.""" newnode = nodes.GeneratorExp( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.elt, newnode), [self.visit(child, newnode) for child in node.generators], ) return newnode def visit_attribute( self, node: ast.Attribute, parent: NodeNG ) -> nodes.Attribute \| nodes.AssignAttr \| nodes.DelAttr: """Visit an Attribute node by returning a fresh instance of it.""" context = self._get_context(node) newnode: nodes.Attribute \| nodes.AssignAttr \| nodes.DelAttr if context == Context.Del: # FIXME : maybe we should reintroduce and visit_delattr ? # for instance, deactivating assign_ctx newnode = nodes.DelAttr( attrname=node.attr, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) elif context == Context.Store: newnode = nodes.AssignAttr( attrname=node.attr, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) # Prohibit a local save if we are in an ExceptHandler. if not isinstance(parent, nodes.ExceptHandler): # mypy doesn't recognize that newnode has to be AssignAttr because it # doesn't support ParamSpec # See https://github.com/python/mypy/issues/8645 self._delayed_assattr.append(newnode) # type: ignore[arg-type] else: newnode = nodes.Attribute( attrname=node.attr, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit(self.visit(node.value, newnode)) return newnode def visit_global(self, node: ast.Global, parent: NodeNG) -> nodes.Global: """Visit a Global node to become astroid.""" newnode = nodes.Global( names=node.names, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) if self._global_names: # global at the module level, no effect for name in node.names: self._global_names[-1].setdefault(name, []).append(newnode) return newnode def visit_if(self, node: ast.If, parent: NodeNG) -> nodes.If: """Visit an If node by returning a fresh instance of it.""" newnode = nodes.If( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.test, newnode), [self.visit(child, newnode) for child in node.body], [self.visit(child, newnode) for child in node.orelse], ) return newnode def visit_ifexp(self, node: ast.IfExp, parent: NodeNG) -> nodes.IfExp: """Visit a IfExp node by returning a fresh instance of it.""" newnode = nodes.IfExp( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.test, newnode), self.visit(node.body, newnode), self.visit(node.orelse, newnode), ) return newnode def visit_import(self, node: ast.Import, parent: NodeNG) -> nodes.Import: """Visit a Import node by returning a fresh instance of it.""" names = [(alias.name, alias.asname) for alias in node.names] newnode = nodes.Import( names=names, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) # save import names in parent's locals: for name, asname in newnode.names: name = asname or name parent.set_local(name.split(".")[0], newnode) return newnode def visit_joinedstr(self, node: ast.JoinedStr, parent: NodeNG) -> nodes.JoinedStr: newnode = nodes.JoinedStr( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit([self.visit(child, newnode) for child in node.values]) return newnode def visit_formattedvalue( self, node: ast.FormattedValue, parent: NodeNG ) -> nodes.FormattedValue: newnode = nodes.FormattedValue( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( value=self.visit(node.value, newnode), conversion=node.conversion, format_spec=self.visit(node.format_spec, newnode), ) return newnode if sys.version_info >= (3, 8): def visit_namedexpr( self, node: ast.NamedExpr, parent: NodeNG ) -> nodes.NamedExpr: newnode = nodes.NamedExpr( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.target, newnode), self.visit(node.value, newnode) ) return newnode if sys.version_info < (3, 9): # Not used in Python 3.9+. def visit_extslice( self, node: ast.ExtSlice, parent: nodes.Subscript ) -> nodes.Tuple: """Visit an ExtSlice node by returning a fresh instance of Tuple.""" # ExtSlice doesn't have lineno or col_offset information newnode = nodes.Tuple(ctx=Context.Load, parent=parent) newnode.postinit([self.visit(dim, newnode) for dim in node.dims]) return newnode def visit_index(self, node: ast.Index, parent: nodes.Subscript) -> NodeNG: """Visit a Index node by returning a fresh instance of NodeNG.""" return self.visit(node.value, parent) def visit_keyword(self, node: ast.keyword, parent: NodeNG) -> nodes.Keyword: """Visit a Keyword node by returning a fresh instance of it.""" newnode = nodes.Keyword( arg=node.arg, # position attributes added in 3.9 lineno=getattr(node, "lineno", None), col_offset=getattr(node, "col_offset", None), end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit(self.visit(node.value, newnode)) return newnode def visit_lambda(self, node: ast.Lambda, parent: NodeNG) -> nodes.Lambda: """Visit a Lambda node by returning a fresh instance of it.""" newnode = nodes.Lambda( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit(self.visit(node.args, newnode), self.visit(node.body, newnode)) return newnode def visit_list(self, node: ast.List, parent: NodeNG) -> nodes.List: """Visit a List node by returning a fresh instance of it.""" context = self._get_context(node) newnode = nodes.List( ctx=context, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit([self.visit(child, newnode) for child in node.elts]) return newnode def visit_listcomp(self, node: ast.ListComp, parent: NodeNG) -> nodes.ListComp: """Visit a ListComp node by returning a fresh instance of it.""" newnode = nodes.ListComp( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.elt, newnode), [self.visit(child, newnode) for child in node.generators], ) return newnode def visit_name( self, node: ast.Name, parent: NodeNG ) -> nodes.Name \| nodes.AssignName \| nodes.DelName: """Visit a Name node by returning a fresh instance of it.""" context = self._get_context(node) newnode: nodes.Name \| nodes.AssignName \| nodes.DelName if context == Context.Del: newnode = nodes.DelName( name=node.id, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) elif context == Context.Store: newnode = nodes.AssignName( name=node.id, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) else: newnode = nodes.Name( name=node.id, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) # XXX REMOVE me : if context in (Context.Del, Context.Store): # 'Aug' ?? newnode = cast(Union[nodes.AssignName, nodes.DelName], newnode) self._save_assignment(newnode) return newnode def visit_nonlocal(self, node: ast.Nonlocal, parent: NodeNG) -> nodes.Nonlocal: """Visit a Nonlocal node and return a new instance of it.""" return nodes.Nonlocal( names=node.names, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) def visit_constant(self, node: ast.Constant, parent: NodeNG) -> nodes.Const: """Visit a Constant node by returning a fresh instance of Const.""" return nodes.Const( value=node.value, kind=node.kind, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) if sys.version_info < (3, 8): # Not used in Python 3.8+. def visit_ellipsis(self, node: ast.Ellipsis, parent: NodeNG) -> nodes.Const: """Visit an Ellipsis node by returning a fresh instance of Const.""" return nodes.Const( value=Ellipsis, lineno=node.lineno, col_offset=node.col_offset, parent=parent, ) def visit_nameconstant( self, node: ast.NameConstant, parent: NodeNG ) -> nodes.Const: # For singleton values True / False / None return nodes.Const( node.value, node.lineno, node.col_offset, parent, ) def visit_str(self, node: ast.Str \| ast.Bytes, parent: NodeNG) -> nodes.Const: """Visit a String/Bytes node by returning a fresh instance of Const.""" return nodes.Const( node.s, node.lineno, node.col_offset, parent, ) visit_bytes = visit_str def visit_num(self, node: ast.Num, parent: NodeNG) -> nodes.Const: """Visit a Num node by returning a fresh instance of Const.""" return nodes.Const( node.n, node.lineno, node.col_offset, parent, ) def visit_pass(self, node: ast.Pass, parent: NodeNG) -> nodes.Pass: """Visit a Pass node by returning a fresh instance of it.""" return nodes.Pass( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) def visit_raise(self, node: ast.Raise, parent: NodeNG) -> nodes.Raise: """Visit a Raise node by returning a fresh instance of it.""" newnode = nodes.Raise( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) # no traceback; anyway it is not used in Pylint newnode.postinit( exc=self.visit(node.exc, newnode), cause=self.visit(node.cause, newnode), ) return newnode def visit_return(self, node: ast.Return, parent: NodeNG) -> nodes.Return: """Visit a Return node by returning a fresh instance of it.""" newnode = nodes.Return( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) if node.value is not None: newnode.postinit(self.visit(node.value, newnode)) return newnode def visit_set(self, node: ast.Set, parent: NodeNG) -> nodes.Set: """Visit a Set node by returning a fresh instance of it.""" newnode = nodes.Set( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit([self.visit(child, newnode) for child in node.elts]) return newnode def visit_setcomp(self, node: ast.SetComp, parent: NodeNG) -> nodes.SetComp: """Visit a SetComp node by returning a fresh instance of it.""" newnode = nodes.SetComp( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.elt, newnode), [self.visit(child, newnode) for child in node.generators], ) return newnode def visit_slice(self, node: ast.Slice, parent: nodes.Subscript) -> nodes.Slice: """Visit a Slice node by returning a fresh instance of it.""" newnode = nodes.Slice( # position attributes added in 3.9 lineno=getattr(node, "lineno", None), col_offset=getattr(node, "col_offset", None), end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( lower=self.visit(node.lower, newnode), upper=self.visit(node.upper, newnode), step=self.visit(node.step, newnode), ) return newnode def visit_subscript(self, node: ast.Subscript, parent: NodeNG) -> nodes.Subscript: """Visit a Subscript node by returning a fresh instance of it.""" context = self._get_context(node) newnode = nodes.Subscript( ctx=context, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.value, newnode), self.visit(node.slice, newnode) ) return newnode def visit_starred(self, node: ast.Starred, parent: NodeNG) -> nodes.Starred: """Visit a Starred node and return a new instance of it.""" context = self._get_context(node) newnode = nodes.Starred( ctx=context, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit(self.visit(node.value, newnode)) return newnode def visit_tryexcept(self, node: ast.Try, parent: NodeNG) -> nodes.TryExcept: """Visit a TryExcept node by returning a fresh instance of it.""" if sys.version_info >= (3, 8): # TryExcept excludes the 'finally' but that will be included in the # end_lineno from 'node'. Therefore, we check all non 'finally' # children to find the correct end_lineno and column. end_lineno = node.end_lineno end_col_offset = node.end_col_offset all_children: list[ast.AST] = [node.body, node.handlers, *node.orelse] for child in reversed(all_children): end_lineno = child.end_lineno end_col_offset = child.end_col_offset break newnode = nodes.TryExcept( lineno=node.lineno, col_offset=node.col_offset, end_lineno=end_lineno, end_col_offset=end_col_offset, parent=parent, ) else: newnode = nodes.TryExcept(node.lineno, node.col_offset, parent) newnode.postinit( [self.visit(child, newnode) for child in node.body], [self.visit(child, newnode) for child in node.handlers], [self.visit(child, newnode) for child in node.orelse], ) return newnode def visit_try( self, node: ast.Try, parent: NodeNG ) -> nodes.TryExcept \| nodes.TryFinally \| None: # python 3.3 introduce a new Try node replacing # TryFinally/TryExcept nodes if node.finalbody: newnode = nodes.TryFinally( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) body: list[NodeNG \| nodes.TryExcept] if node.handlers: body = [self.visit_tryexcept(node, newnode)] else: body = [self.visit(child, newnode) for child in node.body] newnode.postinit(body, [self.visit(n, newnode) for n in node.finalbody]) return newnode if node.handlers: return self.visit_tryexcept(node, parent) return None def visit_trystar(self, node: ast.TryStar, parent: NodeNG) -> nodes.TryStar: newnode = nodes.TryStar( lineno=node.lineno, col_offset=node.col_offset, end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( body=[self.visit(n, newnode) for n in node.body], handlers=[self.visit(n, newnode) for n in node.handlers], orelse=[self.visit(n, newnode) for n in node.orelse], finalbody=[self.visit(n, newnode) for n in node.finalbody], ) return newnode def visit_tuple(self, node: ast.Tuple, parent: NodeNG) -> nodes.Tuple: """Visit a Tuple node by returning a fresh instance of it.""" context = self._get_context(node) newnode = nodes.Tuple( ctx=context, lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit([self.visit(child, newnode) for child in node.elts]) return newnode def visit_unaryop(self, node: ast.UnaryOp, parent: NodeNG) -> nodes.UnaryOp: """Visit a UnaryOp node by returning a fresh instance of it.""" newnode = nodes.UnaryOp( op=self._parser_module.unary_op_classes[node.op.__class__], lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit(self.visit(node.operand, newnode)) return newnode def visit_while(self, node: ast.While, parent: NodeNG) -> nodes.While: """Visit a While node by returning a fresh instance of it.""" newnode = nodes.While( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) newnode.postinit( self.visit(node.test, newnode), [self.visit(child, newnode) for child in node.body], [self.visit(child, newnode) for child in node.orelse], ) return newnode @overload def _visit_with( self, cls: type[nodes.With], node: ast.With, parent: NodeNG ) -> nodes.With: ... @overload def _visit_with( self, cls: type[nodes.AsyncWith], node: ast.AsyncWith, parent: NodeNG ) -> nodes.AsyncWith: ... def _visit_with( self, cls: type[_WithT], node: ast.With \| ast.AsyncWith, parent: NodeNG, ) -> _WithT: col_offset = node.col_offset if IS_PYPY and not PY39_PLUS and isinstance(node, ast.AsyncWith) and self._data: # pylint: disable-next=unsubscriptable-object col_offset = self._data[node.lineno - 1].index("async") newnode = cls( lineno=node.lineno, col_offset=col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) def visit_child(child: ast.withitem) -> tuple[NodeNG, NodeNG \| None]: expr = self.visit(child.context_expr, newnode) var = self.visit(child.optional_vars, newnode) return expr, var type_annotation = self.check_type_comment(node, parent=newnode) newnode.postinit( items=[visit_child(child) for child in node.items], body=[self.visit(child, newnode) for child in node.body], type_annotation=type_annotation, ) return newnode def visit_with(self, node: ast.With, parent: NodeNG) -> NodeNG: return self._visit_with(nodes.With, node, parent) def visit_yield(self, node: ast.Yield, parent: NodeNG) -> NodeNG: """Visit a Yield node by returning a fresh instance of it.""" newnode = nodes.Yield( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) if node.value is not None: newnode.postinit(self.visit(node.value, newnode)) return newnode def visit_yieldfrom(self, node: ast.YieldFrom, parent: NodeNG) -> NodeNG: newnode = nodes.YieldFrom( lineno=node.lineno, col_offset=node.col_offset, # end_lineno and end_col_offset added in 3.8 end_lineno=getattr(node, "end_lineno", None), end_col_offset=getattr(node, "end_col_offset", None), parent=parent, ) if node.value is not None: newnode.postinit(self.visit(node.value, newnode)) return newnode if sys.version_info >= (3, 10): def visit_match(self, node: ast.Match, parent: NodeNG) -> nodes.Match: newnode = nodes.Match( lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) newnode.postinit( subject=self.visit(node.subject, newnode), cases=[self.visit(case, newnode) for case in node.cases], ) return newnode def visit_matchcase( self, node: ast.match_case, parent: NodeNG ) -> nodes.MatchCase: newnode = nodes.MatchCase(parent=parent) newnode.postinit( pattern=self.visit(node.pattern, newnode), guard=self.visit(node.guard, newnode), body=[self.visit(child, newnode) for child in node.body], ) return newnode def visit_matchvalue( self, node: ast.MatchValue, parent: NodeNG ) -> nodes.MatchValue: newnode = nodes.MatchValue( lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) newnode.postinit(value=self.visit(node.value, newnode)) return newnode def visit_matchsingleton( self, node: ast.MatchSingleton, parent: NodeNG ) -> nodes.MatchSingleton: return nodes.MatchSingleton( value=node.value, lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) def visit_matchsequence( self, node: ast.MatchSequence, parent: NodeNG ) -> nodes.MatchSequence: newnode = nodes.MatchSequence( lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) newnode.postinit( patterns=[self.visit(pattern, newnode) for pattern in node.patterns] ) return newnode def visit_matchmapping( self, node: ast.MatchMapping, parent: NodeNG ) -> nodes.MatchMapping: newnode = nodes.MatchMapping( lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) # Add AssignName node for 'node.name' # https://bugs.python.org/issue43994 newnode.postinit( keys=[self.visit(child, newnode) for child in node.keys], patterns=[self.visit(pattern, newnode) for pattern in node.patterns], rest=self.visit_assignname(node, newnode, node.rest), ) return newnode def visit_matchclass( self, node: ast.MatchClass, parent: NodeNG ) -> nodes.MatchClass: newnode = nodes.MatchClass( lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) newnode.postinit( cls=self.visit(node.cls, newnode), patterns=[self.visit(pattern, newnode) for pattern in node.patterns], kwd_attrs=node.kwd_attrs, kwd_patterns=[ self.visit(pattern, newnode) for pattern in node.kwd_patterns ], ) return newnode def visit_matchstar( self, node: ast.MatchStar, parent: NodeNG ) -> nodes.MatchStar: newnode = nodes.MatchStar( lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) # Add AssignName node for 'node.name' # https://bugs.python.org/issue43994 newnode.postinit(name=self.visit_assignname(node, newnode, node.name)) return newnode def visit_matchas(self, node: ast.MatchAs, parent: NodeNG) -> nodes.MatchAs: newnode = nodes.MatchAs( lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) # Add AssignName node for 'node.name' # https://bugs.python.org/issue43994 newnode.postinit( pattern=self.visit(node.pattern, newnode), name=self.visit_assignname(node, newnode, node.name), ) return newnode def visit_matchor(self, node: ast.MatchOr, parent: NodeNG) -> nodes.MatchOr: newnode = nodes.MatchOr( lineno=node.lineno, col_offset=node.col_offset, end_lineno=node.end_lineno, end_col_offset=node.end_col_offset, parent=parent, ) newnode.postinit( patterns=[self.visit(pattern, newnode) for pattern in node.patterns] ) return newnode	77.86 KB	2026-01-20 12:58
📄 scoped_nodes.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt # pylint: disable=unused-import import warnings from astroid.nodes.scoped_nodes import ( AsyncFunctionDef, ClassDef, ComprehensionScope, DictComp, FunctionDef, GeneratorExp, Lambda, ListComp, LocalsDictNodeNG, Module, SetComp, _is_metaclass, builtin_lookup, function_to_method, get_wrapping_class, ) # We cannot create a __all__ here because it would create a circular import # Please remove astroid/scoped_nodes.py\|astroid/node_classes.py in autoflake # exclude when removing this file. warnings.warn( "The 'astroid.scoped_nodes' module is deprecated and will be replaced by " "'astroid.nodes' in astroid 3.0.0", DeprecationWarning, stacklevel=2, )	958 B	2026-01-20 12:58
📄 test_utils.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt """Utility functions for test code that uses astroid ASTs as input.""" from __future__ import annotations import contextlib import functools import sys import warnings from collections.abc import Callable import pytest from astroid import manager, nodes, transforms def require_version(minver: str = "0.0.0", maxver: str = "4.0.0") -> Callable: """Compare version of python interpreter to the given one and skips the test if older.""" def parse(python_version: str) -> tuple[int, ...]: try: return tuple(int(v) for v in python_version.split(".")) except ValueError as e: msg = f"{python_version} is not a correct version : should be X.Y[.Z]." raise ValueError(msg) from e min_version = parse(minver) max_version = parse(maxver) def check_require_version(f): current: tuple[int, int, int] = sys.version_info[:3] if min_version < current <= max_version: return f version: str = ".".join(str(v) for v in sys.version_info) @functools.wraps(f) def new_f(args, *kwargs): if current <= min_version: pytest.skip(f"Needs Python > {minver}. Current version is {version}.") elif current > max_version: pytest.skip(f"Needs Python <= {maxver}. Current version is {version}.") return new_f return check_require_version def get_name_node(start_from, name, index=0): return [n for n in start_from.nodes_of_class(nodes.Name) if n.name == name][index] @contextlib.contextmanager def enable_warning(warning): warnings.simplefilter("always", warning) try: yield finally: # Reset it to default value, so it will take # into account the values from the -W flag. warnings.simplefilter("default", warning) def brainless_manager(): m = manager.AstroidManager() # avoid caching into the AstroidManager borg since we get problems # with other tests : m.__dict__ = {} m._failed_import_hooks = [] m.astroid_cache = {} m._mod_file_cache = {} m._transform = transforms.TransformVisitor() m.extension_package_whitelist = set() return m	2.38 KB	2026-01-20 12:58
📄 transforms.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt from __future__ import annotations import collections from typing import TYPE_CHECKING from astroid.context import _invalidate_cache if TYPE_CHECKING: from astroid import NodeNG class TransformVisitor: """A visitor for handling transforms. The standard approach of using it is to call :meth:`~visit` with an astroid module and the class will take care of the rest, walking the tree and running the transforms for each encountered node. Based on its usage in AstroidManager.brain, it should not be reinstantiated. """ def __init__(self): self.transforms = collections.defaultdict(list) def _transform(self, node: NodeNG) -> NodeNG: """Call matching transforms for the given node if any and return the transformed node. """ cls = node.__class__ transforms = self.transforms[cls] for transform_func, predicate in transforms: if predicate is None or predicate(node): ret = transform_func(node) # if the transformation function returns something, it's # expected to be a replacement for the node if ret is not None: _invalidate_cache() node = ret if ret.__class__ != cls: # Can no longer apply the rest of the transforms. break return node def _visit(self, node): if hasattr(node, "_astroid_fields"): for name in node._astroid_fields: value = getattr(node, name) visited = self._visit_generic(value) if visited != value: setattr(node, name, visited) return self._transform(node) def _visit_generic(self, node): if isinstance(node, list): return [self._visit_generic(child) for child in node] if isinstance(node, tuple): return tuple(self._visit_generic(child) for child in node) if not node or isinstance(node, str): return node return self._visit(node) def register_transform(self, node_class, transform, predicate=None) -> None: """Register `transform(node)` function to be applied on the given astroid's `node_class` if `predicate` is None or returns true when called with the node as argument. The transform function may return a value which is then used to substitute the original node in the tree. """ self.transforms[node_class].append((transform, predicate)) def unregister_transform(self, node_class, transform, predicate=None) -> None: """Unregister the given transform.""" self.transforms[node_class].remove((transform, predicate)) def visit(self, module): """Walk the given astroid tree and transform each encountered node. Only the nodes which have transforms registered will actually be replaced or changed. """ return self._visit(module)	3.19 KB	2026-01-20 12:58
📄 typing.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt from __future__ import annotations import sys from typing import TYPE_CHECKING, Any, Callable, Generator, TypeVar, Union if TYPE_CHECKING: from astroid import bases, exceptions, nodes, transforms, util from astroid.context import InferenceContext from astroid.interpreter._import import spec if sys.version_info >= (3, 8): from typing import TypedDict else: from typing_extensions import TypedDict _NodesT = TypeVar("_NodesT", bound="nodes.NodeNG") class InferenceErrorInfo(TypedDict): """Store additional Inference error information raised with StopIteration exception. """ node: nodes.NodeNG context: InferenceContext \| None InferFn = Callable[..., Any] class AstroidManagerBrain(TypedDict): """Dictionary to store relevant information for a AstroidManager class.""" astroid_cache: dict[str, nodes.Module] _mod_file_cache: dict[ tuple[str, str \| None], spec.ModuleSpec \| exceptions.AstroidImportError ] _failed_import_hooks: list[Callable[[str], nodes.Module]] always_load_extensions: bool optimize_ast: bool extension_package_whitelist: set[str] _transform: transforms.TransformVisitor InferenceResult = Union["nodes.NodeNG", "util.UninferableBase", "bases.Proxy"] SuccessfulInferenceResult = Union["nodes.NodeNG", "bases.Proxy"] ConstFactoryResult = Union[ "nodes.List", "nodes.Set", "nodes.Tuple", "nodes.Dict", "nodes.Const", "nodes.EmptyNode", ] InferBinaryOp = Callable[ [ Union[_NodesT, "bases.Instance"], Union["nodes.AugAssign", "nodes.BinOp"], str, InferenceResult, "InferenceContext", SuccessfulInferenceResult, ], Generator[InferenceResult, None, None], ]	1.94 KB	2026-01-20 12:58
📄 util.py # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE # Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt from __future__ import annotations import importlib import sys import warnings from typing import Any import lazy_object_proxy if sys.version_info >= (3, 8): from typing import Final, Literal else: from typing_extensions import Final, Literal def lazy_descriptor(obj): class DescriptorProxy(lazy_object_proxy.Proxy): def __get__(self, instance, owner=None): return self.__class__.__get__(self, instance) return DescriptorProxy(obj) def lazy_import(module_name: str) -> lazy_object_proxy.Proxy: return lazy_object_proxy.Proxy( lambda: importlib.import_module("." + module_name, "astroid") ) class UninferableBase: """Special inference object, which is returned when inference fails. This is meant to be used as a singleton. Use astroid.util.Uninferable to access it. """ def __repr__(self) -> Literal["Uninferable"]: return "Uninferable" __str__ = __repr__ def __getattribute__(self, name: str) -> Any: if name == "next": raise AttributeError("next method should not be called") if name.startswith("__") and name.endswith("__"): return object.__getattribute__(self, name) if name == "accept": return object.__getattribute__(self, name) return self def __call__(self, args: Any, *kwargs: Any) -> UninferableBase: return self def __bool__(self) -> Literal[False]: return False __nonzero__ = __bool__ def accept(self, visitor): return visitor.visit_uninferable(self) Uninferable: Final = UninferableBase() class BadOperationMessage: """Object which describes a TypeError occurred somewhere in the inference chain. This is not an exception, but a container object which holds the types and the error which occurred. """ class BadUnaryOperationMessage(BadOperationMessage): """Object which describes operational failures on UnaryOps.""" def __init__(self, operand, op, error): self.operand = operand self.op = op self.error = error @property def _object_type_helper(self): helpers = lazy_import("helpers") return helpers.object_type def _object_type(self, obj): objtype = self._object_type_helper(obj) if isinstance(objtype, UninferableBase): return None return objtype def __str__(self) -> str: if hasattr(self.operand, "name"): operand_type = self.operand.name else: object_type = self._object_type(self.operand) if hasattr(object_type, "name"): operand_type = object_type.name else: # Just fallback to as_string operand_type = object_type.as_string() msg = "bad operand type for unary {}: {}" return msg.format(self.op, operand_type) class BadBinaryOperationMessage(BadOperationMessage): """Object which describes type errors for BinOps.""" def __init__(self, left_type, op, right_type): self.left_type = left_type self.right_type = right_type self.op = op def __str__(self) -> str: msg = "unsupported operand type(s) for {}: {!r} and {!r}" return msg.format(self.op, self.left_type.name, self.right_type.name) def _instancecheck(cls, other) -> bool: wrapped = cls.__wrapped__ other_cls = other.__class__ is_instance_of = wrapped is other_cls or issubclass(other_cls, wrapped) warnings.warn( "%r is deprecated and slated for removal in astroid " "2.0, use %r instead" % (cls.__class__.__name__, wrapped.__name__), PendingDeprecationWarning, stacklevel=2, ) return is_instance_of def proxy_alias(alias_name, node_type): """Get a Proxy from the given name to the given node type.""" proxy = type( alias_name, (lazy_object_proxy.Proxy,), { "__class__": object.__dict__["__class__"], "__instancecheck__": _instancecheck, }, ) return proxy(lambda: node_type) def check_warnings_filter() -> bool: """Return True if any other than the default DeprecationWarning filter is enabled. https://docs.python.org/3/library/warnings.html#default-warning-filter """ return any( issubclass(DeprecationWarning, filter[2]) and filter[0] != "ignore" and filter[3] != "__main__" for filter in warnings.filters )	4.62 KB	2026-01-20 12:58

Edit File:

Terminal