dbos 0.26.0a18__py3-none-any.whl → 0.26.0a21__py3-none-any.whl

dbos/__init__.py

@@ -5,8 +5,7 @@ from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle
 from ._dbos_config import ConfigFile, DBOSConfig, get_dbos_database_url, load_config
 from ._kafka_message import KafkaMessage
 from ._queue import Queue
-from ._sys_db import GetWorkflowsInput, WorkflowStatusString
-from ._workflow_commands import WorkflowStatus
+from ._sys_db import GetWorkflowsInput, WorkflowStatus, WorkflowStatusString
 
 __all__ = [
     "ConfigFile",

dbos/_app_db.py

@@ -74,9 +74,12 @@ class ApplicationDatabase:
                 database["connectionTimeoutMillis"] / 1000
             )
 
+        pool_size = database.get("app_db_pool_size")
+        if pool_size is None:
+            pool_size = 20
         self.engine = sa.create_engine(
             app_db_url,
-            pool_size=database["app_db_pool_size"],
+            pool_size=pool_size,
             max_overflow=0,
             pool_timeout=30,
             connect_args=connect_args,

dbos/_client.py

@@ -3,6 +3,8 @@ import sys
 import uuid
 from typing import Any, Generic, List, Optional, TypedDict, TypeVar
 
+from dbos._app_db import ApplicationDatabase
+
 if sys.version_info < (3, 11):
     from typing_extensions import NotRequired
 else:
@@ -14,11 +16,18 @@ from dbos._dbos_config import parse_database_url_to_dbconfig
 from dbos._error import DBOSNonExistentWorkflowError
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
 from dbos._serialization import WorkflowInputs
-from dbos._sys_db import SystemDatabase, WorkflowStatusInternal, WorkflowStatusString
-from dbos._workflow_commands import (
+from dbos._sys_db import (
+    StepInfo,
+    SystemDatabase,
     WorkflowStatus,
+    WorkflowStatusInternal,
+    WorkflowStatusString,
+)
+from dbos._workflow_commands import (
+    fork_workflow,
     get_workflow,
     list_queued_workflows,
+    list_workflow_steps,
     list_workflows,
 )
 
@@ -45,7 +54,7 @@ class WorkflowHandleClientPolling(Generic[R]):
         res: R = self._sys_db.await_workflow_result(self.workflow_id)
         return res
 
-    def get_status(self) -> "WorkflowStatus":
+    def get_status(self) -> WorkflowStatus:
         status = get_workflow(self._sys_db, self.workflow_id, True)
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
@@ -67,7 +76,7 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
         )
         return res
 
-    async def get_status(self) -> "WorkflowStatus":
+    async def get_status(self) -> WorkflowStatus:
         status = await asyncio.to_thread(
             get_workflow, self._sys_db, self.workflow_id, True
         )
@@ -82,6 +91,7 @@ class DBOSClient:
         if system_database is not None:
             db_config["sys_db_name"] = system_database
         self._sys_db = SystemDatabase(db_config)
+        self._app_db = ApplicationDatabase(db_config)
 
     def destroy(self) -> None:
         self._sys_db.destroy()
@@ -124,7 +134,9 @@ class DBOSClient:
             "kwargs": kwargs,
         }
 
-        self._sys_db.init_workflow(status, _serialization.serialize_args(inputs))
+        self._sys_db.init_workflow(
+            status, _serialization.serialize_args(inputs), max_recovery_attempts=None
+        )
         return workflow_id
 
     def enqueue(
@@ -180,7 +192,9 @@ class DBOSClient:
             "app_version": None,
         }
         with self._sys_db.engine.begin() as conn:
-            self._sys_db.insert_workflow_status(status, conn)
+            self._sys_db.insert_workflow_status(
+                status, conn, max_recovery_attempts=None
+            )
         self._sys_db.send(status["workflow_uuid"], 0, destination_id, message, topic)
 
     async def send_async(
@@ -321,3 +335,23 @@ class DBOSClient:
             offset=offset,
             sort_desc=sort_desc,
         )
+
+    def list_workflow_steps(self, workflow_id: str) -> List[StepInfo]:
+        return list_workflow_steps(self._sys_db, self._app_db, workflow_id)
+
+    async def list_workflow_steps_async(self, workflow_id: str) -> List[StepInfo]:
+        return await asyncio.to_thread(self.list_workflow_steps, workflow_id)
+
+    def fork_workflow(self, workflow_id: str, start_step: int) -> WorkflowHandle[R]:
+        forked_workflow_id = fork_workflow(
+            self._sys_db, self._app_db, workflow_id, start_step
+        )
+        return WorkflowHandleClientPolling[R](forked_workflow_id, self._sys_db)
+
+    async def fork_workflow_async(
+        self, workflow_id: str, start_step: int
+    ) -> WorkflowHandleAsync[R]:
+        forked_workflow_id = await asyncio.to_thread(
+            fork_workflow, self._sys_db, self._app_db, workflow_id, start_step
+        )
+        return WorkflowHandleClientAsyncPolling[R](forked_workflow_id, self._sys_db)

dbos/_conductor/protocol.py

@@ -3,8 +3,7 @@ from dataclasses import asdict, dataclass
 from enum import Enum
 from typing import List, Optional, Type, TypedDict, TypeVar
 
-from dbos._sys_db import StepInfo
-from dbos._workflow_commands import WorkflowStatus
+from dbos._sys_db import StepInfo, WorkflowStatus
 
 
 class MessageType(str, Enum):

dbos/_core.py

@@ -75,6 +75,7 @@ from ._serialization import WorkflowInputs
 from ._sys_db import (
     GetEventWorkflowContext,
     OperationResultInternal,
+    WorkflowStatus,
     WorkflowStatusInternal,
     WorkflowStatusString,
 )
@@ -87,7 +88,6 @@ if TYPE_CHECKING:
         DBOSRegistry,
         IsolationLevel,
     )
-    from ._workflow_commands import WorkflowStatus
 
 from sqlalchemy.exc import DBAPIError, InvalidRequestError
 
@@ -119,7 +119,7 @@ class WorkflowHandleFuture(Generic[R]):
         self.dbos._sys_db.record_get_result(self.workflow_id, serialized_r, None)
         return r
 
-    def get_status(self) -> "WorkflowStatus":
+    def get_status(self) -> WorkflowStatus:
         stat = self.dbos.get_workflow_status(self.workflow_id)
         if stat is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
@@ -146,7 +146,7 @@ class WorkflowHandlePolling(Generic[R]):
         self.dbos._sys_db.record_get_result(self.workflow_id, serialized_r, None)
         return r
 
-    def get_status(self) -> "WorkflowStatus":
+    def get_status(self) -> WorkflowStatus:
         stat = self.dbos.get_workflow_status(self.workflow_id)
         if stat is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
@@ -181,7 +181,7 @@ class WorkflowHandleAsyncTask(Generic[R]):
         )
         return r
 
-    async def get_status(self) -> "WorkflowStatus":
+    async def get_status(self) -> WorkflowStatus:
         stat = await asyncio.to_thread(self.dbos.get_workflow_status, self.workflow_id)
         if stat is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
@@ -217,7 +217,7 @@ class WorkflowHandleAsyncPolling(Generic[R]):
         )
         return r
 
-    async def get_status(self) -> "WorkflowStatus":
+    async def get_status(self) -> WorkflowStatus:
         stat = await asyncio.to_thread(self.dbos.get_workflow_status, self.workflow_id)
         if stat is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
@@ -232,8 +232,8 @@ def _init_workflow(
     class_name: Optional[str],
     config_name: Optional[str],
     temp_wf_type: Optional[str],
-    queue: Optional[str] = None,
-    max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS,
+    queue: Optional[str],
+    max_recovery_attempts: Optional[int],
 ) -> WorkflowStatusInternal:
     wfid = (
         ctx.workflow_id
@@ -653,7 +653,7 @@ else:
 def workflow_wrapper(
     dbosreg: "DBOSRegistry",
     func: Callable[P, R],
-    max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS,
+    max_recovery_attempts: Optional[int] = DEFAULT_MAX_RECOVERY_ATTEMPTS,
 ) -> Callable[P, R]:
     func.__orig_func = func  # type: ignore
 
@@ -718,6 +718,7 @@ def workflow_wrapper(
                 class_name=get_dbos_class_name(fi, func, args),
                 config_name=get_config_name(fi, func, args),
                 temp_wf_type=get_temp_workflow_type(func),
+                queue=None,
                 max_recovery_attempts=max_recovery_attempts,
             )
 
@@ -765,7 +766,7 @@ def workflow_wrapper(
 
 
 def decorate_workflow(
-    reg: "DBOSRegistry", max_recovery_attempts: int
+    reg: "DBOSRegistry", 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)

dbos/_dbos.py

@@ -31,9 +31,10 @@ from typing import (
 from opentelemetry.trace import Span
 
 from dbos._conductor.conductor import ConductorWebsocket
+from dbos._sys_db import WorkflowStatus
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 from dbos._workflow_commands import (
-    WorkflowStatus,
+    fork_workflow,
     list_queued_workflows,
     list_workflows,
 )
@@ -67,7 +68,7 @@ from ._registrations import (
 )
 from ._roles import default_required_roles, required_roles
 from ._scheduler import ScheduledWorkflow, scheduled
-from ._sys_db import reset_system_database
+from ._sys_db import StepInfo, WorkflowStatus, reset_system_database
 from ._tracer import dbos_tracer
 
 if TYPE_CHECKING:
@@ -113,7 +114,7 @@ from ._error import (
 from ._event_loop import BackgroundEventLoop
 from ._logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
 from ._sys_db import SystemDatabase
-from ._workflow_commands import WorkflowStatus, get_workflow
+from ._workflow_commands import get_workflow, list_workflow_steps
 
 # Most DBOS functions are just any callable F, so decorators / wrappers work on F
 # There are cases where the parameters P and return value R should be separate
@@ -599,7 +600,7 @@ class DBOS:
     # Decorators for DBOS functionality
     @classmethod
     def workflow(
-        cls, *, max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS
+        cls, *, max_recovery_attempts: Optional[int] = DEFAULT_MAX_RECOVERY_ATTEMPTS
     ) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """Decorate a function for use as a DBOS workflow."""
         return decorate_workflow(_get_or_create_dbos_registry(), max_recovery_attempts)
@@ -959,40 +960,19 @@ class DBOS:
     @classmethod
     def restart_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Restart a workflow with a new workflow ID"""
-
         return cls.fork_workflow(workflow_id, 1)
 
     @classmethod
-    def fork_workflow(
-        cls, workflow_id: str, start_step: int = 1
-    ) -> WorkflowHandle[Any]:
-        """Restart a workflow with a new workflow ID"""
-
-        def get_max_function_id(workflow_uuid: str) -> int:
-            max_transactions = (
-                _get_dbos_instance()._app_db.get_max_function_id(workflow_uuid) or 0
-            )
-            max_operations = (
-                _get_dbos_instance()._sys_db.get_max_function_id(workflow_uuid) or 0
-            )
-            return max(max_transactions, max_operations)
-
-        max_function_id = get_max_function_id(workflow_id)
-        if max_function_id > 0 and start_step > max_function_id:
-            raise DBOSException(
-                f"Cannot fork workflow {workflow_id} at step {start_step}. The workflow has  {max_function_id} steps."
-            )
+    def fork_workflow(cls, workflow_id: str, start_step: int) -> WorkflowHandle[Any]:
+        """Restart a workflow with a new workflow ID from a specific step"""
 
         def fn() -> str:
-            forked_workflow_id = str(uuid.uuid4())
             dbos_logger.info(f"Forking workflow: {workflow_id} from step {start_step}")
-
-            _get_dbos_instance()._app_db.clone_workflow_transactions(
-                workflow_id, forked_workflow_id, start_step
-            )
-
-            return _get_dbos_instance()._sys_db.fork_workflow(
-                workflow_id, forked_workflow_id, start_step
+            return fork_workflow(
+                _get_dbos_instance()._sys_db,
+                _get_dbos_instance()._app_db,
+                workflow_id,
+                start_step,
             )
 
         new_id = _get_dbos_instance()._sys_db.call_function_as_step(
@@ -1066,6 +1046,17 @@ class DBOS:
             fn, "DBOS.listQueuedWorkflows"
         )
 
+    @classmethod
+    def list_workflow_steps(cls, workflow_id: str) -> List[StepInfo]:
+        def fn() -> List[StepInfo]:
+            return list_workflow_steps(
+                _get_dbos_instance()._sys_db, _get_dbos_instance()._app_db, workflow_id
+            )
+
+        return _get_dbos_instance()._sys_db.call_function_as_step(
+            fn, "DBOS.listWorkflowSteps"
+        )
+
     @classproperty
     def logger(cls) -> Logger:
         """Return the DBOS `Logger` for the current context."""

dbos/_registrations.py

@@ -51,7 +51,7 @@ class DBOSFuncInfo:
     class_info: Optional[DBOSClassInfo] = None
     func_type: DBOSFuncType = DBOSFuncType.Unknown
     required_roles: Optional[List[str]] = None
-    max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS
+    max_recovery_attempts: Optional[int] = DEFAULT_MAX_RECOVERY_ATTEMPTS
 
 
 def get_or_create_class_info(

dbos/_sys_db.py

@@ -1,4 +1,5 @@
 import datetime
+import json
 import logging
 import os
 import re
@@ -64,6 +65,50 @@ WorkflowStatuses = Literal[
 ]
 
 
+class WorkflowStatus:
+    # The workflow ID
+    workflow_id: str
+    # The workflow status. Must be one of ENQUEUED, PENDING, SUCCESS, ERROR, CANCELLED, or RETRIES_EXCEEDED
+    status: str
+    # The name of the workflow function
+    name: str
+    # The name of the workflow's class, if any
+    class_name: Optional[str]
+    # The name with which the workflow's class instance was configured, if any
+    config_name: Optional[str]
+    # The user who ran the workflow, if specified
+    authenticated_user: Optional[str]
+    # The role with which the workflow ran, if specified
+    assumed_role: Optional[str]
+    # All roles which the authenticated user could assume
+    authenticated_roles: Optional[list[str]]
+    # The deserialized workflow input object
+    input: Optional[_serialization.WorkflowInputs]
+    # The workflow's output, if any
+    output: Optional[Any] = None
+    # The error the workflow threw, if any
+    error: Optional[Exception] = None
+    # Workflow start time, as a Unix epoch timestamp in ms
+    created_at: Optional[int]
+    # Last time the workflow status was updated, as a Unix epoch timestamp in ms
+    updated_at: Optional[int]
+    # If this workflow was enqueued, on which queue
+    queue_name: Optional[str]
+    # The executor to most recently executed this workflow
+    executor_id: Optional[str]
+    # The application version on which this workflow was started
+    app_version: Optional[str]
+
+    # INTERNAL FIELDS
+
+    # The ID of the application executing this workflow
+    app_id: Optional[str]
+    # The number of times this workflow's execution has been attempted
+    recovery_attempts: Optional[int]
+    # The HTTP request that triggered the workflow, if known
+    request: Optional[str]
+
+
 class WorkflowStatusInternal(TypedDict):
     workflow_uuid: str
     status: WorkflowStatuses
@@ -148,11 +193,6 @@ class GetQueuedWorkflowsInput(TypedDict):
     sort_desc: Optional[bool]  # Sort by created_at in DESC or ASC order
 
 
-class GetWorkflowsOutput:
-    def __init__(self, workflow_uuids: List[str]):
-        self.workflow_uuids = workflow_uuids
-
-
 class GetPendingWorkflowsOutput:
     def __init__(self, *, workflow_uuid: str, queue_name: Optional[str] = None):
         self.workflow_uuid: str = workflow_uuid
@@ -287,7 +327,7 @@ class SystemDatabase:
         status: WorkflowStatusInternal,
         conn: sa.Connection,
         *,
-        max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS,
+        max_recovery_attempts: Optional[int],
     ) -> WorkflowStatuses:
         if self._debug_mode:
             raise Exception("called insert_workflow_status in debug mode")
@@ -354,7 +394,11 @@ class SystemDatabase:
 
             # Every time we start executing a workflow (and thus attempt to insert its status), we increment `recovery_attempts` by 1.
             # When this number becomes equal to `maxRetries + 1`, we mark the workflow as `RETRIES_EXCEEDED`.
-            if recovery_attempts > max_recovery_attempts + 1:
+            if (
+                (wf_status != "SUCCESS" and wf_status != "ERROR")
+                and max_recovery_attempts is not None
+                and recovery_attempts > max_recovery_attempts + 1
+            ):
                 delete_cmd = sa.delete(SystemSchema.workflow_queue).where(
                     SystemSchema.workflow_queue.c.workflow_uuid
                     == status["workflow_uuid"]
@@ -702,8 +746,37 @@ class SystemDatabase:
             )
             return inputs
 
-    def get_workflows(self, input: GetWorkflowsInput) -> GetWorkflowsOutput:
-        query = sa.select(SystemSchema.workflow_status.c.workflow_uuid)
+    def get_workflows(
+        self, input: GetWorkflowsInput, get_request: bool = False
+    ) -> List[WorkflowStatus]:
+        """
+        Retrieve a list of workflows result and inputs based on the input criteria. The result is a list of external-facing workflow status objects.
+        """
+        query = sa.select(
+            SystemSchema.workflow_status.c.workflow_uuid,
+            SystemSchema.workflow_status.c.status,
+            SystemSchema.workflow_status.c.name,
+            SystemSchema.workflow_status.c.request,
+            SystemSchema.workflow_status.c.recovery_attempts,
+            SystemSchema.workflow_status.c.config_name,
+            SystemSchema.workflow_status.c.class_name,
+            SystemSchema.workflow_status.c.authenticated_user,
+            SystemSchema.workflow_status.c.authenticated_roles,
+            SystemSchema.workflow_status.c.assumed_role,
+            SystemSchema.workflow_status.c.queue_name,
+            SystemSchema.workflow_status.c.executor_id,
+            SystemSchema.workflow_status.c.created_at,
+            SystemSchema.workflow_status.c.updated_at,
+            SystemSchema.workflow_status.c.application_version,
+            SystemSchema.workflow_status.c.application_id,
+            SystemSchema.workflow_inputs.c.inputs,
+            SystemSchema.workflow_status.c.output,
+            SystemSchema.workflow_status.c.error,
+        ).join(
+            SystemSchema.workflow_inputs,
+            SystemSchema.workflow_status.c.workflow_uuid
+            == SystemSchema.workflow_inputs.c.workflow_uuid,
+        )
         if input.sort_desc:
             query = query.order_by(SystemSchema.workflow_status.c.created_at.desc())
         else:
@@ -749,18 +822,76 @@ class SystemDatabase:
 
         with self.engine.begin() as c:
             rows = c.execute(query)
-        workflow_ids = [row[0] for row in rows]
 
-        return GetWorkflowsOutput(workflow_ids)
+        infos: List[WorkflowStatus] = []
+        for row in rows:
+            info = WorkflowStatus()
+            info.workflow_id = row[0]
+            info.status = row[1]
+            info.name = row[2]
+            info.request = row[3] if get_request else None
+            info.recovery_attempts = row[4]
+            info.config_name = row[5]
+            info.class_name = row[6]
+            info.authenticated_user = row[7]
+            info.authenticated_roles = (
+                json.loads(row[8]) if row[8] is not None else None
+            )
+            info.assumed_role = row[9]
+            info.queue_name = row[10]
+            info.executor_id = row[11]
+            info.created_at = row[12]
+            info.updated_at = row[13]
+            info.app_version = row[14]
+            info.app_id = row[15]
+
+            inputs = _serialization.deserialize_args(row[16])
+            if inputs is not None:
+                info.input = inputs
+            if info.status == WorkflowStatusString.SUCCESS.value:
+                info.output = _serialization.deserialize(row[17])
+            elif info.status == WorkflowStatusString.ERROR.value:
+                info.error = _serialization.deserialize_exception(row[18])
+
+            infos.append(info)
+        return infos
 
     def get_queued_workflows(
-        self, input: GetQueuedWorkflowsInput
-    ) -> GetWorkflowsOutput:
-
-        query = sa.select(SystemSchema.workflow_queue.c.workflow_uuid).join(
-            SystemSchema.workflow_status,
-            SystemSchema.workflow_queue.c.workflow_uuid
-            == SystemSchema.workflow_status.c.workflow_uuid,
+        self, input: GetQueuedWorkflowsInput, get_request: bool = False
+    ) -> List[WorkflowStatus]:
+        """
+        Retrieve a list of queued workflows result and inputs based on the input criteria. The result is a list of external-facing workflow status objects.
+        """
+        query = sa.select(
+            SystemSchema.workflow_status.c.workflow_uuid,
+            SystemSchema.workflow_status.c.status,
+            SystemSchema.workflow_status.c.name,
+            SystemSchema.workflow_status.c.request,
+            SystemSchema.workflow_status.c.recovery_attempts,
+            SystemSchema.workflow_status.c.config_name,
+            SystemSchema.workflow_status.c.class_name,
+            SystemSchema.workflow_status.c.authenticated_user,
+            SystemSchema.workflow_status.c.authenticated_roles,
+            SystemSchema.workflow_status.c.assumed_role,
+            SystemSchema.workflow_status.c.queue_name,
+            SystemSchema.workflow_status.c.executor_id,
+            SystemSchema.workflow_status.c.created_at,
+            SystemSchema.workflow_status.c.updated_at,
+            SystemSchema.workflow_status.c.application_version,
+            SystemSchema.workflow_status.c.application_id,
+            SystemSchema.workflow_inputs.c.inputs,
+            SystemSchema.workflow_status.c.output,
+            SystemSchema.workflow_status.c.error,
+        ).select_from(
+            SystemSchema.workflow_queue.join(
+                SystemSchema.workflow_status,
+                SystemSchema.workflow_queue.c.workflow_uuid
+                == SystemSchema.workflow_status.c.workflow_uuid,
+            ).join(
+                SystemSchema.workflow_inputs,
+                SystemSchema.workflow_queue.c.workflow_uuid
+                == SystemSchema.workflow_inputs.c.workflow_uuid,
+            )
         )
         if input["sort_desc"]:
             query = query.order_by(SystemSchema.workflow_status.c.created_at.desc())
@@ -797,9 +928,40 @@ class SystemDatabase:
 
         with self.engine.begin() as c:
             rows = c.execute(query)
-        workflow_uuids = [row[0] for row in rows]
 
-        return GetWorkflowsOutput(workflow_uuids)
+        infos: List[WorkflowStatus] = []
+        for row in rows:
+            info = WorkflowStatus()
+            info.workflow_id = row[0]
+            info.status = row[1]
+            info.name = row[2]
+            info.request = row[3] if get_request else None
+            info.recovery_attempts = row[4]
+            info.config_name = row[5]
+            info.class_name = row[6]
+            info.authenticated_user = row[7]
+            info.authenticated_roles = (
+                json.loads(row[8]) if row[8] is not None else None
+            )
+            info.assumed_role = row[9]
+            info.queue_name = row[10]
+            info.executor_id = row[11]
+            info.created_at = row[12]
+            info.updated_at = row[13]
+            info.app_version = row[14]
+            info.app_id = row[15]
+
+            inputs = _serialization.deserialize_args(row[16])
+            if inputs is not None:
+                info.input = inputs
+            if info.status == WorkflowStatusString.SUCCESS.value:
+                info.output = _serialization.deserialize(row[17])
+            elif info.status == WorkflowStatusString.ERROR.value:
+                info.error = _serialization.deserialize_exception(row[18])
+
+            infos.append(info)
+
+        return infos
 
     def get_pending_workflows(
         self, executor_id: str, app_version: str
@@ -1658,7 +1820,7 @@ class SystemDatabase:
         status: WorkflowStatusInternal,
         inputs: str,
         *,
-        max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS,
+        max_recovery_attempts: Optional[int],
     ) -> WorkflowStatuses:
         """
         Synchronously record the status and inputs for workflows in a single transaction

dbos/_workflow_commands.py

@@ -1,62 +1,18 @@
-import json
 import uuid
-from typing import Any, List, Optional
+from typing import List, Optional
+
+from dbos._error import DBOSException
 
-from . import _serialization
 from ._app_db import ApplicationDatabase
 from ._sys_db import (
     GetQueuedWorkflowsInput,
     GetWorkflowsInput,
-    GetWorkflowsOutput,
     StepInfo,
     SystemDatabase,
+    WorkflowStatus,
 )
 
 
-class WorkflowStatus:
-    # The workflow ID
-    workflow_id: str
-    # The workflow status. Must be one of ENQUEUED, PENDING, SUCCESS, ERROR, CANCELLED, or RETRIES_EXCEEDED
-    status: str
-    # The name of the workflow function
-    name: str
-    # The name of the workflow's class, if any
-    class_name: Optional[str]
-    # The name with which the workflow's class instance was configured, if any
-    config_name: Optional[str]
-    # The user who ran the workflow, if specified
-    authenticated_user: Optional[str]
-    # The role with which the workflow ran, if specified
-    assumed_role: Optional[str]
-    # All roles which the authenticated user could assume
-    authenticated_roles: Optional[list[str]]
-    # The deserialized workflow input object
-    input: Optional[_serialization.WorkflowInputs]
-    # The workflow's output, if any
-    output: Optional[Any] = None
-    # The error the workflow threw, if any
-    error: Optional[Exception] = None
-    # Workflow start time, as a Unix epoch timestamp in ms
-    created_at: Optional[int]
-    # Last time the workflow status was updated, as a Unix epoch timestamp in ms
-    updated_at: Optional[int]
-    # If this workflow was enqueued, on which queue
-    queue_name: Optional[str]
-    # The executor to most recently executed this workflow
-    executor_id: Optional[str]
-    # The application version on which this workflow was started
-    app_version: Optional[str]
-
-    # INTERNAL FIELDS
-
-    # The ID of the application executing this workflow
-    app_id: Optional[str]
-    # The number of times this workflow's execution has been attempted
-    recovery_attempts: Optional[int]
-    # The HTTP request that triggered the workflow, if known
-    request: Optional[str]
-
-
 def list_workflows(
     sys_db: SystemDatabase,
     *,
@@ -86,12 +42,8 @@ def list_workflows(
     input.sort_desc = sort_desc
     input.workflow_id_prefix = workflow_id_prefix
 
-    output: GetWorkflowsOutput = sys_db.get_workflows(input)
-    infos: List[WorkflowStatus] = []
-    for workflow_id in output.workflow_uuids:
-        info = get_workflow(sys_db, workflow_id, request)  # Call the method for each ID
-        if info is not None:
-            infos.append(info)
+    infos: List[WorkflowStatus] = sys_db.get_workflows(input, request)
+
     return infos
 
 
@@ -118,63 +70,22 @@ def list_queued_workflows(
         "offset": offset,
         "sort_desc": sort_desc,
     }
-    output: GetWorkflowsOutput = sys_db.get_queued_workflows(input)
-    infos: List[WorkflowStatus] = []
-    for workflow_id in output.workflow_uuids:
-        info = get_workflow(sys_db, workflow_id, request)  # Call the method for each ID
-        if info is not None:
-            infos.append(info)
+
+    infos: List[WorkflowStatus] = sys_db.get_queued_workflows(input, request)
     return infos
 
 
 def get_workflow(
     sys_db: SystemDatabase, workflow_id: str, get_request: bool
 ) -> Optional[WorkflowStatus]:
+    input = GetWorkflowsInput()
+    input.workflow_ids = [workflow_id]
 
-    internal_status = sys_db.get_workflow_status(workflow_id)
-    if internal_status is None:
+    infos: List[WorkflowStatus] = sys_db.get_workflows(input, get_request)
+    if not infos:
         return None
 
-    info = WorkflowStatus()
-
-    info.workflow_id = workflow_id
-    info.status = internal_status["status"]
-    info.name = internal_status["name"]
-    info.class_name = internal_status["class_name"]
-    info.config_name = internal_status["config_name"]
-    info.authenticated_user = internal_status["authenticated_user"]
-    info.assumed_role = internal_status["assumed_role"]
-    info.authenticated_roles = (
-        json.loads(internal_status["authenticated_roles"])
-        if internal_status["authenticated_roles"] is not None
-        else None
-    )
-    info.request = internal_status["request"]
-    info.created_at = internal_status["created_at"]
-    info.updated_at = internal_status["updated_at"]
-    info.queue_name = internal_status["queue_name"]
-    info.executor_id = internal_status["executor_id"]
-    info.app_version = internal_status["app_version"]
-    info.app_id = internal_status["app_id"]
-    info.recovery_attempts = internal_status["recovery_attempts"]
-
-    input_data = sys_db.get_workflow_inputs(workflow_id)
-    if input_data is not None:
-        info.input = input_data
-
-    if internal_status.get("status") == "SUCCESS":
-        result = sys_db.await_workflow_result(workflow_id)
-        info.output = result
-    elif internal_status.get("status") == "ERROR":
-        try:
-            sys_db.await_workflow_result(workflow_id)
-        except Exception as e:
-            info.error = e
-
-    if not get_request:
-        info.request = None
-
-    return info
+    return infos[0]
 
 
 def list_workflow_steps(
@@ -185,3 +96,25 @@ def list_workflow_steps(
     merged_steps = steps + transactions
     merged_steps.sort(key=lambda step: step["function_id"])
     return merged_steps
+
+
+def fork_workflow(
+    sys_db: SystemDatabase,
+    app_db: ApplicationDatabase,
+    workflow_id: str,
+    start_step: int,
+) -> str:
+    def get_max_function_id(workflow_uuid: str) -> int:
+        max_transactions = app_db.get_max_function_id(workflow_uuid) or 0
+        max_operations = sys_db.get_max_function_id(workflow_uuid) or 0
+        return max(max_transactions, max_operations)
+
+    max_function_id = get_max_function_id(workflow_id)
+    if max_function_id > 0 and start_step > max_function_id:
+        raise DBOSException(
+            f"Cannot fork workflow {workflow_id} from step {start_step}. The workflow has {max_function_id} steps."
+        )
+    forked_workflow_id = str(uuid.uuid4())
+    app_db.clone_workflow_transactions(workflow_id, forked_workflow_id, start_step)
+    sys_db.fork_workflow(workflow_id, forked_workflow_id, start_step)
+    return forked_workflow_id

{dbos-0.26.0a18.dist-info → dbos-0.26.0a21.dist-info}/METADATA

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

{dbos-0.26.0a18.dist-info → dbos-0.26.0a21.dist-info}/RECORD

@@ -1,19 +1,19 @@
-dbos-0.26.0a18.dist-info/METADATA,sha256=QG3XkqovR0FvEIL1_sHK6K80-comGqhpyC1LCWUDEzA,5554
-dbos-0.26.0a18.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-0.26.0a18.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.26.0a18.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
-dbos/__init__.py,sha256=3NQfGlBiiUSM_v88STdVP3rNZvGkUL_9WbSotKb8Voo,873
+dbos-0.26.0a21.dist-info/METADATA,sha256=6JPLTUn5uCaKpHI_sEis2zJWOrNqsRUIQ2_4h7ZzWfw,5554
+dbos-0.26.0a21.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-0.26.0a21.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.26.0a21.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos/__init__.py,sha256=VoGS7H9GVtNAnD2S4zseIEioS1dNIJXRovQ4oHlg8og,842
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=RrbABfR1D3p9c_QLrCSrgFuYce6FKi0fjMRIYLjO_Y8,9038
-dbos/_app_db.py,sha256=Q9lEyCJFoZMTlnjMO8Pj8bczVmVWyDOP8qPQ6l5PpEU,11241
+dbos/_app_db.py,sha256=obNlgC9IZ20y8tqQeA1q4TjceG3jBFalxz70ieDOWCA,11332
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=QiIR-mwRYb1ffgwGR96ICQgFORki2QpR5najtVJ2WsA,10906
+dbos/_client.py,sha256=S3tejQ7xAJ9wjo1PhQ0P3UYuloDOdZqXsQwE4YjAQ8s,12124
 dbos/_conductor/conductor.py,sha256=HYzVL29IMMrs2Mnms_7cHJynCnmmEN5SDQOMjzn3UoU,16840
-dbos/_conductor/protocol.py,sha256=xN7pmooyF1pqbH1b6WhllU5718P7zSb_b0KCwA6bzcs,6716
+dbos/_conductor/protocol.py,sha256=zEKIuOQdIaSduNqfZKpo8PSD9_1oNpKIPnBNCu3RUyE,6681
 dbos/_context.py,sha256=I8sLkdKTTkZEz7wG-MjynaQB6XEF2bLXuwNksiauP7w,19430
-dbos/_core.py,sha256=uxDIJui4WS_2V1k2np0Ifue_IRzLTyq-c52bgZSQYn4,45118
+dbos/_core.py,sha256=SecObOKLjNinNAXDcYVMVUURHcoaPe0js-axLMMNwqY,45098
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=jtvBQOvwdXFfknx9pDHgKC4DuiH58ICAs_0NoJQMI4w,47526
+dbos/_dbos.py,sha256=bbio_FjBfU__Zk1BFegfS16IrPPejFxOKm5rUg5nW1o,47185
 dbos/_dbos_config.py,sha256=m05IFjM0jSwZBsnFMF_4qP2JkjVFc0gqyM2tnotXq20,20636
 dbos/_debug.py,sha256=MNlQVZ6TscGCRQeEEL0VE8Uignvr6dPeDDDefS3xgIE,1823
 dbos/_docker_pg_helper.py,sha256=NmcgqmR5rQA_4igfeqh8ugNT2z3YmoOvuep_MEtxTiY,5854
@@ -37,7 +37,7 @@ dbos/_migrations/versions/f4b9b32ba814_functionname_childid_op_outputs.py,sha256
 dbos/_outcome.py,sha256=EXxBg4jXCVJsByDQ1VOCIedmbeq_03S6d-p1vqQrLFU,6810
 dbos/_queue.py,sha256=l0g_CXJbxEmftCA9yhy-cyaR_sddfQSCfm-5XgIWzqU,3397
 dbos/_recovery.py,sha256=98Py7icfytyIELJ54gIsdvmURBvTb0HmWaxEAuYL0dc,2546
-dbos/_registrations.py,sha256=ZDC5lghy_1ZMdMGsSBrXSyS96DH3baA4nyCkFdUmIlc,7292
+dbos/_registrations.py,sha256=EZzG3ZfYmWA2bHX2hpnSIQ3PTi3-cXsvbcmXjyOusMk,7302
 dbos/_request.py,sha256=cX1B3Atlh160phgS35gF1VEEV4pD126c9F3BDgBmxZU,929
 dbos/_roles.py,sha256=iOsgmIAf1XVzxs3gYWdGRe1B880YfOw5fpU7Jwx8_A8,2271
 dbos/_scheduler.py,sha256=SR1oRZRcVzYsj-JauV2LA8JtwTkt8mru7qf6H1AzQ1U,2027
@@ -45,7 +45,7 @@ dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
 dbos/_schemas/system_database.py,sha256=W9eSpL7SZzQkxcEZ4W07BOcwkkDr35b9oCjUOgfHWek,5336
 dbos/_serialization.py,sha256=YCYv0qKAwAZ1djZisBC7khvKqG-5OcIv9t9EC5PFIog,1743
-dbos/_sys_db.py,sha256=kfNR9R7rQ6MTqBuPt4OI5nZElIJNXlGuUjG_ypGKHWI,71195
+dbos/_sys_db.py,sha256=M3BVJVhG0YXkLhw5axSrKjBN1AOS3KmvgWEYn2l94pw,78203
 dbos/_templates/dbos-db-starter/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
 dbos/_templates/dbos-db-starter/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_templates/dbos-db-starter/__package/main.py,sha256=nJMN3ZD2lmwg4Dcgmiwqc-tQGuCJuJal2Xl85iA277U,2453
@@ -58,11 +58,11 @@ dbos/_templates/dbos-db-starter/migrations/versions/2024_07_31_180642_init.py,sh
 dbos/_templates/dbos-db-starter/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
 dbos/_tracer.py,sha256=dFDSFlta-rfA3-ahIRLYwnnoAOmlavdxAGllqwFgnCA,2440
 dbos/_utils.py,sha256=nFRUHzVjXG5AusF85AlYHikj63Tzi-kQm992ihsrAxA,201
-dbos/_workflow_commands.py,sha256=hHNcW4zopgxVXWfg3flHwqZEFGYpYp8ZAfUXmqiULUk,6261
+dbos/_workflow_commands.py,sha256=7wyxTfIyh2IVIqlkaTr8CMBq8yxWP3Hhddyv1YJY8zE,3576
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=-WW3kbq0W_Tq4WbMqb1UGJG3xvJb3woEY5VspG95Srk,2857
 dbos/cli/cli.py,sha256=1qCTs__A9LOEfU44XZ6TufwmRwe68ZEwbWEPli3vnVM,17873
 dbos/dbos-config.schema.json,sha256=i7jcxXqByKq0Jzv3nAUavONtj03vTwj6vWP4ylmBr8o,5694
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.26.0a18.dist-info/RECORD,,
+dbos-0.26.0a21.dist-info/RECORD,,