toil 6.1.0a1__py3-none-any.whl → 8.0.0__py3-none-any.whl

toil/test/sort/sortTest.py

@@ -25,29 +25,35 @@ from toil.batchSystems.mesos.test import MesosTestSupport
 from toil.common import Toil
 from toil.exceptions import FailedJobsException
 from toil.job import Job
-from toil.jobStores.abstractJobStore import (JobStoreExistsException,
-                                             NoSuchJobStoreException)
+from toil.jobStores.abstractJobStore import (
+    JobStoreExistsException,
+    NoSuchJobStoreException,
+)
 from toil.lib.bioio import root_logger
-from toil.test import (ToilTest,
-                       needs_aws_ec2,
-                       needs_google_project,
-                       needs_google_storage,
-                       needs_gridengine,
-                       needs_mesos,
-                       needs_torque,
-                       slow)
-from toil.test.sort.sort import (copySubRangeOfFile,
-                                 getMidPoint,
-                                 main,
-                                 makeFileToSort,
-                                 merge,
-                                 sort)
+from toil.test import (
+    ToilTest,
+    needs_aws_ec2,
+    needs_google_project,
+    needs_google_storage,
+    needs_gridengine,
+    needs_mesos,
+    needs_torque,
+    slow,
+)
+from toil.test.sort.sort import (
+    copySubRangeOfFile,
+    getMidPoint,
+    main,
+    makeFileToSort,
+    merge,
+    sort,
+)
 
 logger = logging.getLogger(__name__)
 
-defaultLineLen = int(os.environ.get('TOIL_TEST_SORT_LINE_LEN', 10))
-defaultLines = int(os.environ.get('TOIL_TEST_SORT_LINES', 10))
-defaultN = int(os.environ.get('TOIL_TEST_SORT_N', defaultLineLen * defaultLines / 5))
+defaultLineLen = int(os.environ.get("TOIL_TEST_SORT_LINE_LEN", 10))
+defaultLines = int(os.environ.get("TOIL_TEST_SORT_LINES", 10))
+defaultN = int(os.environ.get("TOIL_TEST_SORT_N", defaultLineLen * defaultLines / 5))
 
 
 @contextmanager
@@ -67,10 +73,11 @@ class SortTest(ToilTest, MesosTestSupport):
     Tests Toil by sorting a file in parallel on various combinations of job stores and batch
     systems.
     """
+
     def setUp(self):
         super().setUp()
-        self.tempDir = self._createTempDir(purpose='tempDir')
-        self.outputFile = os.path.join(self.tempDir, 'sortedFile.txt')
+        self.tempDir = self._createTempDir(purpose="tempDir")
+        self.outputFile = os.path.join(self.tempDir, "sortedFile.txt")
         self.inputFile = os.path.join(self.tempDir, "fileToSort.txt")
 
     def tearDown(self):
@@ -78,9 +85,19 @@ class SortTest(ToilTest, MesosTestSupport):
             shutil.rmtree(self.tempDir)
         ToilTest.tearDown(self)
 
-    def _toilSort(self, jobStoreLocator, batchSystem,
-                  lines=defaultLines, N=defaultN, testNo=1, lineLen=defaultLineLen,
-                  retryCount=2, badWorker=0.5, downCheckpoints=False, caching=True):
+    def _toilSort(
+        self,
+        jobStoreLocator,
+        batchSystem,
+        lines=defaultLines,
+        N=defaultN,
+        testNo=1,
+        lineLen=defaultLineLen,
+        retryCount=2,
+        badWorker=0.5,
+        downCheckpoints=False,
+        caching=True,
+    ):
         """
         Generate a file consisting of the given number of random lines, each line of the given
         length. Sort the file with Toil by splitting the file recursively until each part is less
@@ -112,8 +129,8 @@ class SortTest(ToilTest, MesosTestSupport):
                 options.caching = caching
                 # This is required because mesos_endpoint now defaults to the IP of the machine
                 # that is starting the workflow while the mesos *tests* run locally.
-                if batchSystem == 'mesos':
-                    options.mesos_endpoint = 'localhost:5050'
+                if batchSystem == "mesos":
+                    options.mesos_endpoint = "localhost:5050"
                 options.downCheckpoints = downCheckpoints
                 options.N = N
                 options.outputFile = self.outputFile
@@ -166,18 +183,22 @@ class SortTest(ToilTest, MesosTestSupport):
                     except FailedJobsException as e:
                         i = e.numberOfFailedJobs
                         if totalTrys > 32:  # p(fail after this many restarts) = 0.5**32
-                            self.fail('Exceeded a reasonable number of restarts')
+                            self.fail("Exceeded a reasonable number of restarts")
                         totalTrys += 1
             finally:
-                subprocess.check_call([resolveEntryPoint('toil'), 'clean', jobStoreLocator])
+                subprocess.check_call(
+                    [resolveEntryPoint("toil"), "clean", jobStoreLocator]
+                )
                 # final test to make sure the jobStore was actually deleted
-                self.assertRaises(NoSuchJobStoreException, Toil.resumeJobStore, jobStoreLocator)
-
-
+                self.assertRaises(
+                    NoSuchJobStoreException, Toil.resumeJobStore, jobStoreLocator
+                )
 
     @needs_aws_ec2
     def testAwsSingle(self):
-        self._toilSort(jobStoreLocator=self._awsJobStore(), batchSystem='single_machine')
+        self._toilSort(
+            jobStoreLocator=self._awsJobStore(), batchSystem="single_machine"
+        )
 
     @needs_aws_ec2
     @needs_mesos
@@ -192,14 +213,18 @@ class SortTest(ToilTest, MesosTestSupport):
     def testFileMesos(self):
         self._startMesos()
         try:
-            self._toilSort(jobStoreLocator=self._getTestJobStorePath(), batchSystem="mesos")
+            self._toilSort(
+                jobStoreLocator=self._getTestJobStorePath(), batchSystem="mesos"
+            )
         finally:
             self._stopMesos()
 
     @needs_google_project
     @needs_google_storage
     def testGoogleSingle(self):
-        self._toilSort(jobStoreLocator=self._googleJobStore(), batchSystem="single_machine")
+        self._toilSort(
+            jobStoreLocator=self._googleJobStore(), batchSystem="single_machine"
+        )
 
     @needs_google_project
     @needs_google_storage
@@ -212,29 +237,46 @@ class SortTest(ToilTest, MesosTestSupport):
             self._stopMesos()
 
     def testFileSingle(self):
-        self._toilSort(jobStoreLocator=self._getTestJobStorePath(), batchSystem='single_machine')
+        self._toilSort(
+            jobStoreLocator=self._getTestJobStorePath(), batchSystem="single_machine"
+        )
 
     def testFileSingleNonCaching(self):
-        self._toilSort(jobStoreLocator=self._getTestJobStorePath(), batchSystem='single_machine',
-                       caching=False)
+        self._toilSort(
+            jobStoreLocator=self._getTestJobStorePath(),
+            batchSystem="single_machine",
+            caching=False,
+        )
 
     def testFileSingleCheckpoints(self):
-        self._toilSort(jobStoreLocator=self._getTestJobStorePath(), batchSystem='single_machine',
-                       retryCount=2, downCheckpoints=True)
+        self._toilSort(
+            jobStoreLocator=self._getTestJobStorePath(),
+            batchSystem="single_machine",
+            retryCount=2,
+            downCheckpoints=True,
+        )
 
     def testFileSingle10000(self):
-        self._toilSort(jobStoreLocator=self._getTestJobStorePath(), batchSystem='single_machine',
-                       lines=10000, N=10000)
+        self._toilSort(
+            jobStoreLocator=self._getTestJobStorePath(),
+            batchSystem="single_machine",
+            lines=10000,
+            N=10000,
+        )
 
     @needs_gridengine
-    @unittest.skip('GridEngine does not support shared caching')
+    @unittest.skip("GridEngine does not support shared caching")
     def testFileGridEngine(self):
-        self._toilSort(jobStoreLocator=self._getTestJobStorePath(), batchSystem='gridengine')
+        self._toilSort(
+            jobStoreLocator=self._getTestJobStorePath(), batchSystem="gridengine"
+        )
 
     @needs_torque
-    @unittest.skip('PBS/Torque does not support shared caching')
+    @unittest.skip("PBS/Torque does not support shared caching")
     def testFileTorqueEngine(self):
-        self._toilSort(jobStoreLocator=self._getTestJobStorePath(), batchSystem='torque')
+        self._toilSort(
+            jobStoreLocator=self._getTestJobStorePath(), batchSystem="torque"
+        )
 
     testNo = 5
 
@@ -258,7 +300,7 @@ class SortTest(ToilTest, MesosTestSupport):
             makeFileToSort(tempFile2)
             sort(tempFile1)
             sort(tempFile2)
-            with open(tempFile3, 'w') as fileHandle:
+            with open(tempFile3, "w") as fileHandle:
                 with open(tempFile1) as tempFileHandle1:
                     with open(tempFile2) as tempFileHandle2:
                         merge(tempFileHandle1, tempFileHandle2, fileHandle)
@@ -277,7 +319,7 @@ class SortTest(ToilTest, MesosTestSupport):
             assert fileSize > 0
             fileStart = random.choice(range(0, fileSize))
             fileEnd = random.choice(range(fileStart, fileSize))
-            with open(outputFile, 'w') as f:
+            with open(outputFile, "w") as f:
                 f.write(copySubRangeOfFile(tempFile, fileStart, fileEnd))
             with open(outputFile) as f:
                 l = f.read()
@@ -294,11 +336,11 @@ class SortTest(ToilTest, MesosTestSupport):
             midPoint = getMidPoint(self.inputFile, 0, fileSize)
             print(f"The mid point is {midPoint} of a file of {fileSize} bytes.")
             assert midPoint < fileSize
-            assert sorted_contents[midPoint] == '\n'
+            assert sorted_contents[midPoint] == "\n"
             assert midPoint >= 0
 
     def _awsJobStore(self):
-        return f'aws:{self.awsRegion()}:sort-test-{uuid4()}'
+        return f"aws:{self.awsRegion()}:sort-test-{uuid4()}"
 
     def _googleJobStore(self):
         return f'google:{os.getenv("TOIL_GOOGLE_PROJECTID")}:sort-test-{uuid4()}'

toil/test/src/autoDeploymentTest.py

@@ -5,10 +5,7 @@ from contextlib import contextmanager
 
 from toil.exceptions import FailedJobsException
 from toil.lib.iterables import concat
-from toil.test import (ApplianceTestSupport,
-                       needs_local_appliance,
-                       needs_mesos,
-                       slow)
+from toil.test import ApplianceTestSupport, needs_local_appliance, needs_mesos, slow
 from toil.version import exactPython
 
 logger = logging.getLogger(__name__)
@@ -35,34 +32,38 @@ class AutoDeploymentTest(ApplianceTestSupport):
         Creates an appliance cluster with a virtualenv at './venv' on the leader and a temporary
         directory on the host mounted at /data in the leader and worker containers.
         """
-        dataDirPath = self._createTempDir(purpose='data')
-        with self._applianceCluster(mounts={dataDirPath: '/data'}) as (leader, worker):
-            leader.runOnAppliance('virtualenv',
-                                  '--system-site-packages',
-                                  '--never-download',  # prevent silent upgrades to pip etc
-                                  '--python', exactPython,
-                                  'venv')
-            leader.runOnAppliance('venv/bin/pip', 'list')  # For diagnostic purposes
+        dataDirPath = self._createTempDir(purpose="data")
+        with self._applianceCluster(mounts={dataDirPath: "/data"}) as (leader, worker):
+            leader.runOnAppliance(
+                "virtualenv",
+                "--system-site-packages",
+                "--never-download",  # prevent silent upgrades to pip etc
+                "--python",
+                exactPython,
+                "venv",
+            )
+            leader.runOnAppliance("venv/bin/pip", "list")  # For diagnostic purposes
             yield leader, worker
 
     # TODO: Are we sure the python in the appliance we are testing is the same
     # as the one we are testing from? If not, how can we get the version it is?
-    sitePackages = f'venv/lib/{exactPython}/site-packages'
+    sitePackages = f"venv/lib/{exactPython}/site-packages"
 
     def testRestart(self):
         """
         Test whether auto-deployment works on restart.
         """
         with self._venvApplianceCluster() as (leader, worker):
+
             def userScript():
                 from toil.common import Toil
                 from toil.job import Job
 
                 # noinspection PyUnusedLocal
-                def job(job, disk='10M', cores=1, memory='10M'):
+                def job(job, disk="10M", cores=1, memory="10M"):
                     assert False
 
-                if __name__ == '__main__':
+                if __name__ == "__main__":
                     options = Job.Runner.getDefaultArgumentParser().parse_args()
                     with Toil(options) as toil:
                         if toil.config.restart:
@@ -72,26 +73,30 @@ class AutoDeploymentTest(ApplianceTestSupport):
 
             userScript = self._getScriptSource(userScript)
 
-            leader.deployScript(path=self.sitePackages,
-                                packagePath='foo.bar',
-                                script=userScript)
-
-            pythonArgs = ['venv/bin/python', '-m', 'foo.bar']
-            toilArgs = ['--logDebug',
-                        '--batchSystem=mesos',
-                        '--mesosEndpoint=localhost:5050',
-                        '--defaultMemory=10M',
-                        '/data/jobstore']
+            leader.deployScript(
+                path=self.sitePackages, packagePath="foo.bar", script=userScript
+            )
+
+            pythonArgs = ["venv/bin/python", "-m", "foo.bar"]
+            toilArgs = [
+                "--logDebug",
+                "--batchSystem=mesos",
+                "--mesosEndpoint=localhost:5050",
+                "--defaultMemory=10M",
+                "/data/jobstore",
+            ]
             command = concat(pythonArgs, toilArgs)
-            self.assertRaises(subprocess.CalledProcessError, leader.runOnAppliance, *command)
+            self.assertRaises(
+                subprocess.CalledProcessError, leader.runOnAppliance, *command
+            )
 
             # Deploy an updated version of the script ...
-            userScript = userScript.replace('assert False', 'assert True')
-            leader.deployScript(path=self.sitePackages,
-                                packagePath='foo.bar',
-                                script=userScript)
+            userScript = userScript.replace("assert False", "assert True")
+            leader.deployScript(
+                path=self.sitePackages, packagePath="foo.bar", script=userScript
+            )
             # ... and restart Toil.
-            command = concat(pythonArgs, '--restart', toilArgs)
+            command = concat(pythonArgs, "--restart", toilArgs)
             leader.runOnAppliance(*command)
 
     def testSplitRootPackages(self):
@@ -109,11 +114,11 @@ class AutoDeploymentTest(ApplianceTestSupport):
             def libraryModule():
                 # noinspection PyUnusedLocal
                 def libraryJob(job):
-                    open('/data/foo.txt', 'w').close()
+                    open("/data/foo.txt", "w").close()
 
-            leader.deployScript(path=self.sitePackages,
-                                packagePath='toil_lib.foo',
-                                script=libraryModule)
+            leader.deployScript(
+                path=self.sitePackages, packagePath="toil_lib.foo", script=libraryModule
+            )
 
             # Deploy the user script
             def userScript():
@@ -124,12 +129,14 @@ class AutoDeploymentTest(ApplianceTestSupport):
                 from toil.job import Job
 
                 # noinspection PyUnusedLocal
-                def job(job, disk='10M', cores=1, memory='10M'):
+                def job(job, disk="10M", cores=1, memory="10M"):
                     # Double the requirements to prevent chaining as chaining might hide problems
                     # in auto-deployment code.
-                    job.addChildJobFn(libraryJob, disk='20M', cores=cores, memory=memory)
+                    job.addChildJobFn(
+                        libraryJob, disk="20M", cores=cores, memory=memory
+                    )
 
-                if __name__ == '__main__':
+                if __name__ == "__main__":
                     options = Job.Runner.getDefaultArgumentParser().parse_args()
                     with Toil(options) as toil:
                         if toil.config.restart:
@@ -137,24 +144,32 @@ class AutoDeploymentTest(ApplianceTestSupport):
                         else:
                             toil.start(Job.wrapJobFn(job))
 
-            leader.deployScript(path=self.sitePackages,
-                                packagePath='toil_script.bar',
-                                script=userScript)
+            leader.deployScript(
+                path=self.sitePackages, packagePath="toil_script.bar", script=userScript
+            )
 
             # Assert that output file isn't there
-            worker.runOnAppliance('test', '!', '-f', '/data/foo.txt')
+            worker.runOnAppliance("test", "!", "-f", "/data/foo.txt")
             # Just being paranoid
-            self.assertRaises(subprocess.CalledProcessError,
-                              worker.runOnAppliance, 'test', '-f', '/data/foo.txt')
-            leader.runOnAppliance('venv/bin/python',
-                                  '-m', 'toil_script.bar',
-                                  '--logDebug',
-                                  '--batchSystem=mesos',
-                                  '--mesosEndpoint=localhost:5050',
-                                  '--defaultMemory=10M',
-                                  '/data/jobstore')
+            self.assertRaises(
+                subprocess.CalledProcessError,
+                worker.runOnAppliance,
+                "test",
+                "-f",
+                "/data/foo.txt",
+            )
+            leader.runOnAppliance(
+                "venv/bin/python",
+                "-m",
+                "toil_script.bar",
+                "--logDebug",
+                "--batchSystem=mesos",
+                "--mesosEndpoint=localhost:5050",
+                "--defaultMemory=10M",
+                "/data/jobstore",
+            )
             # Assert that out output file is there
-            worker.runOnAppliance('test', '-f', '/data/foo.txt')
+            worker.runOnAppliance("test", "-f", "/data/foo.txt")
 
     def testUserTypesInJobFunctionArgs(self):
         """
@@ -165,6 +180,7 @@ class AutoDeploymentTest(ApplianceTestSupport):
         revealed https://github.com/BD2KGenomics/toil/issues/1278.
         """
         with self._venvApplianceCluster() as (leader, worker):
+
             def userScript():
                 from toil.common import Toil
                 from toil.job import Job
@@ -174,10 +190,10 @@ class AutoDeploymentTest(ApplianceTestSupport):
                     pass
 
                 # noinspection PyUnusedLocal
-                def job(job, x, disk='10M', cores=1, memory='10M'):
+                def job(job, x, disk="10M", cores=1, memory="10M"):
                     return x
 
-                if __name__ == '__main__':
+                if __name__ == "__main__":
                     options = Job.Runner.getDefaultArgumentParser().parse_args()
                     x = X()
                     with Toil(options) as toil:
@@ -187,23 +203,28 @@ class AutoDeploymentTest(ApplianceTestSupport):
                     # translation from __main__ to foo.bar is a side effect of auto-deployment.
                     assert r.__class__ is not X
                     import foo.bar
+
                     assert r.__class__ is foo.bar.X
                     # Assert that a copy was made. This is a side effect of pickling/unpickling.
                     assert x is not r
 
             userScript = self._getScriptSource(userScript)
 
-            leader.deployScript(path=self.sitePackages,
-                                packagePath='foo.bar',
-                                script=userScript)
-
-            leader.runOnAppliance('venv/bin/python', '-m', 'foo.bar',
-                                  '--logDebug',
-                                  '--batchSystem=mesos',
-                                  '--mesosEndpoint=localhost:5050',
-                                  '--defaultMemory=10M',
-                                  '--defaultDisk=10M',
-                                  '/data/jobstore')
+            leader.deployScript(
+                path=self.sitePackages, packagePath="foo.bar", script=userScript
+            )
+
+            leader.runOnAppliance(
+                "venv/bin/python",
+                "-m",
+                "foo.bar",
+                "--logDebug",
+                "--batchSystem=mesos",
+                "--mesosEndpoint=localhost:5050",
+                "--defaultMemory=10M",
+                "--defaultDisk=10M",
+                "/data/jobstore",
+            )
 
     def testDeferralWithConcurrentEncapsulation(self):
         """
@@ -243,18 +264,21 @@ class AutoDeploymentTest(ApplianceTestSupport):
 
         3) it is an instance of Job (and so does not introduce the user script to sys.path itself),
 
-        … it might cause problems with deserializing a defered function defined in the user script.
+        … it might cause problems with deserializing a deferred function defined in the user script.
 
         `Encapsulated` has two children to ensure that `Follow-on` is run in a separate worker.
         """
         with self._venvApplianceCluster() as (leader, worker):
+
             def userScript():
                 from toil.common import Toil
                 from toil.job import Job
 
                 def root(rootJob):
                     def nullFile():
-                        return rootJob.fileStore.jobStore.import_file('file:///dev/null')
+                        return rootJob.fileStore.jobStore.import_file(
+                            "file:///dev/null"
+                        )
 
                     startFile = nullFile()
                     endFile = nullFile()
@@ -290,7 +314,7 @@ class AutoDeploymentTest(ApplianceTestSupport):
                 def last(job, endFile):
                     job.fileStore.jobStore.delete_file(endFile)
 
-                if __name__ == '__main__':
+                if __name__ == "__main__":
                     options = Job.Runner.getDefaultArgumentParser().parse_args()
                     with Toil(options) as toil:
                         rootJob = Job.wrapJobFn(root)
@@ -298,18 +322,22 @@ class AutoDeploymentTest(ApplianceTestSupport):
 
             userScript = self._getScriptSource(userScript)
 
-            leader.deployScript(path=self.sitePackages,
-                                packagePath='foo.bar',
-                                script=userScript)
-
-            leader.runOnAppliance('venv/bin/python', '-m', 'foo.bar',
-                                  '--logDebug',
-                                  '--batchSystem=mesos',
-                                  '--mesosEndpoint=localhost:5050',
-                                  '--retryCount=0',
-                                  '--defaultMemory=10M',
-                                  '--defaultDisk=10M',
-                                  '/data/jobstore')
+            leader.deployScript(
+                path=self.sitePackages, packagePath="foo.bar", script=userScript
+            )
+
+            leader.runOnAppliance(
+                "venv/bin/python",
+                "-m",
+                "foo.bar",
+                "--logDebug",
+                "--batchSystem=mesos",
+                "--mesosEndpoint=localhost:5050",
+                "--retryCount=0",
+                "--defaultMemory=10M",
+                "--defaultDisk=10M",
+                "/data/jobstore",
+            )
 
     def testDeferralWithFailureAndEncapsulation(self):
         """
@@ -348,6 +376,7 @@ class AutoDeploymentTest(ApplianceTestSupport):
         jobs have been executed by that worker.
         """
         with self._venvApplianceCluster() as (leader, worker):
+
             def userScript():
                 import os
                 import time
@@ -359,7 +388,9 @@ class AutoDeploymentTest(ApplianceTestSupport):
 
                 def root(rootJob):
                     def nullFile():
-                        return rootJob.fileStore.jobStore.import_file('file:///dev/null')
+                        return rootJob.fileStore.jobStore.import_file(
+                            "file:///dev/null"
+                        )
 
                     startFile = nullFile()
                     endFile = nullFile()
@@ -380,10 +411,10 @@ class AutoDeploymentTest(ApplianceTestSupport):
                     Return path to a file at the root of the job store, exploiting the fact that
                     the job store is shared between leader and worker container.
                     """
-                    prefix = 'file:'
+                    prefix = "file:"
                     locator = config.jobStore
                     assert locator.startswith(prefix)
-                    return os.path.join(locator[len(prefix):], 'testDeferredFile')
+                    return os.path.join(locator[len(prefix) :], "testDeferredFile")
 
                 def deferred(deferredFilePath):
                     """
@@ -425,6 +456,7 @@ class AutoDeploymentTest(ApplianceTestSupport):
                     finds the left-overs of the `deferring` job.
                     """
                     import errno
+
                     jobStore = job.fileStore.jobStore
                     with jobStore.read_file_stream(endFile) as fH:
                         pid = int(fH.read())
@@ -452,36 +484,44 @@ class AutoDeploymentTest(ApplianceTestSupport):
                         else:
                             raise
 
-                if __name__ == '__main__':
+                if __name__ == "__main__":
                     import errno
+
                     options = Job.Runner.getDefaultArgumentParser().parse_args()
                     with Toil(options) as toil:
                         deferredFilePath = deferredFile(toil.config)
-                        open(deferredFilePath, 'w').close()
+                        open(deferredFilePath, "w").close()
                         try:
                             assert os.path.exists(deferredFilePath)
                             try:
                                 toil.start(Job.wrapJobFn(root))
                             except FailedJobsException as e:
-                                assert e.numberOfFailedJobs == 2 # `root` and `deferring`
-                                assert not os.path.exists(deferredFilePath), \
-                                    'Apparently, the deferred function did not run.'
+                                assert (
+                                    e.numberOfFailedJobs == 2
+                                )  # `root` and `deferring`
+                                assert not os.path.exists(
+                                    deferredFilePath
+                                ), "Apparently, the deferred function did not run."
                             else:
-                                assert False, 'Workflow should not have succeeded.'
+                                assert False, "Workflow should not have succeeded."
                         finally:
                             tryUnlink(deferredFilePath)
 
             userScript = self._getScriptSource(userScript)
 
-            leader.deployScript(path=self.sitePackages,
-                                packagePath='foo.bar',
-                                script=userScript)
-
-            leader.runOnAppliance('venv/bin/python', '-m', 'foo.bar',
-                                  '--logDebug',
-                                  '--batchSystem=mesos',
-                                  '--mesosEndpoint=localhost:5050',
-                                  '--retryCount=0',
-                                  '--defaultMemory=10M',
-                                  '--defaultDisk=10M',
-                                  '/data/jobstore')
+            leader.deployScript(
+                path=self.sitePackages, packagePath="foo.bar", script=userScript
+            )
+
+            leader.runOnAppliance(
+                "venv/bin/python",
+                "-m",
+                "foo.bar",
+                "--logDebug",
+                "--batchSystem=mesos",
+                "--mesosEndpoint=localhost:5050",
+                "--retryCount=0",
+                "--defaultMemory=10M",
+                "--defaultDisk=10M",
+                "/data/jobstore",
+            )