dbos 0.5.0a3__tar.gz → 0.5.0a4__tar.gz

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

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

{dbos-0.5.0a3 → dbos-0.5.0a4}/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.0a4}/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
@@ -362,7 +359,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 +367,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 +514,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 +541,7 @@ def _transaction(
     return decorator
 
 
-def _communicator(
+def _step(
     dbosreg: "_DBOSRegistry",
     *,
     retries_allowed: bool = False,
@@ -554,7 +551,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 +560,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 +588,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 +613,10 @@ 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 +626,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 +648,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 +663,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 +692,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 +717,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 +738,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.0a4}/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.0a4}/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.0a4}/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:

{dbos-0.5.0a3 → dbos-0.5.0a4}/dbos/system_database.py

@@ -4,17 +4,7 @@ import select
 import threading
 import time
 from enum import Enum
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Sequence,
-    TypedDict,
-    cast,
-)
+from typing import Any, Dict, List, Literal, Optional, Sequence, TypedDict, cast
 
 import psycopg2
 import sqlalchemy as sa
@@ -33,9 +23,6 @@ from .dbos_config import ConfigFile
 from .logger import dbos_logger
 from .schemas.system_database import SystemSchema
 
-if TYPE_CHECKING:
-    from dbos.dbos import DBOS
-
 
 class WorkflowStatusString(Enum):
     """Enumeration of values allowed for `WorkflowSatusInternal.status`."""

{dbos-0.5.0a3 → dbos-0.5.0a4}/pyproject.toml

@@ -23,7 +23,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.5.0a3"
+version = "0.5.0a4"
 
 [project.license]
 text = "MIT"

{dbos-0.5.0a3 → dbos-0.5.0a4}/tests/classdefs.py

@@ -11,20 +11,20 @@ from dbos.context import assert_current_dbos_context
 class DBOSTestClass(DBOSConfiguredInstance):
     txn_counter_c = 0
     wf_counter_c = 0
-    comm_counter_c = 0
+    step_counter_c = 0
 
     def __init__(self) -> None:
         super().__init__("myconfig")
         self.txn_counter: int = 0
         self.wf_counter: int = 0
-        self.comm_counter: int = 0
+        self.step_counter: int = 0
 
     @classmethod
     @DBOS.workflow()
     def test_workflow_cls(cls, var: str, var2: str) -> str:
         cls.wf_counter_c += 1
         res = DBOSTestClass.test_transaction_cls(var2)
-        res2 = DBOSTestClass.test_communicator_cls(var)
+        res2 = DBOSTestClass.test_step_cls(var)
         return res + res2
 
     @classmethod
@@ -35,16 +35,16 @@ class DBOSTestClass(DBOSConfiguredInstance):
         return var2 + str(rows[0][0])
 
     @classmethod
-    @DBOS.communicator()
-    def test_communicator_cls(cls, var: str) -> str:
-        cls.comm_counter_c += 1
+    @DBOS.step()
+    def test_step_cls(cls, var: str) -> str:
+        cls.step_counter_c += 1
         return var
 
     @DBOS.workflow()
     def test_workflow(self, var: str, var2: str) -> str:
         self.wf_counter += 1
         res = self.test_transaction(var2)
-        res2 = self.test_communicator(var)
+        res2 = self.test_step(var)
         return res + res2
 
     @DBOS.transaction()
@@ -53,9 +53,9 @@ class DBOSTestClass(DBOSConfiguredInstance):
         self.txn_counter += 1
         return var2 + str(rows[0][0])
 
-    @DBOS.communicator()
-    def test_communicator(self, var: str) -> str:
-        self.comm_counter += 1
+    @DBOS.step()
+    def test_step(self, var: str) -> str:
+        self.step_counter += 1
         return var
 
     @DBOS.workflow()

{dbos-0.5.0a3 → dbos-0.5.0a4}/tests/test_admin_server.py

@@ -54,7 +54,7 @@ def test_admin_recovery(dbos: DBOS) -> None:
     os.environ["DBOS__APPVERSION"] = "testversion"
     os.environ["DBOS__APPID"] = "testappid"
 
-    comm_counter: int = 0
+    step_counter: int = 0
     wf_counter: int = 0
 
     @DBOS.workflow()
@@ -62,13 +62,13 @@ def test_admin_recovery(dbos: DBOS) -> None:
         DBOS.logger.info("WFID: " + DBOS.workflow_id)
         nonlocal wf_counter
         wf_counter += 1
-        res = test_communicator(var2)
+        res = test_step(var2)
         return res + var
 
-    @DBOS.communicator()
-    def test_communicator(var2: str) -> str:
-        nonlocal comm_counter
-        comm_counter += 1
+    @DBOS.step()
+    def test_step(var2: str) -> str:
+        nonlocal step_counter
+        step_counter += 1
         return var2 + "1"
 
     wfuuid = str(uuid.uuid4())

{dbos-0.5.0a3 → dbos-0.5.0a4}/tests/test_classdecorators.py

@@ -190,14 +190,14 @@ def test_simple_workflow_static(dbos: DBOS) -> None:
     class DBOSTestClassStatic:
         txn_counter: int = 0
         wf_counter: int = 0
-        comm_counter: int = 0
+        step_counter: int = 0
 
         @staticmethod
         @DBOS.workflow()
         def test_workflow(var: str, var2: str) -> str:
             DBOSTestClassStatic.wf_counter += 1
             res = DBOSTestClassStatic.test_transaction(var2)
-            res2 = DBOSTestClassStatic.test_communicator(var)
+            res2 = DBOSTestClassStatic.test_step(var)
             DBOS.logger.info("I'm test_workflow")
             return res + res2
 
@@ -210,10 +210,10 @@ def test_simple_workflow_static(dbos: DBOS) -> None:
             return var2 + str(rows[0][0])
 
         @staticmethod
-        @DBOS.communicator()
-        def test_communicator(var: str) -> str:
-            DBOSTestClassStatic.comm_counter += 1
-            DBOS.logger.info("I'm test_communicator")
+        @DBOS.step()
+        def test_step(var: str) -> str:
+            DBOSTestClassStatic.step_counter += 1
+            DBOS.logger.info("I'm test_step")
             return var
 
     assert DBOSTestClassStatic.test_workflow("bob", "bob") == "bob1bob"
@@ -221,7 +221,7 @@ def test_simple_workflow_static(dbos: DBOS) -> None:
     assert wfh.get_result() == "bob1bob"
     assert DBOSTestClassStatic.txn_counter == 2
     assert DBOSTestClassStatic.wf_counter == 2
-    assert DBOSTestClassStatic.comm_counter == 2
+    assert DBOSTestClassStatic.step_counter == 2
 
 
 def test_simple_workflow_class(dbos: DBOS) -> None:
@@ -229,14 +229,14 @@ def test_simple_workflow_class(dbos: DBOS) -> None:
     class DBOSTestClassClass:
         txn_counter: int = 0
         wf_counter: int = 0
-        comm_counter: int = 0
+        step_counter: int = 0
 
         @classmethod
         @DBOS.workflow()
         def test_workflow(cls, var: str, var2: str) -> str:
             DBOSTestClassClass.wf_counter += 1
             res = DBOSTestClassClass.test_transaction(var2)
-            res2 = DBOSTestClassClass.test_communicator(var)
+            res2 = DBOSTestClassClass.test_step(var)
             DBOS.logger.info("I'm test_workflow")
             return res + res2
 
@@ -249,10 +249,10 @@ def test_simple_workflow_class(dbos: DBOS) -> None:
             return var2 + str(rows[0][0])
 
         @classmethod
-        @DBOS.communicator()
-        def test_communicator(cls, var: str) -> str:
-            DBOSTestClassClass.comm_counter += 1
-            DBOS.logger.info("I'm test_communicator")
+        @DBOS.step()
+        def test_step(cls, var: str) -> str:
+            DBOSTestClassClass.step_counter += 1
+            DBOS.logger.info("I'm test_step")
             return var
 
     assert DBOSTestClassClass.test_workflow("bob", "bob") == "bob1bob"
@@ -260,7 +260,7 @@ def test_simple_workflow_class(dbos: DBOS) -> None:
     assert wfh.get_result() == "bob1bob"
     assert DBOSTestClassClass.txn_counter == 2
     assert DBOSTestClassClass.wf_counter == 2
-    assert DBOSTestClassClass.comm_counter == 2
+    assert DBOSTestClassClass.step_counter == 2
 
 
 def test_no_instname(dbos: DBOS) -> None:
@@ -282,13 +282,13 @@ def test_simple_workflow_inst(dbos: DBOS) -> None:
             super().__init__("bob", dbos)
             self.txn_counter: int = 0
             self.wf_counter: int = 0
-            self.comm_counter: int = 0
+            self.step_counter: int = 0
 
         @DBOS.workflow()
         def test_workflow(self, var: str, var2: str) -> str:
             self.wf_counter += 1
             res = self.test_transaction(var2)
-            res2 = self.test_communicator(var)
+            res2 = self.test_step(var)
             DBOS.logger.info("I'm test_workflow")
             return res + res2
 
@@ -299,10 +299,10 @@ def test_simple_workflow_inst(dbos: DBOS) -> None:
             DBOS.logger.info("I'm test_transaction")
             return var2 + str(rows[0][0])
 
-        @DBOS.communicator()
-        def test_communicator(self, var: str) -> str:
-            self.comm_counter += 1
-            DBOS.logger.info("I'm test_communicator")
+        @DBOS.step()
+        def test_step(self, var: str) -> str:
+            self.step_counter += 1
+            DBOS.logger.info("I'm test_step")
             return var
 
     inst = DBOSTestClassInst()
@@ -321,7 +321,7 @@ def test_simple_workflow_inst(dbos: DBOS) -> None:
     assert wfh.get_result() == "bob1bob"
     assert inst.txn_counter == 2
     assert inst.wf_counter == 2
-    assert inst.comm_counter == 2
+    assert inst.step_counter == 2
 
 
 def test_forgotten_decorator(dbos: DBOS) -> None:
@@ -330,7 +330,7 @@ def test_forgotten_decorator(dbos: DBOS) -> None:
             super().__init__("bob", dbos)
             self.txn_counter: int = 0
             self.wf_counter: int = 0
-            self.comm_counter: int = 0
+            self.step_counter: int = 0
 
         @DBOS.workflow()
         def test_workflow1(self) -> str:

{dbos-0.5.0a3 → dbos-0.5.0a4}/tests/test_concurrency.py

@@ -32,15 +32,15 @@ def test_concurrent_workflows(dbos: DBOS) -> None:
 
 def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     condition = threading.Condition()
-    comm_count = 0
+    step_count = 0
     txn_count = 0
 
-    @DBOS.communicator()
-    def test_communicator() -> str:
-        nonlocal comm_count
-        comm_count += 1
+    @DBOS.step()
+    def test_step() -> str:
+        nonlocal step_count
+        step_count += 1
         condition.acquire()
-        if comm_count == 1:
+        if step_count == 1:
             # Wait for the other one to notify
             condition.wait()
         else:
@@ -50,12 +50,12 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
 
     @DBOS.workflow()
     def test_workflow() -> str:
-        res = test_communicator()
+        res = test_step()
         return res
 
     def test_comm_thread(id: str) -> str:
         with SetWorkflowID(id):
-            return test_communicator()
+            return test_step()
 
     # Need to set isolation level to a lower one, otherwise it gets serialization error instead (we already handle it correctly by automatic retries).
     @DBOS.transaction(isolation_level="REPEATABLE READ")
@@ -88,7 +88,7 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     assert wf_handle2.get_result() == wfuuid
 
     # Make sure temp workflows can handle conflicts as well.
-    comm_count = 0
+    step_count = 0
     wfuuid = str(uuid.uuid4())
     with ThreadPoolExecutor(max_workers=2) as executor:
         future1 = executor.submit(test_comm_thread, wfuuid)

{dbos-0.5.0a3 → dbos-0.5.0a4}/tests/test_dbos.py

@@ -15,7 +15,7 @@ from dbos import DBOS, ConfigFile, SetWorkflowID, WorkflowHandle, WorkflowStatus
 
 # Private API because this is a test
 from dbos.context import assert_current_dbos_context, get_local_dbos_context
-from dbos.error import DBOSCommunicatorMaxRetriesExceededError
+from dbos.error import DBOSMaxStepRetriesExceeded
 from dbos.system_database import GetWorkflowsInput
 from tests.conftest import default_config
 
@@ -23,14 +23,14 @@ from tests.conftest import default_config
 def test_simple_workflow(dbos: DBOS) -> None:
     txn_counter: int = 0
     wf_counter: int = 0
-    comm_counter: int = 0
+    step_counter: int = 0
 
     @DBOS.workflow()
     def test_workflow(var: str, var2: str) -> str:
         nonlocal wf_counter
         wf_counter += 1
         res = test_transaction(var2)
-        res2 = test_communicator(var)
+        res2 = test_step(var)
         DBOS.logger.info("I'm test_workflow")
         return res + res2
 
@@ -42,11 +42,11 @@ def test_simple_workflow(dbos: DBOS) -> None:
         DBOS.logger.info("I'm test_transaction")
         return var2 + str(rows[0][0])
 
-    @DBOS.communicator()
-    def test_communicator(var: str) -> str:
-        nonlocal comm_counter
-        comm_counter += 1
-        DBOS.logger.info("I'm test_communicator")
+    @DBOS.step()
+    def test_step(var: str) -> str:
+        nonlocal step_counter
+        step_counter += 1
+        DBOS.logger.info("I'm test_step")
         return var
 
     assert test_workflow("bob", "bob") == "bob1bob"
@@ -58,7 +58,7 @@ def test_simple_workflow(dbos: DBOS) -> None:
     with SetWorkflowID(wfuuid):
         assert test_workflow("alice", "alice") == "alice1alice"
     assert txn_counter == 2  # Only increment once
-    assert comm_counter == 2  # Only increment once
+    assert step_counter == 2  # Only increment once
 
     # Test we can execute the workflow by uuid
     handle = DBOS.execute_workflow_id(wfuuid)
@@ -69,7 +69,7 @@ def test_simple_workflow(dbos: DBOS) -> None:
 def test_child_workflow(dbos: DBOS) -> None:
     txn_counter: int = 0
     wf_counter: int = 0
-    comm_counter: int = 0
+    step_counter: int = 0
 
     @DBOS.transaction()
     def test_transaction(var2: str) -> str:
@@ -79,11 +79,11 @@ def test_child_workflow(dbos: DBOS) -> None:
         DBOS.logger.info("I'm test_transaction")
         return var2 + str(rows[0][0])
 
-    @DBOS.communicator()
-    def test_communicator(var: str) -> str:
-        nonlocal comm_counter
-        comm_counter += 1
-        DBOS.logger.info("I'm test_communicator")
+    @DBOS.step()
+    def test_step(var: str) -> str:
+        nonlocal step_counter
+        step_counter += 1
+        DBOS.logger.info("I'm test_step")
         return var
 
     @DBOS.workflow()
@@ -96,7 +96,7 @@ def test_child_workflow(dbos: DBOS) -> None:
         nonlocal wf_counter
         wf_counter += 1
         res = test_transaction(var2)
-        res2 = test_communicator(var)
+        res2 = test_step(var)
         return res + res2
 
     @DBOS.workflow()
@@ -159,7 +159,7 @@ def test_child_workflow(dbos: DBOS) -> None:
 def test_exception_workflow(dbos: DBOS) -> None:
     txn_counter: int = 0
     wf_counter: int = 0
-    comm_counter: int = 0
+    step_counter: int = 0
 
     @DBOS.transaction()
     def exception_transaction(var: str) -> str:
@@ -167,10 +167,10 @@ def test_exception_workflow(dbos: DBOS) -> None:
         txn_counter += 1
         raise Exception(var)
 
-    @DBOS.communicator()
-    def exception_communicator(var: str) -> str:
-        nonlocal comm_counter
-        comm_counter += 1
+    @DBOS.step()
+    def exception_step(var: str) -> str:
+        nonlocal step_counter
+        step_counter += 1
         raise Exception(var)
 
     @DBOS.workflow()
@@ -185,7 +185,7 @@ def test_exception_workflow(dbos: DBOS) -> None:
             err1 = e
 
         try:
-            exception_communicator("test error")
+            exception_step("test error")
         except Exception as e:
             err2 = e
         assert err1 is not None and err2 is not None
@@ -209,7 +209,7 @@ def test_exception_workflow(dbos: DBOS) -> None:
             exception_workflow()
     assert "test error" == str(exc_info.value)
     assert txn_counter == 2  # Only increment once
-    assert comm_counter == 2  # Only increment once
+    assert step_counter == 2  # Only increment once
 
     # Test we can execute the workflow by uuid, shouldn't throw errors
     handle = DBOS.execute_workflow_id(wfuuid)
@@ -221,7 +221,7 @@ def test_exception_workflow(dbos: DBOS) -> None:
 
 def test_temp_workflow(dbos: DBOS) -> None:
     txn_counter: int = 0
-    comm_counter: int = 0
+    step_counter: int = 0
 
     cur_time: str = datetime.datetime.now().isoformat()
     gwi: GetWorkflowsInput = GetWorkflowsInput()
@@ -234,21 +234,21 @@ def test_temp_workflow(dbos: DBOS) -> None:
         txn_counter += 1
         return var2 + str(rows[0][0])
 
-    @DBOS.communicator()
-    def test_communicator(var: str) -> str:
-        nonlocal comm_counter
-        comm_counter += 1
+    @DBOS.step()
+    def test_step(var: str) -> str:
+        nonlocal step_counter
+        step_counter += 1
         return var
 
-    @DBOS.communicator()
-    def call_communicator(var: str) -> str:
-        return test_communicator(var)
+    @DBOS.step()
+    def call_step(var: str) -> str:
+        return test_step(var)
 
     assert get_local_dbos_context() is None
     res = test_transaction("var2")
     assert res == "var21"
     assert get_local_dbos_context() is None
-    res = test_communicator("var")
+    res = test_step("var")
     assert res == "var"
 
     # Wait for buffers to flush
@@ -265,17 +265,17 @@ def test_temp_workflow(dbos: DBOS) -> None:
     assert wfi2["name"].startswith("<temp>")
 
     assert txn_counter == 1
-    assert comm_counter == 1
+    assert step_counter == 1
 
-    res = call_communicator("var2")
+    res = call_step("var2")
     assert res == "var2"
-    assert comm_counter == 2
+    assert step_counter == 2
 
 
 def test_temp_workflow_errors(dbos: DBOS) -> None:
     txn_counter: int = 0
-    comm_counter: int = 0
-    retried_comm_counter: int = 0
+    step_counter: int = 0
+    retried_step_counter: int = 0
 
     cur_time: str = datetime.datetime.now().isoformat()
     gwi: GetWorkflowsInput = GetWorkflowsInput()
@@ -287,16 +287,16 @@ def test_temp_workflow_errors(dbos: DBOS) -> None:
         txn_counter += 1
         raise Exception(var2)
 
-    @DBOS.communicator()
-    def test_communicator(var: str) -> str:
-        nonlocal comm_counter
-        comm_counter += 1
+    @DBOS.step()
+    def test_step(var: str) -> str:
+        nonlocal step_counter
+        step_counter += 1
         raise Exception(var)
 
-    @DBOS.communicator(retries_allowed=True)
-    def test_retried_communicator(var: str) -> str:
-        nonlocal retried_comm_counter
-        retried_comm_counter += 1
+    @DBOS.step(retries_allowed=True)
+    def test_retried_step(var: str) -> str:
+        nonlocal retried_step_counter
+        retried_step_counter += 1
         raise Exception(var)
 
     with pytest.raises(Exception) as exc_info:
@@ -304,15 +304,15 @@ def test_temp_workflow_errors(dbos: DBOS) -> None:
     assert "tval" == str(exc_info.value)
 
     with pytest.raises(Exception) as exc_info:
-        test_communicator("cval")
+        test_step("cval")
     assert "cval" == str(exc_info.value)
 
-    with pytest.raises(DBOSCommunicatorMaxRetriesExceededError) as exc_info:
-        test_retried_communicator("rval")
+    with pytest.raises(DBOSMaxStepRetriesExceeded) as exc_info:
+        test_retried_step("rval")
 
     assert txn_counter == 1
-    assert comm_counter == 1
-    assert retried_comm_counter == 3
+    assert step_counter == 1
+    assert retried_step_counter == 3
 
 
 def test_recovery_workflow(dbos: DBOS) -> None:

{dbos-0.5.0a3 → dbos-0.5.0a4}/tests/test_fastapi.py

@@ -29,7 +29,7 @@ def test_simple_endpoint(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
         DBOS.span.set_attribute("test_key", "test_value")
         assert DBOS.request is not None
         res1 = test_transaction(var1)
-        res2 = test_communicator(var2)
+        res2 = test_step(var2)
         return res1 + res2
 
     @DBOS.transaction()
@@ -37,8 +37,8 @@ def test_simple_endpoint(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
         rows = DBOS.sql_session.execute(sa.text("SELECT 1")).fetchall()
         return var + str(rows[0][0])
 
-    @DBOS.communicator()
-    def test_communicator(var: str) -> str:
+    @DBOS.step()
+    def test_step(var: str) -> str:
         return var
 
     response = client.get("/workflow/bob/bob")
@@ -66,7 +66,7 @@ def test_start_workflow(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
         DBOS.span.set_attribute("test_key", "test_value")
         assert DBOS.request is not None
         res1 = test_transaction(var1)
-        res2 = test_communicator(var2)
+        res2 = test_step(var2)
         return res1 + res2
 
     @DBOS.transaction()
@@ -74,8 +74,8 @@ def test_start_workflow(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
         rows = DBOS.sql_session.execute(sa.text("SELECT 1")).fetchall()
         return var + str(rows[0][0])
 
-    @DBOS.communicator()
-    def test_communicator(var: str) -> str:
+    @DBOS.step()
+    def test_step(var: str) -> str:
         return var
 
     response = client.get("/bob/bob")