dbos 0.5.0a3__tar.gz → 0.5.0a5__tar.gz

{dbos-0.5.0a3 → dbos-0.5.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.5.0a3
+Version: 0.5.0a5
 Summary: A Python framework for backends that scale
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-0.5.0a3 → dbos-0.5.0a5}/dbos/application_database.py

@@ -3,6 +3,7 @@ from typing import Optional, TypedDict, cast
 import sqlalchemy as sa
 import sqlalchemy.dialects.postgresql as pg
 import sqlalchemy.exc as sa_exc
+from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Session, sessionmaker
 
 from dbos.error import DBOSWorkflowConflictIDError
@@ -95,8 +96,10 @@ class ApplicationDatabase:
                     ),
                 )
             )
-        except sa_exc.IntegrityError:
-            raise DBOSWorkflowConflictIDError(output["workflow_uuid"])
+        except DBAPIError as dbapi_error:
+            if dbapi_error.orig.pgcode == "23505":  # type: ignore
+                raise DBOSWorkflowConflictIDError(output["workflow_uuid"])
+            raise dbapi_error
         except Exception as e:
             raise e
 
@@ -118,8 +121,10 @@ class ApplicationDatabase:
                         ),
                     )
                 )
-        except sa_exc.IntegrityError:
-            raise DBOSWorkflowConflictIDError(output["workflow_uuid"])
+        except DBAPIError as dbapi_error:
+            if dbapi_error.orig.pgcode == "23505":  # type: ignore
+                raise DBOSWorkflowConflictIDError(output["workflow_uuid"])
+            raise dbapi_error
         except Exception as e:
             raise e
 

{dbos-0.5.0a3 → dbos-0.5.0a5}/dbos/context.py

@@ -18,18 +18,16 @@ from .logger import dbos_logger
 from .tracer import dbos_tracer
 
 
-# Values must be the same as in TypeScript Transact
+# These are used to tag OTel traces
 class OperationType(Enum):
     HANDLER = "handler"
     WORKFLOW = "workflow"
     TRANSACTION = "transaction"
-    COMMUNICATOR = "communicator"
+    STEP = "step"
     PROCEDURE = "procedure"
 
 
-OperationTypes = Literal[
-    "handler", "workflow", "transaction", "communicator", "procedure"
-]
+OperationTypes = Literal["handler", "workflow", "transaction", "step", "procedure"]
 
 
 # Keys must be the same as in TypeScript Transact
@@ -64,7 +62,7 @@ class DBOSContext:
         self.function_id: int = -1
         self.in_recovery: bool = False
 
-        self.curr_comm_function_id: int = -1
+        self.curr_step_function_id: int = -1
         self.curr_tx_function_id: int = -1
         self.sql_session: Optional[Session] = None
         self.spans: list[Span] = []
@@ -117,26 +115,26 @@ class DBOSContext:
     def is_workflow(self) -> bool:
         return (
             len(self.workflow_id) > 0
-            and not self.is_communicator()
+            and not self.is_step()
             and not self.is_transaction()
         )
 
     def is_transaction(self) -> bool:
         return self.sql_session is not None
 
-    def is_communicator(self) -> bool:
-        return self.curr_comm_function_id >= 0
+    def is_step(self) -> bool:
+        return self.curr_step_function_id >= 0
 
-    def start_communicator(
+    def start_step(
         self,
         fid: int,
         attributes: TracedAttributes,
     ) -> None:
-        self.curr_comm_function_id = fid
+        self.curr_step_function_id = fid
         self._start_span(attributes)
 
-    def end_communicator(self, exc_value: Optional[BaseException]) -> None:
-        self.curr_comm_function_id = -1
+    def end_step(self, exc_value: Optional[BaseException]) -> None:
+        self.curr_step_function_id = -1
         self._end_span(exc_value)
 
     def start_transaction(
@@ -375,7 +373,7 @@ class EnterDBOSChildWorkflow:
     def __enter__(self) -> DBOSContext:
         ctx = assert_current_dbos_context()
         self.parent_ctx = ctx
-        assert ctx.is_workflow()  # Is in a workflow and not in tx/comm
+        assert ctx.is_workflow()  # Is in a workflow and not in a step
         ctx.function_id += 1
         if len(ctx.id_assigned_for_next_workflow) == 0:
             ctx.id_assigned_for_next_workflow = (
@@ -401,7 +399,7 @@ class EnterDBOSChildWorkflow:
         return False  # Did not handle
 
 
-class EnterDBOSCommunicator:
+class EnterDBOSStep:
     def __init__(
         self,
         attributes: TracedAttributes,
@@ -412,7 +410,7 @@ class EnterDBOSCommunicator:
         ctx = assert_current_dbos_context()
         assert ctx.is_workflow()
         ctx.function_id += 1
-        ctx.start_communicator(ctx.function_id, attributes=self.attributes)
+        ctx.start_step(ctx.function_id, attributes=self.attributes)
         return ctx
 
     def __exit__(
@@ -422,8 +420,8 @@ class EnterDBOSCommunicator:
         traceback: Optional[TracebackType],
     ) -> Literal[False]:
         ctx = assert_current_dbos_context()
-        assert ctx.is_communicator()
-        ctx.end_communicator(exc_value)
+        assert ctx.is_step()
+        ctx.end_step(exc_value)
         return False  # Did not handle
 
 

{dbos-0.5.0a3 → dbos-0.5.0a5}/dbos/core.py

@@ -19,20 +19,18 @@ from dbos.context import (
     DBOSContextEnsure,
     DBOSContextSwap,
     EnterDBOSChildWorkflow,
-    EnterDBOSCommunicator,
+    EnterDBOSStep,
     EnterDBOSTransaction,
     EnterDBOSWorkflow,
     OperationType,
     SetWorkflowID,
     TracedAttributes,
     assert_current_dbos_context,
-    clear_local_dbos_context,
     get_local_dbos_context,
-    set_local_dbos_context,
 )
 from dbos.error import (
-    DBOSCommunicatorMaxRetriesExceededError,
     DBOSException,
+    DBOSMaxStepRetriesExceeded,
     DBOSNonExistentWorkflowError,
     DBOSRecoveryError,
     DBOSWorkflowConflictIDError,
@@ -61,7 +59,6 @@ if TYPE_CHECKING:
     from dbos.dbos import IsolationLevel
 
 from sqlalchemy.exc import DBAPIError
-from sqlalchemy.orm import Session
 
 P = ParamSpec("P")  # A generic type for workflow parameters
 R = TypeVar("R", covariant=True)  # A generic type for workflow return values
@@ -139,14 +136,18 @@ def _init_workflow(
         "recovery_attempts": None,
     }
 
+    # If we have a class name, the first arg is the instance and do not serialize
+    if class_name is not None:
+        inputs = {"args": inputs["args"][1:], "kwargs": inputs["kwargs"]}
+
     if temp_wf_type != "transaction":
-        # Don't synchronously record the status or inputs for single transaction workflows
+        # Synchronously record the status and inputs for workflows and single-step workflows
+        # We also have to do this for single-step workflows because of the foreign key constraint on the operation outputs table
         dbos.sys_db.update_workflow_status(status, False, ctx.in_recovery)
-
-        # If we have a class name, the first arg is the instance and do not serialize
-        if class_name is not None:
-            inputs = {"args": inputs["args"][1:], "kwargs": inputs["kwargs"]}
         dbos.sys_db.update_workflow_inputs(wfid, utils.serialize(inputs))
+    else:
+        # Buffer the inputs for single-transaction workflows, but don't buffer the status
+        dbos.sys_db.buffer_workflow_inputs(wfid, utils.serialize(inputs))
 
     return status
 
@@ -176,20 +177,6 @@ def _execute_workflow(
         status["error"] = utils.serialize(error)
         dbos.sys_db.update_workflow_status(status)
         raise error
-    finally:
-        if get_temp_workflow_type(func) == "transaction":
-            # Buffer the inputs for single transaction workflows
-            inputs: WorkflowInputs = {
-                "args": args,
-                "kwargs": kwargs,
-            }
-            # If we have a class name, the first arg is the instance and do not serialize
-            class_name = get_dbos_class_name(get_func_info(func), func, args)
-            if class_name is not None:
-                inputs = {"args": inputs["args"][1:], "kwargs": inputs["kwargs"]}
-            dbos.sys_db.buffer_workflow_inputs(
-                status["workflow_uuid"], utils.serialize(inputs)
-            )
 
     return output
 
@@ -362,7 +349,7 @@ def _start_workflow(
 
     # Sequence of events for starting a workflow:
     #   First - is there a WF already running?
-    #      (and not in tx/comm as that is an error)
+    #      (and not in step as that is an error)
     #   Assign an ID to the workflow, if it doesn't have an app-assigned one
     #      If this is a root workflow, assign a new ID
     #      If this is a child workflow, assign parent wf id with call# suffix
@@ -370,7 +357,7 @@ def _start_workflow(
     #   Pass the new context to a worker thread that will run the wf function
     cur_ctx = get_local_dbos_context()
     if cur_ctx is not None and cur_ctx.is_within_workflow():
-        assert cur_ctx.is_workflow()  # Not in tx / comm
+        assert cur_ctx.is_workflow()  # Not in a step
         cur_ctx.function_id += 1
         if len(cur_ctx.id_assigned_for_next_workflow) == 0:
             cur_ctx.id_assigned_for_next_workflow = (
@@ -517,7 +504,7 @@ def _transaction(
         def wrapper(*args: Any, **kwargs: Any) -> Any:
             rr: Optional[str] = check_required_roles(func, fi)
             # Entering transaction is allowed:
-            #  In a workflow (that is not in a transaction / comm already)
+            #  In a workflow (that is not in a step already)
             #  Not in a workflow (we will start the single op workflow)
             ctx = get_local_dbos_context()
             if ctx and ctx.is_within_workflow():
@@ -544,7 +531,7 @@ def _transaction(
     return decorator
 
 
-def _communicator(
+def _step(
     dbosreg: "_DBOSRegistry",
     *,
     retries_allowed: bool = False,
@@ -554,7 +541,7 @@ def _communicator(
 ) -> Callable[[F], F]:
     def decorator(func: F) -> F:
 
-        def invoke_comm(*args: Any, **kwargs: Any) -> Any:
+        def invoke_step(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
                 raise DBOSException(
                     f"Function {func.__name__} invoked before DBOS initialized"
@@ -563,10 +550,10 @@ def _communicator(
 
             attributes: TracedAttributes = {
                 "name": func.__name__,
-                "operationType": OperationType.COMMUNICATOR.value,
+                "operationType": OperationType.STEP.value,
             }
-            with EnterDBOSCommunicator(attributes) as ctx:
-                comm_output: OperationResultInternal = {
+            with EnterDBOSStep(attributes) as ctx:
+                step_output: OperationResultInternal = {
                     "workflow_uuid": ctx.workflow_id,
                     "function_id": ctx.function_id,
                     "output": None,
@@ -591,24 +578,24 @@ def _communicator(
                 for attempt in range(1, local_max_attempts + 1):
                     try:
                         output = func(*args, **kwargs)
-                        comm_output["output"] = utils.serialize(output)
+                        step_output["output"] = utils.serialize(output)
                         error = None
                         break
                     except Exception as err:
                         error = err
                         if retries_allowed:
                             dbos.logger.warning(
-                                f"Communicator being automatically retried. (attempt {attempt} of {local_max_attempts}). {traceback.format_exc()}"
+                                f"Step being automatically retried. (attempt {attempt} of {local_max_attempts}). {traceback.format_exc()}"
                             )
                             ctx.get_current_span().add_event(
-                                f"Communicator attempt {attempt} failed",
+                                f"Step attempt {attempt} failed",
                                 {
                                     "error": str(error),
                                     "retryIntervalSeconds": local_interval_seconds,
                                 },
                             )
                             if attempt == local_max_attempts:
-                                error = DBOSCommunicatorMaxRetriesExceededError()
+                                error = DBOSMaxStepRetriesExceeded()
                             else:
                                 time.sleep(local_interval_seconds)
                                 local_interval_seconds = min(
@@ -616,10 +603,11 @@ def _communicator(
                                     max_retry_interval_seconds,
                                 )
 
-                comm_output["error"] = (
+                step_output["error"] = (
                     utils.serialize(error) if error is not None else None
                 )
-                dbos.sys_db.record_operation_result(comm_output)
+                dbos.sys_db.record_operation_result(step_output)
+
                 if error is not None:
                     raise error
                 return output
@@ -629,20 +617,18 @@ def _communicator(
         @wraps(func)
         def wrapper(*args: Any, **kwargs: Any) -> Any:
             rr: Optional[str] = check_required_roles(func, fi)
-            # Entering communicator is allowed:
-            #  In a communicator already, just call the original function directly.
-            #  In a workflow (that is not in a transaction / comm already)
+            # Entering step is allowed:
+            #  In a step already, just call the original function directly.
+            #  In a workflow (that is not in a step already)
             #  Not in a workflow (we will start the single op workflow)
             ctx = get_local_dbos_context()
-            if ctx and ctx.is_communicator():
+            if ctx and ctx.is_step():
                 # Call the original function directly
                 return func(*args, **kwargs)
             if ctx and ctx.is_within_workflow():
-                assert (
-                    ctx.is_workflow()
-                ), "Communicators must be called from within workflows"
+                assert ctx.is_workflow(), "Steps must be called from within workflows"
                 with DBOSAssumeRole(rr):
-                    return invoke_comm(*args, **kwargs)
+                    return invoke_step(*args, **kwargs)
             else:
                 tempwf = dbosreg.workflow_info_map.get("<temp>." + func.__qualname__)
                 assert tempwf
@@ -653,7 +639,7 @@ def _communicator(
 
         wrapped_wf = _workflow_wrapper(dbosreg, temp_wf)
         set_dbos_func_name(temp_wf, "<temp>." + func.__qualname__)
-        set_temp_workflow_type(temp_wf, "communicator")
+        set_temp_workflow_type(temp_wf, "step")
         dbosreg.register_wf_function(get_dbos_func_name(temp_wf), wrapped_wf)
 
         return cast(F, wrapper)
@@ -668,10 +654,10 @@ def _send(
         attributes: TracedAttributes = {
             "name": "send",
         }
-        with EnterDBOSCommunicator(attributes) as ctx:
+        with EnterDBOSStep(attributes) as ctx:
             dbos.sys_db.send(
                 ctx.workflow_id,
-                ctx.curr_comm_function_id,
+                ctx.curr_step_function_id,
                 destination_id,
                 message,
                 topic,
@@ -697,12 +683,12 @@ def _recv(
         attributes: TracedAttributes = {
             "name": "recv",
         }
-        with EnterDBOSCommunicator(attributes) as ctx:
+        with EnterDBOSStep(attributes) as ctx:
             ctx.function_id += 1  # Reserve for the sleep
             timeout_function_id = ctx.function_id
             return dbos.sys_db.recv(
                 ctx.workflow_id,
-                ctx.curr_comm_function_id,
+                ctx.curr_step_function_id,
                 timeout_function_id,
                 topic,
                 timeout_seconds,
@@ -722,9 +708,9 @@ def _set_event(dbos: "DBOS", key: str, value: Any) -> None:
         attributes: TracedAttributes = {
             "name": "set_event",
         }
-        with EnterDBOSCommunicator(attributes) as ctx:
+        with EnterDBOSStep(attributes) as ctx:
             dbos.sys_db.set_event(
-                ctx.workflow_id, ctx.curr_comm_function_id, key, value
+                ctx.workflow_id, ctx.curr_step_function_id, key, value
             )
     else:
         # Cannot call it from outside of a workflow
@@ -743,12 +729,12 @@ def _get_event(
         attributes: TracedAttributes = {
             "name": "get_event",
         }
-        with EnterDBOSCommunicator(attributes) as ctx:
+        with EnterDBOSStep(attributes) as ctx:
             ctx.function_id += 1
             timeout_function_id = ctx.function_id
             caller_ctx: GetEventWorkflowContext = {
                 "workflow_uuid": ctx.workflow_id,
-                "function_id": ctx.curr_comm_function_id,
+                "function_id": ctx.curr_step_function_id,
                 "timeout_function_id": timeout_function_id,
             }
             return dbos.sys_db.get_event(workflow_id, key, timeout_seconds, caller_ctx)

{dbos-0.5.0a3 → dbos-0.5.0a5}/dbos/dbos.py

@@ -25,13 +25,13 @@ from opentelemetry.trace import Span
 
 from dbos.core import (
     TEMP_SEND_WF_NAME,
-    _communicator,
     _execute_workflow_id,
     _get_event,
     _recv,
     _send,
     _set_event,
     _start_workflow,
+    _step,
     _transaction,
     _workflow,
     _workflow_wrapper,
@@ -63,7 +63,7 @@ else:
 
 from dbos.admin_sever import AdminServer
 from dbos.context import (
-    EnterDBOSCommunicator,
+    EnterDBOSStep,
     TracedAttributes,
     assert_current_dbos_context,
     get_local_dbos_context,
@@ -179,7 +179,7 @@ class DBOS:
     Main access class for DBOS functionality.
 
     `DBOS` contains functions and properties for:
-    1. Decorating classes, workflows, transactions, and communicators
+    1. Decorating classes, workflows, and steps
     2. Starting workflow functions
     3. Retrieving workflow status information
     4. Interacting with workflows via events and messages
@@ -388,9 +388,8 @@ class DBOS:
         """
         return _transaction(_get_or_create_dbos_registry(), isolation_level)
 
-    # Mirror the CommunicatorConfig from TS. However, we disable retries by default.
     @classmethod
-    def communicator(
+    def step(
         cls,
         *,
         retries_allowed: bool = False,
@@ -399,17 +398,17 @@ class DBOS:
         backoff_rate: float = 2.0,
     ) -> Callable[[F], F]:
         """
-        Decorate and configure a function for use as a DBOS communicator.
+        Decorate and configure a function for use as a DBOS step.
 
         Args:
             retries_allowed(bool): If true, enable retries on thrown exceptions
             interval_seconds(float): Time between retry attempts
             backoff_rate(float): Multiplier for exponentially increasing `interval_seconds` between retries
-            max_attempts(int): Maximum number of communicator retries before raising an exception
+            max_attempts(int): Maximum number of retries before raising an exception
 
         """
 
-        return _communicator(
+        return _step(
             _get_or_create_dbos_registry(),
             retries_allowed=retries_allowed,
             interval_seconds=interval_seconds,
@@ -542,9 +541,9 @@ class DBOS:
         }
         if seconds <= 0:
             return
-        with EnterDBOSCommunicator(attributes) as ctx:
+        with EnterDBOSStep(attributes) as ctx:
             _get_dbos_instance().sys_db.sleep(
-                ctx.workflow_id, ctx.curr_comm_function_id, seconds
+                ctx.workflow_id, ctx.curr_step_function_id, seconds
             )
 
     @classmethod
@@ -615,9 +614,7 @@ class DBOS:
     def sql_session(cls) -> Session:
         """Return the SQLAlchemy `Session` for the current context, which must be within a transaction function."""
         ctx = assert_current_dbos_context()
-        assert (
-            ctx.is_transaction()
-        ), "sql_session is only available within a transaction."
+        assert ctx.is_transaction(), "db is only available within a transaction."
         rv = ctx.sql_session
         assert rv
         return rv
@@ -628,7 +625,7 @@ class DBOS:
         ctx = assert_current_dbos_context()
         assert (
             ctx.is_within_workflow()
-        ), "workflow_id is only available within a workflow, transaction, or communicator."
+        ), "workflow_id is only available within a DBOS operation."
         return ctx.workflow_id
 
     @classproperty
@@ -722,9 +719,9 @@ class DBOSConfiguredInstance:
     """
     Base class for classes containing DBOS member functions.
 
-    When a class contains workflow, transaction, and communicator functions that access
-    instance state, the DBOS workflow executor needs a name for the instance.  This name
-    is recorded in the database, and used to refer to the proper instance upon recovery.
+    When a class contains DBOS functions that access instance state, the DBOS workflow
+    executor needs a name for the instance.  This name is recorded in the database, and
+    used to refer to the proper instance upon recovery.
 
     Use `DBOSConfiguredInstance` to specify the instance name and register the instance
     with the DBOS workflow executor.

{dbos-0.5.0a3 → dbos-0.5.0a5}/dbos/error.py

@@ -32,7 +32,7 @@ class DBOSErrorCode(Enum):
     WorkflowFunctionNotFound = 4
     NonExistentWorkflowError = 5
     DuplicateWorkflowEventError = 6
-    CommunicatorMaxRetriesExceeded = 7
+    MaxStepRetriesExceeded = 7
     NotAuthorized = 8
 
 
@@ -106,11 +106,11 @@ class DBOSNotAuthorizedError(DBOSException):
         )
 
 
-class DBOSCommunicatorMaxRetriesExceededError(DBOSException):
-    """Exception raised when a communicator function was retried the maximimum number of times without success."""
+class DBOSMaxStepRetriesExceeded(DBOSException):
+    """Exception raised when a step was retried the maximimum number of times without success."""
 
     def __init__(self) -> None:
         super().__init__(
-            "Communicator reached maximum retries.",
-            dbos_error_code=DBOSErrorCode.CommunicatorMaxRetriesExceeded.value,
+            "Step reached maximum retries.",
+            dbos_error_code=DBOSErrorCode.MaxStepRetriesExceeded.value,
         )

{dbos-0.5.0a3 → dbos-0.5.0a5}/dbos/registrations.py

@@ -16,7 +16,7 @@ def set_dbos_func_name(f: Any, name: str) -> None:
     setattr(f, "dbos_function_name", name)
 
 
-TempWorkflowType = Literal["transaction", "communicator", "send", None]
+TempWorkflowType = Literal["transaction", "step", "send", None]
 
 
 def get_temp_workflow_type(f: Any) -> TempWorkflowType: