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

ansible/_internal/_templating/_jinja_bits.py

@@ -78,6 +78,21 @@ The values following this prefix up to the first newline are parsed as Jinja2 te
 To include this literal value at the start of a string, a space or other character must precede it.
 """
 
+JINJA_KEYWORDS = frozenset(
+    {
+        # scalar singletons (see jinja2.nodes.Name.can_assign)
+        'true',
+        'false',
+        'none',
+        'True',
+        'False',
+        'None',
+        # other
+        'not',  # unary operator always applicable to names
+    }
+)
+"""Names which have special meaning to Jinja and cannot be resolved as variable names."""
+
 display = Display()
 
 
@@ -799,7 +814,7 @@ class AnsibleEnvironment(ImmutableSandboxedEnvironment):
             # Performing either before calling them will interfere with that processing.
             return super().call(__context, __obj, *args, **kwargs)
 
-        # Jinja's generated macro code handles Markers, so pre-emptive raise on Marker args and lazy retrieval should be disabled for the macro invocation.
+        # Jinja's generated macro code handles Markers, so preemptive raise on Marker args and lazy retrieval should be disabled for the macro invocation.
         is_macro = isinstance(__obj, Macro)
 
         if not is_macro and (first_marker := get_first_marker_arg(args, kwargs)) is not None:

ansible/_internal/_templating/_jinja_common.py

@@ -96,7 +96,7 @@ class Marker(StrictUndefined, Tripwire):
         return AnsibleUndefinedVariable(self._undefined_message, obj=self._marker_template_source)
 
     def _as_message(self) -> str:
-        """Return the error message to show when this marker must be represented as a string, such as for subsitutions or warnings."""
+        """Return the error message to show when this marker must be represented as a string, such as for substitutions or warnings."""
         return self._undefined_message
 
     def _fail_with_undefined_error(self, *args: t.Any, **kwargs: t.Any) -> t.NoReturn:

ansible/cli/__init__.py

@@ -212,9 +212,9 @@ class CLI(ABC):
             # used by --vault-id and --vault-password-file
             vault_ids.append(id_slug)
 
-        # if an action needs an encrypt password (create_new_password=True) and we dont
+        # if an action needs an encrypt password (create_new_password=True) and we don't
         # have other secrets setup, then automatically add a password prompt as well.
-        # prompts cant/shouldnt work without a tty, so dont add prompt secrets
+        # prompts can't/shouldn't work without a tty, so don't add prompt secrets
         if ask_vault_pass or (not vault_ids and auto_prompt):
 
             id_slug = u'%s@%s' % (C.DEFAULT_VAULT_IDENTITY, u'prompt_ask_vault_pass')

ansible/cli/adhoc.py

@@ -88,8 +88,11 @@ class AdHocCLI(CLI):
         if not module_args:
             module_args = parse_kv(module_args_raw, check_raw=check_raw)
 
-        mytask = {'action': {'module': context.CLIARGS['module_name'], 'args': module_args},
-                  'timeout': context.CLIARGS['task_timeout']}
+        mytask = dict(
+            action=context.CLIARGS['module_name'],
+            args=module_args,
+            timeout=context.CLIARGS['task_timeout'],
+        )
 
         mytask = Origin(description=f'<adhoc {context.CLIARGS["module_name"]!r} task>').tag(mytask)
 
@@ -184,7 +187,7 @@ class AdHocCLI(CLI):
                 variable_manager=variable_manager,
                 loader=loader,
                 passwords=passwords,
-                stdout_callback=cb,
+                stdout_callback_name=cb,
                 run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS,
                 run_tree=run_tree,
                 forks=context.CLIARGS['forks'],

ansible/cli/console.py

@@ -222,7 +222,7 @@ class ConsoleCLI(CLI, cmd.Cmd):
                     variable_manager=self.variable_manager,
                     loader=self.loader,
                     passwords=self.passwords,
-                    stdout_callback=cb,
+                    stdout_callback_name=cb,
                     run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS,
                     run_tree=False,
                     forks=self.forks,

ansible/cli/doc.py

@@ -1309,7 +1309,7 @@ class DocCLI(CLI, RoleMixin):
                             if ignore in item:
                                 del item[ignore]
 
-            # reformat cli optoins
+            # reformat cli options
             if 'cli' in opt and opt['cli']:
                 conf['cli'] = []
                 for cli in opt['cli']:
@@ -1440,7 +1440,7 @@ class DocCLI(CLI, RoleMixin):
         pad = display.columns * 0.20
         limit = max(display.columns - int(pad), 70)
 
-        text.append("> %s %s (%s)" % (plugin_type.upper(), _format(doc.pop('plugin_name'), 'bold'), doc.pop('filename')))
+        text.append("> %s %s (%s)" % (plugin_type.upper(), _format(doc.pop('plugin_name'), 'bold'), doc.pop('filename') or 'Jinja2'))
 
         if isinstance(doc['description'], list):
             descs = doc.pop('description')

ansible/config/base.yml

@@ -41,6 +41,15 @@ _CALLBACK_DISPATCH_ERROR_BEHAVIOR:
     ignore: just continue silently
   env: [ { name: _ANSIBLE_CALLBACK_DISPATCH_ERROR_BEHAVIOR } ]
   version_added: '2.19'
+_MODULE_METADATA:
+  name: Enable experimental module metadata
+  description:
+    - Enables experimental module-level metadata controls for serialization profile selection.
+    - This is for internal use only.
+  type: boolean
+  default: false
+  env: [ { name: _ANSIBLE_MODULE_METADATA } ]
+  version_added: '2.19'
 ALLOW_BROKEN_CONDITIONALS:
   # This config option will be deprecated once it no longer has any effect (2.23).
   name: Allow broken conditionals
@@ -2176,12 +2185,6 @@ WIN_ASYNC_STARTUP_TIMEOUT:
   vars:
     - {name: ansible_win_async_startup_timeout}
   version_added: '2.10'
-WRAP_STDERR:
-  description: Control line-wrapping behavior on console warnings and errors from default output callbacks (eases pattern-based output testing)
-  env: [{name: ANSIBLE_WRAP_STDERR}]
-  default: false
-  type: bool
-  version_added: "2.19"
 YAML_FILENAME_EXTENSIONS:
   name: Valid YAML extensions
   default: [".yml", ".yaml", ".json"]

ansible/executor/module_common.py

@@ -364,7 +364,7 @@ def _get_shebang(interpreter, task_vars, templar: _template.Templar, args=tuple(
                                                    options=TemplateOptions(value_for_omit=None))
 
     if not interpreter_out:
-        # nothing matched(None) or in case someone configures empty string or empty intepreter
+        # nothing matched(None) or in case someone configures empty string or empty interpreter
         interpreter_out = interpreter
 
     # set shebang
@@ -659,9 +659,14 @@ metadata_versions: dict[t.Any, type[ModuleMetadata]] = {
     1: ModuleMetadataV1,
 }
 
+_DEFAULT_LEGACY_METADATA = ModuleMetadataV1(serialization_profile='legacy')
+
 
 def _get_module_metadata(module: ast.Module) -> ModuleMetadata:
-    # DTFIX2: while module metadata works, this feature isn't fully baked and should be turned off before release
+    # experimental module metadata; off by default
+    if not C.config.get_config_value('_MODULE_METADATA'):
+        return _DEFAULT_LEGACY_METADATA
+
     metadata_nodes: list[ast.Assign] = []
 
     for node in module.body:
@@ -674,9 +679,7 @@ def _get_module_metadata(module: ast.Module) -> ModuleMetadata:
                         metadata_nodes.append(node)
 
     if not metadata_nodes:
-        return ModuleMetadataV1(
-            serialization_profile='legacy',
-        )
+        return _DEFAULT_LEGACY_METADATA
 
     if len(metadata_nodes) > 1:
         raise ValueError('Module METADATA must defined only once.')

ansible/executor/powershell/psrp_put_file.ps1

@@ -102,7 +102,7 @@ begin {
             Set-Property 'MaximumAllowedMemory' $null
     }
     catch {
-        # Satify pslint, we purposefully ignore this error as it is not critical it works.
+        # Satisfy pslint, we purposefully ignore this error as it is not critical it works.
         $null = $null
     }
 }

ansible/executor/task_executor.py

@@ -872,7 +872,7 @@ class TaskExecutor:
                 async_result = async_handler.run(task_vars=task_vars)
                 # We do not bail out of the loop in cases where the failure
                 # is associated with a parsing error. The async_runner can
-                # have issues which result in a half-written/unparseable result
+                # have issues which result in a half-written/unparsable result
                 # file on disk, which manifests to the user as a timeout happening
                 # before it's time to timeout.
                 if (async_result.get('finished', False) or
@@ -910,7 +910,7 @@ class TaskExecutor:
             if async_result.get('_ansible_parsed'):
                 return dict(failed=True, msg="async task did not complete within the requested time - %ss" % self._task.async_val, async_result=async_result)
             else:
-                return dict(failed=True, msg="async task produced unparseable results", async_result=async_result)
+                return dict(failed=True, msg="async task produced unparsable results", async_result=async_result)
         else:
             # If the async task finished, automatically cleanup the temporary
             # status file left behind.

ansible/executor/task_queue_manager.py

@@ -34,7 +34,6 @@ from ansible.executor.play_iterator import PlayIterator
 from ansible.executor.stats import AggregateStats
 from ansible.executor.task_result import _RawTaskResult, _WireTaskResult
 from ansible.inventory.data import InventoryData
-from ansible.module_utils.six import string_types
 from ansible.module_utils.common.text.converters import to_native
 from ansible.parsing.dataloader import DataLoader
 from ansible.playbook.play_context import PlayContext
@@ -139,7 +138,7 @@ class TaskQueueManager:
         variable_manager: VariableManager,
         loader: DataLoader,
         passwords: dict[str, str | None],
-        stdout_callback: str | None = None,
+        stdout_callback_name: str | None = None,
         run_additional_callbacks: bool = True,
         run_tree: bool = False,
         forks: int | None = None,
@@ -149,12 +148,11 @@ class TaskQueueManager:
         self._loader = loader
         self._stats = AggregateStats()
         self.passwords = passwords
-        self._stdout_callback: str | None | CallbackBase = stdout_callback
+        self._stdout_callback_name: str | None = stdout_callback_name or C.DEFAULT_STDOUT_CALLBACK
         self._run_additional_callbacks = run_additional_callbacks
         self._run_tree = run_tree
         self._forks = forks or 5
 
-        self._callbacks_loaded = False
         self._callback_plugins: list[CallbackBase] = []
         self._start_at_done = False
 
@@ -199,44 +197,40 @@ class TaskQueueManager:
         only one such callback plugin will be loaded.
         """
 
-        if self._callbacks_loaded:
+        if self._callback_plugins:
             return
 
-        stdout_callback_loaded = False
-        if self._stdout_callback is None:
-            self._stdout_callback = C.DEFAULT_STDOUT_CALLBACK
+        if not self._stdout_callback_name:
+            raise AnsibleError("No stdout callback name provided.")
 
-        if isinstance(self._stdout_callback, CallbackBase):
-            stdout_callback_loaded = True
-        elif isinstance(self._stdout_callback, string_types):
-            if self._stdout_callback not in callback_loader:
-                raise AnsibleError("Invalid callback for stdout specified: %s" % self._stdout_callback)
-            else:
-                self._stdout_callback = callback_loader.get(self._stdout_callback)
-                self._stdout_callback.set_options()
-                stdout_callback_loaded = True
-        else:
-            raise AnsibleError("callback must be an instance of CallbackBase or the name of a callback plugin")
+        stdout_callback = callback_loader.get(self._stdout_callback_name)
+
+        if not stdout_callback:
+            raise AnsibleError(f"Could not load {self._stdout_callback_name!r} callback plugin.")
+
+        stdout_callback._init_callback_methods()
+        stdout_callback.set_options()
+
+        self._callback_plugins.append(stdout_callback)
 
         # get all configured loadable callbacks (adjacent, builtin)
-        callback_list = list(callback_loader.all(class_only=True))
+        plugin_types = {plugin_type.ansible_name: plugin_type for plugin_type in callback_loader.all(class_only=True)}
 
         # add enabled callbacks that refer to collections, which might not appear in normal listing
         for c in C.CALLBACKS_ENABLED:
             # load all, as collection ones might be using short/redirected names and not a fqcn
             plugin = callback_loader.get(c, class_only=True)
 
-            # TODO: check if this skip is redundant, loader should handle bad file/plugin cases already
             if plugin:
                 # avoids incorrect and dupes possible due to collections
-                if plugin not in callback_list:
-                    callback_list.append(plugin)
+                plugin_types.setdefault(plugin.ansible_name, plugin)
             else:
                 display.warning("Skipping callback plugin '%s', unable to load" % c)
 
-        # for each callback in the list see if we should add it to 'active callbacks' used in the play
-        for callback_plugin in callback_list:
+        plugin_types.pop(stdout_callback.ansible_name, None)
 
+        # for each callback in the list see if we should add it to 'active callbacks' used in the play
+        for callback_plugin in plugin_types.values():
             callback_type = getattr(callback_plugin, 'CALLBACK_TYPE', '')
             callback_needs_enabled = getattr(callback_plugin, 'CALLBACK_NEEDS_ENABLED', getattr(callback_plugin, 'CALLBACK_NEEDS_WHITELIST', False))
 
@@ -252,10 +246,8 @@ class TaskQueueManager:
             display.vvvvv("Attempting to use '%s' callback." % (callback_name))
             if callback_type == 'stdout':
                 # we only allow one callback of type 'stdout' to be loaded,
-                if callback_name != self._stdout_callback or stdout_callback_loaded:
-                    display.vv("Skipping callback '%s', as we already have a stdout callback." % (callback_name))
-                    continue
-                stdout_callback_loaded = True
+                display.vv("Skipping callback '%s', as we already have a stdout callback." % (callback_name))
+                continue
             elif callback_name == 'tree' and self._run_tree:
                 # TODO: remove special case for tree, which is an adhoc cli option --tree
                 pass
@@ -270,21 +262,16 @@ class TaskQueueManager:
                 # avoid bad plugin not returning an object, only needed cause we do class_only load and bypass loader checks,
                 # really a bug in the plugin itself which we ignore as callback errors are not supposed to be fatal.
                 if callback_obj:
-                    # skip initializing if we already did the work for the same plugin (even with diff names)
-                    if callback_obj not in self._callback_plugins:
-                        callback_obj.set_options()
-                        self._callback_plugins.append(callback_obj)
-                    else:
-                        display.vv("Skipping callback '%s', already loaded as '%s'." % (callback_plugin, callback_name))
+                    callback_obj._init_callback_methods()
+                    callback_obj.set_options()
+                    self._callback_plugins.append(callback_obj)
                 else:
                     display.warning("Skipping callback '%s', as it does not create a valid plugin instance." % callback_name)
                     continue
-            except Exception as e:
-                display.warning("Skipping callback '%s', unable to load due to: %s" % (callback_name, to_native(e)))
+            except Exception as ex:
+                display.warning_as_error(f"Failed to load callback plugin {callback_name!r}.", exception=ex)
                 continue
 
-        self._callbacks_loaded = True
-
     def run(self, play):
         """
         Iterates over the roles/tasks in a play, using the given (or default)
@@ -294,8 +281,7 @@ class TaskQueueManager:
         are done with the current task).
         """
 
-        if not self._callbacks_loaded:
-            self.load_callbacks()
+        self.load_callbacks()
 
         all_vars = self._variable_manager.get_vars(play=play)
         templar = TemplateEngine(loader=self._loader, variables=all_vars)
@@ -311,13 +297,9 @@ class TaskQueueManager:
         )
 
         play_context = PlayContext(new_play, self.passwords, self._connection_lockfile.fileno())
-        if (self._stdout_callback and
-                hasattr(self._stdout_callback, 'set_play_context')):
-            self._stdout_callback.set_play_context(play_context)
 
         for callback_plugin in self._callback_plugins:
-            if hasattr(callback_plugin, 'set_play_context'):
-                callback_plugin.set_play_context(play_context)
+            callback_plugin.set_play_context(play_context)
 
         self.send_callback('v2_playbook_on_play_start', new_play)
 
@@ -437,7 +419,7 @@ class TaskQueueManager:
     @lock_decorator(attr='_callback_lock')
     def send_callback(self, method_name, *args, **kwargs):
         # We always send events to stdout callback first, rest should follow config order
-        for callback_plugin in [self._stdout_callback] + self._callback_plugins:
+        for callback_plugin in self._callback_plugins:
             # a plugin that set self.disabled to True will not be called
             # see osx_say.py example for such a plugin
             if callback_plugin.disabled:
@@ -448,31 +430,13 @@ class TaskQueueManager:
             if not callback_plugin.wants_implicit_tasks and (task_arg := self._first_arg_of_type(Task, args)) and task_arg.implicit:
                 continue
 
-            # try to find v2 method, fallback to v1 method, ignore callback if no method found
             methods = []
 
-            for possible in [method_name, 'v2_on_any']:
-                method = getattr(callback_plugin, possible, None)
-
-                if method is None:
-                    method = getattr(callback_plugin, possible.removeprefix('v2_'), None)
-
-                    if method is not None:
-                        display.deprecated(
-                            msg='The v1 callback API is deprecated.',
-                            version='2.23',
-                            help_text='Use `v2_` prefixed callback methods instead.',
-                        )
-
-                if method is not None and not getattr(method, '_base_impl', False):  # don't bother dispatching to the base impls
-                    if possible == 'v2_on_any':
-                        display.deprecated(
-                            msg='The `v2_on_any` callback method is deprecated.',
-                            version='2.23',
-                            help_text='Use event-specific callback methods instead.',
-                        )
+            if method_name in callback_plugin._implemented_callback_methods:
+                methods.append(getattr(callback_plugin, method_name))
 
-                    methods.append(method)
+            if 'v2_on_any' in callback_plugin._implemented_callback_methods:
+                methods.append(getattr(callback_plugin, 'v2_on_any'))
 
             for method in methods:
                 # send clean copies
@@ -498,4 +462,4 @@ class TaskQueueManager:
                     except Exception as ex:
                         raise AnsibleCallbackError(f"Callback dispatch {method_name!r} failed for plugin {callback_plugin._load_name!r}.") from ex
 
-            callback_plugin._current_task_result = None
+            callback_plugin._current_task_result = None  # clear temporary instance storage hack

ansible/executor/task_result.py

@@ -27,7 +27,7 @@ _SUB_PRESERVE = {'_ansible_delegated_vars': {'ansible_host', 'ansible_port', 'an
 CLEAN_EXCEPTIONS = (
     '_ansible_verbose_always',  # for debug and other actions, to always expand data (pretty jsonification)
     '_ansible_item_label',  # to know actual 'item' variable
-    '_ansible_no_log',  # jic we didnt clean up well enough, DON'T LOG
+    '_ansible_no_log',  # jic we didn't clean up well enough, DON'T LOG
     '_ansible_verbose_override',  # controls display of ansible_facts, gathering would be very noise with -v otherwise
 )
 

ansible/galaxy/api.py

@@ -92,7 +92,7 @@ def g_connect(versions):
                 try:
                     data = self._call_galaxy(n_url, method='GET', error_context_msg=error_context_msg, cache=True)
                 except (AnsibleError, GalaxyError, ValueError, KeyError) as err:
-                    # Either the URL doesnt exist, or other error. Or the URL exists, but isn't a galaxy API
+                    # Either the URL doesn't exist, or other error. Or the URL exists, but isn't a galaxy API
                     # root (not JSON, no 'available_versions') so try appending '/api/'
                     if n_url.endswith('/api') or n_url.endswith('/api/'):
                         raise
@@ -877,7 +877,7 @@ class GalaxyAPI:
         except GalaxyError as err:
             if err.http_code != 404:
                 raise
-            # v3 doesn't raise a 404 so we need to mimick the empty response from APIs that do.
+            # v3 doesn't raise a 404 so we need to mimic the empty response from APIs that do.
             return []
 
         if 'data' in data:

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

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/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/_deprecator.py

@@ -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:
@@ -62,6 +67,10 @@ 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")
@@ -101,6 +110,8 @@ def _path_as_collection_plugininfo(path: str) -> _messages.PluginInfo | None:
 
     name = '.'.join((match.group('ns'), match.group('coll'), match.group('plugin_name')))
 
+    # DTFIX-FUTURE: deprecations from __init__ will be incorrectly attributed to a plugin of that name
+
     return _messages.PluginInfo(resolved_name=name, type=plugin_type)
 
 

ansible/module_utils/ansible_release.py

@@ -17,6 +17,6 @@
 
 from __future__ import annotations
 
-__version__ = '2.19.0b6'
+__version__ = '2.19.0b7'
 __author__ = 'Ansible, Inc.'
 __codename__ = "What Is and What Should Never Be"

ansible/module_utils/basic.py

@@ -1657,10 +1657,11 @@ class AnsibleModule(object):
             ext = time.strftime("%Y-%m-%d@%H:%M:%S~", time.localtime(time.time()))
             backupdest = '%s.%s.%s' % (fn, os.getpid(), ext)
 
-            try:
-                self.preserved_copy(fn, backupdest)
-            except (shutil.Error, OSError) as ex:
-                raise Exception(f'Could not make backup of {fn!r} to {backupdest!r}.') from ex
+            if not self.check_mode:
+                try:
+                    self.preserved_copy(fn, backupdest)
+                except (shutil.Error, IOError) as ex:
+                    raise Exception(f'Could not make backup of {fn!r} to {backupdest!r}.') from ex
 
         return backupdest
 
@@ -1899,18 +1900,18 @@ class AnsibleModule(object):
             the execution to hang (especially if no input data is specified)
         :kw environ_update: dictionary to *update* environ variables with
         :kw umask: Umask to be used when running the command. Default None
-        :kw encoding: Since we return native strings, on python3 we need to
+        :kw encoding: Since we return strings, we need to
             know the encoding to use to transform from bytes to text.  If you
             want to always get bytes back, use encoding=None.  The default is
             "utf-8".  This does not affect transformation of strings given as
             args.
-        :kw errors: Since we return native strings, on python3 we need to
+        :kw errors: Since we return strings, we need to
             transform stdout and stderr from bytes to text.  If the bytes are
             undecodable in the ``encoding`` specified, then use this error
             handler to deal with them.  The default is ``surrogate_or_strict``
             which means that the bytes will be decoded using the
             surrogateescape error handler if available (available on all
-            python3 versions we support) otherwise a UnicodeError traceback
+            Python versions we support) otherwise a UnicodeError traceback
             will be raised.  This does not affect transformations of strings
             given as args.
         :kw expand_user_and_vars: When ``use_unsafe_shell=False`` this argument
@@ -1918,10 +1919,8 @@ class AnsibleModule(object):
             are expanded before running the command. When ``True`` a string such as
             ``$SHELL`` will be expanded regardless of escaping. When ``False`` and
             ``use_unsafe_shell=False`` no path or variable expansion will be done.
-        :kw pass_fds: When running on Python 3 this argument
-            dictates which file descriptors should be passed
-            to an underlying ``Popen`` constructor. On Python 2, this will
-            set ``close_fds`` to False.
+        :kw pass_fds: This argument dictates which file descriptors should be passed
+            to an underlying ``Popen`` constructor.
         :kw before_communicate_callback: This function will be called
             after ``Popen`` object will be created
             but before communicating to the process.
@@ -1932,11 +1931,10 @@ class AnsibleModule(object):
         :kw handle_exceptions: This flag indicates whether an exception will
             be handled inline and issue a failed_json or if the caller should
             handle it.
-        :returns: A 3-tuple of return code (integer), stdout (native string),
-            and stderr (native string).  On python2, stdout and stderr are both
-            byte strings.  On python3, stdout and stderr are text strings converted
-            according to the encoding and errors parameters.  If you want byte
-            strings on python3, use encoding=None to turn decoding to text off.
+        :returns: A 3-tuple of return code (int), stdout (str), and stderr (str).
+            stdout and stderr are text strings converted according to the encoding
+            and errors parameters.  If you want byte strings, use encoding=None
+            to turn decoding to text off.
         """
         # used by clean args later on
         self._clean = None