toil 7.0.0__py3-none-any.whl → 8.0.0__py3-none-any.whl

toil/test/wdl/wdltoil_test_kubernetes.py

@@ -1,16 +1,20 @@
 import unittest
-
-from toil.test.provisioners.clusterTest import AbstractClusterTest
 from uuid import uuid4
 
 import pytest
 
 from toil.provisioners import cluster_factory
-from toil.test import (slow, integrative)
+from toil.test import integrative, slow
+from toil.test.provisioners.clusterTest import AbstractClusterTest
+from toil.test.wdl.wdltoil_test import (
+    WDL_CONFORMANCE_TEST_COMMIT,
+    WDL_CONFORMANCE_TEST_REPO,
+)
+
 
 @integrative
 @slow
-@pytest.mark.timeout(600)
+@pytest.mark.timeout(1800)
 class WDLKubernetesClusterTest(AbstractClusterTest):
     """
     Ensure WDL works on the Kubernetes batchsystem.
@@ -18,7 +22,7 @@ class WDLKubernetesClusterTest(AbstractClusterTest):
 
     def __init__(self, name):
         super().__init__(name)
-        self.clusterName = 'wdl-integration-test-' + str(uuid4())
+        self.clusterName = "wdl-integration-test-" + str(uuid4())
         # t2.medium is the minimum t2 instance that permits Kubernetes
         self.leaderNodeType = "t2.medium"
         self.instanceTypes = ["t2.medium"]
@@ -26,13 +30,21 @@ class WDLKubernetesClusterTest(AbstractClusterTest):
 
     def setUp(self) -> None:
         super().setUp()
-        self.jobStore = f'aws:{self.awsRegion()}:wdl-test-{uuid4()}'
+        self.jobStore = f"aws:{self.awsRegion()}:wdl-test-{uuid4()}"
 
     def launchCluster(self) -> None:
-        self.createClusterUtil(args=['--leaderStorage', str(self.requestedLeaderStorage),
-                                     '--nodeTypes', ",".join(self.instanceTypes),
-                                     '-w', ",".join(self.numWorkers),
-                                     '--nodeStorage', str(self.requestedLeaderStorage)])
+        self.createClusterUtil(
+            args=[
+                "--leaderStorage",
+                str(self.requestedLeaderStorage),
+                "--nodeTypes",
+                ",".join(self.instanceTypes),
+                "-w",
+                ",".join(self.numWorkers),
+                "--nodeStorage",
+                str(self.requestedLeaderStorage),
+            ]
+        )
 
     def test_wdl_kubernetes_cluster(self):
         """
@@ -50,27 +62,29 @@ class WDLKubernetesClusterTest(AbstractClusterTest):
         )
         self.leader = self.cluster.getLeader()
 
-        url = "https://github.com/DataBiosphere/wdl-conformance-tests.git"
-        commit = "09b9659cd01473e836738a2e0dd205df0adb49c5"
         wdl_dir = "wdl_conformance_tests"
 
         # get the wdl-conformance-tests repo to get WDL tasks to run
-        self.sshUtil([
-            "bash",
-            "-c",
-            f"git clone {url} {wdl_dir} && cd {wdl_dir} && git checkout {commit}"
-        ])
+        self.sshUtil(
+            [
+                "bash",
+                "-c",
+                f"git clone {WDL_CONFORMANCE_TEST_REPO} {wdl_dir} && cd {wdl_dir} && git checkout {WDL_CONFORMANCE_TEST_COMMIT}",
+            ]
+        )
 
         # run on kubernetes batchsystem
-        toil_options = ['--batchSystem=kubernetes',
-                        f"--jobstore={self.jobStore}"]
+        toil_options = ["--batchSystem=kubernetes", f"--jobstore={self.jobStore}"]
 
         # run WDL workflow that will run singularity
         test_options = [f"tests/md5sum/md5sum.wdl", f"tests/md5sum/md5sum.json"]
-        self.sshUtil([
-            "bash",
-            "-c",
-            f"cd {wdl_dir} && toil-wdl-runner {' '.join(test_options)} {' '.join(toil_options)}"])
+        self.sshUtil(
+            [
+                "bash",
+                "-c",
+                f"cd {wdl_dir} && toil-wdl-runner {' '.join(test_options)} {' '.join(toil_options)}",
+            ]
+        )
 
 
 if __name__ == "__main__":

toil/toilState.py

@@ -13,12 +13,11 @@
 # limitations under the License.
 import logging
 import time
-from typing import Dict, Optional, Set
+from typing import Optional
 
 from toil.bus import JobUpdatedMessage, MessageBus
 from toil.job import CheckpointJobDescription, JobDescription
-from toil.jobStores.abstractJobStore import (AbstractJobStore,
-                                             NoSuchJobException)
+from toil.jobStores.abstractJobStore import AbstractJobStore, NoSuchJobException
 
 logger = logging.getLogger(__name__)
 
@@ -63,47 +62,47 @@ class ToilState:
         # This holds the one true copy of every JobDescription in the leader.
         # TODO: Do in-place update instead of assignment when we load so we
         # can't let any non-true copies escape.
-        self.__job_database: Dict[str, JobDescription] = {}
+        self.__job_database: dict[str, JobDescription] = {}
 
         # Maps from successor (child or follow-on) jobStoreID to predecessor jobStoreIDs
-        self.successor_to_predecessors: Dict[str, Set[str]] = {}
+        self.successor_to_predecessors: dict[str, set[str]] = {}
 
         # Hash of jobStoreIDs to counts of numbers of successors issued.
         # There are no entries for jobs without successors in this map.
-        self.successorCounts: Dict[str, int] = {}
+        self.successorCounts: dict[str, int] = {}
 
         # This is a hash of service jobs, referenced by jobStoreID, to their client's ID
-        self.service_to_client: Dict[str, str] = {}
+        self.service_to_client: dict[str, str] = {}
 
         # Holds, for each client job ID, the job IDs of its services that are
         # possibly currently issued. Includes every service host that has been
         # given to the service manager by the leader, and hasn't been seen by
         # the leader as stopped yet.
-        self.servicesIssued: Dict[str, Set[str]] = {}
+        self.servicesIssued: dict[str, set[str]] = {}
 
         # Holds the IDs of jobs that are currently issued to the batch system
         # and haven't come back yet.
         # TODO: a bit redundant with leader's issued_jobs_by_batch_system_id
-        self.jobs_issued: Set[str] = set()
+        self.jobs_issued: set[str] = set()
 
         # The set of totally failed jobs - this needs to be filtered at the
         # end to remove jobs that were removed by checkpoints
-        self.totalFailedJobs: Set[str] = set()
+        self.totalFailedJobs: set[str] = set()
 
         # Jobs (as jobStoreIDs) with successors that have totally failed
-        self.hasFailedSuccessors: Set[str] = set()
+        self.hasFailedSuccessors: set[str] = set()
 
         # The set of successors of failed jobs as a set of jobStoreIds
-        self.failedSuccessors: Set[str] = set()
+        self.failedSuccessors: set[str] = set()
 
         # Set of jobs that have multiple predecessors that have one or more predecessors
         # finished, but not all of them.
-        self.jobsToBeScheduledWithMultiplePredecessors: Set[str] = set()
+        self.jobsToBeScheduledWithMultiplePredecessors: set[str] = set()
 
     def load_workflow(
         self,
         rootJob: JobDescription,
-        jobCache: Optional[Dict[str, JobDescription]] = None
+        jobCache: Optional[dict[str, JobDescription]] = None,
     ) -> None:
         """
         Load the workflow rooted at the given job.
@@ -281,7 +280,11 @@ class ToilState:
             )
         else:
             self.successorCounts[predecessor_id] -= 1
-            logger.debug("Successors: one fewer for %s, now have %d", predecessor_id, self.successorCounts[predecessor_id])
+            logger.debug(
+                "Successors: one fewer for %s, now have %d",
+                predecessor_id,
+                self.successorCounts[predecessor_id],
+            )
             if self.successorCounts[predecessor_id] == 0:
                 del self.successorCounts[predecessor_id]
 
@@ -296,7 +299,6 @@ class ToilState:
         else:
             return self.successorCounts[predecessor_id]
 
-
     def _buildToilState(self, jobDesc: JobDescription) -> None:
         """
         Build the ToilState class from the subtree root JobDescription.
@@ -330,7 +332,10 @@ class ToilState:
             # Set the job updated because we should be able to make progress on it.
             self.bus.publish(JobUpdatedMessage(str(jobDesc.jobStoreID), 0))
 
-            if isinstance(jobDesc, CheckpointJobDescription) and jobDesc.checkpoint is not None:
+            if (
+                isinstance(jobDesc, CheckpointJobDescription)
+                and jobDesc.checkpoint is not None
+            ):
                 jobDesc.restore_checkpoint()
 
         else:  # There exist successors
@@ -345,7 +350,9 @@ class ToilState:
                 jobDesc.nextSuccessors() or set()
             )
 
-            def processSuccessorWithMultiplePredecessors(successor: JobDescription) -> None:
+            def processSuccessorWithMultiplePredecessors(
+                successor: JobDescription,
+            ) -> None:
                 # If jobDesc is not reported as complete by the successor
                 if jobDesc.jobStoreID not in successor.predecessorsFinished:
 
@@ -354,11 +361,15 @@ class ToilState:
 
                 # If the successor has no predecessors to finish
                 if len(successor.predecessorsFinished) > successor.predecessorNumber:
-                    raise RuntimeError("There are more finished predecessors than possible.")
+                    raise RuntimeError(
+                        "There are more finished predecessors than possible."
+                    )
                 if len(successor.predecessorsFinished) == successor.predecessorNumber:
 
                     # It is ready to be run, so remove it from the set of waiting jobs
-                    self.jobsToBeScheduledWithMultiplePredecessors.remove(successorJobStoreID)
+                    self.jobsToBeScheduledWithMultiplePredecessors.remove(
+                        successorJobStoreID
+                    )
 
                     # Recursively consider the successor
                     self._buildToilState(successor)
@@ -383,9 +394,16 @@ class ToilState:
 
                         # We put the successor job in the set of waiting successor
                         # jobs with multiple predecessors
-                        if successorJobStoreID in self.jobsToBeScheduledWithMultiplePredecessors:
-                            raise RuntimeError("Failed to schedule the successor job. The successor job is already scheduled.")
-                        self.jobsToBeScheduledWithMultiplePredecessors.add(successorJobStoreID)
+                        if (
+                            successorJobStoreID
+                            in self.jobsToBeScheduledWithMultiplePredecessors
+                        ):
+                            raise RuntimeError(
+                                "Failed to schedule the successor job. The successor job is already scheduled."
+                            )
+                        self.jobsToBeScheduledWithMultiplePredecessors.add(
+                            successorJobStoreID
+                        )
 
                         # Process successor
                         processSuccessorWithMultiplePredecessors(successor)
@@ -399,14 +417,22 @@ class ToilState:
                     # We've already seen the successor
 
                     # Add the job as a predecessor
-                    if jobDesc.jobStoreID in self.successor_to_predecessors[successorJobStoreID]:
-                        raise RuntimeError("Failed to add the job as a predecessor. The job is already added as a predecessor.")
+                    if (
+                        jobDesc.jobStoreID
+                        in self.successor_to_predecessors[successorJobStoreID]
+                    ):
+                        raise RuntimeError(
+                            "Failed to add the job as a predecessor. The job is already added as a predecessor."
+                        )
                     self.successor_to_predecessors[successorJobStoreID].add(
                         str(jobDesc.jobStoreID)
                     )
 
                     # If the successor has multiple predecessors
-                    if successorJobStoreID in self.jobsToBeScheduledWithMultiplePredecessors:
+                    if (
+                        successorJobStoreID
+                        in self.jobsToBeScheduledWithMultiplePredecessors
+                    ):
 
                         # Get the successor from cache
                         successor = self.get_job(successorJobStoreID)

toil/utils/toilConfig.py

@@ -26,11 +26,20 @@ logger = logging.getLogger(__name__)
 def main() -> None:
     parser = ArgParser()
 
-    parser.add_argument("output", default="config.yaml", help="Filepath to write the config file too. Default=%("
-                                                              "default)s")
+    parser.add_argument(
+        "output",
+        default="config.yaml",
+        help="Filepath to write the config file too. Default=%(" "default)s",
+    )
     add_logging_options(parser)
     options = parser.parse_args()
     set_logging_from_options(options)
-    logger.debug("Attempting to write a default config file to %s.", os.path.abspath(options.output))
+    logger.debug(
+        "Attempting to write a default config file to %s.",
+        os.path.abspath(options.output),
+    )
     generate_config(os.path.abspath(options.output))
-    logger.info("Successfully wrote a default config file to %s.", os.path.abspath(options.output))
+    logger.info(
+        "Successfully wrote a default config file to %s.",
+        os.path.abspath(options.output),
+    )

toil/utils/toilDebugFile.py

@@ -20,8 +20,8 @@ from typing import Optional
 
 from toil.common import Config, Toil, parser_with_common_options
 from toil.jobStores.fileJobStore import FileJobStore
-from toil.lib.resources import glob
 from toil.lib.conversions import strtobool
+from toil.lib.resources import glob
 from toil.statsAndLogging import set_logging_from_options
 
 logger = logging.getLogger(__name__)
@@ -44,17 +44,23 @@ def fetchJobStoreFiles(jobStore: FileJobStore, options: argparse.Namespace) -> N
     # globbing around inside it. Does this even work?
 
     for jobStoreFile in options.fetch:
-        jobStoreHits = glob(directoryname=options.jobStore,
-                            glob_pattern=jobStoreFile)
+        jobStoreHits = glob(directoryname=options.jobStore, glob_pattern=jobStoreFile)
         for jobStoreFileID in jobStoreHits:
-            logger.debug(f"Copying job store file: {jobStoreFileID} to {options.localFilePath[0]}")
-            jobStore.read_file(jobStoreFileID,
-                               os.path.join(options.localFilePath[0],
-                                           os.path.basename(jobStoreFileID)),
-                               symlink=options.useSymlinks)
-
-
-def printContentsOfJobStore(job_store: FileJobStore, job_id: Optional[str] = None) -> None:
+            logger.debug(
+                f"Copying job store file: {jobStoreFileID} to {options.localFilePath[0]}"
+            )
+            jobStore.read_file(
+                jobStoreFileID,
+                os.path.join(
+                    options.localFilePath[0], os.path.basename(jobStoreFileID)
+                ),
+                symlink=options.useSymlinks,
+            )
+
+
+def printContentsOfJobStore(
+    job_store: FileJobStore, job_id: Optional[str] = None
+) -> None:
     """
     Fetch a list of all files contained in the job store if nameOfJob is not
     declared, otherwise it only prints out the names of files for that specific
@@ -90,22 +96,33 @@ def printContentsOfJobStore(job_store: FileJobStore, job_id: Optional[str] = Non
 
 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.")
-    parser.add_argument("--fetch",
-                        nargs="+",
-                        help="List of job-store files to be copied locally."
-                             "Use either explicit names (i.e. 'data.txt'), or "
-                             "specify glob patterns (i.e. '*.txt')")
-    parser.add_argument("--listFilesInJobStore", type=strtobool,
-                        help="Prints a list of the current files in the jobStore.")
-    parser.add_argument("--fetchEntireJobStore", type=strtobool,
-                        help="Copy all job store files into a local directory.")
-    parser.add_argument("--useSymlinks", type=strtobool,
-                        help="Creates symlink 'shortcuts' of files in the localFilePath"
-                             " instead of hardlinking or copying, where possible.  If this is"
-                             " not possible, it will copy the files (shutil.copyfile()).")
+    parser.add_argument(
+        "--localFilePath", nargs=1, help="Location to which to copy job store files."
+    )
+    parser.add_argument(
+        "--fetch",
+        nargs="+",
+        help="List of job-store files to be copied locally."
+        "Use either explicit names (i.e. 'data.txt'), or "
+        "specify glob patterns (i.e. '*.txt')",
+    )
+    parser.add_argument(
+        "--listFilesInJobStore",
+        type=strtobool,
+        help="Prints a list of the current files in the jobStore.",
+    )
+    parser.add_argument(
+        "--fetchEntireJobStore",
+        type=strtobool,
+        help="Copy all job store files into a local directory.",
+    )
+    parser.add_argument(
+        "--useSymlinks",
+        type=strtobool,
+        help="Creates symlink 'shortcuts' of files in the localFilePath"
+        " instead of hardlinking or copying, where possible.  If this is"
+        " not possible, it will copy the files (shutil.copyfile()).",
+    )
 
     # Load the jobStore
     options = parser.parse_args()

toil/utils/toilDebugJob.py

@@ -17,11 +17,10 @@ import logging
 import os
 import pprint
 import sys
-
 from pathlib import Path
-from typing import Optional, List, Tuple
+from typing import Optional
 
-from toil.common import Config, Toil, parser_with_common_options
+from toil.common import Toil, parser_with_common_options
 from toil.job import FilesDownloadedStoppingPointReached
 from toil.jobStores.fileJobStore import FileJobStore
 from toil.statsAndLogging import set_logging_from_options
@@ -33,23 +32,38 @@ logger = logging.getLogger(__name__)
 
 
 def main() -> None:
-    parser = parser_with_common_options(jobstore_option=True, prog="toil debug-job", default_log_level=logging.DEBUG)
-    parser.add_argument("job", type=str,
-                        help="The job store id or job name of a job within the provided jobstore")
-    parser.add_argument("--printJobInfo", action="store_true",
-                        help="Dump debugging info about the job instead of running it")
-    parser.add_argument("--retrieveTaskDirectory", dest="retrieve_task_directory", type=str, default=None,
-                        help="Download CWL or WDL task inputs to the given directory and stop.")
+    parser = parser_with_common_options(
+        jobstore_option=True, prog="toil debug-job", default_log_level=logging.DEBUG
+    )
+    parser.add_argument(
+        "job",
+        type=str,
+        help="The job store id or job name of a job within the provided jobstore",
+    )
+    parser.add_argument(
+        "--printJobInfo",
+        action="store_true",
+        help="Dump debugging info about the job instead of running it",
+    )
+    parser.add_argument(
+        "--retrieveTaskDirectory",
+        dest="retrieve_task_directory",
+        type=str,
+        default=None,
+        help="Download CWL or WDL task inputs to the given directory and stop.",
+    )
 
     options = parser.parse_args()
     set_logging_from_options(options)
 
-    if options.retrieve_task_directory is not None and os.path.exists(options.retrieve_task_directory):
+    if options.retrieve_task_directory is not None and os.path.exists(
+        options.retrieve_task_directory
+    ):
         # The logic to duplicate container mounts depends on stuff not already existing.
         logger.error(
             "The directory %s given for --retrieveTaskDirectory already exists. "
             "Stopping to avoid clobbering existing files.",
-            options.retrieve_task_directory
+            options.retrieve_task_directory,
         )
         sys.exit(1)
 
@@ -58,6 +72,7 @@ def main() -> None:
     config = jobStore.config
     # But override its options
     config.setOptions(options)
+    config.cleanWorkDir = "never"
 
     # Find the job
 
@@ -82,26 +97,45 @@ def main() -> None:
         if len(hits) == 0:
             # No hits
             if suggestion is None:
-                logger.critical("No job found with ID or name \"%s\". No jobs are completely failed.", options.job)
+                logger.critical(
+                    'No job found with ID or name "%s". No jobs are completely failed.',
+                    options.job,
+                )
             else:
-                logger.critical("No job found with ID or name \"%s\". How about the failed job %s instead?", options.job, suggestion)
+                logger.critical(
+                    'No job found with ID or name "%s". How about the failed job %s instead?',
+                    options.job,
+                    suggestion,
+                )
             sys.exit(1)
         elif len(hits) > 1:
             # Several hits, maybe only one has failed
             completely_failed_hits = [job for job in hits if job.remainingTryCount == 0]
             if len(completely_failed_hits) == 0:
-                logger.critical("Multiple jobs match \"%s\" but none are completely failed: %s", options.job, hits)
+                logger.critical(
+                    'Multiple jobs match "%s" but none are completely failed: %s',
+                    options.job,
+                    hits,
+                )
                 sys.exit(1)
             elif len(completely_failed_hits) > 0:
-                logger.critical("Multiple jobs matching \"%s\" are completely failed: %s", options.job, completely_failed_hits)
+                logger.critical(
+                    'Multiple jobs matching "%s" are completely failed: %s',
+                    options.job,
+                    completely_failed_hits,
+                )
                 sys.exit(1)
             else:
                 # We found one completely failed job, they probably mean that one.
-                logger.info("There are %s jobs matching \"%s\"; assuming you mean the failed one: %s", options.job, completely_failed_hits[0])
+                logger.info(
+                    'There are %s jobs matching "%s"; assuming you mean the failed one: %s',
+                    options.job,
+                    completely_failed_hits[0],
+                )
                 job_id = completely_failed_hits[0].jobStoreID
         else:
             # We found one job with this name, so they must mean that one
-            logger.info("Looked up job named \"%s\": %s", options.job, hits[0])
+            logger.info('Looked up job named "%s": %s', options.job, hits[0])
             job_id = hits[0].jobStoreID
 
     if options.printJobInfo:
@@ -121,19 +155,29 @@ def main() -> None:
         local_worker_temp_dir = None
         if options.retrieve_task_directory is not None:
             # Pick a directory in it (which may be removed by the worker) as the worker's temp dir.
-            local_worker_temp_dir = os.path.join(options.retrieve_task_directory, "worker")
+            local_worker_temp_dir = os.path.join(
+                options.retrieve_task_directory, "worker"
+            )
             # Make sure it exists
             os.makedirs(local_worker_temp_dir, exist_ok=True)
             # And tell the job to just download files
             debug_flags.add("download_only")
         # We might need to reconstruct a container environment.
-        host_and_job_paths: Optional[List[Tuple[str, str]]] = None
+        host_and_job_paths: Optional[list[tuple[str, str]]] = None
         # Track if the run succeeded without error
         run_succeeded = False
 
         logger.info(f"Running the following job locally: {job_id}")
         try:
-            workerScript(jobStore, config, job_id, job_id, redirect_output_to_log_file=False, local_worker_temp_dir=local_worker_temp_dir, debug_flags=debug_flags)
+            workerScript(
+                jobStore,
+                config,
+                job_id,
+                job_id,
+                redirect_output_to_log_file=False,
+                local_worker_temp_dir=local_worker_temp_dir,
+                debug_flags=debug_flags,
+            )
         except FilesDownloadedStoppingPointReached as e:
             # We asked for the files to be downloaded and now they are.
             assert options.retrieve_task_directory is not None
@@ -164,21 +208,37 @@ def main() -> None:
 
             for host_path, job_path in sorted_mounts:
                 if not os.path.exists(host_path):
-                    logger.error("Job intended to mount %s as %s but it does not exist!", host_path, job_path)
+                    logger.error(
+                        "Job intended to mount %s as %s but it does not exist!",
+                        host_path,
+                        job_path,
+                    )
                     continue
                 if not job_path.startswith("/"):
-                    logger.error("Job intended to mount %s as %s but destination is a relative path!", host_path, job_path)
+                    logger.error(
+                        "Job intended to mount %s as %s but destination is a relative path!",
+                        host_path,
+                        job_path,
+                    )
                     continue
                 # Drop the slash because we are building a chroot-ish mini filesystem.
                 job_relative_path = job_path[1:]
                 if job_relative_path.startswith("/"):
                     # We are having trouble understanding what the job
                     # intended to do. Stop working on this mount.
-                    logger.error("Job intended to mount %s as %s but destination starts with multiple slashes for some reason!", host_path, job_path)
+                    logger.error(
+                        "Job intended to mount %s as %s but destination starts with multiple slashes for some reason!",
+                        host_path,
+                        job_path,
+                    )
                     continue
                 fake_job_path = os.path.join(fake_job_root, job_relative_path)
                 if os.path.exists(fake_job_path):
-                    logger.error("Job intended to mount %s as %s but that location is already mounted!", host_path, job_path)
+                    logger.error(
+                        "Job intended to mount %s as %s but that location is already mounted!",
+                        host_path,
+                        job_path,
+                    )
                     continue
 
                 logger.info("Job mounted %s as %s", host_path, job_path)

toil/utils/toilDestroyCluster.py

@@ -20,16 +20,21 @@ from toil.statsAndLogging import set_logging_from_options
 
 logger = logging.getLogger(__name__)
 
+
 def main() -> None:
-    parser = parser_with_common_options(provisioner_options=True, jobstore_option=False, prog="toil destroy-cluster")
+    parser = parser_with_common_options(
+        provisioner_options=True, jobstore_option=False, prog="toil destroy-cluster"
+    )
     options = parser.parse_args()
     set_logging_from_options(options)
 
-    logger.info('Destroying cluster %s', options.clusterName)
+    logger.info("Destroying cluster %s", options.clusterName)
 
-    cluster = cluster_factory(provisioner=options.provisioner,
-                              clusterName=options.clusterName,
-                              zone=options.zone)
+    cluster = cluster_factory(
+        provisioner=options.provisioner,
+        clusterName=options.clusterName,
+        zone=options.zone,
+    )
     cluster.destroyCluster()
 
-    logger.info('Cluster %s is now gone.', options.clusterName)
+    logger.info("Cluster %s is now gone.", options.clusterName)

toil/utils/toilKill.py

@@ -26,8 +26,11 @@ logger = logging.getLogger(__name__)
 
 def main() -> None:
     parser = parser_with_common_options(prog="toil kill")
-    parser.add_argument('--force', action='store_true',
-                        help="Send SIGKILL to the leader process if local.")
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Send SIGKILL to the leader process if local.",
+    )
     options = parser.parse_args()
     set_logging_from_options(options)
     config = Config()
@@ -65,7 +68,9 @@ def main() -> None:
             os.kill(pid_to_kill, signal.SIGKILL if options.force else signal.SIGTERM)
             logger.info("Toil process %i successfully terminated.", pid_to_kill)
         except OSError:
-            logger.error("Could not signal process %i. Is it still running?", pid_to_kill)
+            logger.error(
+                "Could not signal process %i. Is it still running?", pid_to_kill
+            )
             sys.exit(1)
     else:
         # Flip the flag inside the job store to signal kill