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

ansible/module_utils/common/_collections_compat.py

@@ -2,7 +2,7 @@
 # Simplified BSD License (see licenses/simplified_bsd.txt or https://opensource.org/licenses/BSD-2-Clause)
 """Collections ABC import shim.
 
-Use `ansible.module_utils.six.moves.collections_abc` instead, which has been available since ansible-core 2.11.
+Use `collections.abc` instead.
 This module exists only for backwards compatibility.
 """
 
@@ -10,7 +10,7 @@ from __future__ import annotations
 
 # Although this was originally intended for internal use only, it has wide adoption in collections.
 # This is due in part to sanity tests previously recommending its use over `collections` imports.
-from ansible.module_utils.six.moves.collections_abc import (  # pylint: disable=unused-import
+from collections.abc import (  # pylint: disable=unused-import
     MappingView,
     ItemsView,
     KeysView,
@@ -25,3 +25,12 @@ from ansible.module_utils.six.moves.collections_abc import (  # pylint: disable=
     Iterable,
     Iterator,
 )
+
+from ansible.module_utils.common import warnings as _warnings
+
+
+_warnings.deprecate(
+    msg="The `ansible.module_utils.common._collections_compat` module is deprecated.",
+    help_text="Use `collections.abc` from the Python standard library instead.",
+    version="2.24",
+)

ansible/module_utils/common/collections.py

@@ -6,9 +6,10 @@
 from __future__ import annotations
 
 
+from collections.abc import Hashable, Mapping, MutableMapping, Sequence  # pylint: disable=unused-import
+
+from ansible.module_utils._internal import _no_six
 from ansible.module_utils.common import warnings as _warnings
-from ansible.module_utils.six import binary_type, text_type
-from ansible.module_utils.six.moves.collections_abc import Hashable, Mapping, MutableMapping, Sequence  # pylint: disable=unused-import
 
 
 class ImmutableDict(Hashable, Mapping):
@@ -67,7 +68,7 @@ class ImmutableDict(Hashable, Mapping):
 
 def is_string(seq):
     """Identify whether the input has a string-like type (including bytes)."""
-    return isinstance(seq, (text_type, binary_type))
+    return isinstance(seq, (str, bytes))
 
 
 def is_iterable(seq, include_strings=False):
@@ -114,3 +115,7 @@ def count(seq):
     for elem in seq:
         counters[elem] = counters.get(elem, 0) + 1
     return counters
+
+
+def __getattr__(importable_name):
+    return _no_six.deprecate(importable_name, __name__, "binary_type", "text_type")

ansible/module_utils/common/dict_transformations.py

@@ -7,10 +7,9 @@ from __future__ import annotations
 
 
 import re
+from collections.abc import MutableMapping
 from copy import deepcopy
 
-from ansible.module_utils.six.moves.collections_abc import MutableMapping
-
 
 def camel_dict_to_snake_dict(camel_dict, reversible=False, ignore_list=()):
     """

ansible/module_utils/common/network.py

@@ -6,11 +6,13 @@
 from __future__ import annotations
 
 import re
+
+# backward compat
+from builtins import zip  # pylint: disable=unused-import
+
 from struct import pack
 from socket import inet_ntoa
 
-from ansible.module_utils.six.moves import zip
-
 
 VALID_MASKS = [2**8 - 2**i for i in range(0, 9)]
 

ansible/module_utils/common/parameters.py

@@ -9,9 +9,19 @@ import os
 import typing as t
 
 from collections import deque
-from itertools import chain
+from collections.abc import (
+    KeysView,
+    Set,
+    Sequence,
+    Mapping,
+    MutableMapping,
+    MutableSet,
+    MutableSequence,
+)
+from itertools import chain  # pylint: disable=unused-import
 
 from ansible.module_utils.common.collections import is_iterable
+from ansible.module_utils._internal import _no_six
 from ansible.module_utils._internal._datatag import AnsibleSerializable, AnsibleTagHelper
 from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
 from ansible.module_utils.common.warnings import warn
@@ -33,26 +43,6 @@ from ansible.module_utils.errors import (
     SubParameterTypeError,
 )
 from ansible.module_utils.parsing.convert_bool import BOOLEANS_FALSE, BOOLEANS_TRUE
-
-from ansible.module_utils.six.moves.collections_abc import (
-    KeysView,
-    Set,
-    Sequence,
-    Mapping,
-    MutableMapping,
-    MutableSet,
-    MutableSequence,
-)
-
-from ansible.module_utils.six import (
-    binary_type,
-    integer_types,
-    string_types,
-    text_type,
-    PY2,
-    PY3,
-)
-
 from ansible.module_utils.common.validation import (
     check_mutually_exclusive,
     check_required_arguments,
@@ -243,7 +233,7 @@ def _handle_aliases(argument_spec, parameters, alias_warnings=None, alias_deprec
         if aliases is None:
             continue
 
-        if not is_iterable(aliases) or isinstance(aliases, (binary_type, text_type)):
+        if not is_iterable(aliases) or isinstance(aliases, (bytes, str)):
             raise TypeError('internal error: aliases must be a list or tuple')
 
         for alias in aliases:
@@ -346,7 +336,7 @@ def _list_no_log_values(argument_spec, params):
                     for sub_param in sub_parameters:
                         # Validate dict fields in case they came in as strings
 
-                        if isinstance(sub_param, string_types):
+                        if isinstance(sub_param, str):
                             sub_param = check_type_dict(sub_param)
 
                         if not isinstance(sub_param, Mapping):
@@ -362,7 +352,7 @@ def _return_datastructure_name(obj):
     """ Return native stringified values from datastructures.
 
     For use with removing sensitive values pre-jsonification."""
-    if isinstance(obj, (text_type, binary_type)):
+    if isinstance(obj, (str, bytes)):
         if obj:
             yield to_native(obj, errors='surrogate_or_strict')
         return
@@ -375,7 +365,7 @@ def _return_datastructure_name(obj):
     elif obj is None or isinstance(obj, bool):
         # This must come before int because bools are also ints
         return
-    elif isinstance(obj, tuple(list(integer_types) + [float])):
+    elif isinstance(obj, (int, float)):
         yield to_native(obj, nonstring='simplerepr')
     else:
         raise TypeError('Unknown parameter type: %s' % (type(obj)))
@@ -413,26 +403,23 @@ def _remove_values_conditions(value, no_log_strings, deferred_removals):
     """
     original_value = value
 
-    if isinstance(value, (text_type, binary_type)):
+    if isinstance(value, (str, bytes)):
         # Need native str type
         native_str_value = value
-        if isinstance(value, text_type):
+        if isinstance(value, str):
             value_is_text = True
-            if PY2:
-                native_str_value = to_bytes(value, errors='surrogate_or_strict')
-        elif isinstance(value, binary_type):
+        elif isinstance(value, bytes):
             value_is_text = False
-            if PY3:
-                native_str_value = to_text(value, errors='surrogate_or_strict')
+            native_str_value = to_text(value, errors='surrogate_or_strict')
 
         if native_str_value in no_log_strings:
             return 'VALUE_SPECIFIED_IN_NO_LOG_PARAMETER'
         for omit_me in no_log_strings:
             native_str_value = native_str_value.replace(omit_me, '*' * 8)
 
-        if value_is_text and isinstance(native_str_value, binary_type):
+        if value_is_text and isinstance(native_str_value, bytes):
             value = to_text(native_str_value, encoding='utf-8', errors='surrogate_then_replace')
-        elif not value_is_text and isinstance(native_str_value, text_type):
+        elif not value_is_text and isinstance(native_str_value, str):
             value = to_bytes(native_str_value, encoding='utf-8', errors='surrogate_then_replace')
         else:
             value = native_str_value
@@ -514,7 +501,7 @@ def _set_defaults(argument_spec, parameters, set_default=True):
 
 def _sanitize_keys_conditions(value, no_log_strings, ignore_keys, deferred_removals):
     """ Helper method to :func:`sanitize_keys` to build ``deferred_removals`` and avoid deep recursion. """
-    if isinstance(value, (text_type, binary_type)):
+    if isinstance(value, (str, bytes)):
         return value
 
     if isinstance(value, Sequence):
@@ -541,7 +528,7 @@ def _sanitize_keys_conditions(value, no_log_strings, ignore_keys, deferred_remov
         deferred_removals.append((value, new_value))
         return new_value
 
-    if isinstance(value, tuple(chain(integer_types, (float, bool, NoneType)))):
+    if isinstance(value, (int, float, bool, NoneType)):
         return value
 
     if isinstance(value, (datetime.datetime, datetime.date, datetime.time)):
@@ -560,8 +547,8 @@ def _validate_elements(wanted_type, parameter, values, options_context=None, err
     # Get param name for strings so we can later display this value in a useful error message if needed
     # Only pass 'kwargs' to our checkers and ignore custom callable checkers
     kwargs = {}
-    if wanted_element_type == 'str' and isinstance(wanted_type, string_types):
-        if isinstance(parameter, string_types):
+    if wanted_element_type == 'str' and isinstance(wanted_type, str):
+        if isinstance(parameter, str):
             kwargs['param'] = parameter
         elif isinstance(parameter, dict):
             kwargs['param'] = list(parameter.keys())[0]
@@ -620,7 +607,7 @@ def _validate_argument_types(argument_spec, parameters, prefix='', options_conte
         # Get param name for strings so we can later display this value in a useful error message if needed
         # Only pass 'kwargs' to our checkers and ignore custom callable checkers
         kwargs = {}
-        if wanted_name == 'str' and isinstance(wanted_type, string_types):
+        if wanted_name == 'str' and isinstance(wanted_type, str):
             kwargs['param'] = list(parameters.keys())[0]
 
             # Get the name of the parent key if this is a nested option
@@ -659,7 +646,7 @@ def _validate_argument_values(argument_spec, parameters, options_context=None, e
         if choices is None:
             continue
 
-        if isinstance(choices, (frozenset, KeysView, Sequence)) and not isinstance(choices, (binary_type, text_type)):
+        if isinstance(choices, (frozenset, KeysView, Sequence)) and not isinstance(choices, (bytes, str)):
             if param in parameters:
                 # Allow one or more when type='list' param with choices
                 if isinstance(parameters[param], list):
@@ -745,7 +732,7 @@ def _validate_sub_spec(
             options_context.append(param)
 
             # Make sure we can iterate over the elements
-            if not isinstance(parameters[param], Sequence) or isinstance(parameters[param], string_types):
+            if not isinstance(parameters[param], Sequence) or isinstance(parameters[param], str):
                 elements = [parameters[param]]
             else:
                 elements = parameters[param]
@@ -940,3 +927,7 @@ def remove_values(value, no_log_strings):
                     raise TypeError('Unknown container type encountered when removing private values from output')
 
     return new_value
+
+
+def __getattr__(importable_name):
+    return _no_six.deprecate(importable_name, __name__, "binary_type", "text_type", "integer_types", "string_types", "PY2", "PY3")

ansible/module_utils/common/text/converters.py

@@ -8,11 +8,8 @@ from __future__ import annotations
 import codecs
 import json
 
-from ansible.module_utils.six import (
-    binary_type,
-    iteritems,
-    text_type,
-)
+from ansible.module_utils.compat import typing as _t
+from ansible.module_utils._internal import _no_six
 
 try:
     codecs.lookup_error('surrogateescape')
@@ -25,8 +22,54 @@ _COMPOSED_ERROR_HANDLERS = frozenset((None, 'surrogate_or_replace',
                                       'surrogate_or_strict',
                                       'surrogate_then_replace'))
 
+_T = _t.TypeVar('_T')
 
-def to_bytes(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
+_NonStringPassthru: _t.TypeAlias = _t.Literal['passthru']
+_NonStringOther: _t.TypeAlias = _t.Literal['simplerepr', 'empty', 'strict']
+_NonStringAll: _t.TypeAlias = _t.Union[_NonStringPassthru, _NonStringOther]
+
+
+@_t.overload
+def to_bytes(
+    obj: object,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+) -> bytes: ...
+
+
+@_t.overload
+def to_bytes(
+    obj: bytes | str,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+    nonstring: _NonStringPassthru = 'passthru',
+) -> bytes: ...
+
+
+@_t.overload
+def to_bytes(
+    obj: _T,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+    nonstring: _NonStringPassthru = 'passthru',
+) -> _T: ...
+
+
+@_t.overload
+def to_bytes(
+    obj: object,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+    nonstring: _NonStringOther = 'simplerepr',
+) -> bytes: ...
+
+
+def to_bytes(
+    obj: _T,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+    nonstring: _NonStringAll = 'simplerepr'
+) -> _T | bytes:
     """Make sure that a string is a byte string
 
     :arg obj: An object to make sure is a byte string.  In most cases this
@@ -84,13 +127,13 @@ def to_bytes(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
         string is valid in the specified encoding.  If it's important that the
         byte string is in the specified encoding do::
 
-            encoded_string = to_bytes(to_text(input_string, 'latin-1'), 'utf-8')
+            encoded_string = to_bytes(to_text(input_string, encoding='latin-1'), encoding='utf-8')
 
     .. version_changed:: 2.3
 
         Added the ``surrogate_then_replace`` error handler and made it the default error handler.
     """
-    if isinstance(obj, binary_type):
+    if isinstance(obj, bytes):
         return obj
 
     # We're given a text string
@@ -104,7 +147,7 @@ def to_bytes(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
         else:
             errors = 'replace'
 
-    if isinstance(obj, text_type):
+    if isinstance(obj, str):
         try:
             # Try this first as it's the fastest
             return obj.encode(encoding, errors)
@@ -129,21 +172,60 @@ def to_bytes(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
                 value = repr(obj)
             except UnicodeError:
                 # Giving up
-                return to_bytes('')
+                return b''
     elif nonstring == 'passthru':
         return obj
     elif nonstring == 'empty':
-        # python2.4 doesn't have b''
-        return to_bytes('')
+        return b''
     elif nonstring == 'strict':
         raise TypeError('obj must be a string type')
     else:
         raise TypeError('Invalid value %s for to_bytes\' nonstring parameter' % nonstring)
 
-    return to_bytes(value, encoding, errors)
+    return to_bytes(value, encoding=encoding, errors=errors)
 
 
-def to_text(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
+@_t.overload
+def to_text(
+    obj: object,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+) -> str: ...
+
+
+@_t.overload
+def to_text(
+    obj: str | bytes,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+    nonstring: _NonStringPassthru = 'passthru',
+) -> str: ...
+
+
+@_t.overload
+def to_text(
+    obj: _T,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+    nonstring: _NonStringPassthru = 'passthru',
+) -> _T: ...
+
+
+@_t.overload
+def to_text(
+    obj: object,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+    nonstring: _NonStringOther = 'simplerepr',
+) -> str: ...
+
+
+def to_text(
+    obj: _T,
+    encoding: str = 'utf-8',
+    errors: str | None = None,
+    nonstring: _NonStringAll = 'simplerepr'
+) -> _T | str:
     """Make sure that a string is a text string
 
     :arg obj: An object to make sure is a text string.  In most cases this
@@ -194,7 +276,7 @@ def to_text(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
 
         Added the surrogate_then_replace error handler and made it the default error handler.
     """
-    if isinstance(obj, text_type):
+    if isinstance(obj, str):
         return obj
 
     if errors in _COMPOSED_ERROR_HANDLERS:
@@ -205,7 +287,7 @@ def to_text(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
         else:
             errors = 'replace'
 
-    if isinstance(obj, binary_type):
+    if isinstance(obj, bytes):
         # Note: We don't need special handling for surrogate_then_replace
         # because all bytes will either be made into surrogates or are valid
         # to decode.
@@ -221,17 +303,17 @@ def to_text(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
                 value = repr(obj)
             except UnicodeError:
                 # Giving up
-                return u''
+                return ''
     elif nonstring == 'passthru':
         return obj
     elif nonstring == 'empty':
-        return u''
+        return ''
     elif nonstring == 'strict':
         raise TypeError('obj must be a string type')
     else:
         raise TypeError('Invalid value %s for to_text\'s nonstring parameter' % nonstring)
 
-    return to_text(value, encoding, errors)
+    return to_text(value, encoding=encoding, errors=errors)
 
 
 to_native = to_text
@@ -259,10 +341,10 @@ def container_to_bytes(d, encoding='utf-8', errors='surrogate_or_strict'):
     """
     # DTFIX-FUTURE: deprecate
 
-    if isinstance(d, text_type):
+    if isinstance(d, str):
         return to_bytes(d, encoding=encoding, errors=errors)
     elif isinstance(d, dict):
-        return dict(container_to_bytes(o, encoding, errors) for o in iteritems(d))
+        return dict(container_to_bytes(o, encoding, errors) for o in d.items())
     elif isinstance(d, list):
         return [container_to_bytes(o, encoding, errors) for o in d]
     elif isinstance(d, tuple):
@@ -279,14 +361,18 @@ def container_to_text(d, encoding='utf-8', errors='surrogate_or_strict'):
     """
     # DTFIX-FUTURE: deprecate
 
-    if isinstance(d, binary_type):
+    if isinstance(d, bytes):
         # Warning, can traceback
         return to_text(d, encoding=encoding, errors=errors)
     elif isinstance(d, dict):
-        return dict(container_to_text(o, encoding, errors) for o in iteritems(d))
+        return dict(container_to_text(o, encoding, errors) for o in d.items())
     elif isinstance(d, list):
         return [container_to_text(o, encoding, errors) for o in d]
     elif isinstance(d, tuple):
         return tuple(container_to_text(o, encoding, errors) for o in d)
     else:
         return d
+
+
+def __getattr__(importable_name):
+    return _no_six.deprecate(importable_name, __name__, "binary_type", "text_type", "iteritems")

ansible/module_utils/common/text/formatters.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import re
 
-from ansible.module_utils.six import iteritems
+from ansible.module_utils._internal import _no_six
 
 SIZE_RANGES = {
     'Y': 1 << 80,
@@ -117,7 +117,7 @@ def bytes_to_human(size, isbits=False, unit=None):
         base = 'bits'
     suffix = ''
 
-    for suffix, limit in sorted(iteritems(SIZE_RANGES), key=lambda item: -item[1]):
+    for suffix, limit in sorted(SIZE_RANGES.items(), key=lambda item: -item[1]):
         if (unit is None and size >= limit) or unit is not None and unit.upper() == suffix[0]:
             break
 
@@ -127,3 +127,7 @@ def bytes_to_human(size, isbits=False, unit=None):
         suffix = base
 
     return '%.2f %s' % (size / limit, suffix)
+
+
+def __getattr__(importable_name):
+    return _no_six.deprecate(importable_name, __name__, "iteritems")

ansible/module_utils/common/validation.py

@@ -10,15 +10,13 @@ import os
 import re
 
 from ast import literal_eval
+from ansible.module_utils._internal import _no_six
 from ansible.module_utils.common import json as _common_json
 from ansible.module_utils.common.text.converters import to_native
 from ansible.module_utils.common.collections import is_iterable
 from ansible.module_utils.common.text.formatters import human_to_bytes
 from ansible.module_utils.common.warnings import deprecate
 from ansible.module_utils.parsing.convert_bool import boolean
-from ansible.module_utils.six import (
-    string_types,
-)
 
 
 def count_terms(terms, parameters):
@@ -43,7 +41,7 @@ def safe_eval(value, locals=None, include_exceptions=False):
         version="2.21",
     )
     # do not allow method calls to modules
-    if not isinstance(value, string_types):
+    if not isinstance(value, str):
         # already templated to a datavaluestructure, perhaps?
         if include_exceptions:
             return (value, None)
@@ -194,7 +192,7 @@ def check_required_by(requirements, parameters, options_context=None):
         if key not in parameters or parameters[key] is None:
             continue
         # Support strings (single-item lists)
-        if isinstance(value, string_types):
+        if isinstance(value, str):
             value = [value]
 
         if missing := [required for required in value if required not in parameters or parameters[required] is None]:
@@ -373,7 +371,7 @@ def check_type_str(value, allow_conversion=True, param=None, prefix=''):
     :returns: Original value if it is a string, the value converted to a string
         if allow_conversion=True, or raises a TypeError if allow_conversion=False.
     """
-    if isinstance(value, string_types):
+    if isinstance(value, str):
         return value
 
     if value is None:
@@ -406,7 +404,7 @@ def check_type_list(value):
         return value
 
     # DTFIX-FUTURE: deprecate legacy comma split functionality, eventually replace with `_check_type_list_strict`
-    if isinstance(value, string_types):
+    if isinstance(value, str):
         return value.split(",")
     elif isinstance(value, int) or isinstance(value, float):
         return [str(value)]
@@ -434,7 +432,7 @@ def check_type_dict(value):
     if isinstance(value, dict):
         return value
 
-    if isinstance(value, string_types):
+    if isinstance(value, str):
         if value.startswith("{"):
             try:
                 return json.loads(value)
@@ -497,7 +495,7 @@ def check_type_bool(value):
     if isinstance(value, bool):
         return value
 
-    if isinstance(value, string_types) or isinstance(value, (int, float)):
+    if isinstance(value, str) or isinstance(value, (int, float)):
         return boolean(value)
 
     raise TypeError('%s cannot be converted to a bool' % type(value))
@@ -597,3 +595,7 @@ def check_type_jsonarg(value):
         return json.dumps(value, cls=_common_json._get_legacy_encoder(), _decode_bytes=True)
 
     raise TypeError('%s cannot be converted to a json string' % type(value))
+
+
+def __getattr__(importable_name):
+    return _no_six.deprecate(importable_name, __name__, "string_types")

ansible/module_utils/connection.py

@@ -36,9 +36,10 @@ import struct
 import uuid
 
 from functools import partial
+
+from ansible.module_utils._internal import _no_six
 from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.module_utils.common.json import _get_legacy_encoder
-from ansible.module_utils.six import iteritems
 
 
 def write_to_stream(stream, obj):
@@ -95,7 +96,7 @@ class ConnectionError(Exception):
 
     def __init__(self, message, *args, **kwargs):
         super(ConnectionError, self).__init__(message)
-        for k, v in iteritems(kwargs):
+        for k, v in kwargs.items():
             setattr(self, k, v)
 
 
@@ -149,7 +150,7 @@ class Connection(object):
                 raise ConnectionError(
                     "Unable to decode JSON from response to {0}. Received '{1}'.".format(name, out)
                 )
-            params = [repr(arg) for arg in args] + ['{0}={1!r}'.format(k, v) for k, v in iteritems(kwargs)]
+            params = [repr(arg) for arg in args] + ['{0}={1!r}'.format(k, v) for k, v in kwargs.items()]
             params = ', '.join(params)
             raise ConnectionError(
                 "Unable to decode JSON from response to {0}({1}). Received '{2}'.".format(name, params, out)
@@ -200,3 +201,7 @@ class Connection(object):
         sf.close()
 
         return to_text(response, errors='surrogate_or_strict')
+
+
+def __getattr__(importable_name):
+    return _no_six.deprecate(importable_name, __name__, "iteritems")