ansible-core 2.18.4rc1__py3-none-any.whl → 2.19.0b1__py3-none-any.whl

ansible/template/native_helpers.py

@@ -1,251 +0,0 @@
-# Copyright: (c) 2018, Ansible Project
-# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
-
-from __future__ import annotations
-
-
-import ast
-from collections.abc import Mapping
-from itertools import islice, chain
-from types import GeneratorType
-
-from ansible.module_utils.common.collections import is_sequence
-from ansible.module_utils.common.text.converters import to_text
-from ansible.module_utils.six import string_types
-from ansible.parsing.yaml.objects import AnsibleVaultEncryptedUnicode
-from ansible.utils.native_jinja import NativeJinjaText
-from ansible.utils.unsafe_proxy import wrap_var
-import ansible.module_utils.compat.typing as t
-
-from jinja2.runtime import StrictUndefined
-
-
-_JSON_MAP = {
-    "true": True,
-    "false": False,
-    "null": None,
-}
-
-
-class Json2Python(ast.NodeTransformer):
-    def visit_Name(self, node):
-        if node.id not in _JSON_MAP:
-            return node
-        return ast.Constant(value=_JSON_MAP[node.id])
-
-
-def _is_unsafe(value: t.Any) -> bool:
-    """
-    Our helper function, which will also recursively check dict and
-    list entries due to the fact that they may be repr'd and contain
-    a key or value which contains jinja2 syntax and would otherwise
-    lose the AnsibleUnsafe value.
-    """
-    to_check = [value]
-    seen = set()
-
-    while True:
-        if not to_check:
-            break
-
-        val = to_check.pop(0)
-        val_id = id(val)
-
-        if val_id in seen:
-            continue
-        seen.add(val_id)
-
-        if isinstance(val, AnsibleUndefined):
-            continue
-        if isinstance(val, Mapping):
-            to_check.extend(val.keys())
-            to_check.extend(val.values())
-        elif is_sequence(val):
-            to_check.extend(val)
-        elif getattr(val, '__UNSAFE__', False):
-            return True
-
-    return False
-
-
-def ansible_eval_concat(nodes):
-    """Return a string of concatenated compiled nodes. Throw an undefined error
-    if any of the nodes is undefined.
-
-    If the result of concat appears to be a dictionary, list or bool,
-    try and convert it to such using literal_eval, the same mechanism as used
-    in jinja2_native.
-
-    Used in Templar.template() when jinja2_native=False and convert_data=True.
-    """
-    head = list(islice(nodes, 2))
-
-    if not head:
-        return ''
-
-    unsafe = False
-
-    if len(head) == 1:
-        out = head[0]
-
-        if isinstance(out, NativeJinjaText):
-            return out
-
-        unsafe = _is_unsafe(out)
-        out = to_text(out)
-    else:
-        if isinstance(nodes, GeneratorType):
-            nodes = chain(head, nodes)
-
-        out_values = []
-        for v in nodes:
-            if not unsafe and _is_unsafe(v):
-                unsafe = True
-
-            out_values.append(to_text(v))
-
-        out = ''.join(out_values)
-
-    # if this looks like a dictionary, list or bool, convert it to such
-    if out.startswith(('{', '[')) or out in ('True', 'False'):
-        try:
-            out = ast.literal_eval(
-                ast.fix_missing_locations(
-                    Json2Python().visit(
-                        ast.parse(out, mode='eval')
-                    )
-                )
-            )
-        except (TypeError, ValueError, SyntaxError, MemoryError):
-            pass
-
-    if unsafe:
-        out = wrap_var(out)
-
-    return out
-
-
-def ansible_concat(nodes):
-    """Return a string of concatenated compiled nodes. Throw an undefined error
-    if any of the nodes is undefined. Other than that it is equivalent to
-    Jinja2's default concat function.
-
-    Used in Templar.template() when jinja2_native=False and convert_data=False.
-    """
-    unsafe = False
-    values = []
-    for v in nodes:
-        if not unsafe and _is_unsafe(v):
-            unsafe = True
-
-        values.append(to_text(v))
-
-    out = ''.join(values)
-    if unsafe:
-        out = wrap_var(out)
-
-    return out
-
-
-def ansible_native_concat(nodes):
-    """Return a native Python type from the list of compiled nodes. If the
-    result is a single node, its value is returned. Otherwise, the nodes are
-    concatenated as strings. If the result can be parsed with
-    :func:`ast.literal_eval`, the parsed value is returned. Otherwise, the
-    string is returned.
-
-    https://github.com/pallets/jinja/blob/master/src/jinja2/nativetypes.py
-    """
-    head = list(islice(nodes, 2))
-
-    if not head:
-        return None
-
-    unsafe = False
-
-    if len(head) == 1:
-        out = head[0]
-
-        # TODO send unvaulted data to literal_eval?
-        if isinstance(out, AnsibleVaultEncryptedUnicode):
-            return out.data
-
-        if isinstance(out, NativeJinjaText):
-            # Sometimes (e.g. ``| string``) we need to mark variables
-            # in a special way so that they remain strings and are not
-            # passed into literal_eval.
-            # See:
-            # https://github.com/ansible/ansible/issues/70831
-            # https://github.com/pallets/jinja/issues/1200
-            # https://github.com/ansible/ansible/issues/70831#issuecomment-664190894
-            return out
-
-        # short-circuit literal_eval for anything other than strings
-        if not isinstance(out, string_types):
-            return out
-
-        unsafe = _is_unsafe(out)
-
-    else:
-        if isinstance(nodes, GeneratorType):
-            nodes = chain(head, nodes)
-
-        out_values = []
-        for v in nodes:
-            if not unsafe and _is_unsafe(v):
-                unsafe = True
-
-            out_values.append(to_text(v))
-
-        out = ''.join(out_values)
-
-    try:
-        evaled = ast.literal_eval(
-            # In Python 3.10+ ast.literal_eval removes leading spaces/tabs
-            # from the given string. For backwards compatibility we need to
-            # parse the string ourselves without removing leading spaces/tabs.
-            ast.parse(out, mode='eval')
-        )
-    except (TypeError, ValueError, SyntaxError, MemoryError):
-        if unsafe:
-            out = wrap_var(out)
-
-        return out
-
-    if isinstance(evaled, string_types):
-        quote = out[0]
-        evaled = f'{quote}{evaled}{quote}'
-
-    if unsafe:
-        evaled = wrap_var(evaled)
-
-    return evaled
-
-
-class AnsibleUndefined(StrictUndefined):
-    """
-    A custom Undefined class, which returns further Undefined objects on access,
-    rather than throwing an exception.
-    """
-    def __getattr__(self, name):
-        if name == '__UNSAFE__':
-            # AnsibleUndefined should never be assumed to be unsafe
-            # This prevents ``hasattr(val, '__UNSAFE__')`` from evaluating to ``True``
-            raise AttributeError(name)
-        # Return original Undefined object to preserve the first failure context
-        return self
-
-    def __getitem__(self, key):
-        # Return original Undefined object to preserve the first failure context
-        return self
-
-    def __repr__(self):
-        return 'AnsibleUndefined(hint={0!r}, obj={1!r}, name={2!r})'.format(
-            self._undefined_hint,
-            self._undefined_obj,
-            self._undefined_name
-        )
-
-    def __contains__(self, item):
-        # Return original Undefined object to preserve the first failure context
-        return self

ansible/template/template.py

@@ -1,43 +0,0 @@
-# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
-#
-# This file is part of Ansible
-#
-# Ansible is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Ansible is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
-
-from __future__ import annotations
-
-from jinja2.nativetypes import NativeTemplate
-
-__all__ = ['AnsibleJ2Template']
-
-
-class AnsibleJ2Template(NativeTemplate):
-    '''
-    A helper class, which prevents Jinja2 from running AnsibleJ2Vars through dict().
-    Without this, {% include %} and similar will create new contexts unlike the special
-    one created in Templar.template. This ensures they are all alike, except for
-    potential locals.
-    '''
-
-    def new_context(self, vars=None, shared=False, locals=None):
-        if vars is None:
-            vars = dict(self.globals or ())
-
-        if isinstance(vars, dict):
-            vars = vars.copy()
-            if locals is not None:
-                vars.update(locals)
-        else:
-            vars = vars.add_locals(locals)
-        return self.environment.context_class(self.environment, vars, self.name, self.blocks)

ansible/template/vars.py

@@ -1,77 +0,0 @@
-# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
-# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
-from __future__ import annotations
-
-from collections import ChainMap
-
-from jinja2.utils import missing
-
-from ansible.errors import AnsibleError, AnsibleUndefinedVariable
-from ansible.module_utils.common.text.converters import to_native
-
-
-__all__ = ['AnsibleJ2Vars']
-
-
-def _process_locals(_l):
-    if _l is None:
-        return {}
-    return {
-        k: v for k, v in _l.items()
-        if v is not missing
-        and k not in {'context', 'environment', 'template'}  # NOTE is this really needed?
-    }
-
-
-class AnsibleJ2Vars(ChainMap):
-    """Helper variable storage class that allows for nested variables templating: `foo: "{{ bar }}"`."""
-
-    def __init__(self, templar, globals, locals=None):
-        self._templar = templar
-        super().__init__(
-            _process_locals(locals),  # first mapping has the highest precedence
-            self._templar.available_variables,
-            globals,
-        )
-
-    def __getitem__(self, varname):
-        variable = super().__getitem__(varname)
-
-        from ansible.vars.hostvars import HostVars
-        if (varname == "vars" and isinstance(variable, dict)) or isinstance(variable, HostVars) or hasattr(variable, '__UNSAFE__'):
-            return variable
-
-        try:
-            return self._templar.template(variable)
-        except AnsibleUndefinedVariable as e:
-            # Instead of failing here prematurely, return an Undefined
-            # object which fails only after its first usage allowing us to
-            # do lazy evaluation and passing it into filters/tests that
-            # operate on such objects.
-            return self._templar.environment.undefined(
-                hint=f"{variable}: {e.message}",
-                name=varname,
-                exc=AnsibleUndefinedVariable,
-            )
-        except Exception as e:
-            msg = getattr(e, 'message', None) or to_native(e)
-            raise AnsibleError(
-                f"An unhandled exception occurred while templating '{to_native(variable)}'. "
-                f"Error was a {type(e)}, original message: {msg}"
-            )
-
-    def add_locals(self, locals):
-        """If locals are provided, create a copy of self containing those
-        locals in addition to what is already in this variable proxy.
-        """
-        if locals is None:
-            return self
-
-        current_locals = self.maps[0]
-        current_globals = self.maps[2]
-
-        # prior to version 2.9, locals contained all of the vars and not just the current
-        # local vars so this was not necessary for locals to propagate down to nested includes
-        new_locals = current_locals | locals
-
-        return AnsibleJ2Vars(self._templar, current_globals, locals=new_locals)

ansible/utils/native_jinja.py

@@ -1,11 +0,0 @@
-# Copyright: (c) 2020, 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 ansible.module_utils.six import text_type
-
-
-class NativeJinjaText(text_type):
-    pass

ansible/vars/fact_cache.py

@@ -1,71 +0,0 @@
-# Copyright: (c) 2014, Michael DeHaan <michael.dehaan@gmail.com>
-# Copyright: (c) 2018, 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 collections.abc import MutableMapping
-
-from ansible import constants as C
-from ansible.errors import AnsibleError
-from ansible.plugins.loader import cache_loader
-from ansible.utils.display import Display
-
-
-display = Display()
-
-
-class FactCache(MutableMapping):
-
-    def __init__(self, *args, **kwargs):
-
-        self._plugin = cache_loader.get(C.CACHE_PLUGIN)
-        if not self._plugin:
-            raise AnsibleError('Unable to load the facts cache plugin (%s).' % (C.CACHE_PLUGIN))
-
-        super(FactCache, self).__init__(*args, **kwargs)
-
-    def __getitem__(self, key):
-        if not self._plugin.contains(key):
-            raise KeyError
-        return self._plugin.get(key)
-
-    def __setitem__(self, key, value):
-        self._plugin.set(key, value)
-
-    def __delitem__(self, key):
-        self._plugin.delete(key)
-
-    def __contains__(self, key):
-        return self._plugin.contains(key)
-
-    def __iter__(self):
-        return iter(self._plugin.keys())
-
-    def __len__(self):
-        return len(self._plugin.keys())
-
-    def copy(self):
-        """ Return a primitive copy of the keys and values from the cache. """
-        return dict(self)
-
-    def keys(self):
-        return self._plugin.keys()
-
-    def flush(self):
-        """ Flush the fact cache of all keys. """
-        self._plugin.flush()
-
-    def first_order_merge(self, key, value):
-        host_facts = {key: value}
-
-        try:
-            host_cache = self._plugin.get(key)
-            if host_cache:
-                host_cache.update(value)
-                host_facts[key] = host_cache
-        except KeyError:
-            pass
-
-        super(FactCache, self).update(host_facts)