toil 8.1.0b1__py3-none-any.whl → 8.2.0__py3-none-any.whl

toil/test/docs/scripts/tutorial_staging.py

@@ -0,0 +1,45 @@
+import os
+
+from toil.common import Toil
+from toil.job import Job
+from toil.lib.io import mkdtemp
+
+
+class HelloWorld(Job):
+    def __init__(self, id):
+        Job.__init__(self)
+        self.inputFileID = id
+
+    def run(self, fileStore):
+        with fileStore.readGlobalFileStream(self.inputFileID, encoding="utf-8") as fi:
+            with fileStore.writeGlobalFileStream(encoding="utf-8") as (
+                fo,
+                outputFileID,
+            ):
+                fo.write(fi.read() + "World!")
+        return outputFileID
+
+
+if __name__ == "__main__":
+    jobstore: str = mkdtemp("tutorial_staging")
+    os.rmdir(jobstore)
+    options = Job.Runner.getDefaultOptions(jobstore)
+    options.logLevel = "INFO"
+    options.clean = "always"
+
+    with Toil(options) as toil:
+        if not toil.options.restart:
+            ioFileDirectory = os.path.join(
+                os.path.dirname(os.path.abspath(__file__)), "stagingExampleFiles"
+            )
+            inputFileID = toil.importFile(
+                "file://" + os.path.abspath(os.path.join(ioFileDirectory, "in.txt"))
+            )
+            outputFileID = toil.start(HelloWorld(inputFileID))
+        else:
+            outputFileID = toil.restart()
+
+        toil.exportFile(
+            outputFileID,
+            "file://" + os.path.abspath(os.path.join(ioFileDirectory, "out.txt")),
+        )

toil/test/docs/scripts/tutorial_stats.py

@@ -0,0 +1,64 @@
+import math
+import time
+from multiprocessing import Process
+
+from toil.common import Toil
+from toil.job import Job
+
+
+def think(seconds):
+    start = time.time()
+    while time.time() - start < seconds:
+        # Use CPU
+        math.sqrt(123456)
+
+
+class TimeWaster(Job):
+    def __init__(self, time_to_think, time_to_waste, space_to_waste, *args, **kwargs):
+        self.time_to_think = time_to_think
+        self.time_to_waste = time_to_waste
+        self.space_to_waste = space_to_waste
+        super().__init__(*args, **kwargs)
+
+    def run(self, fileStore):
+        # Waste some space
+        file_path = fileStore.getLocalTempFile()
+        with open(file_path, "w") as stream:
+            for i in range(self.space_to_waste):
+                stream.write("X")
+
+        # Do some "useful" compute
+        processes = []
+        for core_number in range(max(1, self.cores)):
+            # Use all the assigned cores to think
+            p = Process(target=think, args=(self.time_to_think,))
+            p.start()
+            processes.append(p)
+        for p in processes:
+            p.join()
+
+        # Also waste some time
+        time.sleep(self.time_to_waste)
+
+
+def main():
+    options = Job.Runner.getDefaultArgumentParser().parse_args()
+
+    job1 = TimeWaster(0, 0, 0, displayName="doNothing")
+    job2 = TimeWaster(10, 0, 4096, displayName="efficientJob")
+    job3 = TimeWaster(10, 0, 1024, cores=4, displayName="multithreadedJob")
+    job4 = TimeWaster(1, 9, 65536, displayName="inefficientJob")
+
+    job1.addChild(job2)
+    job1.addChild(job3)
+    job3.addChild(job4)
+
+    with Toil(options) as toil:
+        if not toil.options.restart:
+            toil.start(job1)
+        else:
+            toil.restart()
+
+
+if __name__ == "__main__":
+    main()

toil/test/lib/aws/test_iam.py

@@ -19,7 +19,7 @@ import boto3
 from moto import mock_aws
 
 from toil.lib.aws import iam
-from toil.test import ToilTest
+from toil.test import ToilTest, needs_aws_s3
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.DEBUG)
@@ -70,6 +70,7 @@ class IAMTest(ToilTest):
         assert iam.permission_matches_any("ec2:*", ["iam:*"]) is False
 
     @mock_aws
+    @needs_aws_s3  # mock is incomplete, this avoid 'botocore.exceptions.NoCredentialsError: Unable to locate credentials'
     def test_get_policy_permissions(self):
         mock_iam = boto3.client("iam")
 
@@ -165,6 +166,7 @@ class IAMTest(ToilTest):
         assert actions_set == expected_actions
         assert notactions_set == set()
 
+    @needs_aws_s3
     def test_create_delete_iam_role(self):
         region = "us-west-2"
         role_name = f'test{str(uuid4()).replace("-", "")}'

toil/test/lib/dockerTest.py

@@ -13,12 +13,14 @@
 # limitations under the License.
 import logging
 import os
+from pathlib import Path
 import signal
 import time
+from typing import Optional
 import uuid
 from threading import Thread
 
-from docker.errors import ContainerError
+from docker.errors import ContainerError  # type: ignore[import-not-found]
 from toil.common import Toil
 from toil.exceptions import FailedJobsException
 from toil.job import Job
@@ -30,31 +32,31 @@ from toil.lib.docker import (
     containerIsRunning,
     dockerKill,
 )
-from toil.test import ToilTest, needs_docker, slow
+from toil.test import pneeds_docker as needs_docker, pslow as slow
+
+import pytest
 
 logger = logging.getLogger(__name__)
 
 
 @needs_docker
-class DockerTest(ToilTest):
+@pytest.mark.docker
+@pytest.mark.online
+class TestDocker:
     """
     Tests dockerCall and ensures no containers are left around.
-    When running tests you may optionally set the TOIL_TEST_TEMP environment
-    variable to the path of a directory where you want temporary test files be
-    placed. The directory will be created if it doesn't exist. The path may be
-    relative in which case it will be assumed to be relative to the project
-    root. If TOIL_TEST_TEMP is not defined, temporary files and directories will
-    be created in the system's default location for such files and any temporary
-    files or directories left over from tests will be removed automatically
-    removed during tear down.
-    Otherwise, left-over files will not be removed.
     """
 
-    def setUp(self):
-        self.tempDir = self._createTempDir(purpose="tempDir")
-        self.dockerTestLogLevel = "INFO"
+    dockerTestLogLevel = "INFO"
 
-    def testDockerClean(self, caching=False, detached=True, rm=True, deferParam=None):
+    def testDockerClean(
+        self,
+        tmp_path: Path,
+        caching: bool = False,
+        detached: bool = True,
+        rm: bool = True,
+        deferParam: Optional[int] = None,
+    ) -> None:
         """
         Run the test container that creates a file in the work dir, and sleeps
         for 5 minutes.
@@ -72,16 +74,15 @@ class DockerTest(ToilTest):
         # detached     X         R         E      X
         #  Neither     X         R         E      X
 
-        data_dir = os.path.join(self.tempDir, "data")
-        working_dir = os.path.join(self.tempDir, "working")
-        test_file = os.path.join(working_dir, "test.txt")
-
-        os.makedirs(data_dir, exist_ok=True)
-        os.makedirs(working_dir, exist_ok=True)
+        data_dir = tmp_path / "data"
+        data_dir.mkdir()
+        working_dir = tmp_path / "working"
+        working_dir.mkdir()
+        test_file = working_dir / "test.txt"
 
-        options = Job.Runner.getDefaultOptions(os.path.join(self.tempDir, "jobstore"))
+        options = Job.Runner.getDefaultOptions(tmp_path / "jobstore")
         options.logLevel = self.dockerTestLogLevel
-        options.workDir = working_dir
+        options.workDir = str(working_dir)
         options.clean = "always"
         options.retryCount = 0  # we're expecting the job to fail so don't retry!
         options.caching = caching
@@ -99,7 +100,7 @@ class DockerTest(ToilTest):
             # and since it was created inside the container, it would have had
             # uid and gid == 0 (root) which may cause problems when docker
             # attempts to clean up the jobstore.
-            file_stats = os.stat(test_file)
+            file_stats = test_file.stat()
             assert file_stats.st_gid != 0
             assert file_stats.st_uid != 0
 
@@ -124,104 +125,173 @@ class DockerTest(ToilTest):
             # Clean up
             try:
                 dockerKill(container_name, remove=True)
-                os.remove(test_file)
+                test_file.unlink()
             except:
                 pass
 
-    def testDockerClean_CRx_FORGO(self):
-        self.testDockerClean(caching=False, detached=False, rm=True, deferParam=FORGO)
+    def testDockerClean_CRx_FORGO(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=False, rm=True, deferParam=FORGO
+        )
 
-    def testDockerClean_CRx_STOP(self):
-        self.testDockerClean(caching=False, detached=False, rm=True, deferParam=STOP)
+    def testDockerClean_CRx_STOP(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=False, rm=True, deferParam=STOP
+        )
 
-    def testDockerClean_CRx_RM(self):
-        self.testDockerClean(caching=False, detached=False, rm=True, deferParam=RM)
+    def testDockerClean_CRx_RM(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=False, rm=True, deferParam=RM
+        )
 
     @slow
-    def testDockerClean_CRx_None(self):
-        self.testDockerClean(caching=False, detached=False, rm=True, deferParam=None)
+    @pytest.mark.slow
+    def testDockerClean_CRx_None(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=False, rm=True, deferParam=None
+        )
 
     @slow
-    def testDockerClean_CxD_FORGO(self):
-        self.testDockerClean(caching=False, detached=True, rm=False, deferParam=FORGO)
+    @pytest.mark.slow
+    def testDockerClean_CxD_FORGO(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=True, rm=False, deferParam=FORGO
+        )
 
     @slow
-    def testDockerClean_CxD_STOP(self):
-        self.testDockerClean(caching=False, detached=True, rm=False, deferParam=STOP)
+    @pytest.mark.slow
+    def testDockerClean_CxD_STOP(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=True, rm=False, deferParam=STOP
+        )
 
     @slow
-    def testDockerClean_CxD_RM(self):
-        self.testDockerClean(caching=False, detached=True, rm=False, deferParam=RM)
+    @pytest.mark.slow
+    def testDockerClean_CxD_RM(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=True, rm=False, deferParam=RM
+        )
 
     @slow
-    def testDockerClean_CxD_None(self):
-        self.testDockerClean(caching=False, detached=True, rm=False, deferParam=None)
+    @pytest.mark.slow
+    def testDockerClean_CxD_None(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=True, rm=False, deferParam=None
+        )
 
     @slow
-    def testDockerClean_Cxx_FORGO(self):
-        self.testDockerClean(caching=False, detached=False, rm=False, deferParam=FORGO)
+    @pytest.mark.slow
+    def testDockerClean_Cxx_FORGO(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=False, rm=False, deferParam=FORGO
+        )
 
     @slow
-    def testDockerClean_Cxx_STOP(self):
-        self.testDockerClean(caching=False, detached=False, rm=False, deferParam=STOP)
+    @pytest.mark.slow
+    def testDockerClean_Cxx_STOP(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=False, rm=False, deferParam=STOP
+        )
 
     @slow
-    def testDockerClean_Cxx_RM(self):
-        self.testDockerClean(caching=False, detached=False, rm=False, deferParam=RM)
+    @pytest.mark.slow
+    def testDockerClean_Cxx_RM(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=False, rm=False, deferParam=RM
+        )
 
     @slow
-    def testDockerClean_Cxx_None(self):
-        self.testDockerClean(caching=False, detached=False, rm=False, deferParam=None)
+    @pytest.mark.slow
+    def testDockerClean_Cxx_None(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=False, detached=False, rm=False, deferParam=None
+        )
 
     @slow
-    def testDockerClean_xRx_FORGO(self):
-        self.testDockerClean(caching=True, detached=False, rm=True, deferParam=FORGO)
+    @pytest.mark.slow
+    def testDockerClean_xRx_FORGO(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=False, rm=True, deferParam=FORGO
+        )
 
     @slow
-    def testDockerClean_xRx_STOP(self):
-        self.testDockerClean(caching=True, detached=False, rm=True, deferParam=STOP)
+    @pytest.mark.slow
+    def testDockerClean_xRx_STOP(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=False, rm=True, deferParam=STOP
+        )
 
     @slow
-    def testDockerClean_xRx_RM(self):
-        self.testDockerClean(caching=True, detached=False, rm=True, deferParam=RM)
+    @pytest.mark.slow
+    def testDockerClean_xRx_RM(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=False, rm=True, deferParam=RM
+        )
 
     @slow
-    def testDockerClean_xRx_None(self):
-        self.testDockerClean(caching=True, detached=False, rm=True, deferParam=None)
+    @pytest.mark.slow
+    def testDockerClean_xRx_None(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=False, rm=True, deferParam=None
+        )
 
     @slow
-    def testDockerClean_xxD_FORGO(self):
-        self.testDockerClean(caching=True, detached=True, rm=False, deferParam=FORGO)
+    @pytest.mark.slow
+    def testDockerClean_xxD_FORGO(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=True, rm=False, deferParam=FORGO
+        )
 
     @slow
-    def testDockerClean_xxD_STOP(self):
-        self.testDockerClean(caching=True, detached=True, rm=False, deferParam=STOP)
+    @pytest.mark.slow
+    def testDockerClean_xxD_STOP(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=True, rm=False, deferParam=STOP
+        )
 
     @slow
-    def testDockerClean_xxD_RM(self):
-        self.testDockerClean(caching=True, detached=True, rm=False, deferParam=RM)
+    @pytest.mark.slow
+    def testDockerClean_xxD_RM(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=True, rm=False, deferParam=RM
+        )
 
     @slow
-    def testDockerClean_xxD_None(self):
-        self.testDockerClean(caching=True, detached=True, rm=False, deferParam=None)
+    @pytest.mark.slow
+    def testDockerClean_xxD_None(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=True, rm=False, deferParam=None
+        )
 
     @slow
-    def testDockerClean_xxx_FORGO(self):
-        self.testDockerClean(caching=True, detached=False, rm=False, deferParam=FORGO)
+    @pytest.mark.slow
+    def testDockerClean_xxx_FORGO(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=False, rm=False, deferParam=FORGO
+        )
 
     @slow
-    def testDockerClean_xxx_STOP(self):
-        self.testDockerClean(caching=True, detached=False, rm=False, deferParam=STOP)
+    @pytest.mark.slow
+    def testDockerClean_xxx_STOP(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=False, rm=False, deferParam=STOP
+        )
 
     @slow
-    def testDockerClean_xxx_RM(self):
-        self.testDockerClean(caching=True, detached=False, rm=False, deferParam=RM)
+    @pytest.mark.slow
+    def testDockerClean_xxx_RM(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=False, rm=False, deferParam=RM
+        )
 
     @slow
-    def testDockerClean_xxx_None(self):
-        self.testDockerClean(caching=True, detached=False, rm=False, deferParam=None)
+    @pytest.mark.slow
+    def testDockerClean_xxx_None(self, tmp_path: Path) -> None:
+        self.testDockerClean(
+            tmp_path, caching=True, detached=False, rm=False, deferParam=None
+        )
 
-    def testDockerPipeChain(self, caching=False):
+    def testDockerPipeChain(self, tmp_path: Path, caching: bool = False) -> None:
         r"""
         Test for piping API for dockerCall().  Using this API (activated when
         list of argument lists is given as parameters), commands a piped
@@ -229,9 +299,11 @@ class DockerTest(ToilTest):
         ex:  ``parameters=[ ['printf', 'x\n y\n'], ['wc', '-l'] ]`` should execute:
         ``printf 'x\n y\n' | wc -l``
         """
-        options = Job.Runner.getDefaultOptions(os.path.join(self.tempDir, "jobstore"))
+        workdir = tmp_path / "workdir"
+        workdir.mkdir()
+        options = Job.Runner.getDefaultOptions(tmp_path / "jobstore")
         options.logLevel = self.dockerTestLogLevel
-        options.workDir = self.tempDir
+        options.workDir = str(workdir)
         options.clean = "always"
         options.caching = caching
         A = Job.wrapJobFn(_testDockerPipeChainFn)
@@ -240,38 +312,44 @@ class DockerTest(ToilTest):
         rv = rv.decode("utf-8")
         assert rv.strip() == "2"
 
-    def testDockerPipeChainErrorDetection(self, caching=False):
+    def testDockerPipeChainErrorDetection(
+        self, tmp_path: Path, caching: bool = False
+    ) -> None:
         """
         By default, executing cmd1 | cmd2 | ... | cmdN, will only return an
         error if cmdN fails.  This can lead to all manor of errors being
         silently missed.  This tests to make sure that the piping API for
         dockerCall() throws an exception if non-last commands in the chain fail.
         """
-        options = Job.Runner.getDefaultOptions(os.path.join(self.tempDir, "jobstore"))
+        workdir = tmp_path / "workdir"
+        workdir.mkdir()
+        options = Job.Runner.getDefaultOptions(tmp_path / "jobstore")
         options.logLevel = self.dockerTestLogLevel
-        options.workDir = self.tempDir
+        options.workDir = str(workdir)
         options.clean = "always"
         options.caching = caching
         A = Job.wrapJobFn(_testDockerPipeChainErrorFn)
         rv = Job.Runner.startToil(A, options)
         assert rv is True
 
-    def testNonCachingDockerChain(self):
-        self.testDockerPipeChain(caching=True)
+    def testNonCachingDockerChain(self, tmp_path: Path) -> None:
+        self.testDockerPipeChain(tmp_path, caching=True)
 
-    def testNonCachingDockerChainErrorDetection(self):
-        self.testDockerPipeChainErrorDetection(caching=True)
+    def testNonCachingDockerChainErrorDetection(self, tmp_path: Path) -> None:
+        self.testDockerPipeChainErrorDetection(tmp_path, caching=True)
 
-    def testDockerLogs(self, stream=False, demux=False):
+    def testDockerLogs(
+        self, tmp_path: Path, stream: bool = False, demux: bool = False
+    ) -> None:
         """Test for the different log outputs when deatch=False."""
 
-        working_dir = os.path.join(self.tempDir, "working")
-        script_file = os.path.join(working_dir, "script.sh")
-        os.makedirs(working_dir, exist_ok=True)
+        working_dir = tmp_path / "working"
+        working_dir.mkdir()
+        script_file = working_dir / "script.sh"
 
-        options = Job.Runner.getDefaultOptions(os.path.join(self.tempDir, "jobstore"))
+        options = Job.Runner.getDefaultOptions(tmp_path / "jobstore")
         options.logLevel = self.dockerTestLogLevel
-        options.workDir = working_dir
+        options.workDir = str(working_dir)
         options.clean = "always"
         A = Job.wrapJobFn(
             _testDockerLogsFn,
@@ -281,43 +359,42 @@ class DockerTest(ToilTest):
             demux=demux,
         )
 
-        try:
-            rv = Job.Runner.startToil(A, options)
-            assert rv is True
-        finally:
-            try:
-                os.remove(script_file)
-            except:
-                pass
+        rv = Job.Runner.startToil(A, options)
+        assert rv is True
 
-    def testDockerLogs_Stream(self):
-        self.testDockerLogs(stream=True, demux=False)
+    def testDockerLogs_Stream(self, tmp_path: Path) -> None:
+        self.testDockerLogs(tmp_path, stream=True, demux=False)
 
-    def testDockerLogs_Demux(self):
-        self.testDockerLogs(stream=False, demux=True)
+    def testDockerLogs_Demux(self, tmp_path: Path) -> None:
+        self.testDockerLogs(tmp_path, stream=False, demux=True)
 
-    def testDockerLogs_Demux_Stream(self):
-        self.testDockerLogs(stream=True, demux=True)
+    def testDockerLogs_Demux_Stream(self, tmp_path: Path) -> None:
+        self.testDockerLogs(tmp_path, stream=True, demux=True)
 
 
 def _testDockerCleanFn(
-    job, working_dir, detached=None, rm=None, deferParam=None, containerName=None
-):
+    job: Job,
+    working_dir: Path,
+    detached: bool = True,
+    rm: Optional[bool] = None,
+    deferParam: Optional[int] = None,
+    containerName: Optional[str] = None,
+) -> None:
     """
     Test function for test docker_clean.  Runs a container with given flags and
     then dies leaving behind a zombie container.
-    :param toil.job.Job job: job
+    :param job: job
     :param working_dir: See `work_dir=` in :func:`dockerCall`
-    :param bool rm: See `rm=` in :func:`dockerCall`
-    :param bool detached: See `detached=` in :func:`dockerCall`
-    :param int deferParam: See `deferParam=` in :func:`dockerCall`
-    :param str containerName: See `container_name=` in :func:`dockerCall`
+    :param detached: See `detached=` in :func:`dockerCall`
+    :param rm: See `rm=` in :func:`dockerCall`
+    :param deferParam: See `deferParam=` in :func:`dockerCall`
+    :param containerName: See `container_name=` in :func:`dockerCall`
     """
 
-    def killSelf():
-        test_file = os.path.join(working_dir, "test.txt")
+    def killSelf() -> None:
+        test_file = working_dir / "test.txt"
         # Kill the worker once we are sure the docker container is started
-        while not os.path.exists(test_file):
+        while not test_file.exists():
             logger.debug("Waiting on the file created by spooky_container.")
             time.sleep(1)
         # By the time we reach here, we are sure the container is running.
@@ -331,8 +408,8 @@ def _testDockerCleanFn(
     apiDockerCall(
         job,
         image="quay.io/ucsc_cgl/spooky_test",
-        working_dir=working_dir,
         deferParam=deferParam,
+        working_dir=str(working_dir),
         containerName=containerName,
         detach=detached,
         remove=rm,
@@ -340,7 +417,7 @@ def _testDockerCleanFn(
     )
 
 
-def _testDockerPipeChainFn(job):
+def _testDockerPipeChainFn(job: Job) -> str:
     """Return the result of a simple pipe chain.  Should be 2."""
     parameters = [["printf", "x\n y\n"], ["wc", "-l"]]
     return apiDockerCall(
@@ -351,7 +428,7 @@ def _testDockerPipeChainFn(job):
     )
 
 
-def _testDockerPipeChainErrorFn(job):
+def _testDockerPipeChainErrorFn(job: Job) -> bool:
     """Return True if the command exit 1 | wc -l raises a ContainerError."""
     parameters = [["exit", "1"], ["wc", "-l"]]
     try:
@@ -361,7 +438,13 @@ def _testDockerPipeChainErrorFn(job):
     return False
 
 
-def _testDockerLogsFn(job, working_dir, script_file, stream=False, demux=False):
+def _testDockerLogsFn(
+    job: Job,
+    working_dir: Path,
+    script_file: Path,
+    stream: bool = False,
+    demux: bool = False,
+) -> bool:
     """Return True if the test succeeds. Otherwise Exception is raised."""
 
     # we write a script file because the redirection operator, '>&2', is wrapped
@@ -380,15 +463,15 @@ def _testDockerLogsFn(job, working_dir, script_file, stream=False, demux=False):
     """
     )
 
-    with open(script_file, "w") as file:
+    with script_file.open("w") as file:
         file.write(bash_script)
 
     out = apiDockerCall(
         job,
         image="quay.io/ucsc_cgl/ubuntu:20.04",
-        working_dir=working_dir,
-        parameters=[script_file],
-        volumes={working_dir: {"bind": working_dir, "mode": "rw"}},
+        working_dir=str(working_dir),
+        parameters=[str(script_file)],
+        volumes={str(working_dir): {"bind": str(working_dir), "mode": "rw"}},
         entrypoint="/bin/bash",
         stdout=True,
         stderr=True,