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

ansible/plugins/callback/default.py

@@ -21,7 +21,7 @@ DOCUMENTATION = """
 
 from ansible import constants as C
 from ansible import context
-from ansible.executor.task_result import TaskResult
+from ansible.executor.task_result import CallbackTaskResult
 from ansible.playbook.task_include import TaskInclude
 from ansible.plugins.callback import CallbackBase
 from ansible.utils.color import colorize, hostcolor
@@ -47,39 +47,39 @@ class CallbackModule(CallbackBase):
         self._task_type_cache = {}
         super(CallbackModule, self).__init__()
 
-    def v2_runner_on_failed(self, result: TaskResult, ignore_errors: bool = False) -> None:
+    def v2_runner_on_failed(self, result: CallbackTaskResult, ignore_errors: bool = False) -> None:
         host_label = self.host_label(result)
 
-        if self._last_task_banner != result._task._uuid:
-            self._print_task_banner(result._task)
+        if self._last_task_banner != result.task._uuid:
+            self._print_task_banner(result.task)
 
         self._handle_warnings_and_exception(result)
 
         # FIXME: this method should not exist, delegate "suggested keys to display" to the plugin or something... As-is, the placement of this
         #          call obliterates `results`, which causes a task summary to be printed on loop failures, which we don't do anywhere else.
-        self._clean_results(result._result, result._task.action)
+        self._clean_results(result.result, result.task.action)
 
-        if result._task.loop and 'results' in result._result:
+        if result.task.loop and 'results' in result.result:
             self._process_items(result)
         else:
             if self._display.verbosity < 2 and self.get_option('show_task_path_on_failure'):
-                self._print_task_path(result._task)
-            msg = "fatal: [%s]: FAILED! => %s" % (host_label, self._dump_results(result._result))
+                self._print_task_path(result.task)
+            msg = "fatal: [%s]: FAILED! => %s" % (host_label, self._dump_results(result.result))
             self._display.display(msg, color=C.COLOR_ERROR, stderr=self.get_option('display_failed_stderr'))
 
         if ignore_errors:
             self._display.display("...ignoring", color=C.COLOR_SKIP)
 
-    def v2_runner_on_ok(self, result: TaskResult) -> None:
+    def v2_runner_on_ok(self, result: CallbackTaskResult) -> None:
         host_label = self.host_label(result)
 
-        if isinstance(result._task, TaskInclude):
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+        if isinstance(result.task, TaskInclude):
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
             return
-        elif result._result.get('changed', False):
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+        elif result.result.get('changed', False):
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             msg = "changed: [%s]" % (host_label,)
             color = C.COLOR_CHANGED
@@ -87,52 +87,52 @@ class CallbackModule(CallbackBase):
             if not self.get_option('display_ok_hosts'):
                 return
 
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             msg = "ok: [%s]" % (host_label,)
             color = C.COLOR_OK
 
         self._handle_warnings_and_exception(result)
 
-        if result._task.loop and 'results' in result._result:
+        if result.task.loop and 'results' in result.result:
             self._process_items(result)
         else:
-            self._clean_results(result._result, result._task.action)
+            self._clean_results(result.result, result.task.action)
 
             if self._run_is_verbose(result):
-                msg += " => %s" % (self._dump_results(result._result),)
+                msg += " => %s" % (self._dump_results(result.result),)
             self._display.display(msg, color=color)
 
-    def v2_runner_on_skipped(self, result: TaskResult) -> None:
+    def v2_runner_on_skipped(self, result: CallbackTaskResult) -> None:
         if self.get_option('display_skipped_hosts'):
 
-            self._clean_results(result._result, result._task.action)
+            self._clean_results(result.result, result.task.action)
 
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             self._handle_warnings_and_exception(result)
 
-            if result._task.loop is not None and 'results' in result._result:
+            if result.task.loop is not None and 'results' in result.result:
                 self._process_items(result)
 
-            msg = "skipping: [%s]" % result._host.get_name()
+            msg = "skipping: [%s]" % result.host.get_name()
             if self._run_is_verbose(result):
-                msg += " => %s" % self._dump_results(result._result)
+                msg += " => %s" % self._dump_results(result.result)
             self._display.display(msg, color=C.COLOR_SKIP)
 
-    def v2_runner_on_unreachable(self, result: TaskResult) -> None:
-        if self._last_task_banner != result._task._uuid:
-            self._print_task_banner(result._task)
+    def v2_runner_on_unreachable(self, result: CallbackTaskResult) -> None:
+        if self._last_task_banner != result.task._uuid:
+            self._print_task_banner(result.task)
 
         self._handle_warnings_and_exception(result)
 
         host_label = self.host_label(result)
-        msg = "fatal: [%s]: UNREACHABLE! => %s" % (host_label, self._dump_results(result._result))
+        msg = "fatal: [%s]: UNREACHABLE! => %s" % (host_label, self._dump_results(result.result))
         self._display.display(msg, color=C.COLOR_UNREACHABLE, stderr=self.get_option('display_failed_stderr'))
 
-        if result._task.ignore_unreachable:
+        if result.task.ignore_unreachable:
             self._display.display("...ignoring", color=C.COLOR_SKIP)
 
     def v2_playbook_on_no_hosts_matched(self):
@@ -222,29 +222,29 @@ class CallbackModule(CallbackBase):
 
         self._display.banner(msg)
 
-    def v2_on_file_diff(self, result):
-        if result._task.loop and 'results' in result._result:
-            for res in result._result['results']:
+    def v2_on_file_diff(self, result: CallbackTaskResult) -> None:
+        if result.task.loop and 'results' in result.result:
+            for res in result.result['results']:
                 if 'diff' in res and res['diff'] and res.get('changed', False):
                     diff = self._get_diff(res['diff'])
                     if diff:
-                        if self._last_task_banner != result._task._uuid:
-                            self._print_task_banner(result._task)
+                        if self._last_task_banner != result.task._uuid:
+                            self._print_task_banner(result.task)
                         self._display.display(diff)
-        elif 'diff' in result._result and result._result['diff'] and result._result.get('changed', False):
-            diff = self._get_diff(result._result['diff'])
+        elif 'diff' in result.result and result.result['diff'] and result.result.get('changed', False):
+            diff = self._get_diff(result.result['diff'])
             if diff:
-                if self._last_task_banner != result._task._uuid:
-                    self._print_task_banner(result._task)
+                if self._last_task_banner != result.task._uuid:
+                    self._print_task_banner(result.task)
                 self._display.display(diff)
 
-    def v2_runner_item_on_ok(self, result: TaskResult) -> None:
+    def v2_runner_item_on_ok(self, result: CallbackTaskResult) -> None:
         host_label = self.host_label(result)
-        if isinstance(result._task, TaskInclude):
+        if isinstance(result.task, TaskInclude):
             return
-        elif result._result.get('changed', False):
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+        elif result.result.get('changed', False):
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             msg = 'changed'
             color = C.COLOR_CHANGED
@@ -252,47 +252,47 @@ class CallbackModule(CallbackBase):
             if not self.get_option('display_ok_hosts'):
                 return
 
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             msg = 'ok'
             color = C.COLOR_OK
 
         self._handle_warnings_and_exception(result)
 
-        msg = "%s: [%s] => (item=%s)" % (msg, host_label, self._get_item_label(result._result))
-        self._clean_results(result._result, result._task.action)
+        msg = "%s: [%s] => (item=%s)" % (msg, host_label, self._get_item_label(result.result))
+        self._clean_results(result.result, result.task.action)
         if self._run_is_verbose(result):
-            msg += " => %s" % self._dump_results(result._result)
+            msg += " => %s" % self._dump_results(result.result)
         self._display.display(msg, color=color)
 
-    def v2_runner_item_on_failed(self, result: TaskResult) -> None:
-        if self._last_task_banner != result._task._uuid:
-            self._print_task_banner(result._task)
+    def v2_runner_item_on_failed(self, result: CallbackTaskResult) -> None:
+        if self._last_task_banner != result.task._uuid:
+            self._print_task_banner(result.task)
 
         self._handle_warnings_and_exception(result)
 
         host_label = self.host_label(result)
 
         msg = "failed: [%s]" % (host_label,)
-        self._clean_results(result._result, result._task.action)
+        self._clean_results(result.result, result.task.action)
         self._display.display(
-            msg + " (item=%s) => %s" % (self._get_item_label(result._result), self._dump_results(result._result)),
+            msg + " (item=%s) => %s" % (self._get_item_label(result.result), self._dump_results(result.result)),
             color=C.COLOR_ERROR,
             stderr=self.get_option('display_failed_stderr')
         )
 
-    def v2_runner_item_on_skipped(self, result: TaskResult) -> None:
+    def v2_runner_item_on_skipped(self, result: CallbackTaskResult) -> None:
         if self.get_option('display_skipped_hosts'):
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             self._handle_warnings_and_exception(result)
 
-            self._clean_results(result._result, result._task.action)
-            msg = "skipping: [%s] => (item=%s) " % (result._host.get_name(), self._get_item_label(result._result))
+            self._clean_results(result.result, result.task.action)
+            msg = "skipping: [%s] => (item=%s) " % (result.host.get_name(), self._get_item_label(result.result))
             if self._run_is_verbose(result):
-                msg += " => %s" % self._dump_results(result._result)
+                msg += " => %s" % self._dump_results(result.result)
             self._display.display(msg, color=C.COLOR_SKIP)
 
     def v2_playbook_on_include(self, included_file):
@@ -377,37 +377,37 @@ class CallbackModule(CallbackBase):
         if context.CLIARGS['check'] and self.get_option('check_mode_markers'):
             self._display.banner("DRY RUN")
 
-    def v2_runner_retry(self, result):
-        task_name = result.task_name or result._task
+    def v2_runner_retry(self, result: CallbackTaskResult) -> None:
+        task_name = result.task_name or result.task
         host_label = self.host_label(result)
-        msg = "FAILED - RETRYING: [%s]: %s (%d retries left)." % (host_label, task_name, result._result['retries'] - result._result['attempts'])
+        msg = "FAILED - RETRYING: [%s]: %s (%d retries left)." % (host_label, task_name, result.result['retries'] - result.result['attempts'])
         if self._run_is_verbose(result, verbosity=2):
-            msg += "Result was: %s" % self._dump_results(result._result)
+            msg += "Result was: %s" % self._dump_results(result.result)
         self._display.display(msg, color=C.COLOR_DEBUG)
 
-    def v2_runner_on_async_poll(self, result):
-        host = result._host.get_name()
-        jid = result._result.get('ansible_job_id')
-        started = result._result.get('started')
-        finished = result._result.get('finished')
+    def v2_runner_on_async_poll(self, result: CallbackTaskResult) -> None:
+        host = result.host.get_name()
+        jid = result.result.get('ansible_job_id')
+        started = result.result.get('started')
+        finished = result.result.get('finished')
         self._display.display(
             'ASYNC POLL on %s: jid=%s started=%s finished=%s' % (host, jid, started, finished),
             color=C.COLOR_DEBUG
         )
 
-    def v2_runner_on_async_ok(self, result):
-        host = result._host.get_name()
-        jid = result._result.get('ansible_job_id')
+    def v2_runner_on_async_ok(self, result: CallbackTaskResult) -> None:
+        host = result.host.get_name()
+        jid = result.result.get('ansible_job_id')
         self._display.display("ASYNC OK on %s: jid=%s" % (host, jid), color=C.COLOR_DEBUG)
 
-    def v2_runner_on_async_failed(self, result):
-        host = result._host.get_name()
+    def v2_runner_on_async_failed(self, result: CallbackTaskResult) -> None:
+        host = result.host.get_name()
 
         # Attempt to get the async job ID. If the job does not finish before the
         # async timeout value, the ID may be within the unparsed 'async_result' dict.
-        jid = result._result.get('ansible_job_id')
-        if not jid and 'async_result' in result._result:
-            jid = result._result['async_result'].get('ansible_job_id')
+        jid = result.result.get('ansible_job_id')
+        if not jid and 'async_result' in result.result:
+            jid = result.result['async_result'].get('ansible_job_id')
         self._display.display("ASYNC FAILED on %s: jid=%s" % (host, jid), color=C.COLOR_DEBUG)
 
     def v2_playbook_on_notify(self, handler, host):

ansible/plugins/callback/junit.py

@@ -86,12 +86,14 @@ import decimal
 import os
 import time
 import re
+import typing as t
 
 from ansible import constants
-from ansible.module_utils.common.messages import ErrorSummary
 from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.playbook.task import Task
 from ansible.plugins.callback import CallbackBase
+from ansible.executor.task_result import CallbackTaskResult
+from ansible.playbook.included_file import IncludedFile
 from ansible.utils._junit_xml import (
     TestCase,
     TestError,
@@ -184,23 +186,23 @@ class CallbackModule(CallbackBase):
 
         self._task_data[uuid] = TaskData(uuid, name, path, play, action)
 
-    def _finish_task(self, status, result):
+    def _finish_task(self, status: str, result: IncludedFile | CallbackTaskResult) -> None:
         """ record the results of a task for a single host """
 
-        task_uuid = result._task._uuid
+        if isinstance(result, CallbackTaskResult):
+            task_uuid = result.task._uuid
+            host_uuid = result.host._uuid
+            host_name = result.host.name
 
-        if hasattr(result, '_host'):
-            host_uuid = result._host._uuid
-            host_name = result._host.name
+            if self._fail_on_change == 'true' and status == 'ok' and result.result.get('changed', False):
+                status = 'failed'
         else:
+            task_uuid = result._task._uuid
             host_uuid = 'include'
             host_name = 'include'
 
         task_data = self._task_data[task_uuid]
 
-        if self._fail_on_change == 'true' and status == 'ok' and result._result.get('changed', False):
-            status = 'failed'
-
         # ignore failure if expected and toggle result if asked for
         if status == 'failed' and 'EXPECTED FAILURE' in task_data.name:
             status = 'ok'
@@ -233,7 +235,8 @@ class CallbackModule(CallbackBase):
         if host_data.status == 'included':
             return TestCase(name=name, classname=junit_classname, time=duration, system_out=str(host_data.result))
 
-        res = host_data.result._result
+        task_result = t.cast(CallbackTaskResult, host_data.result)
+        res = task_result.result
         rc = res.get('rc', 0)
         dump = self._dump_results(res, indent=0)
         dump = self._cleanse_string(dump)
@@ -243,10 +246,8 @@ class CallbackModule(CallbackBase):
 
         test_case = TestCase(name=name, classname=junit_classname, time=duration)
 
-        error_summary: ErrorSummary
-
         if host_data.status == 'failed':
-            if error_summary := res.get('exception'):
+            if error_summary := task_result.exception:
                 message = error_summary._format()
                 output = error_summary.formatted_traceback
                 test_case.errors.append(TestError(message=message, output=output))
@@ -309,19 +310,19 @@ class CallbackModule(CallbackBase):
     def v2_playbook_on_handler_task_start(self, task: Task) -> None:
         self._start_task(task)
 
-    def v2_runner_on_failed(self, result, ignore_errors=False):
+    def v2_runner_on_failed(self, result: CallbackTaskResult, ignore_errors=False) -> None:
         if ignore_errors and self._fail_on_ignore != 'true':
             self._finish_task('ok', result)
         else:
             self._finish_task('failed', result)
 
-    def v2_runner_on_ok(self, result):
+    def v2_runner_on_ok(self, result: CallbackTaskResult) -> None:
         self._finish_task('ok', result)
 
-    def v2_runner_on_skipped(self, result):
+    def v2_runner_on_skipped(self, result: CallbackTaskResult) -> None:
         self._finish_task('skipped', result)
 
-    def v2_playbook_on_include(self, included_file):
+    def v2_playbook_on_include(self, included_file: IncludedFile) -> None:
         self._finish_task('included', included_file)
 
     def v2_playbook_on_stats(self, stats):
@@ -347,7 +348,7 @@ class TaskData:
         if host.uuid in self.host_data:
             if host.status == 'included':
                 # concatenate task include output from multiple items
-                host.result = '%s\n%s' % (self.host_data[host.uuid].result, host.result)
+                host.result = f'{self.host_data[host.uuid].result}\n{host.result}'
             else:
                 raise Exception('%s: %s: %s: duplicate host callback: %s' % (self.path, self.play, self.name, host.name))
 
@@ -359,7 +360,7 @@ class HostData:
     Data about an individual host.
     """
 
-    def __init__(self, uuid, name, status, result):
+    def __init__(self, uuid: str, name: str, status: str, result: IncludedFile | CallbackTaskResult | str) -> None:
         self.uuid = uuid
         self.name = name
         self.status = status

ansible/plugins/callback/minimal.py

@@ -15,7 +15,7 @@ DOCUMENTATION = """
       - result_format_callback
 """
 
-from ansible.executor.task_result import TaskResult
+from ansible.executor.task_result import CallbackTaskResult
 from ansible.plugins.callback import CallbackBase
 from ansible import constants as C
 
@@ -41,41 +41,41 @@ class CallbackModule(CallbackBase):
 
         return buf + "\n"
 
-    def v2_runner_on_failed(self, result: TaskResult, ignore_errors: bool = False) -> None:
+    def v2_runner_on_failed(self, result: CallbackTaskResult, ignore_errors: bool = False) -> None:
         self._handle_warnings_and_exception(result)
 
-        if result._task.action in C.MODULE_NO_JSON and 'module_stderr' not in result._result:
-            self._display.display(self._command_generic_msg(result._host.get_name(), result._result, "FAILED"), color=C.COLOR_ERROR)
+        if result.task.action in C.MODULE_NO_JSON and 'module_stderr' not in result.result:
+            self._display.display(self._command_generic_msg(result.host.get_name(), result.result, "FAILED"), color=C.COLOR_ERROR)
         else:
-            self._display.display("%s | FAILED! => %s" % (result._host.get_name(), self._dump_results(result._result, indent=4)), color=C.COLOR_ERROR)
+            self._display.display("%s | FAILED! => %s" % (result.host.get_name(), self._dump_results(result.result, indent=4)), color=C.COLOR_ERROR)
 
-    def v2_runner_on_ok(self, result: TaskResult) -> None:
+    def v2_runner_on_ok(self, result: CallbackTaskResult) -> None:
         self._handle_warnings_and_exception(result)
 
-        self._clean_results(result._result, result._task.action)
+        self._clean_results(result.result, result.task.action)
 
-        if result._result.get('changed', False):
+        if result.result.get('changed', False):
             color = C.COLOR_CHANGED
             state = 'CHANGED'
         else:
             color = C.COLOR_OK
             state = 'SUCCESS'
 
-        if result._task.action in C.MODULE_NO_JSON and 'ansible_job_id' not in result._result:
-            self._display.display(self._command_generic_msg(result._host.get_name(), result._result, state), color=color)
+        if result.task.action in C.MODULE_NO_JSON and 'ansible_job_id' not in result.result:
+            self._display.display(self._command_generic_msg(result.host.get_name(), result.result, state), color=color)
         else:
-            self._display.display("%s | %s => %s" % (result._host.get_name(), state, self._dump_results(result._result, indent=4)), color=color)
+            self._display.display("%s | %s => %s" % (result.host.get_name(), state, self._dump_results(result.result, indent=4)), color=color)
 
-    def v2_runner_on_skipped(self, result: TaskResult) -> None:
+    def v2_runner_on_skipped(self, result: CallbackTaskResult) -> None:
         self._handle_warnings_and_exception(result)
 
-        self._display.display("%s | SKIPPED" % (result._host.get_name()), color=C.COLOR_SKIP)
+        self._display.display("%s | SKIPPED" % (result.host.get_name()), color=C.COLOR_SKIP)
 
-    def v2_runner_on_unreachable(self, result: TaskResult) -> None:
+    def v2_runner_on_unreachable(self, result: CallbackTaskResult) -> None:
         self._handle_warnings_and_exception(result)
 
-        self._display.display("%s | UNREACHABLE! => %s" % (result._host.get_name(), self._dump_results(result._result, indent=4)), color=C.COLOR_UNREACHABLE)
+        self._display.display("%s | UNREACHABLE! => %s" % (result.host.get_name(), self._dump_results(result.result, indent=4)), color=C.COLOR_UNREACHABLE)
 
     def v2_on_file_diff(self, result):
-        if 'diff' in result._result and result._result['diff']:
-            self._display.display(self._get_diff(result._result['diff']))
+        if 'diff' in result.result and result.result['diff']:
+            self._display.display(self._get_diff(result.result['diff']))

ansible/plugins/callback/oneline.py

@@ -16,6 +16,7 @@ DOCUMENTATION = """
 from ansible import constants as C
 from ansible.plugins.callback import CallbackBase
 from ansible.template import Templar
+from ansible.executor.task_result import CallbackTaskResult
 
 
 class CallbackModule(CallbackBase):
@@ -41,9 +42,9 @@ class CallbackModule(CallbackBase):
         else:
             return "%s | %s | rc=%s | (stdout) %s" % (hostname, caption, result.get('rc', -1), stdout)
 
-    def v2_runner_on_failed(self, result, ignore_errors=False):
-        if 'exception' in result._result:
-            error_text = Templar().template(result._result['exception'])  # transform to a string
+    def v2_runner_on_failed(self, result: CallbackTaskResult, ignore_errors: bool = False) -> None:
+        if 'exception' in result.result:
+            error_text = Templar().template(result.result['exception'])  # transform to a string
             if self._display.verbosity < 3:
                 # extract just the actual error message from the exception text
                 error = error_text.strip().split('\n')[-1]
@@ -51,31 +52,31 @@ class CallbackModule(CallbackBase):
             else:
                 msg = "An exception occurred during task execution. The full traceback is:\n" + error_text.replace('\n', '')
 
-            if result._task.action in C.MODULE_NO_JSON and 'module_stderr' not in result._result:
-                self._display.display(self._command_generic_msg(result._host.get_name(), result._result, 'FAILED'), color=C.COLOR_ERROR)
+            if result.task.action in C.MODULE_NO_JSON and 'module_stderr' not in result.result:
+                self._display.display(self._command_generic_msg(result.host.get_name(), result.result, 'FAILED'), color=C.COLOR_ERROR)
             else:
                 self._display.display(msg, color=C.COLOR_ERROR)
 
-        self._display.display("%s | FAILED! => %s" % (result._host.get_name(), self._dump_results(result._result, indent=0).replace('\n', '')),
+        self._display.display("%s | FAILED! => %s" % (result.host.get_name(), self._dump_results(result.result, indent=0).replace('\n', '')),
                               color=C.COLOR_ERROR)
 
-    def v2_runner_on_ok(self, result):
+    def v2_runner_on_ok(self, result: CallbackTaskResult) -> None:
 
-        if result._result.get('changed', False):
+        if result.result.get('changed', False):
             color = C.COLOR_CHANGED
             state = 'CHANGED'
         else:
             color = C.COLOR_OK
             state = 'SUCCESS'
 
-        if result._task.action in C.MODULE_NO_JSON and 'ansible_job_id' not in result._result:
-            self._display.display(self._command_generic_msg(result._host.get_name(), result._result, state), color=color)
+        if result.task.action in C.MODULE_NO_JSON and 'ansible_job_id' not in result.result:
+            self._display.display(self._command_generic_msg(result.host.get_name(), result.result, state), color=color)
         else:
-            self._display.display("%s | %s => %s" % (result._host.get_name(), state, self._dump_results(result._result, indent=0).replace('\n', '')),
+            self._display.display("%s | %s => %s" % (result.host.get_name(), state, self._dump_results(result.result, indent=0).replace('\n', '')),
                                   color=color)
 
-    def v2_runner_on_unreachable(self, result):
-        self._display.display("%s | UNREACHABLE!: %s" % (result._host.get_name(), result._result.get('msg', '')), color=C.COLOR_UNREACHABLE)
+    def v2_runner_on_unreachable(self, result: CallbackTaskResult) -> None:
+        self._display.display("%s | UNREACHABLE!: %s" % (result.host.get_name(), result.result.get('msg', '')), color=C.COLOR_UNREACHABLE)
 
-    def v2_runner_on_skipped(self, result):
-        self._display.display("%s | SKIPPED" % (result._host.get_name()), color=C.COLOR_SKIP)
+    def v2_runner_on_skipped(self, result: CallbackTaskResult) -> None:
+        self._display.display("%s | SKIPPED" % (result.host.get_name()), color=C.COLOR_SKIP)

ansible/plugins/callback/tree.py

@@ -30,6 +30,7 @@ DOCUMENTATION = """
 import os
 
 from ansible.constants import TREE_DIR
+from ansible.executor.task_result import CallbackTaskResult
 from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.plugins.callback import CallbackBase
 from ansible.utils.path import makedirs_safe, unfrackpath
@@ -76,14 +77,14 @@ class CallbackModule(CallbackBase):
         except (OSError, IOError) as e:
             self._display.warning(u"Unable to write to %s's file: %s" % (hostname, to_text(e)))
 
-    def result_to_tree(self, result):
-        self.write_tree_file(result._host.get_name(), self._dump_results(result._result))
+    def result_to_tree(self, result: CallbackTaskResult) -> None:
+        self.write_tree_file(result.host.get_name(), self._dump_results(result.result))
 
-    def v2_runner_on_ok(self, result):
+    def v2_runner_on_ok(self, result: CallbackTaskResult) -> None:
         self.result_to_tree(result)
 
-    def v2_runner_on_failed(self, result, ignore_errors=False):
+    def v2_runner_on_failed(self, result: CallbackTaskResult, ignore_errors: bool = False) -> None:
         self.result_to_tree(result)
 
-    def v2_runner_on_unreachable(self, result):
+    def v2_runner_on_unreachable(self, result: CallbackTaskResult) -> None:
         self.result_to_tree(result)

ansible/plugins/filter/core.py

@@ -26,7 +26,7 @@ from jinja2.filters import do_map, do_select, do_selectattr, do_reject, do_rejec
 from jinja2.environment import Environment
 
 from ansible._internal._templating import _lazy_containers
-from ansible.errors import AnsibleFilterError, AnsibleTypeError
+from ansible.errors import AnsibleFilterError, AnsibleTypeError, AnsibleTemplatePluginError
 from ansible.module_utils.datatag import native_type_name
 from ansible.module_utils.common.json import get_encoder, get_decoder
 from ansible.module_utils.six import string_types, integer_types, text_type
@@ -405,6 +405,13 @@ def comment(text, style='plain', **kw):
         }
     }
 
+    if style not in comment_styles:
+        raise AnsibleTemplatePluginError(
+            message=f"Invalid style {style!r}.",
+            help_text=f"Available styles: {', '.join(comment_styles)}",
+            obj=style,
+        )
+
     # Pointer to the right comment type
     style_params = comment_styles[style]