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

ansible/executor/task_queue_manager.py

@@ -17,6 +17,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 import os
 import sys
 import tempfile
@@ -31,7 +32,7 @@ from ansible.errors import AnsibleError, ExitCode, AnsibleCallbackError
 from ansible._internal._errors._handler import ErrorHandler
 from ansible.executor.play_iterator import PlayIterator
 from ansible.executor.stats import AggregateStats
-from ansible.executor.task_result import TaskResult
+from ansible.executor.task_result import _RawTaskResult, _WireTaskResult
 from ansible.inventory.data import InventoryData
 from ansible.module_utils.six import string_types
 from ansible.module_utils.common.text.converters import to_native
@@ -47,7 +48,8 @@ from ansible.utils.display import Display
 from ansible.utils.lock import lock_decorator
 from ansible.utils.multiprocessing import context as multiprocessing_context
 
-from dataclasses import dataclass
+if t.TYPE_CHECKING:
+    from ansible.executor.process.worker import WorkerProcess
 
 __all__ = ['TaskQueueManager']
 
@@ -57,12 +59,13 @@ STDERR_FILENO = 2
 
 display = Display()
 
+_T = t.TypeVar('_T')
 
+
+@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
 class CallbackSend:
-    def __init__(self, method_name, *args, **kwargs):
-        self.method_name = method_name
-        self.args = args
-        self.kwargs = kwargs
+    method_name: str
+    wire_task_result: _WireTaskResult
 
 
 class DisplaySend:
@@ -72,7 +75,7 @@ class DisplaySend:
         self.kwargs = kwargs
 
 
-@dataclass
+@dataclasses.dataclass
 class PromptSend:
     worker_id: int
     prompt: str
@@ -87,19 +90,11 @@ class FinalQueue(multiprocessing.queues.SimpleQueue):
         kwargs['ctx'] = multiprocessing_context
         super().__init__(*args, **kwargs)
 
-    def send_callback(self, method_name, *args, **kwargs):
-        self.put(
-            CallbackSend(method_name, *args, **kwargs),
-        )
+    def send_callback(self, method_name: str, task_result: _RawTaskResult) -> None:
+        self.put(CallbackSend(method_name=method_name, wire_task_result=task_result.as_wire_task_result()))
 
-    def send_task_result(self, *args, **kwargs):
-        if isinstance(args[0], TaskResult):
-            tr = args[0]
-        else:
-            tr = TaskResult(*args, **kwargs)
-        self.put(
-            tr,
-        )
+    def send_task_result(self, task_result: _RawTaskResult) -> None:
+        self.put(task_result.as_wire_task_result())
 
     def send_display(self, method, *args, **kwargs):
         self.put(
@@ -194,11 +189,8 @@ class TaskQueueManager:
         # plugins for inter-process locking.
         self._connection_lockfile = tempfile.TemporaryFile()
 
-    def _initialize_processes(self, num):
-        self._workers = []
-
-        for i in range(num):
-            self._workers.append(None)
+    def _initialize_processes(self, num: int) -> None:
+        self._workers: list[WorkerProcess | None] = [None] * num
 
     def load_callbacks(self):
         """
@@ -438,54 +430,72 @@ class TaskQueueManager:
                 defunct = True
         return defunct
 
+    @staticmethod
+    def _first_arg_of_type(value_type: t.Type[_T], args: t.Sequence) -> _T | None:
+        return next((arg for arg in args if isinstance(arg, value_type)), None)
+
     @lock_decorator(attr='_callback_lock')
     def send_callback(self, method_name, *args, **kwargs):
         # We always send events to stdout callback first, rest should follow config order
         for callback_plugin in [self._stdout_callback] + self._callback_plugins:
             # a plugin that set self.disabled to True will not be called
             # see osx_say.py example for such a plugin
-            if getattr(callback_plugin, 'disabled', False):
+            if callback_plugin.disabled:
                 continue
 
             # a plugin can opt in to implicit tasks (such as meta). It does this
             # by declaring self.wants_implicit_tasks = True.
-            wants_implicit_tasks = getattr(callback_plugin, 'wants_implicit_tasks', False)
+            if not callback_plugin.wants_implicit_tasks and (task_arg := self._first_arg_of_type(Task, args)) and task_arg.implicit:
+                continue
 
             # try to find v2 method, fallback to v1 method, ignore callback if no method found
             methods = []
+
             for possible in [method_name, 'v2_on_any']:
-                gotit = getattr(callback_plugin, possible, None)
-                if gotit is None:
-                    gotit = getattr(callback_plugin, possible.removeprefix('v2_'), None)
-                if gotit is not None:
-                    methods.append(gotit)
-
-            # send clean copies
-            new_args = []
-
-            # If we end up being given an implicit task, we'll set this flag in
-            # the loop below. If the plugin doesn't care about those, then we
-            # check and continue to the next iteration of the outer loop.
-            is_implicit_task = False
-
-            for arg in args:
-                # FIXME: add play/task cleaners
-                if isinstance(arg, TaskResult):
-                    new_args.append(arg.clean_copy())
-                # elif isinstance(arg, Play):
-                # elif isinstance(arg, Task):
-                else:
-                    new_args.append(arg)
+                method = getattr(callback_plugin, possible, None)
 
-                if isinstance(arg, Task) and arg.implicit:
-                    is_implicit_task = True
+                if method is None:
+                    method = getattr(callback_plugin, possible.removeprefix('v2_'), None)
 
-            if is_implicit_task and not wants_implicit_tasks:
-                continue
+                    if method is not None:
+                        display.deprecated(
+                            msg='The v1 callback API is deprecated.',
+                            version='2.23',
+                            help_text='Use `v2_` prefixed callback methods instead.',
+                        )
+
+                if method is not None and not getattr(method, '_base_impl', False):  # don't bother dispatching to the base impls
+                    if possible == 'v2_on_any':
+                        display.deprecated(
+                            msg='The `v2_on_any` callback method is deprecated.',
+                            version='2.23',
+                            help_text='Use event-specific callback methods instead.',
+                        )
+
+                    methods.append(method)
 
             for method in methods:
+                # send clean copies
+                new_args = []
+
+                for arg in args:
+                    # FIXME: add play/task cleaners
+                    if isinstance(arg, _RawTaskResult):
+                        copied_tr = arg.as_callback_task_result()
+                        new_args.append(copied_tr)
+                        # this state hack requires that no callback ever accepts > 1 TaskResult object
+                        callback_plugin._current_task_result = copied_tr
+                    else:
+                        new_args.append(arg)
+
                 with self._callback_dispatch_error_handler.handle(AnsibleCallbackError):
                     try:
                         method(*new_args, **kwargs)
+                    except AssertionError:
+                        # Using an `assert` in integration tests is useful.
+                        # Production code should never use `assert` or raise `AssertionError`.
+                        raise
                     except Exception as ex:
                         raise AnsibleCallbackError(f"Callback dispatch {method_name!r} failed for plugin {callback_plugin._load_name!r}.") from ex
+
+            callback_plugin._current_task_result = None

ansible/executor/task_result.py

@@ -4,15 +4,24 @@
 
 from __future__ import annotations
 
+import collections.abc as _c
+import dataclasses
+import functools
 import typing as t
 
-from ansible import constants as C
-from ansible.parsing.dataloader import DataLoader
+from ansible import constants
+from ansible.utils import vars as _vars
 from ansible.vars.clean import module_response_deepcopy, strip_internal_keys
+from ansible.module_utils.common import messages as _messages
+from ansible._internal import _collection_proxy
+
+if t.TYPE_CHECKING:
+    from ansible.inventory.host import Host
+    from ansible.playbook.task import Task
 
 _IGNORE = ('failed', 'skipped')
-_PRESERVE = ('attempts', 'changed', 'retries', '_ansible_no_log')
-_SUB_PRESERVE = {'_ansible_delegated_vars': ('ansible_host', 'ansible_port', 'ansible_user', 'ansible_connection')}
+_PRESERVE = {'attempts', 'changed', 'retries', '_ansible_no_log'}
+_SUB_PRESERVE = {'_ansible_delegated_vars': {'ansible_host', 'ansible_port', 'ansible_user', 'ansible_connection'}}
 
 # stuff callbacks need
 CLEAN_EXCEPTIONS = (
@@ -23,61 +32,120 @@ CLEAN_EXCEPTIONS = (
 )
 
 
-class TaskResult:
+@t.final
+@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
+class _WireTaskResult:
+    """A thin version of `_RawTaskResult` which can be sent over the worker queue."""
+
+    host_name: str
+    task_uuid: str
+    return_data: _c.MutableMapping[str, object]
+    task_fields: _c.Mapping[str, object]
+
+
+class _BaseTaskResult:
     """
     This class is responsible for interpreting the resulting data
     from an executed task, and provides helper methods for determining
     the result of a given task.
     """
 
-    def __init__(self, host, task, return_data, task_fields=None):
-        self._host = host
-        self._task = task
+    def __init__(self, host: Host, task: Task, return_data: _c.MutableMapping[str, t.Any], task_fields: _c.Mapping[str, t.Any]) -> None:
+        self.__host = host
+        self.__task = task
+        self._return_data = return_data  # FIXME: this should be immutable, but strategy result processing mutates it in some corner cases
+        self.__task_fields = task_fields
 
-        if isinstance(return_data, dict):
-            self._result = return_data.copy()
-        else:
-            self._result = DataLoader().load(return_data)
+    @property
+    def host(self) -> Host:
+        """The host associated with this result."""
+        return self.__host
 
-        if task_fields is None:
-            self._task_fields = dict()
-        else:
-            self._task_fields = task_fields
+    @property
+    def _host(self) -> Host:
+        """Use the `host` property when supporting only ansible-core 2.19 or later."""
+        # deprecated: description='Deprecate `_host` in favor of `host`' core_version='2.23'
+        return self.__host
+
+    @property
+    def task(self) -> Task:
+        """The task associated with this result."""
+        return self.__task
+
+    @property
+    def _task(self) -> Task:
+        """Use the `task` property when supporting only ansible-core 2.19 or later."""
+        # deprecated: description='Deprecate `_task` in favor of `task`' core_version='2.23'
+        return self.__task
+
+    @property
+    def task_fields(self) -> _c.Mapping[str, t.Any]:
+        """The task fields associated with this result."""
+        return self.__task_fields
+
+    @property
+    def _task_fields(self) -> _c.Mapping[str, t.Any]:
+        """Use the `task_fields` property when supporting only ansible-core 2.19 or later."""
+        # deprecated: description='Deprecate `_task_fields` in favor of `task`' core_version='2.23'
+        return self.__task_fields
+
+    @property
+    def exception(self) -> _messages.ErrorSummary | None:
+        """The error from this task result, if any."""
+        return self._return_data.get('exception')
+
+    @property
+    def warnings(self) -> _c.Sequence[_messages.WarningSummary]:
+        """The warnings for this task, if any."""
+        return _collection_proxy.SequenceProxy(self._return_data.get('warnings') or [])
+
+    @property
+    def deprecations(self) -> _c.Sequence[_messages.DeprecationSummary]:
+        """The deprecation warnings for this task, if any."""
+        return _collection_proxy.SequenceProxy(self._return_data.get('deprecations') or [])
+
+    @property
+    def _loop_results(self) -> list[_c.MutableMapping[str, t.Any]]:
+        """Return a list of loop results. If no loop results are present, an empty list is returned."""
+        results = self._return_data.get('results')
+
+        if not isinstance(results, list):
+            return []
+
+        return results
 
     @property
-    def task_name(self):
-        return self._task_fields.get('name', None) or self._task.get_name()
+    def task_name(self) -> str:
+        return str(self.task_fields.get('name', '')) or self.task.get_name()
 
-    def is_changed(self):
+    def is_changed(self) -> bool:
         return self._check_key('changed')
 
-    def is_skipped(self):
-        # loop results
-        if 'results' in self._result:
-            results = self._result['results']
+    def is_skipped(self) -> bool:
+        if self._loop_results:
             # Loop tasks are only considered skipped if all items were skipped.
             # some squashed results (eg, dnf) are not dicts and can't be skipped individually
-            if results and all(isinstance(res, dict) and res.get('skipped', False) for res in results):
+            if all(isinstance(loop_res, dict) and loop_res.get('skipped', False) for loop_res in self._loop_results):
                 return True
 
         # regular tasks and squashed non-dict results
-        return self._result.get('skipped', False)
+        return bool(self._return_data.get('skipped', False))
 
-    def is_failed(self):
-        if 'failed_when_result' in self._result or \
-           'results' in self._result and True in [True for x in self._result['results'] if 'failed_when_result' in x]:
+    def is_failed(self) -> bool:
+        if 'failed_when_result' in self._return_data or any(isinstance(loop_res, dict) and 'failed_when_result' in loop_res for loop_res in self._loop_results):
             return self._check_key('failed_when_result')
-        else:
-            return self._check_key('failed')
 
-    def is_unreachable(self):
+        return self._check_key('failed')
+
+    def is_unreachable(self) -> bool:
         return self._check_key('unreachable')
 
-    def needs_debugger(self, globally_enabled=False):
-        _debugger = self._task_fields.get('debugger')
-        _ignore_errors = C.TASK_DEBUGGER_IGNORE_ERRORS and self._task_fields.get('ignore_errors')
+    def needs_debugger(self, globally_enabled: bool = False) -> bool:
+        _debugger = self.task_fields.get('debugger')
+        _ignore_errors = constants.TASK_DEBUGGER_IGNORE_ERRORS and self.task_fields.get('ignore_errors')
 
         ret = False
+
         if globally_enabled and ((self.is_failed() and not _ignore_errors) or self.is_unreachable()):
             ret = True
 
@@ -94,68 +162,96 @@ class TaskResult:
 
         return ret
 
-    def _check_key(self, key):
-        """get a specific key from the result or its items"""
+    def _check_key(self, key: str) -> bool:
+        """Fetch a specific named boolean value from the result; if missing, a logical OR of the value from nested loop results; False for non-loop results."""
+        if (value := self._return_data.get(key, ...)) is not ...:
+            return bool(value)
 
-        if isinstance(self._result, dict) and key in self._result:
-            return self._result.get(key, False)
-        else:
-            flag = False
-            for res in self._result.get('results', []):
-                if isinstance(res, dict):
-                    flag |= res.get(key, False)
-            return flag
+        return any(isinstance(result, dict) and result.get(key) for result in self._loop_results)
 
-    def clean_copy(self):
 
-        """ returns 'clean' taskresult object """
+@t.final
+class _RawTaskResult(_BaseTaskResult):
+    def as_wire_task_result(self) -> _WireTaskResult:
+        """Return a `_WireTaskResult` from this instance."""
+        return _WireTaskResult(
+            host_name=self.host.name,
+            task_uuid=self.task._uuid,
+            return_data=self._return_data,
+            task_fields=self.task_fields,
+        )
 
-        # FIXME: clean task_fields, _task and _host copies
-        result = TaskResult(self._host, self._task, {}, self._task_fields)
+    def as_callback_task_result(self) -> CallbackTaskResult:
+        """Return a `CallbackTaskResult` from this instance."""
+        ignore: tuple[str, ...]
 
         # statuses are already reflected on the event type
-        if result._task and result._task.action in C._ACTION_DEBUG:
+        if self.task and self.task.action in constants._ACTION_DEBUG:
             # debug is verbose by default to display vars, no need to add invocation
             ignore = _IGNORE + ('invocation',)
         else:
             ignore = _IGNORE
 
-        subset = {}
+        subset: dict[str, dict[str, object]] = {}
+
         # preserve subset for later
-        for sub in _SUB_PRESERVE:
-            if sub in self._result:
-                subset[sub] = {}
-                for key in _SUB_PRESERVE[sub]:
-                    if key in self._result[sub]:
-                        subset[sub][key] = self._result[sub][key]
+        for sub, sub_keys in _SUB_PRESERVE.items():
+            sub_data = self._return_data.get(sub)
+
+            if isinstance(sub_data, dict):
+                subset[sub] = {key: value for key, value in sub_data.items() if key in sub_keys}
 
         # DTFIX-FUTURE: is checking no_log here redundant now that we use _ansible_no_log everywhere?
-        if isinstance(self._task.no_log, bool) and self._task.no_log or self._result.get('_ansible_no_log'):
-            censored_result = censor_result(self._result)
+        if isinstance(self.task.no_log, bool) and self.task.no_log or self._return_data.get('_ansible_no_log'):
+            censored_result = censor_result(self._return_data)
 
-            if results := self._result.get('results'):
+            if self._loop_results:
                 # maintain shape for loop results so callback behavior recognizes a loop was performed
-                censored_result.update(results=[censor_result(item) if item.get('_ansible_no_log') else item for item in results])
+                censored_result.update(results=[
+                    censor_result(loop_res) if isinstance(loop_res, dict) and loop_res.get('_ansible_no_log') else loop_res for loop_res in self._loop_results
+                ])
 
-            result._result = censored_result
-        elif self._result:
-            result._result = module_response_deepcopy(self._result)
-
-            # actually remove
-            for remove_key in ignore:
-                if remove_key in result._result:
-                    del result._result[remove_key]
+            return_data = censored_result
+        elif self._return_data:
+            return_data = {k: v for k, v in module_response_deepcopy(self._return_data).items() if k not in ignore}
 
             # remove almost ALL internal keys, keep ones relevant to callback
-            strip_internal_keys(result._result, exceptions=CLEAN_EXCEPTIONS)
+            strip_internal_keys(return_data, exceptions=CLEAN_EXCEPTIONS)
+        else:
+            return_data = {}
 
         # keep subset
-        result._result.update(subset)
+        return_data.update(subset)
+
+        return CallbackTaskResult(self.host, self.task, return_data, self.task_fields)
+
+
+@t.final
+class CallbackTaskResult(_BaseTaskResult):
+    """Public contract of TaskResult """
+
+    # DTFIX-RELEASE: find a better home for this since it's public API
+
+    @property
+    def _result(self) -> _c.MutableMapping[str, t.Any]:
+        """Use the `result` property when supporting only ansible-core 2.19 or later."""
+        # deprecated: description='Deprecate `_result` in favor of `result`' core_version='2.23'
+        return self.result
+
+    @functools.cached_property
+    def result(self) -> _c.MutableMapping[str, t.Any]:
+        """
+        Returns a cached copy of the task result dictionary for consumption by callbacks.
+        Internal custom types are transformed to native Python types to facilitate access and serialization.
+        """
+        return t.cast(_c.MutableMapping[str, t.Any], _vars.transform_to_native_types(self._return_data))
+
 
-        return result
+TaskResult = CallbackTaskResult
+"""Compatibility name for the pre-2.19 callback-shaped TaskResult passed to callbacks."""
 
 
-def censor_result(result: dict[str, t.Any]) -> dict[str, t.Any]:
+def censor_result(result: _c.Mapping[str, t.Any]) -> dict[str, t.Any]:
     censored_result = {key: value for key in _PRESERVE if (value := result.get(key, ...)) is not ...}
     censored_result.update(censored="the output has been hidden due to the fact that 'no_log: true' was specified for this result")
 

ansible/inventory/manager.py

@@ -30,6 +30,7 @@ from random import shuffle
 
 from ansible import constants as C
 from ansible._internal import _json, _wrapt
+from ansible._internal._json import EncryptedStringBehavior
 from ansible.errors import AnsibleError, AnsibleOptionsError
 from ansible.inventory.data import InventoryData
 from ansible.module_utils.six import string_types
@@ -787,7 +788,7 @@ class _InventoryDataWrapper(_wrapt.ObjectProxy):
         return _json.AnsibleVariableVisitor(
             trusted_as_template=self._target_plugin.trusted_by_default,
             origin=self._default_origin,
-            allow_encrypted_string=True,
+            encrypted_string_behavior=EncryptedStringBehavior.PRESERVE,
         )
 
     def set_variable(self, entity: str, varname: str, value: t.Any) -> None:

ansible/module_utils/ansible_release.py

@@ -17,6 +17,6 @@
 
 from __future__ import annotations
 
-__version__ = '2.19.0b1'
+__version__ = '2.19.0b2'
 __author__ = 'Ansible, Inc.'
 __codename__ = "What Is and What Should Never Be"

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
@@ -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
@@ -1459,7 +1457,7 @@ class AnsibleModule(object):
         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.
@@ -1498,7 +1496,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/warnings.py

@@ -11,7 +11,7 @@ from ansible.module_utils._internal import _traceback, _plugin_exec_context
 from ansible.module_utils.common import messages as _messages
 from ansible.module_utils import _internal
 
-_UNSET = _t.cast(_t.Any, ...)
+_UNSET = _t.cast(_t.Any, object())
 
 
 def warn(warning: str) -> None:

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))