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

ansible/module_utils/_internal/_plugin_info.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import typing as t
+
+from ..common import messages as _messages
+
+
+class HasPluginInfo(t.Protocol):
+    """Protocol to type-annotate and expose PluginLoader-set values."""
+
+    @property
+    def ansible_name(self) -> str | None:
+        """Fully resolved plugin name."""
+
+    @property
+    def plugin_type(self) -> str:
+        """Plugin type name."""
+
+
+def get_plugin_info(value: HasPluginInfo) -> _messages.PluginInfo:
+    """Utility method that returns a `PluginInfo` from an object implementing the `HasPluginInfo` protocol."""
+    return _messages.PluginInfo(
+        resolved_name=value.ansible_name,
+        type=value.plugin_type,
+    )

ansible/module_utils/_internal/_validation.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import keyword
+
+
+def validate_collection_name(collection_name: object, name: str = 'collection_name') -> None:
+    """Validate a collection name."""
+    if not isinstance(collection_name, str):
+        raise TypeError(f"{name} must be {str} instead of {type(collection_name)}")
+
+    parts = collection_name.split('.')
+
+    if len(parts) != 2 or not all(part.isidentifier() and not keyword.iskeyword(part) for part in parts):
+        raise ValueError(f"{name} must consist of two non-keyword identifiers separated by '.'")

ansible/module_utils/ansible_release.py

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

ansible/module_utils/basic.py

@@ -75,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,
@@ -509,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):
         """
@@ -1404,6 +1419,7 @@ class AnsibleModule(object):
             self.cleanup(path)
 
     def _return_formatted(self, kwargs):
+        _skip_stackwalk = True
 
         self.add_path_info(kwargs)
 
@@ -1411,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)
@@ -1422,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:
@@ -1452,6 +1496,7 @@ 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)
@@ -1473,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(

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, object())
-
 
 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/playbook/task.py

@@ -227,8 +227,6 @@ class Task(Base, Conditional, Taggable, CollectionSearch, Notifiable, Delegatabl
             raise AnsibleError("you must specify a value when using %s" % k, obj=ds)
         new_ds['loop_with'] = loop_name
         new_ds['loop'] = v
-        # display.deprecated("with_ type loops are being phased out, use the 'loop' keyword instead",
-        #                    version="2.10", collection_name='ansible.builtin')
 
     def preprocess_data(self, ds):
         """

ansible/plugins/__init__.py

@@ -20,24 +20,26 @@
 from __future__ import annotations
 
 import abc
+import functools
 import types
 import typing as t
 
 from ansible import constants as C
 from ansible.errors import AnsibleError
 from ansible.utils.display import Display
+from ansible.utils import display as _display
 
-from ansible.module_utils._internal import _plugin_exec_context
+from ansible.module_utils._internal import _plugin_info
 
 display = Display()
 
 if t.TYPE_CHECKING:
-    from .loader import PluginPathContext
+    from . import loader as _t_loader
 
 # Global so that all instances of a PluginLoader will share the caches
 MODULE_CACHE = {}  # type: dict[str, dict[str, types.ModuleType]]
-PATH_CACHE = {}  # type: dict[str, list[PluginPathContext] | None]
-PLUGIN_PATH_CACHE = {}  # type: dict[str, dict[str, dict[str, PluginPathContext]]]
+PATH_CACHE = {}  # type: dict[str, list[_t_loader.PluginPathContext] | None]
+PLUGIN_PATH_CACHE = {}  # type: dict[str, dict[str, dict[str, _t_loader.PluginPathContext]]]
 
 
 def get_plugin_class(obj):
@@ -50,10 +52,10 @@ def get_plugin_class(obj):
 class _ConfigurablePlugin(t.Protocol):
     """Protocol to provide type-safe access to config for plugin-related mixins."""
 
-    def get_option(self, option: str, hostvars: dict[str, object] | None = None) -> object: ...
+    def get_option(self, option: str, hostvars: dict[str, object] | None = None) -> t.Any: ...
 
 
-class _AnsiblePluginInfoMixin(_plugin_exec_context.HasPluginInfo):
+class _AnsiblePluginInfoMixin(_plugin_info.HasPluginInfo):
     """Mixin to provide type annotations and default values for existing PluginLoader-set load-time attrs."""
     _original_path: str | None = None
     _load_name: str | None = None
@@ -102,6 +104,14 @@ class AnsiblePlugin(_AnsiblePluginInfoMixin, _ConfigurablePlugin, metaclass=abc.
             raise KeyError(str(e))
         return option_value, origin
 
+    @functools.cached_property
+    def __plugin_info(self):
+        """
+        Internal cached property to retrieve `PluginInfo` for this plugin instance.
+        Only for use by the `AnsiblePlugin` base class.
+        """
+        return _plugin_info.get_plugin_info(self)
+
     def get_option(self, option, hostvars=None):
 
         if option not in self._options:
@@ -117,7 +127,7 @@ class AnsiblePlugin(_AnsiblePluginInfoMixin, _ConfigurablePlugin, metaclass=abc.
 
     def set_option(self, option, value):
         self._options[option] = C.config.get_config_value(option, plugin_type=self.plugin_type, plugin_name=self._load_name, direct={option: value})
-        C.handle_config_noise(display)
+        _display._report_config_warnings(self.__plugin_info)
 
     def set_options(self, task_keys=None, var_options=None, direct=None):
         """
@@ -134,7 +144,7 @@ class AnsiblePlugin(_AnsiblePluginInfoMixin, _ConfigurablePlugin, metaclass=abc.
         if self.allow_extras and var_options and '_extras' in var_options:
             # these are largely unvalidated passthroughs, either plugin or underlying API will validate
             self._options['_extras'] = var_options['_extras']
-        C.handle_config_noise(display)
+        _display._report_config_warnings(self.__plugin_info)
 
     def has_option(self, option):
         if not self._options:

ansible/plugins/action/__init__.py

@@ -318,13 +318,6 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
         final_environment: dict[str, t.Any] = {}
         self._compute_environment_string(final_environment)
 
-        # `modify_module` adapts PluginInfo to allow target-side use of `PluginExecContext` since modules aren't plugins
-        plugin = PluginInfo(
-            requested_name=module_name,
-            resolved_name=result.resolved_fqcn,
-            type='module',
-        )
-
         # modify_module will exit early if interpreter discovery is required; re-run after if necessary
         for _dummy in (1, 2):
             try:
@@ -338,7 +331,6 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
                     async_timeout=self._task.async_val,
                     environment=final_environment,
                     remote_is_local=bool(getattr(self._connection, '_remote_is_local', False)),
-                    plugin=plugin,
                     become_plugin=self._connection.become,
                 )
 
@@ -649,12 +641,12 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
         # done. Make the files +x if we're asked to, and return.
         if not self._is_become_unprivileged():
             if execute:
-                # Can't depend on the file being transferred with execute permissions.
+                # Can't depend on the file being transferred with required permissions.
                 # Only need user perms because no become was used here
-                res = self._remote_chmod(remote_paths, 'u+x')
+                res = self._remote_chmod(remote_paths, 'u+rwx')
                 if res['rc'] != 0:
                     raise AnsibleError(
-                        'Failed to set execute bit on remote files '
+                        'Failed to set permissions on remote files '
                         '(rc: {0}, err: {1})'.format(
                             res['rc'],
                             to_native(res['stderr'])))
@@ -695,10 +687,10 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
             return remote_paths
 
         # Step 3b: Set execute if we need to. We do this before anything else
-        # because some of the methods below might work but not let us set +x
-        # as part of them.
+        # because some of the methods below might work but not let us set
+        # permissions as part of them.
         if execute:
-            res = self._remote_chmod(remote_paths, 'u+x')
+            res = self._remote_chmod(remote_paths, 'u+rwx')
             if res['rc'] != 0:
                 raise AnsibleError(
                     'Failed to set file mode or acl on remote temporary files '