Update astroid nodes import (#10592)

Author: cdce8p

pylint/checkers/base/basic_error_checker.py

@@ -27,10 +27,10 @@ def _get_break_loop_node(break_node: nodes.Break) -> nodes.For | nodes.While | N
     """Returns the loop node that holds the break node in arguments.
 
     Args:
-        break_node (astroid.Break): the break node of interest.
+        break_node (nodes.Break): the break node of interest.
 
     Returns:
-        astroid.For or astroid.While: the loop node holding the break node.
+        nodes.For or nodes.While: the loop node holding the break node.
     """
     loop_nodes = (nodes.For, nodes.While)
     parent = break_node.parent
@@ -48,7 +48,7 @@ def _loop_exits_early(loop: nodes.For | nodes.While) -> bool:
     """Returns true if a loop may end with a break statement.
 
     Args:
-        loop (astroid.For, astroid.While): the loop node inspected.
+        loop (nodes.For, nodes.While): the loop node inspected.
 
     Returns:
         bool: True if the loop may end with a break statement, False otherwise.

pylint/checkers/base/name_checker/checker.py

@@ -650,9 +650,9 @@ def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
     @staticmethod
     def _assigns_typevar(node: nodes.NodeNG | None) -> str | None:
         """Check if a node is assigning a TypeVar and return TypeVar type."""
-        if isinstance(node, astroid.Call):
+        if isinstance(node, nodes.Call):
             inferred = utils.safe_infer(node.func)
-            if isinstance(inferred, astroid.ClassDef):
+            if isinstance(inferred, nodes.ClassDef):
                 qname = inferred.qname()
                 for typevar_node_typ, qnames in TYPE_VAR_QNAMES.items():
                     if qname in qnames:

pylint/checkers/classes/class_checker.py

@@ -1517,7 +1517,7 @@ def _check_functools_or_not(self, decorator: nodes.Attribute) -> bool:
             return False
         import_node = import_nodes[0]
 
-        if not isinstance(import_node, (astroid.Import, astroid.ImportFrom)):
+        if not isinstance(import_node, (nodes.Import, nodes.ImportFrom)):
             return False
 
         return "functools" in dict(import_node.names)

pylint/checkers/classes/special_methods_checker.py

@@ -379,7 +379,7 @@ def _check_getnewargs_ex(
             return
 
         if not isinstance(inferred, nodes.Tuple):
-            # If it's not an astroid.Tuple we can't analyze it further
+            # If it's not an nodes.Tuple we can't analyze it further
             return
 
         found_error = False

pylint/checkers/deprecated.py

@@ -24,7 +24,7 @@
     astroid.UnboundMethod,
     nodes.FunctionDef,
     nodes.ClassDef,
-    astroid.Attribute,
+    nodes.Attribute,
 )
 
 
@@ -89,8 +89,8 @@ class DeprecatedMixin(BaseChecker):
     }
 
     @utils.only_required_for_messages("deprecated-attribute")
-    def visit_attribute(self, node: astroid.Attribute) -> None:
-        """Called when an `astroid.Attribute` node is visited."""
+    def visit_attribute(self, node: nodes.Attribute) -> None:
+        """Called when an `Attribute` node is visited."""
         self.check_deprecated_attribute(node)
 
     @utils.only_required_for_messages(
@@ -111,7 +111,7 @@ def visit_call(self, node: nodes.Call) -> None:
                 and inferred.qname() == "builtins.__import__"
                 and len(node.args) == 1
                 and (mod_path_node := utils.safe_infer(node.args[0]))
-                and isinstance(mod_path_node, astroid.Const)
+                and isinstance(mod_path_node, nodes.Const)
             ):
                 self.check_deprecated_module(node, mod_path_node.value)
 
@@ -219,7 +219,7 @@ def deprecated_attributes(self) -> Iterable[str]:
         """Callback returning the deprecated attributes."""
         return ()
 
-    def check_deprecated_attribute(self, node: astroid.Attribute) -> None:
+    def check_deprecated_attribute(self, node: nodes.Attribute) -> None:
         """Checks if the attribute is deprecated."""
         inferred_expr = safe_infer(node.expr)
         if not isinstance(inferred_expr, (nodes.ClassDef, Instance, nodes.Module)):

pylint/checkers/design_analysis.py

@@ -11,7 +11,6 @@
 from collections.abc import Iterator
 from typing import TYPE_CHECKING
 
-import astroid
 from astroid import nodes
 
 from pylint.checkers import BaseChecker
@@ -182,7 +181,7 @@
 )
 
 
-def _is_exempt_from_public_methods(node: astroid.ClassDef) -> bool:
+def _is_exempt_from_public_methods(node: nodes.ClassDef) -> bool:
     """Check if a class is exempt from too-few-public-methods."""
     # If it's a typing.Namedtuple, typing.TypedDict or an Enum
     for ancestor in node.ancestors():
@@ -201,10 +200,10 @@ def _is_exempt_from_public_methods(node: astroid.ClassDef) -> bool:
 
     root_locals = set(node.root().locals)
     for decorator in node.decorators.nodes:
-        if isinstance(decorator, astroid.Call):
+        if isinstance(decorator, nodes.Call):
             decorator = decorator.func
         match decorator:
-            case astroid.Name(name=name) | astroid.Attribute(attrname=name):
+            case nodes.Name(name=name) | nodes.Attribute(attrname=name):
                 pass
             case _:
                 continue
@@ -227,7 +226,7 @@ def _count_boolean_expressions(bool_op: nodes.BoolOp) -> int:
     """
     nb_bool_expr = 0
     for bool_expr in bool_op.get_children():
-        if isinstance(bool_expr, astroid.BoolOp):
+        if isinstance(bool_expr, nodes.BoolOp):
             nb_bool_expr += _count_boolean_expressions(bool_expr)
         else:
             nb_bool_expr += 1
@@ -662,7 +661,7 @@ def visit_if(self, node: nodes.If) -> None:
         branches = 1
         # don't double count If nodes coming from some 'elif'
         if node.orelse and (
-            len(node.orelse) > 1 or not isinstance(node.orelse[0], astroid.If)
+            len(node.orelse) > 1 or not isinstance(node.orelse[0], nodes.If)
         ):
             branches += 1
         self._inc_branch(node, branches)
@@ -673,7 +672,7 @@ def _check_boolean_expressions(self, node: nodes.If) -> None:
         if the 'if' node test is a BoolOp node.
         """
         condition = node.test
-        if not isinstance(condition, astroid.BoolOp):
+        if not isinstance(condition, nodes.BoolOp):
             return
         nb_bool_expr = _count_boolean_expressions(condition)
         if nb_bool_expr > self.linter.config.max_bool_expr:

pylint/checkers/refactoring/implicit_booleaness_checker.py

@@ -17,9 +17,7 @@
 def _is_constant_zero(node: str | nodes.NodeNG) -> bool:
     # We have to check that node.value is not False because node.value == 0 is True
     # when node.value is False
-    return (
-        isinstance(node, astroid.Const) and node.value == 0 and node.value is not False
-    )
+    return isinstance(node, nodes.Const) and node.value == 0 and node.value is not False
 
 
 class ImplicitBooleanessChecker(checkers.BaseChecker):
@@ -195,7 +193,7 @@ def _check_compare_to_str_or_zero(self, node: nodes.Compare) -> None:
             return
 
         negation_redundant_ops = {"!=", "is not"}
-        # note: astroid.Compare has the left most operand in node.left
+        # note: nodes.Compare has the left most operand in node.left
         # while the rest are a list of tuples in node.ops
         # the format of the tuple is ('compare operator sign', node)
         # here we squash everything into `ops` to make it easier for processing later

pylint/checkers/refactoring/recommendation_checker.py

@@ -392,10 +392,7 @@ def _detect_replacable_format_call(self, node: nodes.Const) -> None:
                     # If star expressions with more than 1 element are being used
                     if isinstance(arg, nodes.Starred):
                         inferred = utils.safe_infer(arg.value)
-                        if (
-                            isinstance(inferred, astroid.List)
-                            and len(inferred.elts) > 1
-                        ):
+                        if isinstance(inferred, nodes.List) and len(inferred.elts) > 1:
                             return
                     # Backslashes can't be in f-string expressions
                     if "\\" in arg.as_string():

pylint/checkers/refactoring/refactoring_checker.py

@@ -1712,7 +1712,7 @@ def _check_use_list_literal(self, node: nodes.Call) -> None:
 
     def _check_use_dict_literal(self, node: nodes.Call) -> None:
         """Check if dict is created by using the literal {}."""
-        if not (isinstance(node.func, astroid.Name) and node.func.name == "dict"):
+        if not (isinstance(node.func, nodes.Name) and node.func.name == "dict"):
             return
         inferred = utils.safe_infer(node.func)
         if (

pylint/checkers/typecheck.py

@@ -756,19 +756,19 @@ def _infer_from_metaclass_constructor(
 ) -> InferenceResult | None:
     """Try to infer what the given *func* constructor is building.
 
-    :param astroid.FunctionDef func:
+    :param nodes.FunctionDef func:
         A metaclass constructor. Metaclass definitions can be
         functions, which should accept three arguments, the name of
         the class, the bases of the class and the attributes.
         The function could return anything, but usually it should
         be a proper metaclass.
-    :param astroid.ClassDef cls:
+    :param nodes.ClassDef cls:
         The class for which the *func* parameter should generate
         a metaclass.
     :returns:
         The class generated by the function or None,
         if we couldn't infer it.
-    :rtype: astroid.ClassDef
+    :rtype: nodes.ClassDef
     """
     context = astroid.context.InferenceContext()
 
@@ -1130,7 +1130,7 @@ def visit_attribute(
             except astroid.NotFoundError:
                 # Avoid false positive in case a decorator supplies member.
                 if (
-                    isinstance(owner, (astroid.FunctionDef, astroid.BoundMethod))
+                    isinstance(owner, (nodes.FunctionDef, astroid.BoundMethod))
                     and owner.decorators
                 ):
                     continue