ansible-core 2.17.4rc1__py3-none-any.whl → 2.18.0b1__py3-none-any.whl

ansible/constants.py

@@ -15,6 +15,10 @@ from ansible.module_utils.parsing.convert_bool import BOOLEANS_TRUE
 from ansible.release import __version__
 from ansible.utils.fqcn import add_internal_fqcns
 
+# initialize config manager/config data to read/store global settings
+# and generate 'pseudo constants' for app consumption.
+config = ConfigManager()
+
 
 def _warning(msg):
     ''' display is not guaranteed here, nor it being the full class, but try anyways, fallback to sys.stderr.write '''
@@ -36,6 +40,28 @@ def _deprecated(msg, version):
         sys.stderr.write(' [DEPRECATED] %s, to be removed in %s\n' % (msg, version))
 
 
+def handle_config_noise(display=None):
+
+    if display is not None:
+        w = display.warning
+        d = display.deprecated
+    else:
+        w = _warning
+        d = _deprecated
+
+    while config.WARNINGS:
+        warn = config.WARNINGS.pop()
+        w(warn)
+
+    while config.DEPRECATED:
+        # tuple with name and options
+        dep = config.DEPRECATED.pop(0)
+        msg = config.get_deprecated_msg_from_config(dep[1])
+        # use tabs only for ansible-doc?
+        msg = msg.replace("\t", "")
+        d(f"{dep[0]} option. {msg}", version=dep[1]['version'])
+
+
 def set_constant(name, value, export=vars()):
     ''' sets constants and returns resolved options dict '''
     export[name] = value
@@ -152,10 +178,10 @@ INTERNAL_STATIC_VARS = frozenset(
     ]
 )
 LOCALHOST = ('127.0.0.1', 'localhost', '::1')
-MODULE_REQUIRE_ARGS = tuple(add_internal_fqcns(('command', 'win_command', 'ansible.windows.win_command', 'shell', 'win_shell',
-                                                'ansible.windows.win_shell', 'raw', 'script')))
-MODULE_NO_JSON = tuple(add_internal_fqcns(('command', 'win_command', 'ansible.windows.win_command', 'shell', 'win_shell',
-                                           'ansible.windows.win_shell', 'raw')))
+WIN_MOVED = ['ansible.windows.win_command', 'ansible.windows.win_shell']
+MODULE_REQUIRE_ARGS_SIMPLE = ['command', 'raw', 'script', 'shell', 'win_command', 'win_shell']
+MODULE_REQUIRE_ARGS = tuple(add_internal_fqcns(MODULE_REQUIRE_ARGS_SIMPLE) + WIN_MOVED)
+MODULE_NO_JSON = tuple(add_internal_fqcns(('command', 'win_command', 'shell', 'win_shell', 'raw')) + WIN_MOVED)
 RESTRICTED_RESULT_KEYS = ('ansible_rsync_path', 'ansible_playbook_python', 'ansible_facts')
 SYNTHETIC_COLLECTIONS = ('ansible.builtin', 'ansible.legacy')
 TREE_DIR = None
@@ -218,11 +244,8 @@ MAGIC_VARIABLE_MAPPING = dict(
 )
 
 # POPULATE SETTINGS FROM CONFIG ###
-config = ConfigManager()
-
-# Generate constants from config
 for setting in config.get_configuration_definitions():
     set_constant(setting, config.get_config_value(setting, variables=vars()))
 
-for warn in config.WARNINGS:
-    _warning(warn)
+# emit any warnings or deprecations
+handle_config_noise()

ansible/errors/__init__.py

@@ -227,6 +227,11 @@ class AnsibleOptionsError(AnsibleError):
     pass
 
 
+class AnsibleRequiredOptionError(AnsibleOptionsError):
+    ''' bad or incomplete options passed '''
+    pass
+
+
 class AnsibleParserError(AnsibleError):
     ''' something was detected early that is wrong about a playbook or data file '''
     pass

ansible/executor/interpreter_discovery.py

@@ -41,7 +41,7 @@ class InterpreterDiscoveryRequiredError(Exception):
 def discover_interpreter(action, interpreter_name, discovery_mode, task_vars):
     # interpreter discovery is a 2-step process with the target. First, we use a simple shell-agnostic bootstrap to
     # get the system type from uname, and find any random Python that can get us the info we need. For supported
-    # target OS types, we'll dispatch a Python script that calls plaform.dist() (for older platforms, where available)
+    # target OS types, we'll dispatch a Python script that calls platform.dist() (for older platforms, where available)
     # and brings back /etc/os-release (if present). The proper Python path is looked up in a table of known
     # distros/versions with included Pythons; if nothing is found, depending on the discovery mode, either the
     # default fallback of /usr/bin/python is used (if we know it's there), or discovery fails.

ansible/executor/play_iterator.py

@@ -635,3 +635,19 @@ class PlayIterator:
 
     def clear_notification(self, hostname: str, notification: str) -> None:
         self._host_states[hostname].handler_notifications.remove(notification)
+
+    def end_host(self, hostname: str) -> None:
+        """Used by ``end_host``, ``end_batch`` and ``end_play`` meta tasks to end executing given host."""
+        state = self.get_active_state(self.get_state_for_host(hostname))
+        if state.run_state == IteratingStates.RESCUE:
+            # This is a special case for when ending a host occurs in rescue.
+            # By definition the meta task responsible for ending the host
+            # is the last task, so we need to clear the fail state to mark
+            # the host as rescued.
+            # The reason we need to do that is because this operation is
+            # normally done when PlayIterator transitions from rescue to
+            # always when only then we can say that rescue didn't fail
+            # but with ending a host via meta task, we don't get to that transition.
+            self.set_fail_state_for_host(hostname, FailedStates.NONE)
+        self.set_run_state_for_host(hostname, IteratingStates.COMPLETE)
+        self._play._removed_hosts.append(hostname)

ansible/executor/playbook_executor.py

@@ -195,10 +195,7 @@ class PlaybookExecutor:
                                 result = self._tqm.RUN_FAILED_HOSTS
                                 break_play = True
 
-                            # check the number of failures here, to see if they're above the maximum
-                            # failure percentage allowed, or if any errors are fatal. If either of those
-                            # conditions are met, we break out, otherwise we only break out if the entire
-                            # batch failed
+                            # check the number of failures here and break out if the entire batch failed
                             failed_hosts_count = len(self._tqm._failed_hosts) + len(self._tqm._unreachable_hosts) - \
                                 (previously_failed + previously_unreachable)
 

ansible/executor/powershell/become_wrapper.ps1

@@ -116,12 +116,11 @@ Write-AnsibleLog "INFO - parsed become input, user: '$username', type: '$logon_t
 # set to Stop and cannot be changed. Also need to split the payload from the wrapper to prevent potentially
 # sensitive content from being logged by the scriptblock logger.
 $bootstrap_wrapper = {
-    &chcp.com 65001 > $null
-    $exec_wrapper_str = [System.Console]::In.ReadToEnd()
-    $split_parts = $exec_wrapper_str.Split(@("`0`0`0`0"), 2, [StringSplitOptions]::RemoveEmptyEntries)
+    [Console]::InputEncoding = [Console]::OutputEncoding = New-Object System.Text.UTF8Encoding
+    $ew = [System.Console]::In.ReadToEnd()
+    $split_parts = $ew.Split(@("`0`0`0`0"), 2, [StringSplitOptions]::RemoveEmptyEntries)
     Set-Variable -Name json_raw -Value $split_parts[1]
-    $exec_wrapper = [ScriptBlock]::Create($split_parts[0])
-    &$exec_wrapper
+    &([ScriptBlock]::Create($split_parts[0]))
 }
 $exec_command = [System.Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes($bootstrap_wrapper.ToString()))
 $lp_command_line = "powershell.exe -NonInteractive -NoProfile -ExecutionPolicy Bypass -EncodedCommand $exec_command"

ansible/executor/powershell/bootstrap_wrapper.ps1

@@ -1,4 +1,4 @@
-&chcp.com 65001 > $null
+try { [Console]::InputEncoding = [Console]::OutputEncoding = New-Object System.Text.UTF8Encoding } catch { $null = $_ }
 
 if ($PSVersionTable.PSVersion -lt [Version]"3.0") {
     '{"failed":true,"msg":"Ansible requires PowerShell v3.0 or newer"}'
@@ -9,5 +9,4 @@ $exec_wrapper_str = $input | Out-String
 $split_parts = $exec_wrapper_str.Split(@("`0`0`0`0"), 2, [StringSplitOptions]::RemoveEmptyEntries)
 If (-not $split_parts.Length -eq 2) { throw "invalid payload" }
 Set-Variable -Name json_raw -Value $split_parts[1]
-$exec_wrapper = [ScriptBlock]::Create($split_parts[0])
-&$exec_wrapper
+& ([ScriptBlock]::Create($split_parts[0]))

ansible/executor/powershell/exec_wrapper.ps1

@@ -16,7 +16,7 @@ begin {
             .SYNOPSIS
             Converts a JSON string to a Hashtable/Array in the fastest way
             possible. Unfortunately ConvertFrom-Json is still faster but outputs
-            a PSCustomObject which is combersone for module consumption.
+            a PSCustomObject which is cumbersome for module consumption.
 
             .PARAMETER InputObject
             [String] The JSON string to deserialize.

ansible/executor/powershell/module_manifest.py

@@ -8,7 +8,7 @@ import errno
 import json
 import os
 import pkgutil
-import random
+import secrets
 import re
 from importlib import import_module
 
@@ -318,7 +318,7 @@ def _create_powershell_wrapper(b_module_data, module_path, module_args,
 
         exec_manifest["actions"].insert(0, 'async_watchdog')
         exec_manifest["actions"].insert(0, 'async_wrapper')
-        exec_manifest["async_jid"] = f'j{random.randint(0, 999999999999)}'
+        exec_manifest["async_jid"] = f'j{secrets.randbelow(999999999999)}'
         exec_manifest["async_timeout_sec"] = async_timeout
         exec_manifest["async_startup_timeout"] = C.config.get_config_value("WIN_ASYNC_STARTUP_TIMEOUT", variables=task_vars)
 

ansible/executor/task_executor.py

@@ -4,23 +4,24 @@
 from __future__ import annotations
 
 import os
-import pty
 import time
 import json
+import pathlib
 import signal
 import subprocess
 import sys
-import termios
 import traceback
 
 from ansible import constants as C
+from ansible.cli import scripts
 from ansible.errors import AnsibleError, AnsibleParserError, AnsibleUndefinedVariable, AnsibleConnectionFailure, AnsibleActionFail, AnsibleActionSkip
 from ansible.executor.task_result import TaskResult
 from ansible.executor.module_common import get_action_args_with_defaults
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.module_utils.six import binary_type
 from ansible.module_utils.common.text.converters import to_text, to_native
-from ansible.module_utils.connection import write_to_file_descriptor
+from ansible.module_utils.connection import write_to_stream
+from ansible.module_utils.six import string_types
 from ansible.playbook.conditional import Conditional
 from ansible.playbook.task import Task
 from ansible.plugins import get_plugin_class
@@ -42,11 +43,21 @@ __all__ = ['TaskExecutor']
 
 
 class TaskTimeoutError(BaseException):
-    pass
+    def __init__(self, message="", frame=None):
+
+        if frame is not None:
+            orig = frame
+            root = pathlib.Path(__file__).parent
+            while not pathlib.Path(frame.f_code.co_filename).is_relative_to(root):
+                frame = frame.f_back
+
+            self.frame = 'Interrupted at %s called from %s' % (orig, frame)
+
+        super(TaskTimeoutError, self).__init__(message)
 
 
 def task_timeout(signum, frame):
-    raise TaskTimeoutError
+    raise TaskTimeoutError(frame=frame)
 
 
 def remove_omit(task_args, omit_token):
@@ -369,12 +380,17 @@ class TaskExecutor:
                     'msg': 'Failed to template loop_control.label: %s' % to_text(e)
                 })
 
+            # if plugin is loaded, get resolved name, otherwise leave original task connection
+            if self._connection and not isinstance(self._connection, string_types):
+                task_fields['connection'] = getattr(self._connection, 'ansible_name')
+
             tr = TaskResult(
                 self._host.name,
                 self._task._uuid,
                 res,
                 task_fields=task_fields,
             )
+
             if tr.is_failed() or tr.is_unreachable():
                 self._final_q.send_callback('v2_runner_item_on_failed', tr)
             elif tr.is_skipped():
@@ -386,6 +402,19 @@ class TaskExecutor:
                     self._final_q.send_callback('v2_runner_item_on_ok', tr)
 
             results.append(res)
+
+            # break loop if break_when conditions are met
+            if self._task.loop_control and self._task.loop_control.break_when:
+                cond = Conditional(loader=self._loader)
+                cond.when = self._task.loop_control.get_validated_value(
+                    'break_when', self._task.loop_control.fattributes.get('break_when'), self._task.loop_control.break_when, templar
+                )
+                if cond.evaluate_conditional(templar, task_vars):
+                    # delete loop vars before exiting loop
+                    del task_vars[loop_var]
+                    break
+
+            # done with loop var, remove for next iteration
             del task_vars[loop_var]
 
             # clear 'connection related' plugin variables for next iteration
@@ -647,7 +676,7 @@ class TaskExecutor:
                 return dict(unreachable=True, msg=to_text(e))
             except TaskTimeoutError as e:
                 msg = 'The %s action failed to execute in the expected time frame (%d) and was terminated' % (self._task.action, self._task.timeout)
-                return dict(failed=True, msg=msg)
+                return dict(failed=True, msg=msg, timedout={'frame': e.frame, 'period': self._task.timeout})
             finally:
                 if self._task.timeout:
                     signal.alarm(0)
@@ -1183,26 +1212,19 @@ class TaskExecutor:
         return handler, module
 
 
+CLI_STUB_NAME = 'ansible_connection_cli_stub.py'
+
+
 def start_connection(play_context, options, task_uuid):
     '''
     Starts the persistent connection
     '''
-    candidate_paths = [C.ANSIBLE_CONNECTION_PATH or os.path.dirname(sys.argv[0])]
-    candidate_paths.extend(os.environ.get('PATH', '').split(os.pathsep))
-    for dirname in candidate_paths:
-        ansible_connection = os.path.join(dirname, 'ansible-connection')
-        if os.path.isfile(ansible_connection):
-            display.vvvv("Found ansible-connection at path {0}".format(ansible_connection))
-            break
-    else:
-        raise AnsibleError("Unable to find location of 'ansible-connection'. "
-                           "Please set or check the value of ANSIBLE_CONNECTION_PATH")
 
     env = os.environ.copy()
     env.update({
         # HACK; most of these paths may change during the controller's lifetime
         # (eg, due to late dynamic role includes, multi-playbook execution), without a way
-        # to invalidate/update, ansible-connection won't always see the same plugins the controller
+        # to invalidate/update, the persistent connection helper won't always see the same plugins the controller
         # can.
         'ANSIBLE_BECOME_PLUGINS': become_loader.print_paths(),
         'ANSIBLE_CLICONF_PLUGINS': cliconf_loader.print_paths(),
@@ -1215,30 +1237,19 @@ def start_connection(play_context, options, task_uuid):
     verbosity = []
     if display.verbosity:
         verbosity.append('-%s' % ('v' * display.verbosity))
-    python = sys.executable
-    master, slave = pty.openpty()
+
+    if not (cli_stub_path := C.config.get_config_value('_ANSIBLE_CONNECTION_PATH')):
+        cli_stub_path = str(pathlib.Path(scripts.__file__).parent / CLI_STUB_NAME)
+
     p = subprocess.Popen(
-        [python, ansible_connection, *verbosity, to_text(os.getppid()), to_text(task_uuid)],
-        stdin=slave, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env
+        [sys.executable, cli_stub_path, *verbosity, to_text(os.getppid()), to_text(task_uuid)],
+        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env,
     )
-    os.close(slave)
-
-    # We need to set the pty into noncanonical mode. This ensures that we
-    # can receive lines longer than 4095 characters (plus newline) without
-    # truncating.
-    old = termios.tcgetattr(master)
-    new = termios.tcgetattr(master)
-    new[3] = new[3] & ~termios.ICANON
-
-    try:
-        termios.tcsetattr(master, termios.TCSANOW, new)
-        write_to_file_descriptor(master, options)
-        write_to_file_descriptor(master, play_context.serialize())
-
-        (stdout, stderr) = p.communicate()
-    finally:
-        termios.tcsetattr(master, termios.TCSANOW, old)
-    os.close(master)
+
+    write_to_stream(p.stdin, options)
+    write_to_stream(p.stdin, play_context.serialize())
+
+    (stdout, stderr) = p.communicate()
 
     if p.returncode == 0:
         result = json.loads(to_text(stdout, errors='surrogate_then_replace'))

ansible/executor/task_queue_manager.py

@@ -223,7 +223,7 @@ class TaskQueueManager:
             callback_type = getattr(callback_plugin, 'CALLBACK_TYPE', '')
             callback_needs_enabled = getattr(callback_plugin, 'CALLBACK_NEEDS_ENABLED', getattr(callback_plugin, 'CALLBACK_NEEDS_WHITELIST', False))
 
-            # try to get colleciotn world name first
+            # try to get collection world name first
             cnames = getattr(callback_plugin, '_redirected_names', [])
             if cnames:
                 # store the name the plugin was loaded as, as that's what we'll need to compare to the configured callback list later

ansible/executor/task_result.py

@@ -139,7 +139,7 @@ class TaskResult:
         elif self._result:
             result._result = module_response_deepcopy(self._result)
 
-            # actualy remove
+            # actually remove
             for remove_key in ignore:
                 if remove_key in result._result:
                     del result._result[remove_key]

ansible/galaxy/api.py

@@ -62,8 +62,7 @@ def should_retry_error(exception):
         if isinstance(orig_exc, URLError):
             orig_exc = orig_exc.reason
 
-        # Handle common URL related errors such as TimeoutError, and BadStatusLine
-        # Note: socket.timeout is only required for Py3.9
+        # Handle common URL related errors
         if isinstance(orig_exc, (TimeoutError, BadStatusLine, IncompleteRead)):
             return True
 
@@ -720,7 +719,7 @@ class GalaxyAPI:
 
         display.display("Waiting until Galaxy import task %s has completed" % full_url)
         start = time.time()
-        wait = 2
+        wait = C.GALAXY_COLLECTION_IMPORT_POLL_INTERVAL
 
         while timeout == 0 or (time.time() - start) < timeout:
             try:
@@ -744,7 +743,7 @@ class GalaxyAPI:
             time.sleep(wait)
 
             # poor man's exponential backoff algo so we don't flood the Galaxy API, cap at 30 seconds.
-            wait = min(30, wait * 1.5)
+            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))

ansible/galaxy/collection/__init__.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import errno
 import fnmatch
 import functools
+import glob
 import inspect
 import json
 import os
@@ -1525,6 +1526,7 @@ def install(collection, path, artifacts_manager):  # FIXME: mv to dataclasses?
             artifacts_manager.required_successful_signature_count,
             artifacts_manager.ignore_signature_errors,
         )
+        remove_source_metadata(collection, b_collection_path)
         if (collection.is_online_index_pointer and isinstance(collection.src, GalaxyAPI)):
             write_source_metadata(
                 collection,
@@ -1561,6 +1563,22 @@ def write_source_metadata(collection, b_collection_path, artifacts_manager):
         raise
 
 
+def remove_source_metadata(collection, b_collection_path):
+    pattern = f"{collection.namespace}.{collection.name}-*.info"
+    info_path = os.path.join(
+        b_collection_path,
+        b'../../',
+        to_bytes(pattern, errors='surrogate_or_strict')
+    )
+    if (outdated_info := glob.glob(info_path)):
+        display.vvvv(f"Removing {pattern} metadata from previous installations")
+    for info_dir in outdated_info:
+        try:
+            shutil.rmtree(info_dir)
+        except Exception:
+            pass
+
+
 def verify_artifact_manifest(manifest_file, signatures, keyring, required_signature_count, ignore_signature_errors):
     # type: (str, list[str], str, str, list[str]) -> None
     failed_verify = False
@@ -1584,13 +1602,6 @@ def install_artifact(b_coll_targz_path, b_collection_path, b_temp_path, signatur
     """
     try:
         with tarfile.open(b_coll_targz_path, mode='r') as collection_tar:
-            # Remove this once py3.11 is our controller minimum
-            # Workaround for https://bugs.python.org/issue47231
-            # See _extract_tar_dir
-            collection_tar._ansible_normalized_cache = {
-                m.name.removesuffix(os.path.sep): m for m in collection_tar.getmembers()
-            }  # deprecated: description='TarFile member index' core_version='2.18' python_version='3.11'
-
             # Verify the signature on the MANIFEST.json before extracting anything else
             _extract_tar_file(collection_tar, MANIFEST_FILENAME, b_collection_path, b_temp_path)
 
@@ -1671,10 +1682,10 @@ def install_src(collection, b_collection_path, b_collection_output_path, artifac
 
 def _extract_tar_dir(tar, dirname, b_dest):
     """ Extracts a directory from a collection tar. """
-    dirname = to_native(dirname, errors='surrogate_or_strict').removesuffix(os.path.sep)
+    dirname = to_native(dirname, errors='surrogate_or_strict')
 
     try:
-        tar_member = tar._ansible_normalized_cache[dirname]
+        tar_member = tar.getmember(dirname)
     except KeyError:
         raise AnsibleError("Unable to extract '%s' from collection" % dirname)
 
@@ -1896,7 +1907,7 @@ def _resolve_depenency_map(
 
         for req in dep_exc.criterion.iter_requirement():
             error_msg_lines.append(
-                '* {req.fqcn!s}:{req.ver!s}'.format(req=req)
+                f'* {req.fqcn!s}:{req.ver!s}'
             )
         error_msg_lines.append(pre_release_hint)
 

ansible/galaxy/collection/concrete_artifact_manager.py

@@ -61,7 +61,7 @@ class ConcreteArtifactsManager:
     """
     def __init__(self, b_working_directory, validate_certs=True, keyring=None, timeout=60, required_signature_count=None, ignore_signature_errors=None):
         # type: (bytes, bool, str, int, str, list[str]) -> None
-        """Initialize ConcreteArtifactsManager caches and costraints."""
+        """Initialize ConcreteArtifactsManager caches and constraints."""
         self._validate_certs = validate_certs  # type: bool
         self._artifact_cache = {}  # type: dict[bytes, bytes]
         self._galaxy_artifact_cache = {}  # type: dict[Candidate | Requirement, bytes]
@@ -413,7 +413,7 @@ def _extract_collection_from_git(repo_url, coll_ver, b_path):
     b_checkout_path = mkdtemp(
         dir=b_path,
         prefix=to_bytes(name, errors='surrogate_or_strict'),
-    )  # type: bytes
+    )
 
     try:
         git_executable = get_bin_path('git')

ansible/galaxy/collection/galaxy_api_proxy.py

@@ -27,8 +27,7 @@ display = Display()
 class MultiGalaxyAPIProxy:
     """A proxy that abstracts talking to multiple Galaxy instances."""
 
-    def __init__(self, apis, concrete_artifacts_manager, offline=False):
-        # type: (t.Iterable[GalaxyAPI], ConcreteArtifactsManager, bool) -> None
+    def __init__(self, apis: t.Iterable[GalaxyAPI], concrete_artifacts_manager: ConcreteArtifactsManager, offline: bool = False) -> None:
         """Initialize the target APIs list."""
         self._apis = apis
         self._concrete_art_mgr = concrete_artifacts_manager
@@ -38,22 +37,21 @@ class MultiGalaxyAPIProxy:
     def is_offline_mode_requested(self):
         return self._offline
 
-    def _assert_that_offline_mode_is_not_requested(self):  # type: () -> None
+    def _assert_that_offline_mode_is_not_requested(self) -> None:
         if self.is_offline_mode_requested:
             raise NotImplementedError("The calling code is not supposed to be invoked in 'offline' mode.")
 
-    def _get_collection_versions(self, requirement):
-        # type: (Requirement) -> t.Iterator[tuple[GalaxyAPI, str]]
+    def _get_collection_versions(self, requirement: Requirement) -> t.Iterator[tuple[GalaxyAPI, str]]:
         """Helper for get_collection_versions.
 
         Yield api, version pairs for all APIs,
         and reraise the last error if no valid API was found.
         """
         if self._offline:
-            return []
+            return
 
         found_api = False
-        last_error = None  # type: Exception | None
+        last_error: Exception | None = None
 
         api_lookup_order = (
             (requirement.src, )
@@ -86,8 +84,7 @@ class MultiGalaxyAPIProxy:
         if not found_api and last_error is not None:
             raise last_error
 
-    def get_collection_versions(self, requirement):
-        # type: (Requirement) -> t.Iterable[tuple[str, GalaxyAPI]]
+    def get_collection_versions(self, requirement: Requirement) -> t.Iterable[tuple[str, GalaxyAPI]]:
         """Get a set of unique versions for FQCN on Galaxy servers."""
         if requirement.is_concrete_artifact:
             return {
@@ -110,8 +107,7 @@ class MultiGalaxyAPIProxy:
             )
         )
 
-    def get_collection_version_metadata(self, collection_candidate):
-        # type: (Candidate) -> CollectionVersionMetadata
+    def get_collection_version_metadata(self, collection_candidate: Candidate) -> CollectionVersionMetadata:
         """Retrieve collection metadata of a given candidate."""
         self._assert_that_offline_mode_is_not_requested()
 
@@ -160,8 +156,7 @@ class MultiGalaxyAPIProxy:
 
         raise last_err
 
-    def get_collection_dependencies(self, collection_candidate):
-        # type: (Candidate) -> dict[str, str]
+    def get_collection_dependencies(self, collection_candidate: Candidate) -> dict[str, str]:
         # FIXME: return Requirement instances instead?
         """Retrieve collection dependencies of a given candidate."""
         if collection_candidate.is_concrete_artifact:
@@ -177,13 +172,12 @@ class MultiGalaxyAPIProxy:
             dependencies
         )
 
-    def get_signatures(self, collection_candidate):
-        # type: (Candidate) -> list[str]
+    def get_signatures(self, collection_candidate: Candidate) -> list[str]:
         self._assert_that_offline_mode_is_not_requested()
         namespace = collection_candidate.namespace
         name = collection_candidate.name
         version = collection_candidate.ver
-        last_err = None  # type: Exception | None
+        last_err: Exception | None = None
 
         api_lookup_order = (
             (collection_candidate.src, )