ansible-core 2.19.3rc1__py3-none-any.whl → 2.20.0b2__py3-none-any.whl

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")

ansible/module_utils/facts/hardware/linux.py

@@ -24,13 +24,13 @@ import re
 import sys
 import time
 
+from ansible.module_utils._internal import _no_six
 from ansible.module_utils._internal._concurrent import _futures
 from ansible.module_utils.common.locale import get_best_parsable_locale
 from ansible.module_utils.common.text.converters import to_text
 from ansible.module_utils.common.text.formatters import bytes_to_human
 from ansible.module_utils.facts.hardware.base import Hardware, HardwareCollector
 from ansible.module_utils.facts.utils import get_file_content, get_file_lines, get_mount_size
-from ansible.module_utils.six import iteritems
 
 # import this as a module to ensure we get the same module instance
 from ansible.module_utils.facts import timeout
@@ -653,7 +653,7 @@ class LinuxHardware(Hardware):
                     retval[target].add(entry)
                 except OSError:
                     continue
-            return dict((k, list(sorted(v))) for (k, v) in iteritems(retval))
+            return dict((k, list(sorted(v))) for (k, v) in retval.items())
         except OSError:
             return {}
 
@@ -665,7 +665,7 @@ class LinuxHardware(Hardware):
                 device = elements[3]
                 target = elements[5]
                 retval[target].add(device)
-            return dict((k, list(sorted(v))) for (k, v) in iteritems(retval))
+            return dict((k, list(sorted(v))) for (k, v) in retval.items())
         except OSError:
             return {}
 
@@ -750,7 +750,7 @@ class LinuxHardware(Hardware):
             d = {}
             d['virtual'] = virtual
             d['links'] = {}
-            for (link_type, link_values) in iteritems(links):
+            for (link_type, link_values) in links.items():
                 d['links'][link_type] = link_values.get(block, [])
             diskname = os.path.basename(sysdir)
             for key in ['vendor', 'model', 'sas_address', 'sas_device_handle']:
@@ -801,7 +801,7 @@ class LinuxHardware(Hardware):
                     part_sysdir = sysdir + "/" + partname
 
                     part['links'] = {}
-                    for (link_type, link_values) in iteritems(links):
+                    for (link_type, link_values) in links.items():
                         part['links'][link_type] = link_values.get(partname, [])
 
                     part['start'] = get_file_content(part_sysdir + "/start", 0)
@@ -890,7 +890,8 @@ class LinuxHardware(Hardware):
                     'size_g': items[-2],
                     'free_g': items[-1],
                     'num_lvs': items[2],
-                    'num_pvs': items[1]
+                    'num_pvs': items[1],
+                    'lvs': {},
                 }
 
             lvs_path = self.module.get_bin_path('lvs')
@@ -901,7 +902,18 @@ class LinuxHardware(Hardware):
                 rc, lv_lines, err = self.module.run_command('%s %s' % (lvs_path, lvm_util_options))
                 for lv_line in lv_lines.splitlines():
                     items = lv_line.strip().split(',')
-                    lvs[items[0]] = {'size_g': items[3], 'vg': items[1]}
+                    vg_name = items[1]
+                    lv_name = items[0]
+                    # The LV name is only unique per VG, so the top level fact lvs can be misleading.
+                    # TODO: deprecate lvs in favor of vgs
+                    lvs[lv_name] = {'size_g': items[3], 'vg': vg_name}
+                    try:
+                        vgs[vg_name]['lvs'][lv_name] = {'size_g': items[3]}
+                    except KeyError:
+                        self.module.warn(
+                            "An LVM volume group was created while gathering LVM facts, "
+                            "and is not included in ansible_facts['vgs']."
+                        )
 
             pvs_path = self.module.get_bin_path('pvs')
             # pvs fields: PV VG #Fmt #Attr PSize PFree
@@ -925,3 +937,7 @@ class LinuxHardwareCollector(HardwareCollector):
     _fact_class = LinuxHardware
 
     required_facts = set(['platform'])
+
+
+def __getattr__(importable_name):
+    return _no_six.deprecate(importable_name, __name__, "iteritems")

ansible/module_utils/facts/hardware/netbsd.py

@@ -19,7 +19,7 @@ import os
 import re
 import time
 
-from ansible.module_utils.six.moves import reduce
+from functools import reduce
 
 from ansible.module_utils.facts.hardware.base import Hardware, HardwareCollector
 from ansible.module_utils.facts.timeout import TimeoutError, timeout

ansible/module_utils/facts/hardware/sunos.py

@@ -18,12 +18,13 @@ from __future__ import annotations
 import re
 import time
 
+from functools import reduce
+
 from ansible.module_utils.common.locale import get_best_parsable_locale
 from ansible.module_utils.common.text.formatters import bytes_to_human
 from ansible.module_utils.facts.utils import get_file_content, get_mount_size
 from ansible.module_utils.facts.hardware.base import Hardware, HardwareCollector
 from ansible.module_utils.facts import timeout
-from ansible.module_utils.six.moves import reduce
 
 
 class SunOSHardware(Hardware):