ansible-core 2.19.3rc1__py3-none-any.whl → 2.20.0b2__py3-none-any.whl

ansible/playbook/block.py

@@ -17,7 +17,6 @@
 
 from __future__ import annotations
 
-import ansible.constants as C
 from ansible.errors import AnsibleParserError
 from ansible.module_utils.common.sentinel import Sentinel
 from ansible.playbook.attribute import NonInheritableFieldAttribute
@@ -27,7 +26,6 @@ from ansible.playbook.collectionsearch import CollectionSearch
 from ansible.playbook.delegatable import Delegatable
 from ansible.playbook.helpers import load_list_of_tasks
 from ansible.playbook.notifiable import Notifiable
-from ansible.playbook.role import Role
 from ansible.playbook.taggable import Taggable
 
 
@@ -220,65 +218,6 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
         new_me.validate()
         return new_me
 
-    def serialize(self):
-        """
-        Override of the default serialize method, since when we're serializing
-        a task we don't want to include the attribute list of tasks.
-        """
-
-        data = dict()
-        for attr in self.fattributes:
-            if attr not in ('block', 'rescue', 'always'):
-                data[attr] = getattr(self, attr)
-
-        data['dep_chain'] = self.get_dep_chain()
-
-        if self._role is not None:
-            data['role'] = self._role.serialize()
-        if self._parent is not None:
-            data['parent'] = self._parent.copy(exclude_tasks=True).serialize()
-            data['parent_type'] = self._parent.__class__.__name__
-
-        return data
-
-    def deserialize(self, data):
-        """
-        Override of the default deserialize method, to match the above overridden
-        serialize method
-        """
-
-        # import is here to avoid import loops
-        from ansible.playbook.task_include import TaskInclude
-        from ansible.playbook.handler_task_include import HandlerTaskInclude
-
-        # we don't want the full set of attributes (the task lists), as that
-        # would lead to a serialize/deserialize loop
-        for attr in self.fattributes:
-            if attr in data and attr not in ('block', 'rescue', 'always'):
-                setattr(self, attr, data.get(attr))
-
-        self._dep_chain = data.get('dep_chain', None)
-
-        # if there was a serialized role, unpack it too
-        role_data = data.get('role')
-        if role_data:
-            r = Role()
-            r.deserialize(role_data)
-            self._role = r
-
-        parent_data = data.get('parent')
-        if parent_data:
-            parent_type = data.get('parent_type')
-            if parent_type == 'Block':
-                p = Block()
-            elif parent_type == 'TaskInclude':
-                p = TaskInclude()
-            elif parent_type == 'HandlerTaskInclude':
-                p = HandlerTaskInclude()
-            p.deserialize(parent_data)
-            self._parent = p
-            self._dep_chain = self._parent.get_dep_chain()
-
     def set_loader(self, loader):
         self._loader = loader
         if self._parent:
@@ -376,8 +315,7 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
                     filtered_block = evaluate_block(task)
                     if filtered_block.has_tasks():
                         tmp_list.append(filtered_block)
-                elif ((task.action in C._ACTION_META and task.implicit) or
-                        task.evaluate_tags(self._play.only_tags, self._play.skip_tags, all_vars=all_vars)):
+                elif task.evaluate_tags(self._play.only_tags, self._play.skip_tags, all_vars=all_vars):
                     tmp_list.append(task)
             return tmp_list
 

ansible/playbook/collectionsearch.py

@@ -3,7 +3,6 @@
 
 from __future__ import annotations
 
-from ansible.module_utils.six import string_types
 from ansible.playbook.attribute import FieldAttribute
 from ansible.utils.collection_loader import AnsibleCollectionConfig
 from ansible.utils.display import Display
@@ -32,7 +31,7 @@ def _ensure_default_collection(collection_list=None):
 class CollectionSearch:
 
     # this needs to be populated before we can resolve tasks/roles/etc
-    collections = FieldAttribute(isa='list', listof=string_types, priority=100, default=_ensure_default_collection, always_post_validate=True, static=True)
+    collections = FieldAttribute(isa='list', listof=(str,), priority=100, default=_ensure_default_collection, always_post_validate=True, static=True)
 
     def _load_collections(self, attr, ds):
         # We are always a mixin with Base, so we can validate this untemplated

ansible/playbook/handler.py

@@ -20,12 +20,11 @@ from __future__ import annotations
 from ansible.errors import AnsibleAssertionError
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.task import Task
-from ansible.module_utils.six import string_types
 
 
 class Handler(Task):
 
-    listen = NonInheritableFieldAttribute(isa='list', default=list, listof=string_types, static=True)
+    listen = NonInheritableFieldAttribute(isa='list', default=list, listof=(str,), static=True)
 
     def __init__(self, block=None, role=None, task_include=None):
         self.notified_hosts = []
@@ -72,8 +71,3 @@ class Handler(Task):
 
     def is_host_notified(self, host):
         return host in self.notified_hosts
-
-    def serialize(self):
-        result = super(Handler, self).serialize()
-        result['is_handler'] = True
-        return result

ansible/playbook/helpers.py

@@ -165,17 +165,29 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                     subdir = 'tasks'
                     if use_handlers:
                         subdir = 'handlers'
+                    try:
+                        include_target = templar.template(task.args['_raw_params'])
+                    except AnsibleUndefinedVariable as ex:
+                        raise AnsibleParserError(
+                            message=f"Error when evaluating variable in import path {task.args['_raw_params']!r}.",
+                            help_text="When using static imports, ensure that any variables used in their names are defined in vars/vars_files\n"
+                                      "or extra-vars passed in from the command line. Static imports cannot use variables from facts or inventory\n"
+                                      "sources like group or host vars.",
+                            obj=task_ds,
+                        ) from ex
+                    # FIXME this appears to be (almost?) duplicate code as in IncludedFile for include_tasks
                     while parent_include is not None:
                         if not isinstance(parent_include, TaskInclude):
                             parent_include = parent_include._parent
                             continue
-                        parent_include.post_validate(templar=templar)
-                        parent_include_dir = os.path.dirname(parent_include.args.get('_raw_params'))
+                        if isinstance(parent_include, IncludeRole):
+                            parent_include_dir = parent_include._role_path
+                        else:
+                            parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                         if cumulative_path is None:
                             cumulative_path = parent_include_dir
                         elif not os.path.isabs(cumulative_path):
                             cumulative_path = os.path.join(parent_include_dir, cumulative_path)
-                        include_target = templar.template(task.args['_raw_params'])
                         if task._role:
                             new_basedir = os.path.join(task._role._role_path, subdir, cumulative_path)
                             include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
@@ -189,16 +201,6 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                             parent_include = parent_include._parent
 
                     if not found:
-                        try:
-                            include_target = templar.template(task.args['_raw_params'])
-                        except AnsibleUndefinedVariable as ex:
-                            raise AnsibleParserError(
-                                message=f"Error when evaluating variable in import path {task.args['_raw_params']!r}.",
-                                help_text="When using static imports, ensure that any variables used in their names are defined in vars/vars_files\n"
-                                "or extra-vars passed in from the command line. Static imports cannot use variables from facts or inventory\n"
-                                "sources like group or host vars.",
-                                obj=task_ds,
-                            ) from ex
                         if task._role:
                             include_file = loader.path_dwim_relative(task._role._role_path, subdir, include_target)
                         else:
@@ -230,13 +232,6 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                         variable_manager=variable_manager,
                     )
 
-                    tags = ti_copy.tags[:]
-
-                    # now we extend the tags on each of the included blocks
-                    for b in included_blocks:
-                        b.tags = list(set(b.tags).union(tags))
-                    # FIXME - END
-
                     # FIXME: handlers shouldn't need this special handling, but do
                     #        right now because they don't iterate blocks correctly
                     if use_handlers:

ansible/playbook/included_file.py

@@ -203,7 +203,7 @@ class IncludedFile:
                         for from_arg in new_task.FROM_ARGS:
                             if from_arg in include_args:
                                 from_key = from_arg.removesuffix('_from')
-                                new_task._from_files[from_key] = include_args.pop(from_arg)
+                                new_task._from_files[from_key] = include_args.get(from_arg)
 
                         inc_file = IncludedFile(role_name, include_args, special_vars, new_task, is_role=True)
 

ansible/playbook/play.py

@@ -17,12 +17,15 @@
 
 from __future__ import annotations
 
+import functools as _functools
+import pathlib as _pathlib
+
 from ansible import constants as C
 from ansible import context
 from ansible.errors import AnsibleError
-from ansible.errors import AnsibleParserError, AnsibleAssertionError
+from ansible.errors import AnsibleParserError, AnsibleAssertionError, AnsibleValueOmittedError
 from ansible.module_utils.common.collections import is_sequence
-from ansible.module_utils.six import binary_type, string_types, text_type
+from ansible.module_utils.common.yaml import yaml_dump
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.base import Base
 from ansible.playbook.block import Block
@@ -34,6 +37,8 @@ from ansible.playbook.taggable import Taggable
 from ansible.parsing.vault import EncryptedString
 from ansible.utils.display import Display
 
+from ansible._internal._templating._engine import TemplateEngine as _TE
+
 display = Display()
 
 
@@ -53,11 +58,11 @@ class Play(Base, Taggable, CollectionSearch):
     """
 
     # =================================================================================
-    hosts = NonInheritableFieldAttribute(isa='list', required=True, listof=string_types, always_post_validate=True, priority=-2)
+    hosts = NonInheritableFieldAttribute(isa='list', required=True, listof=(str,), always_post_validate=True, priority=-2)
 
     # Facts
     gather_facts = NonInheritableFieldAttribute(isa='bool', default=None, always_post_validate=True)
-    gather_subset = NonInheritableFieldAttribute(isa='list', default=None, listof=string_types, always_post_validate=True)
+    gather_subset = NonInheritableFieldAttribute(isa='list', default=None, listof=(str,), always_post_validate=True)
     gather_timeout = NonInheritableFieldAttribute(isa='int', default=None, always_post_validate=True)
     fact_path = NonInheritableFieldAttribute(isa='string', default=None)
 
@@ -65,6 +70,8 @@ class Play(Base, Taggable, CollectionSearch):
     vars_files = NonInheritableFieldAttribute(isa='list', default=list, priority=99)
     vars_prompt = NonInheritableFieldAttribute(isa='list', default=list, always_post_validate=False)
 
+    validate_argspec = NonInheritableFieldAttribute(isa='string', always_post_validate=True)
+
     # Role Attributes
     roles = NonInheritableFieldAttribute(isa='list', default=list, priority=90)
 
@@ -120,10 +127,10 @@ class Play(Base, Taggable, CollectionSearch):
                 for entry in value:
                     if entry is None:
                         raise AnsibleParserError("Hosts list cannot contain values of 'None'. Please check your playbook")
-                    elif not isinstance(entry, (binary_type, text_type)):
+                    elif not isinstance(entry, (bytes, str)):
                         raise AnsibleParserError("Hosts list contains an invalid host value: '{host!s}'".format(host=entry))
 
-            elif not isinstance(value, (binary_type, text_type, EncryptedString)):
+            elif not isinstance(value, (bytes, str, EncryptedString)):
                 raise AnsibleParserError("Hosts list must be a sequence or string. Please check your playbook.")
 
     def get_name(self):
@@ -303,23 +310,13 @@ class Play(Base, Taggable, CollectionSearch):
 
         t = Task(block=flush_block)
         t.action = 'meta'
-        t.resolved_action = 'ansible.builtin.meta'
+        t._resolved_action = 'ansible.builtin.meta'
         t.args['_raw_params'] = 'flush_handlers'
         t.implicit = True
         t.set_loader(self._loader)
+        t.tags = ['always']
 
-        if self.tags:
-            # Avoid calling flush_handlers in case the whole play is skipped on tags,
-            # this could be performance improvement since calling flush_handlers on
-            # large inventories could be expensive even if no hosts are notified
-            # since we call flush_handlers per host.
-            # Block.filter_tagged_tasks ignores evaluating tags on implicit meta
-            # tasks so we need to explicitly call Task.evaluate_tags here.
-            t.tags = self.tags
-            if t.evaluate_tags(self.only_tags, self.skip_tags, all_vars=self.vars):
-                flush_block.block = [t]
-        else:
-            flush_block.block = [t]
+        flush_block.block = [t]
 
         # NOTE keep flush_handlers tasks even if a section has no regular tasks,
         #      there may be notified handlers from the previous section
@@ -400,36 +397,6 @@ class Play(Base, Taggable, CollectionSearch):
                 tasklist.append(task)
         return tasklist
 
-    def serialize(self):
-        data = super(Play, self).serialize()
-
-        roles = []
-        for role in self.get_roles():
-            roles.append(role.serialize())
-        data['roles'] = roles
-        data['included_path'] = self._included_path
-        data['action_groups'] = self._action_groups
-        data['group_actions'] = self._group_actions
-
-        return data
-
-    def deserialize(self, data):
-        super(Play, self).deserialize(data)
-
-        self._included_path = data.get('included_path', None)
-        self._action_groups = data.get('action_groups', {})
-        self._group_actions = data.get('group_actions', {})
-        if 'roles' in data:
-            role_data = data.get('roles', [])
-            roles = []
-            for role in role_data:
-                r = Role()
-                r.deserialize(role)
-                roles.append(r)
-
-            setattr(self, 'roles', roles)
-            del data['roles']
-
     def copy(self):
         new_me = super(Play, self).copy()
         new_me.role_cache = self.role_cache.copy()
@@ -438,3 +405,92 @@ class Play(Base, Taggable, CollectionSearch):
         new_me._action_groups = self._action_groups
         new_me._group_actions = self._group_actions
         return new_me
+
+    def _post_validate_validate_argspec(self, attr: NonInheritableFieldAttribute, value: object, templar: _TE) -> str | None:
+        """Validate user input is a bool or string, and return the corresponding argument spec name."""
+
+        # Ensure the configuration is valid
+        if isinstance(value, str):
+            try:
+                value = templar.template(value)
+            except AnsibleValueOmittedError:
+                value = False
+
+        if not isinstance(value, (str, bool)):
+            raise AnsibleParserError(f"validate_argspec must be a boolean or string, not {type(value)}", obj=value)
+
+        # Short-circuit if configuration is turned off or inapplicable
+        if not value or self._origin is None:
+            return None
+
+        # Use the requested argument spec or fall back to the play name
+        argspec_name = None
+        if isinstance(value, str):
+            argspec_name = value
+        elif self._ds.get("name"):
+            argspec_name = self.name
+
+        metadata_err = argspec_err = ""
+        if not argspec_name:
+            argspec_err = (
+                "A play name is required when validate_argspec is True. "
+                "Alternatively, set validate_argspec to the name of an argument spec."
+            )
+        if self._metadata_path is None:
+            metadata_err = "A playbook meta file is required. Considered:\n  - "
+            metadata_err += "\n  - ".join([path.as_posix() for path in self._metadata_candidate_paths])
+
+        if metadata_err or argspec_err:
+            error = f"{argspec_err + (' ' if argspec_err else '')}{metadata_err}"
+            raise AnsibleParserError(error, obj=self._origin)
+
+        metadata = self._loader.load_from_file(self._metadata_path)
+
+        try:
+            metadata = metadata['argument_specs']
+            metadata = metadata[argspec_name]
+            options = metadata['options']
+        except (TypeError, KeyError):
+            options = None
+
+        if not isinstance(options, dict):
+            raise AnsibleParserError(
+                f"No argument spec named '{argspec_name}' in {self._metadata_path}. Minimally expected:\n"
+                + yaml_dump({"argument_specs": {f"{argspec_name!s}": {"options": {}}}}),
+                obj=metadata,
+            )
+
+        return argspec_name
+
+    @property
+    def _metadata_candidate_paths(self) -> list[_pathlib.Path]:
+        """A list of possible playbook.meta paths in configured order."""
+        extensions = C.config.get_config_value("YAML_FILENAME_EXTENSIONS")
+        if self._origin.path.endswith(tuple(extensions)):
+            playbook_without_ext = self._origin.path.rsplit('.', 1)[0]
+        else:
+            playbook_without_ext = self._origin.path
+
+        return [_pathlib.Path(playbook_without_ext + ".meta" + ext) for ext in extensions + ['']]
+
+    @_functools.cached_property
+    def _metadata_path(self) -> str | None:
+        """Locate playbook meta path:
+
+        playbook{ext?} -> playbook.meta{ext?}
+        """
+        if self._origin is None:
+            # adhoc, ansible-console don't have an associated playbook
+            return None
+        for candidate in self._metadata_candidate_paths:
+            if candidate.is_file():
+                return candidate.as_posix()
+        return None
+
+    @property
+    def argument_spec(self) -> dict:
+        """Retrieve the argument spec if one is configured."""
+        if not self.validate_argspec:
+            return {}
+
+        return self._loader.load_from_file(self._metadata_path)['argument_specs'][self.validate_argspec]['options']

ansible/playbook/play_context.py

@@ -325,3 +325,7 @@ class PlayContext(Base):
                         variables[var_opt] = var_val
             except AttributeError:
                 continue
+
+    def deserialize(self, data):
+        """Do not use this method. Backward compatibility for network connections plugins that rely on it."""
+        self.from_attrs(data)

ansible/playbook/role/__init__.py

@@ -27,7 +27,6 @@ from ansible import constants as C
 from ansible.errors import AnsibleError, AnsibleParserError, AnsibleAssertionError
 from ansible.module_utils.common.sentinel import Sentinel
 from ansible.module_utils.common.text.converters import to_text
-from ansible.module_utils.six import binary_type, text_type
 from ansible.playbook.base import Base
 from ansible.playbook.collectionsearch import CollectionSearch
 from ansible.playbook.conditional import Conditional
@@ -37,6 +36,7 @@ from ansible.playbook.role.metadata import RoleMetadata
 from ansible.playbook.taggable import Taggable
 from ansible.plugins.loader import add_all_plugin_dirs
 from ansible.utils.collection_loader import AnsibleCollectionConfig
+from ansible.utils.display import Display
 from ansible.utils.path import is_subpath
 from ansible.utils.vars import combine_vars
 
@@ -52,14 +52,12 @@ if _t.TYPE_CHECKING:
 
 __all__ = ['Role', 'hash_params']
 
-# TODO: this should be a utility function, but can't be a member of
-#       the role due to the fact that it would require the use of self
-#       in a static method. This is also used in the base class for
-#       strategies (ansible/plugins/strategy/__init__.py)
+_display = Display()
 
 
 def hash_params(params):
     """
+    DEPRECATED
     Construct a data structure of parameters that is hashable.
 
     This requires changing any mutable data structures into immutable ones.
@@ -71,10 +69,16 @@ def hash_params(params):
         1) There shouldn't be any unhashable scalars specified in the yaml
         2) Our only choice would be to return an error anyway.
     """
+
+    _display.deprecated(
+        msg="The hash_params function is deprecated as its consumers have moved to internal alternatives",
+        version='2.24',
+        help_text='Contact the plugin author to update their code',
+    )
     # Any container is unhashable if it contains unhashable items (for
     # instance, tuple() is a Hashable subclass but if it contains a dict, it
     # cannot be hashed)
-    if isinstance(params, Container) and not isinstance(params, (text_type, binary_type)):
+    if isinstance(params, Container) and not isinstance(params, (str, bytes)):
         if isinstance(params, Mapping):
             try:
                 # Optimistically hope the contents are all hashable
@@ -651,65 +655,6 @@ class Role(Base, Conditional, Taggable, CollectionSearch, Delegatable):
 
         return block_list
 
-    def serialize(self, include_deps=True):
-        res = super(Role, self).serialize()
-
-        res['_role_name'] = self._role_name
-        res['_role_path'] = self._role_path
-        res['_role_vars'] = self._role_vars
-        res['_role_params'] = self._role_params
-        res['_default_vars'] = self._default_vars
-        res['_had_task_run'] = self._had_task_run.copy()
-        res['_completed'] = self._completed.copy()
-
-        res['_metadata'] = self._metadata.serialize()
-
-        if include_deps:
-            deps = []
-            for role in self.get_direct_dependencies():
-                deps.append(role.serialize())
-            res['_dependencies'] = deps
-
-        parents = []
-        for parent in self._parents:
-            parents.append(parent.serialize(include_deps=False))
-        res['_parents'] = parents
-
-        return res
-
-    def deserialize(self, data, include_deps=True):
-        self._role_name = data.get('_role_name', '')
-        self._role_path = data.get('_role_path', '')
-        self._role_vars = data.get('_role_vars', dict())
-        self._role_params = data.get('_role_params', dict())
-        self._default_vars = data.get('_default_vars', dict())
-        self._had_task_run = data.get('_had_task_run', dict())
-        self._completed = data.get('_completed', dict())
-
-        if include_deps:
-            deps = []
-            for dep in data.get('_dependencies', []):
-                r = Role()
-                r.deserialize(dep)
-                deps.append(r)
-            setattr(self, '_dependencies', deps)
-
-        parent_data = data.get('_parents', [])
-        parents = []
-        for parent in parent_data:
-            r = Role()
-            r.deserialize(parent, include_deps=False)
-            parents.append(r)
-        setattr(self, '_parents', parents)
-
-        metadata_data = data.get('_metadata')
-        if metadata_data:
-            m = RoleMetadata()
-            m.deserialize(metadata_data)
-            self._metadata = m
-
-        super(Role, self).deserialize(data)
-
     def set_loader(self, loader):
         self._loader = loader
         for parent in self._parents:

ansible/playbook/role/definition.py

@@ -22,7 +22,6 @@ import os
 from ansible import constants as C
 from ansible.errors import AnsibleError, AnsibleAssertionError
 from ansible.module_utils._internal._datatag import AnsibleTagHelper
-from ansible.module_utils.six import string_types
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.base import Base
 from ansible.playbook.collectionsearch import CollectionSearch
@@ -70,7 +69,7 @@ class RoleDefinition(Base, Conditional, Taggable, CollectionSearch):
         if isinstance(ds, int):
             ds = "%s" % ds
 
-        if not isinstance(ds, dict) and not isinstance(ds, string_types):
+        if not isinstance(ds, dict) and not isinstance(ds, str):
             raise AnsibleAssertionError()
 
         if isinstance(ds, dict):
@@ -113,11 +112,11 @@ class RoleDefinition(Base, Conditional, Taggable, CollectionSearch):
         string), just that string
         """
 
-        if isinstance(ds, string_types):
+        if isinstance(ds, str):
             return ds
 
         role_name = ds.get('role', ds.get('name'))
-        if not role_name or not isinstance(role_name, string_types):
+        if not role_name or not isinstance(role_name, str):
             raise AnsibleError('role definitions must contain a role name', obj=ds)
 
         # if we have the required datastructures, and if the role_name

ansible/playbook/role/include.py

@@ -18,7 +18,6 @@
 from __future__ import annotations
 
 from ansible.errors import AnsibleError, AnsibleParserError
-from ansible.module_utils.six import string_types
 from ansible.playbook.delegatable import Delegatable
 from ansible.playbook.role.definition import RoleDefinition
 
@@ -40,10 +39,10 @@ class RoleInclude(RoleDefinition, Delegatable):
     @staticmethod
     def load(data, play, current_role_path=None, parent_role=None, variable_manager=None, loader=None, collection_list=None):
 
-        if not (isinstance(data, string_types) or isinstance(data, dict)):
+        if not (isinstance(data, str) or isinstance(data, dict)):
             raise AnsibleParserError("Invalid role definition.", obj=data)
 
-        if isinstance(data, string_types) and ',' in data:
+        if isinstance(data, str) and ',' in data:
             raise AnsibleError("Invalid old style role requirement: %s" % data)
 
         ri = RoleInclude(play=play, role_basedir=current_role_path, variable_manager=variable_manager, loader=loader, collection_list=collection_list)

ansible/playbook/role/metadata.py

@@ -20,7 +20,6 @@ from __future__ import annotations
 import os
 
 from ansible.errors import AnsibleParserError, AnsibleError
-from ansible.module_utils.six import string_types
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.base import Base
 from ansible.playbook.collectionsearch import CollectionSearch
@@ -70,7 +69,7 @@ class RoleMetadata(Base, CollectionSearch):
 
             for role_def in ds:
                 # FIXME: consolidate with ansible-galaxy to keep this in sync
-                if isinstance(role_def, string_types) or 'role' in role_def or 'name' in role_def:
+                if isinstance(role_def, str) or 'role' in role_def or 'name' in role_def:
                     roles.append(role_def)
                     continue
                 try:
@@ -106,13 +105,3 @@ class RoleMetadata(Base, CollectionSearch):
                                       collection_search_list=collection_search_list)
         except AssertionError as ex:
             raise AnsibleParserError("A malformed list of role dependencies was encountered.", obj=self._ds) from ex
-
-    def serialize(self):
-        return dict(
-            allow_duplicates=self._allow_duplicates,
-            dependencies=self._dependencies
-        )
-
-    def deserialize(self, data):
-        setattr(self, 'allow_duplicates', data.get('allow_duplicates', False))
-        setattr(self, 'dependencies', data.get('dependencies', []))

ansible/playbook/role/requirement.py

@@ -18,7 +18,6 @@
 from __future__ import annotations
 
 from ansible.errors import AnsibleError
-from ansible.module_utils.six import string_types
 from ansible.playbook.role.definition import RoleDefinition
 from ansible.utils.display import Display
 from ansible.utils.galaxy import scm_archive_resource
@@ -65,7 +64,7 @@ class RoleRequirement(RoleDefinition):
     @staticmethod
     def role_yaml_parse(role):
 
-        if isinstance(role, string_types):
+        if isinstance(role, str):
             name = None
             scm = None
             src = None

ansible/playbook/role_include.py

@@ -23,7 +23,6 @@ from ansible.playbook.task_include import TaskInclude
 from ansible.playbook.role import Role
 from ansible.playbook.role.include import RoleInclude
 from ansible.utils.display import Display
-from ansible.module_utils.six import string_types
 from ansible._internal._templating._engine import TemplateEngine
 
 __all__ = ['IncludeRole']
@@ -137,7 +136,7 @@ class IncludeRole(TaskInclude):
         for key in my_arg_names.intersection(IncludeRole.FROM_ARGS):
             from_key = key.removesuffix('_from')
             args_value = ir.args.get(key)
-            if not isinstance(args_value, string_types):
+            if not isinstance(args_value, str):
                 raise AnsibleParserError('Expected a string for %s but got %s instead' % (key, type(args_value)))
             ir._from_files[from_key] = args_value