dbos 0.23.0a3__tar.gz → 0.23.0a5__tar.gz

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

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

{dbos-0.23.0a3 → dbos-0.23.0a5}/dbos/_core.py

@@ -177,6 +177,8 @@ def _init_workflow(
         ),
         "assumed_role": ctx.assumed_role,
         "queue_name": queue,
+        "created_at": None,
+        "updated_at": None,
     }
 
     # If we have a class name, the first arg is the instance and do not serialize

{dbos-0.23.0a3 → dbos-0.23.0a5}/dbos/_sys_db.py

@@ -68,17 +68,19 @@ class WorkflowStatusInternal(TypedDict):
     name: str
     class_name: Optional[str]
     config_name: Optional[str]
+    authenticated_user: Optional[str]
+    assumed_role: Optional[str]
+    authenticated_roles: Optional[str]  # JSON list of roles
     output: Optional[str]  # JSON (jsonpickle)
+    request: Optional[str]  # JSON (jsonpickle)
     error: Optional[str]  # JSON (jsonpickle)
+    created_at: Optional[int]  # Unix epoch timestamp in ms
+    updated_at: Optional[int]  # Unix epoch timestamp in ms
+    queue_name: Optional[str]
     executor_id: Optional[str]
     app_version: Optional[str]
     app_id: Optional[str]
-    request: Optional[str]  # JSON (jsonpickle)
     recovery_attempts: Optional[int]
-    authenticated_user: Optional[str]
-    assumed_role: Optional[str]
-    authenticated_roles: Optional[str]  # JSON list of roles.
-    queue_name: Optional[str]
 
 
 class RecordedResult(TypedDict):
@@ -104,19 +106,12 @@ class GetWorkflowsInput:
     Structure for argument to `get_workflows` function.
 
     This specifies the search criteria for workflow retrieval by `get_workflows`.
-
-    Attributes:
-       name(str):  The name of the workflow function
-       authenticated_user(str):  The name of the user who invoked the function
-       start_time(str): Beginning of search range for time of invocation, in ISO 8601 format
-       end_time(str): End of search range for time of invocation, in ISO 8601 format
-       status(str): Current status of the workflow invocation (see `WorkflowStatusString`)
-       application_version(str): Application version that invoked the workflow
-       limit(int): Limit on number of returned records
-
     """
 
     def __init__(self) -> None:
+        self.workflow_ids: Optional[List[str]] = (
+            None  # Search only in these workflow IDs
+        )
         self.name: Optional[str] = None  # The name of the workflow function
         self.authenticated_user: Optional[str] = None  # The user who ran the workflow.
         self.start_time: Optional[str] = None  # Timestamp in ISO 8601 format
@@ -128,14 +123,18 @@ class GetWorkflowsInput:
         self.limit: Optional[int] = (
             None  # Return up to this many workflows IDs. IDs are ordered by workflow creation time.
         )
+        self.offset: Optional[int] = (
+            None  # Offset into the matching records for pagination
+        )
 
 
 class GetQueuedWorkflowsInput(TypedDict):
-    queue_name: Optional[str]
-    status: Optional[str]
+    queue_name: Optional[str]  # Get workflows belonging to this queue
+    status: Optional[str]  # Get workflows with this status
     start_time: Optional[str]  # Timestamp in ISO 8601 format
     end_time: Optional[str]  # Timestamp in ISO 8601 format
     limit: Optional[int]  # Return up to this many workflows IDs.
+    offset: Optional[int]  # Offset into the matching records for pagination
     name: Optional[str]  # The name of the workflow function
 
 
@@ -489,27 +488,33 @@ class SystemDatabase:
                     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,
                 ).where(SystemSchema.workflow_status.c.workflow_uuid == workflow_uuid)
             ).fetchone()
             if row is None:
                 return None
             status: WorkflowStatusInternal = {
                 "workflow_uuid": workflow_uuid,
-                "status": row[0],
-                "name": row[1],
-                "class_name": row[5],
-                "config_name": row[4],
                 "output": None,
                 "error": None,
-                "app_id": None,
-                "app_version": None,
-                "executor_id": row[10],
+                "status": row[0],
+                "name": row[1],
                 "request": row[2],
                 "recovery_attempts": row[3],
+                "config_name": row[4],
+                "class_name": row[5],
                 "authenticated_user": row[6],
                 "authenticated_roles": row[7],
                 "assumed_role": row[8],
                 "queue_name": row[9],
+                "executor_id": row[10],
+                "created_at": row[11],
+                "updated_at": row[12],
+                "app_version": row[13],
+                "app_id": row[14],
             }
             return status
 
@@ -538,47 +543,6 @@ class SystemDatabase:
         )
         return stat
 
-    def get_workflow_status_w_outputs(
-        self, workflow_uuid: str
-    ) -> Optional[WorkflowStatusInternal]:
-        with self.engine.begin() as c:
-            row = c.execute(
-                sa.select(
-                    SystemSchema.workflow_status.c.status,
-                    SystemSchema.workflow_status.c.name,
-                    SystemSchema.workflow_status.c.request,
-                    SystemSchema.workflow_status.c.output,
-                    SystemSchema.workflow_status.c.error,
-                    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,
-                ).where(SystemSchema.workflow_status.c.workflow_uuid == workflow_uuid)
-            ).fetchone()
-            if row is None:
-                return None
-            status: WorkflowStatusInternal = {
-                "workflow_uuid": workflow_uuid,
-                "status": row[0],
-                "name": row[1],
-                "config_name": row[5],
-                "class_name": row[6],
-                "output": row[3],
-                "error": row[4],
-                "app_id": None,
-                "app_version": None,
-                "executor_id": None,
-                "request": row[2],
-                "recovery_attempts": None,
-                "authenticated_user": row[7],
-                "authenticated_roles": row[8],
-                "assumed_role": row[9],
-                "queue_name": row[10],
-            }
-            return status
-
     def await_workflow_result_internal(self, workflow_uuid: str) -> dict[str, Any]:
         polling_interval_secs: float = 1.000
 
@@ -625,21 +589,6 @@ class SystemDatabase:
             raise _serialization.deserialize_exception(stat["error"])
         return None
 
-    def get_workflow_info(
-        self, workflow_uuid: str, get_request: bool
-    ) -> Optional[WorkflowInformation]:
-        stat = self.get_workflow_status_w_outputs(workflow_uuid)
-        if stat is None:
-            return None
-        info = cast(WorkflowInformation, stat)
-        input = self.get_workflow_inputs(workflow_uuid)
-        if input is not None:
-            info["input"] = input
-        if not get_request:
-            info.pop("request", None)
-
-        return info
-
     def update_workflow_inputs(
         self, workflow_uuid: str, inputs: str, conn: Optional[sa.Connection] = None
     ) -> None:
@@ -715,14 +664,20 @@ class SystemDatabase:
                 SystemSchema.workflow_status.c.application_version
                 == input.application_version
             )
+        if input.workflow_ids:
+            query = query.where(
+                SystemSchema.workflow_status.c.workflow_uuid.in_(input.workflow_ids)
+            )
         if input.limit:
             query = query.limit(input.limit)
+        if input.offset:
+            query = query.offset(input.offset)
 
         with self.engine.begin() as c:
             rows = c.execute(query)
-        workflow_uuids = [row[0] for row in rows]
+        workflow_ids = [row[0] for row in rows]
 
-        return GetWorkflowsOutput(workflow_uuids)
+        return GetWorkflowsOutput(workflow_ids)
 
     def get_queued_workflows(
         self, input: GetQueuedWorkflowsInput
@@ -763,6 +718,8 @@ class SystemDatabase:
             )
         if input.get("limit"):
             query = query.limit(input["limit"])
+        if input.get("offset"):
+            query = query.offset(input["offset"])
 
         with self.engine.begin() as c:
             rows = c.execute(query)

dbos-0.23.0a5/dbos/_workflow_commands.py

@@ -0,0 +1,148 @@
+from typing import List, Optional, cast
+
+import typer
+
+from . import _serialization
+from ._dbos_config import ConfigFile
+from ._logger import dbos_logger
+from ._sys_db import (
+    GetQueuedWorkflowsInput,
+    GetWorkflowsInput,
+    GetWorkflowsOutput,
+    SystemDatabase,
+    WorkflowStatuses,
+)
+
+
+class WorkflowInformation:
+    workflow_id: str
+    status: WorkflowStatuses
+    workflow_name: str
+    workflow_class_name: Optional[str]
+    workflow_config_name: Optional[str]
+    authenticated_user: Optional[str]
+    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
+    queue_name: Optional[str]
+    executor_id: Optional[str]
+    app_version: Optional[str]
+    app_id: Optional[str]
+    recovery_attempts: Optional[int]
+
+
+def list_workflows(
+    sys_db: SystemDatabase,
+    *,
+    workflow_ids: Optional[List[str]] = None,
+    user: 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,
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+) -> List[WorkflowInformation]:
+    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.application_version = app_version
+    input.limit = limit
+    input.name = name
+    input.offset = offset
+
+    output: GetWorkflowsOutput = sys_db.get_workflows(input)
+    infos: List[WorkflowInformation] = []
+    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)
+    return infos
+
+
+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,
+    name: Optional[str] = None,
+    request: bool = False,
+    offset: Optional[int] = None,
+) -> List[WorkflowInformation]:
+    input: GetQueuedWorkflowsInput = {
+        "queue_name": queue_name,
+        "start_time": start_time,
+        "end_time": end_time,
+        "status": status,
+        "limit": limit,
+        "name": name,
+        "offset": offset,
+    }
+    output: GetWorkflowsOutput = sys_db.get_queued_workflows(input)
+    infos: List[WorkflowInformation] = []
+    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)
+    return infos
+
+
+def get_workflow(
+    sys_db: SystemDatabase, workflowUUID: str, getRequest: bool
+) -> Optional[WorkflowInformation]:
+
+    info = sys_db.get_workflow_status(workflowUUID)
+    if info 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)
+    if input_data is not None:
+        winfo.input = input_data
+
+    if info.get("status") == "SUCCESS":
+        result = sys_db.await_workflow_result(workflowUUID)
+        winfo.output = result
+    elif info.get("status") == "ERROR":
+        try:
+            sys_db.await_workflow_result(workflowUUID)
+        except Exception as e:
+            winfo.error = str(e)
+
+    if not getRequest:
+        winfo.request = None
+
+    return winfo

{dbos-0.23.0a3 → dbos-0.23.0a5}/dbos/cli/cli.py

@@ -19,12 +19,7 @@ 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 (
-    cancel_workflow,
-    get_workflow,
-    list_queued_workflows,
-    list_workflows,
-)
+from .._workflow_commands import get_workflow, list_queued_workflows, list_workflows
 from ..cli._github_init import create_template_from_github
 from ._template_init import copy_template, get_project_name, get_templates_directory
 
@@ -290,25 +285,37 @@ def list(
     request: Annotated[
         bool,
         typer.Option("--request", help="Retrieve workflow request information"),
-    ] = True,
+    ] = False,
 ) -> None:
     config = load_config(silent=True)
+    sys_db = SystemDatabase(config)
     workflows = list_workflows(
-        config, limit, user, starttime, endtime, status, request, appversion, name
+        sys_db,
+        limit=limit,
+        user=user,
+        start_time=starttime,
+        end_time=endtime,
+        status=status,
+        request=request,
+        app_version=appversion,
+        name=name,
     )
     print(jsonpickle.encode(workflows, unpicklable=False))
 
 
 @workflow.command(help="Retrieve the status of a workflow")
 def get(
-    uuid: Annotated[str, typer.Argument()],
+    workflow_id: Annotated[str, typer.Argument()],
     request: Annotated[
         bool,
         typer.Option("--request", help="Retrieve workflow request information"),
-    ] = True,
+    ] = False,
 ) -> None:
     config = load_config(silent=True)
-    print(jsonpickle.encode(get_workflow(config, uuid, request), unpicklable=False))
+    sys_db = SystemDatabase(config)
+    print(
+        jsonpickle.encode(get_workflow(sys_db, workflow_id, request), unpicklable=False)
+    )
 
 
 @workflow.command(
@@ -316,10 +323,23 @@ def get(
 )
 def cancel(
     uuid: Annotated[str, typer.Argument()],
+    host: Annotated[
+        typing.Optional[str],
+        typer.Option("--host", "-H", help="Specify the admin host"),
+    ] = "localhost",
+    port: Annotated[
+        typing.Optional[int],
+        typer.Option("--port", "-p", help="Specify the admin port"),
+    ] = 3001,
 ) -> None:
-    config = load_config()
-    cancel_workflow(config, uuid)
-    print(f"Workflow {uuid} has been cancelled")
+    response = requests.post(
+        f"http://{host}:{port}/workflows/{uuid}/cancel", json=[], timeout=5
+    )
+
+    if response.status_code == 204:
+        print(f"Workflow {uuid} has been cancelled")
+    else:
+        print(f"Failed to cancel workflow {uuid}. Status code: {response.status_code}")
 
 
 @workflow.command(help="Resume a workflow that has been cancelled")
@@ -327,7 +347,7 @@ def resume(
     uuid: Annotated[str, typer.Argument()],
     host: Annotated[
         typing.Optional[str],
-        typer.Option("--host", "-h", help="Specify the admin host"),
+        typer.Option("--host", "-H", help="Specify the admin host"),
     ] = "localhost",
     port: Annotated[
         typing.Optional[int],
@@ -338,7 +358,7 @@ def resume(
         f"http://{host}:{port}/workflows/{uuid}/resume", json=[], timeout=5
     )
 
-    if response.status_code == 200:
+    if response.status_code == 204:
         print(f"Workflow {uuid} has been resumed")
     else:
         print(f"Failed to resume workflow {uuid}. Status code: {response.status_code}")
@@ -349,7 +369,7 @@ def restart(
     uuid: Annotated[str, typer.Argument()],
     host: Annotated[
         typing.Optional[str],
-        typer.Option("--host", "-h", help="Specify the admin host"),
+        typer.Option("--host", "-H", help="Specify the admin host"),
     ] = "localhost",
     port: Annotated[
         typing.Optional[int],
@@ -360,7 +380,7 @@ def restart(
         f"http://{host}:{port}/workflows/{uuid}/restart", json=[], timeout=5
     )
 
-    if response.status_code == 200:
+    if response.status_code == 204:
         print(f"Workflow {uuid} has been restarted")
     else:
         print(f"Failed to resume workflow {uuid}. Status code: {response.status_code}")
@@ -415,11 +435,12 @@ def list_queue(
     request: Annotated[
         bool,
         typer.Option("--request", help="Retrieve workflow request information"),
-    ] = True,
+    ] = False,
 ) -> None:
     config = load_config(silent=True)
+    sys_db = SystemDatabase(config)
     workflows = list_queued_workflows(
-        config=config,
+        sys_db=sys_db,
         limit=limit,
         start_time=start_time,
         end_time=end_time,

{dbos-0.23.0a3 → dbos-0.23.0a5}/pyproject.toml

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

{dbos-0.23.0a3 → dbos-0.23.0a5}/tests/conftest.py

@@ -11,6 +11,7 @@ from flask import Flask
 
 from dbos import DBOS, ConfigFile
 from dbos._schemas.system_database import SystemSchema
+from dbos._sys_db import SystemDatabase
 
 
 @pytest.fixture(scope="session")
@@ -45,6 +46,13 @@ def config() -> ConfigFile:
     return default_config()
 
 
+@pytest.fixture()
+def sys_db(config: ConfigFile) -> Generator[SystemDatabase, Any, None]:
+    sys_db = SystemDatabase(config)
+    yield sys_db
+    sys_db.destroy()
+
+
 @pytest.fixture(scope="session")
 def postgres_db_engine() -> sa.Engine:
     cfg = default_config()

{dbos-0.23.0a3 → dbos-0.23.0a5}/tests/test_admin_server.py

@@ -1,4 +1,5 @@
 import os
+import threading
 import time
 import uuid
 
@@ -8,7 +9,7 @@ import sqlalchemy as sa
 # Public API
 from dbos import DBOS, ConfigFile, Queue, SetWorkflowID, _workflow_commands
 from dbos._schemas.system_database import SystemSchema
-from dbos._sys_db import WorkflowStatusString
+from dbos._sys_db import SystemDatabase, WorkflowStatusString
 from dbos._utils import GlobalParams
 
 
@@ -171,11 +172,13 @@ runtimeConfig:
         os.remove("dbos-config.yaml")
 
 
-def test_admin_workflow_resume(dbos: DBOS, config: ConfigFile) -> None:
+def test_admin_workflow_resume(dbos: DBOS, sys_db: SystemDatabase) -> None:
     counter: int = 0
+    event = threading.Event()
 
     @DBOS.workflow()
     def simple_workflow() -> None:
+        event.set()
         nonlocal counter
         counter += 1
 
@@ -185,13 +188,11 @@ def test_admin_workflow_resume(dbos: DBOS, config: ConfigFile) -> None:
     dbos._sys_db.wait_for_buffer_flush()
 
     # Verify the workflow has succeeded
-    output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None, None
-    )
+    output = _workflow_commands.list_workflows(sys_db)
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
     assert output[0] != None, "Expected output to be not None"
-    wfUuid = output[0].workflowUUID
-    info = _workflow_commands.get_workflow(config, wfUuid, True)
+    wfUuid = output[0].workflow_id
+    info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     assert info is not None, "Expected output to be not None"
     assert info.status == "SUCCESS", f"Expected status to be SUCCESS"
 
@@ -200,7 +201,7 @@ def test_admin_workflow_resume(dbos: DBOS, config: ConfigFile) -> None:
         f"http://localhost:3001/workflows/{wfUuid}/cancel", json=[], timeout=5
     )
     assert response.status_code == 204
-    info = _workflow_commands.get_workflow(config, wfUuid, True)
+    info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     assert info is not None
     assert info.status == "CANCELLED", f"Expected status to be CANCELLED"
 
@@ -216,13 +217,15 @@ def test_admin_workflow_resume(dbos: DBOS, config: ConfigFile) -> None:
         c.execute(query)
 
     # Resume the workflow. Verify that it succeeds again.
+    event.clear()
     response = requests.post(
         f"http://localhost:3001/workflows/{wfUuid}/resume", json=[], timeout=5
     )
     assert response.status_code == 204
+    assert event.wait(timeout=5)
     dbos._sys_db.wait_for_buffer_flush()
     assert counter == 2
-    info = _workflow_commands.get_workflow(config, wfUuid, True)
+    info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     assert info is not None
     assert info.status == "SUCCESS", f"Expected status to be SUCCESS"
     assert info.executor_id == GlobalParams.executor_id
@@ -233,13 +236,13 @@ def test_admin_workflow_resume(dbos: DBOS, config: ConfigFile) -> None:
     )
     assert response.status_code == 204
     dbos._sys_db.wait_for_buffer_flush()
-    info = _workflow_commands.get_workflow(config, wfUuid, True)
+    info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     assert info is not None
     assert info.status == "SUCCESS", f"Expected status to be SUCCESS"
     assert counter == 2
 
 
-def test_admin_workflow_restart(dbos: DBOS, config: ConfigFile) -> None:
+def test_admin_workflow_restart(dbos: DBOS, sys_db: SystemDatabase) -> None:
 
     @DBOS.workflow()
     def simple_workflow() -> None:
@@ -251,16 +254,14 @@ def test_admin_workflow_restart(dbos: DBOS, config: ConfigFile) -> None:
     time.sleep(1)
 
     # get the workflow list
-    output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None, None
-    )
+    output = _workflow_commands.list_workflows(sys_db)
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
 
     assert output[0] != None, "Expected output to be not None"
 
-    wfUuid = output[0].workflowUUID
+    wfUuid = output[0].workflow_id
 
-    info = _workflow_commands.get_workflow(config, wfUuid, True)
+    info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     assert info is not None, "Expected output to be not None"
 
     assert info.status == "SUCCESS", f"Expected status to be SUCCESS"
@@ -270,7 +271,7 @@ def test_admin_workflow_restart(dbos: DBOS, config: ConfigFile) -> None:
     )
     assert response.status_code == 204
 
-    info = _workflow_commands.get_workflow(config, wfUuid, True)
+    info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     if info is not None:
         assert info.status == "CANCELLED", f"Expected status to be CANCELLED"
     else:
@@ -283,23 +284,21 @@ def test_admin_workflow_restart(dbos: DBOS, config: ConfigFile) -> None:
 
     time.sleep(1)
 
-    info = _workflow_commands.get_workflow(config, wfUuid, True)
+    info = _workflow_commands.get_workflow(sys_db, wfUuid, True)
     if info is not None:
         assert info.status == "CANCELLED", f"Expected status to be CANCELLED"
     else:
         assert False, "Expected info to be not None"
 
-    output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None, None
-    )
+    output = _workflow_commands.list_workflows(sys_db)
     assert len(output) == 2, f"Expected list length to be 2, but got {len(output)}"
 
-    if output[0].workflowUUID == wfUuid:
-        new_wfUuid = output[1].workflowUUID
+    if output[0].workflow_id == wfUuid:
+        new_wfUuid = output[1].workflow_id
     else:
-        new_wfUuid = output[0].workflowUUID
+        new_wfUuid = output[0].workflow_id
 
-    info = _workflow_commands.get_workflow(config, new_wfUuid, True)
+    info = _workflow_commands.get_workflow(sys_db, new_wfUuid, True)
     if info is not None:
         assert info.status == "SUCCESS", f"Expected status to be SUCCESS"
     else: