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

ansible/module_utils/basic.py

@@ -75,7 +75,7 @@ except ImportError:
 # Python2 & 3 way to get NoneType
 NoneType = type(None)
 
-from ._internal import _traceback, _errors, _debugging, _deprecator
+from ._internal import _traceback, _errors, _debugging, _deprecator, _messages
 
 from .common.text.converters import (
     to_native,
@@ -161,10 +161,10 @@ from ansible.module_utils.common.validation import (
     safe_eval,
 )
 from ansible.module_utils.common._utils import get_all_subclasses as _get_all_subclasses
-from ansible.module_utils.common import messages as _messages
 from ansible.module_utils.parsing.convert_bool import BOOLEANS, BOOLEANS_FALSE, BOOLEANS_TRUE, boolean
 from ansible.module_utils.common.warnings import (
     deprecate,
+    error_as_warning,
     get_deprecations,
     get_warnings,
     warn,
@@ -480,9 +480,11 @@ class AnsibleModule(object):
             if basedir is not None and not os.path.exists(basedir):
                 try:
                     os.makedirs(basedir, mode=0o700)
-                except (OSError, IOError) as e:
-                    self.warn("Unable to use %s as temporary directory, "
-                              "failing back to system: %s" % (basedir, to_native(e)))
+                except OSError as ex:
+                    self.error_as_warning(
+                        msg=f"Unable to use {basedir!r} as temporary directory, falling back to system default.",
+                        exception=ex,
+                    )
                     basedir = None
                 else:
                     self.warn("Module remote_tmp %s did not exist and was "
@@ -494,20 +496,45 @@ class AnsibleModule(object):
             basefile = "ansible-moduletmp-%s-" % time.time()
             try:
                 tmpdir = tempfile.mkdtemp(prefix=basefile, dir=basedir)
-            except (OSError, IOError) as e:
-                self.fail_json(
-                    msg="Failed to create remote module tmp path at dir %s "
-                        "with prefix %s: %s" % (basedir, basefile, to_native(e))
-                )
+            except OSError as ex:
+                raise Exception(
+                    f"Failed to create remote module tmp path at dir {basedir!r} "
+                    f"with prefix {basefile!r}.",
+                ) from ex
             if not self._keep_remote_files:
                 atexit.register(shutil.rmtree, tmpdir)
             self._tmpdir = tmpdir
 
         return self._tmpdir
 
-    def warn(self, warning):
-        warn(warning)
-        self.log('[WARNING] %s' % warning)
+    def warn(
+        self,
+        warning: str,
+        *,
+        help_text: str | None = None,
+    ) -> None:
+        _skip_stackwalk = True
+
+        warn(
+            warning=warning,
+            help_text=help_text,
+        )
+
+    def error_as_warning(
+        self,
+        msg: str | None,
+        exception: BaseException,
+        *,
+        help_text: str | None = None,
+    ) -> None:
+        """Display an exception as a warning."""
+        _skip_stackwalk = True
+
+        error_as_warning(
+            msg=msg,
+            exception=exception,
+            help_text=help_text,
+        )
 
     def deprecate(
         self,
@@ -633,11 +660,8 @@ class AnsibleModule(object):
             return context
         try:
             ret = selinux.lgetfilecon_raw(to_native(path, errors='surrogate_or_strict'))
-        except OSError as e:
-            if e.errno == errno.ENOENT:
-                self.fail_json(path=path, msg='path %s does not exist' % path)
-            else:
-                self.fail_json(path=path, msg='failed to retrieve selinux context')
+        except OSError as ex:
+            self.fail_json(path=path, msg='Failed to retrieve selinux context.', exception=ex)
         if ret[0] == -1:
             return context
         # Limit split to 4 because the selevel, the last in the list,
@@ -777,9 +801,9 @@ class AnsibleModule(object):
                 return True
             try:
                 os.lchown(b_path, uid, -1)
-            except (IOError, OSError) as e:
+            except OSError as ex:
                 path = to_text(b_path)
-                self.fail_json(path=path, msg='chown failed: %s' % (to_text(e)))
+                self.fail_json(path=path, msg='chown failed', exception=ex)
             changed = True
         return changed
 
@@ -1305,7 +1329,7 @@ class AnsibleModule(object):
                     else:
                         journal.send(MESSAGE=u"%s %s" % (module, journal_msg),
                                      **dict(journal_args))
-                except IOError:
+                except OSError:
                     # fall back to syslog since logging to journal failed
                     self._log_to_syslog(journal_msg)
             else:
@@ -1399,7 +1423,7 @@ class AnsibleModule(object):
         # deprecate(
         #     msg="The `AnsibleModule.jsonify' method is deprecated.",
         #     version="2.27",
-        #     # help_text="",  # DTFIX-RELEASE: fill in this help text
+        #     # help_text="",  # DTFIX-FUTURE: fill in this help text
         # )
 
         try:
@@ -1528,16 +1552,25 @@ class AnsibleModule(object):
         )
 
         if isinstance(exception, BaseException):
-            # Include a `_messages.ErrorDetail` in the result.
-            # The `msg` is included in the list of errors to ensure it is not lost when looking only at `exception` from the result.
-
-            error_summary = _errors.create_error_summary(exception)
-            error_summary = _dataclasses.replace(error_summary, details=(_messages.Detail(msg=msg),) + error_summary.details)
-
-            kwargs.update(exception=error_summary)
+            # Include a `_messages.Event` in the result.
+            # The `msg` is included in the chain to ensure it is not lost when looking only at `exception` from the result.
+
+            kwargs.update(
+                exception=_messages.ErrorSummary(
+                    event=_messages.Event(
+                        msg=msg,
+                        formatted_traceback=_traceback.maybe_capture_traceback(msg, _traceback.TracebackEvent.ERROR),
+                        chain=_messages.EventChain(
+                            msg_reason=_errors.MSG_REASON_DIRECT_CAUSE,
+                            traceback_reason="The above exception was the direct cause of the following error:",
+                            event=_errors.EventFactory.from_exception(exception, _traceback.is_traceback_enabled(_traceback.TracebackEvent.ERROR)),
+                        ),
+                    ),
+                ),
+            )
         elif _traceback.is_traceback_enabled(_traceback.TracebackEvent.ERROR):
             # Include only a formatted traceback string in the result.
-            # The controller will combine this with `msg` to create an `_messages.ErrorDetail`.
+            # The controller will combine this with `msg` to create an `_messages.ErrorSummary`.
 
             formatted_traceback: str | None
 
@@ -1546,7 +1579,7 @@ class AnsibleModule(object):
             elif exception is _UNSET and (current_exception := t.cast(t.Optional[BaseException], sys.exc_info()[1])):
                 formatted_traceback = _traceback.maybe_extract_traceback(current_exception, _traceback.TracebackEvent.ERROR)
             else:
-                formatted_traceback = _traceback.maybe_capture_traceback(_traceback.TracebackEvent.ERROR)
+                formatted_traceback = _traceback.maybe_capture_traceback(msg, _traceback.TracebackEvent.ERROR)
 
             if formatted_traceback:
                 kwargs.update(exception=formatted_traceback)
@@ -1626,8 +1659,8 @@ class AnsibleModule(object):
 
             try:
                 self.preserved_copy(fn, backupdest)
-            except (shutil.Error, IOError) as e:
-                self.fail_json(msg='Could not make backup of %s to %s: %s' % (fn, backupdest, to_native(e)))
+            except (shutil.Error, OSError) as ex:
+                raise Exception(f'Could not make backup of {fn!r} to {backupdest!r}.') from ex
 
         return backupdest
 
@@ -1701,28 +1734,25 @@ class AnsibleModule(object):
         try:
             # Optimistically try a rename, solves some corner cases and can avoid useless work, throws exception if not atomic.
             os.rename(b_src, b_dest)
-        except (IOError, OSError) as e:
-            if e.errno not in [errno.EPERM, errno.EXDEV, errno.EACCES, errno.ETXTBSY, errno.EBUSY]:
+        except OSError as ex:
+            if ex.errno in (errno.EPERM, errno.EXDEV, errno.EACCES, errno.ETXTBSY, errno.EBUSY):
                 # only try workarounds for errno 18 (cross device), 1 (not permitted),  13 (permission denied)
                 # and 26 (text file busy) which happens on vagrant synced folders and other 'exotic' non posix file systems
-                self.fail_json(msg='Could not replace file: %s to %s: %s' % (src, dest, to_native(e)))
-            else:
                 # Use bytes here.  In the shippable CI, this fails with
                 # a UnicodeError with surrogateescape'd strings for an unknown
                 # reason (doesn't happen in a local Ubuntu16.04 VM)
                 b_dest_dir = os.path.dirname(b_dest)
                 b_suffix = os.path.basename(b_dest)
-                error_msg = None
                 tmp_dest_name = None
                 try:
                     tmp_dest_fd, tmp_dest_name = tempfile.mkstemp(prefix=b'.ansible_tmp', dir=b_dest_dir, suffix=b_suffix)
-                except (OSError, IOError) as e:
-                    error_msg = 'The destination directory (%s) is not writable by the current user. Error was: %s' % (os.path.dirname(dest), to_native(e))
-
+                except OSError as ex:
                     if unsafe_writes:
                         self._unsafe_writes(b_src, b_dest)
                     else:
-                        self.fail_json(msg=error_msg)
+                        raise Exception(
+                            f'The destination directory {os.path.dirname(dest)!r} is not writable by the current user.'
+                        ) from ex
 
                 if tmp_dest_name:
                     b_tmp_dest_name = to_bytes(tmp_dest_name, errors='surrogate_or_strict')
@@ -1751,24 +1781,27 @@ class AnsibleModule(object):
                                     if dest_stat and (tmp_stat.st_uid != dest_stat.st_uid or tmp_stat.st_gid != dest_stat.st_gid):
                                         os.chown(b_tmp_dest_name, dest_stat.st_uid, dest_stat.st_gid)
                                     os.utime(b_tmp_dest_name, times=(time.time(), time.time()))
-                            except OSError as e:
-                                if e.errno != errno.EPERM:
+                            except OSError as ex:
+                                if ex.errno != errno.EPERM:
                                     raise
                             try:
                                 os.rename(b_tmp_dest_name, b_dest)
-                            except (shutil.Error, OSError, IOError) as e:
-                                if unsafe_writes and e.errno == errno.EBUSY:
+                            except (shutil.Error, OSError) as ex:
+                                if unsafe_writes and ex.errno == errno.EBUSY:
                                     self._unsafe_writes(b_tmp_dest_name, b_dest)
                                 else:
-                                    self.fail_json(msg='Unable to make %s into to %s, failed final rename from %s: %s' %
-                                                       (src, dest, b_tmp_dest_name, to_native(e)))
-                        except (shutil.Error, OSError, IOError) as e:
+                                    raise Exception(
+                                        f'Unable to make {src!r} into to {dest!r}, failed final rename from {to_text(b_tmp_dest_name)!r}.'
+                                    ) from ex
+                        except (shutil.Error, OSError) as ex:
                             if unsafe_writes:
                                 self._unsafe_writes(b_src, b_dest)
                             else:
-                                self.fail_json(msg='Failed to replace file: %s to %s: %s' % (src, dest, to_native(e)))
+                                raise Exception(f'Failed to replace {dest!r} with {src!r}.') from ex
                     finally:
                         self.cleanup(b_tmp_dest_name)
+            else:
+                raise Exception(f'Could not replace {dest!r} with {src!r}.') from ex
 
         if creating:
             # make sure the file has the correct permissions
@@ -1795,18 +1828,11 @@ class AnsibleModule(object):
         # sadly there are some situations where we cannot ensure atomicity, but only if
         # the user insists and we get the appropriate error we update the file unsafely
         try:
-            out_dest = in_src = None
-            try:
-                out_dest = open(dest, 'wb')
-                in_src = open(src, 'rb')
-                shutil.copyfileobj(in_src, out_dest)
-            finally:  # assuring closed files in 2.4 compatible way
-                if out_dest:
-                    out_dest.close()
-                if in_src:
-                    in_src.close()
-        except (shutil.Error, OSError, IOError) as e:
-            self.fail_json(msg='Could not write data to file (%s) from (%s): %s' % (dest, src, to_native(e)))
+            with open(dest, 'wb') as out_dest:
+                with open(src, 'rb') as in_src:
+                    shutil.copyfileobj(in_src, out_dest)
+        except (shutil.Error, OSError) as ex:
+            raise Exception(f'Could not write data to file {dest!r} from {src!r}.') from ex
 
     def _clean_args(self, args):
 
@@ -2092,18 +2118,16 @@ class AnsibleModule(object):
             selector.close()
 
             rc = cmd.returncode
-        except (OSError, IOError) as e:
-            self.log("Error Executing CMD:%s Exception:%s" % (self._clean_args(args), to_native(e)))
+        except OSError as ex:
             if handle_exceptions:
-                self.fail_json(rc=e.errno, stdout=b'', stderr=b'', msg=to_native(e), cmd=self._clean_args(args))
+                self.fail_json(rc=ex.errno, stdout='', stderr='', msg="Error executing command.", cmd=self._clean_args(args), exception=ex)
             else:
-                raise e
-        except Exception as e:
-            self.log("Error Executing CMD:%s Exception:%s" % (self._clean_args(args), to_native(traceback.format_exc())))
+                raise
+        except Exception as ex:
             if handle_exceptions:
-                self.fail_json(rc=257, stdout=b'', stderr=b'', msg=to_native(e), cmd=self._clean_args(args))
+                self.fail_json(rc=257, stdout='', stderr='', msg="Error executing command.", cmd=self._clean_args(args), exception=ex)
             else:
-                raise e
+                raise
 
         if rc != 0 and check_rc:
             msg = heuristic_log_sanitize(stderr.rstrip(), self.no_log_values)
@@ -2174,7 +2198,7 @@ def __getattr__(importable_name):
         importable = repeat
     elif importable_name in {
         'PY2', 'PY3', 'b', 'binary_type', 'integer_types',
-        'iteritems', 'string_types', 'test_type'
+        'iteritems', 'string_types', 'text_type',
     }:
         import importlib
         importable = getattr(

ansible/module_utils/common/arg_spec.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 from copy import deepcopy
 
+from ansible.module_utils.datatag import deprecator_from_collection_name
 from ansible.module_utils.common.parameters import (
     _ADDITIONAL_CHECKS,
     _get_legal_inputs,
@@ -22,7 +23,6 @@ from ansible.module_utils.common.parameters import (
 
 from ansible.module_utils.common.text.converters import to_native
 from ansible.module_utils.common.warnings import deprecate, warn
-from ansible.module_utils.common import messages as _messages
 
 from ansible.module_utils.common.validation import (
     check_mutually_exclusive,
@@ -306,7 +306,7 @@ class ModuleArgumentSpecValidator(ArgumentSpecValidator):
                 msg=d['msg'],
                 version=d.get('version'),
                 date=d.get('date'),
-                deprecator=_messages.PluginInfo._from_collection_name(d.get('collection_name')),
+                deprecator=deprecator_from_collection_name(d.get('collection_name')),
             )
 
         for w in result._warnings:

ansible/module_utils/common/collections.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 
+from ansible.module_utils.common import warnings as _warnings
 from ansible.module_utils.six import binary_type, text_type
 from ansible.module_utils.six.moves.collections_abc import Hashable, Mapping, MutableMapping, Sequence  # pylint: disable=unused-import
 
@@ -102,6 +103,11 @@ def count(seq):
     code is run on Python 2.6.* where collections.Counter is not available. It should be
     deprecated and replaced when support for Python < 2.7 is dropped.
     """
+    _warnings.deprecate(
+        msg="The `ansible.module_utils.common.collections.count` function is deprecated.",
+        version="2.23",
+        help_text="Use `collections.Counter` from the Python standard library instead.",
+    )
     if not is_iterable(seq):
         raise Exception('Argument provided  is not an iterable')
     counters = dict()

ansible/module_utils/common/json.py

@@ -20,7 +20,7 @@ def __getattr__(name: str) -> object:
         #     _warnings.deprecate(
         #         msg="The `AnsibleJSONEncoder` type is deprecated.",
         #         version="2.27",
-        #         help_text="Use a profile-based encoder instead.",  # DTFIX-RELEASE: improve this help text
+        #         help_text="Use a profile-based encoder instead.",  # DTFIX-FUTURE: improve this help text
         #     )
 
         return _get_legacy_encoder()
@@ -31,7 +31,7 @@ def __getattr__(name: str) -> object:
         #     _warnings.deprecate(
         #         msg="The `AnsibleJSONDecoder` type is deprecated.",
         #         version="2.27",
-        #         help_text="Use a profile-based decoder instead.",  # DTFIX-RELEASE: improve this help text
+        #         help_text="Use a profile-based decoder instead.",  # DTFIX-FUTURE: improve this help text
         #     )
 
         return _tagless.Decoder

ansible/module_utils/common/respawn.py

@@ -10,6 +10,7 @@ import sys
 import typing as t
 
 from ansible.module_utils.common.text.converters import to_bytes
+from ansible.module_utils._internal._ansiballz import _respawn
 
 _ANSIBLE_PARENT_PATH = pathlib.Path(__file__).parents[3]
 
@@ -39,7 +40,7 @@ def respawn_module(interpreter_path) -> t.NoReturn:
         raise Exception('module has already been respawned')
 
     # FUTURE: we need a safe way to log that a respawn has occurred for forensic/debug purposes
-    payload = _create_payload()
+    payload = _respawn.create_payload()
     stdin_read, stdin_write = os.pipe()
     os.write(stdin_write, to_bytes(payload))
     os.close(stdin_write)
@@ -59,10 +60,12 @@ def probe_interpreters_for_module(interpreter_paths, module_name):
     :arg module_name: fully-qualified Python module name to probe for (for example, ``selinux``)
     """
     PYTHONPATH = os.getenv('PYTHONPATH', '')
+
     env = os.environ.copy()
     env.update({
         'PYTHONPATH': f'{_ANSIBLE_PARENT_PATH}:{PYTHONPATH}'.rstrip(': ')
     })
+
     for interpreter_path in interpreter_paths:
         if not os.path.exists(interpreter_path):
             continue
@@ -81,43 +84,3 @@ def probe_interpreters_for_module(interpreter_paths, module_name):
             continue
 
     return None
-
-
-def _create_payload():
-    # FIXME: move this into _ansiballz and skip the template
-    from ansible.module_utils import basic
-
-    module_fqn = sys.modules['__main__']._module_fqn
-    modlib_path = sys.modules['__main__']._modlib_path
-
-    respawn_code_template = """
-if __name__ == '__main__':
-    import runpy
-    import sys
-
-    json_params = {json_params!r}
-    profile = {profile!r}
-    module_fqn = {module_fqn!r}
-    modlib_path = {modlib_path!r}
-
-    sys.path.insert(0, modlib_path)
-
-    from ansible.module_utils._internal import _ansiballz
-
-    _ansiballz.run_module(
-        json_params=json_params,
-        profile=profile,
-        module_fqn=module_fqn,
-        modlib_path=modlib_path,
-        init_globals=dict(_respawned=True),
-    )
-"""
-
-    respawn_code = respawn_code_template.format(
-        json_params=basic._ANSIBLE_ARGS,
-        profile=basic._ANSIBLE_PROFILE,
-        module_fqn=module_fqn,
-        modlib_path=modlib_path,
-    )
-
-    return respawn_code

ansible/module_utils/common/text/converters.py

@@ -245,7 +245,7 @@ def jsonify(data, **kwargs):
     # deprecate(
     #     msg="The `jsonify` function is deprecated.",
     #     version="2.27",
-    #     # help_text="",  # DTFIX-RELEASE: fill in this help text
+    #     # help_text="",  # DTFIX-FUTURE: fill in this help text
     # )
 
     return json.dumps(data, cls=_common_json._get_legacy_encoder(), _decode_bytes=True, **kwargs)
@@ -257,7 +257,7 @@ def container_to_bytes(d, encoding='utf-8', errors='surrogate_or_strict'):
         Specialized for json return because this only handles, lists, tuples,
         and dict container types (the containers that the json module returns)
     """
-    # DTFIX-RELEASE: deprecate
+    # DTFIX-FUTURE: deprecate
 
     if isinstance(d, text_type):
         return to_bytes(d, encoding=encoding, errors=errors)
@@ -277,7 +277,7 @@ def container_to_text(d, encoding='utf-8', errors='surrogate_or_strict'):
     Specialized for json return because this only handles, lists, tuples,
     and dict container types (the containers that the json module returns)
     """
-    # DTFIX-RELEASE: deprecate
+    # DTFIX-FUTURE: deprecate
 
     if isinstance(d, binary_type):
         # Warning, can traceback

ansible/module_utils/common/validation.py

@@ -402,7 +402,7 @@ def check_type_list(value):
     if isinstance(value, list):
         return value
 
-    # DTFIX-RELEASE: deprecate legacy comma split functionality, eventually replace with `_check_type_list_strict`
+    # DTFIX-FUTURE: deprecate legacy comma split functionality, eventually replace with `_check_type_list_strict`
     if isinstance(value, string_types):
         return value.split(",")
     elif isinstance(value, int) or isinstance(value, float):

ansible/module_utils/common/warnings.py

@@ -6,20 +6,77 @@ from __future__ import annotations as _annotations
 
 import typing as _t
 
-from ansible.module_utils._internal import _traceback, _deprecator
-from ansible.module_utils.common import messages as _messages
+from ansible.module_utils._internal import _traceback, _deprecator, _event_utils, _messages, _errors
 from ansible.module_utils import _internal
 
 
-def warn(warning: str) -> None:
+def warn(
+    warning: str,
+    *,
+    help_text: str | None = None,
+    obj: object | None = None,
+) -> None:
     """Record a warning to be returned with the module result."""
-    # DTFIX-RELEASE: shim to controller display warning like `deprecate`
-    _global_warnings[_messages.WarningSummary(
-        details=(
-            _messages.Detail(msg=warning),
+    _skip_stackwalk = True
+
+    if _internal.is_controller:
+        _display = _internal.import_controller_module('ansible.utils.display').Display()
+        _display.warning(
+            msg=warning,
+            help_text=help_text,
+            obj=obj,
+        )
+
+        return
+
+    warning = _messages.WarningSummary(
+        event=_messages.Event(
+            msg=warning,
+            help_text=help_text,
+            formatted_traceback=_traceback.maybe_capture_traceback(warning, _traceback.TracebackEvent.WARNING),
+        ),
+    )
+
+    _global_warnings[warning] = None
+
+
+def error_as_warning(
+    msg: str | None,
+    exception: BaseException,
+    *,
+    help_text: str | None = None,
+    obj: object = None,
+) -> None:
+    """Display an exception as a warning."""
+    _skip_stackwalk = True
+
+    if _internal.is_controller:
+        _display = _internal.import_controller_module('ansible.utils.display').Display()
+        _display.error_as_warning(
+            msg=msg,
+            exception=exception,
+            help_text=help_text,
+            obj=obj,
+        )
+
+        return
+
+    event = _errors.EventFactory.from_exception(exception, _traceback.is_traceback_enabled(_traceback.TracebackEvent.WARNING))
+
+    warning = _messages.WarningSummary(
+        event=_messages.Event(
+            msg=msg,
+            help_text=help_text,
+            formatted_traceback=_traceback.maybe_capture_traceback(msg, _traceback.TracebackEvent.WARNING),
+            chain=_messages.EventChain(
+                msg_reason=_errors.MSG_REASON_DIRECT_CAUSE,
+                traceback_reason=_errors.TRACEBACK_REASON_EXCEPTION_DIRECT_WARNING,
+                event=event,
+            ),
         ),
-        formatted_traceback=_traceback.maybe_capture_traceback(_traceback.TracebackEvent.WARNING),
-    )] = None
+    )
+
+    _global_warnings[warning] = None
 
 
 def deprecate(
@@ -57,30 +114,30 @@ def deprecate(
 
         return
 
-    _global_deprecations[_messages.DeprecationSummary(
-        details=(
-            _messages.Detail(msg=msg, help_text=help_text),
+    warning = _messages.DeprecationSummary(
+        event=_messages.Event(
+            msg=msg,
+            help_text=help_text,
+            formatted_traceback=_traceback.maybe_capture_traceback(msg, _traceback.TracebackEvent.DEPRECATED),
         ),
-        formatted_traceback=_traceback.maybe_capture_traceback(_traceback.TracebackEvent.DEPRECATED),
         version=version,
         date=date,
         deprecator=deprecator,
-    )] = None
+    )
+
+    _global_deprecations[warning] = None
 
 
 def get_warning_messages() -> tuple[str, ...]:
     """Return a tuple of warning messages accumulated over this run."""
-    # DTFIX-RELEASE: add future deprecation comment
-    return tuple(item._format() for item in _global_warnings)
-
-
-_DEPRECATION_MESSAGE_KEYS = frozenset({'msg', 'date', 'version', 'collection_name'})
+    # DTFIX7: add future deprecation comment
+    return tuple(_event_utils.format_event_brief_message(item.event) for item in _global_warnings)
 
 
 def get_deprecation_messages() -> tuple[dict[str, _t.Any], ...]:
     """Return a tuple of deprecation warning messages accumulated over this run."""
-    # DTFIX-RELEASE: add future deprecation comment
-    return tuple({key: value for key, value in item._as_simple_dict().items() if key in _DEPRECATION_MESSAGE_KEYS} for item in _global_deprecations)
+    # DTFIX7: add future deprecation comment
+    return tuple(_event_utils.deprecation_as_dict(item) for item in _global_deprecations)
 
 
 def get_warnings() -> list[_messages.WarningSummary]:
@@ -94,7 +151,7 @@ def get_deprecations() -> list[_messages.DeprecationSummary]:
 
 
 _global_warnings: dict[_messages.WarningSummary, object] = {}
-"""Global, ordered, de-deplicated storage of acculumated warnings for the current module run."""
+"""Global, ordered, de-duplicated storage of accumulated warnings for the current module run."""
 
 _global_deprecations: dict[_messages.DeprecationSummary, object] = {}
-"""Global, ordered, de-deplicated storage of acculumated deprecations for the current module run."""
+"""Global, ordered, de-duplicated storage of accumulated deprecations for the current module run."""

ansible/module_utils/common/yaml.py

@@ -24,7 +24,7 @@ except ImportError:
 else:
     HAS_YAML = True
 
-# DTFIX-RELEASE: refactor this to share the implementation with the controller version
+# DTFIX-FUTURE: refactor this to share the implementation with the controller version
 #              use an abstract base class, with __init_subclass__ for representer registration, and instance methods for overridable representers
 #              then tests can be consolidated intead of having two nearly identical copies