1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
# For details: https://github.com/pylint-dev/astroid/blob/main/LICENSE
# Copyright (c) https://github.com/pylint-dev/astroid/blob/main/CONTRIBUTORS.txt
from __future__ import annotations
from typing import (
TYPE_CHECKING,
Any,
Callable,
Generator,
Generic,
Protocol,
TypedDict,
TypeVar,
Union,
)
if TYPE_CHECKING:
from astroid import bases, exceptions, nodes, transforms, util
from astroid.context import InferenceContext
from astroid.interpreter._import import spec
class InferenceErrorInfo(TypedDict):
"""Store additional Inference error information
raised with StopIteration exception.
"""
node: nodes.NodeNG
context: InferenceContext | None
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"]
_SuccessfulInferenceResultT = TypeVar(
"_SuccessfulInferenceResultT", bound=SuccessfulInferenceResult
)
_SuccessfulInferenceResultT_contra = TypeVar(
"_SuccessfulInferenceResultT_contra",
bound=SuccessfulInferenceResult,
contravariant=True,
)
ConstFactoryResult = Union[
"nodes.List",
"nodes.Set",
"nodes.Tuple",
"nodes.Dict",
"nodes.Const",
"nodes.EmptyNode",
]
InferBinaryOp = Callable[
[
_SuccessfulInferenceResultT,
Union["nodes.AugAssign", "nodes.BinOp"],
str,
InferenceResult,
"InferenceContext",
SuccessfulInferenceResult,
],
Generator[InferenceResult, None, None],
]
class InferFn(Protocol, Generic[_SuccessfulInferenceResultT_contra]):
def __call__(
self,
node: _SuccessfulInferenceResultT_contra,
context: InferenceContext | None = None,
**kwargs: Any,
) -> Generator[InferenceResult, None, None]:
... # pragma: no cover
class TransformFn(Protocol, Generic[_SuccessfulInferenceResultT]):
def __call__(
self,
node: _SuccessfulInferenceResultT,
infer_function: InferFn[_SuccessfulInferenceResultT] = ...,
) -> _SuccessfulInferenceResultT | None:
... # pragma: no cover
|
