ansible-core 2.19.0b6__py3-none-any.whl → 2.19.0rc1__py3-none-any.whl

ansible/modules/assemble.py

@@ -80,7 +80,7 @@ attributes:
     bypass_host_loop:
       support: none
     check_mode:
-      support: none
+      support: full
     diff_mode:
       support: full
     platform:
@@ -212,6 +212,7 @@ def main():
             decrypt=dict(type='bool', default=True),
         ),
         add_file_common_args=True,
+        supports_check_mode=True,
     )
 
     changed = False
@@ -266,12 +267,13 @@ def main():
         if backup and dest_hash is not None:
             result['backup_file'] = module.backup_local(dest)
 
-        module.atomic_move(path, dest, unsafe_writes=module.params['unsafe_writes'])
+        if not module.check_mode:
+            module.atomic_move(path, dest, unsafe_writes=module.params['unsafe_writes'])
         changed = True
 
     cleanup(module, path, result)
 
-    # handle file permissions
+    # handle file permissions (check mode aware)
     file_args = module.load_file_common_arguments(module.params)
     result['changed'] = module.set_fs_attributes_if_different(file_args, changed)
 

ansible/modules/expect.py

@@ -218,7 +218,7 @@ def main():
                 rc=0
             )
 
-    startd = datetime.datetime.now()
+    start_date = datetime.datetime.now()
 
     try:
         try:
@@ -246,8 +246,8 @@ def main():
     except pexpect.ExceptionPexpect as e:
         module.fail_json(msg='%s' % to_native(e))
 
-    endd = datetime.datetime.now()
-    delta = endd - startd
+    end_date = datetime.datetime.now()
+    delta = end_date - start_date
 
     if b_out is None:
         b_out = b''
@@ -256,8 +256,8 @@ def main():
         cmd=args,
         stdout=to_native(b_out).rstrip('\r\n'),
         rc=rc,
-        start=str(startd),
-        end=str(endd),
+        start=str(start_date),
+        end=str(end_date),
         delta=str(delta),
         changed=True,
     )

ansible/modules/hostname.py

@@ -608,8 +608,8 @@ class Hostname(object):
         self.use = module.params['use']
 
         if self.use is not None:
-            strat = globals()['%sStrategy' % STRATS[self.use]]
-            self.strategy = strat(module)
+            strategy = globals()['%sStrategy' % STRATS[self.use]]
+            self.strategy = strategy(module)
         elif platform.system() == 'Linux' and ServiceMgrFactCollector.is_systemd_managed(module):
             # This is Linux and systemd is active
             self.strategy = SystemdStrategy(module)

ansible/modules/pip.py

@@ -60,7 +60,7 @@ options:
   virtualenv_python:
     description:
       - The Python executable used for creating the virtual environment.
-        For example V(python3.12), V(python2.7). When not specified, the
+        For example V(python3.13). When not specified, the
         Python version used to run the ansible module is used. This parameter
         should not be used when O(virtualenv_command) is using V(pyvenv) or
         the C(-m venv) module.
@@ -93,8 +93,8 @@ options:
     description:
       - The explicit executable or pathname for the C(pip) executable,
         if different from the Ansible Python interpreter. For
-        example V(pip3.3), if there are both Python 2.7 and 3.3 installations
-        in the system and you want to run pip for the Python 3.3 installation.
+        example V(pip3.13), if there are multiple Python installations
+        in the system and you want to run pip for the Python 3.13 installation.
       - Mutually exclusive with O(virtualenv) (added in 2.1).
       - Does not affect the Ansible Python interpreter.
       - The C(setuptools) package must be installed for both the Ansible Python interpreter
@@ -134,7 +134,7 @@ notes:
      the virtualenv needs to be created.
    - Although it executes using the Ansible Python interpreter, the pip module shells out to
      run the actual pip command, so it can use any pip version you specify with O(executable).
-     By default, it uses the pip version for the Ansible Python interpreter. For example, pip3 on python 3, and pip2 or pip on python 2.
+     By default, it uses the pip version for the Ansible Python interpreter.
    - The interpreter used by Ansible
      (see R(ansible_python_interpreter, ansible_python_interpreter))
      requires the setuptools package, regardless of the version of pip set with
@@ -197,11 +197,11 @@ EXAMPLES = """
     virtualenv: /my_app/venv
     virtualenv_site_packages: yes
 
-- name: Install bottle into the specified (virtualenv), using Python 2.7
+- name: Install bottle into the specified (virtualenv), using Python 3.13
   ansible.builtin.pip:
     name: bottle
     virtualenv: /my_app/venv
-    virtualenv_command: virtualenv-2.7
+    virtualenv_command: virtualenv-3.13
 
 - name: Install bottle within a user home directory
   ansible.builtin.pip:
@@ -227,10 +227,10 @@ EXAMPLES = """
     requirements: /my_app/requirements.txt
     extra_args: "--no-index --find-links=file:///my_downloaded_packages_dir"
 
-- name: Install bottle for Python 3.3 specifically, using the 'pip3.3' executable
+- name: Install bottle for Python 3.13 specifically, using the 'pip3.13' executable
   ansible.builtin.pip:
     name: bottle
-    executable: pip3.3
+    executable: pip3.13
 
 - name: Install bottle, forcing reinstallation if it's already installed
   ansible.builtin.pip:
@@ -460,9 +460,7 @@ def _get_pip(module, env=None, executable=None):
             candidate_pip_basenames = (executable,)
     elif executable is None and env is None and _have_pip_module():
         # If no executable or virtualenv were specified, use the pip module for the current Python interpreter if available.
-        # Use of `__main__` is required to support Python 2.6 since support for executing packages with `runpy` was added in Python 2.7.
-        # Without it Python 2.6 gives the following error: pip is a package and cannot be directly executed
-        pip = [sys.executable, '-m', 'pip.__main__']
+        pip = [sys.executable, '-m', 'pip']
 
     if pip is None:
         if env is None:

ansible/modules/raw.py

@@ -73,8 +73,8 @@ author:
 """
 
 EXAMPLES = r"""
-- name: Bootstrap a host without python2 installed
-  ansible.builtin.raw: dnf install -y python2 python2-dnf libselinux-python
+- name: Bootstrap a host without Python installed
+  ansible.builtin.raw: dnf install -y python3 python3-libdnf
 
 - name: Run a command that uses non-posix shell-isms (in this example /bin/sh doesn't handle redirection and wildcards together but bash does)
   ansible.builtin.raw: cat < /tmp/*txt

ansible/modules/stat.py

@@ -408,7 +408,7 @@ def format_output(module, path, st):
             ('st_blksize', 'block_size'),
             ('st_rdev', 'device_type'),
             ('st_flags', 'flags'),
-            # Some Berkley based
+            # Some Berkeley based
             ('st_gen', 'generation'),
             ('st_birthtime', 'birthtime'),
             # RISCOS

ansible/modules/systemd.py

@@ -34,7 +34,7 @@ options:
         choices: [ reloaded, restarted, started, stopped ]
     enabled:
         description:
-            - Whether the unit should start on boot. At least one of O(state) and O(enabled) are required.
+            - Whether the unit should start on boot. At least one of O(state) or O(enabled) are required.
             - If set, requires O(name).
         type: bool
     force:

ansible/modules/systemd_service.py

@@ -34,7 +34,7 @@ options:
         choices: [ reloaded, restarted, started, stopped ]
     enabled:
         description:
-            - Whether the unit should start on boot. At least one of O(state) and O(enabled) are required.
+            - Whether the unit should start on boot. At least one of O(state) or O(enabled) are required.
             - If set, requires O(name).
         type: bool
     force:

ansible/modules/wait_for.py

@@ -76,6 +76,8 @@ options:
     description:
       - Can be used to match a string in either a file or a socket connection.
       - Defaults to a multiline regex.
+      - When inspecting a system log file and a static string, remember that Ansible by default logs its own actions there;
+        see the notes and examples for information.
     type: str
     version_added: "1.4"
   exclude_hosts:
@@ -105,13 +107,13 @@ attributes:
     platform:
         platforms: posix
 notes:
-  - The ability to use search_regex with a port connection was added in Ansible 1.7.
-  - Prior to Ansible 2.4, testing for the absence of a directory or UNIX socket did not work correctly.
-  - Prior to Ansible 2.4, testing for the presence of a file did not work correctly if the remote user did not have read access to that file.
   - Under some circumstances when using mandatory access control, a path may always be treated as being absent even if it exists, but
     can't be modified or created by the remote user either.
   - When waiting for a path, symbolic links will be followed.  Many other modules that manipulate files do not follow symbolic links,
     so operations on the path using other modules may not work exactly as expected.
+  - When searching a static string within a system log file, it is important to account for potential self-matching against log entries
+    generated by the Ansible modules.  To prevent this, add a regular expression construct into the search string. For example, to match
+    a literal string 'this thing', one could use a regular expression like 'this t[h]ing'.
 seealso:
 - module: ansible.builtin.wait_for_connection
 - module: ansible.windows.win_wait_for
@@ -156,6 +158,11 @@ EXAMPLES = r"""
     path: /tmp/foo
     search_regex: completed
 
+- name: Wait until the string "tomcat up" is in syslog, use regex character set to avoid self match
+  ansible.builtin.wait_for:
+    path: /var/log/syslog
+    search_regex: 'tomcat [u]p'
+
 - name: Wait until regex pattern matches in the file /tmp/foo and print the matched group
   ansible.builtin.wait_for:
     path: /tmp/foo

ansible/parsing/mod_args.py

@@ -20,17 +20,17 @@ from __future__ import annotations
 import ansible.constants as C
 from ansible.errors import AnsibleParserError, AnsibleError, AnsibleAssertionError
 from ansible.module_utils._internal._datatag import AnsibleTagHelper
-from ansible.module_utils.six import string_types
 from ansible.module_utils.common.sentinel import Sentinel
 from ansible.module_utils.common.text.converters import to_text
 from ansible.parsing.splitter import parse_kv, split_args
 from ansible.parsing.vault import EncryptedString
 from ansible.plugins.loader import module_loader, action_loader
-from ansible._internal._templating._engine import TemplateEngine
+from ansible._internal._templating import _jinja_bits
+from ansible.utils.display import Display
 from ansible.utils.fqcn import add_internal_fqcns
 
 
-# modules formated for user msg
+# modules formatted for user msg
 _BUILTIN_RAW_PARAM_MODULES_SIMPLE = set([
     'include_vars',
     'include_tasks',
@@ -152,38 +152,43 @@ class ModuleArgsParser:
         arguments can be fuzzy.  Deal with all the forms.
         """
 
-        additional_args = {} if additional_args is None else additional_args
-
         # final args are the ones we'll eventually return, so first update
         # them with any additional args specified, which have lower priority
         # than those which may be parsed/normalized next
         final_args = dict()
-        if additional_args:
-            if isinstance(additional_args, (str, EncryptedString)):
-                # DTFIX5: should this be is_possibly_template?
-                if TemplateEngine().is_template(additional_args):
-                    final_args['_variable_params'] = additional_args
-                else:
-                    raise AnsibleParserError("Complex args containing variables cannot use bare variables (without Jinja2 delimiters), "
-                                             "and must use the full variable style ('{{var_name}}')")
+
+        if additional_args is not Sentinel:
+            if isinstance(additional_args, str) and _jinja_bits.is_possibly_all_template(additional_args):
+                final_args['_variable_params'] = additional_args
             elif isinstance(additional_args, dict):
                 final_args.update(additional_args)
+            elif additional_args is None:
+                Display().deprecated(
+                    msg="Ignoring empty task `args` keyword.",
+                    version="2.23",
+                    help_text='A mapping or template which resolves to a mapping is required.',
+                    obj=self._task_ds,
+                )
             else:
-                raise AnsibleParserError('Complex args must be a dictionary or variable string ("{{var}}").')
+                raise AnsibleParserError(
+                    message='The value of the task `args` keyword is invalid.',
+                    help_text='A mapping or template which resolves to a mapping is required.',
+                    obj=additional_args,
+                )
 
         # how we normalize depends if we figured out what the module name is
         # yet.  If we have already figured it out, it's a 'new style' invocation.
         # otherwise, it's not
 
         if action is not None:
-            args = self._normalize_new_style_args(thing, action)
+            args = self._normalize_new_style_args(thing, action, additional_args)
         else:
             (action, args) = self._normalize_old_style_args(thing)
 
             # this can occasionally happen, simplify
             if args and 'args' in args:
                 tmp_args = args.pop('args')
-                if isinstance(tmp_args, string_types):
+                if isinstance(tmp_args, str):
                     tmp_args = parse_kv(tmp_args)
                 args.update(tmp_args)
 
@@ -206,7 +211,7 @@ class ModuleArgsParser:
 
         return (action, final_args)
 
-    def _normalize_new_style_args(self, thing, action):
+    def _normalize_new_style_args(self, thing, action, additional_args):
         """
         deals with fuzziness in new style module invocations
         accepting key=value pairs and dictionaries, and returns
@@ -222,11 +227,23 @@ class ModuleArgsParser:
         if isinstance(thing, dict):
             # form is like: { xyz: { x: 2, y: 3 } }
             args = thing
-        elif isinstance(thing, string_types):
+        elif isinstance(thing, str):
             # form is like: copy: src=a dest=b
             check_raw = action in FREEFORM_ACTIONS
             args = parse_kv(thing, check_raw=check_raw)
+            args_keys = set(args) - {'_raw_params'}
+
+            if args_keys and additional_args is not Sentinel:
+                kv_args = ', '.join(repr(arg) for arg in sorted(args_keys))
+
+                Display().deprecated(
+                    msg=f"Merging legacy k=v args ({kv_args}) into task args.",
+                    help_text="Include all task args in the task `args` mapping.",
+                    version="2.23",
+                    obj=thing,
+                )
         elif isinstance(thing, EncryptedString):
+            # k=v parsing intentionally omitted
             args = dict(_raw_params=thing)
         elif thing is None:
             # this can happen with modules which take no params, like ping:
@@ -253,6 +270,7 @@ class ModuleArgsParser:
 
         if isinstance(thing, dict):
             # form is like:  action: { module: 'copy', src: 'a', dest: 'b' }
+            Display().deprecated("Using a mapping for `action` is deprecated.", version='2.23', help_text='Use a string value for `action`.', obj=thing)
             thing = thing.copy()
             if 'module' in thing:
                 action, module_args = self._split_module_string(thing['module'])
@@ -261,7 +279,7 @@ class ModuleArgsParser:
                 args.update(parse_kv(module_args, check_raw=check_raw))
                 del args['module']
 
-        elif isinstance(thing, string_types):
+        elif isinstance(thing, str):
             # form is like:  action: copy src=a dest=b
             (action, args) = self._split_module_string(thing)
             check_raw = action in FREEFORM_ACTIONS
@@ -287,7 +305,7 @@ class ModuleArgsParser:
         # This is the standard YAML form for command-type modules. We grab
         # the args and pass them in as additional arguments, which can/will
         # be overwritten via dict updates from the other arg sources below
-        additional_args = self._task_ds.get('args', dict())
+        additional_args = self._task_ds.get('args', Sentinel)
 
         # We can have one of action, local_action, or module specified
         # action

ansible/parsing/vault/__init__.py

@@ -570,8 +570,8 @@ def match_encrypt_secret(secrets, encrypt_vault_id=None):
         return match_encrypt_vault_id_secret(secrets,
                                              encrypt_vault_id=encrypt_vault_id)
 
-    # Find the best/first secret from secrets since we didnt specify otherwise
-    # ie, consider all of the available secrets as matches
+    # Find the best/first secret from secrets since we didn't specify otherwise
+    # ie, consider all the available secrets as matches
     _vault_id_matchers = [_vault_id for _vault_id, dummy in secrets]
     best_secret = match_best_secret(secrets, _vault_id_matchers)
 
@@ -1413,7 +1413,7 @@ class EncryptedString(AnsibleTaggedObject):
             'ljust',
             'lower',
             'lstrip',
-            'maketrans',  # static, but implemented for simplicty/consistency
+            'maketrans',  # static, but implemented for simplicity/consistency
             'partition',
             'removeprefix',
             'removesuffix',

ansible/playbook/base.py

@@ -221,8 +221,6 @@ class FieldAttributeBase:
 
     def validate(self, all_vars=None):
         """ validation that is done at parse time, not load time """
-        all_vars = {} if all_vars is None else all_vars
-
         if not self._validated:
             # walk all fields in the object
             for (name, attribute) in self.fattributes.items():

ansible/playbook/helpers.py

@@ -122,7 +122,7 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
             except AnsibleParserError as ex:
                 # if the raises exception was created with obj=ds args, then it includes the detail
                 # so we dont need to add it so we can just re raise.
-                if ex.obj:
+                if ex.obj is not None:
                     raise
                 # But if it wasn't, we can add the yaml object now to get more detail
                 # DTFIX-FUTURE: this *should* be unnecessary- check code coverage.

ansible/playbook/playbook_include.py

@@ -19,12 +19,7 @@ from __future__ import annotations
 
 import os
 
-import ansible.constants as C
-from ansible.errors import AnsibleParserError, AnsibleAssertionError
 from ansible.module_utils.common.text.converters import to_bytes
-from ansible.module_utils._internal._datatag import AnsibleTagHelper
-from ansible.module_utils.six import string_types
-from ansible.parsing.splitter import split_args
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.base import Base
 from ansible.playbook.conditional import Conditional
@@ -32,15 +27,27 @@ from ansible.playbook.taggable import Taggable
 from ansible.utils.collection_loader import AnsibleCollectionConfig
 from ansible.utils.collection_loader._collection_finder import _get_collection_name_from_path, _get_collection_playbook_path
 from ansible._internal._templating._engine import TemplateEngine
-from ansible.utils.display import Display
-
-display = Display()
+from ansible.errors import AnsibleError
+from ansible import constants as C
 
 
 class PlaybookInclude(Base, Conditional, Taggable):
 
-    import_playbook = NonInheritableFieldAttribute(isa='string')
-    vars_val = NonInheritableFieldAttribute(isa='dict', default=dict, alias='vars')
+    import_playbook = NonInheritableFieldAttribute(isa='string', required=True)
+
+    _post_validate_object = True  # manually post_validate to get free arg validation/coercion
+
+    def preprocess_data(self, ds):
+        keys = {action for action in C._ACTION_IMPORT_PLAYBOOK if action in ds}
+
+        if len(keys) != 1:
+            raise AnsibleError(f'Found conflicting import_playbook actions: {", ".join(sorted(keys))}')
+
+        key = next(iter(keys))
+
+        ds['import_playbook'] = ds.pop(key)
+
+        return ds
 
     @staticmethod
     def load(data, basedir, variable_manager=None, loader=None):
@@ -62,18 +69,22 @@ class PlaybookInclude(Base, Conditional, Taggable):
         new_obj = super(PlaybookInclude, self).load_data(ds, variable_manager, loader)
 
         all_vars = self.vars.copy()
+
         if variable_manager:
             all_vars |= variable_manager.get_vars()
 
         templar = TemplateEngine(loader=loader, variables=all_vars)
 
+        new_obj.post_validate(templar)
+
         # then we use the object to load a Playbook
         pb = Playbook(loader=loader)
 
-        file_name = templar.template(new_obj.import_playbook)
+        file_name = new_obj.import_playbook
 
         # check for FQCN
         resource = _get_collection_playbook_path(file_name)
+
         if resource is not None:
             playbook = resource[1]
             playbook_collection = resource[2]
@@ -92,6 +103,7 @@ class PlaybookInclude(Base, Conditional, Taggable):
         else:
             # it is NOT a collection playbook, setup adjacent paths
             AnsibleCollectionConfig.playbook_paths.append(os.path.dirname(os.path.abspath(to_bytes(playbook, errors='surrogate_or_strict'))))
+            # broken, see: https://github.com/ansible/ansible/issues/85357
 
         pb._load_playbook_data(file_name=playbook, variable_manager=variable_manager, vars=self.vars.copy())
 
@@ -120,49 +132,3 @@ class PlaybookInclude(Base, Conditional, Taggable):
                     task_block._when = new_obj.when[:] + task_block.when[:]
 
         return pb
-
-    def preprocess_data(self, ds):
-        """
-        Reorganizes the data for a PlaybookInclude datastructure to line
-        up with what we expect the proper attributes to be
-        """
-
-        if not isinstance(ds, dict):
-            raise AnsibleAssertionError('ds (%s) should be a dict but was a %s' % (ds, type(ds)))
-
-        # the new, cleaned datastructure, which will have legacy items reduced to a standard structure suitable for the
-        # attributes of the task class; copy any tagged data to preserve things like origin
-        new_ds = AnsibleTagHelper.tag_copy(ds, {})
-
-        for (k, v) in ds.items():
-            if k in C._ACTION_IMPORT_PLAYBOOK:
-                self._preprocess_import(ds, new_ds, k, v)
-            else:
-                # some basic error checking, to make sure vars are properly
-                # formatted and do not conflict with k=v parameters
-                if k == 'vars':
-                    if 'vars' in new_ds:
-                        raise AnsibleParserError("import_playbook parameters cannot be mixed with 'vars' entries for import statements", obj=ds)
-                    elif not isinstance(v, dict):
-                        raise AnsibleParserError("vars for import_playbook statements must be specified as a dictionary", obj=ds)
-                new_ds[k] = v
-
-        return super(PlaybookInclude, self).preprocess_data(new_ds)
-
-    def _preprocess_import(self, ds, new_ds, k, v):
-        """
-        Splits the playbook import line up into filename and parameters
-        """
-        if v is None:
-            raise AnsibleParserError("playbook import parameter is missing", obj=ds)
-        elif not isinstance(v, string_types):
-            raise AnsibleParserError("playbook import parameter must be a string indicating a file path, got %s instead" % type(v), obj=ds)
-
-        # The import_playbook line must include at least one item, which is the filename
-        # to import. Anything after that should be regarded as a parameter to the import
-        items = split_args(v)
-        if len(items) == 0:
-            raise AnsibleParserError("import_playbook statements must specify the file name to import", obj=ds)
-
-        # DTFIX3: investigate this as a possible "problematic strip"
-        new_ds['import_playbook'] = AnsibleTagHelper.tag_copy(v, items[0].strip())

ansible/playbook/role/__init__.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import os
+import typing as _t
 
 from collections.abc import Container, Mapping, Set, Sequence
 from types import MappingProxyType
@@ -39,6 +40,16 @@ from ansible.utils.collection_loader import AnsibleCollectionConfig
 from ansible.utils.path import is_subpath
 from ansible.utils.vars import combine_vars
 
+# NOTE: This import is only needed for the type-checking in __init__. While there's an alternative
+#       available by using forward references this seems not to work well with commonly used IDEs.
+#       Therefore the TYPE_CHECKING hack seems to be a more universal approach, even if not being very elegant.
+#       References:
+#       * https://stackoverflow.com/q/39740632/199513
+#       * https://peps.python.org/pep-0484/#forward-references
+if _t.TYPE_CHECKING:
+    from ansible.playbook.block import Block
+    from ansible.playbook.play import Play
+
 __all__ = ['Role', 'hash_params']
 
 # TODO: this should be a utility function, but can't be a member of
@@ -97,13 +108,19 @@ def hash_params(params):
 
 class Role(Base, Conditional, Taggable, CollectionSearch, Delegatable):
 
-    def __init__(self, play=None, from_files=None, from_include=False, validate=True, public=None, static=True):
-        self._role_name = None
-        self._role_path = None
-        self._role_collection = None
-        self._role_params = dict()
+    def __init__(self,
+                 play: Play = None,
+                 from_files: dict[str, list[str]] = None,
+                 from_include: bool = False,
+                 validate: bool = True,
+                 public: bool = None,
+                 static: bool = True) -> None:
+        self._role_name: str = None
+        self._role_path: str = None
+        self._role_collection: str = None
+        self._role_params: dict[str, dict[str, str]] = dict()
         self._loader = None
-        self.static = static
+        self.static: bool = static
 
         # includes (static=false) default to private, while imports (static=true) default to public
         # but both can be overridden by global config if set
@@ -116,26 +133,26 @@ class Role(Base, Conditional, Taggable, CollectionSearch, Delegatable):
         else:
             self.public = public
 
-        self._metadata = RoleMetadata()
-        self._play = play
-        self._parents = []
-        self._dependencies = []
-        self._all_dependencies = None
-        self._task_blocks = []
-        self._handler_blocks = []
-        self._compiled_handler_blocks = None
-        self._default_vars = dict()
-        self._role_vars = dict()
-        self._had_task_run = dict()
-        self._completed = dict()
-        self._should_validate = validate
+        self._metadata: RoleMetadata = RoleMetadata()
+        self._play: Play = play
+        self._parents: list[Role] = []
+        self._dependencies: list[Role] = []
+        self._all_dependencies: list[Role] | None = None
+        self._task_blocks: list[Block] = []
+        self._handler_blocks: list[Block] = []
+        self._compiled_handler_blocks: list[Block] | None = None
+        self._default_vars: dict[str, str] | None = dict()
+        self._role_vars: dict[str, str] | None = dict()
+        self._had_task_run: dict[str, bool] = dict()
+        self._completed: dict[str, bool] = dict()
+        self._should_validate: bool = validate
 
         if from_files is None:
             from_files = {}
-        self._from_files = from_files
+        self._from_files: dict[str, list[str]] = from_files
 
         # Indicates whether this role was included via include/import_role
-        self.from_include = from_include
+        self.from_include: bool = from_include
 
         self._hash = None
 
@@ -357,8 +374,8 @@ class Role(Base, Conditional, Taggable, CollectionSearch, Delegatable):
             task_name = task_name + ' - ' + argument_spec['short_description']
 
         return {
-            'action': {
-                'module': 'ansible.builtin.validate_argument_spec',
+            'action': 'ansible.builtin.validate_argument_spec',
+            'args': {
                 # Pass only the 'options' portion of the arg spec to the module.
                 'argument_spec': argument_spec.get('options', {}),
                 'provided_arguments': self._role_params,

ansible/plugins/action/__init__.py

@@ -103,7 +103,7 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
         self._display = display
 
     @abstractmethod
-    def run(self, tmp=None, task_vars=None):
+    def run(self, tmp: str | None = None, task_vars: dict[str, t.Any] | None = None) -> dict[str, t.Any]:
         """ Action Plugins should implement this method to perform their
         tasks.  Everything else in this base class is a helper method for the
         action plugin to do that.
@@ -120,7 +120,7 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
         * Module parameters.  These are stored in self._task.args
         """
         # does not default to {'changed': False, 'failed': False}, as it used to break async
-        result = {}
+        result: dict[str, t.Any] = {}
 
         if tmp is not None:
             display.warning('ActionModule.run() no longer honors the tmp parameter. Action'