ansible-core 2.19.0b5__py3-none-any.whl → 2.19.0b7__py3-none-any.whl

ansible/galaxy/collection/__init__.py

@@ -5,7 +5,6 @@
 
 from __future__ import annotations
 
-import errno
 import fnmatch
 import functools
 import glob
@@ -1689,11 +1688,7 @@ def _extract_tar_dir(tar, dirname, b_dest):
     b_dir_path = os.path.join(b_dest, to_bytes(dirname, errors='surrogate_or_strict'))
 
     b_parent_path = os.path.dirname(b_dir_path)
-    try:
-        os.makedirs(b_parent_path, mode=S_IRWXU_RXG_RXO)
-    except OSError as e:
-        if e.errno != errno.EEXIST:
-            raise
+    os.makedirs(b_parent_path, mode=S_IRWXU_RXG_RXO, exist_ok=True)
 
     if tar_member.type == tarfile.SYMTYPE:
         b_link_path = to_bytes(tar_member.linkname, errors='surrogate_or_strict')

ansible/galaxy/collection/concrete_artifact_manager.py

@@ -449,9 +449,9 @@ def _extract_collection_from_git(repo_url, coll_ver, b_path):
     except subprocess.CalledProcessError as proc_err:
         raise AnsibleError(  # should probably be LookupError
             'Failed to switch a cloned Git repo `{repo_url!s}` '
-            'to the requested revision `{commitish!s}`.'.
+            'to the requested revision `{revision!s}`.'.
             format(
-                commitish=to_native(version),
+                revision=to_native(version),
                 repo_url=to_native(git_url),
             ),
         ) from proc_err
@@ -656,14 +656,8 @@ def _get_json_from_installed_dir(
     try:
         with open(b_json_filepath, 'rb') as manifest_fd:
             b_json_text = manifest_fd.read()
-    except (IOError, OSError):
-        raise LookupError(
-            "The collection {manifest!s} path '{path!s}' does not exist.".
-            format(
-                manifest=filename,
-                path=to_native(b_json_filepath),
-            )
-        )
+    except OSError as ex:
+        raise LookupError(f"The collection {filename!r} path {to_text(b_json_filepath)!r} does not exist.") from ex
 
     manifest_txt = to_text(b_json_text, errors='surrogate_or_strict')
 

ansible/galaxy/dependency_resolution/providers.py

@@ -148,7 +148,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
 
         :param resolutions: Mapping of identifier, candidate pairs.
 
-        :param candidates: Possible candidates for the identifer.
+        :param candidates: Possible candidates for the identifier.
             Mapping of identifier, list of candidate pairs.
 
         :param information: Requirement information of each package.
@@ -158,7 +158,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
         :param backtrack_causes: Sequence of requirement information that were
             the requirements that caused the resolver to most recently backtrack.
 
-        The preference could depend on a various of issues, including
+        The preference could depend on various of issues, including
         (not necessarily in this order):
 
           * Is this package pinned in the current resolution result?
@@ -404,7 +404,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
 
         :param requirement: A requirement that produced the `candidate`.
 
-        :param candidate: A pinned candidate supposedly matchine the \
+        :param candidate: A pinned candidate supposedly matching the \
                           `requirement` specifier. It is guaranteed to \
                           have been generated from the `requirement`.
 

ansible/galaxy/role.py

@@ -438,8 +438,8 @@ class GalaxyRole(object):
                 if not (self.src and os.path.isfile(self.src)):
                     try:
                         os.unlink(tmp_file)
-                    except (OSError, IOError) as e:
-                        display.warning(u"Unable to remove tmp file (%s): %s" % (tmp_file, to_text(e)))
+                    except OSError as ex:
+                        display.error_as_warning(f"Unable to remove tmp file {tmp_file!r}.", exception=ex)
                 return True
 
         return False

ansible/inventory/group.py

@@ -26,7 +26,7 @@ from ansible import constants as C
 from ansible.errors import AnsibleError
 from ansible.module_utils.common.text.converters import to_native, to_text
 from ansible.utils.display import Display
-from ansible.utils.vars import combine_vars
+from ansible.utils.vars import combine_vars, validate_variable_name
 
 from . import helpers  # this is left as a module import to facilitate easier unit test patching
 
@@ -221,6 +221,11 @@ class Group:
     def set_variable(self, key: str, value: t.Any) -> None:
         key = helpers.remove_trust(key)
 
+        try:
+            validate_variable_name(key)
+        except AnsibleError as ex:
+            Display().deprecated(msg=f'Accepting inventory variable with invalid name {key!r}.', version='2.23', help_text=ex._help_text, obj=ex.obj)
+
         if key == 'ansible_group_priority':
             self.set_priority(int(value))
         else:

ansible/inventory/host.py

@@ -22,8 +22,10 @@ import typing as t
 
 from collections.abc import Mapping, MutableMapping
 
+from ansible.errors import AnsibleError
 from ansible.inventory.group import Group, InventoryObjectType
 from ansible.parsing.utils.addresses import patterns
+from ansible.utils.display import Display
 from ansible.utils.vars import combine_vars, get_unique_id, validate_variable_name
 
 from . import helpers  # this is left as a module import to facilitate easier unit test patching
@@ -117,7 +119,10 @@ class Host:
     def set_variable(self, key: str, value: t.Any) -> None:
         key = helpers.remove_trust(key)
 
-        validate_variable_name(key)
+        try:
+            validate_variable_name(key)
+        except AnsibleError as ex:
+            Display().deprecated(msg=f'Accepting inventory variable with invalid name {key!r}.', version='2.23', help_text=ex._help_text, obj=ex.obj)
 
         if key in self.vars and isinstance(self.vars[key], MutableMapping) and isinstance(value, Mapping):
             self.vars = combine_vars(self.vars, {key: value})

ansible/module_utils/_internal/__init__.py

@@ -4,6 +4,9 @@ import collections.abc as c
 
 import typing as t
 
+if t.TYPE_CHECKING:
+    from ansible.module_utils.compat.typing import TypeGuard
+
 
 INTERMEDIATE_MAPPING_TYPES = (c.Mapping,)
 """
@@ -18,18 +21,18 @@ These will be converted to a simple Python `list` before serialization or storag
 CAUTION: Scalar types which are sequences should be excluded when using this.
 """
 
-ITERABLE_SCALARS_NOT_TO_ITERATE_FIXME = (str, bytes)
+ITERABLE_SCALARS_NOT_TO_ITERATE = (str, bytes)
 """Scalars which are also iterable, and should thus be excluded from iterable checks."""
 
 
-def is_intermediate_mapping(value: object) -> bool:
+def is_intermediate_mapping(value: object) -> TypeGuard[c.Mapping]:
     """Returns `True` if `value` is a type supported for projection to a Python `dict`, otherwise returns `False`."""
     return isinstance(value, INTERMEDIATE_MAPPING_TYPES)
 
 
-def is_intermediate_iterable(value: object) -> bool:
+def is_intermediate_iterable(value: object) -> TypeGuard[c.Iterable]:
     """Returns `True` if `value` is a type supported for projection to a Python `list`, otherwise returns `False`."""
-    return isinstance(value, INTERMEDIATE_ITERABLE_TYPES) and not isinstance(value, ITERABLE_SCALARS_NOT_TO_ITERATE_FIXME)
+    return isinstance(value, INTERMEDIATE_ITERABLE_TYPES) and not isinstance(value, ITERABLE_SCALARS_NOT_TO_ITERATE)
 
 
 is_controller: bool = False

ansible/module_utils/_internal/_ansiballz/_extensions/_coverage.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import atexit
+import dataclasses
+import importlib.util
+import os
+import sys
+
+import typing as t
+
+
+@dataclasses.dataclass(frozen=True)
+class Options:
+    """Code coverage options."""
+
+    config: str
+    output: str | None
+
+
+def run(args: dict[str, t.Any]) -> None:  # pragma: nocover
+    """Bootstrap `coverage` for the current Ansible module invocation."""
+    options = Options(**args)
+
+    if options.output:
+        # Enable code coverage analysis of the module.
+        # This feature is for internal testing and may change without notice.
+        python_version_string = '.'.join(str(v) for v in sys.version_info[:2])
+        os.environ['COVERAGE_FILE'] = f'{options.output}=python-{python_version_string}=coverage'
+
+        import coverage
+
+        cov = coverage.Coverage(config_file=options.config)
+
+        def atexit_coverage() -> None:
+            cov.stop()
+            cov.save()
+
+        atexit.register(atexit_coverage)
+
+        cov.start()
+    else:
+        # Verify coverage is available without importing it.
+        # This will detect when a module would fail with coverage enabled with minimal overhead.
+        if importlib.util.find_spec('coverage') is None:
+            raise RuntimeError('Could not find the `coverage` Python module.')

ansible/module_utils/_internal/_ansiballz/_extensions/_pydevd.py

@@ -0,0 +1,62 @@
+"""
+Remote debugging support for AnsiballZ modules.
+
+To use with PyCharm:
+
+1) Choose an available port for PyCharm to listen on (e.g. 5678).
+2) Create a Python Debug Server using that port.
+3) Start the Python Debug Server.
+4) Ensure the correct version of `pydevd-pycharm` is installed for the interpreter(s) which will run the code being debugged.
+5) Configure Ansible with the `_ANSIBALLZ_DEBUGGER_CONFIG` option.
+   See `Options` below for the structure of the debugger configuration.
+   Example configuration using an environment variable:
+     export _ANSIBLE_ANSIBALLZ_DEBUGGER_CONFIG='{"module": "pydevd_pycharm", "settrace": {"host": "localhost", "port": 5678, "suspend": false}}'
+6) Set any desired breakpoints.
+7) Run Ansible commands.
+
+A similar process should work for other pydevd based debuggers, such as Visual Studio Code, but they have not been tested.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import importlib
+import json
+import os
+import pathlib
+
+import typing as t
+
+
+@dataclasses.dataclass(frozen=True)
+class Options:
+    """Debugger options for pydevd and its derivatives."""
+
+    module: str = 'pydevd'
+    """The Python module which will be imported and which provides the `settrace` method."""
+    settrace: dict[str, object] = dataclasses.field(default_factory=dict)
+    """The options to pass to the `{module}.settrace` method."""
+    source_mapping: dict[str, str] = dataclasses.field(default_factory=dict)
+    """
+    A mapping of source paths to provide to pydevd.
+    This setting is used internally by AnsiballZ and is not required unless Ansible CLI commands are run from a different system than your IDE.
+    In that scenario, use this setting instead of configuring source mapping in your IDE.
+    The key is a path known to the IDE.
+    The value is the same path as known to the Ansible CLI.
+    Both file paths and directories are supported.
+    """
+
+
+def run(args: dict[str, t.Any]) -> None:  # pragma: nocover
+    """Enable remote debugging."""
+
+    options = Options(**args)
+    temp_dir = pathlib.Path(__file__).parent.parent.parent.parent.parent.parent
+    path_mapping = [[key, str(temp_dir / value)] for key, value in options.source_mapping.items()]
+
+    os.environ['PATHS_FROM_ECLIPSE_TO_PYTHON'] = json.dumps(path_mapping)
+
+    debugging_module = importlib.import_module(options.module)
+    debugging_module.settrace(**options.settrace)
+
+    pass  # when suspend is True, execution pauses here -- it's also a convenient place to put a breakpoint

ansible/module_utils/_internal/{_ansiballz.py → _ansiballz/_loader.py}

@@ -5,17 +5,15 @@
 
 from __future__ import annotations
 
-import atexit
-import importlib.util
+import importlib
 import json
-import os
 import runpy
 import sys
 import typing as t
 
-from . import _errors, _traceback, _messages
-from .. import basic
-from ..common.json import get_module_encoder, Direction
+from ansible.module_utils import basic
+from ansible.module_utils._internal import _errors, _traceback, _messages, _ansiballz
+from ansible.module_utils.common.json import get_module_encoder, Direction
 
 
 def run_module(
@@ -24,13 +22,16 @@ def run_module(
     profile: str,
     module_fqn: str,
     modlib_path: str,
+    extensions: dict[str, dict[str, object]],
     init_globals: dict[str, t.Any] | None = None,
-    coverage_config: str | None = None,
-    coverage_output: str | None = None,
 ) -> None:  # pragma: nocover
     """Used internally by the AnsiballZ wrapper to run an Ansible module."""
     try:
-        _enable_coverage(coverage_config, coverage_output)
+        for extension, args in extensions.items():
+            # importing _ansiballz instead of _extensions avoids an unnecessary import when extensions are not in use
+            extension_module = importlib.import_module(f'{_ansiballz.__name__}._extensions.{extension}')
+            extension_module.run(args)
+
         _run_module(
             json_params=json_params,
             profile=profile,
@@ -42,35 +43,6 @@ def run_module(
         _handle_exception(ex, profile)
 
 
-def _enable_coverage(coverage_config: str | None, coverage_output: str | None) -> None:  # pragma: nocover
-    """Bootstrap `coverage` for the current Ansible module invocation."""
-    if not coverage_config:
-        return
-
-    if coverage_output:
-        # Enable code coverage analysis of the module.
-        # This feature is for internal testing and may change without notice.
-        python_version_string = '.'.join(str(v) for v in sys.version_info[:2])
-        os.environ['COVERAGE_FILE'] = f'{coverage_output}=python-{python_version_string}=coverage'
-
-        import coverage
-
-        cov = coverage.Coverage(config_file=coverage_config)
-
-        def atexit_coverage():
-            cov.stop()
-            cov.save()
-
-        atexit.register(atexit_coverage)
-
-        cov.start()
-    else:
-        # Verify coverage is available without importing it.
-        # This will detect when a module would fail with coverage enabled with minimal overhead.
-        if importlib.util.find_spec('coverage') is None:
-            raise RuntimeError('Could not find the `coverage` Python module.')
-
-
 def _run_module(
     *,
     json_params: bytes,

ansible/module_utils/_internal/_ansiballz/_respawn.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import inspect
+import sys
+
+from ... import basic
+from . import _respawn_wrapper
+
+
+def create_payload() -> str:
+    """Create and return an AnsiballZ payload for respawning a module."""
+    main = sys.modules['__main__']
+    code = inspect.getsource(_respawn_wrapper)
+
+    args = dict(
+        module_fqn=main._module_fqn,
+        modlib_path=main._modlib_path,
+        profile=basic._ANSIBLE_PROFILE,
+        json_params=basic._ANSIBLE_ARGS,
+    )
+
+    args_string = '\n'.join(f'{key}={value!r},' for key, value in args.items())
+
+    wrapper = f"""{code}
+
+if __name__ == "__main__":
+    _respawn_main(
+{args_string}
+)
+"""
+
+    return wrapper

ansible/module_utils/_internal/_ansiballz/_respawn_wrapper.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+
+def _respawn_main(
+    json_params: bytes,
+    profile: str,
+    module_fqn: str,
+    modlib_path: str,
+) -> None:
+    import sys
+
+    sys.path.insert(0, modlib_path)
+
+    from ansible.module_utils._internal._ansiballz import _loader
+
+    _loader.run_module(
+        json_params=json_params,
+        profile=profile,
+        module_fqn=module_fqn,
+        modlib_path=modlib_path,
+        extensions={},
+        init_globals=dict(_respawned=True),
+    )

ansible/module_utils/_internal/_datatag/__init__.py

@@ -5,6 +5,7 @@ import collections.abc as c
 import copy
 import dataclasses
 import datetime
+import enum
 import inspect
 import sys
 
@@ -216,7 +217,7 @@ class AnsibleTagHelper:
             return value
 
 
-class AnsibleSerializable(metaclass=abc.ABCMeta):
+class AnsibleSerializable:
     __slots__ = _NO_INSTANCE_STORAGE
 
     _known_type_map: t.ClassVar[t.Dict[str, t.Type['AnsibleSerializable']]] = {}
@@ -274,6 +275,27 @@ class AnsibleSerializable(metaclass=abc.ABCMeta):
         return f'{name}({arg_string})'
 
 
+class AnsibleSerializableEnum(AnsibleSerializable, enum.Enum):
+    """Base class for serializable enumerations."""
+
+    def _as_dict(self) -> t.Dict[str, t.Any]:
+        return dict(value=self.value)
+
+    @classmethod
+    def _from_dict(cls, d: t.Dict[str, t.Any]) -> t.Self:
+        return cls(d['value'].lower())
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f'<{self.__class__.__name__}.{self.name}>'
+
+    @staticmethod
+    def _generate_next_value_(name, start, count, last_values):
+        return name.lower()
+
+
 class AnsibleSerializableWrapper(AnsibleSerializable, t.Generic[_T], metaclass=abc.ABCMeta):
     __slots__ = ('_value',)
 

ansible/module_utils/_internal/_deprecator.py

@@ -5,7 +5,7 @@ import pathlib
 import sys
 import typing as t
 
-from ansible.module_utils._internal import _stack, _messages, _validation
+from ansible.module_utils._internal import _stack, _messages, _validation, _plugin_info
 
 
 def deprecator_from_collection_name(collection_name: str | None) -> _messages.PluginInfo | None:
@@ -19,7 +19,7 @@ def deprecator_from_collection_name(collection_name: str | None) -> _messages.Pl
 
     return _messages.PluginInfo(
         resolved_name=collection_name,
-        type=_COLLECTION_ONLY_TYPE,
+        type=None,
     )
 
 
@@ -38,11 +38,16 @@ def get_caller_plugin_info() -> _messages.PluginInfo | None:
     _skip_stackwalk = True
 
     if frame_info := _stack.caller_frame():
-        return _path_as_core_plugininfo(frame_info.filename) or _path_as_collection_plugininfo(frame_info.filename)
+        return _path_as_plugininfo(frame_info.filename)
 
     return None  # pragma: nocover
 
 
+def _path_as_plugininfo(path: str) -> _messages.PluginInfo | None:
+    """Return a `PluginInfo` instance if the provided `path` refers to a plugin."""
+    return _path_as_core_plugininfo(path) or _path_as_collection_plugininfo(path)
+
+
 def _path_as_core_plugininfo(path: str) -> _messages.PluginInfo | None:
     """Return a `PluginInfo` instance if the provided `path` refers to a core plugin."""
     try:
@@ -54,7 +59,7 @@ def _path_as_core_plugininfo(path: str) -> _messages.PluginInfo | None:
 
     if match := re.match(r'plugins/(?P<plugin_type>\w+)/(?P<plugin_name>\w+)', relpath):
         plugin_name = match.group("plugin_name")
-        plugin_type = match.group("plugin_type")
+        plugin_type = _plugin_info.normalize_plugin_type(match.group("plugin_type"))
 
         if plugin_type not in _DEPRECATOR_PLUGIN_TYPES:
             # The plugin type isn't a known deprecator type, so we have to assume the caller is intermediate code.
@@ -62,16 +67,20 @@ def _path_as_core_plugininfo(path: str) -> _messages.PluginInfo | None:
             # Callers in this case need to identify the deprecating plugin name, otherwise only ansible-core will be reported.
             # Reporting ansible-core is never wrong, it just may be missing an additional detail (plugin name) in the "on behalf of" case.
             return ANSIBLE_CORE_DEPRECATOR
+
+        if plugin_name == '__init__':
+            # The plugin type is known, but the caller isn't a specific plugin -- instead, it's core plugin infrastructure (the base class).
+            return _messages.PluginInfo(resolved_name=namespace, type=plugin_type)
     elif match := re.match(r'modules/(?P<module_name>\w+)', relpath):
         # AnsiballZ Python package for core modules
         plugin_name = match.group("module_name")
-        plugin_type = "module"
+        plugin_type = _messages.PluginType.MODULE
     elif match := re.match(r'legacy/(?P<module_name>\w+)', relpath):
         # AnsiballZ Python package for non-core library/role modules
         namespace = 'ansible.legacy'
 
         plugin_name = match.group("module_name")
-        plugin_type = "module"
+        plugin_type = _messages.PluginType.MODULE
     else:
         return ANSIBLE_CORE_DEPRECATOR  # non-plugin core path, safe to use ansible-core for the same reason as the non-deprecator plugin type case above
 
@@ -85,7 +94,7 @@ def _path_as_collection_plugininfo(path: str) -> _messages.PluginInfo | None:
     if not (match := re.search(r'/ansible_collections/(?P<ns>\w+)/(?P<coll>\w+)/plugins/(?P<plugin_type>\w+)/(?P<plugin_name>\w+)', path)):
         return None
 
-    plugin_type = match.group('plugin_type')
+    plugin_type = _plugin_info.normalize_plugin_type(match.group('plugin_type'))
 
     if plugin_type in _AMBIGUOUS_DEPRECATOR_PLUGIN_TYPES:
         # We're able to detect the namespace, collection and plugin type -- but we have no way to identify the plugin name currently.
@@ -93,9 +102,6 @@ def _path_as_collection_plugininfo(path: str) -> _messages.PluginInfo | None:
         # In the future we could improve the detection and/or make it easier for a caller to identify the plugin name.
         return deprecator_from_collection_name('.'.join((match.group('ns'), match.group('coll'))))
 
-    if plugin_type == 'modules':
-        plugin_type = 'module'
-
     if plugin_type not in _DEPRECATOR_PLUGIN_TYPES:
         # The plugin type isn't a known deprecator type, so we have to assume the caller is intermediate code.
         # We have no way of knowing if the intermediate code is deprecating its own feature, or acting on behalf of another plugin.
@@ -104,11 +110,10 @@ def _path_as_collection_plugininfo(path: str) -> _messages.PluginInfo | None:
 
     name = '.'.join((match.group('ns'), match.group('coll'), match.group('plugin_name')))
 
-    return _messages.PluginInfo(resolved_name=name, type=plugin_type)
+    # DTFIX-FUTURE: deprecations from __init__ will be incorrectly attributed to a plugin of that name
 
+    return _messages.PluginInfo(resolved_name=name, type=plugin_type)
 
-_COLLECTION_ONLY_TYPE: t.Final = 'collection'
-"""Ersatz placeholder plugin type for use by a `PluginInfo` instance that references only a collection."""
 
 _ANSIBLE_MODULE_BASE_PATH: t.Final = pathlib.Path(sys.modules['ansible'].__file__).parent
 """Runtime-detected base path of the `ansible` Python package to distinguish between Ansible-owned and external code."""
@@ -116,37 +121,37 @@ _ANSIBLE_MODULE_BASE_PATH: t.Final = pathlib.Path(sys.modules['ansible'].__file_
 ANSIBLE_CORE_DEPRECATOR: t.Final = deprecator_from_collection_name('ansible.builtin')
 """Singleton `PluginInfo` instance for ansible-core callers where the plugin can/should not be identified in messages."""
 
-INDETERMINATE_DEPRECATOR: t.Final = _messages.PluginInfo(resolved_name='indeterminate', type='indeterminate')
+INDETERMINATE_DEPRECATOR: t.Final = _messages.PluginInfo(resolved_name=None, type=None)
 """Singleton `PluginInfo` instance for indeterminate deprecator."""
 
 _DEPRECATOR_PLUGIN_TYPES: t.Final = frozenset(
     {
-        'action',
-        'become',
-        'cache',
-        'callback',
-        'cliconf',
-        'connection',
-        # doc_fragments - no code execution
-        # filter - basename inadequate to identify plugin
-        'httpapi',
-        'inventory',
-        'lookup',
-        'module',  # only for collections
-        'netconf',
-        'shell',
-        'strategy',
-        'terminal',
-        # test - basename inadequate to identify plugin
-        'vars',
+        _messages.PluginType.ACTION,
+        _messages.PluginType.BECOME,
+        _messages.PluginType.CACHE,
+        _messages.PluginType.CALLBACK,
+        _messages.PluginType.CLICONF,
+        _messages.PluginType.CONNECTION,
+        # DOC_FRAGMENTS - no code execution
+        # FILTER - basename inadequate to identify plugin
+        _messages.PluginType.HTTPAPI,
+        _messages.PluginType.INVENTORY,
+        _messages.PluginType.LOOKUP,
+        _messages.PluginType.MODULE,  # only for collections
+        _messages.PluginType.NETCONF,
+        _messages.PluginType.SHELL,
+        _messages.PluginType.STRATEGY,
+        _messages.PluginType.TERMINAL,
+        # TEST - basename inadequate to identify plugin
+        _messages.PluginType.VARS,
     }
 )
 """Plugin types which are valid for identifying a deprecator for deprecation purposes."""
 
 _AMBIGUOUS_DEPRECATOR_PLUGIN_TYPES: t.Final = frozenset(
     {
-        'filter',
-        'test',
+        _messages.PluginType.FILTER,
+        _messages.PluginType.TEST,
     }
 )
 """Plugin types for which basename cannot be used to identify the plugin name."""

ansible/module_utils/_internal/_json/_profiles/__init__.py

@@ -87,6 +87,7 @@ For controller-to-module, type behavior is profile dependent.
 _common_module_response_types: frozenset[type[AnsibleSerializable]] = frozenset(
     {
         _messages.PluginInfo,
+        _messages.PluginType,
         _messages.Event,
         _messages.EventChain,
         _messages.ErrorSummary,