dbos 0.26.0a10__tar.gz → 0.26.0a13__tar.gz

{dbos-0.26.0a10 → dbos-0.26.0a13}/PKG-INFO

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

{dbos-0.26.0a10 → dbos-0.26.0a13}/dbos/_dbos.py

@@ -62,6 +62,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,
@@ -181,15 +182,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 +207,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:
@@ -641,15 +644,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]]:
@@ -1061,11 +1071,11 @@ class DBOS:
 
     @classproperty
     def step_id(cls) -> int:
-        """Return the step ID for the current context. This is a unique identifier of the current step within the workflow."""
+        """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_within_workflow()
-        ), "step_id is only available within a DBOS workflow."
+            ctx.is_step() or ctx.is_transaction()
+        ), "step_id is only available within a DBOS step."
         return ctx.function_id
 
     @classproperty

{dbos-0.26.0a10 → dbos-0.26.0a13}/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.0a10 → dbos-0.26.0a13}/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.0a10 → dbos-0.26.0a13}/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.0a10 → dbos-0.26.0a13}/dbos/_sys_db.py

@@ -1569,7 +1569,9 @@ class SystemDatabase:
 
     def call_function_as_step(self, fn: Callable[[], T], function_name: str) -> T:
         ctx = get_local_dbos_context()
-        if ctx and ctx.is_within_workflow():
+        if ctx and ctx.is_transaction():
+            raise Exception(f"Invalid call to `{function_name}` inside a transaction")
+        if ctx and ctx.is_workflow():
             ctx.function_id += 1
             res = self.check_operation_execution(
                 ctx.workflow_id, ctx.function_id, function_name
@@ -1587,7 +1589,7 @@ class SystemDatabase:
                         f"Recorded output and error are both None for {function_name}"
                     )
         result = fn()
-        if ctx and ctx.is_within_workflow():
+        if ctx and ctx.is_workflow():
             self.record_operation_result(
                 {
                     "workflow_uuid": ctx.workflow_id,

{dbos-0.26.0a10 → dbos-0.26.0a13}/pyproject.toml

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

dbos-0.26.0a13/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.0a13/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.0a10 → dbos-0.26.0a13}/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.0a10 → dbos-0.26.0a13}/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.0a10 → dbos-0.26.0a13}/tests/test_workflow_introspection.py

@@ -990,3 +990,39 @@ def test_list_workflows_as_step(dbos: DBOS) -> None:
     workflow_event.set()
     assert handle.get_result() == 1
     assert handle_two.get_result() == 1
+
+
+def test_call_as_step_within_step(
+    dbos: DBOS, sys_db: SystemDatabase, app_db: ApplicationDatabase
+) -> None:
+    # If we call any util functions within a step, it should be called directly without checkpointing
+
+    @DBOS.step()
+    def getStatus(workflow_id: str) -> str:
+        status = DBOS.get_workflow_status(workflow_id)
+        assert status is not None
+        return status.status
+
+    @DBOS.workflow()
+    def getStatusWorkflow() -> str:
+        return getStatus(DBOS.workflow_id)
+
+    @DBOS.transaction()
+    def transactionStatus() -> None:
+        DBOS.get_workflow_status(DBOS.workflow_id)
+
+    wfid = str(uuid.uuid4())
+    with SetWorkflowID(wfid):
+        status = getStatusWorkflow()
+        assert status == WorkflowStatusString.PENDING.value
+
+    steps = _workflow_commands.list_workflow_steps(sys_db, app_db, wfid)
+
+    assert len(steps) == 1
+    assert steps[0]["function_name"] == getStatus.__qualname__
+
+    with pytest.raises(Exception) as exc_info:
+        transactionStatus()
+    assert "Invalid call to `DBOS.getStatus` inside a transaction" in str(
+        exc_info.value
+    )

{dbos-0.26.0a10 → dbos-0.26.0a13}/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.