dbos 1.1.0a4__tar.gz → 1.2.0a4__tar.gz

{dbos-1.1.0a4 → dbos-1.2.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 1.1.0a4
+Version: 1.2.0a4
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_admin_server.py

@@ -5,8 +5,9 @@ import re
 import threading
 from functools import partial
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from typing import TYPE_CHECKING, Any, List, TypedDict
+from typing import TYPE_CHECKING, Any, List, Optional, TypedDict
 
+from ._context import SetWorkflowID
 from ._error import DBOSException
 from ._logger import dbos_logger
 from ._recovery import recover_pending_workflows
@@ -141,7 +142,11 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
                 try:
                     data = json.loads(post_data.decode("utf-8"))
                     start_step: int = data.get("start_step", 1)
-                    self._handle_fork(workflow_id, start_step)
+                    new_workflow_id: Optional[str] = data.get("new_workflow_id")
+                    application_version: Optional[str] = data.get("application_version")
+                    self._handle_fork(
+                        workflow_id, start_step, new_workflow_id, application_version
+                    )
                 except (json.JSONDecodeError, AttributeError) as e:
                     self.send_response(500)
                     self.send_header("Content-Type", "application/json")
@@ -191,9 +196,24 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(response_body)
 
-    def _handle_fork(self, workflow_id: str, start_step: int) -> None:
+    def _handle_fork(
+        self,
+        workflow_id: str,
+        start_step: int,
+        new_workflow_id: Optional[str],
+        application_version: Optional[str],
+    ) -> None:
         try:
-            handle = self.dbos.fork_workflow(workflow_id, start_step)
+            print(f"Forking workflow {workflow_id} from step {start_step}")
+            if new_workflow_id is not None:
+                with SetWorkflowID(new_workflow_id):
+                    handle = self.dbos.fork_workflow(
+                        workflow_id, start_step, application_version=application_version
+                    )
+            else:
+                handle = self.dbos.fork_workflow(
+                    workflow_id, start_step, application_version=application_version
+                )
             response_body = json.dumps(
                 {
                     "workflow_id": handle.workflow_id,

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_app_db.py

@@ -216,21 +216,6 @@ class ApplicationDatabase:
             for row in rows
         ]
 
-    def get_max_function_id(self, workflow_uuid: str) -> Optional[int]:
-        with self.engine.begin() as conn:
-            max_function_id_row = conn.execute(
-                sa.select(
-                    sa.func.max(ApplicationSchema.transaction_outputs.c.function_id)
-                ).where(
-                    ApplicationSchema.transaction_outputs.c.workflow_uuid
-                    == workflow_uuid
-                )
-            ).fetchone()
-
-            max_function_id = max_function_id_row[0] if max_function_id_row else None
-
-            return max_function_id
-
     def clone_workflow_transactions(
         self, src_workflow_id: str, forked_workflow_id: str, start_step: int
     ) -> None:

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_core.py

@@ -602,7 +602,6 @@ async def start_workflow_async(
     *args: P.args,
     **kwargs: P.kwargs,
 ) -> "WorkflowHandleAsync[R]":
-
     # If the function has a class, add the class object as its first argument
     fself: Optional[object] = None
     if hasattr(func, "__self__"):

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_dbos.py

@@ -90,7 +90,6 @@ from ._context import (
 from ._dbos_config import (
     ConfigFile,
     DBOSConfig,
-    check_config_consistency,
     overwrite_config,
     process_config,
     set_env_vars,
@@ -299,6 +298,7 @@ class DBOS:
 
         self._launched: bool = False
         self._debug_mode: bool = False
+        self._configured_threadpool: bool = False
         self._sys_db_field: Optional[SystemDatabase] = None
         self._app_db_field: Optional[ApplicationDatabase] = None
         self._registry: DBOSRegistry = _get_or_create_dbos_registry()
@@ -323,7 +323,6 @@ class DBOS:
         unvalidated_config = translate_dbos_config_to_config_file(config)
         if os.environ.get("DBOS__CLOUD") == "true":
             unvalidated_config = overwrite_config(unvalidated_config)
-        check_config_consistency(name=unvalidated_config["name"])
 
         if unvalidated_config is not None:
             self._config: ConfigFile = process_config(data=unvalidated_config)
@@ -719,6 +718,7 @@ class DBOS:
         **kwargs: P.kwargs,
     ) -> WorkflowHandleAsync[R]:
         """Invoke a workflow function on the event loop, returning a handle to the ongoing execution."""
+        await cls._configure_asyncio_thread_pool()
         return await start_workflow_async(
             _get_dbos_instance(), func, None, True, *args, **kwargs
         )
@@ -736,6 +736,7 @@ class DBOS:
     async def get_workflow_status_async(
         cls, workflow_id: str
     ) -> Optional[WorkflowStatus]:
+        await cls._configure_asyncio_thread_pool()
         """Return the status of a workflow execution."""
         return await asyncio.to_thread(cls.get_workflow_status, workflow_id)
 
@@ -757,6 +758,7 @@ class DBOS:
     ) -> WorkflowHandleAsync[R]:
         """Return a `WorkflowHandle` for a workflow execution."""
         dbos = _get_dbos_instance()
+        await cls._configure_asyncio_thread_pool()
         if existing_workflow:
             stat = await dbos.get_workflow_status_async(workflow_id)
             if stat is None:
@@ -775,6 +777,7 @@ class DBOS:
         cls, destination_id: str, message: Any, topic: Optional[str] = None
     ) -> None:
         """Send a message to a workflow execution."""
+        await cls._configure_asyncio_thread_pool()
         await asyncio.to_thread(lambda: DBOS.send(destination_id, message, topic))
 
     @classmethod
@@ -797,6 +800,7 @@ class DBOS:
         This function is to be called from within a workflow.
         `recv_async` will return the message sent on `topic`, asyncronously waiting if necessary.
         """
+        await cls._configure_asyncio_thread_pool()
         return await asyncio.to_thread(lambda: DBOS.recv(topic, timeout_seconds))
 
     @classmethod
@@ -835,6 +839,7 @@ class DBOS:
         It is important to use `DBOS.sleep` or `DBOS.sleep_async` (as opposed to any other sleep) within workflows,
         as the DBOS sleep methods are durable and completed sleeps will be skipped during recovery.
         """
+        await cls._configure_asyncio_thread_pool()
         await asyncio.to_thread(lambda: DBOS.sleep(seconds))
 
     @classmethod
@@ -869,6 +874,7 @@ class DBOS:
             value(Any): A serializable value to associate with the key
 
         """
+        await cls._configure_asyncio_thread_pool()
         await asyncio.to_thread(lambda: DBOS.set_event(key, value))
 
     @classmethod
@@ -901,6 +907,7 @@ class DBOS:
             timeout_seconds(float): The amount of time to wait, in case `set_event` has not yet been called byt the workflow
 
         """
+        await cls._configure_asyncio_thread_pool()
         return await asyncio.to_thread(
             lambda: DBOS.get_event(workflow_id, key, timeout_seconds)
         )
@@ -929,6 +936,19 @@ class DBOS:
             fn, "DBOS.cancelWorkflow"
         )
 
+    @classmethod
+    async def _configure_asyncio_thread_pool(cls) -> None:
+        """
+        Configure the thread pool for asyncio.to_thread.
+
+        This function is called before the first call to asyncio.to_thread.
+        """
+        if _get_dbos_instance()._configured_threadpool:
+            return
+        loop = asyncio.get_running_loop()
+        loop.set_default_executor(_get_dbos_instance()._executor)
+        _get_dbos_instance()._configured_threadpool = True
+
     @classmethod
     def resume_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Resume a workflow by ID."""

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_dbos_config.py

@@ -529,26 +529,3 @@ def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
         del provided_config["env"]
 
     return provided_config
-
-
-def check_config_consistency(
-    *,
-    name: str,
-    config_file_path: str = DBOS_CONFIG_PATH,
-) -> None:
-    # First load the config file and check whether it is present
-    try:
-        config = load_config(config_file_path, silent=True, run_process_config=False)
-    except FileNotFoundError:
-        dbos_logger.debug(
-            f"No configuration file {config_file_path} found. Skipping consistency check with provided config."
-        )
-        return
-    except Exception as e:
-        raise e
-
-    # Check the name
-    if name != config["name"]:
-        raise DBOSInitializationError(
-            f"Provided app name '{name}' does not match the app name '{config['name']}' in {config_file_path}."
-        )

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_event_loop.py

@@ -1,5 +1,6 @@
 import asyncio
 import threading
+from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Coroutine, Optional, TypeVar
 
 
@@ -33,15 +34,17 @@ class BackgroundEventLoop:
 
     def _run_event_loop(self) -> None:
         self._loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self._loop)
+        with ThreadPoolExecutor(max_workers=64) as thread_pool:
+            self._loop.set_default_executor(thread_pool)
+            asyncio.set_event_loop(self._loop)
 
-        self._running = True
-        self._ready.set()  # Signal that the loop is ready
+            self._running = True
+            self._ready.set()  # Signal that the loop is ready
 
-        try:
-            self._loop.run_forever()
-        finally:
-            self._loop.close()
+            try:
+                self._loop.run_forever()
+            finally:
+                self._loop.close()
 
     async def _shutdown(self) -> None:
         if self._loop is None:

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_queue.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Callable, Coroutine, Optional, TypedDict
 from psycopg import errors
 from sqlalchemy.exc import OperationalError
 
+from dbos._logger import dbos_logger
 from dbos._utils import GlobalParams
 
 from ._core import P, R, execute_workflow_by_id, start_workflow, start_workflow_async
@@ -56,6 +57,8 @@ class Queue:
         from ._dbos import _get_or_create_dbos_registry
 
         registry = _get_or_create_dbos_registry()
+        if self.name in registry.queue_info_map:
+            dbos_logger.warning(f"Queue {name} has already been declared")
         registry.queue_info_map[self.name] = self
 
     def enqueue(

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_sys_db.py

@@ -601,18 +601,6 @@ class SystemDatabase:
                 )
             )
 
-    def get_max_function_id(self, workflow_uuid: str) -> Optional[int]:
-        with self.engine.begin() as conn:
-            max_function_id_row = conn.execute(
-                sa.select(
-                    sa.func.max(SystemSchema.operation_outputs.c.function_id)
-                ).where(SystemSchema.operation_outputs.c.workflow_uuid == workflow_uuid)
-            ).fetchone()
-
-            max_function_id = max_function_id_row[0] if max_function_id_row else None
-
-            return max_function_id
-
     def fork_workflow(
         self,
         original_workflow_id: str,
@@ -1722,13 +1710,8 @@ class SystemDatabase:
                 if num_recent_queries >= queue.limiter["limit"]:
                     return []
 
-            # Dequeue functions eligible for this worker and ordered by the time at which they were enqueued.
-            # If there is a global or local concurrency limit N, select only the N oldest enqueued
-            # functions, else select all of them.
-
-            # First lets figure out how many tasks are eligible for dequeue.
-            # This means figuring out how many unstarted tasks are within the local and global concurrency limits
-            running_tasks_query = (
+            # Count how many workflows on this queue are currently PENDING both locally and globally.
+            pending_tasks_query = (
                 sa.select(
                     SystemSchema.workflow_status.c.executor_id,
                     sa.func.count().label("task_count"),
@@ -1742,41 +1725,37 @@ class SystemDatabase:
                 )
                 .where(SystemSchema.workflow_queue.c.queue_name == queue.name)
                 .where(
-                    SystemSchema.workflow_queue.c.started_at_epoch_ms.isnot(
-                        None
-                    )  # Task is started
-                )
-                .where(
-                    SystemSchema.workflow_queue.c.completed_at_epoch_ms.is_(
-                        None
-                    )  # Task is not completed.
+                    SystemSchema.workflow_status.c.status
+                    == WorkflowStatusString.PENDING.value
                 )
                 .group_by(SystemSchema.workflow_status.c.executor_id)
             )
-            running_tasks_result = c.execute(running_tasks_query).fetchall()
-            running_tasks_result_dict = {row[0]: row[1] for row in running_tasks_result}
-            running_tasks_for_this_worker = running_tasks_result_dict.get(
-                executor_id, 0
-            )  # Get count for current executor
+            pending_workflows = c.execute(pending_tasks_query).fetchall()
+            pending_workflows_dict = {row[0]: row[1] for row in pending_workflows}
+            local_pending_workflows = pending_workflows_dict.get(executor_id, 0)
 
+            # Compute max_tasks, the number of workflows that can be dequeued given local and global concurrency limits,
             max_tasks = float("inf")
             if queue.worker_concurrency is not None:
-                max_tasks = max(
-                    0, queue.worker_concurrency - running_tasks_for_this_worker
-                )
+                # Print a warning if the local concurrency limit is violated
+                if local_pending_workflows > queue.worker_concurrency:
+                    dbos_logger.warning(
+                        f"The number of local pending workflows ({local_pending_workflows}) on queue {queue.name} exceeds the local concurrency limit ({queue.worker_concurrency})"
+                    )
+                max_tasks = max(0, queue.worker_concurrency - local_pending_workflows)
+
             if queue.concurrency is not None:
-                total_running_tasks = sum(running_tasks_result_dict.values())
-                # Queue global concurrency limit should always be >= running_tasks_count
-                # This should never happen but a check + warning doesn't hurt
-                if total_running_tasks > queue.concurrency:
+                global_pending_workflows = sum(pending_workflows_dict.values())
+                # Print a warning if the global concurrency limit is violated
+                if global_pending_workflows > queue.concurrency:
                     dbos_logger.warning(
-                        f"Total running tasks ({total_running_tasks}) exceeds the global concurrency limit ({queue.concurrency})"
+                        f"The total number of pending workflows ({global_pending_workflows}) on queue {queue.name} exceeds the global concurrency limit ({queue.concurrency})"
                     )
-                available_tasks = max(0, queue.concurrency - total_running_tasks)
+                available_tasks = max(0, queue.concurrency - global_pending_workflows)
                 max_tasks = min(max_tasks, available_tasks)
 
             # Retrieve the first max_tasks workflows in the queue.
-            # Only retrieve workflows of the appropriate version (or without version set)
+            # Only retrieve workflows of the local version (or without version set)
             query = (
                 sa.select(
                     SystemSchema.workflow_queue.c.workflow_uuid,
@@ -1789,8 +1768,10 @@ class SystemDatabase:
                     )
                 )
                 .where(SystemSchema.workflow_queue.c.queue_name == queue.name)
-                .where(SystemSchema.workflow_queue.c.started_at_epoch_ms == None)
-                .where(SystemSchema.workflow_queue.c.completed_at_epoch_ms == None)
+                .where(
+                    SystemSchema.workflow_status.c.status
+                    == WorkflowStatusString.ENQUEUED.value
+                )
                 .where(
                     sa.or_(
                         SystemSchema.workflow_status.c.application_version
@@ -1819,20 +1800,16 @@ class SystemDatabase:
             ret_ids: list[str] = []
 
             for id in dequeued_ids:
-                # If we have a limiter, stop starting functions when the number
-                # of functions started this period exceeds the limit.
+                # If we have a limiter, stop dequeueing workflows when the number
+                # of workflows started this period exceeds the limit.
                 if queue.limiter is not None:
                     if len(ret_ids) + num_recent_queries >= queue.limiter["limit"]:
                         break
 
-                # To start a function, first set its status to PENDING and update its executor ID
-                res = c.execute(
+                # To start a workflow, first set its status to PENDING and update its executor ID
+                c.execute(
                     SystemSchema.workflow_status.update()
                     .where(SystemSchema.workflow_status.c.workflow_uuid == id)
-                    .where(
-                        SystemSchema.workflow_status.c.status
-                        == WorkflowStatusString.ENQUEUED.value
-                    )
                     .values(
                         status=WorkflowStatusString.PENDING.value,
                         application_version=app_version,
@@ -1855,16 +1832,15 @@ class SystemDatabase:
                         ),
                     )
                 )
-                if res.rowcount > 0:
-                    # Then give it a start time and assign the executor ID
-                    c.execute(
-                        SystemSchema.workflow_queue.update()
-                        .where(SystemSchema.workflow_queue.c.workflow_uuid == id)
-                        .values(started_at_epoch_ms=start_time_ms)
-                    )
-                    ret_ids.append(id)
+                # Then give it a start time
+                c.execute(
+                    SystemSchema.workflow_queue.update()
+                    .where(SystemSchema.workflow_queue.c.workflow_uuid == id)
+                    .values(started_at_epoch_ms=start_time_ms)
+                )
+                ret_ids.append(id)
 
-            # If we have a limiter, garbage-collect all completed functions started
+            # If we have a limiter, garbage-collect all completed workflows started
             # before the period. If there's no limiter, there's no need--they were
             # deleted on completion.
             if queue.limiter is not None:

{dbos-1.1.0a4 → dbos-1.2.0a4}/dbos/_workflow_commands.py

@@ -103,16 +103,7 @@ def fork_workflow(
     *,
     application_version: Optional[str],
 ) -> str:
-    def get_max_function_id(workflow_uuid: str) -> int:
-        max_transactions = app_db.get_max_function_id(workflow_uuid) or 0
-        max_operations = sys_db.get_max_function_id(workflow_uuid) or 0
-        return max(max_transactions, max_operations)
-
-    max_function_id = get_max_function_id(workflow_id)
-    if max_function_id > 0 and start_step > max_function_id:
-        raise DBOSException(
-            f"Cannot fork workflow {workflow_id} from step {start_step}. The workflow has {max_function_id} steps."
-        )
+
     ctx = get_local_dbos_context()
     if ctx is not None and len(ctx.id_assigned_for_next_workflow) > 0:
         forked_workflow_id = ctx.id_assigned_for_next_workflow

{dbos-1.1.0a4 → dbos-1.2.0a4}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "1.1.0a4"
+version = "1.2.0a4"
 
 [project.license]
 text = "MIT"

{dbos-1.1.0a4 → dbos-1.2.0a4}/tests/test_admin_server.py

@@ -11,7 +11,14 @@ import sqlalchemy as sa
 from requests.exceptions import ConnectionError
 
 # Public API
-from dbos import DBOS, DBOSConfig, Queue, SetWorkflowID, _workflow_commands
+from dbos import (
+    DBOS,
+    DBOSConfig,
+    Queue,
+    SetWorkflowID,
+    WorkflowHandle,
+    _workflow_commands,
+)
 from dbos._error import DBOSWorkflowCancelledError
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import SystemDatabase, WorkflowStatusString
@@ -425,4 +432,24 @@ def test_admin_workflow_fork(dbos: DBOS, sys_db: SystemDatabase) -> None:
         time.sleep(1)
         count += 1
 
+    # test for new_workflow_id and app version
+
+    new_version = "my_new_version"
+    GlobalParams.app_version = new_version
+
+    response = requests.post(
+        f"http://localhost:3001/workflows/{wfUuid}/fork",
+        json={"new_workflow_id": "123456", "application_version": new_version},
+        timeout=5,
+    )
+    assert response.status_code == 200
+
+    new_workflow_id = response.json().get("workflow_id")
+    assert new_workflow_id == "123456", "Expected new workflow ID is not 123456"
+
+    handle: WorkflowHandle[None] = dbos.retrieve_workflow(new_workflow_id)
+    assert (
+        handle.get_status().app_version == new_version
+    ), f"Expected application version to be {new_version}, but got {handle.get_status().app_version}"
+
     assert worked, "Workflow did not finish successfully"

{dbos-1.1.0a4 → dbos-1.2.0a4}/tests/test_async.py

@@ -1,7 +1,7 @@
 import asyncio
 import time
 import uuid
-from typing import Optional
+from typing import List, Optional
 
 import pytest
 import sqlalchemy as sa
@@ -523,3 +523,44 @@ async def test_workflow_timeout_async(dbos: DBOS) -> None:
     with pytest.raises(Exception) as exc_info:
         await (await DBOS.retrieve_workflow_async(direct_child)).get_result()
     assert "was cancelled" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_max_parallel_workflows(dbos: DBOS) -> None:
+    queue = Queue("parallel_queue")
+
+    @DBOS.workflow()
+    async def test_workflow(i: int) -> int:
+        await DBOS.sleep_async(5)
+        return i
+
+    begin_time = time.time()
+
+    tasks: List[WorkflowHandleAsync[int]] = []
+    for i in range(50):
+        tasks.append(await DBOS.start_workflow_async(test_workflow, i))
+
+    # Wait for all tasks to complete
+    for i in range(50):
+        assert (await tasks[i].get_result()) == i, f"Task {i} should return {i}"
+
+    end_time = time.time()
+    assert (
+        end_time - begin_time < 10
+    ), "All tasks should complete in less than 10 seconds"
+
+    # Test enqueues
+    begin_time = time.time()
+    tasks = []
+
+    for i in range(50):
+        tasks.append(await queue.enqueue_async(test_workflow, i))
+
+    # Wait for all tasks to complete
+    for i in range(50):
+        assert (await tasks[i].get_result()) == i, f"Task {i} should return {i}"
+
+    end_time = time.time()
+    assert (
+        end_time - begin_time < 10
+    ), "All enqueued tasks should complete in less than 10 seconds"

{dbos-1.1.0a4 → dbos-1.2.0a4}/tests/test_config.py

@@ -14,7 +14,6 @@ from dbos import DBOS
 from dbos._dbos_config import (
     ConfigFile,
     DBOSConfig,
-    check_config_consistency,
     configure_db_engine_parameters,
     load_config,
     overwrite_config,
@@ -1096,41 +1095,6 @@ def test_overwrite_config_missing_dbos_database_url(mocker):
     )
 
 
-####################
-# PROVIDED CONFIGS vs CONFIG FILE
-####################
-
-
-def test_no_discrepancy(mocker):
-    mock_config = """
-    name: "stock-prices" \
-    """
-    mocker.patch(
-        "builtins.open", side_effect=generate_mock_open("dbos-config.yaml", mock_config)
-    )
-    check_config_consistency(name="stock-prices")
-
-
-def test_name_does_no_match(mocker):
-    mock_config = """
-    name: "stock-prices" \
-    """
-    mocker.patch(
-        "builtins.open", side_effect=generate_mock_open("dbos-config.yaml", mock_config)
-    )
-    with pytest.raises(DBOSInitializationError) as exc_info:
-        check_config_consistency(name="stock-prices-wrong")
-    assert (
-        "Provided app name 'stock-prices-wrong' does not match the app name 'stock-prices' in dbos-config.yaml"
-        in str(exc_info.value)
-    )
-
-
-def test_no_config_file():
-    # Handles FileNotFoundError
-    check_config_consistency(name="stock-prices")
-
-
 ####################
 # DATABASES CONNECTION POOLS
 ####################

{dbos-1.1.0a4 → dbos-1.2.0a4}/tests/test_workflow_management.py

@@ -482,17 +482,6 @@ def test_restart_fromsteps_steps_tr(
     assert stepFourCount == 2
     assert trFiveCount == 3
 
-    # invalid step
-    try:
-        forked_handle = DBOS.fork_workflow(wfid, 7)
-        assert forked_handle.workflow_id != wfid
-        forked_handle.get_result()
-    except Exception as e:
-        print(f"Exception: {e}")
-        assert isinstance(e, DBOSException)
-        assert "Cannot fork workflow" in str(e)
-        assert trOneCount == 1
-
     # invalid < 1 will default to 1
     forked_handle = DBOS.fork_workflow(wfid, -1)
     assert forked_handle.workflow_id != wfid