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

ansible/_internal/_collection_proxy.py

@@ -0,0 +1,47 @@
+from __future__ import annotations as _annotations
+
+import collections.abc as _c
+import typing as _t
+
+_T_co = _t.TypeVar('_T_co', covariant=True)
+
+
+class SequenceProxy(_c.Sequence[_T_co]):
+    """A read-only sequence proxy."""
+
+    # DTFIX-RELEASE: needs unit test coverage
+
+    __slots__ = ('__value',)
+
+    def __init__(self, value: _c.Sequence[_T_co]) -> None:
+        self.__value = value
+
+    @_t.overload
+    def __getitem__(self, index: int) -> _T_co: ...
+
+    @_t.overload
+    def __getitem__(self, index: slice) -> _c.Sequence[_T_co]: ...
+
+    def __getitem__(self, index: int | slice) -> _T_co | _c.Sequence[_T_co]:
+        if isinstance(index, slice):
+            return self.__class__(self.__value[index])
+
+        return self.__value[index]
+
+    def __len__(self) -> int:
+        return len(self.__value)
+
+    def __contains__(self, item: object) -> bool:
+        return item in self.__value
+
+    def __iter__(self) -> _t.Iterator[_T_co]:
+        yield from self.__value
+
+    def __reversed__(self) -> _c.Iterator[_T_co]:
+        return reversed(self.__value)
+
+    def index(self, *args) -> int:
+        return self.__value.index(*args)
+
+    def count(self, value: object) -> int:
+        return self.__value.count(value)

ansible/_internal/_errors/_handler.py

@@ -16,8 +16,8 @@ class ErrorAction(enum.Enum):
     """Action to take when an error is encountered."""
 
     IGNORE = enum.auto()
-    WARN = enum.auto()
-    FAIL = enum.auto()
+    WARNING = enum.auto()
+    ERROR = enum.auto()
 
     @classmethod
     def from_config(cls, setting: str, variables: dict[str, t.Any] | None = None) -> t.Self:
@@ -75,9 +75,9 @@ class ErrorHandler:
             yield
         except args as ex:
             match self.action:
-                case ErrorAction.WARN:
+                case ErrorAction.WARNING:
                     display.error_as_warning(msg=None, exception=ex)
-                case ErrorAction.FAIL:
+                case ErrorAction.ERROR:
                     raise
                 case _:  # ErrorAction.IGNORE
                     pass

ansible/_internal/_json/__init__.py

@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import enum
 import json
 import typing as t
 
@@ -19,7 +20,9 @@ from ansible.module_utils._internal._datatag import (
 from ansible.module_utils._internal._json._profiles import _tagless
 from ansible.parsing.vault import EncryptedString
 from ansible._internal._datatag._tags import Origin, TrustedAsTemplate
+from ansible._internal._templating import _transform
 from ansible.module_utils import _internal
+from ansible.module_utils._internal import _datatag
 
 _T = t.TypeVar('_T')
 _sentinel = object()
@@ -52,6 +55,19 @@ class StateTrackingMixIn(HasCurrent):
         return self._stack[1:] + [self._current]
 
 
+class EncryptedStringBehavior(enum.Enum):
+    """How `AnsibleVariableVisitor` will handle instances of `EncryptedString`."""
+
+    PRESERVE = enum.auto()
+    """Preserves the unmodified `EncryptedString` instance."""
+    DECRYPT = enum.auto()
+    """Replaces the value with its decrypted plaintext."""
+    REDACT = enum.auto()
+    """Replaces the value with a placeholder string."""
+    FAIL = enum.auto()
+    """Raises an `AnsibleVariableTypeError` error."""
+
+
 class AnsibleVariableVisitor:
     """Utility visitor base class to recursively apply various behaviors and checks to variable object graphs."""
 
@@ -63,7 +79,9 @@ class AnsibleVariableVisitor:
         convert_mapping_to_dict: bool = False,
         convert_sequence_to_list: bool = False,
         convert_custom_scalars: bool = False,
-        allow_encrypted_string: bool = False,
+        convert_to_native_values: bool = False,
+        apply_transforms: bool = False,
+        encrypted_string_behavior: EncryptedStringBehavior = EncryptedStringBehavior.DECRYPT,
     ):
         super().__init__()  # supports StateTrackingMixIn
 
@@ -72,7 +90,16 @@ class AnsibleVariableVisitor:
         self.convert_mapping_to_dict = convert_mapping_to_dict
         self.convert_sequence_to_list = convert_sequence_to_list
         self.convert_custom_scalars = convert_custom_scalars
-        self.allow_encrypted_string = allow_encrypted_string
+        self.convert_to_native_values = convert_to_native_values
+        self.apply_transforms = apply_transforms
+        self.encrypted_string_behavior = encrypted_string_behavior
+
+        if apply_transforms:
+            from ansible._internal._templating import _engine
+
+            self._template_engine = _engine.TemplateEngine()
+        else:
+            self._template_engine = None
 
         self._current: t.Any = None  # supports StateTrackingMixIn
 
@@ -113,9 +140,19 @@ class AnsibleVariableVisitor:
 
         value_type = type(value)
 
+        if self.apply_transforms and value_type in _transform._type_transform_mapping:
+            value = self._template_engine.transform(value)
+            value_type = type(value)
+
+        # DTFIX-RELEASE: need to handle native copy for keys too
+        if self.convert_to_native_values and isinstance(value, _datatag.AnsibleTaggedObject):
+            value = value._native_copy()
+            value_type = type(value)
+
         result: _T
 
         # DTFIX-RELEASE: the visitor is ignoring dict/mapping keys except for debugging and schema-aware checking, it should be doing type checks on keys
+        #                keep in mind the allowed types for keys is a more restrictive set than for values (str and taggged str only, not EncryptedString)
         # DTFIX-RELEASE: some type lists being consulted (the ones from datatag) are probably too permissive, and perhaps should not be dynamic
 
         if (result := self._early_visit(value, value_type)) is not _sentinel:
@@ -127,8 +164,14 @@ class AnsibleVariableVisitor:
         elif value_type in _ANSIBLE_ALLOWED_NON_SCALAR_COLLECTION_VAR_TYPES:
             with self:  # supports StateTrackingMixIn
                 result = AnsibleTagHelper.tag_copy(value, (self._visit(k, v) for k, v in enumerate(t.cast(t.Iterable, value))), value_type=value_type)
-        elif self.allow_encrypted_string and isinstance(value, EncryptedString):
-            return value  # type: ignore[return-value]  # DTFIX-RELEASE: this should probably only be allowed for values in dict, not keys (set, dict)
+        elif self.encrypted_string_behavior != EncryptedStringBehavior.FAIL and isinstance(value, EncryptedString):
+            match self.encrypted_string_behavior:
+                case EncryptedStringBehavior.REDACT:
+                    result = "<redacted>"  # type: ignore[assignment]
+                case EncryptedStringBehavior.PRESERVE:
+                    result = value  # type: ignore[assignment]
+                case EncryptedStringBehavior.DECRYPT:
+                    result = str(value)  # type: ignore[assignment]
         elif self.convert_mapping_to_dict and _internal.is_intermediate_mapping(value):
             with self:  # supports StateTrackingMixIn
                 result = {k: self._visit(k, v) for k, v in value.items()}  # type: ignore[assignment]

ansible/_internal/_json/_profiles/_legacy.py

@@ -8,13 +8,12 @@ from __future__ import annotations as _annotations
 import datetime as _datetime
 import typing as _t
 
+from ansible._internal import _json
 from ansible._internal._datatag import _tags
 from ansible.module_utils._internal import _datatag
 from ansible.module_utils._internal._json import _profiles
 from ansible.parsing import vault as _vault
 
-from ... import _json
-
 
 class _Untrusted:
     """
@@ -48,7 +47,7 @@ class _LegacyVariableVisitor(_json.AnsibleVariableVisitor):
             convert_mapping_to_dict=convert_mapping_to_dict,
             convert_sequence_to_list=convert_sequence_to_list,
             convert_custom_scalars=convert_custom_scalars,
-            allow_encrypted_string=True,
+            encrypted_string_behavior=_json.EncryptedStringBehavior.PRESERVE,
         )
 
         self.invert_trust = invert_trust

ansible/_internal/_templating/_jinja_bits.py

@@ -985,12 +985,12 @@ def _maybe_finalize_scalar(o: t.Any) -> t.Any:
 
         match _TemplateConfig.unknown_type_conversion_handler.action:
             # we don't want to show the object value, and it can't be Origin-tagged; send the current template value for best effort
-            case ErrorAction.WARN:
+            case ErrorAction.WARNING:
                 display.warning(
                     msg=f'Type {native_type_name(o)!r} is unsupported in variable storage, converting to {native_type_name(target_type)!r}.',
                     obj=TemplateContext.current(optional=True).template_value,
                 )
-            case ErrorAction.FAIL:
+            case ErrorAction.ERROR:
                 raise AnsibleVariableTypeError.from_value(obj=TemplateContext.current(optional=True).template_value)
 
         return target_type(o)
@@ -1006,12 +1006,12 @@ def _finalize_fallback_collection(
 ) -> t.Collection[t.Any]:
     match _TemplateConfig.unknown_type_conversion_handler.action:
         # we don't want to show the object value, and it can't be Origin-tagged; send the current template value for best effort
-        case ErrorAction.WARN:
+        case ErrorAction.WARNING:
             display.warning(
                 msg=f'Type {native_type_name(o)!r} is unsupported in variable storage, converting to {native_type_name(target_type)!r}.',
                 obj=TemplateContext.current(optional=True).template_value,
             )
-        case ErrorAction.FAIL:
+        case ErrorAction.ERROR:
             raise AnsibleVariableTypeError.from_value(obj=TemplateContext.current(optional=True).template_value)
 
     return _finalize_collection(o, mode, finalizer, target_type)

ansible/_internal/_templating/_jinja_plugins.py

@@ -8,10 +8,6 @@ import datetime
 import functools
 import typing as t
 
-from ansible.errors import (
-    AnsibleTemplatePluginError,
-)
-
 from ansible.module_utils._internal._ambient_context import AmbientContextBase
 from ansible.module_utils._internal._plugin_exec_context import PluginExecContext
 from ansible.module_utils.common.collections import is_sequence
@@ -263,15 +259,13 @@ def _invoke_lookup(*, plugin_name: str, lookup_terms: list, lookup_kwargs: dict[
             return ex.source
         except Exception as ex:
             # DTFIX-RELEASE: convert this to the new error/warn/ignore context manager
-            if isinstance(ex, AnsibleTemplatePluginError):
-                msg = f'Lookup failed but the error is being ignored: {ex}'
-            else:
-                msg = f'An unhandled exception occurred while running the lookup plugin {plugin_name!r}. Error was a {type(ex)}, original message: {ex}'
-
             if errors == 'warn':
-                _display.warning(msg)
+                _display.error_as_warning(
+                    msg=f'An error occurred while running the lookup plugin {plugin_name!r}.',
+                    exception=ex,
+                )
             elif errors == 'ignore':
-                _display.display(msg, log_only=True)
+                _display.display(f'An error of type {type(ex)} occurred while running the lookup plugin {plugin_name!r}: {ex}', log_only=True)
             else:
                 raise AnsibleTemplatePluginRuntimeError('lookup', plugin_name) from ex
 

ansible/cli/__init__.py

@@ -89,18 +89,24 @@ from ansible import _internal  # do not remove or defer; ensures controller-spec
 
 _internal.setup()
 
+from ansible.errors import AnsibleError, ExitCode
+
 try:
     from ansible import constants as C
     from ansible.utils.display import Display
     display = Display()
 except Exception as ex:
-    print(f'ERROR: {ex}\n\n{"".join(traceback.format_exception(ex))}', file=sys.stderr)
+    if isinstance(ex, AnsibleError):
+        ex_msg = ' '.join((ex.message, ex._help_text)).strip()
+    else:
+        ex_msg = str(ex)
+
+    print(f'ERROR: {ex_msg}\n\n{"".join(traceback.format_exception(ex))}', file=sys.stderr)
     sys.exit(5)
 
 
 from ansible import context
 from ansible.cli.arguments import option_helpers as opt_help
-from ansible.errors import AnsibleError, ExitCode
 from ansible.inventory.manager import InventoryManager
 from ansible.module_utils.six import string_types
 from ansible.module_utils.common.text.converters import to_bytes, to_text
@@ -139,7 +145,7 @@ def _launch_ssh_agent() -> None:
             return
         case 'auto':
             try:
-                ssh_agent_bin = get_bin_path('ssh-agent', required=True)
+                ssh_agent_bin = get_bin_path('ssh-agent')
             except ValueError as e:
                 raise AnsibleError('SSH_AGENT set to auto, but cannot find ssh-agent binary') from e
             ssh_agent_dir = os.path.join(C.DEFAULT_LOCAL_TMP, 'ssh_agent')

ansible/cli/doc.py

@@ -1172,12 +1172,16 @@ class DocCLI(CLI, RoleMixin):
         return 'version %s' % (version_added, )
 
     @staticmethod
-    def warp_fill(text, limit, initial_indent='', subsequent_indent='', **kwargs):
+    def warp_fill(text, limit, initial_indent='', subsequent_indent='', initial_extra=0, **kwargs):
         result = []
         for paragraph in text.split('\n\n'):
-            result.append(textwrap.fill(paragraph, limit, initial_indent=initial_indent, subsequent_indent=subsequent_indent,
-                                        break_on_hyphens=False, break_long_words=False, drop_whitespace=True, **kwargs))
+            wrapped = textwrap.fill(paragraph, limit, initial_indent=initial_indent + ' ' * initial_extra, subsequent_indent=subsequent_indent,
+                                    break_on_hyphens=False, break_long_words=False, drop_whitespace=True, **kwargs)
+            if initial_extra and wrapped.startswith(' ' * initial_extra):
+                wrapped = wrapped[initial_extra:]
+            result.append(wrapped)
             initial_indent = subsequent_indent
+            initial_extra = 0
         return '\n'.join(result)
 
     @staticmethod
@@ -1209,20 +1213,23 @@ class DocCLI(CLI, RoleMixin):
             text.append('')
 
             # TODO: push this to top of for and sort by size, create indent on largest key?
-            inline_indent = base_indent + ' ' * max((len(opt_indent) - len(o)) - len(base_indent), 2)
-            sub_indent = inline_indent + ' ' * (len(o) + 3)
+            inline_indent = ' ' * max((len(opt_indent) - len(o)) - len(base_indent), 2)
+            extra_indent = base_indent + ' ' * (len(o) + 3)
+            sub_indent = inline_indent + extra_indent
             if is_sequence(opt['description']):
                 for entry_idx, entry in enumerate(opt['description'], 1):
                     if not isinstance(entry, string_types):
                         raise AnsibleError("Expected string in description of %s at index %s, got %s" % (o, entry_idx, type(entry)))
                     if entry_idx == 1:
-                        text.append(key + DocCLI.warp_fill(DocCLI.tty_ify(entry), limit, initial_indent=inline_indent, subsequent_indent=sub_indent))
+                        text.append(key + DocCLI.warp_fill(DocCLI.tty_ify(entry), limit,
+                                    initial_indent=inline_indent, subsequent_indent=sub_indent, initial_extra=len(extra_indent)))
                     else:
                         text.append(DocCLI.warp_fill(DocCLI.tty_ify(entry), limit, initial_indent=sub_indent, subsequent_indent=sub_indent))
             else:
                 if not isinstance(opt['description'], string_types):
                     raise AnsibleError("Expected string in description of %s, got %s" % (o, type(opt['description'])))
-                text.append(key + DocCLI.warp_fill(DocCLI.tty_ify(opt['description']), limit, initial_indent=inline_indent, subsequent_indent=sub_indent))
+                text.append(key + DocCLI.warp_fill(DocCLI.tty_ify(opt['description']), limit,
+                            initial_indent=inline_indent, subsequent_indent=sub_indent, initial_extra=len(extra_indent)))
             del opt['description']
 
             suboptions = []

ansible/config/base.yml

@@ -9,6 +9,18 @@ _ANSIBLE_CONNECTION_PATH:
     - For internal use only.
   type: path
   version_added: "2.18"
+_CALLBACK_DISPATCH_ERROR_BEHAVIOR:
+  name: Callback dispatch error behavior
+  default: warning
+  description:
+    - Action to take when a callback dispatch results in an error.
+  type: choices
+  choices: &basic_error
+    error: issue a 'fatal' error and stop the play
+    warning: issue a warning but continue
+    ignore: just continue silently
+  env: [ { name: _ANSIBLE_CALLBACK_DISPATCH_ERROR_BEHAVIOR } ]
+  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
@@ -224,18 +236,6 @@ CACHE_PLUGIN_TIMEOUT:
   - {key: fact_caching_timeout, section: defaults}
   type: integer
   yaml: {key: facts.cache.timeout}
-_CALLBACK_DISPATCH_ERROR_BEHAVIOR:
-  name: Callback dispatch error behavior
-  default: warn
-  description:
-    - Action to take when a callback dispatch results in an error.
-  type: choices
-  choices: &choices_ignore_warn_fail
-    - ignore
-    - warn
-    - fail
-  env: [ { name: _ANSIBLE_CALLBACK_DISPATCH_ERROR_BEHAVIOR } ]
-  version_added: '2.19'
 COLLECTIONS_SCAN_SYS_PATH:
   name: Scan PYTHONPATH for installed collections
   description: A boolean to enable or disable scanning the sys.path for installed collections.
@@ -268,10 +268,7 @@ COLLECTIONS_ON_ANSIBLE_VERSION_MISMATCH:
   - When a collection is loaded that does not support the running Ansible version (with the collection metadata key `requires_ansible`).
   env: [{name: ANSIBLE_COLLECTIONS_ON_ANSIBLE_VERSION_MISMATCH}]
   ini: [{key: collections_on_ansible_version_mismatch, section: defaults}]
-  choices: &basic_error
-    error: issue a 'fatal' error and stop the play
-    warning: issue a warning but continue
-    ignore: just continue silently
+  choices: *basic_error
   default: warning
 COLOR_CHANGED:
   name: Color for 'changed' task status
@@ -2058,13 +2055,13 @@ TASK_TIMEOUT:
   version_added: '2.10'
 _TEMPLAR_UNKNOWN_TYPE_CONVERSION:
   name: Templar unknown type conversion behavior
-  default: warn
+  default: warning
   description:
     - Action to take when an unknown type is converted for variable storage during template finalization.
     - This setting has no effect on the inability to store unsupported variable types as the result of templating.
     - Experimental diagnostic feature, subject to change.
   type: choices
-  choices: *choices_ignore_warn_fail
+  choices: *basic_error
   env: [{name: _ANSIBLE_TEMPLAR_UNKNOWN_TYPE_CONVERSION}]
   version_added: '2.19'
 _TEMPLAR_UNKNOWN_TYPE_ENCOUNTERED:
@@ -2074,7 +2071,7 @@ _TEMPLAR_UNKNOWN_TYPE_ENCOUNTERED:
     - Action to take when an unknown type is encountered inside a template pipeline.
     - Experimental diagnostic feature, subject to change.
   type: choices
-  choices: *choices_ignore_warn_fail
+  choices: *basic_error
   env: [{name: _ANSIBLE_TEMPLAR_UNKNOWN_TYPE_ENCOUNTERED}]
   version_added: '2.19'
 _TEMPLAR_UNTRUSTED_TEMPLATE_BEHAVIOR:
@@ -2086,7 +2083,7 @@ _TEMPLAR_UNTRUSTED_TEMPLATE_BEHAVIOR:
     - This setting has no effect on expressions.
     - Experimental diagnostic feature, subject to change.
   type: choices
-  choices: *choices_ignore_warn_fail
+  choices: *basic_error
   env: [{name: _ANSIBLE_TEMPLAR_UNTRUSTED_TEMPLATE_BEHAVIOR}]
   version_added: '2.19'
 WORKER_SHUTDOWN_POLL_COUNT:

ansible/executor/process/worker.py

@@ -32,6 +32,7 @@ from ansible._internal import _task
 from ansible.errors import AnsibleConnectionFailure, AnsibleError
 from ansible.executor.task_executor import TaskExecutor
 from ansible.executor.task_queue_manager import FinalQueue, STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO
+from ansible.executor.task_result import _RawTaskResult
 from ansible.inventory.host import Host
 from ansible.module_utils.common.collections import is_sequence
 from ansible.module_utils.common.text.converters import to_text
@@ -226,7 +227,7 @@ class WorkerProcess(multiprocessing_context.Process):  # type: ignore[name-defin
             init_plugin_loader(cli_collections_path)
 
         try:
-            # execute the task and build a TaskResult from the result
+            # execute the task and build a _RawTaskResult from the result
             display.debug("running TaskExecutor() for %s/%s" % (self._host, self._task))
             executor_result = TaskExecutor(
                 self._host,
@@ -256,48 +257,52 @@ class WorkerProcess(multiprocessing_context.Process):  # type: ignore[name-defin
             # put the result on the result queue
             display.debug("sending task result for task %s" % self._task._uuid)
             try:
-                self._final_q.send_task_result(
-                    self._host.name,
-                    self._task._uuid,
-                    executor_result,
+                self._final_q.send_task_result(_RawTaskResult(
+                    host=self._host,
+                    task=self._task,
+                    return_data=executor_result,
                     task_fields=self._task.dump_attrs(),
-                )
+                ))
             except Exception as ex:
                 try:
                     raise AnsibleError("Task result omitted due to queue send failure.") from ex
                 except Exception as ex_wrapper:
-                    self._final_q.send_task_result(
-                        self._host.name,
-                        self._task._uuid,
-                        ActionBase.result_dict_from_exception(ex_wrapper),  # Overriding the task result, to represent the failure
-                        {},  # The failure pickling may have been caused by the task attrs, omit for safety
-                    )
+                    self._final_q.send_task_result(_RawTaskResult(
+                        host=self._host,
+                        task=self._task,
+                        return_data=ActionBase.result_dict_from_exception(ex_wrapper),  # Overriding the task result, to represent the failure
+                        task_fields={},  # The failure pickling may have been caused by the task attrs, omit for safety
+                    ))
 
             display.debug("done sending task result for task %s" % self._task._uuid)
 
-        except AnsibleConnectionFailure:
+        except AnsibleConnectionFailure as ex:
+            return_data = ActionBase.result_dict_from_exception(ex)
+            return_data.pop('failed')
+            return_data.update(unreachable=True)
+
             self._host.vars = dict()
             self._host.groups = []
-            self._final_q.send_task_result(
-                self._host.name,
-                self._task._uuid,
-                dict(unreachable=True),
+            self._final_q.send_task_result(_RawTaskResult(
+                host=self._host,
+                task=self._task,
+                return_data=return_data,
                 task_fields=self._task.dump_attrs(),
-            )
+            ))
 
-        except Exception as e:
-            if not isinstance(e, (IOError, EOFError, KeyboardInterrupt, SystemExit)) or isinstance(e, TemplateNotFound):
+        except Exception as ex:
+            if not isinstance(ex, (IOError, EOFError, KeyboardInterrupt, SystemExit)) or isinstance(ex, TemplateNotFound):
                 try:
                     self._host.vars = dict()
                     self._host.groups = []
-                    self._final_q.send_task_result(
-                        self._host.name,
-                        self._task._uuid,
-                        dict(failed=True, exception=to_text(traceback.format_exc()), stdout=''),
+                    self._final_q.send_task_result(_RawTaskResult(
+                        host=self._host,
+                        task=self._task,
+                        return_data=ActionBase.result_dict_from_exception(ex),
                         task_fields=self._task.dump_attrs(),
-                    )
+                    ))
                 except Exception:
-                    display.debug(u"WORKER EXCEPTION: %s" % to_text(e))
+                    display.debug(u"WORKER EXCEPTION: %s" % to_text(ex))
                     display.debug(u"WORKER TRACEBACK: %s" % to_text(traceback.format_exc()))
                 finally:
                     self._clean_up()

ansible/executor/task_executor.py

@@ -20,7 +20,7 @@ from ansible.errors import (
     AnsibleError, AnsibleParserError, AnsibleUndefinedVariable, AnsibleConnectionFailure, AnsibleActionFail, AnsibleActionSkip, AnsibleTaskError,
     AnsibleValueOmittedError,
 )
-from ansible.executor.task_result import TaskResult
+from ansible.executor.task_result import _RawTaskResult
 from ansible._internal._datatag import _utils
 from ansible.module_utils._internal._plugin_exec_context import PluginExecContext
 from ansible.module_utils.common.messages import Detail, WarningSummary, DeprecationSummary
@@ -44,6 +44,9 @@ from ansible.vars.clean import namespace_facts, clean_facts
 from ansible.vars.manager import _deprecate_top_level_fact
 from ansible._internal._errors import _captured
 
+if t.TYPE_CHECKING:
+    from ansible.executor.task_queue_manager import FinalQueue
+
 display = Display()
 
 
@@ -79,7 +82,7 @@ class TaskExecutor:
     class.
     """
 
-    def __init__(self, host, task: Task, job_vars, play_context, loader, shared_loader_obj, final_q, variable_manager):
+    def __init__(self, host, task: Task, job_vars, play_context, loader, shared_loader_obj, final_q: FinalQueue, variable_manager):
         self._host = host
         self._task = task
         self._job_vars = job_vars
@@ -361,10 +364,10 @@ class TaskExecutor:
             if self._connection and not isinstance(self._connection, string_types):
                 task_fields['connection'] = getattr(self._connection, 'ansible_name')
 
-            tr = TaskResult(
-                self._host.name,
-                self._task._uuid,
-                res,
+            tr = _RawTaskResult(
+                host=self._host,
+                task=self._task,
+                return_data=res,
                 task_fields=task_fields,
             )
 
@@ -666,17 +669,23 @@ class TaskExecutor:
                     if result.get('failed'):
                         self._final_q.send_callback(
                             'v2_runner_on_async_failed',
-                            TaskResult(self._host.name,
-                                       self._task._uuid,
-                                       result,
-                                       task_fields=self._task.dump_attrs()))
+                            _RawTaskResult(
+                                host=self._host,
+                                task=self._task,
+                                return_data=result,
+                                task_fields=self._task.dump_attrs(),
+                            ),
+                        )
                     else:
                         self._final_q.send_callback(
                             'v2_runner_on_async_ok',
-                            TaskResult(self._host.name,
-                                       self._task._uuid,
-                                       result,
-                                       task_fields=self._task.dump_attrs()))
+                            _RawTaskResult(
+                                host=self._host,
+                                task=self._task,
+                                return_data=result,
+                                task_fields=self._task.dump_attrs(),
+                            ),
+                        )
 
             if 'ansible_facts' in result and self._task.action not in C._ACTION_DEBUG:
                 if self._task.action in C._ACTION_WITH_CLEAN_FACTS:
@@ -756,12 +765,12 @@ class TaskExecutor:
                         display.debug('Retrying task, attempt %d of %d' % (attempt, retries))
                         self._final_q.send_callback(
                             'v2_runner_retry',
-                            TaskResult(
-                                self._host.name,
-                                self._task._uuid,
-                                result,
+                            _RawTaskResult(
+                                host=self._host,
+                                task=self._task,
+                                return_data=result,
                                 task_fields=self._task.dump_attrs()
-                            )
+                            ),
                         )
                         time.sleep(delay)
                         self._handler = self._get_action_handler(templar=templar)
@@ -926,10 +935,10 @@ class TaskExecutor:
                 time_left -= self._task.poll
                 self._final_q.send_callback(
                     'v2_runner_on_async_poll',
-                    TaskResult(
-                        self._host.name,
-                        async_task._uuid,
-                        async_result,
+                    _RawTaskResult(
+                        host=self._host,
+                        task=async_task,
+                        return_data=async_result,
                         task_fields=async_task.dump_attrs(),
                     ),
                 )