dbos 1.1.0a3__tar.gz → 1.2.0a2__tar.gz

{dbos-1.1.0a3 → dbos-1.2.0a2}/PKG-INFO

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

{dbos-1.1.0a3 → dbos-1.2.0a2}/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.0a3 → dbos-1.2.0a2}/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.0a3 → dbos-1.2.0a2}/dbos/_context.py

@@ -392,6 +392,7 @@ class SetWorkflowTimeout:
             else None
         )
         self.saved_workflow_timeout: Optional[int] = None
+        self.saved_workflow_deadline_epoch_ms: Optional[int] = None
 
     def __enter__(self) -> SetWorkflowTimeout:
         # Code to create a basic context
@@ -402,6 +403,8 @@ class SetWorkflowTimeout:
         ctx = assert_current_dbos_context()
         self.saved_workflow_timeout = ctx.workflow_timeout_ms
         ctx.workflow_timeout_ms = self.workflow_timeout_ms
+        self.saved_workflow_deadline_epoch_ms = ctx.workflow_deadline_epoch_ms
+        ctx.workflow_deadline_epoch_ms = None
         return self
 
     def __exit__(
@@ -411,6 +414,9 @@ class SetWorkflowTimeout:
         traceback: Optional[TracebackType],
     ) -> Literal[False]:
         assert_current_dbos_context().workflow_timeout_ms = self.saved_workflow_timeout
+        assert_current_dbos_context().workflow_deadline_epoch_ms = (
+            self.saved_workflow_deadline_epoch_ms
+        )
         # Code to clean up the basic context if we created it
         if self.created_ctx:
             _clear_local_dbos_context()

{dbos-1.1.0a3 → dbos-1.2.0a2}/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.0a3 → dbos-1.2.0a2}/dbos/_dbos.py

@@ -299,6 +299,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()
@@ -719,6 +720,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 +738,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 +760,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 +779,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 +802,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 +841,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 +876,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 +909,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 +938,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.0a3 → dbos-1.2.0a2}/dbos/_error.py

@@ -62,6 +62,7 @@ class DBOSErrorCode(Enum):
     WorkflowCancelled = 10
     UnexpectedStep = 11
     QueueDeduplicated = 12
+    AwaitedWorkflowCancelled = 13
     ConflictingRegistrationError = 25
 
 
@@ -206,6 +207,19 @@ class DBOSQueueDeduplicatedError(DBOSException):
         )
 
 
+class DBOSAwaitedWorkflowCancelledError(DBOSException):
+    def __init__(self, workflow_id: str):
+        self.workflow_id = workflow_id
+        super().__init__(
+            f"Awaited workflow {workflow_id} was cancelled",
+            dbos_error_code=DBOSErrorCode.AwaitedWorkflowCancelled.value,
+        )
+
+    def __reduce__(self) -> Any:
+        # Tell jsonpickle how to reconstruct this object
+        return (self.__class__, (self.workflow_id,))
+
+
 #######################################
 ## BaseException
 #######################################

{dbos-1.1.0a3 → dbos-1.2.0a2}/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.0a3 → dbos-1.2.0a2}/dbos/_sys_db.py

@@ -32,6 +32,7 @@ from dbos._utils import INTERNAL_QUEUE_NAME
 from . import _serialization
 from ._context import get_local_dbos_context
 from ._error import (
+    DBOSAwaitedWorkflowCancelledError,
     DBOSConflictingWorkflowError,
     DBOSDeadLetterQueueError,
     DBOSNonExistentWorkflowError,
@@ -96,6 +97,10 @@ class WorkflowStatus:
     executor_id: Optional[str]
     # The application version on which this workflow was started
     app_version: Optional[str]
+    # The start-to-close timeout of the workflow in ms
+    workflow_timeout_ms: Optional[int]
+    # The deadline of a workflow, computed by adding its timeout to its start time.
+    workflow_deadline_epoch_ms: Optional[int]
 
     # INTERNAL FIELDS
 
@@ -596,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,
@@ -761,9 +754,9 @@ class SystemDatabase:
                         error = row[2]
                         raise _serialization.deserialize_exception(error)
                     elif status == WorkflowStatusString.CANCELLED.value:
-                        # Raise a normal exception here, not the cancellation exception
+                        # Raise AwaitedWorkflowCancelledError here, not the cancellation exception
                         # because the awaiting workflow is not being cancelled.
-                        raise Exception(f"Awaited workflow {workflow_id} was cancelled")
+                        raise DBOSAwaitedWorkflowCancelledError(workflow_id)
                 else:
                     pass  # CB: I guess we're assuming the WF will show up eventually.
             time.sleep(1)
@@ -837,6 +830,8 @@ class SystemDatabase:
             SystemSchema.workflow_inputs.c.inputs,
             SystemSchema.workflow_status.c.output,
             SystemSchema.workflow_status.c.error,
+            SystemSchema.workflow_status.c.workflow_deadline_epoch_ms,
+            SystemSchema.workflow_status.c.workflow_timeout_ms,
         ).join(
             SystemSchema.workflow_inputs,
             SystemSchema.workflow_status.c.workflow_uuid
@@ -918,6 +913,8 @@ class SystemDatabase:
             info.input = inputs
             info.output = output
             info.error = exception
+            info.workflow_deadline_epoch_ms = row[18]
+            info.workflow_timeout_ms = row[19]
 
             infos.append(info)
         return infos
@@ -947,6 +944,8 @@ class SystemDatabase:
             SystemSchema.workflow_inputs.c.inputs,
             SystemSchema.workflow_status.c.output,
             SystemSchema.workflow_status.c.error,
+            SystemSchema.workflow_status.c.workflow_deadline_epoch_ms,
+            SystemSchema.workflow_status.c.workflow_timeout_ms,
         ).select_from(
             SystemSchema.workflow_queue.join(
                 SystemSchema.workflow_status,
@@ -1024,6 +1023,8 @@ class SystemDatabase:
             info.input = inputs
             info.output = output
             info.error = exception
+            info.workflow_deadline_epoch_ms = row[18]
+            info.workflow_timeout_ms = row[19]
 
             infos.append(info)
 
@@ -1827,8 +1828,13 @@ class SystemDatabase:
                         # If a timeout is set, set the deadline on dequeue
                         workflow_deadline_epoch_ms=sa.case(
                             (
-                                SystemSchema.workflow_status.c.workflow_timeout_ms.isnot(
-                                    None
+                                sa.and_(
+                                    SystemSchema.workflow_status.c.workflow_timeout_ms.isnot(
+                                        None
+                                    ),
+                                    SystemSchema.workflow_status.c.workflow_deadline_epoch_ms.is_(
+                                        None
+                                    ),
                                 ),
                                 sa.func.extract("epoch", sa.func.now()) * 1000
                                 + SystemSchema.workflow_status.c.workflow_timeout_ms,

{dbos-1.1.0a3 → dbos-1.2.0a2}/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.0a3 → dbos-1.2.0a2}/pyproject.toml

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

{dbos-1.1.0a3 → dbos-1.2.0a2}/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.0a3 → dbos-1.2.0a2}/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.0a3 → dbos-1.2.0a2}/tests/test_dbos.py

@@ -24,6 +24,7 @@ from dbos import (
 # Private API because this is a test
 from dbos._context import assert_current_dbos_context, get_local_dbos_context
 from dbos._error import (
+    DBOSAwaitedWorkflowCancelledError,
     DBOSConflictingRegistrationError,
     DBOSMaxStepRetriesExceeded,
     DBOSWorkflowCancelledError,
@@ -1507,7 +1508,14 @@ def test_workflow_timeout(dbos: DBOS) -> None:
             with SetWorkflowID(wfid):
                 blocked_workflow()
         assert assert_current_dbos_context().workflow_deadline_epoch_ms is None
+        start_time = time.time() * 1000
         handle = DBOS.start_workflow(blocked_workflow)
+        status = handle.get_status()
+        assert status.workflow_timeout_ms == 100
+        assert (
+            status.workflow_deadline_epoch_ms is not None
+            and status.workflow_deadline_epoch_ms > start_time
+        )
         with pytest.raises(DBOSWorkflowCancelledError):
             handle.get_result()
 
@@ -1555,13 +1563,11 @@ def test_workflow_timeout(dbos: DBOS) -> None:
         with pytest.raises(DBOSWorkflowCancelledError):
             parent_workflow()
 
-    with pytest.raises(Exception) as exc_info:
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         DBOS.retrieve_workflow(start_child).get_result()
-    assert "was cancelled" in str(exc_info.value)
 
-    with pytest.raises(Exception) as exc_info:
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         DBOS.retrieve_workflow(direct_child).get_result()
-    assert "was cancelled" in str(exc_info.value)
 
     # Verify the context variables are set correctly
     with SetWorkflowTimeout(1.0):

{dbos-1.1.0a3 → dbos-1.2.0a2}/tests/test_failures.py

@@ -9,6 +9,7 @@ from sqlalchemy.exc import InvalidRequestError, OperationalError
 
 from dbos import DBOS, Queue, SetWorkflowID
 from dbos._error import (
+    DBOSAwaitedWorkflowCancelledError,
     DBOSDeadLetterQueueError,
     DBOSMaxStepRetriesExceeded,
     DBOSNotAuthorizedError,
@@ -461,6 +462,11 @@ def test_error_serialization() -> None:
     d = deserialize_exception(serialize_exception(e))
     assert isinstance(d, DBOSQueueDeduplicatedError)
     assert str(d) == str(e)
+    # AwaitedWorkflowCancelledError
+    e = DBOSAwaitedWorkflowCancelledError("id")
+    d = deserialize_exception(serialize_exception(e))
+    assert isinstance(d, DBOSAwaitedWorkflowCancelledError)
+    assert str(d) == str(e)
 
     # Test safe_deserialize
     class BadException(Exception):

{dbos-1.1.0a3 → dbos-1.2.0a2}/tests/test_queue.py

@@ -26,6 +26,7 @@ from dbos import (
 )
 from dbos._context import assert_current_dbos_context
 from dbos._dbos import WorkflowHandleAsync
+from dbos._error import DBOSAwaitedWorkflowCancelledError, DBOSWorkflowCancelledError
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import WorkflowStatusString
 from dbos._utils import GlobalParams
@@ -853,9 +854,8 @@ def test_cancelling_queued_workflows(dbos: DBOS) -> None:
 
     # Complete the blocked workflow
     blocking_event.set()
-    with pytest.raises(Exception) as exc_info:
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         blocked_handle.get_result()
-    assert "was cancelled" in str(exc_info.value)
 
     # Verify all queue entries eventually get cleaned up.
     assert queue_entries_are_cleaned_up(dbos)
@@ -891,9 +891,8 @@ def test_timeout_queue(dbos: DBOS) -> None:
 
     # Verify the blocked workflows are cancelled
     for handle in handles:
-        with pytest.raises(Exception) as exc_info:
+        with pytest.raises(DBOSAwaitedWorkflowCancelledError):
             handle.get_result()
-        assert "was cancelled" in str(exc_info.value)
 
     # Verify the normal workflow succeeds
     normal_handle.get_result()
@@ -911,17 +910,14 @@ def test_timeout_queue(dbos: DBOS) -> None:
 
     with SetWorkflowTimeout(1.0):
         handle = queue.enqueue(parent_workflow)
-    with pytest.raises(Exception) as exc_info:
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handle.get_result()
-    assert "was cancelled" in str(exc_info.value)
 
-    with pytest.raises(Exception) as exc_info:
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         DBOS.retrieve_workflow(child_id).get_result()
-    assert "was cancelled" in str(exc_info.value)
 
     # Verify if a parent called with a timeout enqueues a blocked child
     # then exits the deadline propagates and the child is cancelled.
-    child_id = str(uuid.uuid4())
     queue = Queue("regular_queue")
 
     @DBOS.workflow()
@@ -931,9 +927,41 @@ def test_timeout_queue(dbos: DBOS) -> None:
 
     with SetWorkflowTimeout(1.0):
         child_id = exiting_parent_workflow()
-    with pytest.raises(Exception) as exc_info:
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
+        DBOS.retrieve_workflow(child_id).get_result()
+
+    # Verify if a parent called with a timeout enqueues a child that
+    # never starts because the queue is blocked, the deadline propagates
+    # and both parent and child are cancelled.
+    child_id = str(uuid.uuid4())
+    queue = Queue("stuck_queue", concurrency=1)
+
+    start_event = threading.Event()
+    blocking_event = threading.Event()
+
+    @DBOS.workflow()
+    def stuck_workflow() -> None:
+        start_event.set()
+        blocking_event.wait()
+
+    stuck_handle = queue.enqueue(stuck_workflow)
+    start_event.wait()
+
+    @DBOS.workflow()
+    def blocked_parent_workflow() -> None:
+        with SetWorkflowID(child_id):
+            queue.enqueue(blocking_workflow)
+        while True:
+            DBOS.sleep(0.1)
+
+    with SetWorkflowTimeout(1.0):
+        handle = DBOS.start_workflow(blocked_parent_workflow)
+    with pytest.raises(DBOSWorkflowCancelledError):
+        handle.get_result()
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         DBOS.retrieve_workflow(child_id).get_result()
-    assert "was cancelled" in str(exc_info.value)
+    blocking_event.set()
+    stuck_handle.get_result()
 
     # Verify all queue entries eventually get cleaned up.
     assert queue_entries_are_cleaned_up(dbos)
@@ -1341,3 +1369,80 @@ def test_worker_concurrency_across_versions(dbos: DBOS, client: DBOSClient) -> N
     # Change the version, verify the other version complets
     GlobalParams.app_version = other_version
     assert other_version_handle.get_result()
+
+
+def test_timeout_queue_recovery(dbos: DBOS) -> None:
+    queue = Queue("test_queue")
+    evt = threading.Event()
+
+    @DBOS.workflow()
+    def blocking_workflow() -> None:
+        evt.set()
+        while True:
+            DBOS.sleep(0.1)
+
+    timeout = 3.0
+    enqueue_time = time.time()
+    with SetWorkflowTimeout(timeout):
+        original_handle = queue.enqueue(blocking_workflow)
+
+    # Verify the workflow's timeout is properly configured
+    evt.wait()
+    original_status = original_handle.get_status()
+    assert original_status.workflow_timeout_ms == timeout * 1000
+    assert (
+        original_status.workflow_deadline_epoch_ms is not None
+        and original_status.workflow_deadline_epoch_ms > enqueue_time * 1000
+    )
+
+    # Recover the workflow. Verify its deadline remains the same
+    evt.clear()
+    handles = DBOS._recover_pending_workflows()
+    assert len(handles) == 1
+    evt.wait()
+    recovered_handle = handles[0]
+    recovered_status = recovered_handle.get_status()
+    assert recovered_status.workflow_timeout_ms == timeout * 1000
+    assert (
+        recovered_status.workflow_deadline_epoch_ms
+        == original_status.workflow_deadline_epoch_ms
+    )
+
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
+        original_handle.get_result()
+
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
+        recovered_handle.get_result()
+
+
+def test_unsetting_timeout(dbos: DBOS) -> None:
+
+    queue = Queue("test_queue")
+
+    @DBOS.workflow()
+    def child() -> str:
+        for _ in range(5):
+            DBOS.sleep(1)
+        return DBOS.workflow_id
+
+    @DBOS.workflow()
+    def parent(child_one: str, child_two: str) -> None:
+        with SetWorkflowID(child_two):
+            with SetWorkflowTimeout(None):
+                queue.enqueue(child)
+
+        with SetWorkflowID(child_one):
+            queue.enqueue(child)
+
+    child_one, child_two = str(uuid.uuid4()), str(uuid.uuid4())
+    with SetWorkflowTimeout(1.0):
+        queue.enqueue(parent, child_one, child_two).get_result()
+
+    # Verify child one, which has a propagated timeout, is cancelled
+    handle: WorkflowHandle[str] = DBOS.retrieve_workflow(child_one)
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
+        handle.get_result()
+
+    # Verify child two, which doesn't have a timeout, succeeds
+    handle = DBOS.retrieve_workflow(child_two)
+    assert handle.get_result() == child_two

{dbos-1.1.0a3 → dbos-1.2.0a2}/tests/test_workflow_introspection.py

@@ -41,6 +41,8 @@ def test_list_workflow(dbos: DBOS) -> None:
     assert output.app_version == GlobalParams.app_version
     assert output.app_id == ""
     assert output.recovery_attempts == 1
+    assert output.workflow_timeout_ms is None
+    assert output.workflow_deadline_epoch_ms is None
 
     # Test searching by status
     outputs = DBOS.list_workflows(status="PENDING")
@@ -222,6 +224,8 @@ def test_queued_workflows(dbos: DBOS) -> None:
         assert workflow.created_at is not None and workflow.created_at > 0
         assert workflow.updated_at is not None and workflow.updated_at > 0
         assert workflow.recovery_attempts == 1
+        assert workflow.workflow_timeout_ms is None
+        assert workflow.workflow_deadline_epoch_ms is None
 
     # Test sort_desc inverts the order
     workflows = DBOS.list_queued_workflows(sort_desc=True)

{dbos-1.1.0a3 → dbos-1.2.0a2}/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