toil 9.1.1__py3-none-any.whl → 9.2.0__py3-none-any.whl

toil/test/src/jobServiceTest.py

@@ -13,21 +13,21 @@
 # limitations under the License.
 import codecs
 import logging
-from pathlib import Path
 import random
 import sys
 import time
 import traceback
-from typing import cast, Any, Literal
+from pathlib import Path
 from threading import Event, Thread
+from typing import Any, Literal, cast
 
 import pytest
 
+from toil.batchSystems import DeadlockException
 from toil.batchSystems.singleMachine import SingleMachineBatchSystem
 from toil.exceptions import FailedJobsException
 from toil.job import Job, ServiceHostJob
 from toil.jobStores.abstractJobStore import AbstractJobStore
-from toil.batchSystems import DeadlockException
 from toil.test import pslow as slow
 
 logger = logging.getLogger(__name__)
@@ -177,9 +177,16 @@ class TestJobService:
         total_jobs = BUNDLE_SIZE * BUNDLE_COUNT * 2 + 1
         p_complete_job_failure = FAIL_FRACTION ** (RETRY_COUNT + 1)
         p_workflow_success = (1 - p_complete_job_failure) ** total_jobs
-        logger.info("Going to run %s total jobs, each of which completely fails %s of the time, so the workflow will succeed with probability %s", total_jobs, p_complete_job_failure, p_workflow_success)
+        logger.info(
+            "Going to run %s total jobs, each of which completely fails %s of the time, so the workflow will succeed with probability %s",
+            total_jobs,
+            p_complete_job_failure,
+            p_workflow_success,
+        )
         p_test_failure = (1 - p_workflow_success) ** MAX_ATTEMPTS
-        logger.info("This test will fail spuriously with probability %s", p_test_failure)
+        logger.info(
+            "This test will fail spuriously with probability %s", p_test_failure
+        )
 
         # We want to run the workflow through several times to test restarting, so we need it to often fail but reliably sometimes succeed, and almost always succeed when repeated.
 
@@ -192,7 +199,8 @@ class TestJobService:
             outFiles = [tmp_path / f"test{test}_{j}" for j in range(BUNDLE_COUNT)]
             # We send 3 messages each in 2 sets, each of which needs a service and a client
             messageBundles = [
-                [random.randint(1, sys.maxsize) for i in range(BUNDLE_SIZE)] for j in range(BUNDLE_COUNT)
+                [random.randint(1, sys.maxsize) for i in range(BUNDLE_SIZE)]
+                for j in range(BUNDLE_COUNT)
             ]
             # Wire up the services/jobs
             t = Job.wrapJobFn(
@@ -247,7 +255,12 @@ class TestJobService:
                 break
             except FailedJobsException as e:
                 i = e.numberOfFailedJobs
-                logger.info("Workflow attempt %s/%s failed with %s failed jobs", total_tries, max_attempts, i)
+                logger.info(
+                    "Workflow attempt %s/%s failed with %s failed jobs",
+                    total_tries,
+                    max_attempts,
+                    i,
+                )
                 if total_tries == max_attempts:
                     pytest.fail(reason="Exceeded a reasonable number of restarts")
                 total_tries += 1
@@ -261,10 +274,7 @@ class TestPerfectServicet(TestJobService):
         Let us run all the tests in the other service test class, but without worker failures.
         """
         kwargs["badWorker"] = 0
-        super().runToil(
-            *args,
-            **kwargs
-        )
+        super().runToil(*args, **kwargs)
 
 
 def serviceTest(job: Job, outFile: Path, messageInt: int) -> None:
@@ -278,9 +288,7 @@ def serviceTest(job: Job, outFile: Path, messageInt: int) -> None:
     # the serviceAccessor, to prove that when service test is checkpointed and
     # restarted there is never a connection made between an earlier service and
     # later serviceAccessor, or vice versa.
-    to_subtract = random.randint(
-        1, sys.maxsize
-    )
+    to_subtract = random.randint(1, sys.maxsize)
     job.addChildJobFn(
         serviceAccessor,
         job.addService(ToyService(messageInt + to_subtract)),

toil/test/src/jobTest.py

@@ -11,13 +11,12 @@
 # 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.
-from collections.abc import Callable
 import collections
-import logging
 import os
-from pathlib import Path
 import random
-from typing import cast, Optional, Union, Any, NoReturn
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Callable, NoReturn, cast
 
 import pytest
 
@@ -28,14 +27,12 @@ from toil.job import (
     Job,
     JobFunctionWrappingJob,
     JobGraphDeadlockException,
-    ServiceHostJob,
     Promise,
+    ServiceHostJob,
 )
 from toil.lib.misc import FileDescriptorOrPath
 from toil.test import pslow as slow
 
-from pytest_subtests import SubTests
-
 
 class TestJob:
     """Tests the job class."""
@@ -155,6 +152,63 @@ class TestJob:
             with pytest.raises(FailedJobsException):
                 toil.start(i)
 
+    def testDeadlockDetectionStatic(self) -> None:
+        """
+        Test cycle detection on small example graphs.
+        """
+        # Test 1: Simple 3-node graph with a child cycle: 0 -> 1 -> 2 -> 0
+        childEdges: set[tuple[int, int]] = {(0, 1), (1, 2)}
+        followOnEdges: set[tuple[int, int]] = set()
+        # Valid DAG should pass
+        rootJob = self.makeJobGraph(3, childEdges, followOnEdges, None, False)
+        rootJob.checkJobGraphAcylic()
+        rootJob.checkJobGraphConnected()
+        # Adding edge (2, 0) creates cycle
+        childEdges.add((2, 0))
+        with pytest.raises(JobGraphDeadlockException):
+            self.makeJobGraph(3, childEdges, followOnEdges, None, False).checkJobGraphAcylic()
+
+        # Test 2: Self-loop (0 -> 0)
+        childEdges = {(0, 1), (0, 0)}
+        with pytest.raises(JobGraphDeadlockException):
+            self.makeJobGraph(2, childEdges, followOnEdges, None, False).checkJobGraphAcylic()
+
+        # Test 3: Multiple roots detection (nodes 0 and 2 are both roots)
+        childEdges = {(0, 1), (2, 1)}  # Both 0 and 2 point to 1, neither has incoming edges
+        with pytest.raises(JobGraphDeadlockException):
+            self.makeJobGraph(3, childEdges, followOnEdges, None, False).checkJobGraphConnected()
+
+        # Test 4: Follow-on creating a cycle
+        # Graph: 0 -> 1, with follow-on 1 -> 0
+        childEdges = {(0, 1)}
+        followOnEdges = {(1, 0)}
+        with pytest.raises(JobGraphDeadlockException):
+            self.makeJobGraph(2, childEdges, followOnEdges, None, False).checkJobGraphAcylic()
+
+        # Test 5: Self follow-on
+        childEdges = {(0, 1)}
+        followOnEdges = {(0, 0)}
+        with pytest.raises(JobGraphDeadlockException):
+            self.makeJobGraph(2, childEdges, followOnEdges, None, False).checkJobGraphAcylic()
+
+        # Test 6: Larger graph - 5 nodes in a chain, add back-edge
+        childEdges = {(0, 1), (1, 2), (2, 3), (3, 4)}
+        followOnEdges = set()
+        rootJob = self.makeJobGraph(5, childEdges, followOnEdges, None, False)
+        rootJob.checkJobGraphAcylic()
+        # Add back-edge from 4 to 2
+        childEdges.add((4, 2))
+        with pytest.raises(JobGraphDeadlockException):
+            self.makeJobGraph(5, childEdges, followOnEdges, None, False).checkJobGraphAcylic()
+
+    # We have this marked as xfail but allow it to pass also, to try and
+    # collect failing cases without breaking unrelated PRs.
+    # TODO: In the future, go through the CI logs and find the cases that
+    # manage to fail. No failure was found in many iterations locally.
+    @pytest.mark.xfail(
+        reason="Flaky test - see https://github.com/DataBiosphere/toil/issues/5354",
+        strict=False,
+    )
     def testDeadlockDetection(self) -> None:
         """
         Randomly generate job graphs with various types of cycle in them and
@@ -189,17 +243,31 @@ class TestJob:
             rootJob2 = self.makeJobGraph(
                 nodeNumber + 1, childEdges2, followOnEdges, None, False
             )
-            with pytest.raises(JobGraphDeadlockException):
-                rootJob2.checkJobGraphConnected()
+            self._assertDeadlockDetected(
+                rootJob2.checkJobGraphConnected,
+                "multiple roots",
+                nodeNumber + 1,
+                childEdges2,
+                followOnEdges,
+            )
 
             def checkChildEdgeCycleDetection(fNode: int, tNode: int) -> None:
                 childEdges.add((fNode, tNode))  # Create a cycle
                 adjacencyList[fNode].add(tNode)
-                assert not self.isAcyclic(adjacencyList)
-                with pytest.raises(JobGraphDeadlockException):
-                    self.makeJobGraph(
+                assert not self.isAcyclic(adjacencyList), (
+                    f"isAcyclic incorrectly returned True after adding cycle edge "
+                    f"({fNode}, {tNode}). nodeNumber={nodeNumber}, "
+                    f"childEdges={childEdges}, followOnEdges={followOnEdges}"
+                )
+                self._assertDeadlockDetected(
+                    lambda: self.makeJobGraph(
                         nodeNumber, childEdges, followOnEdges, None
-                    ).checkJobGraphAcylic()
+                    ).checkJobGraphAcylic(),
+                    f"child edge cycle ({fNode}, {tNode})",
+                    nodeNumber,
+                    childEdges,
+                    followOnEdges,
+                )
                 # Remove the edges
                 childEdges.remove((fNode, tNode))
                 adjacencyList[fNode].remove(tNode)
@@ -210,10 +278,15 @@ class TestJob:
 
             def checkFollowOnEdgeCycleDetection(fNode: int, tNode: int) -> None:
                 followOnEdges.add((fNode, tNode))  # Create a cycle
-                with pytest.raises(JobGraphDeadlockException):
-                    self.makeJobGraph(
+                self._assertDeadlockDetected(
+                    lambda: self.makeJobGraph(
                         nodeNumber, childEdges, followOnEdges, None, False
-                    ).checkJobGraphAcylic()
+                    ).checkJobGraphAcylic(),
+                    f"follow-on edge cycle ({fNode}, {tNode})",
+                    nodeNumber,
+                    childEdges,
+                    followOnEdges,
+                )
                 # Remove the edges
                 followOnEdges.remove((fNode, tNode))
                 # Check is now acyclic again
@@ -255,10 +328,33 @@ class TestJob:
             ):
                 checkFollowOnEdgeCycleDetection(fNode, tNode)
 
+    def _assertDeadlockDetected(
+        self,
+        check_fn: Callable[[], None],
+        description: str,
+        nodeNumber: int,
+        childEdges: set[tuple[int, int]],
+        followOnEdges: set[tuple[int, int]],
+    ) -> None:
+        """
+        Assert that check_fn raises JobGraphDeadlockException.
+
+        If it doesn't, provide detailed graph info for reproduction.
+        """
+        try:
+            check_fn()
+        except JobGraphDeadlockException:
+            return  # Expected
+        pytest.fail(
+            f"JobGraphDeadlockException not raised for {description}. "
+            f"Graph info for reproduction: nodeNumber={nodeNumber}, "
+            f"childEdges={repr(childEdges)}, followOnEdges={repr(followOnEdges)}"
+        )
+
     @slow
     @pytest.mark.slow
     def testNewCheckpointIsLeafVertexNonRootCase(
-        self, tmp_path: Path, subtests: SubTests
+        self, tmp_path: Path, subtests: pytest.Subtests
     ) -> None:
         """
         Test for issue #1465: Detection of checkpoint jobs that are not leaf vertices
@@ -285,7 +381,7 @@ class TestJob:
     @slow
     @pytest.mark.slow
     def testNewCheckpointIsLeafVertexRootCase(
-        self, tmp_path: Path, subtests: SubTests
+        self, tmp_path: Path, subtests: pytest.Subtests
     ) -> None:
         """
         Test for issue #1466: Detection of checkpoint jobs that are not leaf vertices
@@ -307,7 +403,7 @@ class TestJob:
     def runNewCheckpointIsLeafVertexTest(
         self,
         tmp_path: Path,
-        subtests: SubTests,
+        subtests: pytest.Subtests,
         createWorkflowFn: Callable[[], tuple[Job, Job]],
     ) -> None:
         """
@@ -369,10 +465,10 @@ class TestJob:
         workflowRootJob: Job,
         checkpointJob: Job,
         tmp_path: Path,
-        checkpointJobService: Optional[Job.Service] = None,
-        checkpointJobChild: Optional[Job] = None,
-        checkpointJobFollowOn: Optional[Job] = None,
-        expectedException: Optional[type[Exception]] = None,
+        checkpointJobService: Job.Service | None = None,
+        checkpointJobChild: Job | None = None,
+        checkpointJobFollowOn: Job | None = None,
+        expectedException: type[Exception] | None = None,
     ) -> None:
         """
         Modifies the checkpoint job according to the given parameters
@@ -590,7 +686,7 @@ class TestJob:
         nodeNumber: int,
         childEdges: set[tuple[int, int]],
         followOnEdges: set[tuple[int, int]],
-        outPath: Optional[Path],
+        outPath: Path | None,
         addServices: bool = True,
     ) -> Job:
         """
@@ -666,7 +762,7 @@ class TestJob:
         list.
         """
 
-        def cyclic(fNode: int, visited: set[int], stack: list[int]) -> Union[bool, int]:
+        def cyclic(fNode: int, visited: set[int], stack: list[int]) -> bool | int:
             if fNode not in visited:
                 visited.add(fNode)
                 assert fNode not in stack

toil/test/src/miscTests.py

@@ -14,13 +14,13 @@
 import inspect
 import logging
 import os
-import re
-from pathlib import Path
 import random
+import re
 import sys
-from types import FrameType
+from pathlib import Path
 from uuid import uuid4
-from typing import cast, Union
+
+import pytest
 
 from toil.common import getNodeID
 from toil.lib.exceptions import panic, raise_
@@ -28,8 +28,6 @@ from toil.lib.io import AtomicFileCreate, atomic_install, atomic_tmp_file, mkdte
 from toil.lib.misc import CalledProcessErrorStderr, StrPath, call_command
 from toil.test import pslow as slow
 
-import pytest
-
 log = logging.getLogger(__name__)
 logging.basicConfig()
 
@@ -63,7 +61,7 @@ class TestMisc:
         # a list of the directories used in the test
         directories: list[StrPath] = [tmp_path]
         # A dict of {FILENAME: FILESIZE or FILELINK} for all files used in the test
-        files: dict[Path, Union[int, str]] = {}
+        files: dict[Path, int | str] = {}
         # Create a random directory structure
         for i in range(0, 10):
             directories.append(mkdtemp(dir=random.choice(directories), prefix="test"))

toil/test/src/promisedRequirementTest.py

@@ -12,22 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections.abc import Generator
 import argparse
 import logging
 import os
-from pathlib import Path
 import time
+from collections.abc import Generator
+from pathlib import Path
 from typing import Any
 
-from toil.test.batchSystems import batchSystemTest
+import pytest
+
 from toil.batchSystems.mesos.test import MesosTestSupport
 from toil.fileStores import FileID
-from toil.job import Job, PromisedRequirement, JobFunctionWrappingJob, Promise
+from toil.job import Job, JobFunctionWrappingJob, Promise, PromisedRequirement
 from toil.lib.retry import retry_flaky_test
-from toil.test import pneeds_mesos as needs_mesos, pslow as slow
-
-import pytest
+from toil.test import pneeds_mesos as needs_mesos
+from toil.test import pslow as slow
+from toil.test.batchSystems import batchSystemTest
 
 log = logging.getLogger(__name__)
 

toil/test/src/regularLogTest.py

@@ -14,10 +14,9 @@
 import logging
 import mimetypes
 import os
-from pathlib import Path
 import subprocess
 import sys
-from typing import Optional
+from pathlib import Path
 
 from toil.test import pslow as slow
 from toil.test.mesos import helloWorld
@@ -36,7 +35,7 @@ class RegularLogTest:
         ]
 
     def _assertFileTypeExists(
-        self, dirpath: Path, extension: str, encoding: Optional[str] = None
+        self, dirpath: Path, extension: str, encoding: str | None = None
     ) -> None:
         # an encoding of None implies no compression
         logger.info("Checking for %s file in %s", extension, dirpath)

toil/test/src/resourceTest.py

@@ -11,27 +11,24 @@
 # 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.
-from collections.abc import Iterable
 import importlib
 import os
-from pathlib import Path
 import subprocess
 import sys
-import tempfile
-from contextlib import contextmanager
+from collections.abc import Iterable
 from inspect import getsource
 from io import BytesIO
+from pathlib import Path
 from textwrap import dedent
 from unittest.mock import MagicMock, patch
 from zipfile import ZipFile
-from typing import Optional
+
+import pytest
 
 from toil import inVirtualEnv
 from toil.resource import ModuleDescriptor, Resource, ResourceException
 from toil.version import exactPython
 
-import pytest
-
 
 def tempFileContaining(directory: Path, content: str, suffix: str = "") -> str:
     """
@@ -151,7 +148,7 @@ class TestResource:
         self,
         module_name: str,
         shouldBelongToToil: bool = False,
-        expectedContents: Optional[Iterable[str]] = None,
+        expectedContents: Iterable[str] | None = None,
         allowExtraContents: bool = True,
     ) -> None:
         module = ModuleDescriptor.forModule(module_name)

toil/test/src/restartDAGTest.py

@@ -15,17 +15,16 @@
 
 import logging
 import os
-from pathlib import Path
 import signal
-from typing import Optional
+from pathlib import Path
+
+import pytest
 
 from toil.common import Toil
 from toil.exceptions import FailedJobsException
 from toil.job import Job
 from toil.test import pslow as slow
 
-import pytest
-
 logger = logging.getLogger(__name__)
 
 
@@ -89,7 +88,7 @@ class TestRestartDAG:
 
         assert not childFile.exists()
 
-        errorRaised: Optional[BaseException] = None
+        errorRaised: BaseException | None = None
         # Run the test
         for runMode in "start", "restart":
             errorRaised = None
@@ -142,7 +141,7 @@ class TestRestartDAG:
             )
 
 
-def passingFn(job: Job, file: Optional[Path] = None) -> None:
+def passingFn(job: Job, file: Path | None = None) -> None:
     """
     This function is guaranteed to pass as it does nothing out of the ordinary.
 

toil/test/src/resumabilityTest.py

@@ -14,13 +14,13 @@
 
 from pathlib import Path
 
+import pytest
+
 from toil.exceptions import FailedJobsException
 from toil.job import Job, JobFunctionWrappingJob
 from toil.jobStores.abstractJobStore import NoSuchFileException
 from toil.test import pslow as slow
 
-import pytest
-
 
 class TestResumability:
     """

toil/test/src/retainTempDirTest.py

@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import argparse
-from collections.abc import Callable
 import os
+from collections.abc import Callable
 from pathlib import Path
 
+import pytest
+
 from toil.exceptions import FailedJobsException
 from toil.job import Job, JobFunctionWrappingJob
 
-import pytest
-
 
 class TestCleanWorkDir:
     """

toil/test/src/systemTest.py

@@ -1,9 +1,9 @@
 import errno
 import multiprocessing
 import os
-from pathlib import Path
 from functools import partial
-from typing import Any, Optional
+from pathlib import Path
+from typing import Any
 
 from toil.lib.io import mkdtemp
 from toil.lib.threading import cpu_count
@@ -44,7 +44,7 @@ class TestSystem:
 
 def _testAtomicityOfNonEmptyDirectoryRenamesTask(
     parent: Path, child: Path, _: Any
-) -> Optional[int]:
+) -> int | None:
     tmpChildDir = mkdtemp(dir=parent, prefix="child", suffix=".tmp")
     grandChild = os.path.join(tmpChildDir, "grandChild")
     open(grandChild, "w").close()

toil/test/src/threadingTest.py

@@ -1,11 +1,11 @@
 import logging
 import multiprocessing
 import os
-from pathlib import Path
 import random
 import time
 import traceback
 from functools import partial
+from pathlib import Path
 
 from toil.lib.threading import LastProcessStandingArena, cpu_count, global_mutex
 

toil/test/src/workerTest.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional
 
 from toil.common import Config
 from toil.job import CheckpointJobDescription, JobDescription
@@ -42,7 +41,7 @@ class WorkerTests(ToilTest):
             disk,
             preemptible: bool = True,
             checkpoint: bool = False,
-            local: Optional[bool] = None,
+            local: bool | None = None,
         ):
             """
             Create a JobDescription with no command (representing a Job that

toil/test/utils/toilDebugTest.py

@@ -13,15 +13,17 @@
 # limitations under the License.
 import logging
 import os
-from pathlib import Path
 import subprocess
+from pathlib import Path
+
+import pytest
 
 from toil.lib.resources import glob
-from toil.test import get_data, pneeds_wdl as needs_wdl, pslow as slow
+from toil.test import get_data
+from toil.test import pneeds_wdl as needs_wdl
+from toil.test import pslow as slow
 from toil.version import python
 
-import pytest
-
 logger = logging.getLogger(__name__)
 
 

toil/test/utils/toilKillTest.py

@@ -14,11 +14,11 @@
 
 import logging
 import os
-from pathlib import Path
 import subprocess
 import sys
 import time
 import unittest
+from pathlib import Path
 
 from toil.common import Toil
 from toil.jobStores.abstractJobStore import NoSuchFileException, NoSuchJobStoreException