ansible-core 2.18.5rc1__py3-none-any.whl → 2.19.0b2__py3-none-any.whl

ansible/inventory/host.py

@@ -17,28 +17,26 @@
 
 from __future__ import annotations
 
+import collections.abc as c
+import typing as t
+
 from collections.abc import Mapping, MutableMapping
 
 from ansible.inventory.group import Group, InventoryObjectType
 from ansible.parsing.utils.addresses import patterns
-from ansible.utils.vars import combine_vars, get_unique_id
+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
 
 __all__ = ['Host']
 
 
 class Host:
-    ''' a single ansible host '''
+    """A single ansible host."""
     base_type = InventoryObjectType.HOST
 
     # __slots__ = [ 'name', 'vars', 'groups' ]
 
-    def __getstate__(self):
-        return self.serialize()
-
-    def __setstate__(self, data):
-        return self.deserialize(data)
-
     def __eq__(self, other):
         if not isinstance(other, Host):
             return False
@@ -56,55 +54,28 @@ class Host:
     def __repr__(self):
         return self.get_name()
 
-    def serialize(self):
-        groups = []
-        for group in self.groups:
-            groups.append(group.serialize())
-
-        return dict(
-            name=self.name,
-            vars=self.vars.copy(),
-            address=self.address,
-            uuid=self._uuid,
-            groups=groups,
-            implicit=self.implicit,
-        )
-
-    def deserialize(self, data):
-        self.__init__(gen_uuid=False)  # used by __setstate__ to deserialize in place  # pylint: disable=unnecessary-dunder-call
-
-        self.name = data.get('name')
-        self.vars = data.get('vars', dict())
-        self.address = data.get('address', '')
-        self._uuid = data.get('uuid', None)
-        self.implicit = data.get('implicit', False)
-
-        groups = data.get('groups', [])
-        for group_data in groups:
-            g = Group()
-            g.deserialize(group_data)
-            self.groups.append(g)
+    def __init__(self, name: str, port: int | str | None = None, gen_uuid: bool = True) -> None:
+        name = helpers.remove_trust(name)
 
-    def __init__(self, name=None, port=None, gen_uuid=True):
+        self.vars: dict[str, t.Any] = {}
+        self.groups: list[Group] = []
+        self._uuid: str | None = None
 
-        self.vars = {}
-        self.groups = []
-        self._uuid = None
-
-        self.name = name
-        self.address = name
+        self.name: str = name
+        self.address: str = name
 
         if port:
             self.set_variable('ansible_port', int(port))
 
         if gen_uuid:
             self._uuid = get_unique_id()
-        self.implicit = False
 
-    def get_name(self):
+        self.implicit: bool = False
+
+    def get_name(self) -> str:
         return self.name
 
-    def populate_ancestors(self, additions=None):
+    def populate_ancestors(self, additions: c.Iterable[Group] | None = None) -> None:
         # populate ancestors
         if additions is None:
             for group in self.groups:
@@ -114,7 +85,7 @@ class Host:
                 if group not in self.groups:
                     self.groups.append(group)
 
-    def add_group(self, group):
+    def add_group(self, group: Group) -> bool:
         added = False
         # populate ancestors first
         for oldg in group.get_ancestors():
@@ -127,7 +98,7 @@ class Host:
             added = True
         return added
 
-    def remove_group(self, group):
+    def remove_group(self, group: Group) -> bool:
         removed = False
         if group in self.groups:
             self.groups.remove(group)
@@ -143,18 +114,25 @@ class Host:
                         self.remove_group(oldg)
         return removed
 
-    def set_variable(self, key, value):
+    def set_variable(self, key: str, value: t.Any) -> None:
+        key = helpers.remove_trust(key)
+
+        validate_variable_name(key)
+
         if key in self.vars and isinstance(self.vars[key], MutableMapping) and isinstance(value, Mapping):
             self.vars = combine_vars(self.vars, {key: value})
         else:
             self.vars[key] = value
 
-    def get_groups(self):
+    def get_groups(self) -> list[Group]:
         return self.groups
 
-    def get_magic_vars(self):
-        results = {}
-        results['inventory_hostname'] = self.name
+    def get_magic_vars(self) -> dict[str, t.Any]:
+        results: dict[str, t.Any] = dict(
+            inventory_hostname=self.name,
+        )
+
+        # FUTURE: these values should be dynamically calculated on access ala the rest of magic vars
         if patterns['ipv4'].match(self.name) or patterns['ipv6'].match(self.name):
             results['inventory_hostname_short'] = self.name
         else:
@@ -164,5 +142,5 @@ class Host:
 
         return results
 
-    def get_vars(self):
+    def get_vars(self) -> dict[str, t.Any]:
         return combine_vars(self.vars, self.get_magic_vars())

ansible/inventory/manager.py

@@ -19,28 +19,34 @@
 from __future__ import annotations
 
 import fnmatch
+import functools
 import os
-import sys
 import re
 import itertools
-import traceback
+import typing as t
 
 from operator import attrgetter
 from random import shuffle
 
 from ansible import constants as C
-from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError
+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
+from ansible._internal._datatag._tags import Origin
 from ansible.utils.helpers import deduplicate_list
 from ansible.utils.path import unfrackpath
 from ansible.utils.display import Display
 from ansible.utils.vars import combine_vars
 from ansible.vars.plugins import get_vars_from_inventory_sources
 
+if t.TYPE_CHECKING:
+    from ansible.plugins.inventory import BaseInventoryPlugin
+
 display = Display()
 
 IGNORED_ALWAYS = [br"^\.", b"^host_vars$", b"^group_vars$", b"^vars_plugins$"]
@@ -50,7 +56,7 @@ IGNORED_EXTS = [b'%s$' % to_bytes(re.escape(x)) for x in C.INVENTORY_IGNORE_EXTS
 IGNORED = re.compile(b'|'.join(IGNORED_ALWAYS + IGNORED_PATTERNS + IGNORED_EXTS))
 
 PATTERN_WITH_SUBSCRIPT = re.compile(
-    r'''^
+    r"""^
         (.+)                    # A pattern expression ending with...
         \[(?:                   # A [subscript] expression comprising:
             (-?[0-9]+)|         # A single positive or negative number
@@ -58,12 +64,12 @@ PATTERN_WITH_SUBSCRIPT = re.compile(
             ([0-9]*)
         )\]
         $
-    ''', re.X
+    """, re.X
 )
 
 
 def order_patterns(patterns):
-    ''' takes a list of patterns and reorders them by modifier to apply them consistently '''
+    """ takes a list of patterns and reorders them by modifier to apply them consistently """
 
     # FIXME: this goes away if we apply patterns incrementally or by groups
     pattern_regular = []
@@ -125,19 +131,19 @@ def split_host_pattern(pattern):
             # This mishandles IPv6 addresses, and is retained only for backwards
             # compatibility.
             patterns = re.findall(
-                to_text(r'''(?:     # We want to match something comprising:
+                to_text(r"""(?:     # We want to match something comprising:
                         [^\s:\[\]]  # (anything other than whitespace or ':[]'
                         |           # ...or...
                         \[[^\]]*\]  # a single complete bracketed expression)
                     )+              # occurring once or more
-                '''), pattern, re.X
+                """), pattern, re.X
             )
 
     return [p.strip() for p in patterns if p.strip()]
 
 
 class InventoryManager(object):
-    ''' Creates and manages inventory '''
+    """ Creates and manages inventory """
 
     def __init__(self, loader, sources=None, parse=True, cache=True):
 
@@ -196,12 +202,12 @@ class InventoryManager(object):
     def get_host(self, hostname):
         return self._inventory.get_host(hostname)
 
-    def _fetch_inventory_plugins(self):
-        ''' sets up loaded inventory plugins for usage '''
+    def _fetch_inventory_plugins(self) -> list[BaseInventoryPlugin]:
+        """ sets up loaded inventory plugins for usage """
 
         display.vvvv('setting up inventory plugins')
 
-        plugins = []
+        plugins: list[BaseInventoryPlugin] = []
         for name in C.INVENTORY_ENABLED:
             plugin = inventory_loader.get(name)
             if plugin:
@@ -215,7 +221,7 @@ class InventoryManager(object):
         return plugins
 
     def parse_sources(self, cache=False):
-        ''' iterate over inventory sources and parse each one to populate it'''
+        """ iterate over inventory sources and parse each one to populate it"""
 
         parsed = False
         # allow for multiple inventory parsing
@@ -243,7 +249,7 @@ class InventoryManager(object):
             host.vars = combine_vars(host.vars, get_vars_from_inventory_sources(self._loader, self._sources, [host], 'inventory'))
 
     def parse_source(self, source, cache=False):
-        ''' Generate or update inventory for the source provided '''
+        """ Generate or update inventory for the source provided """
 
         parsed = False
         failures = []
@@ -276,7 +282,6 @@ class InventoryManager(object):
 
             # try source with each plugin
             for plugin in self._fetch_inventory_plugins():
-
                 plugin_name = to_text(getattr(plugin, '_load_name', getattr(plugin, '_original_path', '')))
                 display.debug(u'Attempting to use plugin %s (%s)' % (plugin_name, plugin._original_path))
 
@@ -287,9 +292,14 @@ class InventoryManager(object):
                     plugin_wants = False
 
                 if plugin_wants:
+                    # have this tag ready to apply to errors or output; str-ify source since it is often tagged by the CLI
+                    origin = Origin(description=f'<inventory plugin {plugin_name!r} with source {str(source)!r}>')
                     try:
-                        # FIXME in case plugin fails 1/2 way we have partial inventory
-                        plugin.parse(self._inventory, self._loader, source, cache=cache)
+                        inventory_wrapper = _InventoryDataWrapper(self._inventory, target_plugin=plugin, origin=origin)
+
+                        # FUTURE: now that we have a wrapper around inventory, we can have it use ChainMaps to preview the in-progress inventory,
+                        #  but be able to roll back partial inventory failures by discarding the outermost layer
+                        plugin.parse(inventory_wrapper, self._loader, source, cache=cache)
                         try:
                             plugin.update_cache_if_changed()
                         except AttributeError:
@@ -298,14 +308,16 @@ class InventoryManager(object):
                         parsed = True
                         display.vvv('Parsed %s inventory source with %s plugin' % (source, plugin_name))
                         break
-                    except AnsibleParserError as e:
-                        display.debug('%s was not parsable by %s' % (source, plugin_name))
-                        tb = ''.join(traceback.format_tb(sys.exc_info()[2]))
-                        failures.append({'src': source, 'plugin': plugin_name, 'exc': e, 'tb': tb})
-                    except Exception as e:
-                        display.debug('%s failed while attempting to parse %s' % (plugin_name, source))
-                        tb = ''.join(traceback.format_tb(sys.exc_info()[2]))
-                        failures.append({'src': source, 'plugin': plugin_name, 'exc': AnsibleError(e), 'tb': tb})
+                    except AnsibleError as ex:
+                        if not ex.obj:
+                            ex.obj = origin
+                        failures.append({'src': source, 'plugin': plugin_name, 'exc': ex})
+                    except Exception as ex:
+                        try:
+                            # omit line number to prevent contextual display of script or possibly sensitive info
+                            raise AnsibleError(str(ex), obj=origin) from ex
+                        except AnsibleError as ex:
+                            failures.append({'src': source, 'plugin': plugin_name, 'exc': ex})
                 else:
                     display.vvv("%s declined parsing %s as it did not pass its verify_file() method" % (plugin_name, source))
 
@@ -319,9 +331,8 @@ class InventoryManager(object):
                 if failures:
                     # only if no plugin processed files should we show errors.
                     for fail in failures:
-                        display.warning(u'\n* Failed to parse %s with %s plugin: %s' % (to_text(fail['src']), fail['plugin'], to_text(fail['exc'])))
-                        if 'tb' in fail:
-                            display.vvv(to_text(fail['tb']))
+                        # `obj` should always be set
+                        display.error_as_warning(msg=f'Failed to parse inventory with {fail["plugin"]!r} plugin.', exception=fail['exc'])
 
                 # final error/warning on inventory source failure
                 if C.INVENTORY_ANY_UNPARSED_IS_FAILED:
@@ -335,12 +346,12 @@ class InventoryManager(object):
         return parsed
 
     def clear_caches(self):
-        ''' clear all caches '''
+        """ clear all caches """
         self._hosts_patterns_cache = {}
         self._pattern_cache = {}
 
     def refresh_inventory(self):
-        ''' recalculate inventory '''
+        """ recalculate inventory """
 
         self.clear_caches()
         self._inventory = InventoryData()
@@ -657,9 +668,9 @@ class InventoryManager(object):
         self._pattern_cache = {}
 
     def add_dynamic_host(self, host_info, result_item):
-        '''
+        """
         Helper function to add a new host to inventory based on a task result.
-        '''
+        """
 
         changed = False
         if not result_item.get('refresh'):
@@ -697,10 +708,10 @@ class InventoryManager(object):
             result_item['changed'] = changed
 
     def add_dynamic_group(self, host, result_item):
-        '''
+        """
         Helper function to add a group (if it does not exist), and to assign the
         specified host to that group.
-        '''
+        """
 
         changed = False
 
@@ -749,3 +760,36 @@ class InventoryManager(object):
             self.reconcile_inventory()
 
         result_item['changed'] = changed
+
+
+class _InventoryDataWrapper(_wrapt.ObjectProxy):
+    """
+    Proxy wrapper around InventoryData.
+    Allows `set_variable` calls to automatically apply template trust for plugins that don't know how.
+    """
+
+    # declared as class attrs to signal to ObjectProxy that we want them stored on the proxy, not the wrapped value
+    _target_plugin = None
+    _default_origin = None
+
+    def __init__(self, referent: InventoryData, target_plugin: BaseInventoryPlugin, origin: Origin) -> None:
+        super().__init__(referent)
+        self._target_plugin = target_plugin
+        # fallback origin to ensure that vars are tagged with at least the file they came from
+        self._default_origin = origin
+
+    @functools.cached_property
+    def _inspector(self) -> _json.AnsibleVariableVisitor:
+        """
+        Inventory plugins can delegate to other plugins (e.g. `auto`).
+        This hack defers sampling the target plugin's `trusted_by_default` attr until `set_variable` is called, typically inside `parse`.
+        Trust is then optionally applied based on the plugin's declared intent via `trusted_by_default`.
+        """
+        return _json.AnsibleVariableVisitor(
+            trusted_as_template=self._target_plugin.trusted_by_default,
+            origin=self._default_origin,
+            encrypted_string_behavior=EncryptedStringBehavior.PRESERVE,
+        )
+
+    def set_variable(self, entity: str, varname: str, value: t.Any) -> None:
+        self.__wrapped__.set_variable(entity, varname, self._inspector.visit(value))

ansible/keyword_desc.yml

@@ -13,7 +13,7 @@ become_method: Which method of privilege escalation to use (such as sudo or su).
 become_user: "User that you 'become' after using privilege escalation. The remote/login user must have permissions to become this user."
 block: List of tasks in a block.
 changed_when: "Conditional expression that overrides the task's normal 'changed' status."
-check_mode: A boolean that controls if a task is executed in 'check' mode. See :ref:`check_mode_dry`.
+check_mode: A boolean that controls if a task is run normally or avoids changes to the target and tries to report what it would have done (check mode/dry run). See :ref:`check_mode_dry`.
 collections: |
     List of collection namespaces to search for modules, plugins, and roles. See :ref:`collections_using_playbook`
 

ansible/module_utils/_internal/__init__.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import collections.abc as c
+
+import typing as t
+
+
+# DTFIX-RELEASE: bikeshed "intermediate"
+INTERMEDIATE_MAPPING_TYPES = (c.Mapping,)
+"""
+Mapping types which are supported for recursion and runtime usage, such as in serialization and templating.
+These will be converted to a simple Python `dict` before serialization or storage as a variable.
+"""
+
+INTERMEDIATE_ITERABLE_TYPES = (tuple, set, frozenset, c.Sequence)
+"""
+Iterable types which are supported for recursion and runtime usage, such as in serialization and templating.
+These will be converted to a simple Python `list` before serialization or storage as a variable.
+CAUTION: Scalar types which are sequences should be excluded when using this.
+"""
+
+ITERABLE_SCALARS_NOT_TO_ITERATE_FIXME = (str, bytes)
+"""Scalars which are also iterable, and should thus be excluded from iterable checks."""
+
+
+def is_intermediate_mapping(value: object) -> bool:
+    """Returns `True` if `value` is a type supported for projection to a Python `dict`, otherwise returns `False`."""
+    # DTFIX-RELEASE: bikeshed name
+    return isinstance(value, INTERMEDIATE_MAPPING_TYPES)
+
+
+def is_intermediate_iterable(value: object) -> bool:
+    """Returns `True` if `value` is a type supported for projection to a Python `list`, otherwise returns `False`."""
+    # DTFIX-RELEASE: bikeshed name
+    return isinstance(value, INTERMEDIATE_ITERABLE_TYPES) and not isinstance(value, ITERABLE_SCALARS_NOT_TO_ITERATE_FIXME)
+
+
+is_controller: bool = False
+"""Set to True automatically when this module is imported into an Ansible controller context."""
+
+
+def get_controller_serialize_map() -> dict[type, t.Callable]:
+    """
+    Called to augment serialization maps.
+    This implementation is replaced with the one from ansible._internal in controller contexts.
+    """
+    return {}
+
+
+def import_controller_module(_module_name: str, /) -> t.Any:
+    """
+    Called to conditionally import the named module in a controller context, otherwise returns `None`.
+    This implementation is replaced with the one from ansible._internal in controller contexts.
+    """
+    return None

ansible/module_utils/_internal/_ambient_context.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2024 Ansible Project
+# Simplified BSD License (see licenses/simplified_bsd.txt or https://opensource.org/licenses/BSD-2-Clause)
+
+from __future__ import annotations
+
+import contextlib
+import contextvars
+
+# deprecated: description='typing.Self exists in Python 3.11+' python_version='3.10'
+from ..compat import typing as t
+
+
+class AmbientContextBase:
+    """
+    An abstract base context manager that, once entered, will be accessible via its `current` classmethod to any code in the same
+    `contextvars` context (e.g. same thread/coroutine), until it is exited.
+    """
+
+    __slots__ = ('_contextvar_token',)
+
+    # DTFIX-FUTURE: subclasses need to be able to opt-in to blocking nested contexts of the same type (basically optional per-callstack singleton behavior)
+    # DTFIX-RELEASE: this class should enforce strict nesting of contexts; overlapping context lifetimes leads to incredibly difficult to
+    #        debug situations with undefined behavior, so it should fail fast.
+    # DTFIX-RELEASE: make frozen=True dataclass subclasses work (fix the mutability of the contextvar instance)
+
+    _contextvar: t.ClassVar[contextvars.ContextVar]  # pylint: disable=declare-non-slot  # pylint bug, see https://github.com/pylint-dev/pylint/issues/9950
+    _contextvar_token: contextvars.Token
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        cls._contextvar = contextvars.ContextVar(cls.__name__)
+
+    @classmethod
+    def when(cls, condition: bool, /, *args, **kwargs) -> t.Self | contextlib.nullcontext:
+        """Return an instance of the context if `condition` is `True`, otherwise return a `nullcontext` instance."""
+        return cls(*args, **kwargs) if condition else contextlib.nullcontext()
+
+    @classmethod
+    def current(cls, optional: bool = False) -> t.Self | None:
+        """
+        Return the currently active context value for the current thread or coroutine.
+        Raises ReferenceError if a context is not active, unless `optional` is `True`.
+        """
+        try:
+            return cls._contextvar.get()
+        except LookupError:
+            if optional:
+                return None
+
+            raise ReferenceError(f"A required {cls.__name__} context is not active.") from None
+
+    def __enter__(self) -> t.Self:
+        # DTFIX-RELEASE: actively block multiple entry
+        self._contextvar_token = self.__class__._contextvar.set(self)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.__class__._contextvar.reset(self._contextvar_token)
+        del self._contextvar_token

ansible/module_utils/_internal/_ansiballz.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2024 Ansible Project
+# Simplified BSD License (see licenses/simplified_bsd.txt or https://opensource.org/licenses/BSD-2-Clause)
+
+"""Support code for exclusive use by the AnsiballZ wrapper."""
+
+from __future__ import annotations
+
+import atexit
+import dataclasses
+import importlib.util
+import json
+import os
+import runpy
+import sys
+import typing as t
+
+from . import _errors
+from ._plugin_exec_context import PluginExecContext, HasPluginInfo
+from .. import basic
+from ..common.json import get_module_encoder, Direction
+from ..common.messages import PluginInfo
+
+
+def run_module(
+    *,
+    json_params: bytes,
+    profile: str,
+    plugin_info_dict: dict[str, object],
+    module_fqn: str,
+    modlib_path: str,
+    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)
+        _run_module(
+            json_params=json_params,
+            profile=profile,
+            plugin_info_dict=plugin_info_dict,
+            module_fqn=module_fqn,
+            modlib_path=modlib_path,
+            init_globals=init_globals,
+        )
+    except Exception as ex:  # not BaseException, since modules are expected to raise SystemExit
+        _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,
+    profile: str,
+    plugin_info_dict: dict[str, object],
+    module_fqn: str,
+    modlib_path: str,
+    init_globals: dict[str, t.Any] | None = None,
+) -> None:
+    """Used internally by `_run_module` to run an Ansible module after coverage has been enabled (if applicable)."""
+    basic._ANSIBLE_ARGS = json_params
+    basic._ANSIBLE_PROFILE = profile
+
+    init_globals = init_globals or {}
+    init_globals.update(_module_fqn=module_fqn, _modlib_path=modlib_path)
+
+    with PluginExecContext(_ModulePluginWrapper(PluginInfo._from_dict(plugin_info_dict))):
+        # Run the module. By importing it as '__main__', it executes as a script.
+        runpy.run_module(mod_name=module_fqn, init_globals=init_globals, run_name='__main__', alter_sys=True)
+
+        # An Ansible module must print its own results and exit. If execution reaches this point, that did not happen.
+        raise RuntimeError('New-style module did not handle its own exit.')
+
+
+def _handle_exception(exception: BaseException, profile: str) -> t.NoReturn:
+    """Handle the given exception."""
+    result = dict(
+        failed=True,
+        exception=_errors.create_error_summary(exception),
+    )
+
+    encoder = get_module_encoder(profile, Direction.MODULE_TO_CONTROLLER)
+
+    print(json.dumps(result, cls=encoder))  # pylint: disable=ansible-bad-function
+
+    sys.exit(1)  # pylint: disable=ansible-bad-function
+
+
+@dataclasses.dataclass(frozen=True)
+class _ModulePluginWrapper(HasPluginInfo):
+    """Modules aren't plugin instances; this adapter implements the `HasPluginInfo` protocol to allow `PluginExecContext` infra to work with modules."""
+
+    plugin: PluginInfo
+
+    @property
+    def _load_name(self) -> str:
+        return self.plugin.requested_name
+
+    @property
+    def ansible_name(self) -> str:
+        return self.plugin.resolved_name
+
+    @property
+    def plugin_type(self) -> str:
+        return self.plugin.type

ansible/module_utils/_internal/_concurrent/_daemon_threading.py

@@ -1,4 +1,5 @@
 """Proxy stdlib threading module that only supports non-joinable daemon threads."""
+
 # NB: all new local module attrs are _ prefixed to ensure an identical public attribute surface area to the module we're proxying
 
 from __future__ import annotations as _annotations