dbos 0.23.0a3__py3-none-any.whl → 0.23.0a5__py3-none-any.whl

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/_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/_workflow_commands.py

@@ -4,6 +4,7 @@ import typer
 
 from . import _serialization
 from ._dbos_config import ConfigFile
+from ._logger import dbos_logger
 from ._sys_db import (
     GetQueuedWorkflowsInput,
     GetWorkflowsInput,
@@ -14,69 +15,65 @@ from ._sys_db import (
 
 
 class WorkflowInformation:
-    workflowUUID: str
+    workflow_id: str
     status: WorkflowStatuses
-    workflowName: str
-    workflowClassName: Optional[str]
-    workflowConfigName: Optional[str]
+    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]
-    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]
 
 
 def list_workflows(
-    config: ConfigFile,
-    limit: int,
-    user: Optional[str],
-    starttime: Optional[str],
-    endtime: Optional[str],
-    status: Optional[str],
-    request: bool,
-    appversion: Optional[str],
-    name: Optional[str],
+    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]:
-    try:
-        sys_db = SystemDatabase(config)
-
-        input = GetWorkflowsInput()
-        input.authenticated_user = user
-        input.start_time = starttime
-        input.end_time = endtime
-        if status is not None:
-            input.status = cast(WorkflowStatuses, status)
-        input.application_version = appversion
-        input.limit = limit
-        input.name = name
-
-        output: GetWorkflowsOutput = sys_db.get_workflows(input)
-        infos: List[WorkflowInformation] = []
-        for workflow_id in output.workflow_uuids:
-            info = _get_workflow_info(
-                sys_db, workflow_id, request
-            )  # Call the method for each ID
-            if info is not None:
-                infos.append(info)
-
-        return infos
-    except Exception as e:
-        typer.echo(f"Error listing workflows: {e}")
-        return []
-    finally:
-        if sys_db:
-            sys_db.destroy()
+    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(
-    config: ConfigFile,
+    sys_db: SystemDatabase,
+    *,
     limit: Optional[int] = None,
     start_time: Optional[str] = None,
     end_time: Optional[str] = None,
@@ -84,62 +81,27 @@ def list_queued_workflows(
     status: Optional[str] = None,
     name: Optional[str] = None,
     request: bool = False,
+    offset: Optional[int] = None,
 ) -> List[WorkflowInformation]:
-    try:
-        sys_db = SystemDatabase(config)
-        input: GetQueuedWorkflowsInput = {
-            "queue_name": queue_name,
-            "start_time": start_time,
-            "end_time": end_time,
-            "status": status,
-            "limit": limit,
-            "name": name,
-        }
-        output: GetWorkflowsOutput = sys_db.get_queued_workflows(input)
-        infos: List[WorkflowInformation] = []
-        for workflow_id in output.workflow_uuids:
-            info = _get_workflow_info(
-                sys_db, workflow_id, request
-            )  # Call the method for each ID
-            if info is not None:
-                infos.append(info)
-        return infos
-    except Exception as e:
-        typer.echo(f"Error listing workflows: {e}")
-        return []
-    finally:
-        if sys_db:
-            sys_db.destroy()
+    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(
-    config: ConfigFile, uuid: str, request: bool
-) -> Optional[WorkflowInformation]:
-    try:
-        sys_db = SystemDatabase(config)
-        info = _get_workflow_info(sys_db, uuid, request)
-        return info
-    except Exception as e:
-        typer.echo(f"Error getting workflow: {e}")
-        return None
-    finally:
-        if sys_db:
-            sys_db.destroy()
-
-
-def cancel_workflow(config: ConfigFile, uuid: str) -> None:
-    try:
-        sys_db = SystemDatabase(config)
-        sys_db.cancel_workflow(uuid)
-    except Exception as e:
-        typer.echo(f"Failed to connect to DBOS system database: {e}")
-        raise e
-    finally:
-        if sys_db:
-            sys_db.destroy()
-
-
-def _get_workflow_info(
     sys_db: SystemDatabase, workflowUUID: str, getRequest: bool
 ) -> Optional[WorkflowInformation]:
 
@@ -149,19 +111,22 @@ def _get_workflow_info(
 
     winfo = WorkflowInformation()
 
-    winfo.workflowUUID = workflowUUID
+    winfo.workflow_id = workflowUUID
     winfo.status = info["status"]
-    winfo.workflowName = info["name"]
-    winfo.workflowClassName = info["class_name"]
-    winfo.workflowConfigName = info["config_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"]
+    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)

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.dist-info → dbos-0.23.0a5.dist-info}/METADATA

@@ -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.dist-info → dbos-0.23.0a5.dist-info}/RECORD

@@ -1,7 +1,7 @@
-dbos-0.23.0a3.dist-info/METADATA,sha256=8LvPLZui1gzTiynS6_-_tRmzgj3lY8lziDPA35BCNMk,5309
-dbos-0.23.0a3.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-dbos-0.23.0a3.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.23.0a3.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.23.0a5.dist-info/METADATA,sha256=saWbNoKPc4hy7CWVchMo64BhlRX3rBrl8q49PC4GCAY,5309
+dbos-0.23.0a5.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+dbos-0.23.0a5.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.23.0a5.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=CxRHBHEthPL4PZoLbZhp3rdm44-KkRTT2-7DkK9d4QQ,724
 dbos/_admin_server.py,sha256=YiVn5lywz2Vg8_juyNHOYl0HVEy48--7b4phwK7r92o,5732
 dbos/_app_db.py,sha256=_tv2vmPjjiaikwgxH3mqxgJ4nUUcG2-0uMXKWCqVu1c,5509
@@ -10,7 +10,7 @@ dbos/_cloudutils/authentication.py,sha256=V0fCWQN9stCkhbuuxgPTGpvuQcDqfU3KAxPAh0
 dbos/_cloudutils/cloudutils.py,sha256=YC7jGsIopT0KveLsqbRpQk2KlRBk-nIRC_UCgep4f3o,7797
 dbos/_cloudutils/databases.py,sha256=_shqaqSvhY4n2ScgQ8IP5PDZvzvcx3YBKV8fj-cxhSY,8543
 dbos/_context.py,sha256=Ue5qu3rzLfRmPkz-UUZi9ZS8iXpapRN0NTM4mbA2QmQ,17738
-dbos/_core.py,sha256=2nd_0p1aZM3nVN_nKzwtmgKosU9VIQwE-tPVqeBKryY,36557
+dbos/_core.py,sha256=MWIa8r-KwnadYQtGSod2KdAaeQ4gTJAUMPhMGaM0u2c,36613
 dbos/_croniter.py,sha256=hbhgfsHBqclUS8VeLnJ9PSE9Z54z6mi4nnrr1aUXn0k,47561
 dbos/_db_wizard.py,sha256=6tfJaCRa1NtkUdNW75a2yvi_mEgnPJ9C1HP2zPG1hCU,8067
 dbos/_dbos.py,sha256=JNAFYQ3kVjnZsUl0qJ-JWeaSHKI51VGE3JBXdaPD8Oo,39054
@@ -41,7 +41,7 @@ dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=KeyoPrF7hy_ODXV7QNike_VFSD74QBRfQ76D7QyE9HI,966
 dbos/_schemas/system_database.py,sha256=rwp4EvCSaXcUoMaRczZCvETCxGp72k3-hvLyGUDkih0,5163
 dbos/_serialization.py,sha256=YCYv0qKAwAZ1djZisBC7khvKqG-5OcIv9t9EC5PFIog,1743
-dbos/_sys_db.py,sha256=Dw3pM7xT5K5Y3evCBOU4KNCjov8NkcYHZWZ1EPIHhVk,62692
+dbos/_sys_db.py,sha256=tyBQicOkkf563CU83MwZubENpI5AmCYFyz2tSbQ9XQ4,61045
 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=eI0SS9Nwj-fldtiuSzIlIG6dC91GXXwdRsoHxv6S_WI,2719
@@ -54,11 +54,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=_Id9j9kCrptSNpEpLiRk_g5VPp-DrTWP1WNZInd5BA4,2439
 dbos/_utils.py,sha256=wjOJzxN66IzL9p4dwcEmQACRQah_V09G6mJI2exQfOM,155
-dbos/_workflow_commands.py,sha256=gAynfrq5sAMhdNpMIphiAm_hC2-xk1ZyWEYA-whtfPs,5402
+dbos/_workflow_commands.py,sha256=ZAdVccVuSFlcZ_kEdo6MwQ9xaslVXn_MMRTybJlkyQw,4652
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=AfuMaO8bmr9WsPNHr6j2cp7kjVVZDUpH7KpbTg0hhFs,2722
-dbos/cli/cli.py,sha256=_tXw2IQrWW7fV_h51f_R99vEBSi6aMLz-vCOxKaENiQ,14155
+dbos/cli/cli.py,sha256=BJWFT94I14uKTmMYSI4ITscPMBgidgjV0RBx5_LyNKI,14849
 dbos/dbos-config.schema.json,sha256=X5TpXNcARGceX0zQs0fVgtZW_Xj9uBbY5afPt9Rz9yk,5741
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.23.0a3.dist-info/RECORD,,
+dbos-0.23.0a5.dist-info/RECORD,,