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

toil/test/lib/test_conversions.py

@@ -13,9 +13,7 @@
 # limitations under the License.
 import logging
 
-from toil.lib.conversions import (convert_units,
-                                  hms_duration_to_seconds,
-                                  human2bytes)
+from toil.lib.conversions import convert_units, hms_duration_to_seconds, human2bytes
 from toil.test import ToilTest
 
 logger = logging.getLogger(__name__)
@@ -79,135 +77,135 @@ class ConversionTest(ToilTest):
             "11234234 KB": "0.0112 TB",
             "11234234 MB": "11.2342 TB",
             "11234234 GB": "11234.2340 TB",
-            "11234234 TB": "11234234.0000 TB"
+            "11234234 TB": "11234234.0000 TB",
         }
         results = {}
         for i in (0, 0.1, 0.5, 0.9, 1, 7, 7.42423, 10, 100, 1000, 11234234):
-            for src_unit in ['B', 'KB', 'MB', 'GB', 'TB']:
-                for dst_unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+            for src_unit in ["B", "KB", "MB", "GB", "TB"]:
+                for dst_unit in ["B", "KB", "MB", "GB", "TB"]:
                     converted = convert_units(i, src_unit, dst_unit)
-                    results[f'{i} {src_unit}'] = f'{converted:.4f} {dst_unit}'
+                    results[f"{i} {src_unit}"] = f"{converted:.4f} {dst_unit}"
         self.assertEqual(results, expected_conversions)
 
     def test_human2bytes(self):
         expected_results = {
-            '0 b': 0,
-            '0 Ki': 0,
-            '0 Mi': 0,
-            '0 Gi': 0,
-            '0 Ti': 0,
-            '0 K': 0,
-            '0 M': 0,
-            '0 G': 0,
-            '0 T': 0,
-            '0.1 b': 0,
-            '0.1 Ki': 102,
-            '0.1 Mi': 104857,
-            '0.1 Gi': 107374182,
-            '0.1 Ti': 109951162777,
-            '0.1 K': 100,
-            '0.1 M': 100000,
-            '0.1 G': 100000000,
-            '0.1 T': 100000000000,
-            '0.5 b': 0,
-            '0.5 Ki': 512,
-            '0.5 Mi': 524288,
-            '0.5 Gi': 536870912,
-            '0.5 Ti': 549755813888,
-            '0.5 K': 500,
-            '0.5 M': 500000,
-            '0.5 G': 500000000,
-            '0.5 T': 500000000000,
-            '0.9 b': 0,
-            '0.9 Ki': 921,
-            '0.9 Mi': 943718,
-            '0.9 Gi': 966367641,
-            '0.9 Ti': 989560464998,
-            '0.9 K': 900,
-            '0.9 M': 900000,
-            '0.9 G': 900000000,
-            '0.9 T': 900000000000,
-            '1 b': 1,
-            '1 Ki': 1024,
-            '1 Mi': 1048576,
-            '1 Gi': 1073741824,
-            '1 Ti': 1099511627776,
-            '1 K': 1000,
-            '1 M': 1000000,
-            '1 G': 1000000000,
-            '1 T': 1000000000000,
-            '7 b': 7,
-            '7 Ki': 7168,
-            '7 Mi': 7340032,
-            '7 Gi': 7516192768,
-            '7 Ti': 7696581394432,
-            '7 K': 7000,
-            '7 M': 7000000,
-            '7 G': 7000000000,
-            '7 T': 7000000000000,
-            '7.42423 b': 7,
-            '7.42423 Ki': 7602,
-            '7.42423 Mi': 7784869,
-            '7.42423 Gi': 7971706261,
-            '7.42423 Ti': 8163027212283,
-            '7.42423 K': 7424,
-            '7.42423 M': 7424230,
-            '7.42423 G': 7424230000,
-            '7.42423 T': 7424230000000,
-            '10 b': 10,
-            '10 Ki': 10240,
-            '10 Mi': 10485760,
-            '10 Gi': 10737418240,
-            '10 Ti': 10995116277760,
-            '10 K': 10000,
-            '10 M': 10000000,
-            '10 G': 10000000000,
-            '10 T': 10000000000000,
-            '100 b': 100,
-            '100 Ki': 102400,
-            '100 Mi': 104857600,
-            '100 Gi': 107374182400,
-            '100 Ti': 109951162777600,
-            '100 K': 100000,
-            '100 M': 100000000,
-            '100 G': 100000000000,
-            '100 T': 100000000000000,
-            '1000 b': 1000,
-            '1000 Ki': 1024000,
-            '1000 Mi': 1048576000,
-            '1000 Gi': 1073741824000,
-            '1000 Ti': 1099511627776000,
-            '1000 K': 1000000,
-            '1000 M': 1000000000,
-            '1000 G': 1000000000000,
-            '1000 T': 1000000000000000,
-            '11234234 b': 11234234,
-            '11234234 Ki': 11503855616,
-            '11234234 Mi': 11779948150784,
-            '11234234 Gi': 12062666906402816,
-            '11234234 Ti': 12352170912156483584,
-            '11234234 K': 11234234000,
-            '11234234 M': 11234234000000,
-            '11234234 G': 11234234000000000,
-            '11234234 T': 11234234000000000000
+            "0 b": 0,
+            "0 Ki": 0,
+            "0 Mi": 0,
+            "0 Gi": 0,
+            "0 Ti": 0,
+            "0 K": 0,
+            "0 M": 0,
+            "0 G": 0,
+            "0 T": 0,
+            "0.1 b": 0,
+            "0.1 Ki": 102,
+            "0.1 Mi": 104857,
+            "0.1 Gi": 107374182,
+            "0.1 Ti": 109951162777,
+            "0.1 K": 100,
+            "0.1 M": 100000,
+            "0.1 G": 100000000,
+            "0.1 T": 100000000000,
+            "0.5 b": 0,
+            "0.5 Ki": 512,
+            "0.5 Mi": 524288,
+            "0.5 Gi": 536870912,
+            "0.5 Ti": 549755813888,
+            "0.5 K": 500,
+            "0.5 M": 500000,
+            "0.5 G": 500000000,
+            "0.5 T": 500000000000,
+            "0.9 b": 0,
+            "0.9 Ki": 921,
+            "0.9 Mi": 943718,
+            "0.9 Gi": 966367641,
+            "0.9 Ti": 989560464998,
+            "0.9 K": 900,
+            "0.9 M": 900000,
+            "0.9 G": 900000000,
+            "0.9 T": 900000000000,
+            "1 b": 1,
+            "1 Ki": 1024,
+            "1 Mi": 1048576,
+            "1 Gi": 1073741824,
+            "1 Ti": 1099511627776,
+            "1 K": 1000,
+            "1 M": 1000000,
+            "1 G": 1000000000,
+            "1 T": 1000000000000,
+            "7 b": 7,
+            "7 Ki": 7168,
+            "7 Mi": 7340032,
+            "7 Gi": 7516192768,
+            "7 Ti": 7696581394432,
+            "7 K": 7000,
+            "7 M": 7000000,
+            "7 G": 7000000000,
+            "7 T": 7000000000000,
+            "7.42423 b": 7,
+            "7.42423 Ki": 7602,
+            "7.42423 Mi": 7784869,
+            "7.42423 Gi": 7971706261,
+            "7.42423 Ti": 8163027212283,
+            "7.42423 K": 7424,
+            "7.42423 M": 7424230,
+            "7.42423 G": 7424230000,
+            "7.42423 T": 7424230000000,
+            "10 b": 10,
+            "10 Ki": 10240,
+            "10 Mi": 10485760,
+            "10 Gi": 10737418240,
+            "10 Ti": 10995116277760,
+            "10 K": 10000,
+            "10 M": 10000000,
+            "10 G": 10000000000,
+            "10 T": 10000000000000,
+            "100 b": 100,
+            "100 Ki": 102400,
+            "100 Mi": 104857600,
+            "100 Gi": 107374182400,
+            "100 Ti": 109951162777600,
+            "100 K": 100000,
+            "100 M": 100000000,
+            "100 G": 100000000000,
+            "100 T": 100000000000000,
+            "1000 b": 1000,
+            "1000 Ki": 1024000,
+            "1000 Mi": 1048576000,
+            "1000 Gi": 1073741824000,
+            "1000 Ti": 1099511627776000,
+            "1000 K": 1000000,
+            "1000 M": 1000000000,
+            "1000 G": 1000000000000,
+            "1000 T": 1000000000000000,
+            "11234234 b": 11234234,
+            "11234234 Ki": 11503855616,
+            "11234234 Mi": 11779948150784,
+            "11234234 Gi": 12062666906402816,
+            "11234234 Ti": 12352170912156483584,
+            "11234234 K": 11234234000,
+            "11234234 M": 11234234000000,
+            "11234234 G": 11234234000000000,
+            "11234234 T": 11234234000000000000,
         }
 
         results = {}
         for i in (0, 0.1, 0.5, 0.9, 1, 7, 7.42423, 10, 100, 1000, 11234234):
-            for src_unit in ['b', 'Ki', 'Mi', 'Gi', 'Ti', 'K', 'M', 'G', 'T']:
-                results[f'{i} {src_unit}'] = human2bytes(f'{i} {src_unit}')
+            for src_unit in ["b", "Ki", "Mi", "Gi", "Ti", "K", "M", "G", "T"]:
+                results[f"{i} {src_unit}"] = human2bytes(f"{i} {src_unit}")
         self.assertEqual(results, expected_results)
 
     def test_hms_duration_to_seconds(self):
         expected_results = {
-            '0:0:0' : 0.0,
-            '00:00:00' : 0.0,
-            '1:1:1' : 3661.0,
-            '20:14:33' : 72873.0,
-            '72:80:112' : 264112.0,
+            "0:0:0": 0.0,
+            "00:00:00": 0.0,
+            "1:1:1": 3661.0,
+            "20:14:33": 72873.0,
+            "72:80:112": 264112.0,
         }
         results = {}
         for key in expected_results.keys():
-            results[key] = hms_duration_to_seconds(f'{key}')
-            
+            results[key] = hms_duration_to_seconds(f"{key}")
+
         self.assertEqual(results, expected_results)

toil/test/lib/test_ec2.py

@@ -14,18 +14,21 @@
 import logging
 import os
 
-import pytest
+from unittest import mock
 
-from toil.lib.aws.ami import (aws_marketplace_flatcar_ami_search,
-                              feed_flatcar_ami_release,
-                              flatcar_release_feed_amis,
-                              get_flatcar_ami)
-from toil.lib.aws.session import establish_boto3_session
+from toil.lib.aws.ami import (
+    aws_marketplace_flatcar_ami_search,
+    feed_flatcar_ami_release,
+    flatcar_release_feed_ami,
+    get_flatcar_ami,
+    ReleaseFeedUnavailableError
+)
 from toil.test import ToilTest, needs_aws_ec2, needs_online
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.DEBUG)
 
+
 @needs_online
 class FlatcarFeedTest(ToilTest):
     """Test accessing the Flatcar AMI release feed, independent of the AWS API"""
@@ -36,61 +39,66 @@ class FlatcarFeedTest(ToilTest):
 
     def test_parse_archive_feed(self):
         """Make sure we can get a Flatcar release from the Internet Archive."""
-        amis = list(flatcar_release_feed_amis('us-west-2', 'amd64', 'archive'))
-        for ami in amis:
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
-            
+        ami = flatcar_release_feed_ami("us-west-2", "amd64", "archive")
+        self.assertEqual(len(ami), len("ami-02b46c73fed689d1c"))
+        self.assertTrue(ami.startswith("ami-"))
+
     def test_parse_beta_feed(self):
         """Make sure we can get a Flatcar release from the beta channel."""
-        amis = list(flatcar_release_feed_amis('us-west-2', 'amd64', 'beta'))
-        for ami in amis:
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
-    
+        ami = flatcar_release_feed_ami("us-west-2", "amd64", "beta")
+        self.assertEqual(len(ami), len("ami-02b46c73fed689d1c"))
+        self.assertTrue(ami.startswith("ami-"))
+
     def test_parse_stable_feed(self):
         """Make sure we can get a Flatcar release from the stable channel."""
-        amis = list(flatcar_release_feed_amis('us-west-2', 'amd64', 'stable'))
-        for ami in amis:
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
-            
+        ami = flatcar_release_feed_ami("us-west-2", "amd64", "stable")
+        self.assertEqual(len(ami), len("ami-02b46c73fed689d1c"))
+        self.assertTrue(ami.startswith("ami-"))
+
+
 @needs_aws_ec2
 class AMITest(ToilTest):
     @classmethod
     def setUpClass(cls):
-        session = establish_boto3_session(region_name='us-west-2')
-        cls.ec2_client = session.client('ec2')
+        from toil.lib.aws.session import establish_boto3_session
+
+        session = establish_boto3_session(region_name="us-west-2")
+        cls.ec2_client = session.client("ec2")
 
     def test_fetch_flatcar(self):
-        with self.subTest('Test flatcar AMI from user is prioritized.'):
-            os.environ['TOIL_AWS_AMI'] = 'overridden'
-            ami = get_flatcar_ami(self.ec2_client)
-            self.assertEqual(ami, 'overridden')
-            del os.environ['TOIL_AWS_AMI']
-
-        with self.subTest('Test flatcar AMI returns an AMI-looking AMI.'):
-            ami = get_flatcar_ami(self.ec2_client)
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
-
-        with self.subTest('Test feed_flatcar_ami_release() returns an AMI-looking AMI.'):
-            ami = feed_flatcar_ami_release(self.ec2_client, source='archive')
-            self.assertTrue(ami is None or len(ami) == len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami is None or ami.startswith('ami-'))
-
-        with self.subTest('Test aws_marketplace_flatcar_ami_search() returns an AMI-looking AMI.'):
+        with self.subTest("Test flatcar AMI from user is prioritized."):
+            with mock.patch.dict(os.environ, {"TOIL_AWS_AMI": "overridden"}):
+                ami = get_flatcar_ami(self.ec2_client)
+                self.assertEqual(ami, "overridden")
+
+        with self.subTest("Test flatcar AMI returns an AMI-looking AMI."):
+            try:
+                ami = get_flatcar_ami(self.ec2_client)
+                self.assertEqual(len(ami), len("ami-02b46c73fed689d1c"))
+                self.assertTrue(ami.startswith("ami-"))
+            except ReleaseFeedUnavailableError:
+                # Ignore any remote systems being down.
+                pass
+
+        with self.subTest(
+            "Test feed_flatcar_ami_release() returns an AMI-looking AMI."
+        ):
+            ami = feed_flatcar_ami_release(self.ec2_client, source="archive")
+            self.assertTrue(ami is None or len(ami) == len("ami-02b46c73fed689d1c"))
+            self.assertTrue(ami is None or ami.startswith("ami-"))
+
+        with self.subTest(
+            "Test aws_marketplace_flatcar_ami_search() returns an AMI-looking AMI."
+        ):
             ami = aws_marketplace_flatcar_ami_search(self.ec2_client)
-            self.assertEqual(len(ami), len('ami-02b46c73fed689d1c'))
-            self.assertTrue(ami.startswith('ami-'))
+            self.assertTrue(ami is None or len(ami), len("ami-02b46c73fed689d1c"))
+            self.assertTrue(ami is None or ami.startswith("ami-"))
 
-    # TODO: This will fail until https://github.com/flatcar/Flatcar/issues/962 is fixed
-    @pytest.mark.xfail
     def test_fetch_arm_flatcar(self):
         """Test flatcar AMI finder architecture parameter."""
-        amis = set()
-        for arch in ['amd64', 'arm64']:
-            ami = get_flatcar_ami(self.ec2_client, architecture=arch)
-            self.assertTrue(ami.startswith('ami-'))
-            amis.add(ami)
-        self.assertTrue(len(amis) == 2)
+        try:
+            ami = get_flatcar_ami(self.ec2_client, architecture="arm64")
+            self.assertTrue(ami.startswith("ami-"))
+        except ReleaseFeedUnavailableError:
+            # Ignore any remote systems being down.
+            pass

toil/test/lib/test_integration.py

@@ -0,0 +1,104 @@
+# Copyright (C) 2015-2024 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 io
+import logging
+import pytest
+from typing import IO
+import urllib.request
+from urllib.error import URLError
+
+from toil.lib.retry import retry
+from toil.lib.integration import get_workflow_root_from_dockstore
+from toil.test import ToilTest, needs_online
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+@pytest.mark.integrative
+@needs_online
+class DockstoreLookupTest(ToilTest):
+    """
+    Make sure we can look up workflows on Dockstore.
+    """
+
+    @retry(errors=[URLError, RuntimeError])
+    def read_result(self, url_or_path: str) -> IO[bytes]:
+        """
+        Read a file or URL.
+
+        Binary mode to allow testing for binary file support.
+
+        This lets us test that we have the right workflow contents and not care
+        how we are being shown them.
+        """
+        if url_or_path.startswith("http://") or url_or_path.startswith("https://"):
+            response = urllib.request.urlopen(url_or_path)
+            if response.status != 200:
+                raise RuntimeError(f"HTTP error response: {response}")
+            return response
+        else:
+            return open(url_or_path, "rb")
+
+    # TODO: Tests that definitely test a clear cache
+
+    def test_lookup_from_page_url(self) -> None:
+        PAGE_URL = "https://dockstore.org/workflows/github.com/dockstore/bcc2020-training/HelloWorld:master?tab=info"
+        # If we go in through the website we get an extra refs/heads/ on the branch name.
+        WORKFLOW_URL = "https://raw.githubusercontent.com/dockstore/bcc2020-training/master/wdl-training/exercise1/HelloWorld.wdl"
+        looked_up = get_workflow_root_from_dockstore(PAGE_URL)
+
+        data_from_lookup = self.read_result(looked_up).read()
+        data_from_source = self.read_result(WORKFLOW_URL).read()
+        self.assertEqual(data_from_lookup, data_from_source)
+
+    def test_lookup_from_trs(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker"
+        # Despite "-checker" in the ID, this actually refers to the base md5sum
+        # workflow that just happens to have a checker *available*, not to the
+        # checker workflow itself.
+        WORKFLOW_URL = "https://raw.githubusercontent.com/dockstore-testing/md5sum-checker/master/md5sum/md5sum-workflow.cwl"
+        looked_up = get_workflow_root_from_dockstore(TRS_ID)
+        
+        data_from_lookup = self.read_result(looked_up).read()
+        data_from_source = self.read_result(WORKFLOW_URL).read()
+        self.assertEqual(data_from_lookup, data_from_source)
+
+    def test_lookup_from_trs_cached(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker"
+        WORKFLOW_URL = "https://raw.githubusercontent.com/dockstore-testing/md5sum-checker/master/md5sum/md5sum-workflow.cwl"
+        # This lookup may or may not be cached
+        get_workflow_root_from_dockstore(TRS_ID)
+        # This lookup is definitely cached
+        looked_up = get_workflow_root_from_dockstore(TRS_ID)
+        
+        data_from_lookup = self.read_result(looked_up).read()
+        data_from_source = self.read_result(WORKFLOW_URL).read()
+        self.assertEqual(data_from_lookup, data_from_source)
+
+    def test_lookup_from_trs_with_version(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker:workflowWithHTTPImport"
+        WORKFLOW_URL = "https://raw.githubusercontent.com/dockstore-testing/md5sum-checker/workflowWithHTTPImport/md5sum/md5sum-workflow.cwl"
+        looked_up = get_workflow_root_from_dockstore(TRS_ID)
+        
+        data_from_lookup = self.read_result(looked_up).read()
+        data_from_source = self.read_result(WORKFLOW_URL).read()
+        self.assertEqual(data_from_lookup, data_from_source)
+
+    def test_lookup_from_trs_nonexistent_version(self) -> None:
+        TRS_ID = "#workflow/github.com/dockstore-testing/md5sum-checker:notARealVersion"
+        with self.assertRaises(RuntimeError):
+            looked_up = get_workflow_root_from_dockstore(TRS_ID)
+
+

toil/test/lib/test_misc.py

@@ -32,6 +32,7 @@ class UserNameAvailableTest(ToilTest):
         apparent_user_name = get_user_name()
         self.assertEqual(apparent_user_name, real_user_name)
 
+
 class UserNameUnvailableTest(ToilTest):
     """
     Make sure we can get something for a user name when user names are not
@@ -42,9 +43,12 @@ class UserNameUnvailableTest(ToilTest):
         super().setUp()
         # Monkey patch getpass.getuser to fail
         self.original_getuser = getpass.getuser
+
         def fake_getuser():
-            raise KeyError('Fake key error')
+            raise KeyError("Fake key error")
+
         getpass.getuser = fake_getuser
+
     def tearDown(self):
         # Fix the module we hacked up
         getpass.getuser = self.original_getuser
@@ -54,7 +58,8 @@ class UserNameUnvailableTest(ToilTest):
         apparent_user_name = get_user_name()
         # Make sure we got something
         self.assertTrue(isinstance(apparent_user_name, str))
-        self.assertNotEqual(apparent_user_name, '')
+        self.assertNotEqual(apparent_user_name, "")
+
 
 class UserNameVeryBrokenTest(ToilTest):
     """
@@ -66,9 +71,12 @@ class UserNameVeryBrokenTest(ToilTest):
         super().setUp()
         # Monkey patch getpass.getuser to fail
         self.original_getuser = getpass.getuser
+
         def fake_getuser():
-            raise RuntimeError('Fake error that we did not anticipate')
+            raise RuntimeError("Fake error that we did not anticipate")
+
         getpass.getuser = fake_getuser
+
     def tearDown(self):
         # Fix the module we hacked up
         getpass.getuser = self.original_getuser
@@ -78,5 +86,4 @@ class UserNameVeryBrokenTest(ToilTest):
         apparent_user_name = get_user_name()
         # Make sure we got something
         self.assertTrue(isinstance(apparent_user_name, str))
-        self.assertNotEqual(apparent_user_name, '')
-
+        self.assertNotEqual(apparent_user_name, "")

toil/test/mesos/MesosDataStructuresTest.py

@@ -21,15 +21,19 @@ class DataStructuresTest(ToilTest):
     def _getJob(self, cores=1, memory=1000, disk=5000, preemptible=True):
         from toil.batchSystems.mesos import MesosShape, ToilJob
 
-        resources = MesosShape(wallTime=0, cores=cores, memory=memory, disk=disk, preemptible=preemptible)
+        resources = MesosShape(
+            wallTime=0, cores=cores, memory=memory, disk=disk, preemptible=preemptible
+        )
 
-        job = ToilJob(jobID=str(uuid.uuid4()),
-                      name=str(uuid.uuid4()),
-                      resources=resources,
-                      command="do nothing",
-                      userScript=None,
-                      environment=None,
-                      workerCleanupInfo=None)
+        job = ToilJob(
+            jobID=str(uuid.uuid4()),
+            name=str(uuid.uuid4()),
+            resources=resources,
+            command="do nothing",
+            userScript=None,
+            environment=None,
+            workerCleanupInfo=None,
+        )
         return job
 
     def testJobQueue(self, testJobs=1000):
@@ -39,15 +43,24 @@ class DataStructuresTest(ToilTest):
         non-preemptible jobs groups first, with priority given to large jobs.
         """
         from toil.batchSystems.mesos import JobQueue
+
         jobQueue = JobQueue()
 
         for jobNum in range(0, testJobs):
-            testJob = self._getJob(cores=random.choice(list(range(10))), preemptible=random.choice([True, False]))
+            testJob = self._getJob(
+                cores=random.choice(list(range(10))),
+                preemptible=random.choice([True, False]),
+            )
             jobQueue.insertJob(testJob, testJob.resources)
 
         sortedTypes = jobQueue.sortedTypes
         self.assertGreaterEqual(20, len(sortedTypes))
-        self.assertTrue(all(sortedTypes[i] <= sortedTypes[i + 1] for i in range(len(sortedTypes) - 1)))
+        self.assertTrue(
+            all(
+                sortedTypes[i] <= sortedTypes[i + 1]
+                for i in range(len(sortedTypes) - 1)
+            )
+        )
 
         preemptible = sortedTypes.pop(0).preemptible
         for jtype in sortedTypes: