ansible-core 2.19.0b1__py3-none-any.whl → 2.19.0b3__py3-none-any.whl

ansible/module_utils/basic.py

@@ -53,9 +53,7 @@ try:
 except ImportError:
     HAS_SYSLOG = False
 
-# deprecated: description='types.EllipsisType is available in Python 3.10+' python_version='3.9'
-if t.TYPE_CHECKING:
-    from builtins import ellipsis
+_UNSET = t.cast(t.Any, object())
 
 try:
     from systemd import journal, daemon as systemd_daemon
@@ -77,7 +75,7 @@ except ImportError:
 # Python2 & 3 way to get NoneType
 NoneType = type(None)
 
-from ._internal import _traceback, _errors, _debugging
+from ._internal import _traceback, _errors, _debugging, _deprecator
 
 from .common.text.converters import (
     to_native,
@@ -341,7 +339,7 @@ def _load_params():
     except Exception as ex:
         raise Exception("Failed to decode JSON module parameters.") from ex
 
-    if (ansible_module_args := params.get('ANSIBLE_MODULE_ARGS', ...)) is ...:
+    if (ansible_module_args := params.get('ANSIBLE_MODULE_ARGS', _UNSET)) is _UNSET:
         raise Exception("ANSIBLE_MODULE_ARGS not provided.")
 
     global _PARSED_MODULE_ARGS
@@ -511,16 +509,31 @@ class AnsibleModule(object):
         warn(warning)
         self.log('[WARNING] %s' % warning)
 
-    def deprecate(self, msg, version=None, date=None, collection_name=None):
-        if version is not None and date is not None:
-            raise AssertionError("implementation error -- version and date must not both be set")
-        deprecate(msg, version=version, date=date)
-        # For compatibility, we accept that neither version nor date is set,
-        # and treat that the same as if version would not have been set
-        if date is not None:
-            self.log('[DEPRECATION WARNING] %s %s' % (msg, date))
-        else:
-            self.log('[DEPRECATION WARNING] %s %s' % (msg, version))
+    def deprecate(
+        self,
+        msg: str,
+        version: str | None = None,
+        date: str | None = None,
+        collection_name: str | None = None,
+        *,
+        deprecator: _messages.PluginInfo | None = None,
+        help_text: str | None = None,
+    ) -> None:
+        """
+        Record a deprecation warning to be returned with the module result.
+        Most callers do not need to provide `collection_name` or `deprecator` -- but provide only one if needed.
+        Specify `version` or `date`, but not both.
+        If `date` is a string, it must be in the form `YYYY-MM-DD`.
+        """
+        _skip_stackwalk = True
+
+        deprecate(  # pylint: disable=ansible-deprecated-date-not-permitted,ansible-deprecated-unnecessary-collection-name
+            msg=msg,
+            version=version,
+            date=date,
+            deprecator=_deprecator.get_best_deprecator(deprecator=deprecator, collection_name=collection_name),
+            help_text=help_text,
+        )
 
     def load_file_common_arguments(self, params, path=None):
         """
@@ -1406,6 +1419,7 @@ class AnsibleModule(object):
             self.cleanup(path)
 
     def _return_formatted(self, kwargs):
+        _skip_stackwalk = True
 
         self.add_path_info(kwargs)
 
@@ -1413,6 +1427,13 @@ class AnsibleModule(object):
             kwargs['invocation'] = {'module_args': self.params}
 
         if 'warnings' in kwargs:
+            self.deprecate(  # pylint: disable=ansible-deprecated-unnecessary-collection-name
+                msg='Passing `warnings` to `exit_json` or `fail_json` is deprecated.',
+                version='2.23',
+                help_text='Use `AnsibleModule.warn` instead.',
+                deprecator=_deprecator.ANSIBLE_CORE_DEPRECATOR,
+            )
+
             if isinstance(kwargs['warnings'], list):
                 for w in kwargs['warnings']:
                     self.warn(w)
@@ -1424,17 +1445,38 @@ class AnsibleModule(object):
             kwargs['warnings'] = warnings
 
         if 'deprecations' in kwargs:
+            self.deprecate(  # pylint: disable=ansible-deprecated-unnecessary-collection-name
+                msg='Passing `deprecations` to `exit_json` or `fail_json` is deprecated.',
+                version='2.23',
+                help_text='Use `AnsibleModule.deprecate` instead.',
+                deprecator=_deprecator.ANSIBLE_CORE_DEPRECATOR,
+            )
+
             if isinstance(kwargs['deprecations'], list):
                 for d in kwargs['deprecations']:
-                    if isinstance(d, SEQUENCETYPE) and len(d) == 2:
-                        self.deprecate(d[0], version=d[1])
+                    if isinstance(d, (KeysView, Sequence)) and len(d) == 2:
+                        self.deprecate(  # pylint: disable=ansible-deprecated-unnecessary-collection-name,ansible-invalid-deprecated-version
+                            msg=d[0],
+                            version=d[1],
+                            deprecator=_deprecator.get_best_deprecator(),
+                        )
                     elif isinstance(d, Mapping):
-                        self.deprecate(d['msg'], version=d.get('version'), date=d.get('date'),
-                                       collection_name=d.get('collection_name'))
+                        self.deprecate(  # pylint: disable=ansible-deprecated-date-not-permitted,ansible-deprecated-unnecessary-collection-name
+                            msg=d['msg'],
+                            version=d.get('version'),
+                            date=d.get('date'),
+                            deprecator=_deprecator.get_best_deprecator(collection_name=d.get('collection_name')),
+                        )
                     else:
-                        self.deprecate(d)  # pylint: disable=ansible-deprecated-no-version
+                        self.deprecate(  # pylint: disable=ansible-deprecated-unnecessary-collection-name,ansible-deprecated-no-version
+                            msg=d,
+                            deprecator=_deprecator.get_best_deprecator(),
+                        )
             else:
-                self.deprecate(kwargs['deprecations'])  # pylint: disable=ansible-deprecated-no-version
+                self.deprecate(  # pylint: disable=ansible-deprecated-unnecessary-collection-name,ansible-deprecated-no-version
+                    msg=kwargs['deprecations'],
+                    deprecator=_deprecator.get_best_deprecator(),
+                )
 
         deprecations = get_deprecations()
         if deprecations:
@@ -1454,12 +1496,13 @@ class AnsibleModule(object):
 
     def exit_json(self, **kwargs) -> t.NoReturn:
         """ return from the module, without error """
+        _skip_stackwalk = True
 
         self.do_cleanup_files()
         self._return_formatted(kwargs)
         sys.exit(0)
 
-    def fail_json(self, msg: str, *, exception: BaseException | str | ellipsis | None = ..., **kwargs) -> t.NoReturn:
+    def fail_json(self, msg: str, *, exception: BaseException | str | None = _UNSET, **kwargs) -> t.NoReturn:
         """
         Return from the module with an error message and optional exception/traceback detail.
         A traceback will only be included in the result if error traceback capturing has been enabled.
@@ -1475,6 +1518,8 @@ class AnsibleModule(object):
         When `exception` is not specified, a formatted traceback will be retrieved from the current exception.
         If no exception is pending, the current call stack will be used instead.
         """
+        _skip_stackwalk = True
+
         msg = str(msg)  # coerce to str instead of raising an error due to an invalid type
 
         kwargs.update(
@@ -1498,7 +1543,7 @@ class AnsibleModule(object):
 
             if isinstance(exception, str):
                 formatted_traceback = exception
-            elif exception is ... and (current_exception := t.cast(t.Optional[BaseException], sys.exc_info()[1])):
+            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)

ansible/module_utils/common/arg_spec.py

@@ -22,6 +22,7 @@ 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,
@@ -300,9 +301,13 @@ class ModuleArgumentSpecValidator(ArgumentSpecValidator):
         result = super(ModuleArgumentSpecValidator, self).validate(parameters)
 
         for d in result._deprecations:
-            deprecate(d['msg'],
-                      version=d.get('version'), date=d.get('date'),
-                      collection_name=d.get('collection_name'))
+            # DTFIX-FUTURE: pass an actual deprecator instead of one derived from collection_name
+            deprecate(  # pylint: disable=ansible-deprecated-date-not-permitted,ansible-deprecated-unnecessary-collection-name
+                msg=d['msg'],
+                version=d.get('version'),
+                date=d.get('date'),
+                deprecator=_messages.PluginInfo._from_collection_name(d.get('collection_name')),
+            )
 
         for w in result._warnings:
             warn('Both option {option} and its alias {alias} are set.'.format(option=w['option'], alias=w['alias']))

ansible/module_utils/common/messages.py

@@ -13,7 +13,7 @@ import dataclasses as _dataclasses
 # deprecated: description='typing.Self exists in Python 3.11+' python_version='3.10'
 from ..compat import typing as _t
 
-from ansible.module_utils._internal import _datatag
+from ansible.module_utils._internal import _datatag, _validation
 
 if _sys.version_info >= (3, 10):
     # Using slots for reduced memory usage and improved performance.
@@ -27,13 +27,27 @@ else:
 class PluginInfo(_datatag.AnsibleSerializableDataclass):
     """Information about a loaded plugin."""
 
-    requested_name: str
-    """The plugin name as requested, before resolving, which may be partially or fully qualified."""
     resolved_name: str
     """The resolved canonical plugin name; always fully-qualified for collection plugins."""
     type: str
     """The plugin type."""
 
+    _COLLECTION_ONLY_TYPE: _t.ClassVar[str] = 'collection'
+    """This is not a real plugin type. It's a placeholder for use by a `PluginInfo` instance which references a collection without a plugin."""
+
+    @classmethod
+    def _from_collection_name(cls, collection_name: str | None) -> _t.Self | None:
+        """Returns an instance with the special `collection` type to refer to a non-plugin or ambiguous caller within a collection."""
+        if not collection_name:
+            return None
+
+        _validation.validate_collection_name(collection_name)
+
+        return cls(
+            resolved_name=collection_name,
+            type=cls._COLLECTION_ONLY_TYPE,
+        )
+
 
 @_dataclasses.dataclass(**_dataclass_kwargs)
 class Detail(_datatag.AnsibleSerializableDataclass):
@@ -75,34 +89,37 @@ class WarningSummary(SummaryBase):
 class DeprecationSummary(WarningSummary):
     """Deprecation summary with details (possibly derived from an exception __cause__ chain) and an optional traceback."""
 
-    version: _t.Optional[str] = None
-    date: _t.Optional[str] = None
-    plugin: _t.Optional[PluginInfo] = None
-
-    @property
-    def collection_name(self) -> _t.Optional[str]:
-        if not self.plugin:
-            return None
-
-        parts = self.plugin.resolved_name.split('.')
-
-        if len(parts) < 2:
-            return None
-
-        collection_name = '.'.join(parts[:2])
+    deprecator: _t.Optional[PluginInfo] = None
+    """
+    The identifier for the content which is being deprecated.
+    """
 
-        # deprecated: description='enable the deprecation message for collection_name' core_version='2.23'
-        # from ansible.module_utils.datatag import deprecate_value
-        # collection_name = deprecate_value(collection_name, 'The `collection_name` property is deprecated.', removal_version='2.27')
+    date: _t.Optional[str] = None
+    """
+    The date after which a new release of `deprecator` will remove the feature described by `msg`.
+    Ignored if `deprecator` is not provided.
+    """
 
-        return collection_name
+    version: _t.Optional[str] = None
+    """
+    The version of `deprecator` which will remove the feature described by `msg`.
+    Ignored if `deprecator` is not provided.
+    Ignored if `date` is provided.
+    """
 
     def _as_simple_dict(self) -> _t.Dict[str, _t.Any]:
         """Returns a dictionary representation of the deprecation object in the format exposed to playbooks."""
+        from ansible.module_utils._internal._deprecator import INDETERMINATE_DEPRECATOR  # circular import from messages
+
+        if self.deprecator and self.deprecator != INDETERMINATE_DEPRECATOR:
+            collection_name = '.'.join(self.deprecator.resolved_name.split('.')[:2])
+        else:
+            collection_name = None
+
         result = self._as_dict()
         result.update(
             msg=self._format(),
-            collection_name=self.collection_name,
+            collection_name=collection_name,
         )
 
         return result

ansible/module_utils/common/process.py

@@ -29,7 +29,6 @@ def get_bin_path(arg, opt_dirs=None, required=None):
         deprecate(
             msg="The `required` parameter in `get_bin_path` API is deprecated.",
             version="2.21",
-            collection_name="ansible.builtin",
         )
 
     paths = []

ansible/module_utils/common/respawn.py

@@ -3,14 +3,12 @@
 
 from __future__ import annotations
 
-import dataclasses
 import os
 import pathlib
 import subprocess
 import sys
 import typing as t
 
-from ansible.module_utils._internal import _plugin_exec_context
 from ansible.module_utils.common.text.converters import to_bytes
 
 _ANSIBLE_PARENT_PATH = pathlib.Path(__file__).parents[3]
@@ -99,7 +97,6 @@ if __name__ == '__main__':
 
     json_params = {json_params!r}
     profile = {profile!r}
-    plugin_info_dict = {plugin_info_dict!r}
     module_fqn = {module_fqn!r}
     modlib_path = {modlib_path!r}
 
@@ -110,19 +107,15 @@ if __name__ == '__main__':
     _ansiballz.run_module(
         json_params=json_params,
         profile=profile,
-        plugin_info_dict=plugin_info_dict,
         module_fqn=module_fqn,
         modlib_path=modlib_path,
         init_globals=dict(_respawned=True),
     )
 """
 
-    plugin_info = _plugin_exec_context.PluginExecContext.get_current_plugin_info()
-
     respawn_code = respawn_code_template.format(
         json_params=basic._ANSIBLE_ARGS,
         profile=basic._ANSIBLE_PROFILE,
-        plugin_info_dict=dataclasses.asdict(plugin_info),
         module_fqn=module_fqn,
         modlib_path=modlib_path,
     )

ansible/module_utils/common/warnings.py

@@ -4,15 +4,12 @@
 
 from __future__ import annotations as _annotations
 
-import datetime as _datetime
 import typing as _t
 
-from ansible.module_utils._internal import _traceback, _plugin_exec_context
+from ansible.module_utils._internal import _traceback, _deprecator
 from ansible.module_utils.common import messages as _messages
 from ansible.module_utils import _internal
 
-_UNSET = _t.cast(_t.Any, ...)
-
 
 def warn(warning: str) -> None:
     """Record a warning to be returned with the module result."""
@@ -28,22 +25,23 @@ def warn(warning: str) -> None:
 def deprecate(
     msg: str,
     version: str | None = None,
-    date: str | _datetime.date | None = None,
-    collection_name: str | None = _UNSET,
+    date: str | None = None,
+    collection_name: str | None = None,
     *,
+    deprecator: _messages.PluginInfo | None = None,
     help_text: str | None = None,
     obj: object | None = None,
 ) -> None:
     """
-    Record a deprecation warning to be returned with the module result.
+    Record a deprecation warning.
     The `obj` argument is only useful in a controller context; it is ignored for target-side callers.
+    Most callers do not need to provide `collection_name` or `deprecator` -- but provide only one if needed.
+    Specify `version` or `date`, but not both.
+    If `date` is a string, it must be in the form `YYYY-MM-DD`.
     """
-    if isinstance(date, _datetime.date):
-        date = str(date)
+    _skip_stackwalk = True
 
-    # deprecated: description='enable the deprecation message for collection_name' core_version='2.23'
-    # if collection_name is not _UNSET:
-    #     deprecate('The `collection_name` argument to `deprecate` is deprecated.', version='2.27')
+    deprecator = _deprecator.get_best_deprecator(deprecator=deprecator, collection_name=collection_name)
 
     if _internal.is_controller:
         _display = _internal.import_controller_module('ansible.utils.display').Display()
@@ -53,6 +51,8 @@ def deprecate(
             date=date,
             help_text=help_text,
             obj=obj,
+            # skip passing collection_name; get_best_deprecator already accounted for it when present
+            deprecator=deprecator,
         )
 
         return
@@ -64,7 +64,7 @@ def deprecate(
         formatted_traceback=_traceback.maybe_capture_traceback(_traceback.TracebackEvent.DEPRECATED),
         version=version,
         date=date,
-        plugin=_plugin_exec_context.PluginExecContext.get_current_plugin_info(),
+        deprecator=deprecator,
     )] = None
 
 

ansible/module_utils/datatag.py

@@ -1,11 +1,11 @@
 """Public API for data tagging."""
 from __future__ import annotations as _annotations
 
-import datetime as _datetime
 import typing as _t
 
-from ._internal import _plugin_exec_context, _datatag
+from ._internal import _datatag, _deprecator
 from ._internal._datatag import _tags
+from .common import messages as _messages
 
 _T = _t.TypeVar('_T')
 
@@ -14,28 +14,28 @@ def deprecate_value(
     value: _T,
     msg: str,
     *,
+    version: str | None = None,
+    date: str | None = None,
+    collection_name: str | None = None,
+    deprecator: _messages.PluginInfo | None = None,
     help_text: str | None = None,
-    removal_date: str | _datetime.date | None = None,
-    removal_version: str | None = None,
 ) -> _T:
     """
     Return `value` tagged with the given deprecation details.
     The types `None` and `bool` cannot be deprecated and are returned unmodified.
     Raises a `TypeError` if `value` is not a supported type.
-    If `removal_date` is a string, it must be in the form `YYYY-MM-DD`.
-    This function is only supported in contexts where an Ansible plugin/module is executing.
+    Most callers do not need to provide `collection_name` or `deprecator` -- but provide only one if needed.
+    Specify `version` or `date`, but not both.
+    If `date` is provided, it should be in the form `YYYY-MM-DD`.
     """
-    if isinstance(removal_date, str):
-        # The `fromisoformat` method accepts other ISO 8601 formats than `YYYY-MM-DD` starting with Python 3.11.
-        # That should be considered undocumented behavior of `deprecate_value` rather than an intentional feature.
-        removal_date = _datetime.date.fromisoformat(removal_date)
+    _skip_stackwalk = True
 
     deprecated = _tags.Deprecated(
         msg=msg,
         help_text=help_text,
-        removal_date=removal_date,
-        removal_version=removal_version,
-        plugin=_plugin_exec_context.PluginExecContext.get_current_plugin_info(),
+        date=date,
+        version=version,
+        deprecator=_deprecator.get_best_deprecator(deprecator=deprecator, collection_name=collection_name),
     )
 
     return deprecated.tag(value)

ansible/modules/async_status.py

@@ -68,7 +68,7 @@ EXAMPLES = r"""
   ansible.builtin.async_status:
     jid: '{{ dnf_sleeper.ansible_job_id }}'
   register: job_result
-  until: job_result.finished
+  until: job_result is finished
   retries: 100
   delay: 10
 

ansible/modules/dnf5.py

@@ -797,7 +797,7 @@ class Dnf5Module(YumDnf):
         if self.module.check_mode:
             if results:
                 msg = "Check mode: No changes made, but would have if not in check mode"
-        else:
+        elif changed:
             transaction.download()
             if not self.download_only:
                 transaction.set_description("ansible dnf5 module")

ansible/modules/get_url.py

@@ -87,7 +87,7 @@ options:
       - 'If a checksum is passed to this parameter, the digest of the
         destination file will be calculated after it is downloaded to ensure
         its integrity and verify that the transfer completed successfully.
-        Format: <algorithm>:<checksum|url>, for example C(checksum="sha256:D98291AC[...]B6DC7B97",
+        Format: <algorithm>:<checksum|url>, for example C(checksum="sha256:D98291AC[...]B6DC7B97"),
         C(checksum="sha256:http://example.com/path/sha256sum.txt").'
       - If you worry about portability, only the sha1 algorithm is available
         on all platforms and python versions.

ansible/parsing/utils/jsonify.py

@@ -0,0 +1,40 @@
+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+import json
+
+from ansible.utils.display import Display
+
+Display().deprecated(f'{__name__!r} is deprecated.', version='2.23', help_text='Call `json.dumps` directly instead.')
+
+
+def jsonify(result, format=False):
+    """Format JSON output."""
+
+    if result is None:
+        return "{}"
+
+    indent = None
+    if format:
+        indent = 4
+
+    try:
+        return json.dumps(result, sort_keys=True, indent=indent, ensure_ascii=False)
+    except UnicodeDecodeError:
+        return json.dumps(result, sort_keys=True, indent=indent)

ansible/parsing/yaml/objects.py

@@ -8,25 +8,36 @@ from ansible.module_utils._internal import _datatag
 from ansible.module_utils.common.text import converters as _converters
 from ansible.parsing import vault as _vault
 
+_UNSET = _t.cast(_t.Any, object())
+
 
 class _AnsibleMapping(dict):
     """Backwards compatibility type."""
 
-    def __new__(cls, value):
-        return _datatag.AnsibleTagHelper.tag_copy(value, dict(value))
+    def __new__(cls, value=_UNSET, /, **kwargs):
+        if value is _UNSET:
+            return dict(**kwargs)
+
+        return _datatag.AnsibleTagHelper.tag_copy(value, dict(value, **kwargs))
 
 
 class _AnsibleUnicode(str):
     """Backwards compatibility type."""
 
-    def __new__(cls, value):
-        return _datatag.AnsibleTagHelper.tag_copy(value, str(value))
+    def __new__(cls, object=_UNSET, **kwargs):
+        if object is _UNSET:
+            return str(**kwargs)
+
+        return _datatag.AnsibleTagHelper.tag_copy(object, str(object, **kwargs))
 
 
 class _AnsibleSequence(list):
     """Backwards compatibility type."""
 
-    def __new__(cls, value):
+    def __new__(cls, value=_UNSET, /):
+        if value is _UNSET:
+            return list()
+
         return _datatag.AnsibleTagHelper.tag_copy(value, list(value))
 
 

ansible/playbook/included_file.py

@@ -21,34 +21,42 @@ import os
 
 from ansible import constants as C
 from ansible.errors import AnsibleError
+from ansible.executor.task_result import _RawTaskResult
+from ansible.inventory.host import Host
 from ansible.module_utils.common.text.converters import to_text
+from ansible.parsing.dataloader import DataLoader
 from ansible.playbook.handler import Handler
 from ansible.playbook.task_include import TaskInclude
 from ansible.playbook.role_include import IncludeRole
 from ansible._internal._templating._engine import TemplateEngine
 from ansible.utils.display import Display
+from ansible.vars.manager import VariableManager
 
 display = Display()
 
 
 class IncludedFile:
 
-    def __init__(self, filename, args, vars, task, is_role=False):
+    def __init__(self, filename, args, vars, task, is_role: bool = False) -> None:
         self._filename = filename
         self._args = args
         self._vars = vars
         self._task = task
-        self._hosts = []
+        self._hosts: list[Host] = []
         self._is_role = is_role
-        self._results = []
+        self._results: list[_RawTaskResult] = []
 
-    def add_host(self, host):
+    def add_host(self, host: Host) -> None:
         if host not in self._hosts:
             self._hosts.append(host)
             return
+
         raise ValueError()
 
     def __eq__(self, other):
+        if not isinstance(other, IncludedFile):
+            return False
+
         return (other._filename == self._filename and
                 other._args == self._args and
                 other._vars == self._vars and
@@ -59,23 +67,28 @@ class IncludedFile:
         return "%s (args=%s vars=%s): %s" % (self._filename, self._args, self._vars, self._hosts)
 
     @staticmethod
-    def process_include_results(results, iterator, loader, variable_manager):
-        included_files = []
-        task_vars_cache = {}
+    def process_include_results(
+        results: list[_RawTaskResult],
+        iterator,
+        loader: DataLoader,
+        variable_manager: VariableManager,
+    ) -> list[IncludedFile]:
+        included_files: list[IncludedFile] = []
+        task_vars_cache: dict[tuple, dict] = {}
 
         for res in results:
 
-            original_host = res._host
-            original_task = res._task
+            original_host = res.host
+            original_task = res.task
 
             if original_task.action in C._ACTION_ALL_INCLUDES:
 
                 if original_task.loop:
-                    if 'results' not in res._result:
+                    if 'results' not in res._return_data:
                         continue
-                    include_results = res._result['results']
+                    include_results = res._loop_results
                 else:
-                    include_results = [res._result]
+                    include_results = [res._return_data]
 
                 for include_result in include_results:
                     # if the task result was skipped or failed, continue