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

ansible/galaxy/dependency_resolution/providers.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import collections.abc as _c
 import functools
 import typing as t
 
@@ -15,6 +16,8 @@ if t.TYPE_CHECKING:
     from ansible.galaxy.collection.galaxy_api_proxy import MultiGalaxyAPIProxy
     from ansible.galaxy.api import GalaxyAPI
 
+    from resolvelib.structs import RequirementInformation
+
 from ansible.galaxy.collection.gpg import get_signature_from_source
 from ansible.galaxy.dependency_resolution.dataclasses import (
     Candidate,
@@ -24,7 +27,6 @@ from ansible.galaxy.dependency_resolution.versioning import (
     is_pre_release,
     meets_requirements,
 )
-from ansible.module_utils.six import string_types
 from ansible.utils.version import SemanticVersion, LooseVersion
 
 try:
@@ -38,24 +40,24 @@ except ImportError:
 
 
 # TODO: add python requirements to ansible-test's ansible-core distribution info and remove the hardcoded lowerbound/upperbound fallback
-RESOLVELIB_LOWERBOUND = SemanticVersion("0.5.3")
+RESOLVELIB_LOWERBOUND = SemanticVersion("0.8.0")
 RESOLVELIB_UPPERBOUND = SemanticVersion("2.0.0")
 RESOLVELIB_VERSION = SemanticVersion.from_loose_version(LooseVersion(resolvelib_version))
 
 
-class CollectionDependencyProviderBase(AbstractProvider):
+class CollectionDependencyProvider(AbstractProvider):
     """Delegate providing a requirement interface for the resolver."""
 
     def __init__(
-            self,  # type: CollectionDependencyProviderBase
-            apis,  # type: MultiGalaxyAPIProxy
-            concrete_artifacts_manager=None,  # type: ConcreteArtifactsManager
-            preferred_candidates=None,  # type: t.Iterable[Candidate]
-            with_deps=True,  # type: bool
-            with_pre_releases=False,  # type: bool
-            upgrade=False,  # type: bool
-            include_signatures=True,  # type: bool
-    ):  # type: (...) -> None
+            self,
+            apis: MultiGalaxyAPIProxy,
+            concrete_artifacts_manager: ConcreteArtifactsManager,
+            preferred_candidates: _c.Iterable[Candidate] | None = None,
+            with_deps: bool = True,
+            with_pre_releases: bool = False,
+            upgrade: bool = False,
+            include_signatures: bool = True,
+    ) -> None:
         r"""Initialize helper attributes.
 
         :param api: An instance of the multiple Galaxy APIs wrapper.
@@ -91,8 +93,10 @@ class CollectionDependencyProviderBase(AbstractProvider):
         self._upgrade = upgrade
         self._include_signatures = include_signatures
 
-    def identify(self, requirement_or_candidate):
-        # type: (t.Union[Candidate, Requirement]) -> str
+    def identify(
+        self,
+        requirement_or_candidate: Candidate | Requirement,
+    ) -> str:
         """Given requirement or candidate, return an identifier for it.
 
         This is used to identify a requirement or candidate, e.g.
@@ -103,8 +107,19 @@ class CollectionDependencyProviderBase(AbstractProvider):
         """
         return requirement_or_candidate.canonical_package_id
 
-    def get_preference(self, *args, **kwargs):
-        # type: (t.Any, t.Any) -> t.Union[float, int]
+    def get_preference(
+        self,
+        identifier: str,
+        resolutions: _c.Mapping[str, Candidate],
+        candidates: _c.Mapping[str, _c.Iterator[Candidate]],
+        information: _c.Mapping[
+            str,
+            _c.Iterator[RequirementInformation[Requirement, Candidate]],
+        ],
+        backtrack_causes: _c.Sequence[
+            RequirementInformation[Requirement, Candidate],
+        ],
+    ) -> float | int:
         """Return sort key function return value for given requirement.
 
         This result should be based on preference that is defined as
@@ -112,38 +127,6 @@ class CollectionDependencyProviderBase(AbstractProvider):
         The lower the return value is, the more preferred this
         group of arguments is.
 
-        resolvelib >=0.5.3, <0.7.0
-
-        :param resolution: Currently pinned candidate, or ``None``.
-
-        :param candidates: A list of possible candidates.
-
-        :param information: A list of requirement information.
-
-        Each ``information`` instance is a named tuple with two entries:
-
-          * ``requirement`` specifies a requirement contributing to
-            the current candidate list
-
-          * ``parent`` specifies the candidate that provides
-            (depended on) the requirement, or `None`
-            to indicate a root requirement.
-
-        resolvelib >=0.7.0, < 0.8.0
-
-        :param identifier: The value returned by ``identify()``.
-
-        :param resolutions: Mapping of identifier, candidate pairs.
-
-        :param candidates: Possible candidates for the identifier.
-            Mapping of identifier, list of candidate pairs.
-
-        :param information: Requirement information of each package.
-            Mapping of identifier, list of named tuple pairs.
-            The named tuples have the entries ``requirement`` and ``parent``.
-
-        resolvelib >=0.8.0, <= 1.0.1
-
         :param identifier: The value returned by ``identify()``.
 
         :param resolutions: Mapping of identifier, candidate pairs.
@@ -179,10 +162,6 @@ class CollectionDependencyProviderBase(AbstractProvider):
         the value is, the more preferred this requirement is (i.e. the
         sorting function is called with ``reverse=False``).
         """
-        raise NotImplementedError
-
-    def _get_preference(self, candidates):
-        # type: (list[Candidate]) -> t.Union[float, int]
         if any(
                 candidate in self._preferred_candidates
                 for candidate in candidates
@@ -192,8 +171,12 @@ class CollectionDependencyProviderBase(AbstractProvider):
             return float('-inf')
         return len(candidates)
 
-    def find_matches(self, *args, **kwargs):
-        # type: (t.Any, t.Any) -> list[Candidate]
+    def find_matches(
+        self,
+        identifier: str,
+        requirements: _c.Mapping[str, _c.Iterator[Requirement]],
+        incompatibilities: _c.Mapping[str, _c.Iterator[Candidate]],
+    ) -> list[Candidate]:
         r"""Find all possible candidates satisfying given requirements.
 
         This tries to get candidates based on the requirements' types.
@@ -204,32 +187,13 @@ class CollectionDependencyProviderBase(AbstractProvider):
         For a "named" requirement, Galaxy-compatible APIs are consulted
         to find concrete candidates for this requirement. If there's a
         pre-installed candidate, it's prepended in front of others.
-
-        resolvelib >=0.5.3, <0.6.0
-
-        :param requirements: A collection of requirements which all of \
-                             the returned candidates must match. \
-                             All requirements are guaranteed to have \
-                             the same identifier. \
-                             The collection is never empty.
-
-        resolvelib >=0.6.0
-
-        :param identifier: The value returned by ``identify()``.
-
-        :param requirements: The requirements all returned candidates must satisfy.
-            Mapping of identifier, iterator of requirement pairs.
-
-        :param incompatibilities: Incompatible versions that must be excluded
-            from the returned list.
-
-        :returns: An iterable that orders candidates by preference, \
-                  e.g. the most preferred candidate comes first.
         """
-        raise NotImplementedError
+        return [
+            match for match in self._find_matches(list(requirements[identifier]))
+            if not any(match.ver == incompat.ver for incompat in incompatibilities[identifier])
+        ]
 
-    def _find_matches(self, requirements):
-        # type: (list[Requirement]) -> list[Candidate]
+    def _find_matches(self, requirements: list[Requirement]) -> list[Candidate]:
         # FIXME: The first requirement may be a Git repo followed by
         # FIXME: its cloned tmp dir. Using only the first one creates
         # FIXME: loops that prevent any further dependency exploration.
@@ -250,7 +214,10 @@ class CollectionDependencyProviderBase(AbstractProvider):
                 all(self.is_satisfied_by(requirement, candidate) for requirement in requirements)
             }
         try:
-            coll_versions = [] if preinstalled_candidates else self._api_proxy.get_collection_versions(first_req)  # type: t.Iterable[t.Tuple[str, GalaxyAPI]]
+            coll_versions: _c.Iterable[tuple[str, GalaxyAPI]] = (
+                [] if preinstalled_candidates
+                else self._api_proxy.get_collection_versions(first_req)
+            )
         except TypeError as exc:
             if first_req.is_concrete_artifact:
                 # Non hashable versions will cause a TypeError
@@ -278,7 +245,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
                 # NOTE: Another known mistake is setting a minor part of the SemVer notation
                 # NOTE: skipping the "patch" bit like "1.0" which is assumed non-compliant even
                 # NOTE: after the conversion to string.
-                if not isinstance(version, string_types):
+                if not isinstance(version, str):
                     raise ValueError(version_err)
                 elif version != '*':
                     try:
@@ -293,7 +260,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
 
         latest_matches = []
         signatures = []
-        extra_signature_sources = []  # type: list[str]
+        extra_signature_sources: list[str] = []
 
         discarding_pre_releases_acceptable = any(
             not is_pre_release(candidate_version)
@@ -398,8 +365,11 @@ class CollectionDependencyProviderBase(AbstractProvider):
 
         return list(preinstalled_candidates) + latest_matches
 
-    def is_satisfied_by(self, requirement, candidate):
-        # type: (Requirement, Candidate) -> bool
+    def is_satisfied_by(
+        self,
+        requirement: Requirement,
+        candidate: Candidate,
+    ) -> bool:
         r"""Whether the given requirement is satisfiable by a candidate.
 
         :param requirement: A requirement that produced the `candidate`.
@@ -425,8 +395,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
             requirements=requirement.ver,
         )
 
-    def get_dependencies(self, candidate):
-        # type: (Candidate) -> list[Candidate]
+    def get_dependencies(self, candidate: Candidate) -> list[Requirement]:
         r"""Get direct dependencies of a candidate.
 
         :returns: A collection of requirements that `candidate` \
@@ -457,52 +426,3 @@ class CollectionDependencyProviderBase(AbstractProvider):
             self._make_req_from_dict({'name': dep_name, 'version': dep_req})
             for dep_name, dep_req in req_map.items()
         ]
-
-
-# Classes to handle resolvelib API changes between minor versions for 0.X
-class CollectionDependencyProvider050(CollectionDependencyProviderBase):
-    def find_matches(self, requirements):  # type: ignore[override]
-        # type: (list[Requirement]) -> list[Candidate]
-        return self._find_matches(requirements)
-
-    def get_preference(self, resolution, candidates, information):  # type: ignore[override]
-        # type: (t.Optional[Candidate], list[Candidate], list[t.NamedTuple]) -> t.Union[float, int]
-        return self._get_preference(candidates)
-
-
-class CollectionDependencyProvider060(CollectionDependencyProviderBase):
-    def find_matches(self, identifier, requirements, incompatibilities):  # type: ignore[override]
-        # type: (str, t.Mapping[str, t.Iterator[Requirement]], t.Mapping[str, t.Iterator[Requirement]]) -> list[Candidate]
-        return [
-            match for match in self._find_matches(list(requirements[identifier]))
-            if not any(match.ver == incompat.ver for incompat in incompatibilities[identifier])
-        ]
-
-    def get_preference(self, resolution, candidates, information):  # type: ignore[override]
-        # type: (t.Optional[Candidate], list[Candidate], list[t.NamedTuple]) -> t.Union[float, int]
-        return self._get_preference(candidates)
-
-
-class CollectionDependencyProvider070(CollectionDependencyProvider060):
-    def get_preference(self, identifier, resolutions, candidates, information):  # type: ignore[override]
-        # type: (str, t.Mapping[str, Candidate], t.Mapping[str, t.Iterator[Candidate]], t.Iterator[t.NamedTuple]) -> t.Union[float, int]
-        return self._get_preference(list(candidates[identifier]))
-
-
-class CollectionDependencyProvider080(CollectionDependencyProvider060):
-    def get_preference(self, identifier, resolutions, candidates, information, backtrack_causes):  # type: ignore[override]
-        # type: (str, t.Mapping[str, Candidate], t.Mapping[str, t.Iterator[Candidate]], t.Iterator[t.NamedTuple], t.Sequence) -> t.Union[float, int]
-        return self._get_preference(list(candidates[identifier]))
-
-
-def _get_provider():  # type () -> CollectionDependencyProviderBase
-    if RESOLVELIB_VERSION >= SemanticVersion("0.8.0"):
-        return CollectionDependencyProvider080
-    if RESOLVELIB_VERSION >= SemanticVersion("0.7.0"):
-        return CollectionDependencyProvider070
-    if RESOLVELIB_VERSION >= SemanticVersion("0.6.0"):
-        return CollectionDependencyProvider060
-    return CollectionDependencyProvider050
-
-
-CollectionDependencyProvider = _get_provider()

ansible/galaxy/dependency_resolution/versioning.py

@@ -11,8 +11,7 @@ from ansible.module_utils.compat.version import LooseVersion
 from ansible.utils.version import SemanticVersion
 
 
-def is_pre_release(version):
-    # type: (str) -> bool
+def is_pre_release(version: str) -> bool:
     """Figure out if a given version is a pre-release."""
     try:
         return SemanticVersion(version).is_prerelease
@@ -20,8 +19,7 @@ def is_pre_release(version):
         return False
 
 
-def meets_requirements(version, requirements):
-    # type: (str, str) -> bool
+def meets_requirements(version: str, requirements: str) -> bool:
     """Verify if a given version satisfies all the requirements.
 
     Supported version identifiers are:

ansible/galaxy/role.py

@@ -23,7 +23,6 @@ from __future__ import annotations
 
 import errno
 import datetime
-import functools
 import os
 import tarfile
 import tempfile
@@ -46,32 +45,6 @@ from ansible.utils.path import is_subpath, unfrackpath
 display = Display()
 
 
-@functools.cache
-def _check_working_data_filter() -> bool:
-    """
-    Check if tarfile.data_filter implementation is working
-    for the current Python version or not
-    """
-
-    # Implemented the following code to circumvent broken implementation of data_filter
-    # in tarfile. See for more information - https://github.com/python/cpython/issues/107845
-    # deprecated: description='probing broken data filter implementation' python_version='3.11'
-    ret = False
-    if hasattr(tarfile, 'data_filter'):
-        # We explicitly check if tarfile.data_filter is broken or not
-        ti = tarfile.TarInfo('docs/README.md')
-        ti.type = tarfile.SYMTYPE
-        ti.linkname = '../README.md'
-
-        try:
-            tarfile.data_filter(ti, '/foo')
-        except tarfile.LinkOutsideDestinationError:
-            pass
-        else:
-            ret = True
-    return ret
-
-
 class GalaxyRole(object):
 
     SUPPORTED_SCMS = set(['git', 'hg'])
@@ -418,12 +391,7 @@ class GalaxyRole(object):
                                 relative_path = os.path.join(*full_path.replace(relative_path_dir, "", 1).split(os.sep))
                                 setattr(member, attr, relative_path)
 
-                            if _check_working_data_filter():
-                                # deprecated: description='extract fallback without filter' python_version='3.11'
-                                role_tar_file.extract(member, to_native(self.path), filter='data')  # type: ignore[call-arg]
-                            else:
-                                # Remove along with manual path filter once Python 3.12 is minimum supported version
-                                role_tar_file.extract(member, to_native(self.path))
+                            role_tar_file.extract(member, to_native(self.path), filter='data')
 
                         # write out the install info file for later use
                         self._write_galaxy_install_info()

ansible/inventory/manager.py

@@ -33,7 +33,6 @@ from ansible._internal import _json, _wrapt
 from ansible._internal._json import EncryptedStringBehavior
 from ansible.errors import AnsibleError, AnsibleOptionsError
 from ansible.inventory.data import InventoryData
-from ansible.module_utils.six import string_types
 from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.parsing.utils.addresses import parse_address
 from ansible.plugins.loader import inventory_loader
@@ -112,7 +111,7 @@ def split_host_pattern(pattern):
         results = (split_host_pattern(p) for p in pattern)
         # flatten the results
         return list(itertools.chain.from_iterable(results))
-    elif not isinstance(pattern, string_types):
+    elif not isinstance(pattern, str):
         pattern = to_text(pattern, errors='surrogate_or_strict')
 
     # If it's got commas in it, we'll treat it as a straightforward
@@ -162,7 +161,7 @@ class InventoryManager(object):
         # the inventory dirs, files, script paths or lists of hosts
         if sources is None:
             self._sources = []
-        elif isinstance(sources, string_types):
+        elif isinstance(sources, str):
             self._sources = [sources]
         else:
             self._sources = sources

ansible/keyword_desc.yml

@@ -1,6 +1,3 @@
-accelerate: "*DEPRECATED*, set to True to use accelerate connection plugin."
-accelerate_ipv6: "*DEPRECATED*, set to True to force accelerate plugin to use ipv6 for its connection."
-accelerate_port: "*DEPRECATED*, set to override default port use for accelerate connection."
 action: "The 'action' to execute for a task, it normally translates into a C(module) or action plugin."
 args: "A secondary way to add arguments into a task. Takes a dictionary in which keys map to options and values."
 always: List of tasks, in a block, that execute no matter if there is an error in the block or not.

ansible/module_utils/_internal/_datatag/__init__.py

@@ -500,17 +500,9 @@ class AnsibleDatatagBase(AnsibleSerializableDataclass, metaclass=abc.ABCMeta):
 _known_tag_type_map: t.Dict[str, t.Type[AnsibleDatatagBase]] = {}
 _known_tag_types: t.Set[t.Type[AnsibleDatatagBase]] = set()
 
-if sys.version_info >= (3, 9):
-    # Include the key and value types in the type hints on Python 3.9 and later.
-    # Earlier versions do not support subscriptable dict.
-    # deprecated: description='always use subscriptable dict' python_version='3.8'
-    class _AnsibleTagsMapping(dict[type[_TAnsibleDatatagBase], _TAnsibleDatatagBase]):
-        __slots__ = _NO_INSTANCE_STORAGE
 
-else:
-
-    class _AnsibleTagsMapping(dict):
-        __slots__ = _NO_INSTANCE_STORAGE
+class _AnsibleTagsMapping(dict[type[_TAnsibleDatatagBase], _TAnsibleDatatagBase]):
+    __slots__ = _NO_INSTANCE_STORAGE
 
 
 class _EmptyROInternalTagsMapping(dict):

ansible/module_utils/_internal/_no_six.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import sys
+import types
+
+from ansible.module_utils.common import warnings
+
+
+# INLINED FROM THE SIX LIBRARY, see lib/ansible/module_utils/six/__init__.py
+# Copyright (c) 2010-2024 Benjamin Peterson
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(type):
+
+        def __new__(cls, name, this_bases, d):
+            if sys.version_info[:2] >= (3, 7):
+                # This version introduced PEP 560 that requires a bit
+                # of extra care (we mimic what is done by __build_class__).
+                resolved_bases = types.resolve_bases(bases)
+                if resolved_bases is not bases:
+                    d['__orig_bases__'] = bases
+            else:
+                resolved_bases = bases
+            return meta(name, resolved_bases, d)
+
+        @classmethod
+        def __prepare__(cls, name, this_bases):
+            return meta.__prepare__(name, bases)
+
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        if hasattr(cls, '__qualname__'):
+            orig_vars['__qualname__'] = cls.__qualname__
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+
+    return wrapper
+
+
+def iteritems(d, **kw):
+    return iter(d.items(**kw))
+
+
+_mini_six = {
+    "PY2": False,
+    "PY3": True,
+    "text_type": str,
+    "binary_type": bytes,
+    "string_types": (str,),
+    "integer_types": (int,),
+    "iteritems": iteritems,
+    "add_metaclass": add_metaclass,
+    "with_metaclass": with_metaclass,
+}
+# INLINED SIX END
+
+
+def deprecate(importable_name: str, module_name: str, *deprecated_args) -> object:
+    """Inject import-time deprecation warnings."""
+    if not (importable_name in deprecated_args and (importable := _mini_six.get(importable_name, ...) is not ...)):
+        raise AttributeError(f"module {module_name!r} has no attribute {importable_name!r}")
+
+    # TODO Inspect and remove all calls to this function in 2.24
+    warnings.deprecate(
+        msg=f"Importing {importable_name!r} from {module_name!r} is deprecated.",
+        version="2.24",
+    )
+
+    return importable

ansible/module_utils/_text.py

@@ -1,15 +1,35 @@
 # Copyright (c), Toshio Kuratomi <tkuratomi@ansible.com> 2016
 # Simplified BSD License (see licenses/simplified_bsd.txt or https://opensource.org/licenses/BSD-2-Clause)
 
-"""
-.. warn:: Use ansible.module_utils.common.text.converters instead.
-"""
 from __future__ import annotations
 
-# Backwards compat for people still calling it from this package
-# pylint: disable=unused-import
-import codecs
+from ansible.module_utils.common import warnings as _warnings
 
-from ansible.module_utils.six import PY3, text_type, binary_type
 
-from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
+_mini_six = {
+    "binary_type": bytes,
+    "text_type": str,
+    "PY3": True,
+}
+
+
+def __getattr__(importable_name: str) -> object:
+    """Inject import-time deprecation warnings."""
+    help_text: str | None = None
+    importable: object
+    if importable_name == "codecs":
+        import codecs
+        importable = codecs
+    elif importable_name in {"to_bytes", "to_native", "to_text"}:
+        from ansible.module_utils.common.text import converters
+        importable = getattr(converters, importable_name)
+        help_text = "Use ansible.module_utils.common.text.converters instead."
+    elif (importable := _mini_six.get(importable_name, ...)) is ...:
+        raise AttributeError(f"module {__name__!r} has no attribute {importable_name!r}")
+
+    _warnings.deprecate(
+        msg=f"Importing {importable_name!r} from {__name__!r} is deprecated.",
+        version="2.24",
+        help_text=help_text,
+    )
+    return importable

ansible/module_utils/ansible_release.py

@@ -17,6 +17,6 @@
 
 from __future__ import annotations
 
-__version__ = '2.19.4rc1'
+__version__ = '2.20.0'
 __author__ = 'Ansible, Inc.'
-__codename__ = "What Is and What Should Never Be"
+__codename__ = "Good Times Bad Times"

ansible/module_utils/basic.py

@@ -11,12 +11,13 @@ import typing as t
 
 # Used for determining if the system is running a new enough python version
 # and should only restrict on our documented minimum versions
-_PY_MIN = (3, 8)
+_PY_MIN = (3, 9)
 
 if sys.version_info < _PY_MIN:
     print(json.dumps(dict(
         failed=True,
-        msg=f"ansible-core requires a minimum of Python version {'.'.join(map(str, _PY_MIN))}. Current version: {''.join(sys.version.splitlines())}",
+        msg=f"Ansible requires Python {'.'.join(map(str, _PY_MIN))} or newer on the target. "
+            f"Current version: {''.join(sys.version.splitlines())}",
     )))
     sys.exit(1)
 
@@ -45,6 +46,15 @@ import tempfile
 import time
 import traceback
 
+from collections.abc import (
+    KeysView,
+    Mapping,
+    MutableMapping,
+    Sequence,
+    MutableSequence,
+    Set,
+    MutableSet,
+)
 from functools import reduce
 
 try:
@@ -122,13 +132,6 @@ def _get_available_hash_algorithms():
 AVAILABLE_HASH_ALGORITHMS = _get_available_hash_algorithms()
 
 from ansible.module_utils.common import json as _json
-
-from ansible.module_utils.six.moves.collections_abc import (
-    KeysView,
-    Mapping, MutableMapping,
-    Sequence, MutableSequence,
-    Set, MutableSet,
-)
 from ansible.module_utils.common.locale import get_best_parsable_locale
 from ansible.module_utils.common.process import get_bin_path
 from ansible.module_utils.common.file import (
@@ -2185,6 +2188,18 @@ def get_module_path():
     return os.path.dirname(os.path.realpath(__file__))
 
 
+_mini_six = {
+    "b": lambda s: s.encode("latin-1"),
+    "PY2": False,
+    "PY3": True,
+    "text_type": str,
+    "binary_type": bytes,
+    "string_types": (str,),
+    "integer_types": (int,),
+    "iteritems": lambda d, **kw: iter(d.items(**kw)),
+}
+
+
 def __getattr__(importable_name):
     """Inject import-time deprecation warnings."""
     if importable_name == 'datetime':
@@ -2202,24 +2217,12 @@ def __getattr__(importable_name):
     elif importable_name == 'repeat':
         from itertools import repeat
         importable = repeat
-    elif importable_name in {
-        'PY2', 'PY3', 'b', 'binary_type', 'integer_types',
-        'iteritems', 'string_types', 'text_type',
-    }:
-        import importlib
-        importable = getattr(
-            importlib.import_module('ansible.module_utils.six'),
-            importable_name
-        )
     elif importable_name == 'map':
         importable = map
     elif importable_name == 'shlex_quote':
         importable = shlex.quote
-    else:
-        raise AttributeError(
-            f'cannot import name {importable_name !r} '
-            f"from '{__name__}' ({__file__ !s})"
-        )
+    elif (importable := _mini_six.get(importable_name, ...)) is ...:
+        raise AttributeError(f"module {__name__!r} has no attribute {importable_name!r}")
 
     deprecate(
         msg=f"Importing '{importable_name}' from '{__name__}' is deprecated.",