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

ansible/executor/play_iterator.py

@@ -174,6 +174,27 @@ class PlayIterator:
             setup_task.when = self._play._included_conditional[:]
         setup_block.block = [setup_task]
 
+        validation_task = Task.load({
+            'name': f'Validating arguments against arg spec {self._play.validate_argspec}',
+            'action': 'ansible.builtin.validate_argument_spec',
+            'args': {
+                # 'provided_arguments': {},  # allow configuration via module_defaults
+                'argument_spec': self._play.argument_spec,
+                'validate_args_context': {
+                    'type': 'play',
+                    'name': self._play.validate_argspec,
+                    'argument_spec_name': self._play.validate_argspec,
+                    'path': self._play._metadata_path,
+                },
+            },
+            'tags': ['always'],
+        }, block=setup_block)
+
+        validation_task.set_loader(self._play._loader)
+        if self._play._included_conditional is not None:
+            validation_task.when = self._play._included_conditional[:]
+        setup_block.block.append(validation_task)
+
         setup_block = setup_block.filter_tagged_tasks(all_vars)
         self._blocks.append(setup_block)
 
@@ -271,35 +292,36 @@ class PlayIterator:
                 return (state, None)
 
             if state.run_state == IteratingStates.SETUP:
-                # First, we check to see if we were pending setup. If not, this is
-                # the first trip through IteratingStates.SETUP, so we set the pending_setup
-                # flag and try to determine if we do in fact want to gather facts for
-                # the specified host.
-                if not state.pending_setup:
-                    state.pending_setup = True
+                # First, we check to see if we completed both setup tasks injected
+                # during play compilation in __init__ above.
+                # If not, below we will determine if we do in fact want to gather
+                # facts or validate arguments for the specified host.
+                state.pending_setup = state.cur_regular_task < len(block.block)
+                if state.pending_setup:
+                    task = block.block[state.cur_regular_task]
 
                     # Gather facts if the default is 'smart' and we have not yet
                     # done it for this host; or if 'explicit' and the play sets
                     # gather_facts to True; or if 'implicit' and the play does
                     # NOT explicitly set gather_facts to False.
-
+                    gather_facts = bool(state.cur_regular_task == 0)
                     gathering = C.DEFAULT_GATHERING
                     implied = self._play.gather_facts is None or boolean(self._play.gather_facts, strict=False)
 
-                    if (gathering == 'implicit' and implied) or \
-                       (gathering == 'explicit' and boolean(self._play.gather_facts, strict=False)) or \
-                       (gathering == 'smart' and implied and not self._variable_manager._facts_gathered_for_host(host.name)):
-                        # The setup block is always self._blocks[0], as we inject it
-                        # during the play compilation in __init__ above.
-                        setup_block = self._blocks[0]
-                        if setup_block.has_tasks() and len(setup_block.block) > 0:
-                            task = setup_block.block[0]
-                else:
-                    # This is the second trip through IteratingStates.SETUP, so we clear
-                    # the flag and move onto the next block in the list while setting
-                    # the run state to IteratingStates.TASKS
-                    state.pending_setup = False
+                    if gather_facts and not (
+                        (gathering == 'implicit' and implied) or
+                        (gathering == 'explicit' and boolean(self._play.gather_facts, strict=False)) or
+                        (gathering == 'smart' and implied and not self._variable_manager._facts_gathered_for_host(host.name))
+                    ):
+                        task = None
+                    elif not gather_facts and not self._play.validate_argspec:
+                        task = None
 
+                    state.cur_regular_task += 1
+                else:
+                    # This is the last trip through IteratingStates.SETUP, so we
+                    # move onto the next block in the list while setting the run
+                    # state to IteratingStates.TASKS
                     state.run_state = IteratingStates.TASKS
                     if not state.did_start_at_task:
                         state.cur_block += 1

ansible/executor/playbook_executor.py

@@ -31,7 +31,6 @@ from ansible.utils.helpers import pct_to_int
 from ansible.utils.collection_loader import AnsibleCollectionConfig
 from ansible.utils.collection_loader._collection_finder import _get_collection_name_from_path, _get_collection_playbook_path
 from ansible.utils.path import makedirs_safe
-from ansible.utils.ssh_functions import set_default_transport
 from ansible.utils.display import Display
 
 
@@ -65,14 +64,6 @@ class PlaybookExecutor:
                 forks=context.CLIARGS.get('forks'),
             )
 
-        # Note: We run this here to cache whether the default ansible ssh
-        # executable supports control persist.  Sometime in the future we may
-        # need to enhance this to check that ansible_ssh_executable specified
-        # in inventory is also cached.  We can't do this caching at the point
-        # where it is used (in task_executor) because that is post-fork and
-        # therefore would be discarded after every task.
-        set_default_transport()
-
     def run(self):
         """
         Run the given playbook, based on the settings in the play which

ansible/executor/task_executor.py

@@ -21,7 +21,7 @@ from ansible.errors import (
 )
 
 from ansible._internal import _display_utils
-from ansible.executor.task_result import _RawTaskResult
+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
@@ -29,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
@@ -50,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']
 
@@ -342,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(
@@ -666,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.
@@ -761,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
@@ -776,14 +783,18 @@ 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")
@@ -958,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(
@@ -1215,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

@@ -60,8 +60,6 @@ STDERR_FILENO = 2
 
 display = Display()
 
-_T = t.TypeVar('_T')
-
 
 @dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
 class CallbackSend:
@@ -455,7 +453,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:
@@ -1852,10 +1839,13 @@ def _resolve_depenency_map(
         offline=offline,
     )
     try:
-        return collection_dep_resolver.resolve(
-            requested_requirements,
-            max_rounds=2000000,  # NOTE: same constant pip uses
-        ).mapping
+        return t.cast(
+            dict[str, Candidate],
+            collection_dep_resolver.resolve(
+                requested_requirements,
+                max_rounds=2000000,  # NOTE: same constant pip uses
+            ).mapping,
+        )
     except CollectionDependencyResolutionImpossible as dep_exc:
         conflict_causes = (
             '* {req.fqcn!s}:{req.ver!s} ({dep_origin!s})'.format(

ansible/galaxy/dependency_resolution/__init__.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import collections.abc as _c
 import typing as t
 
 if t.TYPE_CHECKING:
@@ -21,15 +22,15 @@ from ansible.galaxy.dependency_resolution.resolvers import CollectionDependencyR
 
 
 def build_collection_dependency_resolver(
-        galaxy_apis,  # type: t.Iterable[GalaxyAPI]
-        concrete_artifacts_manager,  # type: ConcreteArtifactsManager
-        preferred_candidates=None,  # type: t.Iterable[Candidate]
-        with_deps=True,  # type: bool
-        with_pre_releases=False,  # type: bool
-        upgrade=False,  # type: bool
-        include_signatures=True,  # type: bool
-        offline=False,  # type: bool
-):  # type: (...) -> CollectionDependencyResolver
+        galaxy_apis: _c.Iterable[GalaxyAPI],
+        concrete_artifacts_manager: ConcreteArtifactsManager,
+        preferred_candidates: _c.Iterable[Candidate] | None = None,
+        with_deps: bool = True,
+        with_pre_releases: bool = False,
+        upgrade: bool = False,
+        include_signatures: bool = True,
+        offline: bool = False,
+) -> CollectionDependencyResolver:
     """Return a collection dependency resolver.
 
     The returned instance will have a ``resolve()`` method for