ansible-core 2.18.7rc1__py3-none-any.whl → 2.19.0__py3-none-any.whl

ansible/playbook/included_file.py

@@ -21,35 +21,42 @@ import os
 
 from ansible import constants as C
 from ansible.errors import AnsibleError
-from ansible.executor.task_executor import remove_omit
+from ansible.executor.task_result import _RawTaskResult
+from ansible.inventory.host import Host
 from ansible.module_utils.common.text.converters import to_text
+from ansible.parsing.dataloader import DataLoader
 from ansible.playbook.handler import Handler
 from ansible.playbook.task_include import TaskInclude
 from ansible.playbook.role_include import IncludeRole
-from ansible.template import Templar
+from ansible._internal._templating._engine import TemplateEngine
 from ansible.utils.display import Display
+from ansible.vars.manager import VariableManager
 
 display = Display()
 
 
 class IncludedFile:
 
-    def __init__(self, filename, args, vars, task, is_role=False):
+    def __init__(self, filename, args, vars, task, is_role: bool = False) -> None:
         self._filename = filename
         self._args = args
         self._vars = vars
         self._task = task
-        self._hosts = []
+        self._hosts: list[Host] = []
         self._is_role = is_role
-        self._results = []
+        self._results: list[_RawTaskResult] = []
 
-    def add_host(self, host):
+    def add_host(self, host: Host) -> None:
         if host not in self._hosts:
             self._hosts.append(host)
             return
+
         raise ValueError()
 
     def __eq__(self, other):
+        if not isinstance(other, IncludedFile):
+            return False
+
         return (other._filename == self._filename and
                 other._args == self._args and
                 other._vars == self._vars and
@@ -60,23 +67,28 @@ class IncludedFile:
         return "%s (args=%s vars=%s): %s" % (self._filename, self._args, self._vars, self._hosts)
 
     @staticmethod
-    def process_include_results(results, iterator, loader, variable_manager):
-        included_files = []
-        task_vars_cache = {}
+    def process_include_results(
+        results: list[_RawTaskResult],
+        iterator,
+        loader: DataLoader,
+        variable_manager: VariableManager,
+    ) -> list[IncludedFile]:
+        included_files: list[IncludedFile] = []
+        task_vars_cache: dict[tuple, dict] = {}
 
         for res in results:
 
-            original_host = res._host
-            original_task = res._task
+            original_host = res.host
+            original_task = res.task
 
             if original_task.action in C._ACTION_ALL_INCLUDES:
 
                 if original_task.loop:
-                    if 'results' not in res._result:
+                    if 'results' not in res._return_data:
                         continue
-                    include_results = res._result['results']
+                    include_results = res._loop_results
                 else:
-                    include_results = [res._result]
+                    include_results = [res._return_data]
 
                 for include_result in include_results:
                     # if the task result was skipped or failed, continue
@@ -114,7 +126,7 @@ class IncludedFile:
                     if loader.get_basedir() not in task_vars['ansible_search_path']:
                         task_vars['ansible_search_path'].append(loader.get_basedir())
 
-                    templar = Templar(loader=loader, variables=task_vars)
+                    templar = TemplateEngine(loader=loader, variables=task_vars)
 
                     if original_task.action in C._ACTION_INCLUDE_TASKS:
                         include_file = None
@@ -132,6 +144,8 @@ class IncludedFile:
                                     parent_include_dir = parent_include._role_path
                                 else:
                                     try:
+                                        # FUTURE: Since the parent include path has already been resolved, it should be used here.
+                                        #         Unfortunately it's not currently stored anywhere, so it must be calculated again.
                                         parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                                     except AnsibleError as e:
                                         parent_include_dir = ''
@@ -144,7 +158,7 @@ class IncludedFile:
                                     cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                                 else:
                                     cumulative_path = parent_include_dir
-                                include_target = templar.template(include_result['include'])
+                                include_target = include_result['include']
                                 if original_task._role:
                                     dirname = 'handlers' if isinstance(original_task, Handler) else 'tasks'
                                     new_basedir = os.path.join(original_task._role._role_path, dirname, cumulative_path)
@@ -170,7 +184,7 @@ class IncludedFile:
 
                         if include_file is None:
                             if original_task._role:
-                                include_target = templar.template(include_result['include'])
+                                include_target = include_result['include']
                                 include_file = loader.path_dwim_relative(
                                     original_task._role._role_path,
                                     'handlers' if isinstance(original_task, Handler) else 'tasks',
@@ -179,25 +193,17 @@ class IncludedFile:
                             else:
                                 include_file = loader.path_dwim(include_result['include'])
 
-                        include_file = templar.template(include_file)
                         inc_file = IncludedFile(include_file, include_args, special_vars, original_task)
                     else:
                         # template the included role's name here
                         role_name = include_args.pop('name', include_args.pop('role', None))
-                        if role_name is not None:
-                            role_name = templar.template(role_name)
-
                         new_task = original_task.copy()
                         new_task.post_validate(templar=templar)
                         new_task._role_name = role_name
                         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] = templar.template(include_args.pop(from_arg))
-
-                        omit_token = task_vars.get('omit')
-                        if omit_token:
-                            new_task._from_files = remove_omit(new_task._from_files, omit_token)
+                                new_task._from_files[from_key] = include_args.pop(from_arg)
 
                         inc_file = IncludedFile(role_name, include_args, special_vars, new_task, is_role=True)
 

ansible/playbook/loop_control.py

@@ -40,8 +40,8 @@ class LoopControl(FieldAttributeBase):
         return t.load_data(data, variable_manager=variable_manager, loader=loader)
 
     def _post_validate_break_when(self, attr, value, templar):
-        '''
+        """
         break_when is evaluated after the execution of the loop is complete,
         and should not be templated during the regular post_validate step.
-        '''
+        """
         return value

ansible/playbook/play.py

@@ -19,8 +19,8 @@ from __future__ import annotations
 
 from ansible import constants as C
 from ansible import context
+from ansible.errors import AnsibleError
 from ansible.errors import AnsibleParserError, AnsibleAssertionError
-from ansible.module_utils.common.text.converters import to_native
 from ansible.module_utils.common.collections import is_sequence
 from ansible.module_utils.six import binary_type, string_types, text_type
 from ansible.playbook.attribute import NonInheritableFieldAttribute
@@ -31,6 +31,7 @@ from ansible.playbook.helpers import load_list_of_blocks, load_list_of_roles
 from ansible.playbook.role import Role
 from ansible.playbook.task import Task
 from ansible.playbook.taggable import Taggable
+from ansible.parsing.vault import EncryptedString
 from ansible.utils.display import Display
 
 display = Display()
@@ -99,6 +100,15 @@ class Play(Base, Taggable, CollectionSearch):
     def __repr__(self):
         return self.get_name()
 
+    def _get_cached_role(self, role):
+        role_path = role.get_role_path()
+        role_cache = self.role_cache[role_path]
+        try:
+            idx = role_cache.index(role)
+            return role_cache[idx]
+        except ValueError:
+            raise AnsibleError(f'Cannot locate {role.get_name()} in role cache')
+
     def _validate_hosts(self, attribute, name, value):
         # Only validate 'hosts' if a value was passed in to original data set.
         if 'hosts' in self._ds:
@@ -113,11 +123,11 @@ class Play(Base, Taggable, CollectionSearch):
                     elif not isinstance(entry, (binary_type, text_type)):
                         raise AnsibleParserError("Hosts list contains an invalid host value: '{host!s}'".format(host=entry))
 
-            elif not isinstance(value, (binary_type, text_type)):
+            elif not isinstance(value, (binary_type, text_type, EncryptedString)):
                 raise AnsibleParserError("Hosts list must be a sequence or string. Please check your playbook.")
 
     def get_name(self):
-        ''' return the name of the Play '''
+        """ return the name of the Play """
         if self.name:
             return self.name
 
@@ -136,9 +146,9 @@ class Play(Base, Taggable, CollectionSearch):
         return p.load_data(data, variable_manager=variable_manager, loader=loader)
 
     def preprocess_data(self, ds):
-        '''
+        """
         Adjusts play datastructure to cleanup old/legacy items
-        '''
+        """
 
         if not isinstance(ds, dict):
             raise AnsibleAssertionError('while preprocessing data (%s), ds should be a dict but was a %s' % (ds, type(ds)))
@@ -158,55 +168,57 @@ class Play(Base, Taggable, CollectionSearch):
 
         return super(Play, self).preprocess_data(ds)
 
+    # DTFIX-FUTURE: these do nothing but augment the exception message; DRY and nuke
+
     def _load_tasks(self, attr, ds):
-        '''
+        """
         Loads a list of blocks from a list which may be mixed tasks/blocks.
         Bare tasks outside of a block are given an implicit block.
-        '''
+        """
         try:
             return load_list_of_blocks(ds=ds, play=self, variable_manager=self._variable_manager, loader=self._loader)
-        except AssertionError as e:
-            raise AnsibleParserError("A malformed block was encountered while loading tasks: %s" % to_native(e), obj=self._ds, orig_exc=e)
+        except AssertionError as ex:
+            raise AnsibleParserError("A malformed block was encountered while loading tasks.", obj=self._ds) from ex
 
     def _load_pre_tasks(self, attr, ds):
-        '''
+        """
         Loads a list of blocks from a list which may be mixed tasks/blocks.
         Bare tasks outside of a block are given an implicit block.
-        '''
+        """
         try:
             return load_list_of_blocks(ds=ds, play=self, variable_manager=self._variable_manager, loader=self._loader)
-        except AssertionError as e:
-            raise AnsibleParserError("A malformed block was encountered while loading pre_tasks", obj=self._ds, orig_exc=e)
+        except AssertionError as ex:
+            raise AnsibleParserError("A malformed block was encountered while loading pre_tasks.", obj=self._ds) from ex
 
     def _load_post_tasks(self, attr, ds):
-        '''
+        """
         Loads a list of blocks from a list which may be mixed tasks/blocks.
         Bare tasks outside of a block are given an implicit block.
-        '''
+        """
         try:
             return load_list_of_blocks(ds=ds, play=self, variable_manager=self._variable_manager, loader=self._loader)
-        except AssertionError as e:
-            raise AnsibleParserError("A malformed block was encountered while loading post_tasks", obj=self._ds, orig_exc=e)
+        except AssertionError as ex:
+            raise AnsibleParserError("A malformed block was encountered while loading post_tasks.", obj=self._ds) from ex
 
     def _load_handlers(self, attr, ds):
-        '''
+        """
         Loads a list of blocks from a list which may be mixed handlers/blocks.
         Bare handlers outside of a block are given an implicit block.
-        '''
+        """
         try:
             return self._extend_value(
                 self.handlers,
                 load_list_of_blocks(ds=ds, play=self, use_handlers=True, variable_manager=self._variable_manager, loader=self._loader),
                 prepend=True
             )
-        except AssertionError as e:
-            raise AnsibleParserError("A malformed block was encountered while loading handlers", obj=self._ds, orig_exc=e)
+        except AssertionError as ex:
+            raise AnsibleParserError("A malformed block was encountered while loading handlers.", obj=self._ds) from ex
 
     def _load_roles(self, attr, ds):
-        '''
+        """
         Loads and returns a list of RoleInclude objects from the datastructure
         list of role definitions and creates the Role from those objects
-        '''
+        """
 
         if ds is None:
             ds = []
@@ -214,8 +226,8 @@ class Play(Base, Taggable, CollectionSearch):
         try:
             role_includes = load_list_of_roles(ds, play=self, variable_manager=self._variable_manager,
                                                loader=self._loader, collection_search_list=self.collections)
-        except AssertionError as e:
-            raise AnsibleParserError("A malformed role declaration was encountered.", obj=self._ds, orig_exc=e)
+        except AssertionError as ex:
+            raise AnsibleParserError("A malformed role declaration was encountered.", obj=self._ds) from ex
 
         roles = []
         for ri in role_includes:
@@ -242,13 +254,13 @@ class Play(Base, Taggable, CollectionSearch):
         return vars_prompts
 
     def _compile_roles(self):
-        '''
+        """
         Handles the role compilation step, returning a flat list of tasks
         with the lowest level dependencies first. For example, if a role R
         has a dependency D1, which also has a dependency D2, the tasks from
         D2 are merged first, followed by D1, and lastly by the tasks from
         the parent role R last. This is done for all roles in the Play.
-        '''
+        """
 
         block_list = []
 
@@ -263,10 +275,10 @@ class Play(Base, Taggable, CollectionSearch):
         return block_list
 
     def compile_roles_handlers(self):
-        '''
+        """
         Handles the role handler compilation step, returning a flat list of Handlers
         This is done for all roles in the Play.
-        '''
+        """
 
         block_list = []
 
@@ -279,25 +291,39 @@ class Play(Base, Taggable, CollectionSearch):
         return block_list
 
     def compile(self):
-        '''
+        """
         Compiles and returns the task list for this play, compiled from the
         roles (which are themselves compiled recursively) and/or the list of
         tasks specified in the play.
-        '''
-
+        """
         # create a block containing a single flush handlers meta
         # task, so we can be sure to run handlers at certain points
         # of the playbook execution
-        flush_block = Block.load(
-            data={'meta': 'flush_handlers'},
-            play=self,
-            variable_manager=self._variable_manager,
-            loader=self._loader
-        )
-
-        for task in flush_block.block:
-            task.implicit = True
+        flush_block = Block(play=self)
+
+        t = Task(block=flush_block)
+        t.action = 'meta'
+        t.resolved_action = 'ansible.builtin.meta'
+        t.args['_raw_params'] = 'flush_handlers'
+        t.implicit = True
+        t.set_loader(self._loader)
+
+        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]
 
+        # NOTE keep flush_handlers tasks even if a section has no regular tasks,
+        #      there may be notified handlers from the previous section
+        #      (typically when a handler notifies a handler defined before)
         block_list = []
         if self.force_handlers:
             noop_task = Task()
@@ -307,18 +333,33 @@ class Play(Base, Taggable, CollectionSearch):
             noop_task.set_loader(self._loader)
 
             b = Block(play=self)
-            b.block = self.pre_tasks or [noop_task]
+            if self.pre_tasks:
+                b.block = self.pre_tasks
+            else:
+                nt = noop_task.copy(exclude_parent=True)
+                nt._parent = b
+                b.block = [nt]
             b.always = [flush_block]
             block_list.append(b)
 
             tasks = self._compile_roles() + self.tasks
             b = Block(play=self)
-            b.block = tasks or [noop_task]
+            if tasks:
+                b.block = tasks
+            else:
+                nt = noop_task.copy(exclude_parent=True)
+                nt._parent = b
+                b.block = [nt]
             b.always = [flush_block]
             block_list.append(b)
 
             b = Block(play=self)
-            b.block = self.post_tasks or [noop_task]
+            if self.post_tasks:
+                b.block = self.post_tasks
+            else:
+                nt = noop_task.copy(exclude_parent=True)
+                nt._parent = b
+                b.block = [nt]
             b.always = [flush_block]
             block_list.append(b)
 

ansible/playbook/play_context.py

@@ -65,11 +65,13 @@ RESET_VARS = (
 
 class PlayContext(Base):
 
-    '''
+    """
     This class is used to consolidate the connection information for
     hosts in a play and child tasks, where the task may override some
     connection/authentication information.
-    '''
+    """
+
+    _post_validate_object = True
 
     # base
     module_compression = FieldAttribute(isa='string', default=C.DEFAULT_MODULE_COMPRESSION)
@@ -88,7 +90,7 @@ class PlayContext(Base):
     # networking modules
     network_os = FieldAttribute(isa='string')
 
-    # docker FIXME: remove these
+    # FIXME: docker - remove these
     docker_extra_args = FieldAttribute(isa='string')
 
     # ???
@@ -103,10 +105,6 @@ class PlayContext(Base):
     become_flags = FieldAttribute(isa='string', default=C.DEFAULT_BECOME_FLAGS)
     prompt = FieldAttribute(isa='string')
 
-    # general flags
-    only_tags = FieldAttribute(isa='set', default=set)
-    skip_tags = FieldAttribute(isa='set', default=set)
-
     start_at_task = FieldAttribute(isa='string')
     step = FieldAttribute(isa='bool', default=False)
 
@@ -158,11 +156,11 @@ class PlayContext(Base):
         self.force_handlers = play.force_handlers
 
     def set_attributes_from_cli(self):
-        '''
+        """
         Configures this connection information instance with data from
         options specified by the user on the command line. These have a
         lower precedence than those set on the play or host.
-        '''
+        """
         if context.CLIARGS.get('timeout', False):
             self.timeout = int(context.CLIARGS['timeout'])
 
@@ -175,14 +173,14 @@ class PlayContext(Base):
         self.start_at_task = context.CLIARGS.get('start_at_task', None)  # Else default
 
     def set_task_and_variable_override(self, task, variables, templar):
-        '''
+        """
         Sets attributes from the task if they are set, which will override
         those from the play.
 
         :arg task: the task object with the parameters that were set on it
         :arg variables: variables from inventory
         :arg templar: templar instance if templating variables is needed
-        '''
+        """
 
         new_info = self.copy()
 
@@ -201,8 +199,7 @@ class PlayContext(Base):
             # In the case of a loop, the delegated_to host may have been
             # templated based on the loop variable, so we try and locate
             # the host name in the delegated variable dictionary here
-            delegated_host_name = templar.template(task.delegate_to)
-            delegated_vars = variables.get('ansible_delegated_vars', dict()).get(delegated_host_name, dict())
+            delegated_vars = variables.get('ansible_delegated_vars', dict()).get(task.delegate_to, dict())
 
             delegated_transport = C.DEFAULT_TRANSPORT
             for transport_var in C.MAGIC_VARIABLE_MAPPING.get('connection'):
@@ -218,8 +215,8 @@ class PlayContext(Base):
                 if address_var in delegated_vars:
                     break
             else:
-                display.debug("no remote address found for delegated host %s\nusing its name, so success depends on DNS resolution" % delegated_host_name)
-                delegated_vars['ansible_host'] = delegated_host_name
+                display.debug("no remote address found for delegated host %s\nusing its name, so success depends on DNS resolution" % task.delegate_to)
+                delegated_vars['ansible_host'] = task.delegate_to
 
             # reset the port back to the default if none was specified, to prevent
             # the delegated host from inheriting the original host's setting
@@ -312,10 +309,10 @@ class PlayContext(Base):
         self._become_plugin = plugin
 
     def update_vars(self, variables):
-        '''
+        """
         Adds 'magic' variables relating to connections to the variable dictionary provided.
         In case users need to access from the play, this is a legacy from runner.
-        '''
+        """
 
         for prop, var_list in C.MAGIC_VARIABLE_MAPPING.items():
             try:

ansible/playbook/playbook_include.py

@@ -19,38 +19,45 @@ 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.six import string_types
-from ansible.parsing.splitter import split_args
-from ansible.parsing.yaml.objects import AnsibleBaseYAMLObject, AnsibleMapping
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.base import Base
 from ansible.playbook.conditional import Conditional
 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.template import Templar
-from ansible.utils.display import Display
-
-display = Display()
+from ansible._internal._templating._engine import TemplateEngine
+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):
         return PlaybookInclude().load_data(ds=data, basedir=basedir, variable_manager=variable_manager, loader=loader)
 
     def load_data(self, ds, variable_manager=None, loader=None, basedir=None):
-        '''
+        """
         Overrides the base load_data(), as we're actually going to return a new
         Playbook() object rather than a PlaybookInclude object
-        '''
+        """
 
         # import here to avoid a dependency loop
         from ansible.playbook import Playbook
@@ -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 = Templar(loader=loader, variables=all_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,50 +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
-        new_ds = AnsibleMapping()
-        if isinstance(ds, AnsibleBaseYAMLObject):
-            new_ds.ansible_pos = ds.ansible_pos
-
-        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)
-
-        new_ds['import_playbook'] = items[0].strip()