dbos 0.26.0a11__tar.gz → 0.26.0a14__tar.gz

{dbos-0.26.0a11 → dbos-0.26.0a14}/PKG-INFO

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

{dbos-0.26.0a11 → dbos-0.26.0a14}/dbos/_core.py

@@ -365,7 +365,9 @@ def _execute_workflow_wthread(
                 if isinstance(result, Immediate):
                     return cast(Immediate[R], result)()
                 else:
-                    return asyncio.run(cast(Pending[R], result)())
+                    return dbos._background_event_loop.submit_coroutine(
+                        cast(Pending[R], result)()
+                    )
             except Exception:
                 dbos.logger.error(
                     f"Exception encountered in asynchronous workflow: {traceback.format_exc()}"

{dbos-0.26.0a11 → dbos-0.26.0a14}/dbos/_dbos.py

@@ -4,7 +4,6 @@ import asyncio
 import atexit
 import hashlib
 import inspect
-import json
 import os
 import sys
 import threading
@@ -31,7 +30,6 @@ from typing import (
 
 from opentelemetry.trace import Span
 
-from dbos import _serialization
 from dbos._conductor.conductor import ConductorWebsocket
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 from dbos._workflow_commands import (
@@ -62,6 +60,7 @@ from ._recovery import recover_pending_workflows, startup_recovery_thread
 from ._registrations import (
     DEFAULT_MAX_RECOVERY_ATTEMPTS,
     DBOSClassInfo,
+    _class_fqn,
     get_or_create_class_info,
     set_dbos_func_name,
     set_temp_workflow_type,
@@ -111,6 +110,7 @@ from ._error import (
     DBOSException,
     DBOSNonExistentWorkflowError,
 )
+from ._event_loop import BackgroundEventLoop
 from ._logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
 from ._sys_db import SystemDatabase
 from ._workflow_commands import WorkflowStatus, get_workflow
@@ -181,15 +181,17 @@ class DBOSRegistry:
         self.workflow_info_map[name] = wrapped_func
 
     def register_class(self, cls: type, ci: DBOSClassInfo) -> None:
-        class_name = cls.__name__
+        class_name = _class_fqn(cls)
         if class_name in self.class_info_map:
             if self.class_info_map[class_name] is not cls:
                 raise Exception(f"Duplicate type registration for class '{class_name}'")
         else:
             self.class_info_map[class_name] = cls
 
-    def create_class_info(self, cls: Type[T]) -> Type[T]:
-        ci = get_or_create_class_info(cls)
+    def create_class_info(
+        self, cls: Type[T], class_name: Optional[str] = None
+    ) -> Type[T]:
+        ci = get_or_create_class_info(cls, class_name)
         self.register_class(cls, ci)
         return cls
 
@@ -204,7 +206,7 @@ class DBOSRegistry:
 
     def register_instance(self, inst: object) -> None:
         config_name = getattr(inst, "config_name")
-        class_name = inst.__class__.__name__
+        class_name = _class_fqn(inst.__class__)
         fn = f"{class_name}/{config_name}"
         if fn in self.instance_info_map:
             if self.instance_info_map[fn] is not inst:
@@ -338,6 +340,7 @@ class DBOS:
         self.conductor_url: Optional[str] = conductor_url
         self.conductor_key: Optional[str] = conductor_key
         self.conductor_websocket: Optional[ConductorWebsocket] = None
+        self._background_event_loop: BackgroundEventLoop = BackgroundEventLoop()
 
         init_logger()
 
@@ -448,6 +451,7 @@ class DBOS:
             dbos_logger.info(f"Executor ID: {GlobalParams.executor_id}")
             dbos_logger.info(f"Application version: {GlobalParams.app_version}")
             self._executor_field = ThreadPoolExecutor(max_workers=64)
+            self._background_event_loop.start()
             self._sys_db_field = SystemDatabase(
                 self.config["database"], debug_mode=debug_mode
             )
@@ -565,6 +569,7 @@ class DBOS:
         self._initialized = False
         for event in self.stop_events:
             event.set()
+        self._background_event_loop.stop()
         if self._sys_db_field is not None:
             self._sys_db_field.destroy()
             self._sys_db_field = None
@@ -641,15 +646,22 @@ class DBOS:
         )
 
     @classmethod
-    def dbos_class(cls) -> Callable[[Type[T]], Type[T]]:
+    def dbos_class(
+        cls, class_name: Optional[str] = None
+    ) -> Callable[[Type[T]], Type[T]]:
         """
         Decorate a class that contains DBOS member functions.
 
         All DBOS classes must be decorated, as this associates the class with
-        its member functions.
+        its member functions. Class names must be globally unique. By default, the class name is class.__qualname__  but you can optionally provide a class name that is different from the default name.
         """
 
-        return _get_or_create_dbos_registry().create_class_info
+        def register_class(cls: Type[T]) -> Type[T]:
+            # Register the class with the DBOS registry
+            _get_or_create_dbos_registry().create_class_info(cls, class_name)
+            return cls
+
+        return register_class
 
     @classmethod
     def default_required_roles(cls, roles: List[str]) -> Callable[[Type[T]], Type[T]]:

{dbos-0.26.0a11 → dbos-0.26.0a14}/dbos/_docker_pg_helper.py

@@ -46,7 +46,7 @@ def start_docker_pg() -> None:
     if has_docker:
         start_docker_postgres(pool_config)
         logging.info(
-            f"Postgres available at postgres://postgres:{pool_config['password']}@{pool_config['host']}:{pool_config['port']}"
+            f"Postgres available at postgresql://postgres:{pool_config['password']}@{pool_config['host']}:{pool_config['port']}"
         )
     else:
         logging.warning("Docker not detected locally")

{dbos-0.26.0a11 → dbos-0.26.0a14}/dbos/_error.py

@@ -26,6 +26,29 @@ class DBOSException(Exception):
         return f"DBOS Error: {self.message}"
 
 
+class DBOSBaseException(BaseException):
+    """
+    This class is for DBOS exceptions that should not be caught by user code.
+    It inherits from BaseException instead of Exception so it cannot be caught
+    except by code specifically trying to catch it.
+
+    Attributes:
+        message(str): The error message string
+        dbos_error_code(DBOSErrorCode): The error code, from the `DBOSErrorCode` enum
+    """
+
+    def __init__(self, message: str, dbos_error_code: Optional[int] = None):
+        self.message = message
+        self.dbos_error_code = dbos_error_code
+        self.status_code: Optional[int] = None
+        super().__init__(self.message)
+
+    def __str__(self) -> str:
+        if self.dbos_error_code:
+            return f"DBOS Error {self.dbos_error_code}: {self.message}"
+        return f"DBOS Error: {self.message}"
+
+
 class DBOSErrorCode(Enum):
     ConflictingIDError = 1
     RecoveryError = 2
@@ -41,14 +64,9 @@ class DBOSErrorCode(Enum):
     ConflictingRegistrationError = 25
 
 
-class DBOSWorkflowConflictIDError(DBOSException):
-    """Exception raised when a workflow database record already exists."""
-
-    def __init__(self, workflow_id: str):
-        super().__init__(
-            f"Conflicting workflow ID {workflow_id}",
-            dbos_error_code=DBOSErrorCode.ConflictingIDError.value,
-        )
+#######################################
+## Exception
+#######################################
 
 
 class DBOSConflictingWorkflowError(DBOSException):
@@ -138,16 +156,6 @@ class DBOSMaxStepRetriesExceeded(DBOSException):
         return (self.__class__, (self.step_name, self.max_retries))
 
 
-class DBOSWorkflowCancelledError(DBOSException):
-    """Exception raised when the workflow has already been cancelled."""
-
-    def __init__(self, msg: str) -> None:
-        super().__init__(
-            msg,
-            dbos_error_code=DBOSErrorCode.WorkflowCancelled.value,
-        )
-
-
 class DBOSConflictingRegistrationError(DBOSException):
     """Exception raised when conflicting decorators are applied to the same function."""
 
@@ -168,3 +176,28 @@ class DBOSUnexpectedStepError(DBOSException):
             f"During execution of workflow {workflow_id} step {step_id}, function {recorded_name} was recorded when {expected_name} was expected. Check that your workflow is deterministic.",
             dbos_error_code=DBOSErrorCode.UnexpectedStep.value,
         )
+
+
+#######################################
+## BaseException
+#######################################
+
+
+class DBOSWorkflowCancelledError(DBOSBaseException):
+    """BaseException raised when the workflow has already been cancelled."""
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(
+            msg,
+            dbos_error_code=DBOSErrorCode.WorkflowCancelled.value,
+        )
+
+
+class DBOSWorkflowConflictIDError(DBOSBaseException):
+    """BaseException raised when a workflow database record already exists."""
+
+    def __init__(self, workflow_id: str):
+        super().__init__(
+            f"Conflicting workflow ID {workflow_id}",
+            dbos_error_code=DBOSErrorCode.ConflictingIDError.value,
+        )

dbos-0.26.0a14/dbos/_event_loop.py

@@ -0,0 +1,67 @@
+import asyncio
+import threading
+from typing import Any, Coroutine, Optional, TypeVar
+
+
+class BackgroundEventLoop:
+    """
+    This is the event loop to which DBOS submits any coroutines that are not started from within an event loop.
+    In particular, coroutines submitted to queues (such as from scheduled workflows) run on this event loop.
+    """
+
+    def __init__(self) -> None:
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+        self._ready = threading.Event()
+
+    def start(self) -> None:
+        if self._running:
+            return
+
+        self._thread = threading.Thread(target=self._run_event_loop, daemon=True)
+        self._thread.start()
+        self._ready.wait()  # Wait until the loop is running
+
+    def stop(self) -> None:
+        if not self._running or self._loop is None or self._thread is None:
+            return
+
+        asyncio.run_coroutine_threadsafe(self._shutdown(), self._loop)
+        self._thread.join()
+        self._running = False
+
+    def _run_event_loop(self) -> None:
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+
+        self._running = True
+        self._ready.set()  # Signal that the loop is ready
+
+        try:
+            self._loop.run_forever()
+        finally:
+            self._loop.close()
+
+    async def _shutdown(self) -> None:
+        if self._loop is None:
+            raise RuntimeError("Event loop not started")
+        tasks = [
+            task
+            for task in asyncio.all_tasks(self._loop)
+            if task is not asyncio.current_task(self._loop)
+        ]
+
+        for task in tasks:
+            task.cancel()
+
+        await asyncio.gather(*tasks, return_exceptions=True)
+        self._loop.stop()
+
+    T = TypeVar("T")
+
+    def submit_coroutine(self, coro: Coroutine[Any, Any, T]) -> T:
+        """Submit a coroutine to the background event loop"""
+        if self._loop is None:
+            raise RuntimeError("Event loop not started")
+        return asyncio.run_coroutine_threadsafe(coro, self._loop).result()

{dbos-0.26.0a11 → dbos-0.26.0a14}/dbos/_registrations.py

@@ -34,6 +34,7 @@ def set_temp_workflow_type(f: Any, name: TempWorkflowType) -> None:
 
 @dataclass
 class DBOSClassInfo:
+    registered_name: str
     def_required_roles: Optional[List[str]] = None
 
 
@@ -53,11 +54,17 @@ class DBOSFuncInfo:
     max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS
 
 
-def get_or_create_class_info(cls: Type[Any]) -> DBOSClassInfo:
+def get_or_create_class_info(
+    cls: Type[Any], provided_name: Optional[str] = None
+) -> DBOSClassInfo:
     if hasattr(cls, "dbos_class_decorator_info"):
         ci: DBOSClassInfo = getattr(cls, "dbos_class_decorator_info")
         return ci
-    ci = DBOSClassInfo()
+    class_name = _class_fqn(cls)
+    # Use the provided name instead of the class name if it is not None
+    if provided_name is not None:
+        class_name = provided_name
+    ci = DBOSClassInfo(registered_name=class_name)
     setattr(cls, "dbos_class_decorator_info", ci)
 
     # Tell all DBOS functions about this
@@ -166,16 +173,24 @@ def get_config_name(
     return None
 
 
+def _class_fqn(cls: type) -> str:
+    """Returns the registered name of the given class. If the class name was not overridden at registration time, it returns the qualified name of the class."""
+    ci = get_class_info(cls)
+    if ci is not None:
+        return ci.registered_name
+    return cls.__qualname__
+
+
 def get_dbos_class_name(
     fi: Optional[DBOSFuncInfo], func: Callable[..., Any], args: Tuple[Any, ...]
 ) -> Optional[str]:
     if fi and fi.func_type != DBOSFuncType.Unknown and len(args) > 0:
         if fi.func_type == DBOSFuncType.Instance:
             first_arg = args[0]
-            return str(first_arg.__class__.__name__)
+            return _class_fqn(first_arg.__class__)
         if fi.func_type == DBOSFuncType.Class:
             first_arg = args[0]
-            return str(first_arg.__name__)
+            return _class_fqn(first_arg)
         return None
 
     # Check for improperly-registered functions

{dbos-0.26.0a11 → dbos-0.26.0a14}/pyproject.toml

@@ -28,7 +28,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.26.0a11"
+version = "0.26.0a14"
 
 [project.license]
 text = "MIT"

dbos-0.26.0a14/tests/dupname_classdefs1.py

@@ -0,0 +1,9 @@
+from dbos import DBOS, DBOSConfiguredInstance
+
+
+@DBOS.dbos_class(class_name="AnotherDBOSTestRegDup")
+class DBOSTestRegDup(DBOSConfiguredInstance):
+    """DBOSTestRegDup duplicates the name of a class defined dupname_classdefsa.py"""
+
+    def __init__(self, instance_name: str) -> None:
+        super().__init__(instance_name)

dbos-0.26.0a14/tests/dupname_classdefsa.py

@@ -0,0 +1,9 @@
+from dbos import DBOS, DBOSConfiguredInstance
+
+
+@DBOS.dbos_class()
+class DBOSTestRegDup(DBOSConfiguredInstance):
+    """DBOSTestRegDup duplicates the name of a class defined dupname_classdefs1.py"""
+
+    def __init__(self, instance_name: str) -> None:
+        super().__init__(instance_name)

{dbos-0.26.0a11 → dbos-0.26.0a14}/tests/test_async.py

@@ -7,8 +7,8 @@ import pytest
 import sqlalchemy as sa
 
 # Public API
-from dbos import DBOS, SetWorkflowID
-from dbos._dbos import WorkflowHandleAsync
+from dbos import DBOS, Queue, SetWorkflowID
+from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
 from dbos._dbos_config import ConfigFile
 from dbos._error import DBOSException
 
@@ -56,6 +56,15 @@ async def test_async_workflow(dbos: DBOS) -> None:
     assert step_counter == 1
     assert txn_counter == 1
 
+    # Test DBOS.start_workflow_async
+    handle = await DBOS.start_workflow_async(test_workflow, "alice", "bob")
+    assert (await handle.get_result()) == "alicetxn21bobstep2"
+
+    # Test DBOS.start_workflow. Not recommended for async workflows,
+    # but needed for backwards compatibility.
+    sync_handle = DBOS.start_workflow(test_workflow, "alice", "bob")
+    assert sync_handle.get_result() == "alicetxn31bobstep3"  # type: ignore
+
 
 @pytest.mark.asyncio
 async def test_async_step(dbos: DBOS) -> None:
@@ -160,10 +169,11 @@ async def test_send_recv_async(dbos: DBOS) -> None:
     none_uuid = str(uuid.uuid4())
     none_handle = None
     with SetWorkflowID(none_uuid):
-        none_handle = dbos.start_workflow(test_recv_timeout, 10.0)
+        none_handle = await dbos.start_workflow_async(test_recv_timeout, 10.0)
     await test_send_none(none_uuid)
     begin_time = time.time()
-    assert none_handle.get_result() is None
+    result = await none_handle.get_result()  # type: ignore
+    assert result is None
     duration = time.time() - begin_time
     assert duration < 1.0  # None is from the received message, not from the timeout.
 
@@ -400,3 +410,59 @@ async def test_retrieve_workflow_async(dbos: DBOS) -> None:
     wfstatus = await handle.get_status()
     assert wfstatus.status == "SUCCESS"
     assert wfstatus.workflow_id == wfuuid
+
+
+def test_unawaited_workflow(dbos: DBOS) -> None:
+    input = 5
+    child_id = str(uuid.uuid4())
+    queue = Queue("test_queue")
+
+    @DBOS.workflow()
+    async def child_workflow(x: int) -> int:
+        await asyncio.sleep(0.1)
+        return x
+
+    @DBOS.workflow()
+    async def parent_workflow(x: int) -> None:
+        with SetWorkflowID(child_id):
+            await DBOS.start_workflow_async(child_workflow, x)
+
+    assert queue.enqueue(parent_workflow, input).get_result() is None
+    handle: WorkflowHandle[int] = DBOS.retrieve_workflow(
+        child_id, existing_workflow=False
+    )
+    assert handle.get_result() == 5
+
+
+def test_unawaited_workflow_exception(dbos: DBOS) -> None:
+    child_id = str(uuid.uuid4())
+    queue = Queue("test_queue")
+
+    @DBOS.workflow()
+    async def child_workflow(s: str) -> int:
+        await asyncio.sleep(0.1)
+        raise Exception(s)
+
+    @DBOS.workflow()
+    async def parent_workflow(s: str) -> None:
+        with SetWorkflowID(child_id):
+            await DBOS.start_workflow_async(child_workflow, s)
+
+    # Verify the unawaited child properly throws an exception
+    input = "alice"
+    assert queue.enqueue(parent_workflow, input).get_result() is None
+    handle: WorkflowHandle[int] = DBOS.retrieve_workflow(
+        child_id, existing_workflow=False
+    )
+    with pytest.raises(Exception) as exc_info:
+        handle.get_result()
+    assert input in str(exc_info.value)
+
+    # Verify it works if run again
+    input = "bob"
+    child_id = str(uuid.uuid4())
+    assert queue.enqueue(parent_workflow, input).get_result() is None
+    handle = DBOS.retrieve_workflow(child_id, existing_workflow=False)
+    with pytest.raises(Exception) as exc_info:
+        handle.get_result()
+    assert input in str(exc_info.value)

{dbos-0.26.0a11 → dbos-0.26.0a14}/tests/test_classdecorators.py

@@ -316,11 +316,11 @@ def test_simple_workflow_inst(dbos: DBOS) -> None:
     stati = dbos.get_workflow_status(wfh.get_workflow_id())
     assert stati
     assert stati.config_name == "bob"
-    assert stati.class_name == "DBOSTestClassInst"
+    assert stati.class_name and "DBOSTestClassInst" in stati.class_name
     stat = wfh.get_status()
     assert stat
     assert stat.config_name == "bob"
-    assert stat.class_name == "DBOSTestClassInst"
+    assert stat.class_name and "DBOSTestClassInst" in stat.class_name
 
     assert wfh.get_result() == "bob1bob"
     assert inst.txn_counter == 2
@@ -376,17 +376,38 @@ def test_duplicate_reg(dbos: DBOS) -> None:
             def __init__(self) -> None:
                 super().__init__("bob")
 
-    assert "Duplicate type registration for class 'DBOSTestRegDup'" == str(
-        exc_info.value
+    assert (
+        "Duplicate type registration for class 'test_duplicate_reg.<locals>.DBOSTestRegDup'"
+        == str(exc_info.value)
     )
 
-    # Dupliocate instance registration
+    # Duplicate instance registration
     inst = DBOSTestRegDup()
     with pytest.raises(Exception) as exc_info:
         inst = DBOSTestRegDup()
 
     assert (
-        "Duplicate instance registration for class 'DBOSTestRegDup' instance 'bob'"
+        "Duplicate instance registration for class 'test_duplicate_reg.<locals>.DBOSTestRegDup' instance 'bob'"
+        == str(exc_info.value)
+    )
+
+    # There should be no collision when the duplicate class names are in
+    # different modules if they're specified with different names.
+    from tests import dupname_classdefs1, dupname_classdefsa
+
+    # Two instances of the same class may be registered if they have different
+    # instance_name.
+    # Duplicate instance registration error still occurs with identical class
+    # name and instance_name.
+    alice = dupname_classdefs1.DBOSTestRegDup("alice")
+    bob = dupname_classdefsa.DBOSTestRegDup("bob")
+    bob2 = dupname_classdefs1.DBOSTestRegDup("bob")
+
+    with pytest.raises(Exception) as exc_info:
+        bob2 = dupname_classdefs1.DBOSTestRegDup("bob")
+
+    assert (
+        "Duplicate instance registration for class 'AnotherDBOSTestRegDup' instance 'bob'"
         == str(exc_info.value)
     )
 
@@ -451,7 +472,7 @@ def test_inst_recovery(dbos: DBOS) -> None:
     assert last_inst is None
 
     status = DBOS.retrieve_workflow(wfid).get_status()
-    assert status.class_name == "TestClass"
+    assert status.class_name and "TestClass" in status.class_name
     assert status.config_name == "test_class"
 
 
@@ -479,7 +500,7 @@ def test_inst_async_recovery(dbos: DBOS) -> None:
         orig_handle = DBOS.start_workflow(inst.workflow, input)
 
     status = orig_handle.get_status()
-    assert status.class_name == "TestClass"
+    assert status.class_name and "TestClass" in status.class_name
     assert status.config_name == "test_class"
 
     recovery_handle = DBOS._execute_workflow_id(wfid)
@@ -513,7 +534,7 @@ def test_inst_async_step_recovery(dbos: DBOS) -> None:
         orig_handle = DBOS.start_workflow(inst.step, input)
 
     status = orig_handle.get_status()
-    assert status.class_name == "TestClass"
+    assert status.class_name and "TestClass" in status.class_name
     assert status.config_name == "test_class"
 
     recovery_handle = DBOS._execute_workflow_id(wfid)
@@ -558,7 +579,7 @@ def test_step_recovery(dbos: DBOS) -> None:
     thread_event.wait()
 
     status = DBOS.retrieve_workflow(wfid).get_status()
-    assert status.class_name == "TestClass"
+    assert status.class_name and "TestClass" in status.class_name
     assert status.config_name == "test_class"
 
     recovery_handle = DBOS._execute_workflow_id(wfid)
@@ -626,7 +647,7 @@ def test_class_queue_recovery(dbos: DBOS) -> None:
     result = [i * multiplier for i in range(5)]
     for h in recovery_handles:
         status = h.get_status()
-        assert status.class_name == "TestClass"
+        assert status.class_name and "TestClass" in status.class_name
         assert status.config_name == "test_class"
         if h.get_workflow_id() == wfid:
             assert h.get_result() == result
@@ -770,7 +791,7 @@ def test_class_classmethod_queue_recovery(dbos: DBOS) -> None:
     for h in recovery_handles:
         status = h.get_status()
         # Class name is recorded for class methods
-        assert status.class_name == "TestClass"
+        assert status.class_name and "TestClass" in status.class_name
         assert status.config_name == None
         if h.get_workflow_id() == wfid:
             assert h.get_result() == result
@@ -808,13 +829,13 @@ def test_inst_txn(dbos: DBOS) -> None:
     with SetWorkflowID(wfid):
         assert inst.transaction(input) == input * multiplier
     status = DBOS.retrieve_workflow(wfid).get_status()
-    assert status.class_name == "TestClass"
+    assert status.class_name and "TestClass" in status.class_name
     assert status.config_name == "test_class"
 
     handle = DBOS.start_workflow(inst.transaction, input)
     assert handle.get_result() == input * multiplier
     status = handle.get_status()
-    assert status.class_name == "TestClass"
+    assert status.class_name and "TestClass" in status.class_name
     assert status.config_name == "test_class"
 
 
@@ -848,13 +869,13 @@ def test_mixed_methods(dbos: DBOS) -> None:
     handle = DBOS.start_workflow(inst.instance_workflow, input)
     assert handle.get_result() == input * multiplier
     status = handle.get_status()
-    assert status.class_name == "TestClass"
+    assert status.class_name and "TestClass" in status.class_name
     assert status.config_name == "test_class"
 
     handle = DBOS.start_workflow(inst.classmethod_workflow, input)
     assert handle.get_result() == input
     status = handle.get_status()
-    assert status.class_name == "TestClass"
+    assert status.class_name and "TestClass" in status.class_name
     assert status.config_name == None
 
     handle = DBOS.start_workflow(inst.staticmethod_workflow, input)

{dbos-0.26.0a11 → dbos-0.26.0a14}/tests/test_singleton.py

@@ -48,7 +48,7 @@ def test_dbos_singleton(cleanup_test_databases: None) -> None:
     stati = DBOS.get_workflow_status(wh.get_workflow_id())
     assert stati
     assert stati.config_name == "myconfig"
-    assert stati.class_name == "DBOSTestClass"
+    assert stati.class_name and "DBOSTestClass" in stati.class_name
     wfhr: WorkflowHandle[str] = DBOS.retrieve_workflow(wh.get_workflow_id())
     assert wfhr.workflow_id == wh.get_workflow_id()
 

{dbos-0.26.0a11 → dbos-0.26.0a14}/tests/test_workflow_management.py

@@ -33,7 +33,11 @@ def test_cancel_resume(dbos: DBOS) -> None:
         step_one()
         main_thread_event.set()
         workflow_event.wait()
-        step_two()
+        # A handler like this should not catch DBOSWorkflowCancelledError
+        try:
+            step_two()
+        except Exception:
+            raise
         return x
 
     # Start the workflow and cancel it.