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

toil/test/wdl/wdltoil_test.py

@@ -13,6 +13,8 @@ from unittest.mock import patch
 from uuid import uuid4
 
 import pytest
+from pytest_httpserver import HTTPServer
+
 import WDL.Error
 import WDL.Expr
 
@@ -23,6 +25,7 @@ from toil.test import (
     needs_docker,
     needs_docker_cuda,
     needs_google_storage,
+    needs_online,
     needs_singularity_or_docker,
     needs_wdl,
     slow,
@@ -32,14 +35,13 @@ from toil.wdl.wdltoil import (
     WDLSectionJob,
     WDLWorkflowGraph,
     parse_disks,
-    remove_common_leading_whitespace,
 )
 
 logger = logging.getLogger(__name__)
 
 
 WDL_CONFORMANCE_TEST_REPO = "https://github.com/DataBiosphere/wdl-conformance-tests.git"
-WDL_CONFORMANCE_TEST_COMMIT = "baf44bcc7e6f6927540adf77d91b26a5558ae4b7"
+WDL_CONFORMANCE_TEST_COMMIT = "46b5f85ee38ec60d0b8b9c35928b5104a2af83d5"
 # These tests are known to require things not implemented by
 # Toil and will not be run in CI.
 WDL_CONFORMANCE_TESTS_UNSUPPORTED_BY_TOIL = [
@@ -108,16 +110,25 @@ class TestWDLConformance:
                 "Failed process standard error: %s",
                 p.stderr.decode("utf-8", errors="replace"),
             )
+        else:
+            logger.debug(
+                "Successful process standard output: %s",
+                p.stdout.decode("utf-8", errors="replace"),
+            )
+            logger.debug(
+                "Successful process standard error: %s",
+                p.stderr.decode("utf-8", errors="replace"),
+            )
 
         p.check_returncode()
 
     @slow
     def test_unit_tests_v11(self, wdl_conformance_test_repo: Path) -> None:
-        # There are still some bugs with the WDL spec, use a fixed version until
-        # See comments of https://github.com/openwdl/wdl/pull/669
+        # TODO: Using a branch lets Toil commits that formerly passed start to
+        # fail CI when the branch moves.
         os.chdir(wdl_conformance_test_repo)
-        repo_url = "https://github.com/stxue1/wdl.git"
-        repo_branch = "wdl-1.1.3-fixes"
+        repo_url = "https://github.com/openwdl/wdl.git"
+        repo_branch = "wdl-1.1"
         commands1 = [
             exactPython,
             "setup_unit_tests.py",
@@ -193,6 +204,30 @@ class TestWDLConformance:
 
         self.check(p)
 
+    # estimated running time: 10 minutes (once all the appropriate tests get
+    # marked as "development")
+    @slow
+    def test_conformance_tests_development(self, wdl_conformance_test_repo: Path) -> None:
+        os.chdir(wdl_conformance_test_repo)
+        commands = [
+            exactPython,
+            "run.py",
+            "--runner",
+            "toil-wdl-runner",
+            "--conformance-file",
+            "conformance.yaml",
+            "-v",
+            "development",
+        ]
+        if WDL_CONFORMANCE_TESTS_UNSUPPORTED_BY_TOIL:
+            commands.append("--exclude-numbers")
+            commands.append(
+                ",".join([str(t) for t in WDL_CONFORMANCE_TESTS_UNSUPPORTED_BY_TOIL])
+            )
+        p = subprocess.run(commands, capture_output=True)
+
+        self.check(p)
+
     @slow
     def test_conformance_tests_integration(
         self, wdl_conformance_test_repo: Path
@@ -249,6 +284,7 @@ class TestWDL:
                 assert os.path.exists(result["ga4ghMd5.value"])
                 assert os.path.basename(result["ga4ghMd5.value"]) == "md5sum.txt"
 
+    @needs_online
     def test_url_to_file(self, tmp_path: Path) -> None:
         """
         Test if web URL strings can be coerced to usable Files.
@@ -308,6 +344,59 @@ class TestWDL:
             assert isinstance(result["wait.result"], str)
             assert result["wait.result"] == "waited"
 
+    def test_restart(self, tmp_path: Path) -> None:
+        """
+        Test if a WDL workflow can be restarted and finish successfully.
+        """
+        with get_data("test/wdl/testfiles/read_file.wdl") as wdl:
+            out_dir = tmp_path / "out"
+            file_path = tmp_path / "file"
+            jobstore_path = tmp_path / "tree"
+            command = (
+                self.base_command
+                + [
+                    str(wdl),
+                    "-o",
+                    str(out_dir),
+                    "-i",
+                    json.dumps({"read_file.input_string": str(file_path)}),
+                    "--jobStore",
+                    str(jobstore_path),
+                    "--retryCount=0"
+                ]
+            )
+            with pytest.raises(subprocess.CalledProcessError):
+                # The first time we run it, it should fail because it's trying
+                # to work on a nonexistent file from a string path.
+                result_json = subprocess.check_output(
+                    command + ["--logCritical"]
+                )
+
+            # Then create the file
+            with open(file_path, "w") as f:
+                f.write("This is a line\n")
+                f.write("This is a different line")
+            
+            # Now it should work
+            result_json = subprocess.check_output(
+                    command + ["--restart"]
+                )
+            result = json.loads(result_json)
+
+            assert "read_file.lines" in result
+            assert isinstance(result["read_file.lines"], list)
+            assert result["read_file.lines"] == [
+                "This is a line",
+                "This is a different line"
+            ]
+
+            # Since we were catching
+            # <https://github.com/DataBiosphere/toil/issues/5247> at file
+            # export, make sure we actually exported a file.
+            assert "read_file.remade_file" in result
+            assert isinstance(result["read_file.remade_file"], str)
+            assert os.path.exists(result["read_file.remade_file"])
+
     @needs_singularity_or_docker
     def test_workflow_file_deletion(self, tmp_path: Path) -> None:
         """
@@ -597,7 +686,7 @@ class TestWDL:
                 != result_not_cached["random.value_written"]
             )
 
-    def test_url_to_optional_file(self, tmp_path: Path) -> None:
+    def test_url_to_optional_file(self, tmp_path: Path, httpserver: HTTPServer) -> None:
         """
         Test if missing and error-producing URLs are handled correctly for optional File? values.
         """
@@ -610,7 +699,15 @@ class TestWDL:
                 Return the parsed output.
                 """
                 logger.info("Test optional file with HTTP code %s", code)
-                json_value = '{"url_to_optional_file.http_code": %d}' % code
+                httpserver.expect_request(
+                    "/" + str(code)
+                ).respond_with_data(
+                    "Some data",
+                    status=code,
+                    content_type="text/plain"
+                )
+                base_url = httpserver.url_for("/")
+                json_value = '{"url_to_optional_file.http_code": %d, "url_to_optional_file.base_url": "%s"}' % (code, base_url)
                 result_json = subprocess.check_output(
                     self.base_command
                     + [
@@ -792,25 +889,29 @@ class TestWDL:
         env["TOIL_DOCKSTORE_TOKEN"] = "99cf5578ebe94b194d7864630a86258fa3d6cedcc17d757b5dd49e64ee3b68c3"
         # Enable history for when <https://github.com/DataBiosphere/toil/pull/5258> merges
         env["TOIL_HISTORY"] = "True"
+        
+        try:
+            output_log = subprocess.check_output(
+                self.base_command
+                + [
+                    wdl_file,
+                    json_input,
+                    "--logDebug",
+                    "-o",
+                    str(tmp_path),
+                    "--outputDialect",
+                    "miniwdl",
+                    "--publishWorkflowMetrics=current",
+                ]
+                + (extra_args or []),
+                stderr=subprocess.STDOUT,
+                env=env,
+            ).decode("utf-8", errors="replace")
+        except subprocess.CalledProcessError as e:
+            logger.error("Test run of Toil failed: %s", e.stdout.decode("utf-8", errors="replace"))
+            raise
 
-        output_log = subprocess.check_output(
-            self.base_command
-            + [
-                wdl_file,
-                json_input,
-                "--logDebug",
-                "-o",
-                str(tmp_path),
-                "--outputDialect",
-                "miniwdl",
-                "--publishWorkflowMetrics=current",
-            ]
-            + (extra_args or []),
-            stderr=subprocess.STDOUT,
-            env=env,
-        )
-
-        assert b'Workflow metrics were accepted by Dockstore.' in output_log
+        assert "Workflow metrics were accepted by Dockstore." in output_log, f"No acceptance message in log: {output_log}"
 
     @slow
     @needs_docker_cuda
@@ -1055,7 +1156,7 @@ class TestWDLToilBench(unittest.TestCase):
                     assert "decl2" in result[0]
                     assert "successor" in result[1]
 
-    def make_string_expr(self, to_parse: str) -> WDL.Expr.String:
+    def make_string_expr(self, to_parse: str, expr_type: type[WDL.Expr.String] = WDL.Expr.String) -> WDL.Expr.String:
         """
         Parse pseudo-WDL for testing whitespace removal.
         """
@@ -1066,122 +1167,7 @@ class TestWDLToilBench(unittest.TestCase):
         for i in range(1, len(parts), 2):
             parts[i] = WDL.Expr.Placeholder(pos, {}, WDL.Expr.Null(pos))
 
-        return WDL.Expr.String(pos, parts)
-
-    def test_remove_common_leading_whitespace(self) -> None:
-        """
-        Make sure leading whitespace removal works properly.
-        """
-
-        # For a single line, we remove its leading whitespace
-        expr = self.make_string_expr(" a ~{b} c")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "a "
-        assert trimmed.parts[2] == " c"
-
-        # Whitespace removed isn't affected by totally blank lines
-        expr = self.make_string_expr("    \n\n    a\n    ~{stuff}\n    b\n\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\n\na\n"
-        assert trimmed.parts[2] == "\nb\n\n"
-
-        # Unless blank toleration is off
-        expr = self.make_string_expr("    \n\n    a\n    ~{stuff}\n    b\n\n")
-        trimmed = remove_common_leading_whitespace(expr, tolerate_blanks=False)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "    \n\n    a\n    "
-        assert trimmed.parts[2] == "\n    b\n\n"
-
-        # Whitespace is still removed if the first line doesn't have it before the newline
-        expr = self.make_string_expr("\n    a\n    ~{stuff}\n    b\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\na\n"
-        assert trimmed.parts[2] == "\nb\n"
-
-        # Whitespace is not removed if actual content is dedented
-        expr = self.make_string_expr("    \n\n    a\n    ~{stuff}\nuhoh\n    b\n\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "    \n\n    a\n    "
-        assert trimmed.parts[2] == "\nuhoh\n    b\n\n"
-
-        # Unless dedents are tolerated
-        expr = self.make_string_expr("    \n\n    a\n    ~{stuff}\nuhoh\n    b\n\n")
-        trimmed = remove_common_leading_whitespace(expr, tolerate_dedents=True)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\n\na\n"
-        assert trimmed.parts[2] == "\nuhoh\nb\n\n"
-
-        # Whitespace is still removed if all-whitespace lines have less of it
-        expr = self.make_string_expr("\n    a\n    ~{stuff}\n  \n    b\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\na\n"
-        assert trimmed.parts[2] == "\n\nb\n"
-
-        # Unless all-whitespace lines are not tolerated
-        expr = self.make_string_expr("\n    a\n    ~{stuff}\n  \n    b\n")
-        trimmed = remove_common_leading_whitespace(expr, tolerate_all_whitespace=False)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\n  a\n  "
-        assert trimmed.parts[2] == "\n\n  b\n"
-
-        # When mixed tabs and spaces are detected, nothing is changed.
-        expr = self.make_string_expr("\n    a\n\t~{stuff}\n    b\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\n    a\n\t"
-        assert trimmed.parts[2] == "\n    b\n"
-
-        # When mixed tabs and spaces are not in the prefix, whitespace is removed.
-        expr = self.make_string_expr("\n\ta\n\t~{stuff} \n\tb\n")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == "\na\n"
-        assert trimmed.parts[2] == " \nb\n"
-
-        # An empty string works
-        expr = self.make_string_expr("")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 1
-        assert trimmed.parts[0] == ""
-
-        # A string of only whitespace is preserved as an all-whitespece line
-        expr = self.make_string_expr("\t\t\t")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 1
-        assert trimmed.parts[0] == "\t\t\t"
-
-        # A string of only whitespace is trimmed when all-whitespace lines are not tolerated
-        expr = self.make_string_expr("\t\t\t")
-        trimmed = remove_common_leading_whitespace(expr, tolerate_all_whitespace=False)
-        assert len(trimmed.parts) == 1
-        assert trimmed.parts[0] == ""
-
-        # An empty expression works
-        expr = WDL.Expr.String(
-            WDL.Error.SourcePosition("nowhere", "nowhere", 0, 0, 0, 0), []
-        )
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 0
-
-        # An expression of only placeholders works
-        expr = self.make_string_expr("~{AAA}")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert len(trimmed.parts) == 3
-        assert trimmed.parts[0] == ""
-        assert trimmed.parts[2] == ""
-
-        # The command flag is preserved
-        expr = self.make_string_expr(" a ~{b} c")
-        trimmed = remove_common_leading_whitespace(expr)
-        assert trimmed.command == False
-        expr.command = True
-        trimmed = remove_common_leading_whitespace(expr)
-        assert trimmed.command == True
+        return expr_type(pos, parts)
 
     def test_choose_human_readable_directory(self) -> None:
         """
@@ -1189,34 +1175,57 @@ class TestWDLToilBench(unittest.TestCase):
         """
 
         from toil.wdl.wdltoil import (
-            DirectoryNamingStateDict,
             choose_human_readable_directory,
         )
 
-        state: DirectoryNamingStateDict = {}
-
-        # The first time we should get  apath with the task name and without the ID
+        # The first time we should get a path with the task name
         first_chosen = choose_human_readable_directory(
-            "root", "taskname", "111-222-333", state
+            "root", "taskname", "https://example.com/some/directory"
         )
         assert first_chosen.startswith("root")
-        assert "taskname" in first_chosen
-        assert "111-222-333" not in first_chosen
 
-        # If we use the same ID we should get the same result
-        same_id = choose_human_readable_directory(
-            "root", "taskname", "111-222-333", state
+        # If we use the same parent we should get the same result
+        same_parent = choose_human_readable_directory(
+            "root", "taskname", "https://example.com/some/directory"
+        )
+        assert same_parent == first_chosen
+
+        # If we use a lower parent with a URL, we do not necessarily need to be
+        # inside the higher parent.
+
+        # If we use a URL with a creative number of slashes, it should be distinct.
+        slash_parent = choose_human_readable_directory(
+            "root", "taskname", "https://example.com/some/directory//////"
+        )
+        assert slash_parent != first_chosen
+
+        # If we use the same parent URL but a different task we should get the same result
+        other_task = choose_human_readable_directory(
+            "root", "taskname2", "https://example.com/some/directory"
+        )
+        assert other_task == first_chosen
+
+        # If we use a different parent we should get a different result still obeying the constraints
+        diff_parent = choose_human_readable_directory(
+            "root", "taskname", "/data/tmp/files/somewhere"
+        )
+        assert diff_parent != first_chosen
+        assert diff_parent.startswith("root")
+        assert "taskname" in diff_parent
+
+        # If we use a subpath parent with a filename we should get a path inside it.
+        diff_parent_subpath = choose_human_readable_directory(
+            "root", "taskname", "/data/tmp/files/somewhere/else"
         )
-        assert same_id == first_chosen
+        assert os.path.dirname(diff_parent_subpath) == diff_parent
 
-        # If we use a different ID we should get a different result still obeying the constraints
-        diff_id = choose_human_readable_directory(
-            "root", "taskname", "222-333-444", state
+        # If we use the same parent path but a different task we should get a different result.
+        other_task_directory = choose_human_readable_directory(
+            "root", "taskname2", "/data/tmp/files/somewhere"
         )
-        assert diff_id != first_chosen
-        assert diff_id.startswith("root")
-        assert "taskname" in diff_id
-        assert "222-333-444" not in diff_id
+        assert other_task_directory != diff_parent
+        assert other_task_directory.startswith("root")
+        assert "taskname2" in other_task_directory
 
     def test_uri_packing(self) -> None:
         """
@@ -1232,7 +1241,7 @@ class TestWDLToilBench(unittest.TestCase):
         file_basename = "thefile.txt"
 
         # Pack and unpack it
-        uri = pack_toil_uri(file_id, task_path, dir_id, file_basename)
+        uri = pack_toil_uri(file_id, task_path, str(dir_id), file_basename)
         unpacked = unpack_toil_uri(uri)
 
         # Make sure we got what we put in

toil/test/wdl/wdltoil_test_kubernetes.py

@@ -1,6 +1,7 @@
 import unittest
 from uuid import uuid4
 
+import logging
 import pytest
 
 from toil.provisioners import cluster_factory
@@ -12,6 +13,8 @@ from toil.test.wdl.wdltoil_test import (
 )
 
 
+logger = logging.getLogger(__name__)
+
 @integrative
 @slow
 @pytest.mark.timeout(1800)
@@ -52,6 +55,7 @@ class WDLKubernetesClusterTest(AbstractClusterTest):
         workflow that performs an image pull on the worker.
         :return:
         """
+
         self.numWorkers = "1"
         self.requestedLeaderStorage = 30
         # create the cluster
@@ -64,6 +68,8 @@ class WDLKubernetesClusterTest(AbstractClusterTest):
 
         wdl_dir = "wdl_conformance_tests"
 
+        logger.info("Cloning WDL tests onto cluster...")
+
         # get the wdl-conformance-tests repo to get WDL tasks to run
         self.sshUtil(
             [
@@ -78,6 +84,9 @@ class WDLKubernetesClusterTest(AbstractClusterTest):
 
         # run WDL workflow that will run singularity
         test_options = [f"tests/md5sum/md5sum.wdl", f"tests/md5sum/md5sum.json"]
+
+        logger.info("Running workflow...")
+
         self.sshUtil(
             [
                 "bash",

toil/utils/toilDebugFile.py

@@ -47,12 +47,12 @@ def fetchJobStoreFiles(jobStore: FileJobStore, options: argparse.Namespace) -> N
         jobStoreHits = glob(directoryname=options.jobStore, glob_pattern=jobStoreFile)
         for jobStoreFileID in jobStoreHits:
             logger.debug(
-                f"Copying job store file: {jobStoreFileID} to {options.localFilePath[0]}"
+                f"Copying job store file: {jobStoreFileID} to {options.localFilePath}"
             )
             jobStore.read_file(
                 jobStoreFileID,
                 os.path.join(
-                    options.localFilePath[0], os.path.basename(jobStoreFileID)
+                    options.localFilePath, os.path.basename(jobStoreFileID)
                 ),
                 symlink=options.useSymlinks,
             )
@@ -97,7 +97,10 @@ def printContentsOfJobStore(
 def main() -> None:
     parser = parser_with_common_options(jobstore_option=True, prog="toil debug-file")
     parser.add_argument(
-        "--localFilePath", nargs=1, help="Location to which to copy job store files."
+        "--localFilePath",
+        type=str,
+        default=".",
+        help="Location to which to copy job store files."
     )
     parser.add_argument(
         "--fetch",

toil/utils/toilSshCluster.py

@@ -14,6 +14,7 @@
 """SSH into the toil appliance container running on the leader of the cluster."""
 import argparse
 import logging
+import socket
 import sys
 
 from toil.common import parser_with_common_options
@@ -22,6 +23,22 @@ from toil.statsAndLogging import set_logging_from_options
 
 logger = logging.getLogger(__name__)
 
+def have_ipv6() -> bool:
+    """
+    Return True if the IPv6 loopback interface is useable.
+    """
+
+    # We sniff for actual IPv6 like in
+    # https://github.com/urllib3/urllib3/pull/840/files in urllib3 (which we
+    # don't depend on)
+    if socket.has_ipv6:
+        # Built with IPv6 support
+        try:
+            socket.socket(socket.AF_INET6).bind(("::1", 0))
+            return True
+        except Exception:
+            pass
+    return False
 
 def main() -> None:
     parser = parser_with_common_options(
@@ -73,6 +90,12 @@ def main() -> None:
         ["-L", f"{options.grafana_port}:localhost:3000", "-L", "9090:localhost:9090"]
     )
 
+    if not have_ipv6():
+        # If we try to do SSH port forwarding without any other options, but
+        # IPv6 is turned off on the host, we might get complaints that we
+        # "Cannot assign requested address" on ports on [::1].
+        sshOptions.append("-4")
+
     try:
         cluster.getLeader().sshAppliance(
             *command,

toil/utils/toilStats.py

@@ -326,6 +326,8 @@ def sprint_tag(
     out_str += header + "\n"
     out_str += sub_header + "\n"
     out_str += tag_str + "\n"
+    if tag.excess_cpu > 0:
+        out_str += f" ({tag.excess_cpu} used more CPU than requested!)\n"
     return out_str
 
 
@@ -507,13 +509,25 @@ def build_element(
                 float(item.get(category_key, defaults[category])), category
             )
             values.append(category_value)
-
+    
+    excess_cpu_items = 0
     for index in range(0, len(item_values[CATEGORIES[0]])):
         # For each item, compute the computed categories
-        item_values["wait"].append(
+
+        # Compute wait time (allocated CPU time wasted).
+        # Note that if any item uses *more* CPU cores than requested, at any
+        # time, that decreases the amount of wait we're able to see from that
+        # item. If it hapens a lot, our computed wait could go negative, so we
+        # bound it below at 0.
+        wait_value = (
             item_values["time"][index] * item_values["cores"][index]
             - item_values["clock"][index]
         )
+        if wait_value < 0:
+            # Remember an item used more CPU than allocated.
+            excess_cpu_items += 1
+            wait_value = 0
+        item_values["wait"].append(wait_value)
 
     for category, values in item_values.items():
         values.sort()
@@ -531,6 +545,7 @@ def build_element(
         item_element["average_" + category] = float(sum(values) / len(values))
         item_element["min_" + category] = float(min(values))
         item_element["max_" + category] = float(max(values))
+    item_element["excess_cpu"] = excess_cpu_items
 
     element[item_name] = item_element
 

toil/utils/toilUpdateEC2Instances.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 # Copyright (C) 2015-2021 Regents of the University of California
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

toil/version.py

@@ -1,14 +1,14 @@
-baseVersion = '8.2.0'
+baseVersion = '9.1.0'
 cgcloudVersion = '1.6.0a1.dev393'
-version = '8.2.0-3efbe6f84b89a1eeab1d7b5913bbd01084d6490e'
-cacheTag = 'cache-local-py3.10'
-mainCacheTag = 'cache-master-py3.10'
-distVersion = '8.2.0'
-exactPython = 'python3.10'
-python = 'python3.10'
-dockerTag = '8.2.0-3efbe6f84b89a1eeab1d7b5913bbd01084d6490e-py3.10'
-currentCommit = '3efbe6f84b89a1eeab1d7b5913bbd01084d6490e'
+version = '9.1.0-e341bb669efe78f93308e5ff1f02f7e375973511'
+cacheTag = 'cache-local-py3.9'
+mainCacheTag = 'cache-master-py3.9'
+distVersion = '9.1.0'
+exactPython = 'python3.9'
+python = 'python3.9'
+dockerTag = '9.1.0-e341bb669efe78f93308e5ff1f02f7e375973511-py3.9'
+currentCommit = 'e341bb669efe78f93308e5ff1f02f7e375973511'
 dockerRegistry = 'quay.io/ucsc_cgl'
 dockerName = 'toil'
 dirty = False
-cwltool_version = '3.1.20250110105449'
+cwltool_version = '3.1.20250715140722'