dbos 1.5.0a10__tar.gz → 1.8.0a1__tar.gz

{dbos-1.5.0a10 → dbos-1.8.0a1}/PKG-INFO

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

{dbos-1.5.0a10 → dbos-1.8.0a1}/dbos/_admin_server.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict
 
 from dbos._workflow_commands import garbage_collect, global_timeout
 
+from ._conductor import protocol as conductor_protocol
 from ._context import SetWorkflowID
 from ._error import DBOSException
 from ._logger import dbos_logger
@@ -118,7 +119,12 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
                     self.send_response(404)
                     self._end_headers()
                     return
-                response_body = json.dumps(workflows[0].__dict__).encode("utf-8")
+                workflow_output = (
+                    conductor_protocol.WorkflowsOutput.from_workflow_information(
+                        workflows[0]
+                    )
+                )
+                response_body = json.dumps(workflow_output.__dict__).encode("utf-8")
                 self.send_response(200)
                 self.send_header("Content-Type", "application/json")
                 self.send_header("Content-Length", str(len(response_body)))
@@ -326,20 +332,26 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
 
     def _handle_workflows(self, filters: Dict[str, Any]) -> None:
         workflows = self.dbos.list_workflows(
-            workflow_ids=filters.get("workflow_ids"),
-            name=filters.get("name"),
+            workflow_ids=filters.get("workflow_uuids"),
+            user=filters.get("authenticated_user"),
             start_time=filters.get("start_time"),
             end_time=filters.get("end_time"),
             status=filters.get("status"),
             app_version=filters.get("application_version"),
+            name=filters.get("workflow_name"),
             limit=filters.get("limit"),
             offset=filters.get("offset"),
             sort_desc=filters.get("sort_desc", False),
             workflow_id_prefix=filters.get("workflow_id_prefix"),
+            load_input=filters.get("load_input", False),
+            load_output=filters.get("load_output", False),
         )
-
+        workflows_output = [
+            conductor_protocol.WorkflowsOutput.from_workflow_information(i)
+            for i in workflows
+        ]
         response_body = json.dumps(
-            [workflow.__dict__ for workflow in workflows]
+            [workflow.__dict__ for workflow in workflows_output]
         ).encode("utf-8")
         self.send_response(200)
         self.send_header("Content-Type", "application/json")
@@ -349,18 +361,22 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
 
     def _handle_queued_workflows(self, filters: Dict[str, Any]) -> None:
         workflows = self.dbos.list_queued_workflows(
-            queue_name=filters.get("queue_name"),
-            name=filters.get("name"),
             start_time=filters.get("start_time"),
             end_time=filters.get("end_time"),
             status=filters.get("status"),
+            name=filters.get("workflow_name"),
             limit=filters.get("limit"),
             offset=filters.get("offset"),
+            queue_name=filters.get("queue_name"),
             sort_desc=filters.get("sort_desc", False),
+            load_input=filters.get("load_input", False),
         )
-
+        workflows_output = [
+            conductor_protocol.WorkflowsOutput.from_workflow_information(i)
+            for i in workflows
+        ]
         response_body = json.dumps(
-            [workflow.__dict__ for workflow in workflows]
+            [workflow.__dict__ for workflow in workflows_output]
         ).encode("utf-8")
         self.send_response(200)
         self.send_header("Content-Type", "application/json")

{dbos-1.5.0a10 → dbos-1.8.0a1}/dbos/_client.py

@@ -1,7 +1,7 @@
 import asyncio
 import sys
 import uuid
-from typing import Any, Generic, List, Optional, TypedDict, TypeVar
+from typing import Any, Generic, List, Optional, TypedDict, TypeVar, Union
 
 from dbos._app_db import ApplicationDatabase
 from dbos._context import MaxPriority, MinPriority
@@ -128,7 +128,6 @@ class DBOSClient:
         workflow_name = options["workflow_name"]
         queue_name = options["queue_name"]
 
-        app_version = options.get("app_version")
         max_recovery_attempts = options.get("max_recovery_attempts")
         if max_recovery_attempts is None:
             max_recovery_attempts = DEFAULT_MAX_RECOVERY_ATTEMPTS
@@ -139,6 +138,7 @@ class DBOSClient:
         enqueue_options_internal: EnqueueOptionsInternal = {
             "deduplication_id": options.get("deduplication_id"),
             "priority": options.get("priority"),
+            "app_version": options.get("app_version"),
         }
 
         inputs: WorkflowInputs = {
@@ -152,7 +152,7 @@ class DBOSClient:
             "name": workflow_name,
             "class_name": None,
             "queue_name": queue_name,
-            "app_version": app_version,
+            "app_version": enqueue_options_internal["app_version"],
             "config_name": None,
             "authenticated_user": None,
             "assumed_role": None,
@@ -284,7 +284,7 @@ class DBOSClient:
         self,
         *,
         workflow_ids: Optional[List[str]] = None,
-        status: Optional[str] = None,
+        status: Optional[Union[str, List[str]]] = None,
         start_time: Optional[str] = None,
         end_time: Optional[str] = None,
         name: Optional[str] = None,
@@ -294,6 +294,8 @@ class DBOSClient:
         offset: Optional[int] = None,
         sort_desc: bool = False,
         workflow_id_prefix: Optional[str] = None,
+        load_input: bool = True,
+        load_output: bool = True,
     ) -> List[WorkflowStatus]:
         return list_workflows(
             self._sys_db,
@@ -308,13 +310,15 @@ class DBOSClient:
             offset=offset,
             sort_desc=sort_desc,
             workflow_id_prefix=workflow_id_prefix,
+            load_input=load_input,
+            load_output=load_output,
         )
 
     async def list_workflows_async(
         self,
         *,
         workflow_ids: Optional[List[str]] = None,
-        status: Optional[str] = None,
+        status: Optional[Union[str, List[str]]] = None,
         start_time: Optional[str] = None,
         end_time: Optional[str] = None,
         name: Optional[str] = None,
@@ -324,6 +328,8 @@ class DBOSClient:
         offset: Optional[int] = None,
         sort_desc: bool = False,
         workflow_id_prefix: Optional[str] = None,
+        load_input: bool = True,
+        load_output: bool = True,
     ) -> List[WorkflowStatus]:
         return await asyncio.to_thread(
             self.list_workflows,
@@ -338,19 +344,22 @@ class DBOSClient:
             offset=offset,
             sort_desc=sort_desc,
             workflow_id_prefix=workflow_id_prefix,
+            load_input=load_input,
+            load_output=load_output,
         )
 
     def list_queued_workflows(
         self,
         *,
         queue_name: Optional[str] = None,
-        status: Optional[str] = None,
+        status: Optional[Union[str, List[str]]] = None,
         start_time: Optional[str] = None,
         end_time: Optional[str] = None,
         name: Optional[str] = None,
         limit: Optional[int] = None,
         offset: Optional[int] = None,
         sort_desc: bool = False,
+        load_input: bool = True,
     ) -> List[WorkflowStatus]:
         return list_queued_workflows(
             self._sys_db,
@@ -362,19 +371,21 @@ class DBOSClient:
             limit=limit,
             offset=offset,
             sort_desc=sort_desc,
+            load_input=load_input,
         )
 
     async def list_queued_workflows_async(
         self,
         *,
         queue_name: Optional[str] = None,
-        status: Optional[str] = None,
+        status: Optional[Union[str, List[str]]] = None,
         start_time: Optional[str] = None,
         end_time: Optional[str] = None,
         name: Optional[str] = None,
         limit: Optional[int] = None,
         offset: Optional[int] = None,
         sort_desc: bool = False,
+        load_input: bool = True,
     ) -> List[WorkflowStatus]:
         return await asyncio.to_thread(
             self.list_queued_workflows,
@@ -386,6 +397,7 @@ class DBOSClient:
             limit=limit,
             offset=offset,
             sort_desc=sort_desc,
+            load_input=load_input,
         )
 
     def list_workflow_steps(self, workflow_id: str) -> List[StepInfo]:

{dbos-1.5.0a10 → dbos-1.8.0a1}/dbos/_conductor/conductor.py

@@ -223,6 +223,8 @@ class ConductorWebsocket(threading.Thread):
                             body = list_workflows_message.body
                             infos = []
                             try:
+                                load_input = body.get("load_input", False)
+                                load_output = body.get("load_output", False)
                                 infos = list_workflows(
                                     self.dbos._sys_db,
                                     workflow_ids=body["workflow_uuids"],
@@ -235,6 +237,8 @@ class ConductorWebsocket(threading.Thread):
                                     limit=body["limit"],
                                     offset=body["offset"],
                                     sort_desc=body["sort_desc"],
+                                    load_input=load_input,
+                                    load_output=load_output,
                                 )
                             except Exception as e:
                                 error_message = f"Exception encountered when listing workflows: {traceback.format_exc()}"
@@ -257,6 +261,7 @@ class ConductorWebsocket(threading.Thread):
                             q_body = list_queued_workflows_message.body
                             infos = []
                             try:
+                                q_load_input = q_body.get("load_input", False)
                                 infos = list_queued_workflows(
                                     self.dbos._sys_db,
                                     start_time=q_body["start_time"],
@@ -267,6 +272,7 @@ class ConductorWebsocket(threading.Thread):
                                     offset=q_body["offset"],
                                     queue_name=q_body["queue_name"],
                                     sort_desc=q_body["sort_desc"],
+                                    load_input=q_load_input,
                                 )
                             except Exception as e:
                                 error_message = f"Exception encountered when listing queued workflows: {traceback.format_exc()}"

{dbos-1.5.0a10 → dbos-1.8.0a1}/dbos/_conductor/protocol.py

@@ -110,7 +110,7 @@ class RestartResponse(BaseMessage):
     error_message: Optional[str] = None
 
 
-class ListWorkflowsBody(TypedDict):
+class ListWorkflowsBody(TypedDict, total=False):
     workflow_uuids: List[str]
     workflow_name: Optional[str]
     authenticated_user: Optional[str]
@@ -121,6 +121,8 @@ class ListWorkflowsBody(TypedDict):
     limit: Optional[int]
     offset: Optional[int]
     sort_desc: bool
+    load_input: bool
+    load_output: bool
 
 
 @dataclass
@@ -209,7 +211,7 @@ class ListWorkflowsResponse(BaseMessage):
     error_message: Optional[str] = None
 
 
-class ListQueuedWorkflowsBody(TypedDict):
+class ListQueuedWorkflowsBody(TypedDict, total=False):
     workflow_name: Optional[str]
     start_time: Optional[str]
     end_time: Optional[str]
@@ -218,6 +220,7 @@ class ListQueuedWorkflowsBody(TypedDict):
     limit: Optional[int]
     offset: Optional[int]
     sort_desc: bool
+    load_input: bool
 
 
 @dataclass

{dbos-1.5.0a10 → dbos-1.8.0a1}/dbos/_context.py

@@ -93,6 +93,8 @@ class DBOSContext:
         self.assumed_role: Optional[str] = None
         self.step_status: Optional[StepStatus] = None
 
+        self.app_version: Optional[str] = None
+
         # A user-specified workflow timeout. Takes priority over a propagated deadline.
         self.workflow_timeout_ms: Optional[int] = None
         # A propagated workflow deadline.
@@ -138,23 +140,18 @@ class DBOSContext:
         self,
         wfid: Optional[str],
         attributes: TracedAttributes,
-        is_temp_workflow: bool = False,
     ) -> None:
         if wfid is None or len(wfid) == 0:
             wfid = self.assign_workflow_id()
             self.id_assigned_for_next_workflow = ""
         self.workflow_id = wfid
         self.function_id = 0
-        if not is_temp_workflow:
-            self._start_span(attributes)
+        self._start_span(attributes)
 
-    def end_workflow(
-        self, exc_value: Optional[BaseException], is_temp_workflow: bool = False
-    ) -> None:
+    def end_workflow(self, exc_value: Optional[BaseException]) -> None:
         self.workflow_id = ""
         self.function_id = -1
-        if not is_temp_workflow:
-            self._end_span(exc_value)
+        self._end_span(exc_value)
 
     def is_within_workflow(self) -> bool:
         return len(self.workflow_id) > 0
@@ -435,7 +432,11 @@ class SetEnqueueOptions:
     """
 
     def __init__(
-        self, *, deduplication_id: Optional[str] = None, priority: Optional[int] = None
+        self,
+        *,
+        deduplication_id: Optional[str] = None,
+        priority: Optional[int] = None,
+        app_version: Optional[str] = None,
     ) -> None:
         self.created_ctx = False
         self.deduplication_id: Optional[str] = deduplication_id
@@ -446,6 +447,8 @@ class SetEnqueueOptions:
             )
         self.priority: Optional[int] = priority
         self.saved_priority: Optional[int] = None
+        self.app_version: Optional[str] = app_version
+        self.saved_app_version: Optional[str] = None
 
     def __enter__(self) -> SetEnqueueOptions:
         # Code to create a basic context
@@ -458,6 +461,8 @@ class SetEnqueueOptions:
         ctx.deduplication_id = self.deduplication_id
         self.saved_priority = ctx.priority
         ctx.priority = self.priority
+        self.saved_app_version = ctx.app_version
+        ctx.app_version = self.app_version
         return self
 
     def __exit__(
@@ -469,6 +474,7 @@ class SetEnqueueOptions:
         curr_ctx = assert_current_dbos_context()
         curr_ctx.deduplication_id = self.saved_deduplication_id
         curr_ctx.priority = self.saved_priority
+        curr_ctx.app_version = self.saved_app_version
         # Code to clean up the basic context if we created it
         if self.created_ctx:
             _clear_local_dbos_context()
@@ -479,7 +485,6 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
     def __init__(self, attributes: TracedAttributes) -> None:
         self.created_ctx = False
         self.attributes = attributes
-        self.is_temp_workflow = attributes["name"] == "temp_wf"
         self.saved_workflow_timeout: Optional[int] = None
         self.saved_deduplication_id: Optional[str] = None
         self.saved_priority: Optional[int] = None
@@ -503,7 +508,7 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         self.saved_priority = ctx.priority
         ctx.priority = None
         ctx.start_workflow(
-            None, self.attributes, self.is_temp_workflow
+            None, self.attributes
         )  # Will get from the context's next workflow ID
         return ctx
 
@@ -515,7 +520,7 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
     ) -> Literal[False]:
         ctx = assert_current_dbos_context()
         assert ctx.is_within_workflow()
-        ctx.end_workflow(exc_value, self.is_temp_workflow)
+        ctx.end_workflow(exc_value)
         # Restore the saved workflow timeout
         ctx.workflow_timeout_ms = self.saved_workflow_timeout
         # Clear any propagating timeout

{dbos-1.5.0a10 → dbos-1.8.0a1}/dbos/_core.py

@@ -270,7 +270,12 @@ def _init_workflow(
         "output": None,
         "error": None,
         "app_id": ctx.app_id,
-        "app_version": GlobalParams.app_version,
+        "app_version": (
+            enqueue_options["app_version"]
+            if enqueue_options is not None
+            and enqueue_options["app_version"] is not None
+            else GlobalParams.app_version
+        ),
         "executor_id": ctx.executor_id,
         "recovery_attempts": None,
         "authenticated_user": ctx.authenticated_user,
@@ -387,7 +392,7 @@ def _execute_workflow_wthread(
     **kwargs: Any,
 ) -> R:
     attributes: TracedAttributes = {
-        "name": func.__name__,
+        "name": get_dbos_func_name(func),
         "operationType": OperationType.WORKFLOW.value,
     }
     with DBOSContextSwap(ctx):
@@ -420,7 +425,7 @@ async def _execute_workflow_async(
     **kwargs: Any,
 ) -> R:
     attributes: TracedAttributes = {
-        "name": func.__name__,
+        "name": get_dbos_func_name(func),
         "operationType": OperationType.WORKFLOW.value,
     }
     with DBOSContextSwap(ctx):
@@ -445,7 +450,8 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
     wf_func = dbos._registry.workflow_info_map.get(status["name"], None)
     if not wf_func:
         raise DBOSWorkflowFunctionNotFoundError(
-            workflow_id, "Workflow function not found"
+            workflow_id,
+            f"Cannot execute workflow because {status['name']} is not a registered workflow function",
         )
     with DBOSContextEnsure():
         # If this function belongs to a configured class, add that class instance as its first argument
@@ -526,7 +532,8 @@ def start_workflow(
     fi = get_func_info(func)
     if fi is None:
         raise DBOSWorkflowFunctionNotFoundError(
-            "<NONE>", f"start_workflow: function {func.__name__} is not registered"
+            "<NONE>",
+            f"start_workflow: function {func.__name__} is not registered",
         )
 
     func = cast("Workflow[P, R]", func.__orig_func)  # type: ignore
@@ -546,6 +553,7 @@ def start_workflow(
     enqueue_options = EnqueueOptionsInternal(
         deduplication_id=local_ctx.deduplication_id if local_ctx is not None else None,
         priority=local_ctx.priority if local_ctx is not None else None,
+        app_version=local_ctx.app_version if local_ctx is not None else None,
     )
     new_wf_id, new_wf_ctx = _get_new_wf()
 
@@ -620,7 +628,8 @@ async def start_workflow_async(
     fi = get_func_info(func)
     if fi is None:
         raise DBOSWorkflowFunctionNotFoundError(
-            "<NONE>", f"start_workflow: function {func.__name__} is not registered"
+            "<NONE>",
+            f"start_workflow: function {func.__name__} is not registered",
         )
 
     func = cast("Workflow[P, R]", func.__orig_func)  # type: ignore
@@ -637,6 +646,7 @@ async def start_workflow_async(
     enqueue_options = EnqueueOptionsInternal(
         deduplication_id=local_ctx.deduplication_id if local_ctx is not None else None,
         priority=local_ctx.priority if local_ctx is not None else None,
+        app_version=local_ctx.app_version if local_ctx is not None else None,
     )
     new_wf_id, new_wf_ctx = _get_new_wf()
 
@@ -723,13 +733,13 @@ def workflow_wrapper(
         assert fi is not None
         if dbosreg.dbos is None:
             raise DBOSException(
-                f"Function {func.__name__} invoked before DBOS initialized"
+                f"Function {get_dbos_func_name(func)} invoked before DBOS initialized"
             )
         dbos = dbosreg.dbos
 
         rr: Optional[str] = check_required_roles(func, fi)
         attributes: TracedAttributes = {
-            "name": func.__name__,
+            "name": get_dbos_func_name(func),
             "operationType": OperationType.WORKFLOW.value,
         }
         inputs: WorkflowInputs = {
@@ -829,27 +839,30 @@ def workflow_wrapper(
 
 
 def decorate_workflow(
-    reg: "DBOSRegistry", max_recovery_attempts: Optional[int]
+    reg: "DBOSRegistry", name: Optional[str], max_recovery_attempts: Optional[int]
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def _workflow_decorator(func: Callable[P, R]) -> Callable[P, R]:
         wrapped_func = workflow_wrapper(reg, func, max_recovery_attempts)
-        reg.register_wf_function(func.__qualname__, wrapped_func, "workflow")
+        func_name = name if name is not None else func.__qualname__
+        set_dbos_func_name(func, func_name)
+        set_dbos_func_name(wrapped_func, func_name)
+        reg.register_wf_function(func_name, wrapped_func, "workflow")
         return wrapped_func
 
     return _workflow_decorator
 
 
 def decorate_transaction(
-    dbosreg: "DBOSRegistry", isolation_level: "IsolationLevel" = "SERIALIZABLE"
+    dbosreg: "DBOSRegistry", name: Optional[str], isolation_level: "IsolationLevel"
 ) -> Callable[[F], F]:
     def decorator(func: F) -> F:
 
-        transaction_name = func.__qualname__
+        transaction_name = name if name is not None else func.__qualname__
 
         def invoke_tx(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
                 raise DBOSException(
-                    f"Function {func.__name__} invoked before DBOS initialized"
+                    f"Function {transaction_name} invoked before DBOS initialized"
                 )
 
             dbos = dbosreg.dbos
@@ -857,12 +870,12 @@ def decorate_transaction(
             status = dbos._sys_db.get_workflow_status(ctx.workflow_id)
             if status and status["status"] == WorkflowStatusString.CANCELLED.value:
                 raise DBOSWorkflowCancelledError(
-                    f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {func.__name__}."
+                    f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {transaction_name}."
                 )
 
             with dbos._app_db.sessionmaker() as session:
                 attributes: TracedAttributes = {
-                    "name": func.__name__,
+                    "name": transaction_name,
                     "operationType": OperationType.TRANSACTION.value,
                 }
                 with EnterDBOSTransaction(session, attributes=attributes):
@@ -963,7 +976,7 @@ def decorate_transaction(
                             raise
                         except InvalidRequestError as invalid_request_error:
                             dbos.logger.error(
-                                f"InvalidRequestError in transaction {func.__qualname__} \033[1m Hint: Do not call commit() or rollback() within a DBOS transaction.\033[0m"
+                                f"InvalidRequestError in transaction {transaction_name} \033[1m Hint: Do not call commit() or rollback() within a DBOS transaction.\033[0m"
                             )
                             txn_error = invalid_request_error
                             raise
@@ -983,7 +996,7 @@ def decorate_transaction(
 
         if inspect.iscoroutinefunction(func):
             raise DBOSException(
-                f"Function {func.__name__} is a coroutine function, but DBOS.transaction does not support coroutine functions"
+                f"Function {transaction_name} is a coroutine function, but DBOS.transaction does not support coroutine functions"
             )
 
         fi = get_or_create_func_info(func)
@@ -1002,15 +1015,19 @@ def decorate_transaction(
                 with DBOSAssumeRole(rr):
                     return invoke_tx(*args, **kwargs)
             else:
-                tempwf = dbosreg.workflow_info_map.get("<temp>." + func.__qualname__)
+                tempwf = dbosreg.workflow_info_map.get("<temp>." + transaction_name)
                 assert tempwf
                 return tempwf(*args, **kwargs)
 
+        set_dbos_func_name(func, transaction_name)
+        set_dbos_func_name(wrapper, transaction_name)
+
         def temp_wf(*args: Any, **kwargs: Any) -> Any:
             return wrapper(*args, **kwargs)
 
         wrapped_wf = workflow_wrapper(dbosreg, temp_wf)
-        set_dbos_func_name(temp_wf, "<temp>." + func.__qualname__)
+        set_dbos_func_name(temp_wf, "<temp>." + transaction_name)
+        set_dbos_func_name(wrapped_wf, "<temp>." + transaction_name)
         set_temp_workflow_type(temp_wf, "transaction")
         dbosreg.register_wf_function(
             get_dbos_func_name(temp_wf), wrapped_wf, "transaction"
@@ -1027,24 +1044,25 @@ def decorate_transaction(
 def decorate_step(
     dbosreg: "DBOSRegistry",
     *,
-    retries_allowed: bool = False,
-    interval_seconds: float = 1.0,
-    max_attempts: int = 3,
-    backoff_rate: float = 2.0,
+    name: Optional[str],
+    retries_allowed: bool,
+    interval_seconds: float,
+    max_attempts: int,
+    backoff_rate: float,
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def decorator(func: Callable[P, R]) -> Callable[P, R]:
 
-        step_name = func.__qualname__
+        step_name = name if name is not None else func.__qualname__
 
         def invoke_step(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
                 raise DBOSException(
-                    f"Function {func.__name__} invoked before DBOS initialized"
+                    f"Function {step_name} invoked before DBOS initialized"
                 )
             dbos = dbosreg.dbos
 
             attributes: TracedAttributes = {
-                "name": func.__name__,
+                "name": step_name,
                 "operationType": OperationType.STEP.value,
             }
 
@@ -1123,7 +1141,7 @@ def decorate_step(
                 stepOutcome = stepOutcome.retry(
                     max_attempts,
                     on_exception,
-                    lambda i, e: DBOSMaxStepRetriesExceeded(func.__name__, i, e),
+                    lambda i, e: DBOSMaxStepRetriesExceeded(step_name, i, e),
                 )
 
             outcome = (
@@ -1139,20 +1157,23 @@ def decorate_step(
         def wrapper(*args: Any, **kwargs: Any) -> Any:
             rr: Optional[str] = check_required_roles(func, fi)
             # Entering step is allowed:
+            #  No DBOS, just call the original function directly
             #  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)
+            if not dbosreg.dbos or not dbosreg.dbos._launched:
+                # Call the original function directly
+                return func(*args, **kwargs)
             ctx = get_local_dbos_context()
             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(), "Steps must be called from within workflows"
                 with DBOSAssumeRole(rr):
                     return invoke_step(*args, **kwargs)
             else:
-                tempwf = dbosreg.workflow_info_map.get("<temp>." + func.__qualname__)
+                tempwf = dbosreg.workflow_info_map.get("<temp>." + step_name)
                 assert tempwf
                 return tempwf(*args, **kwargs)
 
@@ -1160,20 +1181,19 @@ def decorate_step(
             _mark_coroutine(wrapper) if inspect.iscoroutinefunction(func) else wrapper  # type: ignore
         )
 
+        set_dbos_func_name(func, step_name)
+        set_dbos_func_name(wrapper, step_name)
+
         def temp_wf_sync(*args: Any, **kwargs: Any) -> Any:
             return wrapper(*args, **kwargs)
 
         async def temp_wf_async(*args: Any, **kwargs: Any) -> Any:
             return await wrapper(*args, **kwargs)
 
-        # Other code in transact-py depends on the name of temporary workflow functions to be "temp_wf"
-        # so set the name of both sync and async temporary workflow functions explicitly
-        temp_wf_sync.__name__ = "temp_wf"
-        temp_wf_async.__name__ = "temp_wf"
-
         temp_wf = temp_wf_async if inspect.iscoroutinefunction(func) else temp_wf_sync
         wrapped_wf = workflow_wrapper(dbosreg, temp_wf)
-        set_dbos_func_name(temp_wf, "<temp>." + func.__qualname__)
+        set_dbos_func_name(temp_wf, "<temp>." + step_name)
+        set_dbos_func_name(wrapped_wf, "<temp>." + step_name)
         set_temp_workflow_type(temp_wf, "step")
         dbosreg.register_wf_function(get_dbos_func_name(temp_wf), wrapped_wf, "step")
         wrapper.__orig_func = temp_wf  # type: ignore