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

ansible/utils/display.py

@@ -17,6 +17,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import dataclasses
 
 try:
@@ -51,13 +52,14 @@ from struct import unpack, pack
 from ansible import constants as C
 from ansible.constants import config
 from ansible.errors import AnsibleAssertionError, AnsiblePromptInterrupt, AnsiblePromptNoninteractive, AnsibleError
-from ansible._internal._errors import _utils
-from ansible.module_utils._internal import _ambient_context, _deprecator
+from ansible._internal._errors import _error_utils, _error_factory
+from ansible._internal import _event_formatting
+from ansible.module_utils._internal import _ambient_context, _deprecator, _messages
 from ansible.module_utils.common.text.converters import to_bytes, to_text
+from ansible.module_utils.datatag import deprecator_from_collection_name
 from ansible._internal._datatag._tags import TrustedAsTemplate
-from ansible.module_utils.common.messages import ErrorSummary, WarningSummary, DeprecationSummary, Detail, SummaryBase, PluginInfo
 from ansible.module_utils.six import text_type
-from ansible.module_utils._internal import _traceback
+from ansible.module_utils._internal import _traceback, _errors
 from ansible.utils.color import stringc
 from ansible.utils.multiprocessing import context as multiprocessing_context
 from ansible.utils.singleton import Singleton
@@ -90,6 +92,9 @@ def _is_controller_traceback_enabled(event: _traceback.TracebackEvent) -> bool:
     if 'never' in flag_values:
         return False
 
+    if _traceback.TracebackEvent.DEPRECATED_VALUE.name.lower() in flag_values:
+        flag_values.add(_traceback.TracebackEvent.DEPRECATED.name.lower())  # DEPRECATED_VALUE implies DEPRECATED
+
     return event.name.lower() in flag_values
 
 
@@ -212,10 +217,22 @@ b_COW_PATHS = (
 
 
 def _synchronize_textiowrapper(tio: t.TextIO, lock: threading.RLock):
-    # Ensure that a background thread can't hold the internal buffer lock on a file object
-    # during a fork, which causes forked children to hang. We're using display's existing lock for
-    # convenience (and entering the lock before a fork).
+    """
+    This decorator ensures that the supplied RLock is held before invoking the wrapped methods.
+    It is intended to prevent background threads from holding the Python stdout/stderr buffer lock on a file object during a fork.
+    Since background threads are abandoned in child forks, locks they hold are orphaned in a locked state.
+    Attempts to acquire an orphaned lock in this state will block forever, effectively hanging the child process on stdout/stderr writes.
+    The shared lock is permanently disabled immediately after a fork.
+    This prevents hangs in early post-fork code (e.g., stdio writes from pydevd, coverage, etc.) before user code has resumed and released the lock.
+    """
+
     def _wrap_with_lock(f, lock):
+        def disable_lock():
+            nonlocal lock
+            lock = contextlib.nullcontext()
+
+        os.register_at_fork(after_in_child=disable_lock)
+
         @wraps(f)
         def locking_wrapper(*args, **kwargs):
             with lock:
@@ -433,6 +450,10 @@ class Display(metaclass=Singleton):
         if not isinstance(msg, str):
             raise TypeError(f'Display message must be str, not: {msg.__class__.__name__}')
 
+        # Convert Windows newlines to Unix newlines.
+        # Some environments, such as Azure Pipelines, render `\r` as an additional `\n`.
+        msg = msg.replace('\r\n', '\n')
+
         nocolor = msg
 
         if not log_only:
@@ -466,7 +487,7 @@ class Display(metaclass=Singleton):
             # final flush at shutdown.
             # try:
             #     fileobj.flush()
-            # except IOError as e:
+            # except OSError as e:
             #     # Ignore EPIPE in case fileobj has been prematurely closed, eg.
             #     # when piping to "head -n1"
             #     if e.errno != errno.EPIPE:
@@ -568,7 +589,7 @@ class Display(metaclass=Singleton):
             version=version,
             removed=removed,
             date=date,
-            deprecator=PluginInfo._from_collection_name(collection_name),
+            deprecator=deprecator_from_collection_name(collection_name),
         )
 
         if removed:
@@ -585,30 +606,28 @@ class Display(metaclass=Singleton):
         version: str | None,
         removed: bool = False,
         date: str | None,
-        deprecator: PluginInfo | None,
+        deprecator: _messages.PluginInfo | None,
     ) -> str:
         """Internal use only. Return a deprecation message and help text for display."""
-        # DTFIX-RELEASE: the logic for omitting date/version doesn't apply to the payload, so it shows up in vars in some cases when it should not
+        # DTFIX-FUTURE: the logic for omitting date/version doesn't apply to the payload, so it shows up in vars in some cases when it should not
 
         if removed:
             removal_fragment = 'This feature was removed'
         else:
             removal_fragment = 'This feature will be removed'
 
-        if not deprecator or deprecator.type == _deprecator.INDETERMINATE_DEPRECATOR.type:
-            collection = None
-            plugin_fragment = ''
-        elif deprecator.type == _deprecator.PluginInfo._COLLECTION_ONLY_TYPE:
-            collection = deprecator.resolved_name
+        if not deprecator or not deprecator.type:
+            # indeterminate has no resolved_name or type
+            # collections have a resolved_name but no type
+            collection = deprecator.resolved_name if deprecator else None
             plugin_fragment = ''
         else:
             parts = deprecator.resolved_name.split('.')
             plugin_name = parts[-1]
-            # DTFIX-RELEASE: normalize 'modules' -> 'module' before storing it so we can eliminate the normalization here
-            plugin_type = "module" if deprecator.type in ("module", "modules") else f'{deprecator.type} plugin'
+            plugin_type_name = str(deprecator.type) if deprecator.type is _messages.PluginType.MODULE else f'{deprecator.type} plugin'
 
             collection = '.'.join(parts[:2]) if len(parts) > 2 else None
-            plugin_fragment = f'{plugin_type} {plugin_name!r}'
+            plugin_fragment = f'{plugin_type_name} {plugin_name!r}'
 
         if collection and plugin_fragment:
             plugin_fragment += ' in'
@@ -668,7 +687,7 @@ class Display(metaclass=Singleton):
         date: str | None = None,
         collection_name: str | None = None,
         *,
-        deprecator: PluginInfo | None = None,
+        deprecator: _messages.PluginInfo | None = None,
         help_text: str | None = None,
         obj: t.Any = None,
     ) -> None:
@@ -678,8 +697,8 @@ class Display(metaclass=Singleton):
         Specify `version` or `date`, but not both.
         If `date` is a string, it must be in the form `YYYY-MM-DD`.
         """
-        # DTFIX-RELEASE: are there any deprecation calls where the feature is switching from enabled to disabled, rather than being removed entirely?
-        # DTFIX-RELEASE: are there deprecated features which should going through deferred deprecation instead?
+        # DTFIX3: are there any deprecation calls where the feature is switching from enabled to disabled, rather than being removed entirely?
+        # DTFIX3: are there deprecated features which should going through deferred deprecation instead?
 
         _skip_stackwalk = True
 
@@ -691,6 +710,7 @@ class Display(metaclass=Singleton):
             help_text=help_text,
             obj=obj,
             deprecator=_deprecator.get_best_deprecator(deprecator=deprecator, collection_name=collection_name),
+            formatted_traceback=_traceback.maybe_capture_traceback(msg, _traceback.TracebackEvent.DEPRECATED),
         )
 
     def _deprecated_with_plugin_info(
@@ -702,7 +722,8 @@ class Display(metaclass=Singleton):
         date: str | None,
         help_text: str | None,
         obj: t.Any,
-        deprecator: PluginInfo | None,
+        deprecator: _messages.PluginInfo | None,
+        formatted_traceback: str | None = None,
     ) -> None:
         """
         This is the internal pre-proxy half of the `deprecated` implementation.
@@ -721,23 +742,21 @@ class Display(metaclass=Singleton):
 
             raise AnsibleError(formatted_msg)
 
-        if source_context := _utils.SourceContext.from_value(obj):
+        if source_context := _error_utils.SourceContext.from_value(obj):
             formatted_source_context = str(source_context)
         else:
             formatted_source_context = None
 
-        deprecation = DeprecationSummary(
-            details=(
-                Detail(
-                    msg=msg,
-                    formatted_source_context=formatted_source_context,
-                    help_text=help_text,
-                ),
+        deprecation = _messages.DeprecationSummary(
+            event=_messages.Event(
+                msg=msg,
+                formatted_source_context=formatted_source_context,
+                help_text=help_text,
+                formatted_traceback=formatted_traceback,
             ),
             version=version,
             date=date,
             deprecator=deprecator,
-            formatted_traceback=_traceback.maybe_capture_traceback(_traceback.TracebackEvent.DEPRECATED),
         )
 
         if warning_ctx := _DeferredWarningContext.current(optional=True):
@@ -747,7 +766,7 @@ class Display(metaclass=Singleton):
         self._deprecated(deprecation)
 
     @_proxy
-    def _deprecated(self, warning: DeprecationSummary) -> None:
+    def _deprecated(self, warning: _messages.DeprecationSummary) -> None:
         """Internal implementation detail, use `deprecated` instead."""
 
         # This is the post-proxy half of the `deprecated` implementation.
@@ -758,10 +777,10 @@ class Display(metaclass=Singleton):
 
         self.warning('Deprecation warnings can be disabled by setting `deprecation_warnings=False` in ansible.cfg.')
 
-        msg = format_message(warning)
+        msg = _format_message(warning, _traceback.is_traceback_enabled(_traceback.TracebackEvent.DEPRECATED))
         msg = f'[DEPRECATION WARNING]: {msg}'
 
-        # DTFIX-RELEASE: what should we do with wrap_message?
+        # DTFIX3: what should we do with wrap_message?
         msg = self._wrap_message(msg=msg, wrap_text=True)
 
         if self._deduplicate(msg, self._deprecations):
@@ -778,47 +797,46 @@ class Display(metaclass=Singleton):
         obj: t.Any = None
     ) -> None:
         """Display a warning message."""
+        _skip_stackwalk = True
 
         # This is the pre-proxy half of the `warning` implementation.
         # Any logic that must occur on workers needs to be implemented here.
 
-        if source_context := _utils.SourceContext.from_value(obj):
+        if source_context := _error_utils.SourceContext.from_value(obj):
             formatted_source_context = str(source_context)
         else:
             formatted_source_context = None
 
-        warning = WarningSummary(
-            details=(
-                Detail(
-                    msg=msg,
-                    help_text=help_text,
-                    formatted_source_context=formatted_source_context,
-                ),
+        warning = _messages.WarningSummary(
+            event=_messages.Event(
+                msg=msg,
+                help_text=help_text,
+                formatted_source_context=formatted_source_context,
+                formatted_traceback=_traceback.maybe_capture_traceback(msg, _traceback.TracebackEvent.WARNING),
             ),
-            formatted_traceback=_traceback.maybe_capture_traceback(_traceback.TracebackEvent.WARNING),
         )
 
         if warning_ctx := _DeferredWarningContext.current(optional=True):
             warning_ctx.capture(warning)
-            # DTFIX-RELEASE: what to do about propagating wrap_text?
+            # DTFIX3: what to do about propagating wrap_text?
             return
 
         self._warning(warning, wrap_text=not formatted)
 
     @_proxy
-    def _warning(self, warning: WarningSummary, wrap_text: bool) -> None:
+    def _warning(self, warning: _messages.WarningSummary, wrap_text: bool) -> None:
         """Internal implementation detail, use `warning` instead."""
 
         # This is the post-proxy half of the `warning` implementation.
         # Any logic that must occur in the primary controller process needs to be implemented here.
 
-        msg = format_message(warning)
+        msg = _format_message(warning, _traceback.is_traceback_enabled(_traceback.TracebackEvent.WARNING))
         msg = f"[WARNING]: {msg}"
 
         if self._deduplicate(msg, self._warns):
             return
 
-        # DTFIX-RELEASE: what should we do with wrap_message?
+        # DTFIX3: what should we do with wrap_message?
         msg = self._wrap_message(msg=msg, wrap_text=wrap_text)
 
         self.display(msg, color=C.config.get_config_value('COLOR_WARN'), stderr=True, caplevel=-2)
@@ -870,17 +888,39 @@ class Display(metaclass=Singleton):
         (out, err) = cmd.communicate()
         self.display(u"%s\n" % to_text(out), color=color)
 
-    def error_as_warning(self, msg: str | None, exception: BaseException) -> None:
+    def error_as_warning(
+        self,
+        msg: str | None,
+        exception: BaseException,
+        *,
+        help_text: str | None = None,
+        obj: t.Any = None,
+    ) -> None:
         """Display an exception as a warning."""
+        _skip_stackwalk = True
 
-        error = _utils._create_error_summary(exception, _traceback.TracebackEvent.WARNING)
+        event = _error_factory.ControllerEventFactory.from_exception(exception, _traceback.is_traceback_enabled(_traceback.TracebackEvent.WARNING))
 
         if msg:
-            error = dataclasses.replace(error, details=(Detail(msg=msg),) + error.details)
+            if source_context := _error_utils.SourceContext.from_value(obj):
+                formatted_source_context = str(source_context)
+            else:
+                formatted_source_context = None
 
-        warning = WarningSummary(
-            details=error.details,
-            formatted_traceback=error.formatted_traceback,
+            event = _messages.Event(
+                msg=msg,
+                help_text=help_text,
+                formatted_source_context=formatted_source_context,
+                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,
+                ),
+            )
+
+        warning = _messages.WarningSummary(
+            event=event,
         )
 
         if warning_ctx := _DeferredWarningContext.current(optional=True):
@@ -891,32 +931,41 @@ class Display(metaclass=Singleton):
 
     def error(self, msg: str | BaseException, wrap_text: bool = True, stderr: bool = True) -> None:
         """Display an error message."""
+        _skip_stackwalk = True
 
         # This is the pre-proxy half of the `error` implementation.
         # Any logic that must occur on workers needs to be implemented here.
 
         if isinstance(msg, BaseException):
-            error = _utils._create_error_summary(msg, _traceback.TracebackEvent.ERROR)
+            event = _error_factory.ControllerEventFactory.from_exception(msg, _traceback.is_traceback_enabled(_traceback.TracebackEvent.ERROR))
+
             wrap_text = False
         else:
-            error = ErrorSummary(details=(Detail(msg=msg),), formatted_traceback=_traceback.maybe_capture_traceback(_traceback.TracebackEvent.ERROR))
+            event = _messages.Event(
+                msg=msg,
+                formatted_traceback=_traceback.maybe_capture_traceback(msg, _traceback.TracebackEvent.ERROR),
+            )
+
+        error = _messages.ErrorSummary(
+            event=event,
+        )
 
         self._error(error, wrap_text=wrap_text, stderr=stderr)
 
     @_proxy
-    def _error(self, error: ErrorSummary, wrap_text: bool, stderr: bool) -> None:
+    def _error(self, error: _messages.ErrorSummary, wrap_text: bool, stderr: bool) -> None:
         """Internal implementation detail, use `error` instead."""
 
         # This is the post-proxy half of the `error` implementation.
         # Any logic that must occur in the primary controller process needs to be implemented here.
 
-        msg = format_message(error)
+        msg = _format_message(error, _traceback.is_traceback_enabled(_traceback.TracebackEvent.ERROR))
         msg = f'[ERROR]: {msg}'
 
         if self._deduplicate(msg, self._errors):
             return
 
-        # DTFIX-RELEASE: what should we do with wrap_message?
+        # DTFIX3: what should we do with wrap_message?
         msg = self._wrap_message(msg=msg, wrap_text=wrap_text)
 
         self.display(msg, color=C.config.get_config_value('COLOR_ERROR'), stderr=stderr, caplevel=-1)
@@ -1146,9 +1195,9 @@ class _DeferredWarningContext(_ambient_context.AmbientContextBase):
 
     def __init__(self, *, variables: dict[str, object]) -> None:
         self._variables = variables  # DTFIX-FUTURE: move this to an AmbientContext-derived TaskContext (once it exists)
-        self._deprecation_warnings: list[DeprecationSummary] = []
-        self._warnings: list[WarningSummary] = []
-        self._seen: set[WarningSummary] = set()
+        self._deprecation_warnings: list[_messages.DeprecationSummary] = []
+        self._warnings: list[_messages.WarningSummary] = []
+        self._seen: set[_messages.WarningSummary] = set()
 
     @classmethod
     def deprecation_warnings_enabled(cls) -> bool:
@@ -1161,82 +1210,29 @@ class _DeferredWarningContext(_ambient_context.AmbientContextBase):
 
         return C.config.get_config_value('DEPRECATION_WARNINGS', variables=variables)
 
-    def capture(self, warning: WarningSummary) -> None:
+    def capture(self, warning: _messages.WarningSummary) -> None:
         """Add the warning/deprecation to the context if it has not already been seen by this context."""
         if warning in self._seen:
             return
 
         self._seen.add(warning)
 
-        if isinstance(warning, DeprecationSummary):
+        if isinstance(warning, _messages.DeprecationSummary):
             self._deprecation_warnings.append(warning)
         else:
             self._warnings.append(warning)
 
-    def get_warnings(self) -> list[WarningSummary]:
+    def get_warnings(self) -> list[_messages.WarningSummary]:
         """Return a list of the captured non-deprecation warnings."""
         # DTFIX-FUTURE: return a read-only list proxy instead
         return self._warnings
 
-    def get_deprecation_warnings(self) -> list[DeprecationSummary]:
+    def get_deprecation_warnings(self) -> list[_messages.DeprecationSummary]:
         """Return a list of the captured deprecation warnings."""
         # DTFIX-FUTURE: return a read-only list proxy instead
         return self._deprecation_warnings
 
 
-def _format_error_details(details: t.Sequence[Detail], formatted_tb: str | None = None) -> str:
-    details = _utils._collapse_error_details(details)
-
-    message_lines: list[str] = []
-
-    if len(details) > 1:
-        message_lines.append(_utils._dedupe_and_concat_message_chain([md.msg for md in details]))
-        message_lines.append('')
-
-    for idx, edc in enumerate(details):
-        if idx:
-            message_lines.extend((
-                '',
-                '<<< caused by >>>',
-                '',
-            ))
-
-        message_lines.extend(_get_message_lines(edc.msg, edc.help_text, edc.formatted_source_context))
-
-    message_lines = [f'{line}\n' for line in message_lines]
-
-    if formatted_tb:
-        message_lines.append('\n')
-        message_lines.append(formatted_tb)
-
-    msg = "".join(message_lines).strip()
-
-    if '\n' in msg:
-        msg += '\n\n'
-    else:
-        msg += '\n'
-
-    return msg
-
-
-def _get_message_lines(message: str, help_text: str | None, formatted_source_context: str | None) -> list[str]:
-    """Return a list of error/warning message lines constructed from the given message, help text and source context."""
-
-    if help_text and not formatted_source_context and '\n' not in message and '\n' not in help_text:
-        return [f'{message} {help_text}']  # prefer a single-line message with help text when there is no source context
-
-    message_lines = [message]
-
-    if formatted_source_context:
-        message_lines.append(formatted_source_context)
-
-    if help_text:
-        message_lines.append('')
-        message_lines.append(help_text)
-
-    return message_lines
-
-
 def _join_sentences(first: str | None, second: str | None) -> str:
     """Join two sentences together."""
     first = (first or '').strip()
@@ -1257,33 +1253,23 @@ def _join_sentences(first: str | None, second: str | None) -> str:
     return ' '.join((first, second))
 
 
-def format_message(summary: SummaryBase) -> str:
-    details: c.Sequence[Detail] = summary.details
-
-    if isinstance(summary, DeprecationSummary) and details:
-        # augment the first detail element for deprecations to include additional diagnostic info and help text
-        detail_list = list(details)
-        detail = detail_list[0]
-
-        deprecation_msg = _display._get_deprecation_message_with_plugin_info(
-            msg=detail.msg,
+def _format_message(summary: _messages.SummaryBase, include_traceback: bool) -> str:
+    if isinstance(summary, _messages.DeprecationSummary):
+        deprecation_message = _display._get_deprecation_message_with_plugin_info(
+            msg=summary.event.msg,
             version=summary.version,
             date=summary.date,
             deprecator=summary.deprecator,
         )
 
-        detail_list[0] = dataclasses.replace(
-            detail,
-            msg=deprecation_msg,
-            help_text=detail.help_text,
-        )
-
-        details = detail_list
+        event = dataclasses.replace(summary.event, msg=deprecation_message)
+    else:
+        event = summary.event
 
-    return _format_error_details(details, summary.formatted_traceback)
+    return _event_formatting.format_event(event, include_traceback)
 
 
-def _report_config_warnings(deprecator: PluginInfo) -> None:
+def _report_config_warnings(deprecator: _messages.PluginInfo) -> None:
     """Called by config to report warnings/deprecations collected during a config parse."""
     while config._errors:
         msg, exception = config._errors.pop()

ansible/utils/galaxy.py

@@ -57,8 +57,8 @@ def scm_archive_resource(src, scm='git', name=None, version='HEAD', keep_scm_met
 
     try:
         scm_path = get_bin_path(scm)
-    except (ValueError, OSError, IOError):
-        raise AnsibleError("could not find/use %s, it is required to continue with installing %s" % (scm, src))
+    except (ValueError, OSError) as ex:
+        raise AnsibleError(f"Could not find/use {scm!r}, it is required to continue with installing {src!r}.") from ex
 
     tempdir = tempfile.mkdtemp(dir=C.DEFAULT_LOCAL_TMP)
     clone_cmd = [scm_path, 'clone']

ansible/utils/hashing.py

@@ -48,18 +48,16 @@ def secure_hash(filename, hash_func=sha1):
     digest = hash_func()
     blocksize = 64 * 1024
     try:
-        infile = open(to_bytes(filename, errors='surrogate_or_strict'), 'rb')
-        block = infile.read(blocksize)
-        while block:
-            digest.update(block)
+        with open(filename, 'rb') as infile:
             block = infile.read(blocksize)
-        infile.close()
-    except IOError as e:
-        raise AnsibleError("error while accessing the file %s, error was: %s" % (filename, e))
+            while block:
+                digest.update(block)
+                block = infile.read(blocksize)
+    except OSError as ex:
+        raise AnsibleError(f"Error while accessing the file {filename!r}.") from ex
     return digest.hexdigest()
 
 
-# The checksum algorithm must match with the algorithm in ShellModule.checksum() method
 checksum = secure_hash
 checksum_s = secure_hash_s
 

ansible/utils/listify.py

@@ -26,10 +26,12 @@ __all__ = ['listify_lookup_plugin_terms']
 
 
 def listify_lookup_plugin_terms(terms, templar=None, fail_on_undefined=True):
-    display.deprecated(
-        msg='"listify_lookup_plugin_terms" is obsolete and in most cases unnecessary',
-        version='2.23',
-    )
+    # deprecated: description="Calling listify_lookup_plugin_terms function is not necessary; the function should be deprecated." core_version="2.23"
+    # display.deprecated(
+    #     msg='The "listify_lookup_plugin_terms" function is not required for lookup terms to be templated.',
+    #     version='2.27',
+    #     help_text='If needed, implement custom `strip` or list-wrapping in the caller.',
+    # )
 
     if isinstance(terms, str):
         terms = terms.strip()

ansible/utils/path.py

@@ -19,9 +19,8 @@ from __future__ import annotations
 import os
 import shutil
 
-from errno import EEXIST
 from ansible.errors import AnsibleError
-from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
+from ansible.module_utils.common.text.converters import to_bytes, to_text
 
 
 __all__ = ['unfrackpath', 'makedirs_safe']
@@ -84,12 +83,11 @@ def makedirs_safe(path, mode=None):
     if not os.path.exists(b_rpath):
         try:
             if mode:
-                os.makedirs(b_rpath, mode)
+                os.makedirs(b_rpath, mode, exist_ok=True)
             else:
-                os.makedirs(b_rpath)
-        except OSError as e:
-            if e.errno != EEXIST:
-                raise AnsibleError("Unable to create local directories(%s): %s" % (to_native(rpath), to_native(e)))
+                os.makedirs(b_rpath, exist_ok=True)
+        except OSError as ex:
+            raise AnsibleError(f"Unable to create local directories {rpath!r}.") from ex
 
 
 def basedir(source):

ansible/utils/py3compat.py

@@ -19,8 +19,9 @@ def __getattr__(name):
         raise AttributeError(name)
 
     display.deprecated(
-        msg='ansible.utils.py3compat.environ is deprecated in favor of os.environ.',
+        msg='`ansible.utils.py3compat.environ` is deprecated.',
         version='2.20',
+        help_text='Use `os.environ` from the Python standard library instead.',
     )
 
     return os.environ

ansible/utils/ssh_functions.py

@@ -57,8 +57,9 @@ def set_default_transport():
     # deal with 'smart' connection .. one time ..
     if C.DEFAULT_TRANSPORT == 'smart':
         display.deprecated(
-            msg="The 'smart' option for connections is deprecated. Set the connection plugin directly instead.",
-            version='2.20',
+            msg="The `smart` option for connections is deprecated.",
+            version="2.20",
+            help_text="Set the connection plugin directly instead.",
         )
 
         # see if SSH can support ControlPersist if not use paramiko

ansible/utils/unsafe_proxy.py

@@ -2,7 +2,7 @@
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 # deprecated: description="deprecate unsafe_proxy module" core_version="2.23"
-# DTFIX-RELEASE: add full unit test coverage
+# DTFIX5: add full unit test coverage
 from __future__ import annotations
 
 from collections.abc import Mapping, Set

ansible/vars/hostvars.py

@@ -113,5 +113,5 @@ class HostVarsVars(c.Mapping):
         return self
 
 
-# DTFIX-RELEASE: is there a better way to add this to the ignorable types in the module_utils code
+# DTFIX-FUTURE: is there a better way to add this to the ignorable types in the module_utils code
 _datatag._untaggable_types.update({HostVars, HostVarsVars})

ansible/vars/plugins.py

@@ -35,10 +35,10 @@ def get_plugin_vars(loader, plugin, path, entities):
         if hasattr(plugin, 'get_host_vars') or hasattr(plugin, 'get_group_vars'):
             display.deprecated(
                 msg=f"The vars plugin {plugin.ansible_name} from {plugin._original_path} is relying "
-                    "on the deprecated entrypoints 'get_host_vars' and 'get_group_vars'. "
-                    "This plugin should be updated to inherit from BaseVarsPlugin and define "
-                    "a 'get_vars' method as the main entrypoint instead.",
+                    "on the deprecated entrypoints `get_host_vars` and `get_group_vars`.",
                 version="2.20",
+                help_text="This plugin should be updated to inherit from `BaseVarsPlugin` and define "
+                          "a `get_vars` method as the main entrypoint instead.",
             )
         try:
             for entity in entities:

{ansible_core-2.19.0b4.dist-info → ansible_core-2.19.0b6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ansible-core
-Version: 2.19.0b4
+Version: 2.19.0b6
 Summary: Radically simple IT automation
 Author: Ansible Project
 Project-URL: Homepage, https://ansible.com/