ansible-core 2.19.2__py3-none-any.whl → 2.20.0b1__py3-none-any.whl

ansible/executor/task_executor.py

@@ -19,7 +19,9 @@ from ansible.errors import (
     AnsibleError, AnsibleParserError, AnsibleUndefinedVariable, AnsibleTaskError,
     AnsibleValueOmittedError,
 )
-from ansible.executor.task_result import _RawTaskResult
+
+from ansible._internal import _display_utils
+from ansible.executor.task_result import _RawTaskResult, _SUB_PRESERVE
 from ansible._internal._datatag import _utils
 from ansible.module_utils._internal import _messages
 from ansible.module_utils.datatag import native_type_name, deprecator_from_collection_name
@@ -27,7 +29,6 @@ from ansible._internal._datatag._tags import TrustedAsTemplate
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.module_utils.common.text.converters import to_text, to_native
 from ansible.module_utils.connection import write_to_stream
-from ansible.module_utils.six import string_types
 from ansible.playbook.task import Task
 from ansible.plugins import get_plugin_class
 from ansible.plugins.loader import become_loader, cliconf_loader, connection_loader, httpapi_loader, netconf_loader, terminal_loader
@@ -35,7 +36,7 @@ from ansible._internal._templating._jinja_plugins import _invoke_lookup, _Direct
 from ansible._internal._templating._engine import TemplateEngine
 from ansible.template import Templar
 from ansible.utils.collection_loader import AnsibleCollectionConfig
-from ansible.utils.display import Display, _DeferredWarningContext
+from ansible.utils.display import Display
 from ansible.utils.vars import combine_vars
 from ansible.vars.clean import namespace_facts, clean_facts
 from ansible.vars.manager import _deprecate_top_level_fact
@@ -48,6 +49,7 @@ display = Display()
 
 
 RETURN_VARS = [x for x in C.MAGIC_VARIABLE_MAPPING.items() if 'become' not in x and '_pass' not in x]
+_INJECT_FACTS, _INJECT_FACTS_ORIGIN = C.config.get_config_value_and_origin('INJECT_FACTS_AS_VARS')
 
 __all__ = ['TaskExecutor']
 
@@ -340,7 +342,7 @@ class TaskExecutor:
                 })
 
             # if plugin is loaded, get resolved name, otherwise leave original task connection
-            if self._connection and not isinstance(self._connection, string_types):
+            if self._connection and not isinstance(self._connection, str):
                 task_fields['connection'] = getattr(self._connection, 'ansible_name')
 
             tr = _RawTaskResult(
@@ -416,7 +418,7 @@ class TaskExecutor:
     def _execute(self, templar: TemplateEngine, variables: dict[str, t.Any]) -> dict[str, t.Any]:
         result: dict[str, t.Any]
 
-        with _DeferredWarningContext(variables=variables) as warning_ctx:
+        with _display_utils.DeferredWarningContext(variables=variables) as warning_ctx:
             try:
                 # DTFIX-FUTURE: improve error handling to prioritize the earliest exception, turning the remaining ones into warnings
                 result = self._execute_internal(templar, variables)
@@ -431,7 +433,7 @@ class TaskExecutor:
 
             self._task.update_result_no_log(templar, result)
 
-        # The warnings/deprecations in the result have already been captured in the _DeferredWarningContext by _apply_task_result_compat.
+        # The warnings/deprecations in the result have already been captured in the DeferredWarningContext by _apply_task_result_compat.
         # The captured warnings/deprecations are a superset of the ones from the result, and may have been converted from a dict to a dataclass.
         # These are then used to supersede the entries in the result.
 
@@ -664,8 +666,11 @@ class TaskExecutor:
                     # TODO: cleaning of facts should eventually become part of taskresults instead of vars
                     af = result['ansible_facts']
                     vars_copy['ansible_facts'] = combine_vars(vars_copy.get('ansible_facts', {}), namespace_facts(af))
-                    if C.INJECT_FACTS_AS_VARS:
-                        cleaned_toplevel = {k: _deprecate_top_level_fact(v) for k, v in clean_facts(af).items()}
+                    if _INJECT_FACTS:
+                        if _INJECT_FACTS_ORIGIN == 'default':
+                            cleaned_toplevel = {k: _deprecate_top_level_fact(v) for k, v in clean_facts(af).items()}
+                        else:
+                            cleaned_toplevel = clean_facts(af)
                         vars_copy.update(cleaned_toplevel)
 
             # set the failed property if it was missing.
@@ -759,9 +764,13 @@ class TaskExecutor:
                 # TODO: cleaning of facts should eventually become part of taskresults instead of vars
                 af = result['ansible_facts']
                 variables['ansible_facts'] = combine_vars(variables.get('ansible_facts', {}), namespace_facts(af))
-                if C.INJECT_FACTS_AS_VARS:
-                    # DTFIX-FUTURE: why is this happening twice, esp since we're post-fork and these will be discarded?
-                    cleaned_toplevel = {k: _deprecate_top_level_fact(v) for k, v in clean_facts(af).items()}
+                if _INJECT_FACTS:
+                    if _INJECT_FACTS_ORIGIN == 'default':
+                        # This happens x2 due to loops and being able to use values in subsequent iterations
+                        # these copies are later discared in favor of 'total/final' one on loop end.
+                        cleaned_toplevel = {k: _deprecate_top_level_fact(v) for k, v in clean_facts(af).items()}
+                    else:
+                        cleaned_toplevel = clean_facts(af)
                     variables.update(cleaned_toplevel)
 
         # save the notification target in the result, if it was specified, as
@@ -774,21 +783,25 @@ class TaskExecutor:
         # on the results side without having to do any further templating
         # also now add connection vars results when delegating
         if self._task.delegate_to:
-            result["_ansible_delegated_vars"] = {'ansible_delegated_host': self._task.delegate_to}
-            for k in plugin_vars:
-                result["_ansible_delegated_vars"][k] = cvars.get(k)
+            result["_ansible_delegated_vars"] = {
+                "ansible_delegated_host": self._task.delegate_to,
+                "ansible_connection": current_connection,
+            }
 
             # note: here for callbacks that rely on this info to display delegation
-            for requireshed in ('ansible_host', 'ansible_port', 'ansible_user', 'ansible_connection'):
-                if requireshed not in result["_ansible_delegated_vars"] and requireshed in cvars:
-                    result["_ansible_delegated_vars"][requireshed] = cvars.get(requireshed)
+            for k in plugin_vars:
+                if k not in _SUB_PRESERVE["_ansible_delegated_vars"]:
+                    continue
+
+                for o in C.config.get_plugin_options_from_var("connection", current_connection, k):
+                    result["_ansible_delegated_vars"][k] = self._connection.get_option(o)
 
         # and return
         display.debug("attempt loop complete, returning result")
         return result
 
     @staticmethod
-    def _apply_task_result_compat(result: dict[str, t.Any], warning_ctx: _DeferredWarningContext) -> None:
+    def _apply_task_result_compat(result: dict[str, t.Any], warning_ctx: _display_utils.DeferredWarningContext) -> None:
         """Apply backward-compatibility mutations to the supplied task result."""
         if warnings := result.get('warnings'):
             if isinstance(warnings, list):
@@ -956,9 +969,6 @@ class TaskExecutor:
 
         self._play_context.connection = current_connection
 
-        # TODO: play context has logic to update the connection for 'smart'
-        # (default value, will chose between ssh and paramiko) and 'persistent'
-        # (really paramiko), eventually this should move to task object itself.
         conn_type = self._play_context.connection
 
         connection, plugin_load_context = self._shared_loader_obj.connection_loader.get_with_context(
@@ -1213,7 +1223,7 @@ def start_connection(play_context, options, task_uuid):
     )
 
     write_to_stream(p.stdin, options)
-    write_to_stream(p.stdin, play_context.serialize())
+    write_to_stream(p.stdin, play_context.dump_attrs())
 
     (stdout, stderr) = p.communicate()
 

ansible/executor/task_queue_manager.py

@@ -58,8 +58,6 @@ STDERR_FILENO = 2
 
 display = Display()
 
-_T = t.TypeVar('_T')
-
 
 @dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
 class CallbackSend:
@@ -413,7 +411,7 @@ class TaskQueueManager:
         return defunct
 
     @staticmethod
-    def _first_arg_of_type(value_type: t.Type[_T], args: t.Sequence) -> _T | None:
+    def _first_arg_of_type[T](value_type: t.Type[T], args: t.Sequence) -> T | None:
         return next((arg for arg in args if isinstance(arg, value_type)), None)
 
     @lock_decorator(attr='_callback_lock')

ansible/galaxy/api.py

@@ -25,7 +25,6 @@ from ansible.errors import AnsibleError
 from ansible.galaxy.user_agent import user_agent
 from ansible.module_utils.api import retry_with_delays_and_condition
 from ansible.module_utils.api import generate_jittered_backoff
-from ansible.module_utils.six import string_types
 from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
 from ansible.module_utils.urls import open_url, prepare_multipart
 from ansible.utils.display import Display
@@ -114,13 +113,7 @@ def g_connect(versions):
                 # url + '/api/' appended.
                 self.api_server = n_url
 
-                # Default to only supporting v1, if only v1 is returned we also assume that v2 is available even though
-                # it isn't returned in the available_versions dict.
-                available_versions = data.get('available_versions', {u'v1': u'v1/'})
-                if list(available_versions.keys()) == [u'v1']:
-                    available_versions[u'v2'] = u'v2/'
-
-                self._available_api_versions = available_versions
+                self._available_api_versions = available_versions = data['available_versions']
                 display.vvvv("Found API version '%s' with Galaxy server %s (%s)"
                              % (', '.join(available_versions.keys()), self.name, self.api_server))
 
@@ -132,15 +125,6 @@ def g_connect(versions):
                                    % (method.__name__, ", ".join(versions), ", ".join(available_versions),
                                       self.name, self.api_server))
 
-            # Warn only when we know we are talking to a collections API
-            if common_versions == {'v2'}:
-                display.deprecated(
-                    'The v2 Ansible Galaxy API is deprecated and no longer supported. '
-                    'Ensure that you have configured the ansible-galaxy CLI to utilize an '
-                    'updated and supported version of Ansible Galaxy.',
-                    version='2.20',
-                )
-
             return method(self, *args, **kwargs)
         return wrapped
     return decorator
@@ -214,11 +198,7 @@ class GalaxyError(AnsibleError):
             err_info = {}
 
         url_split = self.url.split('/')
-        if 'v2' in url_split:
-            galaxy_msg = err_info.get('message', http_error.reason)
-            code = err_info.get('code', 'Unknown')
-            full_error_msg = u"%s (HTTP Code: %d, Message: %s Code: %s)" % (message, self.http_code, galaxy_msg, code)
-        elif 'v3' in url_split:
+        if 'v3' in url_split:
             errors = err_info.get('errors', [])
             if not errors:
                 errors = [{}]  # Defaults are set below, we just need to make sure 1 error is present.
@@ -340,7 +320,7 @@ class GalaxyAPI:
         return self._priority > other_galaxy_api._priority
 
     @property  # type: ignore[misc]  # https://github.com/python/mypy/issues/1362
-    @g_connect(['v1', 'v2', 'v3'])
+    @g_connect(['v1', 'v3'])
     def available_api_versions(self):
         # Calling g_connect will populate self._available_api_versions
         return self._available_api_versions
@@ -595,11 +575,11 @@ class GalaxyAPI:
         page_size = kwargs.get('page_size', None)
         author = kwargs.get('author', None)
 
-        if tags and isinstance(tags, string_types):
+        if tags and isinstance(tags, str):
             tags = tags.split(',')
             search_url += '&tags_autocomplete=' + '+'.join(tags)
 
-        if platforms and isinstance(platforms, string_types):
+        if platforms and isinstance(platforms, str):
             platforms = platforms.split(',')
             search_url += '&platforms_autocomplete=' + '+'.join(platforms)
 
@@ -645,7 +625,7 @@ class GalaxyAPI:
 
     # Collection APIs #
 
-    @g_connect(['v2', 'v3'])
+    @g_connect(['v3'])
     def publish_collection(self, collection_path):
         """
         Publishes a collection to a Galaxy server and returns the import task URI.
@@ -680,19 +660,15 @@ class GalaxyAPI:
             'Content-length': len(b_form_data),
         }
 
-        if 'v3' in self.available_api_versions:
-            n_url = _urljoin(self.api_server, self.available_api_versions['v3'], 'artifacts', 'collections') + '/'
-        else:
-            n_url = _urljoin(self.api_server, self.available_api_versions['v2'], 'collections') + '/'
-
+        n_url = _urljoin(self.api_server, self.available_api_versions['v3'], 'artifacts', 'collections') + '/'
         resp = self._call_galaxy(n_url, args=b_form_data, headers=headers, method='POST', auth_required=True,
                                  error_context_msg='Error when publishing collection to %s (%s)'
                                                    % (self.name, self.api_server))
 
-        return resp['task']
+        return urljoin(self.api_server, resp['task'])
 
-    @g_connect(['v2', 'v3'])
-    def wait_import_task(self, task_id, timeout=0):
+    @g_connect(['v3'])
+    def wait_import_task(self, task_url, timeout=0):
         """
         Waits until the import process on the Galaxy server has completed or the timeout is reached.
 
@@ -703,22 +679,14 @@ class GalaxyAPI:
         state = 'waiting'
         data = None
 
-        # Construct the appropriate URL per version
-        if 'v3' in self.available_api_versions:
-            full_url = _urljoin(self.api_server, self.available_api_versions['v3'],
-                                'imports/collections', task_id, '/')
-        else:
-            full_url = _urljoin(self.api_server, self.available_api_versions['v2'],
-                                'collection-imports', task_id, '/')
-
-        display.display("Waiting until Galaxy import task %s has completed" % full_url)
+        display.display("Waiting until Galaxy import task %s has completed" % task_url)
         start = time.time()
         wait = C.GALAXY_COLLECTION_IMPORT_POLL_INTERVAL
 
         while timeout == 0 or (time.time() - start) < timeout:
             try:
-                data = self._call_galaxy(full_url, method='GET', auth_required=True,
-                                         error_context_msg='Error when getting import task results at %s' % full_url)
+                data = self._call_galaxy(task_url, method='GET', auth_required=True,
+                                         error_context_msg='Error when getting import task results at %s' % task_url)
             except GalaxyError as e:
                 if e.http_code != 404:
                     raise
@@ -740,7 +708,7 @@ class GalaxyAPI:
             wait = min(30, wait * C.GALAXY_COLLECTION_IMPORT_POLL_FACTOR)
         if state == 'waiting':
             raise AnsibleError("Timeout while waiting for the Galaxy import process to finish, check progress at '%s'"
-                               % to_native(full_url))
+                               % to_native(task_url))
 
         for message in data.get('messages', []):
             level = message['level']
@@ -754,10 +722,10 @@ class GalaxyAPI:
         if state == 'failed':
             code = to_native(data['error'].get('code', 'UNKNOWN'))
             description = to_native(
-                data['error'].get('description', "Unknown error, see %s for more details" % full_url))
+                data['error'].get('description', "Unknown error, see %s for more details" % task_url))
             raise AnsibleError("Galaxy import process failed: %s (Code: %s)" % (description, code))
 
-    @g_connect(['v2', 'v3'])
+    @g_connect(['v3'])
     def get_collection_metadata(self, namespace, name):
         """
         Gets the collection information from the Galaxy server about a specific Collection.
@@ -766,18 +734,11 @@ class GalaxyAPI:
         :param name: The collection name.
         return: CollectionMetadata about the collection.
         """
-        if 'v3' in self.available_api_versions:
-            api_path = self.available_api_versions['v3']
-            field_map = [
-                ('created_str', 'created_at'),
-                ('modified_str', 'updated_at'),
-            ]
-        else:
-            api_path = self.available_api_versions['v2']
-            field_map = [
-                ('created_str', 'created'),
-                ('modified_str', 'modified'),
-            ]
+        api_path = self.available_api_versions['v3']
+        field_map = [
+            ('created_str', 'created_at'),
+            ('modified_str', 'updated_at'),
+        ]
 
         info_url = _urljoin(self.api_server, api_path, 'collections', namespace, name, '/')
         error_context_msg = 'Error when getting the collection info for %s.%s from %s (%s)' \
@@ -790,7 +751,7 @@ class GalaxyAPI:
 
         return CollectionMetadata(namespace, name, **metadata)
 
-    @g_connect(['v2', 'v3'])
+    @g_connect(['v3'])
     def get_collection_version_metadata(self, namespace, name, version):
         """
         Gets the collection information from the Galaxy server about a specific Collection version.
@@ -800,7 +761,7 @@ class GalaxyAPI:
         :param version: Version of the collection to get the information for.
         :return: CollectionVersionMetadata about the collection at the version requested.
         """
-        api_path = self.available_api_versions.get('v3', self.available_api_versions.get('v2'))
+        api_path = self.available_api_versions['v3']
         url_paths = [self.api_server, api_path, 'collections', namespace, name, 'versions', version, '/']
 
         n_collection_url = _urljoin(*url_paths)
@@ -824,7 +785,7 @@ class GalaxyAPI:
                                          download_url, data['artifact']['sha256'],
                                          data['metadata']['dependencies'], data['href'], signatures)
 
-    @g_connect(['v2', 'v3'])
+    @g_connect(['v3'])
     def get_collection_versions(self, namespace, name):
         """
         Gets a list of available versions for a collection on a Galaxy server.
@@ -833,17 +794,10 @@ class GalaxyAPI:
         :param name: The collection name.
         :return: A list of versions that are available.
         """
-        relative_link = False
-        if 'v3' in self.available_api_versions:
-            api_path = self.available_api_versions['v3']
-            pagination_path = ['links', 'next']
-            relative_link = True  # AH pagination results are relative an not an absolute URI.
-        else:
-            api_path = self.available_api_versions['v2']
-            pagination_path = ['next']
+        api_path = self.available_api_versions['v3']
+        pagination_path = ['links', 'next']
 
-        page_size_name = 'limit' if 'v3' in self.available_api_versions else 'page_size'
-        versions_url = _urljoin(self.api_server, api_path, 'collections', namespace, name, 'versions', '/?%s=%d' % (page_size_name, COLLECTION_PAGE_SIZE))
+        versions_url = _urljoin(self.api_server, api_path, 'collections', namespace, name, 'versions', '/?limit=%d' % COLLECTION_PAGE_SIZE)
         versions_url_info = urlparse(versions_url)
         cache_key = versions_url_info.path
 
@@ -898,11 +852,10 @@ class GalaxyAPI:
 
             if not next_link:
                 break
-            elif relative_link:
-                next_link_info = urlparse(next_link)
-                if not next_link_info.scheme and not next_link_info.path.startswith('/'):
-                    raise AnsibleError(f'Invalid non absolute pagination link: {next_link}')
-                next_link = urljoin(self.api_server, next_link)
+            next_link_info = urlparse(next_link)
+            if not next_link_info.scheme and not next_link_info.path.startswith('/'):
+                raise AnsibleError(f'Invalid non absolute pagination link: {next_link}')
+            next_link = urljoin(self.api_server, next_link)
 
             data = self._call_galaxy(to_native(next_link, errors='surrogate_or_strict'),
                                      error_context_msg=error_context_msg, cache=True, cache_key=cache_key)
@@ -910,7 +863,7 @@ class GalaxyAPI:
 
         return versions
 
-    @g_connect(['v2', 'v3'])
+    @g_connect(['v3'])
     def get_collection_signatures(self, namespace, name, version):
         """
         Gets the collection signatures from the Galaxy server about a specific Collection version.
@@ -920,7 +873,7 @@ class GalaxyAPI:
         :param version: Version of the collection to get the information for.
         :return: A list of signature strings.
         """
-        api_path = self.available_api_versions.get('v3', self.available_api_versions.get('v2'))
+        api_path = self.available_api_versions['v3']
         url_paths = [self.api_server, api_path, 'collections', namespace, name, 'versions', version, '/']
 
         n_collection_url = _urljoin(*url_paths)

ansible/galaxy/collection/__init__.py

@@ -339,12 +339,12 @@ def verify_local_collection(local_collection, remote_collection, artifacts_manag
     ]
 
     # Find any paths not in the FILES.json
-    for root, dirs, files in os.walk(b_collection_path):
-        for name in files:
+    for root, dirs, filenames in os.walk(b_collection_path):
+        for name in filenames:
             full_path = os.path.join(root, name)
             path = to_text(full_path[len(b_collection_path) + 1::], errors='surrogate_or_strict')
             if any(fnmatch.fnmatch(full_path, b_pattern) for b_pattern in b_ignore_patterns):
-                display.v("Ignoring verification for %s" % full_path)
+                display.v("Ignoring verification for %s" % to_text(full_path))
                 continue
 
             if full_path not in collection_files:
@@ -623,24 +623,11 @@ def publish_collection(collection_path, api, wait, timeout):
     import_uri = api.publish_collection(collection_path)
 
     if wait:
-        # Galaxy returns a url fragment which differs between v2 and v3.  The second to last entry is
-        # always the task_id, though.
-        # v2: {"task": "https://galaxy-dev.ansible.com/api/v2/collection-imports/35573/"}
-        # v3: {"task": "/api/automation-hub/v3/imports/collections/838d1308-a8f4-402c-95cb-7823f3806cd8/"}
-        task_id = None
-        for path_segment in reversed(import_uri.split('/')):
-            if path_segment:
-                task_id = path_segment
-                break
-
-        if not task_id:
-            raise AnsibleError("Publishing the collection did not return valid task info. Cannot wait for task status. Returned task info: '%s'" % import_uri)
-
         with _display_progress(
                 "Collection has been published to the Galaxy server "
                 "{api.name!s} {api.api_server!s}".format(api=api),
         ):
-            api.wait_import_task(task_id, timeout)
+            api.wait_import_task(import_uri, timeout)
         display.display("Collection has been successfully published and imported to the Galaxy server %s %s"
                         % (api.name, api.api_server))
     else:

ansible/galaxy/dependency_resolution/dataclasses.py

@@ -26,9 +26,6 @@ if t.TYPE_CHECKING:
         '_ComputedReqKindsMixin',
     )
 
-import ansible
-import ansible.release
-
 from ansible.errors import AnsibleError, AnsibleAssertionError
 from ansible.galaxy.api import GalaxyAPI
 from ansible.galaxy.collection import HAS_PACKAGING, PkgReq
@@ -42,7 +39,6 @@ _ALLOW_CONCRETE_POINTER_IN_SOURCE = False  # NOTE: This is a feature flag
 _GALAXY_YAML = b'galaxy.yml'
 _MANIFEST_JSON = b'MANIFEST.json'
 _SOURCE_METADATA_FILE = b'GALAXY.yml'
-_ANSIBLE_PACKAGE_PATH = pathlib.Path(ansible.__file__).parent
 
 display = Display()
 
@@ -229,12 +225,6 @@ class _ComputedReqKindsMixin:
             dir_path = dir_path.rstrip(to_bytes(os.path.sep))
         if not _is_collection_dir(dir_path):
             dir_pathlib = pathlib.Path(to_text(dir_path))
-
-            # special handling for bundled collections without manifests, e.g., ansible._protomatter
-            if dir_pathlib.is_relative_to(_ANSIBLE_PACKAGE_PATH):
-                req_name = f'{dir_pathlib.parent.name}.{dir_pathlib.name}'
-                return cls(req_name, ansible.release.__version__, dir_path, 'dir', None)
-
             display.warning(
                 u"Collection at '{path!s}' does not have a {manifest_json!s} "
                 u'file, nor has it {galaxy_yml!s}: cannot detect version.'.

ansible/galaxy/dependency_resolution/providers.py

@@ -24,7 +24,6 @@ from ansible.galaxy.dependency_resolution.versioning import (
     is_pre_release,
     meets_requirements,
 )
-from ansible.module_utils.six import string_types
 from ansible.utils.version import SemanticVersion, LooseVersion
 
 try:
@@ -278,7 +277,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
                 # NOTE: Another known mistake is setting a minor part of the SemVer notation
                 # NOTE: skipping the "patch" bit like "1.0" which is assumed non-compliant even
                 # NOTE: after the conversion to string.
-                if not isinstance(version, string_types):
+                if not isinstance(version, str):
                     raise ValueError(version_err)
                 elif version != '*':
                     try:

ansible/galaxy/role.py

@@ -23,7 +23,6 @@ from __future__ import annotations
 
 import errno
 import datetime
-import functools
 import os
 import tarfile
 import tempfile
@@ -46,32 +45,6 @@ from ansible.utils.path import is_subpath, unfrackpath
 display = Display()
 
 
-@functools.cache
-def _check_working_data_filter() -> bool:
-    """
-    Check if tarfile.data_filter implementation is working
-    for the current Python version or not
-    """
-
-    # Implemented the following code to circumvent broken implementation of data_filter
-    # in tarfile. See for more information - https://github.com/python/cpython/issues/107845
-    # deprecated: description='probing broken data filter implementation' python_version='3.11'
-    ret = False
-    if hasattr(tarfile, 'data_filter'):
-        # We explicitly check if tarfile.data_filter is broken or not
-        ti = tarfile.TarInfo('docs/README.md')
-        ti.type = tarfile.SYMTYPE
-        ti.linkname = '../README.md'
-
-        try:
-            tarfile.data_filter(ti, '/foo')
-        except tarfile.LinkOutsideDestinationError:
-            pass
-        else:
-            ret = True
-    return ret
-
-
 class GalaxyRole(object):
 
     SUPPORTED_SCMS = set(['git', 'hg'])
@@ -418,12 +391,7 @@ class GalaxyRole(object):
                                 relative_path = os.path.join(*full_path.replace(relative_path_dir, "", 1).split(os.sep))
                                 setattr(member, attr, relative_path)
 
-                            if _check_working_data_filter():
-                                # deprecated: description='extract fallback without filter' python_version='3.11'
-                                role_tar_file.extract(member, to_native(self.path), filter='data')  # type: ignore[call-arg]
-                            else:
-                                # Remove along with manual path filter once Python 3.12 is minimum supported version
-                                role_tar_file.extract(member, to_native(self.path))
+                            role_tar_file.extract(member, to_native(self.path), filter='data')
 
                         # write out the install info file for later use
                         self._write_galaxy_install_info()

ansible/inventory/manager.py

@@ -33,7 +33,6 @@ from ansible._internal import _json, _wrapt
 from ansible._internal._json import EncryptedStringBehavior
 from ansible.errors import AnsibleError, AnsibleOptionsError
 from ansible.inventory.data import InventoryData
-from ansible.module_utils.six import string_types
 from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.parsing.utils.addresses import parse_address
 from ansible.plugins.loader import inventory_loader
@@ -112,7 +111,7 @@ def split_host_pattern(pattern):
         results = (split_host_pattern(p) for p in pattern)
         # flatten the results
         return list(itertools.chain.from_iterable(results))
-    elif not isinstance(pattern, string_types):
+    elif not isinstance(pattern, str):
         pattern = to_text(pattern, errors='surrogate_or_strict')
 
     # If it's got commas in it, we'll treat it as a straightforward
@@ -162,7 +161,7 @@ class InventoryManager(object):
         # the inventory dirs, files, script paths or lists of hosts
         if sources is None:
             self._sources = []
-        elif isinstance(sources, string_types):
+        elif isinstance(sources, str):
             self._sources = [sources]
         else:
             self._sources = sources

ansible/keyword_desc.yml

@@ -1,6 +1,3 @@
-accelerate: "*DEPRECATED*, set to True to use accelerate connection plugin."
-accelerate_ipv6: "*DEPRECATED*, set to True to force accelerate plugin to use ipv6 for its connection."
-accelerate_port: "*DEPRECATED*, set to override default port use for accelerate connection."
 action: "The 'action' to execute for a task, it normally translates into a C(module) or action plugin."
 args: "A secondary way to add arguments into a task. Takes a dictionary in which keys map to options and values."
 always: List of tasks, in a block, that execute no matter if there is an error in the block or not.

ansible/module_utils/_internal/_datatag/__init__.py

@@ -500,17 +500,9 @@ class AnsibleDatatagBase(AnsibleSerializableDataclass, metaclass=abc.ABCMeta):
 _known_tag_type_map: t.Dict[str, t.Type[AnsibleDatatagBase]] = {}
 _known_tag_types: t.Set[t.Type[AnsibleDatatagBase]] = set()
 
-if sys.version_info >= (3, 9):
-    # Include the key and value types in the type hints on Python 3.9 and later.
-    # Earlier versions do not support subscriptable dict.
-    # deprecated: description='always use subscriptable dict' python_version='3.8'
-    class _AnsibleTagsMapping(dict[type[_TAnsibleDatatagBase], _TAnsibleDatatagBase]):
-        __slots__ = _NO_INSTANCE_STORAGE
 
-else:
-
-    class _AnsibleTagsMapping(dict):
-        __slots__ = _NO_INSTANCE_STORAGE
+class _AnsibleTagsMapping(dict[type[_TAnsibleDatatagBase], _TAnsibleDatatagBase]):
+    __slots__ = _NO_INSTANCE_STORAGE
 
 
 class _EmptyROInternalTagsMapping(dict):