ansible-core 2.19.4rc1__py3-none-any.whl → 2.20.0__py3-none-any.whl

ansible/parsing/dataloader.py

@@ -2,7 +2,6 @@
 # Copyright: (c) 2017, Ansible Project
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
-from __future__ import annotations
 from __future__ import annotations
 
 import copy
@@ -19,7 +18,6 @@ from ansible._internal._errors import _error_utils
 from ansible.module_utils.basic import is_executable
 from ansible._internal._datatag._tags import Origin, TrustedAsTemplate, SourceWasEncrypted
 from ansible.module_utils._internal._datatag import AnsibleTagHelper
-from ansible.module_utils.six import binary_type, text_type
 from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
 from ansible.parsing.quoting import unquote
 from ansible.parsing.utils.yaml import from_yaml
@@ -32,7 +30,7 @@ display = Display()
 
 # Tries to determine if a path is inside a role, last dir must be 'tasks'
 # this is not perfect but people should really avoid 'tasks' dirs outside roles when using Ansible.
-RE_TASKS = re.compile(u'(?:^|%s)+tasks%s?$' % (os.path.sep, os.path.sep))
+RE_TASKS = re.compile('(?:^|%s)+tasks%s?$' % (os.path.sep, os.path.sep))
 
 
 class DataLoader:
@@ -49,28 +47,27 @@ class DataLoader:
     Usage:
 
         dl = DataLoader()
-        # optionally: dl.set_vault_secrets([('default', ansible.parsing.vault.PrompVaultSecret(...),)])
+        # optionally: dl.set_vault_secrets([('default', ansible.parsing.vault.PromptVaultSecret(...),)])
         ds = dl.load('...')
         ds = dl.load_from_file('/path/to/file')
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
 
-        self._basedir = '.'
+        self._basedir: str = os.path.abspath('.')
 
         # NOTE: not effective with forks as the main copy does not get updated.
         # avoids rereading files
-        self._FILE_CACHE = dict()
+        self._FILE_CACHE: dict[str, object] = {}
 
         # NOTE: not thread safe, also issues with forks not returning data to main proc
         #       so they need to be cleaned independently. See WorkerProcess for example.
         # used to keep track of temp files for cleaning
-        self._tempfiles = set()
+        self._tempfiles: set[str] = set()
 
         # initialize the vault stuff with an empty password
         # TODO: replace with a ref to something that can get the password
         #       a creds/auth provider
-        self._vaults = {}
         self._vault = VaultLib()
         self.set_vault_secrets(None)
 
@@ -230,23 +227,19 @@ class DataLoader:
 
     def set_basedir(self, basedir: str) -> None:
         """ sets the base directory, used to find files when a relative path is given """
-
-        if basedir is not None:
-            self._basedir = to_text(basedir)
+        self._basedir = os.path.abspath(basedir)
 
     def path_dwim(self, given: str) -> str:
         """
         make relative paths work like folks expect.
         """
 
-        given = to_text(given, errors='surrogate_or_strict')
         given = unquote(given)
 
-        if given.startswith(to_text(os.path.sep)) or given.startswith(u'~'):
+        if given.startswith(os.path.sep) or given.startswith('~'):
             path = given
         else:
-            basedir = to_text(self._basedir, errors='surrogate_or_strict')
-            path = os.path.join(basedir, given)
+            path = os.path.join(self._basedir, given)
 
         return unfrackpath(path, follow=False)
 
@@ -294,10 +287,9 @@ class DataLoader:
         """
 
         search = []
-        source = to_text(source, errors='surrogate_or_strict')
 
         # I have full path, nothing else needs to be looked at
-        if source.startswith(to_text(os.path.sep)) or source.startswith(u'~'):
+        if source.startswith(os.path.sep) or source.startswith('~'):
             search.append(unfrackpath(source, follow=False))
         else:
             # base role/play path + templates/files/vars + relative filename
@@ -364,7 +356,7 @@ class DataLoader:
             if os.path.exists(to_bytes(test_path, errors='surrogate_or_strict')):
                 result = test_path
         else:
-            display.debug(u'evaluation_path:\n\t%s' % '\n\t'.join(paths))
+            display.debug('evaluation_path:\n\t%s' % '\n\t'.join(paths))
             for path in paths:
                 upath = unfrackpath(path, follow=False)
                 b_upath = to_bytes(upath, errors='surrogate_or_strict')
@@ -385,9 +377,9 @@ class DataLoader:
                 search.append(os.path.join(to_bytes(self.get_basedir(), errors='surrogate_or_strict'), b_dirname, b_source))
             search.append(os.path.join(to_bytes(self.get_basedir(), errors='surrogate_or_strict'), b_source))
 
-            display.debug(u'search_path:\n\t%s' % to_text(b'\n\t'.join(search)))
+            display.debug('search_path:\n\t%s' % to_text(b'\n\t'.join(search)))
             for b_candidate in search:
-                display.vvvvv(u'looking for "%s" at "%s"' % (source, to_text(b_candidate)))
+                display.vvvvv('looking for "%s" at "%s"' % (source, to_text(b_candidate)))
                 if os.path.exists(b_candidate):
                     result = to_text(b_candidate)
                     break
@@ -418,11 +410,10 @@ class DataLoader:
         Temporary files are cleanup in the destructor
         """
 
-        if not file_path or not isinstance(file_path, (binary_type, text_type)):
+        if not file_path or not isinstance(file_path, (bytes, str)):
             raise AnsibleParserError("Invalid filename: '%s'" % to_native(file_path))
 
-        b_file_path = to_bytes(file_path, errors='surrogate_or_strict')
-        if not self.path_exists(b_file_path) or not self.is_file(b_file_path):
+        if not self.path_exists(file_path) or not self.is_file(file_path):
             raise AnsibleFileNotFound(file_name=file_path)
 
         real_path = self.path_dwim(file_path)
@@ -480,7 +471,7 @@ class DataLoader:
         """
 
         b_path = to_bytes(os.path.join(path, name))
-        found = []
+        found: list[str] = []
 
         if extensions is None:
             # Look for file with no extension first to find dir before file
@@ -489,27 +480,29 @@ class DataLoader:
         for ext in extensions:
 
             if '.' in ext:
-                full_path = b_path + to_bytes(ext)
+                b_full_path = b_path + to_bytes(ext)
             elif ext:
-                full_path = b'.'.join([b_path, to_bytes(ext)])
+                b_full_path = b'.'.join([b_path, to_bytes(ext)])
             else:
-                full_path = b_path
+                b_full_path = b_path
+
+            full_path = to_text(b_full_path)
 
             if self.path_exists(full_path):
                 if self.is_directory(full_path):
                     if allow_dir:
-                        found.extend(self._get_dir_vars_files(to_text(full_path), extensions))
+                        found.extend(self._get_dir_vars_files(full_path, extensions))
                     else:
                         continue
                 else:
-                    found.append(to_text(full_path))
+                    found.append(full_path)
                 break
         return found
 
     def _get_dir_vars_files(self, path: str, extensions: list[str]) -> list[str]:
         found = []
         for spath in sorted(self.list_directory(path)):
-            if not spath.startswith(u'.') and not spath.endswith(u'~'):  # skip hidden and backups
+            if not spath.startswith('.') and not spath.endswith('~'):  # skip hidden and backups
 
                 ext = os.path.splitext(spath)[-1]
                 full_spath = os.path.join(path, spath)

ansible/parsing/vault/__init__.py

@@ -59,7 +59,6 @@ except ImportError:
 
 from ansible.errors import AnsibleError, AnsibleAssertionError
 from ansible import constants as C
-from ansible.module_utils.six import binary_type
 from ansible.module_utils.common.text.converters import to_bytes, to_text, to_native
 from ansible.utils.display import Display
 from ansible.utils.path import makedirs_safe, unfrackpath
@@ -1237,7 +1236,7 @@ class VaultAES256:
 
         It would be nice if there were a library for this but hey.
         """
-        if not (isinstance(b_a, binary_type) and isinstance(b_b, binary_type)):
+        if not (isinstance(b_a, bytes) and isinstance(b_b, bytes)):
             raise TypeError('_is_equal can only be used to compare two byte strings')
 
         # http://codahale.com/a-lesson-in-timing-attacks/

ansible/playbook/base.py

@@ -19,7 +19,6 @@ from ansible import context
 from ansible.errors import AnsibleError, AnsibleParserError, AnsibleAssertionError, AnsibleValueOmittedError, AnsibleFieldAttributeError
 from ansible.module_utils.datatag import native_type_name
 from ansible._internal._datatag._tags import Origin
-from ansible.module_utils.six import string_types
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.module_utils.common.sentinel import Sentinel
 from ansible.module_utils.common.text.converters import to_text
@@ -37,7 +36,7 @@ display = Display()
 def _validate_action_group_metadata(action, found_group_metadata, fq_group_name):
     valid_metadata = {
         'extend_group': {
-            'types': (list, string_types,),
+            'types': (list, str,),
             'errortype': 'list',
         },
     }
@@ -204,7 +203,7 @@ class FieldAttributeBase:
             value = self.set_to_context(attr.name)
 
         valid_values = frozenset(('always', 'on_failed', 'on_unreachable', 'on_skipped', 'never'))
-        if value and isinstance(value, string_types) and value not in valid_values:
+        if value and isinstance(value, str) and value not in valid_values:
             raise AnsibleParserError("'%s' is not a valid value for debugger. Must be one of %s" % (value, ', '.join(valid_values)), obj=self.get_ds())
         return value
 
@@ -350,14 +349,14 @@ class FieldAttributeBase:
         found_group_metadata = False
         for action in action_group:
             # Everything should be a string except the metadata entry
-            if not isinstance(action, string_types):
+            if not isinstance(action, str):
                 _validate_action_group_metadata(action, found_group_metadata, fq_group_name)
 
                 if isinstance(action['metadata'], dict):
                     found_group_metadata = True
 
                     include_groups = action['metadata'].get('extend_group', [])
-                    if isinstance(include_groups, string_types):
+                    if isinstance(include_groups, str):
                         include_groups = [include_groups]
                     if not isinstance(include_groups, list):
                         # Bad entries may be a warning above, but prevent tracebacks by setting it back to the acceptable type.
@@ -472,7 +471,7 @@ class FieldAttributeBase:
         elif attribute.isa == 'percent':
             # special value, which may be an integer or float
             # with an optional '%' at the end
-            if isinstance(value, string_types) and '%' in value:
+            if isinstance(value, str) and '%' in value:
                 value = value.replace('%', '')
             value = float(value)
         elif attribute.isa == 'list':
@@ -660,8 +659,8 @@ class FieldAttributeBase:
         attrs = {}
         for (name, attribute) in self.fattributes.items():
             attr = getattr(self, name)
-            if attribute.isa == 'class' and hasattr(attr, 'serialize'):
-                attrs[name] = attr.serialize()
+            if attribute.isa == 'class':
+                attrs[name] = attr.dump_attrs()
             else:
                 attrs[name] = attr
         return attrs
@@ -675,60 +674,13 @@ class FieldAttributeBase:
                 attribute = self.fattributes[attr]
                 if attribute.isa == 'class' and isinstance(value, dict):
                     obj = attribute.class_type()
-                    obj.deserialize(value)
+                    obj.from_attrs(value)
                     setattr(self, attr, obj)
                 else:
                     setattr(self, attr, value)
             else:
                 setattr(self, attr, value)  # overridden dump_attrs in derived types may dump attributes which are not field attributes
 
-        # from_attrs is only used to create a finalized task
-        # from attrs from the Worker/TaskExecutor
-        # Those attrs are finalized and squashed in the TE
-        # and controller side use needs to reflect that
-        self._finalized = True
-        self._squashed = True
-
-    def serialize(self):
-        """
-        Serializes the object derived from the base object into
-        a dictionary of values. This only serializes the field
-        attributes for the object, so this may need to be overridden
-        for any classes which wish to add additional items not stored
-        as field attributes.
-        """
-
-        repr = self.dump_attrs()
-
-        # serialize the uuid field
-        repr['uuid'] = self._uuid
-        repr['finalized'] = self._finalized
-        repr['squashed'] = self._squashed
-
-        return repr
-
-    def deserialize(self, data):
-        """
-        Given a dictionary of values, load up the field attributes for
-        this object. As with serialize(), if there are any non-field
-        attribute data members, this method will need to be overridden
-        and extended.
-        """
-
-        if not isinstance(data, dict):
-            raise AnsibleAssertionError('data (%s) should be a dict but is a %s' % (data, type(data)))
-
-        for (name, attribute) in self.fattributes.items():
-            if name in data:
-                setattr(self, name, data[name])
-            else:
-                self.set_to_context(name)
-
-        # restore the UUID field
-        setattr(self, '_uuid', data.get('uuid'))
-        self._finalized = data.get('finalized', False)
-        self._squashed = data.get('squashed', False)
-
 
 class Base(FieldAttributeBase):
 

ansible/playbook/block.py

@@ -26,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
 
 
@@ -219,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:

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

@@ -232,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):
@@ -390,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()
@@ -428,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)