dbos 0.26.0a7__py3-none-any.whl → 0.26.0a9__py3-none-any.whl

dbos/_docker_pg_helper.py

@@ -0,0 +1,191 @@
+import logging
+import os
+import subprocess
+import time
+
+import docker
+import psycopg
+from docker.errors import APIError, NotFound
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+from typing import Any, Dict, Optional, Tuple
+
+
+def start_docker_pg() -> None:
+    """
+    Starts a PostgreSQL database in a Docker container.
+
+    This function checks if Docker is installed, and if so, starts a local PostgreSQL
+    database in a Docker container. It configures the database with default settings
+    and provides connection information upon successful startup.
+
+    The function uses environment variable PGPASSWORD if available, otherwise
+    defaults to 'dbos' as the database password.
+
+    Returns:
+        None
+
+    Raises:
+        Exception: If there is an error starting the Docker container or if the
+                   PostgreSQL service does not become available within the timeout period.
+    """
+
+    logging.info("Attempting to create a Docker Postgres container...")
+    has_docker = check_docker_installed()
+
+    pool_config = {
+        "host": "localhost",
+        "port": 5432,
+        "password": os.environ.get("PGPASSWORD", "dbos"),
+        "user": "postgres",
+        "database": "postgres",
+        "connect_timeout": 2,
+    }
+
+    # If Docker is installed, start a local Docker based Postgres
+    if has_docker:
+        start_docker_postgres(pool_config)
+        logging.info(
+            f"Postgres available at postgres://postgres:{pool_config['password']}@{pool_config['host']}:{pool_config['port']}"
+        )
+    else:
+        logging.warning("Docker not detected locally")
+
+
+def check_db_connectivity(config: Dict[str, Any]) -> Optional[Exception]:
+    conn = None
+    try:
+        conn = psycopg.connect(
+            host=config["host"],
+            port=config["port"],
+            user=config["user"],
+            password=config["password"],
+            dbname=config["database"],
+            connect_timeout=config.get("connect_timeout", 30),
+        )
+        cursor = conn.cursor()
+        cursor.execute("SELECT 1;")
+        cursor.close()
+        return None
+    except Exception as error:
+        return error
+    finally:
+        if conn is not None:
+            conn.close()
+
+
+def exec_sync(cmd: str) -> Tuple[str, str]:
+    result = subprocess.run(cmd, shell=True, text=True, capture_output=True, check=True)
+    return result.stdout, result.stderr
+
+
+def start_docker_postgres(pool_config: Dict[str, Any]) -> bool:
+    logging.info("Starting a Postgres Docker container...")
+    container_name = "dbos-db"
+    pg_data = "/var/lib/postgresql/data"
+
+    try:
+        client = docker.from_env()
+
+        # Check if the container already exists
+        try:
+            container = client.containers.get(container_name)
+            if container.status == "running":
+                logging.info(f"Container '{container_name}' is already running.")
+                return True
+            elif container.status == "exited":
+                container.start()
+                logging.info(
+                    f"Container '{container_name}' was stopped and has been restarted."
+                )
+                return True
+        except NotFound:
+            # Container doesn't exist, proceed with creation
+            pass
+
+        # Create and start the container
+        container = client.containers.run(
+            image="pgvector/pgvector:pg16",
+            name=container_name,
+            detach=True,
+            environment={
+                "POSTGRES_PASSWORD": pool_config["password"],
+                "PGDATA": pg_data,
+            },
+            ports={"5432/tcp": pool_config["port"]},
+            volumes={pg_data: {"bind": pg_data, "mode": "rw"}},
+            remove=True,  # Equivalent to --rm
+        )
+
+        logging.info(f"Created container: {container.id}")
+
+    except APIError as e:
+        raise Exception(f"Docker API error: {str(e)}")
+
+    # Wait for PostgreSQL to be ready
+    attempts = 30
+    while attempts > 0:
+        if attempts % 5 == 0:
+            logging.info("Waiting for Postgres Docker container to start...")
+
+        if check_db_connectivity(pool_config) is None:
+            return True
+
+        attempts -= 1
+        time.sleep(1)
+
+    raise Exception(
+        f"Failed to start Docker container: Container {container_name} did not start in time."
+    )
+
+
+def check_docker_installed() -> bool:
+    """
+    Check if Docker is installed and running using the docker library.
+
+    Returns:
+        bool: True if Docker is installed and running, False otherwise.
+    """
+    try:
+        client = docker.from_env()
+        client.ping()  # type: ignore
+        return True
+    except Exception:
+        return False
+
+
+def stop_docker_pg() -> None:
+    """
+    Stops the Docker Postgres container.
+
+    Returns:
+        bool: True if the container was successfully stopped, False if it wasn't running
+
+    Raises:
+        Exception: If there was an error stopping the container
+    """
+    logger = logging.getLogger()
+    container_name = "dbos-db"
+    try:
+        logger.info(f"Stopping Docker Postgres container {container_name}...")
+
+        client = docker.from_env()
+
+        try:
+            container = client.containers.get(container_name)
+
+            if container.status == "running":
+                container.stop()
+                logger.info(
+                    f"Successfully stopped Docker Postgres container {container_name}."
+                )
+            else:
+                logger.info(f"Container {container_name} exists but is not running.")
+
+        except docker.errors.NotFound:
+            logger.info(f"Container {container_name} does not exist.")
+
+    except Exception as error:
+        error_message = str(error)
+        logger.error(f"Failed to stop Docker Postgres container: {error_message}")
+        raise

dbos/_error.py

@@ -37,6 +37,7 @@ class DBOSErrorCode(Enum):
     NotAuthorized = 8
     ConflictingWorkflowError = 9
     WorkflowCancelled = 10
+    UnexpectedStep = 11
     ConflictingRegistrationError = 25
 
 
@@ -155,3 +156,15 @@ class DBOSConflictingRegistrationError(DBOSException):
             f"Operation (Name: {name}) is already registered with a conflicting function type",
             dbos_error_code=DBOSErrorCode.ConflictingRegistrationError.value,
         )
+
+
+class DBOSUnexpectedStepError(DBOSException):
+    """Exception raised when a step has an unexpected recorded name."""
+
+    def __init__(
+        self, workflow_id: str, step_id: int, expected_name: str, recorded_name: str
+    ) -> None:
+        super().__init__(
+            f"During execution of workflow {workflow_id} step {step_id}, function {recorded_name} was recorded when {expected_name} was expected. Check that your workflow is deterministic.",
+            dbos_error_code=DBOSErrorCode.UnexpectedStep.value,
+        )

dbos/_sys_db.py

@@ -9,13 +9,14 @@ from enum import Enum
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Dict,
     List,
     Literal,
     Optional,
     Sequence,
-    Set,
     TypedDict,
+    TypeVar,
 )
 
 import psycopg
@@ -35,6 +36,8 @@ from ._error import (
     DBOSConflictingWorkflowError,
     DBOSDeadLetterQueueError,
     DBOSNonExistentWorkflowError,
+    DBOSUnexpectedStepError,
+    DBOSWorkflowCancelledError,
     DBOSWorkflowConflictIDError,
 )
 from ._logger import dbos_logger
@@ -577,9 +580,7 @@ class SystemDatabase:
             }
             return status
 
-    def await_workflow_result_internal(self, workflow_uuid: str) -> dict[str, Any]:
-        polling_interval_secs: float = 1.000
-
+    def await_workflow_result(self, workflow_id: str) -> Any:
         while True:
             with self.engine.begin() as c:
                 row = c.execute(
@@ -587,41 +588,23 @@ class SystemDatabase:
                         SystemSchema.workflow_status.c.status,
                         SystemSchema.workflow_status.c.output,
                         SystemSchema.workflow_status.c.error,
-                    ).where(
-                        SystemSchema.workflow_status.c.workflow_uuid == workflow_uuid
-                    )
+                    ).where(SystemSchema.workflow_status.c.workflow_uuid == workflow_id)
                 ).fetchone()
                 if row is not None:
                     status = row[0]
-                    if status == str(WorkflowStatusString.SUCCESS.value):
-                        return {
-                            "status": status,
-                            "output": row[1],
-                            "workflow_uuid": workflow_uuid,
-                        }
-
-                    elif status == str(WorkflowStatusString.ERROR.value):
-                        return {
-                            "status": status,
-                            "error": row[2],
-                            "workflow_uuid": workflow_uuid,
-                        }
-
+                    if status == WorkflowStatusString.SUCCESS.value:
+                        output = row[1]
+                        return _serialization.deserialize(output)
+                    elif status == WorkflowStatusString.ERROR.value:
+                        error = row[2]
+                        raise _serialization.deserialize_exception(error)
+                    elif status == WorkflowStatusString.CANCELLED.value:
+                        # Raise a normal exception here, not the cancellation exception
+                        # because the awaiting workflow is not being cancelled.
+                        raise Exception(f"Awaited workflow {workflow_id} was cancelled")
                 else:
                     pass  # CB: I guess we're assuming the WF will show up eventually.
-
-            time.sleep(polling_interval_secs)
-
-    def await_workflow_result(self, workflow_uuid: str) -> Any:
-        stat = self.await_workflow_result_internal(workflow_uuid)
-        if not stat:
-            return None
-        status: str = stat["status"]
-        if status == str(WorkflowStatusString.SUCCESS.value):
-            return _serialization.deserialize(stat["output"])
-        elif status == str(WorkflowStatusString.ERROR.value):
-            raise _serialization.deserialize_exception(stat["error"])
-        return None
+            time.sleep(1)
 
     def update_workflow_inputs(
         self, workflow_uuid: str, inputs: str, conn: Optional[sa.Connection] = None
@@ -895,16 +878,34 @@ class SystemDatabase:
             raise
 
     def check_operation_execution(
-        self, workflow_uuid: str, function_id: int, conn: Optional[sa.Connection] = None
+        self,
+        workflow_id: str,
+        function_id: int,
+        function_name: str,
+        *,
+        conn: Optional[sa.Connection] = None,
     ) -> Optional[RecordedResult]:
-        sql = sa.select(
-            SystemSchema.operation_outputs.c.output,
-            SystemSchema.operation_outputs.c.error,
-        ).where(
-            SystemSchema.operation_outputs.c.workflow_uuid == workflow_uuid,
-            SystemSchema.operation_outputs.c.function_id == function_id,
+        # Retrieve the status of the workflow. Additionally, if this step
+        # has run before, retrieve its name, output, and error.
+        sql = (
+            sa.select(
+                SystemSchema.workflow_status.c.status,
+                SystemSchema.operation_outputs.c.output,
+                SystemSchema.operation_outputs.c.error,
+                SystemSchema.operation_outputs.c.function_name,
+            )
+            .select_from(
+                SystemSchema.workflow_status.outerjoin(
+                    SystemSchema.operation_outputs,
+                    (
+                        SystemSchema.workflow_status.c.workflow_uuid
+                        == SystemSchema.operation_outputs.c.workflow_uuid
+                    )
+                    & (SystemSchema.operation_outputs.c.function_id == function_id),
+                )
+            )
+            .where(SystemSchema.workflow_status.c.workflow_uuid == workflow_id)
         )
-
         # If in a transaction, use the provided connection
         rows: Sequence[Any]
         if conn is not None:
@@ -912,11 +913,32 @@ class SystemDatabase:
         else:
             with self.engine.begin() as c:
                 rows = c.execute(sql).all()
-        if len(rows) == 0:
+        assert len(rows) > 0, f"Error: Workflow {workflow_id} does not exist"
+        workflow_status, output, error, recorded_function_name = (
+            rows[0][0],
+            rows[0][1],
+            rows[0][2],
+            rows[0][3],
+        )
+        # If the workflow is cancelled, raise the exception
+        if workflow_status == WorkflowStatusString.CANCELLED.value:
+            raise DBOSWorkflowCancelledError(
+                f"Workflow {workflow_id} is cancelled. Aborting function."
+            )
+        # If there is no row for the function, return None
+        if recorded_function_name is None:
             return None
+        # If the provided and recorded function name are different, throw an exception.
+        if function_name != recorded_function_name:
+            raise DBOSUnexpectedStepError(
+                workflow_id=workflow_id,
+                step_id=function_id,
+                expected_name=function_name,
+                recorded_name=recorded_function_name,
+            )
         result: RecordedResult = {
-            "output": rows[0][0],
-            "error": rows[0][1],
+            "output": output,
+            "error": error,
         }
         return result
 
@@ -945,10 +967,11 @@ class SystemDatabase:
         message: Any,
         topic: Optional[str] = None,
     ) -> None:
+        function_name = "DBOS.send"
         topic = topic if topic is not None else _dbos_null_topic
         with self.engine.begin() as c:
             recorded_output = self.check_operation_execution(
-                workflow_uuid, function_id, conn=c
+                workflow_uuid, function_id, function_name, conn=c
             )
             if self._debug_mode and recorded_output is None:
                 raise Exception(
@@ -981,7 +1004,7 @@ class SystemDatabase:
             output: OperationResultInternal = {
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
-                "function_name": "DBOS.send",
+                "function_name": function_name,
                 "output": None,
                 "error": None,
             }
@@ -995,10 +1018,13 @@ class SystemDatabase:
         topic: Optional[str],
         timeout_seconds: float = 60,
     ) -> Any:
+        function_name = "DBOS.recv"
         topic = topic if topic is not None else _dbos_null_topic
 
         # First, check for previous executions.
-        recorded_output = self.check_operation_execution(workflow_uuid, function_id)
+        recorded_output = self.check_operation_execution(
+            workflow_uuid, function_id, function_name
+        )
         if self._debug_mode and recorded_output is None:
             raise Exception("called recv in debug mode without a previous execution")
         if recorded_output is not None:
@@ -1075,7 +1101,7 @@ class SystemDatabase:
                 {
                     "workflow_uuid": workflow_uuid,
                     "function_id": function_id,
-                    "function_name": "DBOS.recv",
+                    "function_name": function_name,
                     "output": _serialization.serialize(
                         message
                     ),  # None will be serialized to 'null'
@@ -1149,7 +1175,10 @@ class SystemDatabase:
         seconds: float,
         skip_sleep: bool = False,
     ) -> float:
-        recorded_output = self.check_operation_execution(workflow_uuid, function_id)
+        function_name = "DBOS.sleep"
+        recorded_output = self.check_operation_execution(
+            workflow_uuid, function_id, function_name
+        )
         end_time: float
         if self._debug_mode and recorded_output is None:
             raise Exception("called sleep in debug mode without a previous execution")
@@ -1166,7 +1195,7 @@ class SystemDatabase:
                     {
                         "workflow_uuid": workflow_uuid,
                         "function_id": function_id,
-                        "function_name": "DBOS.sleep",
+                        "function_name": function_name,
                         "output": _serialization.serialize(end_time),
                         "error": None,
                     }
@@ -1185,9 +1214,10 @@ class SystemDatabase:
         key: str,
         message: Any,
     ) -> None:
+        function_name = "DBOS.setEvent"
         with self.engine.begin() as c:
             recorded_output = self.check_operation_execution(
-                workflow_uuid, function_id, conn=c
+                workflow_uuid, function_id, function_name, conn=c
             )
             if self._debug_mode and recorded_output is None:
                 raise Exception(
@@ -1214,7 +1244,7 @@ class SystemDatabase:
             output: OperationResultInternal = {
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
-                "function_name": "DBOS.setEvent",
+                "function_name": function_name,
                 "output": None,
                 "error": None,
             }
@@ -1227,6 +1257,7 @@ class SystemDatabase:
         timeout_seconds: float = 60,
         caller_ctx: Optional[GetEventWorkflowContext] = None,
     ) -> Any:
+        function_name = "DBOS.getEvent"
         get_sql = sa.select(
             SystemSchema.workflow_events.c.value,
         ).where(
@@ -1236,7 +1267,7 @@ class SystemDatabase:
         # Check for previous executions only if it's in a workflow
         if caller_ctx is not None:
             recorded_output = self.check_operation_execution(
-                caller_ctx["workflow_uuid"], caller_ctx["function_id"]
+                caller_ctx["workflow_uuid"], caller_ctx["function_id"], function_name
             )
             if self._debug_mode and recorded_output is None:
                 raise Exception(
@@ -1295,7 +1326,7 @@ class SystemDatabase:
                 {
                     "workflow_uuid": caller_ctx["workflow_uuid"],
                     "function_id": caller_ctx["function_id"],
-                    "function_name": "DBOS.getEvent",
+                    "function_name": function_name,
                     "output": _serialization.serialize(
                         value
                     ),  # None will be serialized to 'null'
@@ -1534,6 +1565,40 @@ class SystemDatabase:
                     )
                 return True
 
+    T = TypeVar("T")
+
+    def call_function_as_step(self, fn: Callable[[], T], function_name: str) -> T:
+        ctx = get_local_dbos_context()
+        if ctx and ctx.is_within_workflow():
+            ctx.function_id += 1
+            res = self.check_operation_execution(
+                ctx.workflow_id, ctx.function_id, function_name
+            )
+            if res is not None:
+                if res["output"] is not None:
+                    resstat: SystemDatabase.T = _serialization.deserialize(
+                        res["output"]
+                    )
+                    return resstat
+                elif res["error"] is not None:
+                    raise _serialization.deserialize_exception(res["error"])
+                else:
+                    raise Exception(
+                        f"Recorded output and error are both None for {function_name}"
+                    )
+        result = fn()
+        if ctx and ctx.is_within_workflow():
+            self.record_operation_result(
+                {
+                    "workflow_uuid": ctx.workflow_id,
+                    "function_id": ctx.function_id,
+                    "function_name": function_name,
+                    "output": _serialization.serialize(result),
+                    "error": None,
+                }
+            )
+        return result
+
 
 def reset_system_database(config: ConfigFile) -> None:
     sysdb_name = (

dbos/_workflow_commands.py

@@ -45,6 +45,9 @@ class WorkflowStatus:
     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

dbos/cli/cli.py

@@ -20,6 +20,7 @@ from dbos._debug import debug_workflow, parse_start_command
 from .. import load_config
 from .._app_db import ApplicationDatabase
 from .._dbos_config import _is_valid_app_name
+from .._docker_pg_helper import start_docker_pg, stop_docker_pg
 from .._sys_db import SystemDatabase, reset_system_database
 from .._workflow_commands import (
     get_workflow,
@@ -37,6 +38,21 @@ queue = typer.Typer()
 app.add_typer(workflow, name="workflow", help="Manage DBOS workflows")
 workflow.add_typer(queue, name="queue", help="Manage enqueued workflows")
 
+postgres = typer.Typer()
+app.add_typer(
+    postgres, name="postgres", help="Manage local Postgres database with Docker"
+)
+
+
+@postgres.command(name="start", help="Start a local Postgres database")
+def pg_start() -> None:
+    start_docker_pg()
+
+
+@postgres.command(name="stop", help="Stop the local Postgres database")
+def pg_stop() -> None:
+    stop_docker_pg()
+
 
 def _on_windows() -> bool:
     return platform.system() == "Windows"
@@ -246,7 +262,7 @@ def reset(
 def debug(
     workflow_id: Annotated[str, typer.Argument(help="Workflow ID to debug")],
 ) -> None:
-    config = load_config(silent=True, use_db_wizard=False)
+    config = load_config(silent=True)
     start = config["runtimeConfig"]["start"]
     if not start:
         typer.echo("No start commands found in 'dbos-config.yaml'")

dbos/dbos-config.schema.json

@@ -62,10 +62,6 @@
             "type": "string",
             "description": "If using SSL/TLS to securely connect to a database, path to an SSL root certificate file"
           },
-          "local_suffix": {
-            "type": "boolean",
-            "description": "Whether to suffix app_db_name with '_local'. Set to true when doing local development using a DBOS Cloud database."
-          },
           "app_db_client": {
             "type": "string",
             "description": "Specify the database client to use to connect to the application database",

{dbos-0.26.0a7.dist-info → dbos-0.26.0a9.dist-info}/METADATA

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

{dbos-0.26.0a7.dist-info → dbos-0.26.0a9.dist-info}/RECORD

@@ -1,26 +1,23 @@
-dbos-0.26.0a7.dist-info/METADATA,sha256=PjY70KmfnbwPahIoEhiSsBEG6VLDOb972f59w0UWS3Q,5553
-dbos-0.26.0a7.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-0.26.0a7.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.26.0a7.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.26.0a9.dist-info/METADATA,sha256=Olpmk9xnLEbfqKPtj7_cLfCShqh_RFowiykc6KtBTNQ,5553
+dbos-0.26.0a9.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-0.26.0a9.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.26.0a9.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=3NQfGlBiiUSM_v88STdVP3rNZvGkUL_9WbSotKb8Voo,873
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=vxPG_YJ6lYrkfPCSp42FiATVLBOij7Fm52Yngg5Z_tE,7027
-dbos/_app_db.py,sha256=XdjZgKJMezSVZQJkvxBNa9x4asLURl2O-QxdmLai7wA,8491
+dbos/_app_db.py,sha256=IwnNlHEQYp2bl5BM66vVPFa40h8DOtvRgUWTJ1dz20A,8963
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
 dbos/_client.py,sha256=fzW_Gagh-oyWyDYtREcQDBesoVl_LsEoMeJAsn5-C5s,7262
-dbos/_cloudutils/authentication.py,sha256=V0fCWQN9stCkhbuuxgPTGpvuQcDqfU3KAxPAh01vKW4,5007
-dbos/_cloudutils/cloudutils.py,sha256=YC7jGsIopT0KveLsqbRpQk2KlRBk-nIRC_UCgep4f3o,7797
-dbos/_cloudutils/databases.py,sha256=_shqaqSvhY4n2ScgQ8IP5PDZvzvcx3YBKV8fj-cxhSY,8543
-dbos/_conductor/conductor.py,sha256=PzUFCX_JXGHClTF-hqTLR0ssO4kXdet4ZwHhJtuevEM,16839
+dbos/_conductor/conductor.py,sha256=HYzVL29IMMrs2Mnms_7cHJynCnmmEN5SDQOMjzn3UoU,16840
 dbos/_conductor/protocol.py,sha256=xN7pmooyF1pqbH1b6WhllU5718P7zSb_b0KCwA6bzcs,6716
 dbos/_context.py,sha256=I8sLkdKTTkZEz7wG-MjynaQB6XEF2bLXuwNksiauP7w,19430
-dbos/_core.py,sha256=EA9X4lTTTlimN8oa_mFICtl6Ke2biCvPdHl6PABjgGI,45749
+dbos/_core.py,sha256=tjBGVbSgOn59lR29gcYi5f6fcKNKQM5EP1QXrQGUkXA,45426
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_db_wizard.py,sha256=VnMa6OL87Lc-XPDD1RnXp8NjsJE8YgiQLj3wtWAXp-8,8252
-dbos/_dbos.py,sha256=je4LWR78S5uitxNzyf3k_x5KErEmXyu88TjqZnHtQXU,46183
-dbos/_dbos_config.py,sha256=rTn30Hgh-RzTxqHbnYh2pC3Ioo30eJV9K4YxhJd-Gj4,22718
-dbos/_debug.py,sha256=mmgvLkqlrljMBBow9wk01PPur9kUf2rI_11dTJXY4gw,1822
-dbos/_error.py,sha256=B6Y9XLS1f6yrawxB2uAEYFMxFwk9BHhdxPNddKco-Fw,5399
+dbos/_dbos.py,sha256=TOLi95Aca50huyOAWl9H5fii4nMYaGwN-zQ8GlLWdOg,45569
+dbos/_dbos_config.py,sha256=m05IFjM0jSwZBsnFMF_4qP2JkjVFc0gqyM2tnotXq20,20636
+dbos/_debug.py,sha256=MNlQVZ6TscGCRQeEEL0VE8Uignvr6dPeDDDefS3xgIE,1823
+dbos/_docker_pg_helper.py,sha256=9OGbuavRA_cwE-uPiLZJSdpbQu-6PPgl9clQZB2zT_U,5852
+dbos/_error.py,sha256=HtdV6Qy7qRyGD57wxLwE7YT0WdYtlx5ZLEe_Kv_gC-U,5953
 dbos/_fastapi.py,sha256=PhaKftbApHnjtYEOw0EYna_3K0cmz__J9of7mRJWzu4,3704
 dbos/_flask.py,sha256=DZKUZR5-xOzPI7tYZ53r2PvvHVoAb8SYwLzMVFsVfjI,2608
 dbos/_kafka.py,sha256=pz0xZ9F3X9Ky1k-VSbeF3tfPhP3UPr3lUUhUfE41__U,4198
@@ -47,7 +44,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=VBYVyKqZrwlFbDJ5cFIkeS5WtDOKpkI3lWJbSd5rB2s,65362
+dbos/_sys_db.py,sha256=BqXZ0l4X4Y4cFKDyaa8ZirWCnRlof9A12yp-XflGnb0,68229
 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
@@ -60,11 +57,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=w981c3rVvhbhYd6BBP268C0Q88ClmwBwnachBxfnRmU,6129
+dbos/_workflow_commands.py,sha256=Tf7_hZQoPgP90KHQjMNlBggCNrLLCNRJxHtAJLvarc4,6153
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=-WW3kbq0W_Tq4WbMqb1UGJG3xvJb3woEY5VspG95Srk,2857
-dbos/cli/cli.py,sha256=FnI5ZAo-kAic-ij5wBqNJ2EJiYoBK1Ot-tTMh1WcXEM,16132
-dbos/dbos-config.schema.json,sha256=4z2OXPfp7H0uNT1m5dKxjg31qbAfPyKkFXwHufuUMec,5910
+dbos/cli/cli.py,sha256=Lb_RYmXoT5KH0xDbwaYpROE4c-svZ0eCq2Kxg7cAxTw,16537
+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.0a7.dist-info/RECORD,,
+dbos-0.26.0a9.dist-info/RECORD,,