dbos 1.8.0a8__tar.gz → 1.9.0__tar.gz

{dbos-1.8.0a8 → dbos-1.9.0}/PKG-INFO

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

{dbos-1.8.0a8 → dbos-1.9.0}/dbos/_core.py

@@ -49,6 +49,7 @@ from ._context import (
     get_local_dbos_context,
 )
 from ._error import (
+    DBOSAwaitedWorkflowCancelledError,
     DBOSException,
     DBOSMaxStepRetriesExceeded,
     DBOSNonExistentWorkflowError,
@@ -370,7 +371,7 @@ def _get_wf_invoke_func(
             r: R = dbos._sys_db.await_workflow_result(status["workflow_uuid"])
             return r
         except DBOSWorkflowCancelledError as error:
-            raise
+            raise DBOSAwaitedWorkflowCancelledError(status["workflow_uuid"])
         except Exception as error:
             if not dbos.debug_mode:
                 dbos._sys_db.update_workflow_outcome(

{dbos-1.8.0a8 → dbos-1.9.0}/dbos/_dbos.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import atexit
 import hashlib
 import inspect
 import os
@@ -1219,39 +1218,40 @@ class DBOS:
         return rv
 
     @classproperty
-    def workflow_id(cls) -> str:
-        """Return the workflow ID for the current context, which must be executing a workflow function."""
-        ctx = assert_current_dbos_context()
-        assert (
-            ctx.is_within_workflow()
-        ), "workflow_id is only available within a DBOS operation."
-        return ctx.workflow_id
+    def workflow_id(cls) -> Optional[str]:
+        """Return the ID of the currently executing workflow. If a workflow is not executing, return None."""
+        ctx = get_local_dbos_context()
+        if ctx and ctx.is_within_workflow():
+            return ctx.workflow_id
+        else:
+            return None
 
     @classproperty
-    def step_id(cls) -> int:
-        """Return the step ID for the currently executing step. This is a unique identifier of the current step within the workflow."""
-        ctx = assert_current_dbos_context()
-        assert (
-            ctx.is_step() or ctx.is_transaction()
-        ), "step_id is only available within a DBOS step."
-        return ctx.function_id
+    def step_id(cls) -> Optional[int]:
+        """Return the step ID for the currently executing step. This is a unique identifier of the current step within the workflow. If a step is not currently executing, return None."""
+        ctx = get_local_dbos_context()
+        if ctx and (ctx.is_step() or ctx.is_transaction()):
+            return ctx.function_id
+        else:
+            return None
 
     @classproperty
-    def step_status(cls) -> StepStatus:
-        """Return the status of the currently executing step."""
-        ctx = assert_current_dbos_context()
-        assert ctx.is_step(), "step_status is only available within a DBOS step."
-        assert ctx.step_status is not None
-        return ctx.step_status
+    def step_status(cls) -> Optional[StepStatus]:
+        """Return the status of the currently executing step. If a step is not currently executing, return None."""
+        ctx = get_local_dbos_context()
+        if ctx and ctx.is_step():
+            return ctx.step_status
+        else:
+            return None
 
     @classproperty
     def parent_workflow_id(cls) -> str:
         """
-        Return the workflow ID for the parent workflow.
-
-        `parent_workflow_id` must be accessed from within a workflow function.
+        This method is deprecated and should not be used.
         """
-
+        dbos_logger.warning(
+            "DBOS.parent_workflow_id is deprecated and should not be used"
+        )
         ctx = assert_current_dbos_context()
         assert (
             ctx.is_within_workflow()

{dbos-1.8.0a8 → dbos-1.9.0}/dbos/cli/cli.py

@@ -10,7 +10,7 @@ from typing import Any, Optional
 import jsonpickle  # type: ignore
 import sqlalchemy as sa
 import typer
-from rich import print
+from rich import print as richprint
 from rich.prompt import IntPrompt
 from typing_extensions import Annotated, List
 
@@ -196,7 +196,7 @@ def init(
                 path.join(templates_dir, template), project_name, config_mode=config
             )
     except Exception as e:
-        print(f"[red]{e}[/red]")
+        richprint(f"[red]{e}[/red]")
 
 
 def _resolve_project_name_and_template(
@@ -217,9 +217,9 @@ def _resolve_project_name_and_template(
         if template not in templates:
             raise Exception(f"Template {template} not found in {templates_dir}")
     else:
-        print("\n[bold]Available templates:[/bold]")
+        richprint("\n[bold]Available templates:[/bold]")
         for idx, template_name in enumerate(templates, 1):
-            print(f"  {idx}. {template_name}")
+            richprint(f"  {idx}. {template_name}")
         while True:
             try:
                 choice = IntPrompt.ask(
@@ -231,13 +231,13 @@ def _resolve_project_name_and_template(
                     template = templates[choice - 1]
                     break
                 else:
-                    print(
+                    richprint(
                         "[red]Invalid selection. Please choose a number from the list.[/red]"
                     )
             except (KeyboardInterrupt, EOFError):
                 raise typer.Abort()
             except ValueError:
-                print("[red]Please enter a valid number.[/red]")
+                richprint("[red]Please enter a valid number.[/red]")
 
     if template in git_templates:
         if project_name is None:

{dbos-1.8.0a8 → dbos-1.9.0}/pyproject.toml

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

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_admin_server.py

@@ -20,7 +20,7 @@ from dbos import (
     WorkflowHandle,
     _workflow_commands,
 )
-from dbos._error import DBOSWorkflowCancelledError
+from dbos._error import DBOSAwaitedWorkflowCancelledError
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import SystemDatabase, WorkflowStatusString
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
@@ -142,7 +142,6 @@ def test_admin_recovery(config: DBOSConfig) -> None:
 
     @DBOS.workflow()
     def test_workflow(var: str, var2: str) -> str:
-        DBOS.logger.info("WFID: " + DBOS.workflow_id)
         nonlocal wf_counter
         wf_counter += 1
         res = test_step(var2)
@@ -307,7 +306,7 @@ def test_admin_workflow_resume(dbos: DBOS, sys_db: SystemDatabase) -> None:
     )
     assert response.status_code == 204
     event.set()
-    with pytest.raises(DBOSWorkflowCancelledError):
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handle.get_result()
     info = _workflow_commands.get_workflow(sys_db, wfid)
     assert info is not None
@@ -464,7 +463,9 @@ def test_list_workflows(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     def test_workflow_2(my_time: datetime) -> str:
-        return DBOS.workflow_id + " completed at " + my_time.isoformat()
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id + " completed at " + my_time.isoformat()
 
     # Start workflows
     handle_1 = DBOS.start_workflow(test_workflow_1)
@@ -656,7 +657,9 @@ def test_get_workflow_by_id(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     def test_workflow_2(my_time: datetime) -> str:
-        return DBOS.workflow_id + " completed at " + my_time.isoformat()
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id + " completed at " + my_time.isoformat()
 
     # Start workflows
     handle_1 = DBOS.start_workflow(test_workflow_1)
@@ -713,7 +716,9 @@ def test_admin_garbage_collect(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     def workflow() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     workflow()
 
@@ -745,7 +750,7 @@ def test_admin_global_timeout(dbos: DBOS) -> None:
         timeout=5,
     )
     response.raise_for_status()
-    with pytest.raises(DBOSWorkflowCancelledError):
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handle.get_result()
 
 

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_async.py

@@ -18,7 +18,7 @@ from dbos import (
 from dbos._context import assert_current_dbos_context
 from dbos._dbos import WorkflowHandle
 from dbos._dbos_config import ConfigFile
-from dbos._error import DBOSException, DBOSWorkflowCancelledError
+from dbos._error import DBOSAwaitedWorkflowCancelledError, DBOSException
 
 
 @pytest.mark.asyncio
@@ -302,7 +302,9 @@ async def test_sleep(dbos: DBOS) -> None:
     @DBOS.workflow()
     async def test_sleep_workflow(secs: float) -> str:
         await dbos.sleep_async(secs)
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     start_time = time.time()
     sleep_uuid = await test_sleep_workflow(1.5)
@@ -490,20 +492,20 @@ async def test_workflow_timeout_async(dbos: DBOS) -> None:
             DBOS.sleep(0.1)
 
     with SetWorkflowTimeout(0.1):
-        with pytest.raises(DBOSWorkflowCancelledError):
+        with pytest.raises(DBOSAwaitedWorkflowCancelledError):
             await blocked_workflow()
         handle = await DBOS.start_workflow_async(blocked_workflow)
-        with pytest.raises(DBOSWorkflowCancelledError):
+        with pytest.raises(DBOSAwaitedWorkflowCancelledError):
             await handle.get_result()
 
     @DBOS.workflow()
     async def parent_workflow_with_timeout() -> None:
         assert assert_current_dbos_context().workflow_deadline_epoch_ms is None
         with SetWorkflowTimeout(0.1):
-            with pytest.raises(DBOSWorkflowCancelledError):
+            with pytest.raises(DBOSAwaitedWorkflowCancelledError):
                 await blocked_workflow()
             handle = await DBOS.start_workflow_async(blocked_workflow)
-            with pytest.raises(DBOSWorkflowCancelledError):
+            with pytest.raises(DBOSAwaitedWorkflowCancelledError):
                 await handle.get_result()
         assert assert_current_dbos_context().workflow_deadline_epoch_ms is None
 
@@ -524,7 +526,7 @@ async def test_workflow_timeout_async(dbos: DBOS) -> None:
     # Verify if a parent called with a timeout calls a blocked child
     # the deadline propagates and the children are also cancelled.
     with SetWorkflowTimeout(1.0):
-        with pytest.raises(DBOSWorkflowCancelledError):
+        with pytest.raises(DBOSAwaitedWorkflowCancelledError):
             await parent_workflow()
 
     with pytest.raises(Exception) as exc_info:

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_async_workflow_management.py

@@ -7,7 +7,7 @@ from typing import List
 import pytest
 
 from dbos import DBOS, Queue, SetWorkflowID
-from dbos._error import DBOSWorkflowCancelledError
+from dbos._error import DBOSAwaitedWorkflowCancelledError
 from dbos._sys_db import StepInfo, WorkflowStatus
 from tests.conftest import queue_entries_are_cleaned_up
 
@@ -46,7 +46,7 @@ async def test_cancel_workflow_async(dbos: DBOS) -> None:
     await DBOS.cancel_workflow_async(wfid)
     workflow_event.set()
 
-    with pytest.raises(DBOSWorkflowCancelledError):
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handle.get_result()
     assert steps_completed == 1
 
@@ -85,7 +85,7 @@ async def test_resume_workflow_async(dbos: DBOS) -> None:
     DBOS.cancel_workflow(wfid)
     workflow_event.set()
 
-    with pytest.raises(DBOSWorkflowCancelledError):
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handle.get_result()
     assert steps_completed == 1
 

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_classdecorators.py

@@ -911,3 +911,30 @@ def test_class_step_without_dbos(dbos: DBOS, config: DBOSConfig) -> None:
     DBOS.launch()
 
     assert inst.step(input) == input + input
+
+
+def test_class_with_only_steps(dbos: DBOS) -> None:
+
+    class StepClass:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+        @DBOS.step()
+        def step(self, x: int, expr: Callable[[int, int], int]) -> int:
+            return expr(self.x, x)
+
+    input = 5
+    inst = StepClass(5)
+
+    l = lambda x, y: x + y
+
+    @DBOS.workflow()
+    def test_workflow() -> int:
+        return inst.step(input, l) + inst.step(input, l)
+
+    handle = DBOS.start_workflow(test_workflow)
+    assert handle.get_result() == input * 4
+
+    steps = DBOS.list_workflow_steps(handle.workflow_id)
+    assert len(steps) == 2
+    assert steps[1]["output"] == steps[1]["output"] == input * 2

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_concurrency.py

@@ -14,7 +14,9 @@ def test_concurrent_workflows(dbos: DBOS) -> None:
     @DBOS.workflow()
     def test_workflow() -> str:
         time.sleep(1)
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     def test_thread(id: str) -> str:
         with SetWorkflowID(id):
@@ -48,7 +50,9 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
             condition.notify()
         condition.release()
 
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     @DBOS.workflow()
     def test_workflow() -> str:
@@ -74,7 +78,9 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
             condition.notify()
         condition.release()
 
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     def test_txn_thread(id: str) -> str:
         with SetWorkflowID(id):

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_dbos.py

@@ -28,7 +28,6 @@ from dbos._error import (
     DBOSAwaitedWorkflowCancelledError,
     DBOSConflictingRegistrationError,
     DBOSMaxStepRetriesExceeded,
-    DBOSWorkflowCancelledError,
 )
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import GetWorkflowsInput
@@ -61,9 +60,11 @@ def test_simple_workflow(dbos: DBOS) -> None:
     @DBOS.step()
     def test_step(var: str) -> str:
         assert DBOS.step_id == 2
-        assert DBOS.step_status.step_id == 2
-        assert DBOS.step_status.current_attempt is None
-        assert DBOS.step_status.max_attempts is None
+        step_status = DBOS.step_status
+        assert step_status is not None
+        assert step_status.step_id == 2
+        assert step_status.current_attempt is None
+        assert step_status.max_attempts is None
         nonlocal step_counter
         step_counter += 1
         DBOS.logger.info("I'm test_step " + var)
@@ -133,10 +134,6 @@ def test_child_workflow(dbos: DBOS) -> None:
     @DBOS.workflow()
     def test_workflow(var: str, var2: str) -> str:
         DBOS.logger.info("I'm test_workflow")
-        if len(DBOS.parent_workflow_id):
-            DBOS.logger.info("  This is a child test_workflow")
-            # Note this assertion is only true if child wasn't assigned an ID explicitly
-            assert DBOS.workflow_id.startswith(DBOS.parent_workflow_id)
         nonlocal wf_counter
         wf_counter += 1
         res = test_transaction(var2)
@@ -651,7 +648,9 @@ def test_retrieve_workflow(dbos: DBOS) -> None:
     @DBOS.workflow()
     def test_sleep_workflow(secs: float) -> str:
         dbos.sleep(secs)
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     @DBOS.workflow()
     def test_sleep_workthrow(secs: float) -> str:
@@ -732,7 +731,9 @@ def test_retrieve_workflow_in_workflow(dbos: DBOS) -> None:
     @DBOS.workflow()
     def test_sleep_workflow(secs: float) -> str:
         dbos.sleep(secs)
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     @DBOS.workflow()
     def test_workflow_status_a() -> str:
@@ -793,7 +794,9 @@ def test_sleep(dbos: DBOS) -> None:
     @DBOS.workflow()
     def test_sleep_workflow(secs: float) -> str:
         dbos.sleep(secs)
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     start_time = time.time()
     sleep_uuid = test_sleep_workflow(1.5)
@@ -1489,7 +1492,7 @@ def test_workflow_timeout(dbos: DBOS) -> None:
     # Verify a blocked workflow called with a timeout is cancelled
     wfid = str(uuid.uuid4())
     with SetWorkflowTimeout(0.1):
-        with pytest.raises(DBOSWorkflowCancelledError):
+        with pytest.raises(DBOSAwaitedWorkflowCancelledError):
             with SetWorkflowID(wfid):
                 blocked_workflow()
         assert assert_current_dbos_context().workflow_deadline_epoch_ms is None
@@ -1501,7 +1504,7 @@ def test_workflow_timeout(dbos: DBOS) -> None:
             status.workflow_deadline_epoch_ms is not None
             and status.workflow_deadline_epoch_ms > start_time
         )
-        with pytest.raises(DBOSWorkflowCancelledError):
+        with pytest.raises(DBOSAwaitedWorkflowCancelledError):
             handle.get_result()
 
     # Change the workflow status to pending
@@ -1514,17 +1517,17 @@ def test_workflow_timeout(dbos: DBOS) -> None:
     # Recover the workflow, verify it still times out
     handles = DBOS._recover_pending_workflows()
     assert len(handles) == 1
-    with pytest.raises(DBOSWorkflowCancelledError):
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handles[0].get_result()
 
     @DBOS.workflow()
     def parent_workflow_with_timeout() -> None:
         assert assert_current_dbos_context().workflow_deadline_epoch_ms is None
         with SetWorkflowTimeout(0.1):
-            with pytest.raises(DBOSWorkflowCancelledError):
+            with pytest.raises(DBOSAwaitedWorkflowCancelledError):
                 blocked_workflow()
             handle = DBOS.start_workflow(blocked_workflow)
-            with pytest.raises(DBOSWorkflowCancelledError):
+            with pytest.raises(DBOSAwaitedWorkflowCancelledError):
                 handle.get_result()
         assert assert_current_dbos_context().workflow_deadline_epoch_ms is None
 
@@ -1545,7 +1548,7 @@ def test_workflow_timeout(dbos: DBOS) -> None:
     # Verify if a parent called with a timeout calls a blocked child
     # the deadline propagates and the children are also cancelled.
     with SetWorkflowTimeout(1.0):
-        with pytest.raises(DBOSWorkflowCancelledError):
+        with pytest.raises(DBOSAwaitedWorkflowCancelledError):
             parent_workflow()
 
     with pytest.raises(DBOSAwaitedWorkflowCancelledError):
@@ -1573,7 +1576,9 @@ def test_custom_names(dbos: DBOS) -> None:
 
     @DBOS.workflow(name=workflow_name)
     def workflow() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     handle = queue.enqueue(workflow)
     assert handle.get_status().name == workflow_name
@@ -1581,7 +1586,9 @@ def test_custom_names(dbos: DBOS) -> None:
 
     @DBOS.step(name=step_name)
     def step() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     handle = queue.enqueue(step)
     assert handle.get_status().name == f"<temp>.{step_name}"
@@ -1589,7 +1596,9 @@ def test_custom_names(dbos: DBOS) -> None:
 
     @DBOS.transaction(name=txn_name)
     def txn() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     handle = queue.enqueue(txn)
     assert handle.get_status().name == f"<temp>.{txn_name}"
@@ -1614,12 +1623,22 @@ def test_custom_names(dbos: DBOS) -> None:
 async def test_step_without_dbos(dbos: DBOS, config: DBOSConfig) -> None:
     DBOS.destroy(destroy_registry=True)
 
+    is_dbos_active = False
+
     @DBOS.step()
     def step(x: int) -> int:
+        if is_dbos_active:
+            assert DBOS.workflow_id is not None
+        else:
+            assert DBOS.workflow_id is None
         return x
 
     @DBOS.step()
     async def async_step(x: int) -> int:
+        if is_dbos_active:
+            assert DBOS.workflow_id is not None
+        else:
+            assert DBOS.workflow_id is None
         return x
 
     assert step(5) == 5
@@ -1631,6 +1650,7 @@ async def test_step_without_dbos(dbos: DBOS, config: DBOSConfig) -> None:
     assert await async_step(5) == 5
 
     DBOS.launch()
+    is_dbos_active = True
 
     assert step(5) == 5
     assert await async_step(5) == 5

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_failures.py

@@ -382,9 +382,11 @@ def test_step_status(dbos: DBOS) -> None:
     @DBOS.step(retries_allowed=True, interval_seconds=0, max_attempts=max_attempts)
     def failing_step() -> None:
         nonlocal step_counter
-        assert DBOS.step_status.step_id == 1
-        assert DBOS.step_status.current_attempt == step_counter
-        assert DBOS.step_status.max_attempts == max_attempts
+        step_status = DBOS.step_status
+        assert step_status is not None
+        assert step_status.step_id == 1
+        assert step_status.current_attempt == step_counter
+        assert step_status.max_attempts == max_attempts
         step_counter += 1
         if step_counter < max_attempts:
             raise Exception("fail")
@@ -442,7 +444,9 @@ def test_keyboardinterrupt_during_retries(dbos: DBOS) -> None:
     @DBOS.workflow()
     def failing_workflow() -> str:
         failing_step()
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     with pytest.raises(KeyboardInterrupt):
         failing_workflow()

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_fastapi.py

@@ -112,7 +112,9 @@ def test_endpoint_recovery(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
 
     @DBOS.workflow()
     def test_workflow(var1: str) -> tuple[str, str]:
-        return var1, DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return var1, workflow_id
 
     @app.get("/{var1}/{var2}")
     def test_endpoint(var1: str, var2: str) -> dict[str, str]:

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_flask.py

@@ -72,7 +72,9 @@ def test_endpoint_recovery(dbos_flask: Tuple[DBOS, Flask]) -> None:
 
     @DBOS.workflow()
     def test_workflow(var1: str) -> tuple[str, str]:
-        return var1, DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return var1, workflow_id
 
     @app.route("/<var1>/<var2>")
     def test_endpoint(var1: str, var2: str) -> dict[str, str]:

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_queue.py

@@ -1,5 +1,4 @@
 import asyncio
-import logging
 import multiprocessing
 import multiprocessing.synchronize
 import os
@@ -27,7 +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._error import DBOSAwaitedWorkflowCancelledError
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import WorkflowStatusString
 from dbos._utils import GlobalParams
@@ -943,7 +942,7 @@ def test_timeout_queue(dbos: DBOS) -> None:
 
     with SetWorkflowTimeout(1.0):
         handle = DBOS.start_workflow(blocked_parent_workflow)
-    with pytest.raises(DBOSWorkflowCancelledError):
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handle.get_result()
     with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         DBOS.retrieve_workflow(child_id).get_result()
@@ -1343,7 +1342,9 @@ def test_worker_concurrency_across_versions(dbos: DBOS, client: DBOSClient) -> N
 
     @DBOS.workflow()
     def test_workflow() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     # First enqueue a workflow on the other version, then on the current version
     other_version = "other_version"
@@ -1417,7 +1418,9 @@ def test_unsetting_timeout(dbos: DBOS) -> None:
     def child() -> str:
         for _ in range(5):
             DBOS.sleep(1)
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     @DBOS.workflow()
     def parent(child_one: str, child_two: str) -> None:
@@ -1448,7 +1451,9 @@ def test_queue_executor_id(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     def example_workflow() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     # Set an executor ID
     original_executor_id = str(uuid.uuid4())

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_scheduler.py

@@ -195,7 +195,9 @@ def test_scheduler_oaoo(dbos: DBOS) -> None:
         nonlocal wf_counter
         wf_counter += 1
         nonlocal workflow_id
-        workflow_id = DBOS.workflow_id
+        wf_id = DBOS.workflow_id
+        assert wf_id is not None
+        workflow_id = wf_id
 
     @DBOS.transaction()
     def test_transaction() -> None:

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_workflow_introspection.py

@@ -456,7 +456,9 @@ def test_set_get_event(dbos: DBOS) -> None:
         DBOS.set_event("key", value)
         stepOne()
         DBOS.get_event("fake_id", "fake_value", 0)
-        return DBOS.get_event(DBOS.workflow_id, "key", 1)
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return DBOS.get_event(workflow_id, "key", 1)
 
     @DBOS.step()
     def stepOne() -> None:
@@ -500,7 +502,9 @@ def test_callchild_first_sync(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     def child_workflow() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     wfid = str(uuid.uuid4())
     with SetWorkflowID(wfid):
@@ -540,7 +544,9 @@ async def test_callchild_direct_asyncio(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     async def child_workflow() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     wfid = str(uuid.uuid4())
     with SetWorkflowID(wfid):
@@ -773,7 +779,9 @@ def test_callchild_middle_async_thread(dbos: DBOS) -> None:
 
     @DBOS.step()
     def stepOne() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     @DBOS.step()
     def stepTwo() -> None:
@@ -781,7 +789,9 @@ def test_callchild_middle_async_thread(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     def child_workflow() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     wfid = str(uuid.uuid4())
     with SetWorkflowID(wfid):
@@ -821,7 +831,9 @@ async def test_callchild_first_asyncio(dbos: DBOS) -> None:
 
     @DBOS.step()
     def stepOne() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     @DBOS.step()
     def stepTwo() -> None:
@@ -829,7 +841,9 @@ async def test_callchild_first_asyncio(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     async def child_workflow() -> str:
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     wfid = str(uuid.uuid4())
     with SetWorkflowID(wfid):
@@ -1045,11 +1059,15 @@ def test_call_as_step_within_step(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     def getStatusWorkflow() -> str:
-        return getStatus(DBOS.workflow_id)
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return getStatus(workflow_id)
 
     @DBOS.transaction()
     def transactionStatus() -> None:
-        DBOS.get_workflow_status(DBOS.workflow_id)
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        DBOS.get_workflow_status(workflow_id)
 
     wfid = str(uuid.uuid4())
     with SetWorkflowID(wfid):

{dbos-1.8.0a8 → dbos-1.9.0}/tests/test_workflow_management.py

@@ -9,7 +9,7 @@ import sqlalchemy as sa
 # Public API
 from dbos import DBOS, Queue, SetWorkflowID
 from dbos._dbos import DBOSConfiguredInstance
-from dbos._error import DBOSWorkflowCancelledError
+from dbos._error import DBOSAwaitedWorkflowCancelledError
 from dbos._schemas.application_database import ApplicationSchema
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 from dbos._workflow_commands import garbage_collect, global_timeout
@@ -52,7 +52,7 @@ def test_cancel_resume(dbos: DBOS) -> None:
     main_thread_event.wait()
     DBOS.cancel_workflow(wfid)
     workflow_event.set()
-    with pytest.raises(DBOSWorkflowCancelledError):
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handle.get_result()
     assert steps_completed == 1
 
@@ -103,7 +103,7 @@ def test_cancel_resume_txn(dbos: DBOS) -> None:
     main_thread_event.wait()
     DBOS.cancel_workflow(wfid)
     workflow_event.set()
-    with pytest.raises(DBOSWorkflowCancelledError):
+    with pytest.raises(DBOSAwaitedWorkflowCancelledError):
         handle.get_result()
     assert txn_completed == 1
 
@@ -652,7 +652,9 @@ def test_garbage_collection(dbos: DBOS) -> None:
     def blocked_workflow() -> str:
         txn(0)
         event.wait()
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     num_workflows = 10
 
@@ -729,7 +731,9 @@ def test_global_timeout(dbos: DBOS) -> None:
     def blocked_workflow() -> str:
         while not event.wait(0):
             DBOS.sleep(0.1)
-        return DBOS.workflow_id
+        workflow_id = DBOS.workflow_id
+        assert workflow_id is not None
+        return workflow_id
 
     num_workflows = 10
     handles = [DBOS.start_workflow(blocked_workflow) for _ in range(num_workflows)]
@@ -742,7 +746,7 @@ def test_global_timeout(dbos: DBOS) -> None:
 
     # Verify all workflows started before the global timeout are cancelled
     for handle in handles:
-        with pytest.raises(DBOSWorkflowCancelledError):
+        with pytest.raises(DBOSAwaitedWorkflowCancelledError):
             handle.get_result()
     event.set()
     assert final_handle.get_result() is not None