dbos 0.25.0a3__py3-none-any.whl → 0.25.0a8__py3-none-any.whl

dbos/_migrations/versions/f4b9b32ba814_functionname_childid_op_outputs.py

@@ -0,0 +1,46 @@
+"""functionname_childid_op_outputs
+
+Revision ID: f4b9b32ba814
+Revises: 04ca4f231047
+Create Date: 2025-03-21 14:32:43.091074
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "f4b9b32ba814"
+down_revision: Union[str, None] = "04ca4f231047"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "operation_outputs",
+        sa.Column(
+            "function_name",
+            sa.Text(),
+            nullable=False,
+            default="",
+        ),
+        schema="dbos",
+    )
+
+    op.add_column(
+        "operation_outputs",
+        sa.Column(
+            "child_workflow_id",
+            sa.Text(),
+            nullable=True,
+        ),
+        schema="dbos",
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("operation_outputs", "function_name", schema="dbos")
+    op.drop_column("operation_outputs", "child_workflow_id", schema="dbos")

dbos/_outcome.py

@@ -4,6 +4,8 @@ import inspect
 import time
 from typing import Any, Callable, Coroutine, Optional, Protocol, TypeVar, Union, cast
 
+from dbos._context import EnterDBOSStepRetry
+
 T = TypeVar("T")
 R = TypeVar("R")
 
@@ -98,7 +100,8 @@ class Immediate(Outcome[T]):
     ) -> T:
         for i in range(attempts):
             try:
-                return func()
+                with EnterDBOSStepRetry(i, attempts):
+                    return func()
             except Exception as exp:
                 wait_time = on_exception(i, exp)
                 time.sleep(wait_time)
@@ -184,7 +187,8 @@ class Pending(Outcome[T]):
     ) -> T:
         for i in range(attempts):
             try:
-                return await func()
+                with EnterDBOSStepRetry(i, attempts):
+                    return await func()
             except Exception as exp:
                 wait_time = on_exception(i, exp)
                 await asyncio.sleep(wait_time)

dbos/_schemas/system_database.py

@@ -71,8 +71,10 @@ class SystemSchema:
             nullable=False,
         ),
         Column("function_id", Integer, nullable=False),
+        Column("function_name", Text, nullable=False, default=""),
         Column("output", Text, nullable=True),
         Column("error", Text, nullable=True),
+        Column("child_workflow_id", Text, nullable=True),
         PrimaryKeyConstraint("workflow_uuid", "function_id"),
     )
 

dbos/_sys_db.py

@@ -28,6 +28,7 @@ from sqlalchemy.sql import func
 from dbos._utils import GlobalParams
 
 from . import _serialization
+from ._context import get_local_dbos_context
 from ._dbos_config import ConfigFile
 from ._error import (
     DBOSConflictingWorkflowError,
@@ -89,6 +90,7 @@ class RecordedResult(TypedDict):
 class OperationResultInternal(TypedDict):
     workflow_uuid: str
     function_id: int
+    function_name: str
     output: Optional[str]  # JSON (jsonpickle)
     error: Optional[str]  # JSON (jsonpickle)
 
@@ -114,7 +116,7 @@ class GetWorkflowsInput:
         self.authenticated_user: Optional[str] = None  # The user who ran the workflow.
         self.start_time: Optional[str] = None  # Timestamp in ISO 8601 format
         self.end_time: Optional[str] = None  # Timestamp in ISO 8601 format
-        self.status: Optional[WorkflowStatuses] = None
+        self.status: Optional[str] = None
         self.application_version: Optional[str] = (
             None  # The application version that ran this workflow. = None
         )
@@ -151,6 +153,14 @@ class GetPendingWorkflowsOutput:
         self.queue_name: Optional[str] = queue_name
 
 
+class StepInfo(TypedDict):
+    function_id: int
+    function_name: str
+    output: Optional[str]  # JSON (jsonpickle)
+    error: Optional[str]  # JSON (jsonpickle)
+    child_workflow_id: Optional[str]
+
+
 _dbos_null_topic = "__null__topic__"
 _buffer_flush_batch_size = 100
 _buffer_flush_interval_secs = 1.0
@@ -531,31 +541,6 @@ class SystemDatabase:
             }
             return status
 
-    def get_workflow_status_within_wf(
-        self, workflow_uuid: str, calling_wf: str, calling_wf_fn: int
-    ) -> Optional[WorkflowStatusInternal]:
-        res = self.check_operation_execution(calling_wf, calling_wf_fn)
-        if res is not None:
-            if res["output"]:
-                resstat: WorkflowStatusInternal = _serialization.deserialize(
-                    res["output"]
-                )
-                return resstat
-            else:
-                raise DBOSException(
-                    "Workflow status record not found. This should not happen! \033[1m Hint: Check if your workflow is deterministic.\033[0m"
-                )
-        stat = self.get_workflow_status(workflow_uuid)
-        self.record_operation_result(
-            {
-                "workflow_uuid": calling_wf,
-                "function_id": calling_wf_fn,
-                "output": _serialization.serialize(stat),
-                "error": None,
-            }
-        )
-        return stat
-
     def await_workflow_result_internal(self, workflow_uuid: str) -> dict[str, Any]:
         polling_interval_secs: float = 1.000
 
@@ -771,6 +756,28 @@ class SystemDatabase:
                 for row in rows
             ]
 
+    def get_workflow_steps(self, workflow_id: str) -> List[StepInfo]:
+        with self.engine.begin() as c:
+            rows = c.execute(
+                sa.select(
+                    SystemSchema.operation_outputs.c.function_id,
+                    SystemSchema.operation_outputs.c.function_name,
+                    SystemSchema.operation_outputs.c.output,
+                    SystemSchema.operation_outputs.c.error,
+                    SystemSchema.operation_outputs.c.child_workflow_id,
+                ).where(SystemSchema.operation_outputs.c.workflow_uuid == workflow_id)
+            ).fetchall()
+            return [
+                StepInfo(
+                    function_id=row[0],
+                    function_name=row[1],
+                    output=row[2],  # Preserve JSON data
+                    error=row[3],
+                    child_workflow_id=row[4],
+                )
+                for row in rows
+            ]
+
     def record_operation_result(
         self, result: OperationResultInternal, conn: Optional[sa.Connection] = None
     ) -> None:
@@ -782,6 +789,7 @@ class SystemDatabase:
         sql = pg.insert(SystemSchema.operation_outputs).values(
             workflow_uuid=result["workflow_uuid"],
             function_id=result["function_id"],
+            function_name=result["function_name"],
             output=output,
             error=error,
         )
@@ -796,6 +804,30 @@ class SystemDatabase:
                 raise DBOSWorkflowConflictIDError(result["workflow_uuid"])
             raise
 
+    def record_child_workflow(
+        self,
+        parentUUID: str,
+        childUUID: str,
+        functionID: int,
+        functionName: str,
+    ) -> None:
+        if self._debug_mode:
+            raise Exception("called record_child_workflow in debug mode")
+
+        sql = pg.insert(SystemSchema.operation_outputs).values(
+            workflow_uuid=parentUUID,
+            function_id=functionID,
+            function_name=functionName,
+            child_workflow_id=childUUID,
+        )
+        try:
+            with self.engine.begin() as c:
+                c.execute(sql)
+        except DBAPIError as dbapi_error:
+            if dbapi_error.orig.sqlstate == "23505":  # type: ignore
+                raise DBOSWorkflowConflictIDError(parentUUID)
+            raise
+
     def check_operation_execution(
         self, workflow_uuid: str, function_id: int, conn: Optional[sa.Connection] = None
     ) -> Optional[RecordedResult]:
@@ -822,6 +854,23 @@ class SystemDatabase:
         }
         return result
 
+    def check_child_workflow(
+        self, workflow_uuid: str, function_id: int
+    ) -> Optional[str]:
+        sql = sa.select(SystemSchema.operation_outputs.c.child_workflow_id).where(
+            SystemSchema.operation_outputs.c.workflow_uuid == workflow_uuid,
+            SystemSchema.operation_outputs.c.function_id == function_id,
+        )
+
+        # If in a transaction, use the provided connection
+        row: Any
+        with self.engine.begin() as c:
+            row = c.execute(sql).fetchone()
+
+        if row is None:
+            return None
+        return str(row[0])
+
     def send(
         self,
         workflow_uuid: str,
@@ -866,6 +915,7 @@ class SystemDatabase:
             output: OperationResultInternal = {
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
+                "function_name": "DBOS.send",
                 "output": None,
                 "error": None,
             }
@@ -959,6 +1009,7 @@ class SystemDatabase:
                 {
                     "workflow_uuid": workflow_uuid,
                     "function_id": function_id,
+                    "function_name": "DBOS.recv",
                     "output": _serialization.serialize(
                         message
                     ),  # None will be serialized to 'null'
@@ -1049,6 +1100,7 @@ class SystemDatabase:
                     {
                         "workflow_uuid": workflow_uuid,
                         "function_id": function_id,
+                        "function_name": "DBOS.sleep",
                         "output": _serialization.serialize(end_time),
                         "error": None,
                     }
@@ -1096,6 +1148,7 @@ class SystemDatabase:
             output: OperationResultInternal = {
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
+                "function_name": "DBOS.setEvent",
                 "output": None,
                 "error": None,
             }
@@ -1176,6 +1229,7 @@ class SystemDatabase:
                 {
                     "workflow_uuid": caller_ctx["workflow_uuid"],
                     "function_id": caller_ctx["function_id"],
+                    "function_name": "DBOS.getEvent",
                     "output": _serialization.serialize(
                         value
                     ),  # None will be serialized to 'null'

dbos/_templates/dbos-db-starter/__package/main.py

@@ -6,6 +6,7 @@
 
 # First, let's do imports, create a FastAPI app, and initialize DBOS.
 
+import uvicorn
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
 
@@ -37,7 +38,7 @@ def example_transaction(name: str) -> str:
     return greeting
 
 
-# Finally, let's use FastAPI to serve an HTML + CSS readme
+# Now, let's use FastAPI to serve an HTML + CSS readme
 # from the root path.
 
 
@@ -66,14 +67,8 @@ def readme() -> HTMLResponse:
     return HTMLResponse(readme)
 
 
-# To deploy this app to DBOS Cloud:
-# - "npm i -g @dbos-inc/dbos-cloud@latest" to install the Cloud CLI (requires Node)
-# - "dbos-cloud app deploy" to deploy your app
-# - Deploy outputs a URL--visit it to see your app!
+# Finally, we'll launch DBOS then start the FastAPI server.
 
-
-# To run this app locally:
-# - Make sure you have a Postgres database to connect to
-# - "dbos migrate" to set up your database tables
-# - "dbos start" to start the app
-# - Visit localhost:8000 to see your app!
+if __name__ == "__main__":
+    DBOS.launch()
+    uvicorn.run(app, host="0.0.0.0", port=8000)

dbos/_templates/dbos-db-starter/dbos-config.yaml.dbos

@@ -7,8 +7,6 @@ name: ${project_name}
 language: python
 runtimeConfig:
   start:
-    - "fastapi run ${package_name}/main.py"
+    - "${start_command}"
 database_url: ${DBOS_DATABASE_URL}
-database:
-  migrate:
-    - ${migration_command}
+${migration_section}

dbos/_workflow_commands.py

@@ -1,59 +1,78 @@
-from typing import List, Optional, cast
+import json
+from typing import Any, List, Optional
 
 from . import _serialization
 from ._sys_db import (
     GetQueuedWorkflowsInput,
     GetWorkflowsInput,
     GetWorkflowsOutput,
+    StepInfo,
     SystemDatabase,
-    WorkflowStatuses,
 )
 
 
-class WorkflowInformation:
+class WorkflowStatus:
+    # The workflow ID
     workflow_id: str
-    status: WorkflowStatuses
-    workflow_name: str
-    workflow_class_name: Optional[str]
-    workflow_config_name: Optional[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]
-    authenticated_roles: Optional[str]  # JSON list of roles.
-    input: Optional[_serialization.WorkflowInputs]  # JSON (jsonpickle)
-    output: Optional[str] = None  # JSON (jsonpickle)
-    request: Optional[str]  # JSON (jsonpickle)
-    error: Optional[str] = None  # JSON (jsonpickle)
-    created_at: Optional[int]  # Unix epoch timestamp in ms
-    updated_at: Optional[int]  # Unix epoch timestamp in ms
+    # 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]
+    # 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,
     *,
     workflow_ids: Optional[List[str]] = None,
-    user: Optional[str] = None,
+    status: Optional[str] = None,
     start_time: Optional[str] = None,
     end_time: Optional[str] = None,
-    status: Optional[str] = None,
-    request: bool = False,
-    app_version: Optional[str] = None,
     name: Optional[str] = None,
+    app_version: Optional[str] = None,
+    user: Optional[str] = None,
     limit: Optional[int] = None,
     offset: Optional[int] = None,
     sort_desc: bool = False,
-) -> List[WorkflowInformation]:
+    request: bool = False,
+) -> List[WorkflowStatus]:
     input = GetWorkflowsInput()
     input.workflow_ids = workflow_ids
     input.authenticated_user = user
     input.start_time = start_time
     input.end_time = end_time
-    if status is not None:
-        input.status = cast(WorkflowStatuses, status)
+    input.status = status
     input.application_version = app_version
     input.limit = limit
     input.name = name
@@ -61,7 +80,7 @@ def list_workflows(
     input.sort_desc = sort_desc
 
     output: GetWorkflowsOutput = sys_db.get_workflows(input)
-    infos: List[WorkflowInformation] = []
+    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:
@@ -72,16 +91,16 @@ def list_workflows(
 def list_queued_workflows(
     sys_db: SystemDatabase,
     *,
-    limit: Optional[int] = None,
-    start_time: Optional[str] = None,
-    end_time: Optional[str] = None,
     queue_name: Optional[str] = None,
     status: Optional[str] = None,
+    start_time: Optional[str] = None,
+    end_time: Optional[str] = None,
     name: Optional[str] = None,
-    request: bool = False,
+    limit: Optional[int] = None,
     offset: Optional[int] = None,
     sort_desc: bool = False,
-) -> List[WorkflowInformation]:
+    request: bool = False,
+) -> List[WorkflowStatus]:
     input: GetQueuedWorkflowsInput = {
         "queue_name": queue_name,
         "start_time": start_time,
@@ -93,7 +112,7 @@ def list_queued_workflows(
         "sort_desc": sort_desc,
     }
     output: GetWorkflowsOutput = sys_db.get_queued_workflows(input)
-    infos: List[WorkflowInformation] = []
+    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:
@@ -102,47 +121,55 @@ def list_queued_workflows(
 
 
 def get_workflow(
-    sys_db: SystemDatabase, workflowUUID: str, getRequest: bool
-) -> Optional[WorkflowInformation]:
+    sys_db: SystemDatabase, workflow_id: str, get_request: bool
+) -> Optional[WorkflowStatus]:
 
-    info = sys_db.get_workflow_status(workflowUUID)
-    if info is None:
+    internal_status = sys_db.get_workflow_status(workflow_id)
+    if internal_status is None:
         return None
 
-    winfo = WorkflowInformation()
-
-    winfo.workflow_id = workflowUUID
-    winfo.status = info["status"]
-    winfo.workflow_name = info["name"]
-    winfo.workflow_class_name = info["class_name"]
-    winfo.workflow_config_name = info["config_name"]
-    winfo.authenticated_user = info["authenticated_user"]
-    winfo.assumed_role = info["assumed_role"]
-    winfo.authenticated_roles = info["authenticated_roles"]
-    winfo.request = info["request"]
-    winfo.created_at = info["created_at"]
-    winfo.updated_at = info["updated_at"]
-    winfo.queue_name = info["queue_name"]
-    winfo.executor_id = info["executor_id"]
-    winfo.app_version = info["app_version"]
-    winfo.app_id = info["app_id"]
-    winfo.recovery_attempts = info["recovery_attempts"]
-
-    # no input field
-    input_data = sys_db.get_workflow_inputs(workflowUUID)
+    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:
-        winfo.input = input_data
+        info.input = input_data
 
-    if info.get("status") == "SUCCESS":
-        result = sys_db.await_workflow_result(workflowUUID)
-        winfo.output = result
-    elif info.get("status") == "ERROR":
+    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(workflowUUID)
+            sys_db.await_workflow_result(workflow_id)
         except Exception as e:
-            winfo.error = str(e)
+            info.error = e
+
+    if not get_request:
+        info.request = None
+
+    return info
 
-    if not getRequest:
-        winfo.request = None
 
-    return winfo
+def list_workflow_steps(sys_db: SystemDatabase, workflow_id: str) -> List[StepInfo]:
+    output = sys_db.get_workflow_steps(workflow_id)
+    return output

dbos/cli/_template_init.py

@@ -58,15 +58,20 @@ def copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
     dst_dir = path.abspath(".")
 
     package_name = project_name.replace("-", "_")
+    default_migration_section = """database:
+  migrate:
+    - alembic upgrade head
+"""
     ctx = {
         "project_name": project_name,
         "package_name": package_name,
-        "migration_command": "alembic upgrade head",
+        "start_command": f"python3 -m {package_name}.main",
+        "migration_section": default_migration_section,
     }
 
     if config_mode:
-        ctx["package_name"] = "."
-        ctx["migration_command"] = "echo 'No migrations specified'"
+        ctx["start_command"] = "python3 main.py"
+        ctx["migration_section"] = ""
         _copy_dbos_template(
             os.path.join(src_dir, "dbos-config.yaml.dbos"),
             os.path.join(dst_dir, "dbos-config.yaml"),

dbos/cli/cli.py

@@ -21,7 +21,12 @@ from .. import load_config
 from .._app_db import ApplicationDatabase
 from .._dbos_config import _is_valid_app_name
 from .._sys_db import SystemDatabase, reset_system_database
-from .._workflow_commands import get_workflow, list_queued_workflows, list_workflows
+from .._workflow_commands import (
+    get_workflow,
+    list_queued_workflows,
+    list_workflow_steps,
+    list_workflows,
+)
 from ..cli._github_init import create_template_from_github
 from ._template_init import copy_template, get_project_name, get_templates_directory
 
@@ -339,6 +344,17 @@ def get(
     )
 
 
+@workflow.command(help="List the steps of a workflow")
+def steps(
+    workflow_id: Annotated[str, typer.Argument()],
+) -> None:
+    config = load_config(silent=True)
+    sys_db = SystemDatabase(config)
+    print(
+        jsonpickle.encode(list_workflow_steps(sys_db, workflow_id), unpicklable=False)
+    )
+
+
 @workflow.command(
     help="Cancel a workflow so it is no longer automatically retried or restarted"
 )

{dbos-0.25.0a3.dist-info → dbos-0.25.0a8.dist-info}/METADATA

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