ansible-core 2.18.5rc1__py3-none-any.whl → 2.19.0b2__py3-none-any.whl

ansible/utils/unsafe_proxy.py

@@ -1,329 +1,42 @@
-# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
-# --------------------------------------------
-#
-# 1. This LICENSE AGREEMENT is between the Python Software Foundation
-# ("PSF"), and the Individual or Organization ("Licensee") accessing and
-# otherwise using this software ("Python") in source or binary form and
-# its associated documentation.
-#
-# 2. Subject to the terms and conditions of this License Agreement, PSF hereby
-# grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
-# analyze, test, perform and/or display publicly, prepare derivative works,
-# distribute, and otherwise use Python alone or in any derivative version,
-# provided, however, that PSF's License Agreement and PSF's notice of copyright,
-# i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
-# 2011, 2012, 2013, 2014 Python Software Foundation; All Rights Reserved" are
-# retained in Python alone or in any derivative version prepared by Licensee.
-#
-# 3. In the event Licensee prepares a derivative work that is based on
-# or incorporates Python or any part thereof, and wants to make
-# the derivative work available to others as provided herein, then
-# Licensee hereby agrees to include in any such work a brief summary of
-# the changes made to Python.
-#
-# 4. PSF is making Python available to Licensee on an "AS IS"
-# basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
-# IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
-# DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
-# FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
-# INFRINGE ANY THIRD PARTY RIGHTS.
-#
-# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
-# FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
-# A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
-# OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
-#
-# 6. This License Agreement will automatically terminate upon a material
-# breach of its terms and conditions.
-#
-# 7. Nothing in this License Agreement shall be deemed to create any
-# relationship of agency, partnership, or joint venture between PSF and
-# Licensee.  This License Agreement does not grant permission to use PSF
-# trademarks or trade name in a trademark sense to endorse or promote
-# products or services of Licensee, or any third party.
-#
-# 8. By copying, installing or otherwise using Python, Licensee
-# agrees to be bound by the terms and conditions of this License
-# Agreement.
-#
-# Original Python Recipe for Proxy:
-# http://code.activestate.com/recipes/496741-object-proxying/
-# Author: Tomer Filiba
+# Copyright: (c) 2023, Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
+# deprecated: description="deprecate unsafe_proxy module" core_version="2.23"
+# DTFIX-RELEASE: add full unit test coverage
 from __future__ import annotations
 
-import sys
-import types
-import warnings
-from sys import intern as _sys_intern
 from collections.abc import Mapping, Set
 
 from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.module_utils.common.collections import is_sequence
-from ansible.utils.native_jinja import NativeJinjaText
+from ansible._internal._datatag._tags import TrustedAsTemplate
+from ansible.module_utils.six import binary_type, text_type
 
+import typing as t
 
 __all__ = ['AnsibleUnsafe', 'wrap_var']
 
+T = t.TypeVar('T')
 
-class AnsibleUnsafe(object):
-    __UNSAFE__ = True
 
+class AnsibleUnsafe:
+    def __new__(cls, value):
+        return TrustedAsTemplate.untag(value)
 
-class AnsibleUnsafeBytes(bytes, AnsibleUnsafe):
-    def _strip_unsafe(self):
-        return super().__bytes__()
 
-    def __reduce__(self, /):
-        return (self.__class__, (self._strip_unsafe(),))
+class AnsibleUnsafeBytes(bytes):
+    def __new__(cls, value):
+        return TrustedAsTemplate.untag(value)
 
-    def __str__(self, /):  # pylint: disable=invalid-str-returned
-        return self.decode()
 
-    def __bytes__(self, /):  # pylint: disable=invalid-bytes-returned
-        return self
+class AnsibleUnsafeText(str):
+    def __new__(cls, value):
+        return TrustedAsTemplate.untag(value)
 
-    def __repr__(self, /):  # pylint: disable=invalid-repr-returned
-        return AnsibleUnsafeText(super().__repr__())
 
-    def __format__(self, format_spec, /):  # pylint: disable=invalid-format-returned
-        return AnsibleUnsafeText(super().__format__(format_spec))
-
-    def __getitem__(self, key, /):
-        if isinstance(key, int):
-            return super().__getitem__(key)
-        return self.__class__(super().__getitem__(key))
-
-    def __reversed__(self, /):
-        return self[::-1]
-
-    def __add__(self, value, /):
-        return self.__class__(super().__add__(value))
-
-    def __radd__(self, value, /):
-        return self.__class__(value.__add__(self))
-
-    def __mul__(self, value, /):
-        return self.__class__(super().__mul__(value))
-
-    __rmul__ = __mul__
-
-    def __mod__(self, value, /):
-        return self.__class__(super().__mod__(value))
-
-    def __rmod__(self, value, /):
-        return self.__class__(super().__rmod__(value))
-
-    def capitalize(self, /):
-        return self.__class__(super().capitalize())
-
-    def center(self, width, fillchar=b' ', /):
-        return self.__class__(super().center(width, fillchar))
-
-    def decode(self, /, encoding='utf-8', errors='strict'):
-        return AnsibleUnsafeText(super().decode(encoding=encoding, errors=errors))
-
-    def removeprefix(self, prefix, /):
-        return self.__class__(super().removeprefix(prefix))
-
-    def removesuffix(self, suffix, /):
-        return self.__class__(super().removesuffix(suffix))
-
-    def expandtabs(self, /, tabsize=8):
-        return self.__class__(super().expandtabs(tabsize))
-
-    def join(self, iterable_of_bytes, /):
-        return self.__class__(super().join(iterable_of_bytes))
-
-    def ljust(self, width, fillchar=b' ', /):
-        return self.__class__(super().ljust(width, fillchar))
-
-    def lower(self, /):
-        return self.__class__(super().lower())
-
-    def lstrip(self, chars=None, /):
-        return self.__class__(super().lstrip(chars))
-
-    def partition(self, sep, /):
-        cls = self.__class__
-        return tuple(cls(e) for e in super().partition(sep))
-
-    def replace(self, old, new, count=-1, /):
-        return self.__class__(super().replace(old, new, count))
-
-    def rjust(self, width, fillchar=b' ', /):
-        return self.__class__(super().rjust(width, fillchar))
-
-    def rpartition(self, sep, /):
-        cls = self.__class__
-        return tuple(cls(e) for e in super().rpartition(sep))
-
-    def rstrip(self, chars=None, /):
-        return self.__class__(super().rstrip(chars))
-
-    def split(self, /, sep=None, maxsplit=-1):
-        cls = self.__class__
-        return [cls(e) for e in super().split(sep=sep, maxsplit=maxsplit)]
-
-    def rsplit(self, /, sep=None, maxsplit=-1):
-        cls = self.__class__
-        return [cls(e) for e in super().rsplit(sep=sep, maxsplit=maxsplit)]
-
-    def splitlines(self, /, keepends=False):
-        cls = self.__class__
-        return [cls(e) for e in super().splitlines(keepends=keepends)]
-
-    def strip(self, chars=None, /):
-        return self.__class__(super().strip(chars))
-
-    def swapcase(self, /):
-        return self.__class__(super().swapcase())
-
-    def title(self, /):
-        return self.__class__(super().title())
-
-    def translate(self, table, /, delete=b''):
-        return self.__class__(super().translate(table, delete=delete))
-
-    def upper(self, /):
-        return self.__class__(super().upper())
-
-    def zfill(self, width, /):
-        return self.__class__(super().zfill(width))
-
-
-class AnsibleUnsafeText(str, AnsibleUnsafe):
-    def _strip_unsafe(self, /):
-        return super().__str__()
-
-    def __reduce__(self, /):
-        return (self.__class__, (self._strip_unsafe(),))
-
-    def __str__(self, /):  # pylint: disable=invalid-str-returned
-        return self
-
-    def __repr__(self, /):  # pylint: disable=invalid-repr-returned
-        return self.__class__(super().__repr__())
-
-    def __format__(self, format_spec, /):  # pylint: disable=invalid-format-returned
-        return self.__class__(super().__format__(format_spec))
-
-    def __getitem__(self, key, /):
-        return self.__class__(super().__getitem__(key))
-
-    def __iter__(self, /):
-        cls = self.__class__
-        return (cls(c) for c in super().__iter__())
-
-    def __reversed__(self, /):
-        return self[::-1]
-
-    def __add__(self, value, /):
-        return self.__class__(super().__add__(value))
-
-    def __radd__(self, value, /):
-        return self.__class__(value.__add__(self))
-
-    def __mul__(self, value, /):
-        return self.__class__(super().__mul__(value))
-
-    __rmul__ = __mul__
-
-    def __mod__(self, value, /):
-        return self.__class__(super().__mod__(value))
-
-    def __rmod__(self, value, /):
-        return self.__class__(super().__rmod__(value))
-
-    def capitalize(self, /):
-        return self.__class__(super().capitalize())
-
-    def casefold(self, /):
-        return self.__class__(super().casefold())
-
-    def center(self, width, fillchar=' ', /):
-        return self.__class__(super().center(width, fillchar))
-
-    def encode(self, /, encoding='utf-8', errors='strict'):
-        return AnsibleUnsafeBytes(super().encode(encoding=encoding, errors=errors))
-
-    def removeprefix(self, prefix, /):
-        return self.__class__(super().removeprefix(prefix))
-
-    def removesuffix(self, suffix, /):
-        return self.__class__(super().removesuffix(suffix))
-
-    def expandtabs(self, /, tabsize=8):
-        return self.__class__(super().expandtabs(tabsize))
-
-    def format(self, /, *args, **kwargs):
-        return self.__class__(super().format(*args, **kwargs))
-
-    def format_map(self, mapping, /):
-        return self.__class__(super().format_map(mapping))
-
-    def join(self, iterable, /):
-        return self.__class__(super().join(iterable))
-
-    def ljust(self, width, fillchar=' ', /):
-        return self.__class__(super().ljust(width, fillchar))
-
-    def lower(self, /):
-        return self.__class__(super().lower())
-
-    def lstrip(self, chars=None, /):
-        return self.__class__(super().lstrip(chars))
-
-    def partition(self, sep, /):
-        cls = self.__class__
-        return tuple(cls(e) for e in super().partition(sep))
-
-    def replace(self, old, new, count=-1, /):
-        return self.__class__(super().replace(old, new, count))
-
-    def rjust(self, width, fillchar=' ', /):
-        return self.__class__(super().rjust(width, fillchar))
-
-    def rpartition(self, sep, /):
-        cls = self.__class__
-        return tuple(cls(e) for e in super().rpartition(sep))
-
-    def rstrip(self, chars=None, /):
-        return self.__class__(super().rstrip(chars))
-
-    def split(self, /, sep=None, maxsplit=-1):
-        cls = self.__class__
-        return [cls(e) for e in super().split(sep=sep, maxsplit=maxsplit)]
-
-    def rsplit(self, /, sep=None, maxsplit=-1):
-        cls = self.__class__
-        return [cls(e) for e in super().rsplit(sep=sep, maxsplit=maxsplit)]
-
-    def splitlines(self, /, keepends=False):
-        cls = self.__class__
-        return [cls(e) for e in super().splitlines(keepends=keepends)]
-
-    def strip(self, chars=None, /):
-        return self.__class__(super().strip(chars))
-
-    def swapcase(self, /):
-        return self.__class__(super().swapcase())
-
-    def title(self, /):
-        return self.__class__(super().title())
-
-    def translate(self, table, /):
-        return self.__class__(super().translate(table))
-
-    def upper(self, /):
-        return self.__class__(super().upper())
-
-    def zfill(self, width, /):
-        return self.__class__(super().zfill(width))
-
-
-class NativeJinjaUnsafeText(NativeJinjaText, AnsibleUnsafeText):
-    pass
+class NativeJinjaUnsafeText(str):
+    def __new__(cls, value):
+        return TrustedAsTemplate.untag(value)
 
 
 def _wrap_dict(v):
@@ -343,6 +56,7 @@ def _wrap_set(v):
 
 
 def wrap_var(v):
+    # maintain backward compat by recursively *un* marking TrustedAsTemplate
     if v is None or isinstance(v, AnsibleUnsafe):
         return v
 
@@ -352,11 +66,9 @@ def wrap_var(v):
         v = _wrap_set(v)
     elif is_sequence(v):
         v = _wrap_sequence(v)
-    elif isinstance(v, NativeJinjaText):
-        v = NativeJinjaUnsafeText(v)
-    elif isinstance(v, bytes):
+    elif isinstance(v, binary_type):
         v = AnsibleUnsafeBytes(v)
-    elif isinstance(v, str):
+    elif isinstance(v, text_type):
         v = AnsibleUnsafeText(v)
 
     return v
@@ -368,24 +80,3 @@ def to_unsafe_bytes(*args, **kwargs):
 
 def to_unsafe_text(*args, **kwargs):
     return wrap_var(to_text(*args, **kwargs))
-
-
-def _is_unsafe(obj):
-    return getattr(obj, '__UNSAFE__', False) is True
-
-
-def _intern(string):
-    """This is a monkey patch for ``sys.intern`` that will strip
-    the unsafe wrapper prior to interning the string.
-
-    This will not exist in future versions.
-    """
-    if isinstance(string, AnsibleUnsafeText):
-        string = string._strip_unsafe()
-    return _sys_intern(string)
-
-
-if isinstance(sys.intern, types.BuiltinFunctionType):
-    sys.intern = _intern
-else:
-    warnings.warn("skipped sys.intern patch; appears to have already been patched", RuntimeWarning)

ansible/utils/vars.py

@@ -20,17 +20,19 @@ from __future__ import annotations
 import keyword
 import secrets
 import uuid
+import typing as t
 
 from collections.abc import MutableMapping, MutableSequence
 from json import dumps
 
 from ansible import constants as C
 from ansible import context
+from ansible._internal import _json
 from ansible.errors import AnsibleError, AnsibleOptionsError
-from ansible.module_utils.six import string_types
+from ansible.module_utils.datatag import native_type_name
 from ansible.module_utils.common.text.converters import to_native, to_text
 from ansible.parsing.splitter import parse_kv
-
+from ansible.parsing.dataloader import DataLoader
 
 _MAXSIZE = 2 ** 32
 cur_id = 0
@@ -178,19 +180,18 @@ def merge_hash(x, y, recursive=True, list_merge='replace'):
     return x
 
 
-def load_extra_vars(loader):
+def load_extra_vars(loader: DataLoader) -> dict[str, t.Any]:
 
     if not getattr(load_extra_vars, 'extra_vars', None):
-        extra_vars = {}
+        extra_vars: dict[str, t.Any] = {}
         for extra_vars_opt in context.CLIARGS.get('extra_vars', tuple()):
-            data = None
             extra_vars_opt = to_text(extra_vars_opt, errors='surrogate_or_strict')
             if extra_vars_opt is None or not extra_vars_opt:
                 continue
 
             if extra_vars_opt.startswith(u"@"):
                 # Argument is a YAML file (JSON is a subset of YAML)
-                data = loader.load_from_file(extra_vars_opt[1:])
+                data = loader.load_from_file(extra_vars_opt[1:], trusted_as_template=True)
             elif extra_vars_opt[0] in [u'/', u'.']:
                 raise AnsibleOptionsError("Please prepend extra_vars filename '%s' with '@'" % extra_vars_opt)
             elif extra_vars_opt[0] in [u'[', u'{']:
@@ -205,7 +206,7 @@ def load_extra_vars(loader):
             else:
                 raise AnsibleOptionsError("Invalid extra vars data supplied. '%s' could not be made into a dictionary" % extra_vars_opt)
 
-        setattr(load_extra_vars, 'extra_vars', extra_vars)
+        load_extra_vars.extra_vars = extra_vars
 
     return load_extra_vars.extra_vars
 
@@ -251,7 +252,7 @@ def isidentifier(ident):
 
     Originally posted at https://stackoverflow.com/a/29586366
     """
-    if not isinstance(ident, string_types):
+    if not isinstance(ident, str):
         return False
 
     if not ident.isascii():
@@ -264,3 +265,45 @@ def isidentifier(ident):
         return False
 
     return True
+
+
+def validate_variable_name(name: object) -> None:
+    """Validate the given variable name is valid, raising an AnsibleError if it is not."""
+    if isinstance(name, str) and isidentifier(name):
+        return
+
+    if isinstance(name, (str, int, float, bool, type(None))):
+        key_description = f'name {str(name)!r}'  # show common scalar key names as strings
+    else:
+        key_description = 'name'
+
+    if not isinstance(name, str):
+        key_description += f' of type {native_type_name(name)!r}'  # show the type name of all non-string keys
+
+    raise AnsibleError(
+        message=f'Invalid variable {key_description}.',
+        help_text='Variable names must be strings starting with a letter or underscore character, and contain only letters, numbers and underscores.',
+        obj=name,
+    )
+
+
+def transform_to_native_types(
+    value: object,
+    redact: bool = True,
+) -> object:
+    """
+    Recursively transform the given value to Python native types.
+    Potentially sensitive values such as individually vaulted variables will be redacted unless ``redact=False`` is passed.
+    Which values are considered potentially sensitive may change in future releases.
+    Types which cannot be converted to Python native types will result in an error.
+    """
+    avv = _json.AnsibleVariableVisitor(
+        convert_mapping_to_dict=True,
+        convert_sequence_to_list=True,
+        convert_custom_scalars=True,
+        convert_to_native_values=True,
+        apply_transforms=True,
+        encrypted_string_behavior=_json.EncryptedStringBehavior.REDACT if redact else _json.EncryptedStringBehavior.DECRYPT,
+    )
+
+    return avv.visit(value)

ansible/utils/version.py

@@ -11,7 +11,7 @@ from ansible.module_utils.compat.version import LooseVersion, Version
 # Regular expression taken from
 # https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
 SEMVER_RE = re.compile(
-    r'''
+    r"""
     ^
         (?P<major>0|[1-9]\d*)
         \.
@@ -30,7 +30,7 @@ SEMVER_RE = re.compile(
             (?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)
         )?
     $
-    ''',
+    """,
     flags=re.X
 )
 

ansible/vars/clean.py

@@ -42,7 +42,7 @@ def module_response_deepcopy(v):
     backwards compatibility, in case we need to extend this function
     to handle our specific needs:
 
-    * ``ansible.executor.task_result.TaskResult.clean_copy``
+    * ``ansible.executor.task_result._RawTaskResult.as_callback_task_result``
     * ``ansible.vars.clean.clean_facts``
     * ``ansible.vars.namespace_facts``
     """
@@ -94,9 +94,9 @@ def strip_internal_keys(dirty, exceptions=None):
 
 
 def remove_internal_keys(data):
-    '''
+    """
     More nuanced version of strip_internal_keys
-    '''
+    """
     for key in list(data.keys()):
         if (key.startswith('_ansible_') and key != '_ansible_parsed') or key in C.INTERNAL_RESULT_KEYS:
             display.warning("Removed unexpected internal key in module return: %s = %s" % (key, data[key]))
@@ -114,7 +114,7 @@ def remove_internal_keys(data):
 
 
 def clean_facts(facts):
-    ''' remove facts that can override internal keys or otherwise deemed unsafe '''
+    """ remove facts that can override internal keys or otherwise deemed unsafe """
     data = module_response_deepcopy(facts)
 
     remove_keys = set()
@@ -157,7 +157,7 @@ def clean_facts(facts):
 
 
 def namespace_facts(facts):
-    ''' return all facts inside 'ansible_facts' w/o an ansible_ prefix '''
+    """ return all facts inside 'ansible_facts' w/o an ansible_ prefix """
     deprefixed = {}
     for k in facts:
         if k.startswith('ansible_') and k not in ('ansible_local',):