ansible-core 2.19.4rc1__py3-none-any.whl → 2.20.0__py3-none-any.whl

ansible_test/_internal/target.py

@@ -65,7 +65,7 @@ def walk_completion_targets(targets: c.Iterable[CompletionTarget], prefix: str,
     return tuple(sorted(matches))
 
 
-def walk_internal_targets(
+def walk_internal_targets[TCompletionTarget: CompletionTarget](
     targets: c.Iterable[TCompletionTarget],
     includes: t.Optional[list[str]] = None,
     excludes: t.Optional[list[str]] = None,
@@ -87,7 +87,7 @@ def walk_internal_targets(
     return tuple(sorted(internal_targets, key=lambda sort_target: sort_target.name))
 
 
-def filter_targets(
+def filter_targets[TCompletionTarget: CompletionTarget](
     targets: c.Iterable[TCompletionTarget],
     patterns: list[str],
     include: bool = True,
@@ -711,7 +711,3 @@ class TargetPatternsNotMatched(ApplicationError):
             message = 'Target pattern not matched: %s' % self.patterns[0]
 
         super().__init__(message)
-
-
-TCompletionTarget = t.TypeVar('TCompletionTarget', bound=CompletionTarget)
-TIntegrationTarget = t.TypeVar('TIntegrationTarget', bound=IntegrationTarget)

ansible_test/_internal/thread.py

@@ -11,9 +11,6 @@ import queue
 import typing as t
 
 
-TCallable = t.TypeVar('TCallable', bound=t.Callable[..., t.Any])
-
-
 class WrappedThread(threading.Thread):
     """Wrapper around Thread which captures results and exceptions."""
 
@@ -50,7 +47,7 @@ class WrappedThread(threading.Thread):
         return result
 
 
-def mutex(func: TCallable) -> TCallable:
+def mutex[TCallable: t.Callable[..., t.Any]](func: TCallable) -> TCallable:
     """Enforce exclusive access on a decorated function."""
     lock = threading.Lock()
 

ansible_test/_internal/util.py

@@ -57,11 +57,6 @@ from .constants import (
     SUPPORTED_PYTHON_VERSIONS,
 )
 
-C = t.TypeVar('C')
-TBase = t.TypeVar('TBase')
-TKey = t.TypeVar('TKey')
-TValue = t.TypeVar('TValue')
-
 PYTHON_PATHS: dict[str, str] = {}
 
 COVERAGE_CONFIG_NAME = 'coveragerc'
@@ -180,7 +175,7 @@ def is_valid_identifier(value: str) -> bool:
     return value.isidentifier() and not keyword.iskeyword(value)
 
 
-def cache(func: c.Callable[[], TValue]) -> c.Callable[[], TValue]:
+def cache[TValue](func: c.Callable[[], TValue]) -> c.Callable[[], TValue]:
     """Enforce exclusive access on a decorated function and cache the result."""
     storage: dict[None, TValue] = {}
     sentinel = object()
@@ -313,7 +308,7 @@ def read_lines_without_comments(path: str, remove_blank_lines: bool = False, opt
     return lines
 
 
-def exclude_none_values(data: dict[TKey, t.Optional[TValue]]) -> dict[TKey, TValue]:
+def exclude_none_values[TKey, TValue](data: dict[TKey, t.Optional[TValue]]) -> dict[TKey, TValue]:
     """Return the provided dictionary with any None values excluded."""
     return dict((key, value) for key, value in data.items() if value is not None)
 
@@ -1059,7 +1054,7 @@ def format_command_output(stdout: str | None, stderr: str | None) -> str:
     return message
 
 
-def retry(func: t.Callable[..., TValue], ex_type: t.Type[BaseException] = SubprocessError, sleep: int = 10, attempts: int = 10, warn: bool = True) -> TValue:
+def retry[T](func: t.Callable[..., T], ex_type: t.Type[BaseException] = SubprocessError, sleep: int = 10, attempts: int = 10, warn: bool = True) -> T:
     """Retry the specified function on failure."""
     for dummy in range(1, attempts):
         try:
@@ -1092,7 +1087,7 @@ def parse_to_list_of_dict(pattern: str, value: str) -> list[dict[str, str]]:
     return matched
 
 
-def get_subclasses(class_type: t.Type[C]) -> list[t.Type[C]]:
+def get_subclasses[C](class_type: t.Type[C]) -> list[t.Type[C]]:
     """Returns a list of types that are concrete subclasses of the given type."""
     subclasses: set[t.Type[C]] = set()
     queue: list[t.Type[C]] = [class_type]
@@ -1168,7 +1163,7 @@ def import_plugins(directory: str, root: t.Optional[str] = None) -> None:
         load_module(module_path, name)
 
 
-def load_plugins(base_type: t.Type[C], database: dict[str, t.Type[C]]) -> None:
+def load_plugins[C](base_type: t.Type[C], database: dict[str, t.Type[C]]) -> None:
     """
     Load plugins of the specified type and track them in the specified database.
     Only plugins which have already been imported will be loaded.
@@ -1195,19 +1190,19 @@ def sanitize_host_name(name: str) -> str:
     return re.sub('[^A-Za-z0-9]+', '-', name)[:63].strip('-')
 
 
-def get_generic_type(base_type: t.Type, generic_base_type: t.Type[TValue]) -> t.Optional[t.Type[TValue]]:
+def get_generic_type[TValue](base_type: t.Type, generic_base_type: t.Type[TValue]) -> t.Optional[t.Type[TValue]]:
     """Return the generic type arg derived from the generic_base_type type that is associated with the base_type type, if any, otherwise return None."""
     # noinspection PyUnresolvedReferences
     type_arg = t.get_args(base_type.__orig_bases__[0])[0]
     return None if isinstance(type_arg, generic_base_type) else type_arg
 
 
-def get_type_associations(base_type: t.Type[TBase], generic_base_type: t.Type[TValue]) -> list[tuple[t.Type[TValue], t.Type[TBase]]]:
+def get_type_associations[TBase, TValue](base_type: t.Type[TBase], generic_base_type: t.Type[TValue]) -> list[tuple[t.Type[TValue], t.Type[TBase]]]:
     """Create and return a list of tuples associating generic_base_type derived types with a corresponding base_type derived type."""
     return [item for item in [(get_generic_type(sc_type, generic_base_type), sc_type) for sc_type in get_subclasses(base_type)] if item[1]]
 
 
-def get_type_map(base_type: t.Type[TBase], generic_base_type: t.Type[TValue]) -> dict[t.Type[TValue], t.Type[TBase]]:
+def get_type_map[TBase, TValue](base_type: t.Type[TBase], generic_base_type: t.Type[TValue]) -> dict[t.Type[TValue], t.Type[TBase]]:
     """Create and return a mapping of generic_base_type derived types to base_type derived types."""
     return {item[0]: item[1] for item in get_type_associations(base_type, generic_base_type)}
 
@@ -1228,7 +1223,7 @@ def verify_sys_executable(path: str) -> t.Optional[str]:
     return expected_executable
 
 
-def type_guard(sequence: c.Sequence[t.Any], guard_type: t.Type[C]) -> t.TypeGuard[c.Sequence[C]]:
+def type_guard[C](sequence: c.Sequence[t.Any], guard_type: t.Type[C]) -> t.TypeGuard[c.Sequence[C]]:
     """
     Raises an exception if any item in the given sequence does not match the specified guard type.
     Use with assert so that type checkers are aware of the type guard.

ansible_test/_util/controller/sanity/code-smell/runtime-metadata.py

@@ -17,14 +17,13 @@ from voluptuous import Required, Schema, Invalid
 from voluptuous.humanize import humanize_error
 
 from ansible.module_utils.compat.version import StrictVersion, LooseVersion
-from ansible.module_utils.six import string_types
 from ansible.utils.collection_loader import AnsibleCollectionRef
 from ansible.utils.version import SemanticVersion
 
 
 def fqcr(value):
     """Validate a FQCR."""
-    if not isinstance(value, string_types):
+    if not isinstance(value, str):
         raise Invalid('Must be a string that is a FQCR')
     if not AnsibleCollectionRef.is_valid_fqcr(value):
         raise Invalid('Must be a FQCR')
@@ -33,7 +32,7 @@ def fqcr(value):
 
 def fqcr_or_shortname(value):
     """Validate a FQCR or a shortname."""
-    if not isinstance(value, string_types):
+    if not isinstance(value, str):
         raise Invalid('Must be a string that is a FQCR or a short name')
     if '.' in value and not AnsibleCollectionRef.is_valid_fqcr(value):
         raise Invalid('Must be a FQCR or a short name')
@@ -48,7 +47,7 @@ def isodate(value, check_deprecation_date=False, is_tombstone=False):
     else:
         # make sure we have a string
         msg = 'Expected ISO 8601 date string (YYYY-MM-DD), or YAML date'
-        if not isinstance(value, string_types):
+        if not isinstance(value, str):
             raise Invalid(msg)
         # From Python 3.7 in, there is datetime.date.fromisoformat(). For older versions,
         # we have to do things manually.
@@ -80,7 +79,7 @@ def removal_version(value, is_ansible, current_version=None, is_tombstone=False)
         'Removal version must be a string' if is_ansible else
         'Removal version must be a semantic version (https://semver.org/)'
     )
-    if not isinstance(value, string_types):
+    if not isinstance(value, str):
         raise Invalid(msg)
     try:
         if is_ansible:
@@ -191,7 +190,7 @@ def validate_metadata_file(path, is_ansible, check_deprecation_dates=False):
                 'removal_version': partial(removal_version, is_ansible=is_ansible,
                                            current_version=current_version),
                 'removal_date': partial(isodate, check_deprecation_date=check_deprecation_dates),
-                'warning_text': Any(*string_types),
+                'warning_text': str,
             }
         ),
         avoid_additional_data
@@ -204,7 +203,7 @@ def validate_metadata_file(path, is_ansible, check_deprecation_dates=False):
                 'removal_version': partial(removal_version, is_ansible=is_ansible,
                                            current_version=current_version, is_tombstone=True),
                 'removal_date': partial(isodate, is_tombstone=True),
-                'warning_text': Any(*string_types),
+                'warning_text': str,
             }
         ),
         avoid_additional_data
@@ -228,18 +227,15 @@ def validate_metadata_file(path, is_ansible, check_deprecation_dates=False):
     # Adjusted schema for module_utils
     plugin_routing_schema_mu = Any(
         plugins_routing_common_schema.extend({
-            ('redirect'): Any(*string_types)}
+            ('redirect'): str}
         ),
     )
 
-    list_dict_plugin_routing_schema = [{str_type: plugin_routing_schema}
-                                       for str_type in string_types]
+    list_dict_plugin_routing_schema = [{str: plugin_routing_schema}]
 
-    list_dict_plugin_routing_schema_mu = [{str_type: plugin_routing_schema_mu}
-                                          for str_type in string_types]
+    list_dict_plugin_routing_schema_mu = [{str: plugin_routing_schema_mu}]
 
-    list_dict_plugin_routing_schema_modules = [{str_type: plugin_routing_schema_modules}
-                                               for str_type in string_types]
+    list_dict_plugin_routing_schema_modules = [{str: plugin_routing_schema_modules}]
 
     plugin_schema = Schema({
         ('action'): Any(None, *list_dict_plugin_routing_schema),
@@ -267,13 +263,12 @@ def validate_metadata_file(path, is_ansible, check_deprecation_dates=False):
 
     import_redirection_schema = Any(
         Schema({
-            ('redirect'): Any(*string_types),
+            ('redirect'): str,
             # import_redirect doesn't currently support deprecation
         }, extra=PREVENT_EXTRA)
     )
 
-    list_dict_import_redirection_schema = [{str_type: import_redirection_schema}
-                                           for str_type in string_types]
+    list_dict_import_redirection_schema = [{str: import_redirection_schema}]
 
     # action_groups schema
 
@@ -289,7 +284,7 @@ def validate_metadata_file(path, is_ansible, check_deprecation_dates=False):
         }, extra=PREVENT_EXTRA)
     }, extra=PREVENT_EXTRA)
     action_group_schema = All([metadata_dict, fqcr_or_shortname], at_most_one_dict)
-    list_dict_action_groups_schema = [{str_type: action_group_schema} for str_type in string_types]
+    list_dict_action_groups_schema = [{str: action_group_schema}]
 
     # top level schema
 
@@ -298,7 +293,7 @@ def validate_metadata_file(path, is_ansible, check_deprecation_dates=False):
         ('plugin_routing'): Any(plugin_schema),
         ('import_redirection'): Any(None, *list_dict_import_redirection_schema),
         # requires_ansible: In the future we should validate this with SpecifierSet
-        ('requires_ansible'): Any(*string_types),
+        ('requires_ansible'): str,
         ('action_groups'): Any(*list_dict_action_groups_schema),
     }, extra=PREVENT_EXTRA)
 

ansible_test/_util/controller/sanity/pylint/plugins/deprecated_calls.py

@@ -11,9 +11,11 @@ import functools
 import pathlib
 import re
 
-import astroid
-import astroid.context
+import astroid.bases
+import astroid.exceptions
+import astroid.nodes
 import astroid.typing
+import astroid.util
 
 import pylint.lint
 import pylint.checkers
@@ -42,7 +44,7 @@ class DeprecationCallArgs:
 
     def all_args_dynamic(self) -> bool:
         """True if all args are dynamic or None, otherwise False."""
-        return all(arg is None or isinstance(arg, astroid.NodeNG) for arg in dataclasses.asdict(self).values())
+        return all(arg is None or isinstance(arg, astroid.nodes.NodeNG) for arg in dataclasses.asdict(self).values())
 
 
 class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
@@ -177,7 +179,7 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
-        self.module_cache: dict[str, astroid.Module] = {}
+        self.module_cache: dict[str, astroid.nodes.Module] = {}
 
     @functools.cached_property
     def collection_name(self) -> str | None:
@@ -226,7 +228,7 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
         return None
 
     @pylint.checkers.utils.only_required_for_messages(*(msgs.keys()))
-    def visit_call(self, node: astroid.Call) -> None:
+    def visit_call(self, node: astroid.nodes.Call) -> None:
         """Visit a call node."""
         if inferred := self.infer(node.func):
             name = self.get_fully_qualified_name(inferred)
@@ -234,50 +236,50 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
             if args := self.DEPRECATION_FUNCTIONS.get(name):
                 self.check_call(node, name, args)
 
-    def infer(self, node: astroid.NodeNG) -> astroid.NodeNG | None:
+    def infer(self, node: astroid.nodes.NodeNG) -> astroid.nodes.NodeNG | None:
         """Return the inferred node from the given node, or `None` if it cannot be unambiguously inferred."""
         names: list[str] = []
-        target: astroid.NodeNG | None = node
+        target: astroid.nodes.NodeNG | None = node
         inferred: astroid.typing.InferenceResult | None = None
 
         while target:
             if inferred := astroid.util.safe_infer(target):
                 break
 
-            if isinstance(target, astroid.Call):
+            if isinstance(target, astroid.nodes.Call):
                 inferred = self.infer(target.func)
                 break
 
-            if isinstance(target, astroid.FunctionDef):
+            if isinstance(target, astroid.nodes.FunctionDef):
                 inferred = target
                 break
 
-            if isinstance(target, astroid.Name):
+            if isinstance(target, astroid.nodes.Name):
                 target = self.infer_name(target)
-            elif isinstance(target, astroid.AssignName) and isinstance(target.parent, astroid.Assign):
+            elif isinstance(target, astroid.nodes.AssignName) and isinstance(target.parent, astroid.nodes.Assign):
                 target = target.parent.value
-            elif isinstance(target, astroid.Attribute):
+            elif isinstance(target, astroid.nodes.Attribute):
                 names.append(target.attrname)
                 target = target.expr
             else:
                 break
 
         for name in reversed(names):
-            if isinstance(inferred, astroid.Instance):
+            if isinstance(inferred, astroid.bases.Instance):
                 try:
                     attr = next(iter(inferred.getattr(name)), None)
-                except astroid.AttributeInferenceError:
+                except astroid.exceptions.AttributeInferenceError:
                     break
 
-                if isinstance(attr, astroid.AssignAttr):
+                if isinstance(attr, astroid.nodes.AssignAttr):
                     inferred = self.get_ansible_module(attr)
                     continue
 
-                if isinstance(attr, astroid.FunctionDef):
+                if isinstance(attr, astroid.nodes.FunctionDef):
                     inferred = attr
                     continue
 
-            if not isinstance(inferred, (astroid.Module, astroid.ClassDef)):
+            if not isinstance(inferred, (astroid.nodes.Module, astroid.nodes.ClassDef)):
                 inferred = None
                 break
 
@@ -288,15 +290,15 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
             else:
                 inferred = self.infer(inferred)
 
-        if isinstance(inferred, astroid.FunctionDef) and isinstance(inferred.parent, astroid.ClassDef):
-            inferred = astroid.BoundMethod(inferred, inferred.parent)
+        if isinstance(inferred, astroid.nodes.FunctionDef) and isinstance(inferred.parent, astroid.nodes.ClassDef):
+            inferred = astroid.bases.BoundMethod(inferred, inferred.parent)
 
         return inferred
 
-    def infer_name(self, node: astroid.Name) -> astroid.NodeNG | None:
+    def infer_name(self, node: astroid.nodes.Name) -> astroid.nodes.NodeNG | None:
         """Infer the node referenced by the given name, or `None` if it cannot be unambiguously inferred."""
         scope = node.scope()
-        inferred: astroid.NodeNG | None = None
+        inferred: astroid.nodes.NodeNG | None = None
         name = node.name
 
         while scope:
@@ -306,12 +308,12 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
                 scope = scope.parent.scope() if scope.parent else None
                 continue
 
-            if isinstance(assignment, astroid.AssignName) and isinstance(assignment.parent, astroid.Assign):
+            if isinstance(assignment, astroid.nodes.AssignName) and isinstance(assignment.parent, astroid.nodes.Assign):
                 inferred = assignment.parent.value
             elif (
-                isinstance(scope, astroid.FunctionDef)
-                and isinstance(assignment, astroid.AssignName)
-                and isinstance(assignment.parent, astroid.Arguments)
+                isinstance(scope, astroid.nodes.FunctionDef)
+                and isinstance(assignment, astroid.nodes.AssignName)
+                and isinstance(assignment.parent, astroid.nodes.Arguments)
                 and assignment.parent.annotations
             ):
                 idx, _node = assignment.parent.find_argname(name)
@@ -322,12 +324,12 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
                     except IndexError:
                         pass
                     else:
-                        if isinstance(annotation, astroid.Name):
+                        if isinstance(annotation, astroid.nodes.Name):
                             name = annotation.name
                             continue
-            elif isinstance(assignment, astroid.ClassDef):
+            elif isinstance(assignment, astroid.nodes.ClassDef):
                 inferred = assignment
-            elif isinstance(assignment, astroid.ImportFrom):
+            elif isinstance(assignment, astroid.nodes.ImportFrom):
                 if module := self.get_module(assignment):
                     name = assignment.real_name(name)
                     scope = module.scope()
@@ -337,7 +339,7 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
 
         return inferred
 
-    def get_module(self, node: astroid.ImportFrom) -> astroid.Module | None:
+    def get_module(self, node: astroid.nodes.ImportFrom) -> astroid.nodes.Module | None:
         """Import the requested module if possible and cache the result."""
         module_name = pylint.checkers.utils.get_import_name(node, node.modname)
 
@@ -357,21 +359,21 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
         return module
 
     @staticmethod
-    def get_fully_qualified_name(node: astroid.NodeNG) -> str | None:
+    def get_fully_qualified_name(node: astroid.nodes.NodeNG) -> str | None:
         """Return the fully qualified name of the given inferred node."""
         parent = node.parent
         parts: tuple[str, ...] | None
 
-        if isinstance(node, astroid.FunctionDef) and isinstance(parent, astroid.Module):
+        if isinstance(node, astroid.nodes.FunctionDef) and isinstance(parent, astroid.nodes.Module):
             parts = (parent.name, node.name)
-        elif isinstance(node, astroid.BoundMethod) and isinstance(parent, astroid.ClassDef) and isinstance(parent.parent, astroid.Module):
+        elif isinstance(node, astroid.bases.BoundMethod) and isinstance(parent, astroid.nodes.ClassDef) and isinstance(parent.parent, astroid.nodes.Module):
             parts = (parent.parent.name, parent.name, node.name)
         else:
             parts = None
 
         return '.'.join(parts) if parts else None
 
-    def check_call(self, node: astroid.Call, name: str, args: tuple[str, ...]) -> None:
+    def check_call(self, node: astroid.nodes.Call, name: str, args: tuple[str, ...]) -> None:
         """Check the given deprecation call node for valid arguments."""
         call_args = self.get_deprecation_call_args(node, args)
 
@@ -400,7 +402,7 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
             self.check_version(node, name, call_args)
 
     @staticmethod
-    def get_deprecation_call_args(node: astroid.Call, args: tuple[str, ...]) -> DeprecationCallArgs:
+    def get_deprecation_call_args(node: astroid.nodes.Call, args: tuple[str, ...]) -> DeprecationCallArgs:
         """Get the deprecation call arguments from the given node."""
         fields: dict[str, object] = {}
 
@@ -413,12 +415,12 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
                 fields[keyword.arg] = keyword.value
 
         for key, value in fields.items():
-            if isinstance(value, astroid.Const):
+            if isinstance(value, astroid.nodes.Const):
                 fields[key] = value.value
 
         return DeprecationCallArgs(**fields)
 
-    def check_collection_name(self, node: astroid.Call, name: str, args: DeprecationCallArgs) -> None:
+    def check_collection_name(self, node: astroid.nodes.Call, name: str, args: DeprecationCallArgs) -> None:
         """Check the collection name provided to the given call node."""
         deprecator_requirement = self.is_deprecator_required()
 
@@ -459,14 +461,14 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
         if args.collection_name and args.collection_name != expected_collection_name:
             self.add_message('wrong-collection-deprecated', node=node, args=(args.collection_name, name))
 
-    def check_version(self, node: astroid.Call, name: str, args: DeprecationCallArgs) -> None:
+    def check_version(self, node: astroid.nodes.Call, name: str, args: DeprecationCallArgs) -> None:
         """Check the version provided to the given call node."""
         if self.collection_name:
             self.check_collection_version(node, name, args)
         else:
             self.check_core_version(node, name, args)
 
-    def check_core_version(self, node: astroid.Call, name: str, args: DeprecationCallArgs) -> None:
+    def check_core_version(self, node: astroid.nodes.Call, name: str, args: DeprecationCallArgs) -> None:
         """Check the core version provided to the given call node."""
         try:
             if not isinstance(args.version, str) or not args.version:
@@ -480,7 +482,7 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
         if self.ANSIBLE_VERSION >= strict_version:
             self.add_message('ansible-deprecated-version', node=node, args=(args.version, name))
 
-    def check_collection_version(self, node: astroid.Call, name: str, args: DeprecationCallArgs) -> None:
+    def check_collection_version(self, node: astroid.nodes.Call, name: str, args: DeprecationCallArgs) -> None:
         """Check the collection version provided to the given call node."""
         try:
             if not isinstance(args.version, str) or not args.version:
@@ -497,7 +499,7 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
         if semantic_version.major != 0 and (semantic_version.minor != 0 or semantic_version.patch != 0):
             self.add_message('removal-version-must-be-major', node=node, args=(args.version,))
 
-    def check_date(self, node: astroid.Call, name: str, args: DeprecationCallArgs) -> None:
+    def check_date(self, node: astroid.nodes.Call, name: str, args: DeprecationCallArgs) -> None:
         """Check the date provided to the given call node."""
         try:
             date_parsed = self.parse_isodate(args.date)
@@ -515,18 +517,19 @@ class AnsibleDeprecatedChecker(pylint.checkers.BaseChecker):
 
         raise TypeError(type(value))
 
-    def get_ansible_module(self, node: astroid.AssignAttr) -> astroid.Instance | None:
+    def get_ansible_module(self, node: astroid.nodes.AssignAttr) -> astroid.bases.Instance | None:
         """Infer an AnsibleModule instance node from the given assignment."""
-        if isinstance(node.parent, astroid.Assign) and isinstance(node.parent.type_annotation, astroid.Name):
+        if isinstance(node.parent, astroid.nodes.Assign) and isinstance(node.parent.type_annotation, astroid.nodes.Name):
             inferred = self.infer_name(node.parent.type_annotation)
-        elif isinstance(node.parent, astroid.Assign) and isinstance(node.parent.parent, astroid.FunctionDef) and isinstance(node.parent.value, astroid.Name):
+        elif (isinstance(node.parent, astroid.nodes.Assign) and isinstance(node.parent.parent, astroid.nodes.FunctionDef) and
+              isinstance(node.parent.value, astroid.nodes.Name)):
             inferred = self.infer_name(node.parent.value)
-        elif isinstance(node.parent, astroid.AnnAssign) and isinstance(node.parent.annotation, astroid.Name):
+        elif isinstance(node.parent, astroid.nodes.AnnAssign) and isinstance(node.parent.annotation, astroid.nodes.Name):
             inferred = self.infer_name(node.parent.annotation)
         else:
             inferred = None
 
-        if isinstance(inferred, astroid.ClassDef) and inferred.name == 'AnsibleModule':
+        if isinstance(inferred, astroid.nodes.ClassDef) and inferred.name == 'AnsibleModule':
             return inferred.instantiate_class()
 
         return None

ansible_test/_util/controller/sanity/pylint/plugins/string_format.py

@@ -5,7 +5,9 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 
-import astroid
+import astroid.bases
+import astroid.exceptions
+import astroid.nodes
 
 try:
     from pylint.checkers.utils import check_messages
@@ -39,22 +41,22 @@ class AnsibleStringFormatChecker(BaseChecker):
     def visit_call(self, node):
         """Visit a call node."""
         func = utils.safe_infer(node.func)
-        if (isinstance(func, astroid.BoundMethod)
-                and isinstance(func.bound, astroid.Instance)
+        if (isinstance(func, astroid.bases.BoundMethod)
+                and isinstance(func.bound, astroid.bases.Instance)
                 and func.bound.name in ('str', 'unicode', 'bytes')):
             if func.name == 'format':
                 self._check_new_format(node, func)
 
     def _check_new_format(self, node, func):
         """ Check the new string formatting """
-        if (isinstance(node.func, astroid.Attribute)
-                and not isinstance(node.func.expr, astroid.Const)):
+        if (isinstance(node.func, astroid.nodes.Attribute)
+                and not isinstance(node.func.expr, astroid.nodes.Const)):
             return
         try:
             strnode = next(func.bound.infer())
-        except astroid.InferenceError:
+        except astroid.exceptions.InferenceError:
             return
-        if not isinstance(strnode, astroid.Const):
+        if not isinstance(strnode, astroid.nodes.Const):
             return
 
         if isinstance(strnode.value, bytes):