toil 8.2.0__py3-none-any.whl → 9.0.0__py3-none-any.whl

toil/lib/misc.py

@@ -27,7 +27,7 @@ def get_public_ip() -> str:
     try:
         # Try to get the internet-facing IP by attempting a connection
         # to a non-existent server and reading what IP was used.
-        ip = "127.0.0.1"
+        ip: str = "127.0.0.1"
         with closing(socket.socket(socket.AF_INET, socket.SOCK_DGRAM)) as sock:
             # 203.0.113.0/24 is reserved as TEST-NET-3 by RFC 5737, so
             # there is guaranteed to be no one listening on the other

toil/lib/plugins.py

@@ -0,0 +1,106 @@
+# Copyright (C) 2015-2025 Regents of the University of California
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Generic plugin system for Toil plugins.
+
+Plugins come in Python packages named::
+
+    toil_{PLUGIN_TYPE}_{WHATEVER}
+
+When looking for plugins, Toil will list all the Python packages with the right
+name prefix for the given type of plugin, and load them. The plugin modules
+then have an opportunity to import :meth:`register_plugin` and register
+themselves.
+"""
+
+import importlib
+from typing import Any, Literal, Union
+import pkgutil
+from toil.lib.memoize import memoize
+
+
+PluginType = Union[Literal["batch_system"], Literal["url_access"]]
+plugin_types: list[PluginType] = ["batch_system", "url_access"]
+
+_registry: dict[str, dict[str, Any]] = {k: {} for k in plugin_types}
+
+def register_plugin(
+    plugin_type: PluginType, plugin_name: str, plugin_being_registered: Any
+) -> None:
+    """
+    Adds a plugin to the registry for the given type of plugin.
+
+    :param plugin_name: For batch systems, this is the string the user will use
+        to select the batch system on the command line with ``--batchSystem``.
+        For URL access plugins, this is the URL scheme that the plugin
+        implements.
+    :param plugin_being_registered: This is a function that, when called,
+        imports and returns a plugin-provided class type. For batch systems,
+        the resulting type must extend
+        :class:`toil.batchSystems.abstractBatchSystem.AbstractBatchSystem`. For
+        URL access plugins, it must extend :class:`toil.lib.url.URLAccess`.
+        Note that the function used here should return the class itslef; it
+        should not construct an instance of the class.
+    """
+    _registry[plugin_type][plugin_name] = plugin_being_registered
+
+def remove_plugin(
+    plugin_type: PluginType, plugin_name: str) -> None:
+    """
+    Removes a plugin from the registry for the given type of plugin.
+    """
+    try:
+        del _registry[plugin_type][plugin_name]
+    except KeyError:
+        # If the plugin does not exist, it can be ignored
+        pass
+
+def get_plugin_names(plugin_type:PluginType) -> list[str]:
+    """
+    Get the names of all the available plugins of the given type.
+    """
+    _load_all_plugins(plugin_type)
+    return list(_registry[plugin_type].keys())
+
+def get_plugin(plugin_type: PluginType, plugin_name: str) -> Any:
+    """
+    Get a plugin class factory function by name.
+
+    :raises: KeyError if plugin_name is not the name of a plugin of the given
+        type.
+    """
+    _load_all_plugins(plugin_type)
+    return _registry[plugin_type][plugin_name]
+
+
+def _plugin_name_prefix(plugin_type: PluginType) -> str:
+    """
+    Get prefix for plugin type. 
+    
+    Any packages with prefix will count as toil plugins of that type.
+    """
+    return f"toil_{plugin_type}_"
+
+@memoize
+def _load_all_plugins(plugin_type: PluginType) -> None:
+    """
+    Load all the plugins of the given type that are installed.
+    """
+    prefix = _plugin_name_prefix(plugin_type)
+    for finder, name, is_pkg in pkgutil.iter_modules():
+        # For all installed packages
+        if name.startswith(prefix):
+            # If it is a Toil batch system plugin, import it
+            importlib.import_module(name)

toil/lib/url.py

@@ -0,0 +1,320 @@
+# Copyright (C) 2015-2025 Regents of the University of California
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import logging
+import os
+from abc import ABC, ABCMeta, abstractmethod
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ContextManager,
+    Literal,
+    Optional,
+    Union,
+    cast,
+    overload,
+    Type,
+)
+from urllib.parse import ParseResult, urlparse
+
+from toil.lib.exceptions import UnimplementedURLException
+from toil.lib.memoize import memoize
+from toil.lib.plugins import register_plugin, get_plugin
+
+try:
+    from botocore.exceptions import ProxyConnectionError
+except ImportError:
+
+    class ProxyConnectionError(BaseException):  # type: ignore
+        """Dummy class."""
+
+logger = logging.getLogger(__name__)
+
+class URLAccess:
+    """
+    Widget for accessing external storage (URLs).
+    """
+
+    @classmethod
+    def url_exists(cls, src_uri: str) -> bool:
+        """
+        Return True if the file at the given URI exists, and False otherwise.
+
+        May raise an error if file existence cannot be determined.
+
+        :param src_uri: URL that points to a file or object in the storage
+               mechanism of a supported URL scheme e.g. a blob in an AWS s3 bucket.
+        """
+        parseResult = urlparse(src_uri)
+        otherCls = cls._find_url_implementation(parseResult)
+        return otherCls._url_exists(parseResult)
+
+    @classmethod
+    def get_size(cls, src_uri: str) -> Optional[int]:
+        """
+        Get the size in bytes of the file at the given URL, or None if it cannot be obtained.
+
+        :param src_uri: URL that points to a file or object in the storage
+               mechanism of a supported URL scheme e.g. a blob in an AWS s3 bucket.
+        """
+        parseResult = urlparse(src_uri)
+        otherCls = cls._find_url_implementation(parseResult)
+        return otherCls._get_size(parseResult)
+
+    @classmethod
+    def get_is_directory(cls, src_uri: str) -> bool:
+        """
+        Return True if the thing at the given URL is a directory, and False if
+        it is a file. The URL may or may not end in '/'.
+        """
+        parseResult = urlparse(src_uri)
+        otherCls = cls._find_url_implementation(parseResult)
+        return otherCls._get_is_directory(parseResult)
+
+    @classmethod
+    def list_url(cls, src_uri: str) -> list[str]:
+        """
+        List the directory at the given URL. Returned path components can be
+        joined with '/' onto the passed URL to form new URLs. Those that end in
+        '/' correspond to directories. The provided URL may or may not end with
+        '/'.
+
+        Currently supported schemes are:
+
+            - 's3' for objects in Amazon S3
+                e.g. s3://bucket/prefix/
+
+            - 'file' for local files
+                e.g. file:///local/dir/path/
+
+        :param str src_uri: URL that points to a directory or prefix in the storage mechanism of a
+                supported URL scheme e.g. a prefix in an AWS s3 bucket.
+
+        :return: A list of URL components in the given directory, already URL-encoded.
+        """
+        parseResult = urlparse(src_uri)
+        otherCls = cls._find_url_implementation(parseResult)
+        return otherCls._list_url(parseResult)
+
+    @classmethod
+    def read_from_url(cls, src_uri: str, writable: IO[bytes]) -> tuple[int, bool]:
+        """
+        Read the given URL and write its content into the given writable stream.
+
+        Raises FileNotFoundError if the URL doesn't exist.
+
+        :return: The size of the file in bytes and whether the executable permission bit is set
+        """
+        parseResult = urlparse(src_uri)
+        otherCls = cls._find_url_implementation(parseResult)
+        return otherCls._read_from_url(parseResult, writable)
+
+    @classmethod
+    def open_url(cls, src_uri: str) -> IO[bytes]:
+        """
+        Read from the given URI.
+
+        Raises FileNotFoundError if the URL doesn't exist.
+
+        Has a readable stream interface, unlike :meth:`read_from_url` which
+        takes a writable stream.
+        """
+        parseResult = urlparse(src_uri)
+        otherCls = cls._find_url_implementation(parseResult)
+        return otherCls._open_url(parseResult)
+
+    @classmethod
+    @abstractmethod
+    def _url_exists(cls, url: ParseResult) -> bool:
+        """
+        Return True if the item at the given URL exists, and Flase otherwise.
+
+        May raise an error if file existence cannot be determined.
+        """
+        raise NotImplementedError(f"No implementation for {url}")
+
+    @classmethod
+    @abstractmethod
+    def _get_size(cls, url: ParseResult) -> Optional[int]:
+        """
+        Get the size of the object at the given URL, or None if it cannot be obtained.
+        """
+        raise NotImplementedError(f"No implementation for {url}")
+
+    @classmethod
+    @abstractmethod
+    def _get_is_directory(cls, url: ParseResult) -> bool:
+        """
+        Return True if the thing at the given URL is a directory, and False if
+        it is a file or it is known not to exist. The URL may or may not end in
+        '/'.
+
+        :param url: URL that points to a file or object, or directory or prefix,
+               in the storage mechanism of a supported URL scheme e.g. a blob
+               in an AWS s3 bucket.
+        """
+        raise NotImplementedError(f"No implementation for {url}")
+
+    @classmethod
+    @abstractmethod
+    def _read_from_url(cls, url: ParseResult, writable: IO[bytes]) -> tuple[int, bool]:
+        """
+        Reads the contents of the object at the specified location and writes it to the given
+        writable stream.
+
+        Raises FileNotFoundError if the thing at the URL is not found.
+
+        :param ParseResult url: URL that points to a file or object in the storage
+               mechanism of a supported URL scheme e.g. a blob in an AWS s3 bucket.
+
+        :param IO[bytes] writable: a writable stream
+
+        :return: The size of the file in bytes and whether the executable permission bit is set
+        """
+        raise NotImplementedError(f"No implementation for {url}")
+
+    @classmethod
+    @abstractmethod
+    def _list_url(cls, url: ParseResult) -> list[str]:
+        """
+        List the contents of the given URL, which may or may not end in '/'
+
+        Returns a list of URL components. Those that end in '/' are meant to be
+        directories, while those that do not are meant to be files.
+
+        :param ParseResult url: URL that points to a directory or prefix in the
+        storage mechanism of a supported URL scheme e.g. a prefix in an AWS s3
+        bucket.
+
+        :return: The children of the given URL, already URL-encoded if
+        appropriate. (If the URL is a bare path, no encoding is done.)
+        """
+        raise NotImplementedError(f"No implementation for {url}")
+
+    @classmethod
+    @abstractmethod
+    def _open_url(cls, url: ParseResult) -> IO[bytes]:
+        """
+        Get a stream of the object at the specified location.
+
+        Raises FileNotFoundError if the thing at the URL is not found.
+        """
+        raise NotImplementedError(f"No implementation for {url}")
+
+    @classmethod
+    @abstractmethod
+    def _write_to_url(
+        cls,
+        readable: Union[IO[bytes], IO[str]],
+        url: ParseResult,
+        executable: bool = False,
+    ) -> None:
+        """
+        Reads the contents of the given readable stream and writes it to the object at the
+        specified location. Raises FileNotFoundError if the URL doesn't exist.
+
+        :param Union[IO[bytes], IO[str]] readable: a readable stream
+
+        :param ParseResult url: URL that points to a file or object in the storage
+               mechanism of a supported URL scheme e.g. a blob in an AWS s3 bucket.
+
+        :param bool executable: determines if the file has executable permissions
+        """
+        raise NotImplementedError(f"No implementation for {url}")
+
+    @classmethod
+    @abstractmethod
+    def _supports_url(cls, url: ParseResult, export: bool = False) -> bool:
+        """
+        Returns True if the url access implementation supports the URL's scheme.
+
+        :param ParseResult url: a parsed URL that may be supported
+
+        :param bool export: Determines if the url is supported for exported
+
+        :return bool: returns true if the cls supports the URL
+        """
+        raise NotImplementedError(f"No implementation for {url}")
+
+    @classmethod
+    def _find_url_implementation(
+        cls, url: ParseResult, export: bool = False
+    ) -> type["URLAccess"]:
+        """
+        Returns the URLAccess subclass that supports the given URL.
+
+        :param ParseResult url: The given URL
+
+        :param bool export: Determines if the url is supported for exporting
+
+        """
+        try:
+            implementation_factory = get_plugin("url_access", url.scheme.lower())
+        except KeyError:
+            raise UnimplementedURLException(url, "export" if export else "import")
+        
+        try:
+            implementation = cast(Type[URLAccess], implementation_factory())
+        except (ImportError, ProxyConnectionError):
+            logger.debug(
+                "Unable to import implementation for scheme '%s', as is expected if the corresponding extra was "
+                "omitted at installation time.",
+                url.scheme.lower(),
+            )
+            raise UnimplementedURLException(url, "export" if export else "import")
+
+        if implementation._supports_url(url, export):
+            return implementation
+        raise UnimplementedURLException(url, "export" if export else "import")
+
+#####
+# Built-in url access
+#####
+
+def file_job_store_factory() -> type[URLAccess]:
+    from toil.jobStores.fileJobStore import FileJobStore
+
+    return FileJobStore
+
+
+def google_job_store_factory() -> type[URLAccess]:
+    from toil.jobStores.googleJobStore import GoogleJobStore
+
+    return GoogleJobStore
+
+
+def aws_job_store_factory() -> type[URLAccess]:
+    from toil.jobStores.aws.jobStore import AWSJobStore
+
+    return AWSJobStore
+
+
+def job_store_support_factory() -> type[URLAccess]:
+    from toil.jobStores.abstractJobStore import JobStoreSupport
+
+    return JobStoreSupport
+
+#make sure my py still works and the tests work
+# can then get rid of _url_access_classes method
+
+#####
+# Registers all built-in urls
+#####
+register_plugin("url_access", "file", file_job_store_factory)
+register_plugin("url_access", "gs", google_job_store_factory)
+register_plugin("url_access", "s3", aws_job_store_factory)
+register_plugin("url_access", "http", job_store_support_factory)
+register_plugin("url_access", "https", job_store_support_factory)
+register_plugin("url_access", "ftp", job_store_support_factory)

toil/options/cwl.py

@@ -3,6 +3,8 @@ from argparse import ArgumentParser
 
 from configargparse import SUPPRESS
 
+from toil.lib.conversions import human2bytes
+from toil.options.common import make_open_interval_action
 from toil.version import baseVersion
 
 
@@ -411,9 +413,19 @@ def add_cwl_options(parser: ArgumentParser, suppress: bool = True) -> None:
         "--no-cwl-default-ram",
         action="store_false",
         help=suppress_help
-        or "Do not apply CWL specification default ramMin, so that Toil --defaultMemory applies.",
+        or "Do not apply CWL specification default ramMin, so that Toil --defaultMemory applies. This can help jobs get to Slurm with no memory limit assigned.",
         dest="cwl_default_ram",
     )
+    parser.add_argument(
+        "--cwl-min-ram",
+        type=human2bytes,
+        action=make_open_interval_action(1),
+        help=suppress_help
+        or "Specify a minimum memory allocation for all tasks ."
+        "If --no-cwl-default-ram is passed, this does not apply to tools that do not "
+        "specify a memory requirement; --defaultMemory is used for those tools"
+        "in that case."
+    )
     parser.add_argument(
         "--destBucket",
         type=str,

toil/options/runner.py

@@ -1,4 +1,4 @@
-from argparse import ArgumentParser
+from argparse import ArgumentParser, SUPPRESS
 
 from toil.lib.conversions import human2bytes
 
@@ -25,17 +25,23 @@ def add_runner_options(
         help="Run the file imports on a worker instead of the leader. This is useful if the leader is not optimized for high network performance. "
         "If set to true, the argument --importWorkersDisk must also be set."
     )
-    import_workers_threshold_argument = ["--importWorkersThreshold"]
+    import_workers_batchsize_argument = ["--importWorkersBatchSize"]
     if cwl:
-        import_workers_threshold_argument.append("--import-workers-threshold")
+        import_workers_batchsize_argument.append("--import-workers-batch-size")
     parser.add_argument(
-        *import_workers_threshold_argument,
-        dest="import_workers_threshold",
+        *import_workers_batchsize_argument,
+        dest="import_workers_batchsize",
         type=lambda x: human2bytes(str(x)),
         default="1 GiB",
-        help="Specify the file size threshold that determines how many files go into a batched import. As many files will go into a batch import job until this threshold "
-             "is reached. This should be set in conjunction with the argument --runImportsOnWorkers."
+        help="Specify the target total file size for file import batches. "
+        "As many files as can fit will go into each batch import job. This should be set in conjunction with the argument --runImportsOnWorkers."
     )
+
+    # Deprecated
+    parser.add_argument(
+        "--importWorkersThreshold", "--import-workers-threshold", dest="import_workers_batchsize",type=lambda x: human2bytes(str(x)), help=SUPPRESS
+    )
+
     import_workers_disk_argument = ["--importWorkersDisk"]
     if cwl:
         import_workers_disk_argument.append("--import-workers-disk")
@@ -44,7 +50,8 @@ def add_runner_options(
         dest="import_workers_disk",
         type=lambda x: human2bytes(str(x)),
         default="1 MiB",
-        help="Specify the disk size each import worker will get. This may be necessary when file streaming is not possible. For example, downloading from AWS to a GCE "
-             "job store. If specified, this should be set to the largest file size of all files to import. This should be set in conjunction with the arguments "
-             "--runImportsOnWorkers and --importWorkersThreshold."
+        help="Specify the disk size each import worker will get. This usually will not need to be set as Toil will attempt to use file streaming when downloading files. "
+             "If not possible, for example, when downloading from AWS to a GCE job store, "
+             "this should be set to the largest file size of all files to import. This should be set in conjunction with the arguments "
+             "--runImportsOnWorkers and --importWorkersBatchSize."
     )

toil/options/wdl.py

@@ -96,4 +96,15 @@ def add_wdl_options(parser: ArgumentParser, suppress: bool = True) -> None:
         type=strtobool,
         default=False,
         help=suppress_help or "Exit runner if workflow has any lint warnings"
-    )
+    )
+
+    quant_check_arguments = ["--wdlQuantCheck"] + (
+        ["--quantCheck"] if not suppress else []
+    )
+    parser.add_argument(
+        *quant_check_arguments,
+        dest="quant_check",
+        type=strtobool,
+        default=True,
+        help=suppress_help or "Whether to relax quantifier validation rules"
+    )

toil/provisioners/aws/awsProvisioner.py

@@ -109,6 +109,11 @@ _INSTANCE_PROFILE_ROLE_NAME = "toil"
 _TAG_KEY_TOIL_NODE_TYPE = "ToilNodeType"
 # The tag that specifies the cluster name on all nodes
 _TAG_KEY_TOIL_CLUSTER_NAME = "clusterName"
+# The tag we use to store the SSH key name.
+# TODO: Get rid of this once
+# <https://github.com/adamchainz/ec2-metadata/pull/562> is merged and we can
+# get the SSH key name from the instance metadata.
+_TAG_KEY_TOIL_SSH_KEY = "sshKeyName"
 # How much storage on the root volume is expected to go to overhead and be
 # unavailable to jobs when the node comes up?
 # TODO: measure
@@ -309,11 +314,28 @@ class AWSProvisioner(AbstractProvisioner):
         for tag in instance["Tags"]:
             if tag.get("Key") == "Name":
                 self.clusterName = tag["Value"]
+            elif tag.get("Key") == _TAG_KEY_TOIL_SSH_KEY:
+                # If we can't get an SSH key from the instance metadata, we
+                # might be able to use this one from the tags.
+                self._keyName = tag["Value"]
         # Determine what subnet we, the leader, are in
         self._leader_subnet = instance["SubnetId"]
         # Determine where to deploy workers.
         self._worker_subnets_by_zone = self._get_good_subnets_like(self._leader_subnet)
 
+        # Find the SSH key name to use to start instances
+        if hasattr(ec2_metadata, 'public_keys') and isinstance(ec2_metadata.public_keys, dict):
+            key_names = list(ec2_metadata.public_keys.keys())
+            if len(key_names) > 0 and isinstance(key_names[0], str):
+                # We have a key name from the EC2 metadata. This should always
+                # be the case once
+                # <https://github.com/adamchainz/ec2-metadata/pull/562> is
+                # merged. Override anything from the tags.
+                self._keyName = key_names[0]
+
+        if not hasattr(self, '_keyName'):
+            raise RuntimeError("Unable to determine the SSH key name the cluster is using")
+
         self._leaderPrivateIP = ec2_metadata.private_ipv4  # this is PRIVATE IP
         self._tags = {
             k: v
@@ -495,6 +517,7 @@ class AWSProvisioner(AbstractProvisioner):
         # Make tags for the leader specifically
         leader_tags = dict(self._tags)
         leader_tags[_TAG_KEY_TOIL_NODE_TYPE] = "leader"
+        leader_tags[_TAG_KEY_TOIL_SSH_KEY] = self._keyName
         logger.debug("Launching leader with tags: %s", leader_tags)
 
         instances: list[Instance] = create_instances(
@@ -1144,7 +1167,7 @@ class AWSProvisioner(AbstractProvisioner):
             workerInstances = [
                 i
                 for i in workerInstances
-                if preemptible == (i["SpotInstanceRequestId"] is not None)
+                if preemptible == (i.get("SpotInstanceRequestId") is not None)
             ]
             logger.debug(
                 "%spreemptible workers found in cluster: %s",
@@ -1161,7 +1184,7 @@ class AWSProvisioner(AbstractProvisioner):
                 name=i["InstanceId"],
                 launchTime=i["LaunchTime"],
                 nodeType=i["InstanceType"],
-                preemptible=i["SpotInstanceRequestId"] is not None,
+                preemptible=i.get("SpotInstanceRequestId") is not None,
                 tags=collapse_tags(i["Tags"]),
             )
             for i in workerInstances

toil/server/app.py

@@ -16,6 +16,7 @@ import logging
 import os
 
 import connexion  # type: ignore
+from connexion.options import SwaggerUIOptions  # type: ignore[import-untyped]
 from configargparse import ArgumentParser
 
 from toil.lib.aws import get_current_aws_region, running_on_ec2, running_on_ecs
@@ -133,8 +134,10 @@ def create_app(args: argparse.Namespace) -> "connexion.FlaskApp":
     """
     Create a "connexion.FlaskApp" instance with Toil server configurations.
     """
+    swagger_ui_options = SwaggerUIOptions(swagger_ui=args.swagger_ui)
+
     flask_app = connexion.FlaskApp(
-        __name__, specification_dir="api_spec/", options={"swagger_ui": args.swagger_ui}
+        __name__, specification_dir="api_spec/", swagger_ui_options=swagger_ui_options
     )
 
     flask_app.app.config["JSON_SORT_KEYS"] = False
@@ -164,16 +167,16 @@ def create_app(args: argparse.Namespace) -> "connexion.FlaskApp":
     if isinstance(backend, ToilBackend):
         # We extend the WES API to allow presenting log data
         base_url = "/toil/wes/v1"
-        flask_app.app.add_url_rule(
+        flask_app.add_url_rule(
             f"{base_url}/logs/<run_id>/stdout", view_func=backend.get_stdout
         )
-        flask_app.app.add_url_rule(
+        flask_app.add_url_rule(
             f"{base_url}/logs/<run_id>/stderr", view_func=backend.get_stderr
         )
         # To be a well-behaved AGC engine we can implement the default status check endpoint
-        flask_app.app.add_url_rule("/engine/v1/status", view_func=backend.get_health)
+        flask_app.add_url_rule("/engine/v1/status", view_func=backend.get_health)
         # And we can provide lost humans some information on what they are looking at
-        flask_app.app.add_url_rule("/", view_func=backend.get_homepage)
+        flask_app.add_url_rule("/", view_func=backend.get_homepage)
 
     return flask_app
 
@@ -201,9 +204,12 @@ def start_server(args: argparse.Namespace) -> None:
     else:
         # start a production WSGI server
         run_app(
-            flask_app.app,
+            flask_app,
             options={
                 "bind": f"{host}:{port}",
                 "workers": args.workers,
+                # The uvicorn worker class must be specified for gunicorn to work on connexion 3
+                # https://github.com/spec-first/connexion/issues/1755#issuecomment-1778522142
+                "worker_class": "uvicorn.workers.UvicornWorker"
             },
         )

toil/server/cli/wes_cwl_runner.py

@@ -14,7 +14,7 @@ import ruamel.yaml
 import schema_salad
 from configargparse import ArgumentParser
 from wes_client.util import WESClient  # type: ignore
-from wes_client.util import wes_reponse as wes_response
+from wes_client.util import wes_response as wes_response
 
 from toil.lib.web import web_session
 from toil.wdl.utils import get_version as get_wdl_version
@@ -144,7 +144,7 @@ class WESClientWithWorkflowEngineParameters(WESClient):  # type: ignore
             return "3.8"
         elif extension == "cwl":
             with open(workflow_file) as f:
-                yaml = ruamel.yaml.YAML(typ='safe', pure=True)
+                yaml = ruamel.yaml.YAML(typ="safe", pure=True)
                 return str(yaml.load(f)["cwlVersion"])
         elif extension == "wdl":
             with open(workflow_file) as f: