ansible-core 2.18.7__py3-none-any.whl → 2.19.0__py3-none-any.whl

ansible_test/_util/controller/sanity/pylint/plugins/string_format.py

@@ -1,4 +1,5 @@
 """Ansible specific pylint plugin for checking format string usage."""
+
 # (c) 2018, Matt Martz <matt@sivel.net>
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 # -*- coding: utf-8 -*-
@@ -6,13 +7,6 @@ from __future__ import annotations
 
 import astroid
 
-# support pylint 2.x and 3.x -- remove when supporting only 3.x
-try:
-    from pylint.interfaces import IAstroidChecker
-except ImportError:
-    class IAstroidChecker:
-        """Backwards compatibility for 2.x / 3.x support."""
-
 try:
     from pylint.checkers.utils import check_messages
 except ImportError:
@@ -38,7 +32,6 @@ class AnsibleStringFormatChecker(BaseChecker):
     is valid and the arguments match the format string.
     """
 
-    __implements__ = (IAstroidChecker,)
     name = 'string'
     msgs = MSGS
 

ansible_test/_util/controller/sanity/pylint/plugins/unwanted.py

@@ -1,4 +1,5 @@
 """A plugin for pylint to identify imports and functions which should not be used."""
+
 from __future__ import annotations
 
 import os
@@ -6,13 +7,6 @@ import typing as t
 
 import astroid
 
-# support pylint 2.x and 3.x -- remove when supporting only 3.x
-try:
-    from pylint.interfaces import IAstroidChecker
-except ImportError:
-    class IAstroidChecker:
-        """Backwards compatibility for 2.x / 3.x support."""
-
 from pylint.checkers import BaseChecker
 
 ANSIBLE_TEST_MODULES_PATH = os.environ['ANSIBLE_TEST_MODULES_PATH']
@@ -63,7 +57,6 @@ def is_module_path(path):  # type: (str) -> bool
 
 class AnsibleUnwantedChecker(BaseChecker):
     """Checker for unwanted imports and functions."""
-    __implements__ = (IAstroidChecker,)
 
     name = 'unwanted'
 

ansible_test/_util/controller/sanity/validate-modules/validate_modules/main.py

@@ -65,7 +65,7 @@ def setup_collection_loader():
 setup_collection_loader()
 
 from ansible import __version__ as ansible_version
-from ansible.executor.module_common import REPLACER_WINDOWS, NEW_STYLE_PYTHON_MODULE_RE
+from ansible.executor.module_common import REPLACER_WINDOWS as _REPLACER_WINDOWS, NEW_STYLE_PYTHON_MODULE_RE
 from ansible.module_utils.common.collections import is_iterable
 from ansible.module_utils.common.parameters import DEFAULT_TYPE_VALIDATORS
 from ansible.module_utils.compat.version import StrictVersion, LooseVersion
@@ -90,7 +90,7 @@ from .utils import CaptureStd, NoArgsAnsibleModule, compare_unordered_lists, par
 TRY_EXCEPT = ast.Try
 # REPLACER_WINDOWS from ansible.executor.module_common is byte
 # string but we need unicode for Python 3
-REPLACER_WINDOWS = REPLACER_WINDOWS.decode('utf-8')
+REPLACER_WINDOWS = _REPLACER_WINDOWS.decode('utf-8')
 
 REJECTLIST_DIRS = frozenset(('.git', 'test', '.github', '.idea'))
 INDENT_REGEX = re.compile(r'([\t]*)')
@@ -311,8 +311,8 @@ class ModuleValidator(Validator):
 
         self.analyze_arg_spec = analyze_arg_spec and plugin_type == 'module'
 
-        self._Version = LooseVersion
-        self._StrictVersion = StrictVersion
+        self._Version: type[LooseVersion | SemanticVersion] = LooseVersion
+        self._StrictVersion: type[StrictVersion | SemanticVersion] = StrictVersion
 
         self.collection = collection
         self.collection_name = 'ansible.builtin'
@@ -687,30 +687,57 @@ class ModuleValidator(Validator):
         # get module list for each
         # check "shape" of each module name
 
-        module_requires = r'(?im)^#\s*requires\s+\-module(?:s?)\s*(Ansible\.ModuleUtils\..+)'
-        csharp_requires = r'(?im)^#\s*ansiblerequires\s+\-csharputil\s*(Ansible\..+)'
+        legacy_ps_requires = r'(?im)^#\s*Requires\s+\-Module(?:s?)\s+(Ansible\.ModuleUtils\..+)'
+        ps_requires = r"""(?imx)
+            ^\#\s*AnsibleRequires\s+-PowerShell\s+
+            (
+                # Builtin PowerShell module
+                (Ansible\.ModuleUtils\.[\w\.]+)
+                |
+                # Fully qualified collection PowerShell module
+                (ansible_collections\.\w+\.\w+\.plugins\.module_utils\.[\w\.]+)
+                |
+                # Relative collection PowerShell module
+                (\.[\w\.]+)
+            )
+            (\s+-Optional)?"""
+        csharp_requires = r"""(?imx)
+            ^\#\s*AnsibleRequires\s+-CSharpUtil\s+
+            (
+                # Builtin C# util
+                (Ansible\.[\w\.]+)
+                |
+                # Fully qualified collection C# util
+                (ansible_collections\.\w+\.\w+\.plugins\.module_utils\.[\w\.]+)
+                |
+                # Relative collection C# util
+                (\.[\w\.]+)
+            )
+            (\s+-Optional)?"""
+
         found_requires = False
 
-        for req_stmt in re.finditer(module_requires, self.text):
-            found_requires = True
-            # this will bomb on dictionary format - "don't do that"
-            module_list = [x.strip() for x in req_stmt.group(1).split(',')]
-            if len(module_list) > 1:
-                self.reporter.error(
-                    path=self.object_path,
-                    code='multiple-utils-per-requires',
-                    msg='Ansible.ModuleUtils requirements do not support multiple modules per statement: "%s"' % req_stmt.group(0)
-                )
-                continue
+        for pattern, required_type in [(legacy_ps_requires, "Requires"), (ps_requires, "AnsibleRequires")]:
+            for req_stmt in re.finditer(pattern, self.text):
+                found_requires = True
+                # this will bomb on dictionary format - "don't do that"
+                module_list = [x.strip() for x in req_stmt.group(1).split(',')]
+                if len(module_list) > 1:
+                    self.reporter.error(
+                        path=self.object_path,
+                        code='multiple-utils-per-requires',
+                        msg='Ansible.ModuleUtils requirements do not support multiple modules per statement: "%s"' % req_stmt.group(0)
+                    )
+                    continue
 
-            module_name = module_list[0]
+                module_name = module_list[0]
 
-            if module_name.lower().endswith('.psm1'):
-                self.reporter.error(
-                    path=self.object_path,
-                    code='invalid-requires-extension',
-                    msg='Module #Requires should not end in .psm1: "%s"' % module_name
-                )
+                if module_name.lower().endswith('.psm1'):
+                    self.reporter.error(
+                        path=self.object_path,
+                        code='invalid-requires-extension',
+                        msg='Module #%s should not end in .psm1: "%s"' % (required_type, module_name)
+                    )
 
         for req_stmt in re.finditer(csharp_requires, self.text):
             found_requires = True
@@ -979,7 +1006,7 @@ class ModuleValidator(Validator):
             missing_fragment = False
             with CaptureStd():
                 try:
-                    get_docstring(self.path, fragment_loader=fragment_loader,
+                    get_docstring(os.path.abspath(self.path), fragment_loader=fragment_loader,
                                   verbose=True,
                                   collection_name=self.collection_name,
                                   plugin_type=self.plugin_type)
@@ -1003,7 +1030,7 @@ class ModuleValidator(Validator):
                     )
 
             if not missing_fragment:
-                add_fragments(doc, self.object_path, fragment_loader=fragment_loader,
+                add_fragments(doc, os.path.abspath(self.object_path), fragment_loader=fragment_loader,
                               is_module=self.plugin_type == 'module')
 
             if 'options' in doc and doc['options'] is None:
@@ -1589,7 +1616,7 @@ class ModuleValidator(Validator):
 
         try:
             if not context:
-                add_fragments(docs, self.object_path, fragment_loader=fragment_loader,
+                add_fragments(docs, os.path.abspath(self.object_path), fragment_loader=fragment_loader,
                               is_module=self.plugin_type == 'module')
         except Exception:
             # Cannot merge fragments
@@ -2186,7 +2213,7 @@ class ModuleValidator(Validator):
         with CaptureStd():
             try:
                 existing_doc, dummy_examples, dummy_return, existing_metadata = get_docstring(
-                    self.base_module, fragment_loader, verbose=True, collection_name=self.collection_name,
+                    os.path.abspath(self.base_module), fragment_loader, verbose=True, collection_name=self.collection_name,
                     is_module=self.plugin_type == 'module')
                 existing_options = existing_doc.get('options', {}) or {}
             except AssertionError:

ansible_test/_util/controller/sanity/validate-modules/validate_modules/module_args.py

@@ -110,15 +110,22 @@ def get_ps_argument_spec(filename, collection):
         b_module_data = module_fd.read()
 
     ps_dep_finder = PSModuleDepFinder()
-    ps_dep_finder.scan_module(b_module_data, fqn=fqc_name)
+    module_deps = ps_dep_finder.scan_module(b_module_data, fqn=fqc_name)
+    ansible_basic = ''
+    ps_utils = {}
+    for dep in module_deps:
+        dep_info = ps_dep_finder.scripts[dep]
 
-    # For ps_argspec.ps1 to compile Ansible.Basic it also needs the AddType module_util.
-    ps_dep_finder._add_module(name=b"Ansible.ModuleUtils.AddType", ext=".psm1", fqn=None, optional=False, wrapper=False)
+        if dep == 'Ansible.Basic.cs':
+            ansible_basic = dep_info.path
+
+        elif dep.endswith('.psm1'):
+            ps_utils[dep] = dep_info.path
 
     util_manifest = json.dumps({
         'module_path': to_text(module_path, errors='surrogate_or_strict'),
-        'ansible_basic': ps_dep_finder.cs_utils_module["Ansible.Basic"]['path'],
-        'ps_utils': {name: info['path'] for name, info in ps_dep_finder.ps_modules.items()}
+        'ansible_basic': ansible_basic,
+        'ps_utils': ps_utils,
     })
 
     script_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'ps_argspec.ps1')

ansible_test/_util/controller/sanity/validate-modules/validate_modules/schema.py

@@ -67,6 +67,17 @@ def collection_name(v, error_code=None):
     return v
 
 
+def fqcn(v, error_code=None):
+    if not isinstance(v, string_types):
+        raise _add_ansible_error_code(
+            Invalid('Module/plugin name must be a string'), error_code or 'invalid-documentation')
+    m = FULLY_QUALIFIED_COLLECTION_RESOURCE_RE.match(v)
+    if not m:
+        raise _add_ansible_error_code(
+            Invalid('Module/plugin name must be of format `<namespace>.<collection>.<name>(.<subname>)*`'), error_code or 'invalid-documentation')
+    return v
+
+
 def deprecation_versions():
     """Create a list of valid version for deprecation entries, current+4"""
     major, minor = [int(version) for version in __version__.split('.')[0:2]]
@@ -196,11 +207,11 @@ seealso_schema = Schema(
     [
         Any(
             {
-                Required('module'): Any(*string_types),
+                Required('module'): fqcn,
                 'description': doc_string,
             },
             {
-                Required('plugin'): Any(*string_types),
+                Required('plugin'): fqcn,
                 Required('plugin_type'): Any(*DOCUMENTABLE_PLUGINS),
                 'description': doc_string,
             },

ansible_test/_util/controller/sanity/validate-modules/validate_modules/utils.py

@@ -199,6 +199,7 @@ class NoArgsAnsibleModule(AnsibleModule):
     """AnsibleModule that does not actually load params. This is used to get access to the
     methods within AnsibleModule without having to fake a bunch of data
     """
+
     def _load_params(self):
         self.params = {'_ansible_selinux_special_fs': [], '_ansible_remote_tmp': '/tmp', '_ansible_keep_remote_files': False, '_ansible_check_mode': False}
 

ansible_test/_util/controller/sanity/yamllint/yamllinter.py

@@ -1,7 +1,9 @@
 """Wrapper around yamllint that supports YAML embedded in Ansible modules."""
+
 from __future__ import annotations
 
 import ast
+import copy
 import json
 import os
 import re
@@ -9,10 +11,10 @@ import sys
 import typing as t
 
 import yaml
-from yaml.resolver import Resolver
-from yaml.constructor import SafeConstructor
+from yaml.resolver import Resolver, BaseResolver
+from yaml.constructor import SafeConstructor, ConstructorError
 from yaml.error import MarkedYAMLError
-from yaml.cyaml import CParser
+from yaml.cyaml import CParser  # type: ignore[attr-defined]
 
 from yamllint import linter
 from yamllint.config import YamlLintConfig
@@ -29,37 +31,49 @@ def main():
 
 class TestConstructor(SafeConstructor):
     """Yaml Safe Constructor that knows about Ansible tags."""
+
     def construct_yaml_unsafe(self, node):
         """Construct an unsafe tag."""
-        try:
-            constructor = getattr(node, 'id', 'object')
-            if constructor is not None:
-                constructor = getattr(self, 'construct_%s' % constructor)
-        except AttributeError:
-            constructor = self.construct_object
+        return self._resolve_and_construct_object(node)
+
+    def construct_yaml_vault(self, node):
+        """Construct a vault tag."""
+        ciphertext = self._resolve_and_construct_object(node)
+
+        if not isinstance(ciphertext, str):
+            raise ConstructorError(problem=f"the {node.tag!r} tag requires a string value", problem_mark=node.start_mark)
 
-        value = constructor(node)
+        return ciphertext
 
-        return value
+    def _resolve_and_construct_object(self, node):
+        # use a copied node to avoid mutating existing node and tripping the recursion check in construct_object
+        copied_node = copy.copy(node)
+        # repeat implicit resolution process to determine the proper tag for the value in the unsafe node
+        copied_node.tag = t.cast(BaseResolver, self).resolve(type(node), node.value, (True, False))  # pylint: disable=no-member
+
+        # re-entrant call using the correct tag
+        # non-deferred construction of hierarchical nodes so the result is a fully realized object, and so our stateful unsafe propagation behavior works
+        return self.construct_object(copied_node, deep=True)
 
 
 TestConstructor.add_constructor(
     '!unsafe',
-    TestConstructor.construct_yaml_unsafe)
+    TestConstructor.construct_yaml_unsafe)  # type: ignore[type-var]
 
 
 TestConstructor.add_constructor(
     '!vault',
-    TestConstructor.construct_yaml_str)
+    TestConstructor.construct_yaml_vault)  # type: ignore[type-var]
 
 
 TestConstructor.add_constructor(
     '!vault-encrypted',
-    TestConstructor.construct_yaml_str)
+    TestConstructor.construct_yaml_vault)  # type: ignore[type-var]
 
 
 class TestLoader(CParser, TestConstructor, Resolver):
     """Custom YAML loader that recognizes custom Ansible tags."""
+
     def __init__(self, stream):
         CParser.__init__(self, stream)
         TestConstructor.__init__(self)
@@ -68,6 +82,7 @@ class TestLoader(CParser, TestConstructor, Resolver):
 
 class YamlChecker:
     """Wrapper around yamllint that supports YAML embedded in Ansible modules."""
+
     def __init__(self):
         self.messages = []
 
@@ -135,11 +150,11 @@ class YamlChecker:
 
             self.messages += [self.result_to_message(r, path, lineno - 1, key) for r in messages]
 
-    def check_parsable(self, path, contents, lineno=1, allow_multiple=False, prefix=""):  # type: (str, str, int, bool) -> None
+    def check_parsable(self, path: str, contents: str, lineno: int = 1, allow_multiple: bool = False, prefix: str = "") -> None:
         """Check the given contents to verify they can be parsed as YAML."""
         prefix = f"{prefix}: " if prefix else ""
         try:
-            documents = len(list(yaml.load_all(contents, Loader=TestLoader)))
+            documents = len(list(yaml.load_all(contents, Loader=TestLoader)))  # type: ignore[arg-type]
             if documents > 1 and not allow_multiple:
                 self.messages += [{'code': 'multiple-yaml-documents',
                                    'message': f'{prefix}expected a single document in the stream',
@@ -149,8 +164,11 @@ class YamlChecker:
                                    'level': 'error',
                                    }]
         except MarkedYAMLError as ex:
+            message = ' '.join(filter(None, (ex.context, ex.problem, ex.note)))
+            message = message.strip()
+
             self.messages += [{'code': 'unparsable-with-libyaml',
-                               'message': f'{prefix}{ex.args[0]} - {ex.args[2]}',
+                               'message': f'{prefix}{message}',
                                'path': path,
                                'line': ex.problem_mark.line + lineno,
                                'column': ex.problem_mark.column + 1,

ansible_test/_util/controller/tools/collection_detail.py

@@ -1,4 +1,5 @@
 """Retrieve collection detail."""
+
 from __future__ import annotations
 
 import json

ansible_test/_util/controller/tools/yaml_to_json.py

@@ -1,4 +1,5 @@
 """Read YAML from stdin and write JSON to stdout."""
+
 from __future__ import annotations
 
 import datetime
@@ -10,7 +11,7 @@ from yaml import load
 try:
     from yaml import CSafeLoader as SafeLoader
 except ImportError:
-    from yaml import SafeLoader
+    from yaml import SafeLoader  # type: ignore[assignment]
 
 # unique ISO date marker matching the one present in importer.py
 ISO_DATE_MARKER = 'isodate:f23983df-f3df-453c-9904-bcd08af468cc:'

ansible_test/_util/target/injector/python.py

@@ -15,6 +15,7 @@ def main():
     args = [sys.executable]
 
     ansible_lib_root = os.environ.get('ANSIBLE_TEST_ANSIBLE_LIB_ROOT')
+    debugger_config = os.environ.get('ANSIBLE_TEST_DEBUGGER_CONFIG')
     coverage_config = os.environ.get('COVERAGE_CONF')
     coverage_output = os.environ.get('COVERAGE_FILE')
 
@@ -28,6 +29,13 @@ def main():
                 sys.exit('ERROR: Could not find `coverage` module. '
                          'Did you use a virtualenv created without --system-site-packages or with the wrong interpreter?')
 
+    if debugger_config:
+        import json
+
+        debugger_options = json.loads(debugger_config)
+        os.environ.update(debugger_options['env'])
+        args += debugger_options['args']
+
     if name == 'python.py':
         if sys.argv[1] == '-c':
             # prevent simple misuse of python.py with -c which does not work with coverage

ansible_test/_util/target/pytest/plugins/ansible_forked.py

@@ -1,4 +1,5 @@
 """Run each test in its own fork. PYTEST_DONT_REWRITE"""
+
 # MIT License (see licenses/MIT-license.txt or https://opensource.org/licenses/MIT)
 # Based on code originally from:
 # https://github.com/pytest-dev/pytest-forked
@@ -63,6 +64,8 @@ def run_parent(item, pid, result_path):  # type: (Item, int, str) -> list[TestRe
     """Wait for the child process to exit and return the test reports. Called in the parent process."""
     exit_code = waitstatus_to_exitcode(os.waitpid(pid, 0)[1])
 
+    reports: list[TestReport]
+
     if exit_code:
         reason = "Test CRASHED with exit code {}.".format(exit_code)
         report = TestReport(item.nodeid, item.location, {x: 1 for x in item.keywords}, "failed", reason, "call", user_properties=item.user_properties)
@@ -73,8 +76,10 @@ def run_parent(item, pid, result_path):  # type: (Item, int, str) -> list[TestRe
 
         reports = [report]
     else:
+        captured_warnings: list[warnings.WarningMessage]
+
         with open(result_path, "rb") as result_file:
-            reports, captured_warnings = pickle.load(result_file)  # type: list[TestReport], list[warnings.WarningMessage]
+            reports, captured_warnings = pickle.load(result_file)
 
         for warning in captured_warnings:
             warnings.warn_explicit(warning.message, warning.category, warning.filename, warning.lineno)

ansible_test/_util/target/pytest/plugins/ansible_pytest_collections.py

@@ -1,4 +1,5 @@
 """Enable unit testing of Ansible collections. PYTEST_DONT_REWRITE"""
+
 from __future__ import annotations
 
 import os
@@ -69,7 +70,7 @@ def enable_assertion_rewriting_hook():  # type: () -> None
     # noinspection PyProtectedMember
     from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionPkgLoaderBase
 
-    _AnsibleCollectionPkgLoaderBase.exec_module = exec_module
+    _AnsibleCollectionPkgLoaderBase.exec_module = exec_module  # type: ignore[method-assign]
 
 
 def pytest_configure():

ansible_test/_util/target/pytest/plugins/ansible_pytest_coverage.py

@@ -1,4 +1,5 @@
 """Monkey patch os._exit when running under coverage so we don't lose coverage data in forks, such as with `pytest --boxed`. PYTEST_DONT_REWRITE"""
+
 from __future__ import annotations
 
 

ansible_test/_util/target/sanity/compile/compile.py

@@ -1,4 +1,5 @@
 """Python syntax checker with lint friendly output."""
+
 from __future__ import annotations
 
 import sys

ansible_test/_util/target/sanity/import/importer.py

@@ -1,4 +1,5 @@
 """Import the given python module(s) and report error(s) encountered."""
+
 from __future__ import annotations
 
 
@@ -43,6 +44,7 @@ def main():
         # noinspection PyCompatibility
         from importlib import import_module
     except ImportError:
+
         def import_module(name, package=None):  # type: (str, str | None) -> types.ModuleType
             assert package is None
             __import__(name)
@@ -60,11 +62,10 @@ def main():
 
     if collection_full_name:
         # allow importing code from collections when testing a collection
-        from ansible.module_utils.common.text.converters import to_bytes, to_text, to_native, text_type
 
         # noinspection PyProtectedMember
         from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionFinder
-        from ansible.utils.collection_loader import _collection_finder
+        from ansible.utils.collection_loader import _collection_finder, _to_text
 
         yaml_to_dict_cache = {}
 
@@ -74,7 +75,7 @@ def main():
 
         def parse_value(value):
             """Custom value parser for JSON deserialization that recognizes our internal ISO date format."""
-            if isinstance(value, text_type):
+            if isinstance(value, str):
                 match = iso_date_re.search(value)
 
                 if match:
@@ -86,7 +87,7 @@ def main():
             """Object hook for custom ISO date deserialization from JSON."""
             return dict((key, parse_value(value)) for key, value in data.items())
 
-        def yaml_to_dict(yaml, content_id):
+        def yaml_to_dict(yaml: str | bytes, content_id):
             """
             Return a Python dict version of the provided YAML.
             Conversion is done in a subprocess since the current Python interpreter does not have access to PyYAML.
@@ -96,18 +97,18 @@ def main():
 
             try:
                 cmd = [external_python, yaml_to_json_path]
-                proc = subprocess.Popen([to_bytes(c) for c in cmd],  # pylint: disable=consider-using-with
-                                        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                stdout_bytes, stderr_bytes = proc.communicate(to_bytes(yaml))
+                proc = subprocess.Popen(cmd,  # pylint: disable=consider-using-with
+                                        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                stdout, stderr = proc.communicate(_to_text(yaml))
 
                 if proc.returncode != 0:
-                    raise Exception('command %s failed with return code %d: %s' % ([to_native(c) for c in cmd], proc.returncode, to_native(stderr_bytes)))
+                    raise Exception('command %s failed with return code %d: %s' % (cmd, proc.returncode, stderr))
 
-                data = yaml_to_dict_cache[content_id] = json.loads(to_text(stdout_bytes), object_hook=object_hook)
+                data = yaml_to_dict_cache[content_id] = json.loads(stdout, object_hook=object_hook)
 
                 return data
             except Exception as ex:
-                raise Exception('internal importer error - failed to parse yaml: %s' % to_native(ex))
+                raise Exception(f'internal importer error - failed to parse yaml: {ex}')
 
         _collection_finder._meta_yml_to_dict = yaml_to_dict  # pylint: disable=protected-access
 
@@ -142,11 +143,13 @@ def main():
 
     class ImporterAnsibleModule:
         """Replacement for AnsibleModule to support import testing."""
+
         def __init__(self, *args, **kwargs):
             raise ImporterAnsibleModuleException()
 
     class RestrictedModuleLoader:
         """Python module loader that restricts inappropriate imports."""
+
         def __init__(self, path, name, restrict_to_module_paths):
             self.path = path
             self.name = name
@@ -431,6 +434,7 @@ def main():
 
     class Capture:
         """Captured output and/or exception."""
+
         def __init__(self):
             # use buffered IO to simulate StringIO; allows Ansible's stream patching to behave without warnings
             self.stdout = TextIOWrapper(BytesIO())
@@ -489,6 +493,7 @@ def main():
         finally:
             if import_type == 'plugin' and not collection_loader:
                 from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionFinder
+
                 _AnsibleCollectionFinder._remove()  # pylint: disable=protected-access
 
             if sys.meta_path[0] != restricted_loader:
@@ -541,12 +546,6 @@ def main():
                     "ignore",
                     "AnsibleCollectionFinder has already been configured")
 
-            # ansible.utils.unsafe_proxy attempts patching sys.intern generating a warning if it was already patched
-            warnings.filterwarnings(
-                "ignore",
-                "skipped sys.intern patch; appears to have already been patched"
-            )
-
             try:
                 yield
             finally: