dbos 0.24.0a4__py3-none-any.whl → 0.24.0a5__py3-none-any.whl

dbos/__init__.py

@@ -1,13 +1,14 @@
 from . import _error as error
 from ._context import DBOSContextEnsure, DBOSContextSetAuth, SetWorkflowID
 from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle, WorkflowStatus
-from ._dbos_config import ConfigFile, get_dbos_database_url, load_config
+from ._dbos_config import ConfigFile, DBOSConfig, get_dbos_database_url, load_config
 from ._kafka_message import KafkaMessage
 from ._queue import Queue
 from ._sys_db import GetWorkflowsInput, WorkflowStatusString
 
 __all__ = [
     "ConfigFile",
+    "DBOSConfig",
     "DBOS",
     "DBOSConfiguredInstance",
     "DBOSContextEnsure",

dbos/_db_wizard.py

@@ -28,7 +28,20 @@ class DatabaseConnection(TypedDict):
     local_suffix: Optional[bool]
 
 
-def db_wizard(config: "ConfigFile", config_file_path: str) -> "ConfigFile":
+def db_wizard(config: "ConfigFile") -> "ConfigFile":
+    """Checks database connectivity and helps the user start a database if needed
+
+    First, check connectivity to the database configured in the provided `config` object.
+    If it fails:
+     - Return an error if the connection failed due to incorrect credentials.
+     - Return an error if it detects a non-default configuration.
+     - Otherwise assume the configured database is not running and guide the user through setting it up.
+
+     The wizard will first attempt to start a local Postgres instance using Docker.
+     If Docker is not available, it will prompt the user to connect to a DBOS Cloud database.
+
+     Finally, if a database was configured, its connection details will be saved in the local `.dbos/db_connection` file.
+    """
     # 1. Check the connectivity to the database. Return if successful. If cannot connect, continue to the following steps.
     db_connection_error = _check_db_connectivity(config)
     if db_connection_error is None:
@@ -44,27 +57,18 @@ def db_wizard(config: "ConfigFile", config_file_path: str) -> "ConfigFile":
         raise DBOSInitializationError(
             f"Could not connect to Postgres: password authentication failed: {db_connection_error}"
         )
-    db_config = config["database"]
-
-    # Read the config file and check if the database hostname/port/username are set. If so, skip the wizard.
-    with open(config_file_path, "r") as file:
-        content = file.read()
-        local_config = yaml.safe_load(content)
-        if "database" not in local_config:
-            local_config["database"] = {}
-        local_config = cast("ConfigFile", local_config)
 
+    # If the database config is not the default one, surface the error and exit.
+    db_config = config["database"]  # FIXME: what if database is not in config?
     if (
-        local_config["database"].get("hostname")
-        or local_config["database"].get("port")
-        or local_config["database"].get("username")
-        or db_config["hostname"] != "localhost"
+        db_config["hostname"] != "localhost"
         or db_config["port"] != 5432
         or db_config["username"] != "postgres"
     ):
         raise DBOSInitializationError(
             f"Could not connect to the database. Exception: {db_connection_error}"
         )
+
     print("[yellow]Postgres not detected locally[/yellow]")
 
     # 3. If the database config is the default one, check if the user has Docker properly installed.

dbos/_dbos.py

@@ -88,13 +88,23 @@ from ._context import (
     assert_current_dbos_context,
     get_local_dbos_context,
 )
-from ._dbos_config import ConfigFile, load_config, set_env_vars
+from ._dbos_config import (
+    ConfigFile,
+    DBOSConfig,
+    check_config_consistency,
+    is_dbos_configfile,
+    load_config,
+    overwrite_config,
+    process_config,
+    set_env_vars,
+    translate_dbos_config_to_config_file,
+)
 from ._error import (
     DBOSConflictingRegistrationError,
     DBOSException,
     DBOSNonExistentWorkflowError,
 )
-from ._logger import add_otlp_to_all_loggers, dbos_logger
+from ._logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
 from ._sys_db import SystemDatabase
 
 # Most DBOS functions are just any callable F, so decorators / wrappers work on F
@@ -257,7 +267,7 @@ class DBOS:
     def __new__(
         cls: Type[DBOS],
         *,
-        config: Optional[ConfigFile] = None,
+        config: Optional[Union[ConfigFile, DBOSConfig]] = None,
         fastapi: Optional["FastAPI"] = None,
         flask: Optional["Flask"] = None,
         conductor_url: Optional[str] = None,
@@ -302,7 +312,7 @@ class DBOS:
     def __init__(
         self,
         *,
-        config: Optional[ConfigFile] = None,
+        config: Optional[Union[ConfigFile, DBOSConfig]] = None,
         fastapi: Optional["FastAPI"] = None,
         flask: Optional["Flask"] = None,
         conductor_url: Optional[str] = None,
@@ -312,12 +322,7 @@ class DBOS:
             return
 
         self._initialized: bool = True
-        if config is None:
-            config = load_config()
-        set_env_vars(config)
-        dbos_tracer.config(config)
-        dbos_logger.info("Initializing DBOS")
-        self.config: ConfigFile = config
+
         self._launched: bool = False
         self._debug_mode: bool = False
         self._sys_db_field: Optional[SystemDatabase] = None
@@ -334,6 +339,36 @@ class DBOS:
         self.conductor_key: Optional[str] = conductor_key
         self.conductor_websocket: Optional[ConductorWebsocket] = None
 
+        init_logger()
+
+        unvalidated_config: Optional[ConfigFile] = None
+
+        if config is None:
+            # If no config is provided, load it from dbos-config.yaml
+            unvalidated_config = load_config(run_process_config=False)
+        elif is_dbos_configfile(config):
+            unvalidated_config = cast(ConfigFile, config)
+            if os.environ.get("DBOS__CLOUD") == "true":
+                unvalidated_config = overwrite_config(unvalidated_config)
+            check_config_consistency(name=unvalidated_config["name"])
+        else:
+            unvalidated_config = translate_dbos_config_to_config_file(
+                cast(DBOSConfig, config)
+            )
+            if os.environ.get("DBOS__CLOUD") == "true":
+                unvalidated_config = overwrite_config(unvalidated_config)
+            check_config_consistency(name=unvalidated_config["name"])
+
+        if unvalidated_config is not None:
+            self.config: ConfigFile = process_config(data=unvalidated_config)
+        else:
+            raise ValueError("No valid configuration was loaded.")
+
+        set_env_vars(self.config)
+        config_logger(self.config)
+        dbos_tracer.config(self.config)
+        dbos_logger.info("Initializing DBOS")
+
         # If using FastAPI, set up middleware and lifecycle events
         if self.fastapi is not None:
             from ._fastapi import setup_fastapi_middleware
@@ -419,7 +454,7 @@ class DBOS:
             if debug_mode:
                 return
 
-            admin_port = self.config["runtimeConfig"].get("admin_port")
+            admin_port = self.config.get("runtimeConfig", {}).get("admin_port")
             if admin_port is None:
                 admin_port = 3001
             self._admin_server_field = AdminServer(dbos=self, port=admin_port)
@@ -923,7 +958,9 @@ class DBOS:
         reg = _get_or_create_dbos_registry()
         if reg.config is not None:
             return reg.config
-        config = load_config()
+        config = (
+            load_config()
+        )  # This will return the processed & validated config (with defaults)
         reg.config = config
         return config
 

dbos/_dbos_config.py

@@ -1,21 +1,47 @@
 import json
 import os
 import re
+import sys
 from importlib import resources
-from typing import Any, Dict, List, Optional, TypedDict, cast
+from typing import Any, Dict, List, Optional, TypedDict, Union, cast
+
+if sys.version_info < (3, 10):
+    from typing_extensions import TypeGuard
+else:
+    from typing import TypeGuard
 
 import yaml
 from jsonschema import ValidationError, validate
 from rich import print
-from sqlalchemy import URL
+from sqlalchemy import URL, make_url
 
 from ._db_wizard import db_wizard, load_db_connection
 from ._error import DBOSInitializationError
-from ._logger import config_logger, dbos_logger, init_logger
+from ._logger import dbos_logger
 
 DBOS_CONFIG_PATH = "dbos-config.yaml"
 
 
+class DBOSConfig(TypedDict):
+    """
+    Data structure containing the DBOS library configuration.
+
+    Attributes:
+        name (str): Application name
+        database_url (str): Database connection string
+        sys_db_name (str): System database name
+        log_level (str): Log level
+        otlp_traces_endpoints: List[str]: OTLP traces endpoints
+    """
+
+    name: str
+    database_url: Optional[str]
+    sys_db_name: Optional[str]
+    log_level: Optional[str]
+    otlp_traces_endpoints: Optional[List[str]]
+    admin_port: Optional[int]
+
+
 class RuntimeConfig(TypedDict, total=False):
     start: List[str]
     setup: Optional[List[str]]
@@ -33,11 +59,30 @@ class DatabaseConfig(TypedDict, total=False):
     ssl: Optional[bool]
     ssl_ca: Optional[str]
     local_suffix: Optional[bool]
-    app_db_client: Optional[str]
     migrate: Optional[List[str]]
     rollback: Optional[List[str]]
 
 
+def parse_database_url_to_dbconfig(database_url: str) -> DatabaseConfig:
+    db_url = make_url(database_url)
+    db_config = {
+        "hostname": db_url.host,
+        "port": db_url.port or 5432,
+        "username": db_url.username,
+        "password": db_url.password,
+        "app_db_name": db_url.database,
+    }
+    for key, value in db_url.query.items():
+        str_value = value[0] if isinstance(value, tuple) else value
+        if key == "connect_timeout":
+            db_config["connectionTimeoutMillis"] = int(str_value) * 1000
+        elif key == "sslmode":
+            db_config["ssl"] = str_value == "require"
+        elif key == "sslrootcert":
+            db_config["ssl_ca"] = str_value
+    return cast(DatabaseConfig, db_config)
+
+
 class OTLPExporterConfig(TypedDict, total=False):
     logsEndpoint: Optional[str]
     tracesEndpoint: Optional[str]
@@ -61,9 +106,9 @@ class ConfigFile(TypedDict, total=False):
 
     Attributes:
         name (str): Application name
-        language (str): The app language (probably `python`)
         runtimeConfig (RuntimeConfig): Configuration for request serving
         database (DatabaseConfig): Configuration for the application and system databases
+        database_url (str): Database connection string
         telemetry (TelemetryConfig): Configuration for tracing / logging
         env (Dict[str,str]): Environment varialbes
         application (Dict[str, Any]): Application-specific configuration section
@@ -71,12 +116,71 @@ class ConfigFile(TypedDict, total=False):
     """
 
     name: str
-    language: str
     runtimeConfig: RuntimeConfig
     database: DatabaseConfig
+    database_url: Optional[str]
     telemetry: Optional[TelemetryConfig]
     env: Dict[str, str]
-    application: Dict[str, Any]
+
+
+def is_dbos_configfile(data: Union[ConfigFile, DBOSConfig]) -> TypeGuard[DBOSConfig]:
+    """
+    Type guard to check if the provided data is a DBOSConfig.
+
+    Args:
+        data: The configuration object to check
+
+    Returns:
+        True if the data is a DBOSConfig, False otherwise
+    """
+    return (
+        isinstance(data, dict)
+        and "name" in data
+        and (
+            "runtimeConfig" in data
+            or "database" in data
+            or "env" in data
+            or "telemetry" in data
+        )
+    )
+
+
+def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
+    if "name" not in config:
+        raise DBOSInitializationError(f"Configuration must specify an application name")
+
+    translated_config: ConfigFile = {
+        "name": config["name"],
+    }
+
+    # Database config
+    db_config: DatabaseConfig = {}
+    database_url = config.get("database_url")
+    if database_url:
+        db_config = parse_database_url_to_dbconfig(database_url)
+    if "sys_db_name" in config:
+        db_config["sys_db_name"] = config.get("sys_db_name")
+    if db_config:
+        translated_config["database"] = db_config
+
+    # Admin port
+    if "admin_port" in config:
+        translated_config["runtimeConfig"] = {"admin_port": config["admin_port"]}
+
+    # Telemetry config
+    telemetry = {}
+    # Add OTLPExporter if traces endpoints exist
+    otlp_trace_endpoints = config.get("otlp_traces_endpoints")
+    if isinstance(otlp_trace_endpoints, list) and len(otlp_trace_endpoints) > 0:
+        telemetry["OTLPExporter"] = {"tracesEndpoint": otlp_trace_endpoints[0]}
+    # Default to INFO -- the logging seems to default to WARN otherwise.
+    log_level = config.get("log_level", "INFO")
+    if log_level:
+        telemetry["logs"] = {"logLevel": log_level}
+    if telemetry:
+        translated_config["telemetry"] = cast(TelemetryConfig, telemetry)
+
+    return translated_config
 
 
 def _substitute_env_vars(content: str) -> str:
@@ -110,7 +214,7 @@ def get_dbos_database_url(config_file_path: str = DBOS_CONFIG_PATH) -> str:
         str: Database URL for the application database
 
     """
-    dbos_config = load_config(config_file_path)
+    dbos_config = process_config(data=load_config(config_file_path))
     db_url = URL.create(
         "postgresql+psycopg",
         username=dbos_config["database"]["username"],
@@ -125,6 +229,7 @@ def get_dbos_database_url(config_file_path: str = DBOS_CONFIG_PATH) -> str:
 def load_config(
     config_file_path: str = DBOS_CONFIG_PATH,
     *,
+    run_process_config: bool = True,
     use_db_wizard: bool = True,
     silent: bool = False,
 ) -> ConfigFile:
@@ -141,13 +246,17 @@ def load_config(
 
     """
 
-    init_logger()
-
     with open(config_file_path, "r") as file:
         content = file.read()
         substituted_content = _substitute_env_vars(content)
         data = yaml.safe_load(substituted_content)
 
+    if not isinstance(data, dict):
+        raise DBOSInitializationError(
+            f"dbos-config.yaml must contain a dictionary, not {type(data)}"
+        )
+    data = cast(Dict[str, Any], data)
+
     # Load the JSON schema relative to the package root
     schema_file = resources.files("dbos").joinpath("dbos-config.schema.json")
     with schema_file.open("r") as f:
@@ -159,37 +268,48 @@ def load_config(
     except ValidationError as e:
         raise DBOSInitializationError(f"Validation error: {e}")
 
-    if "database" not in data:
-        data["database"] = {}
-
-    if "name" not in data:
-        raise DBOSInitializationError(
-            f"dbos-config.yaml must specify an application name"
-        )
+    data = cast(ConfigFile, data)
+    if run_process_config:
+        data = process_config(data=data, use_db_wizard=use_db_wizard, silent=silent)
+    return data  # type: ignore
 
-    if "language" not in data:
-        raise DBOSInitializationError(
-            f"dbos-config.yaml must specify the application language is Python"
-        )
 
-    if data["language"] != "python":
-        raise DBOSInitializationError(
-            f'dbos-config.yaml specifies invalid language { data["language"] }'
-        )
+def process_config(
+    *,
+    use_db_wizard: bool = True,
+    data: ConfigFile,
+    silent: bool = False,
+) -> ConfigFile:
 
-    if "runtimeConfig" not in data or "start" not in data["runtimeConfig"]:
-        raise DBOSInitializationError(f"dbos-config.yaml must specify a start command")
+    if "name" not in data:
+        raise DBOSInitializationError(f"Configuration must specify an application name")
 
     if not _is_valid_app_name(data["name"]):
         raise DBOSInitializationError(
             f'Invalid app name {data["name"]}.  App names must be between 3 and 30 characters long and contain only lowercase letters, numbers, dashes, and underscores.'
         )
 
-    if "app_db_name" not in data["database"]:
+    if "database" not in data:
+        data["database"] = {}
+
+    # database_url takes precedence over database config, but we need to preserve rollback and migrate if they exist
+    migrate = data["database"].get("migrate", False)
+    rollback = data["database"].get("rollback", False)
+    local_suffix = data["database"].get("local_suffix", False)
+    if data.get("database_url"):
+        dbconfig = parse_database_url_to_dbconfig(cast(str, data["database_url"]))
+        if migrate:
+            dbconfig["migrate"] = cast(List[str], migrate)
+        if rollback:
+            dbconfig["rollback"] = cast(List[str], rollback)
+        if local_suffix:
+            dbconfig["local_suffix"] = cast(bool, local_suffix)
+        data["database"] = dbconfig
+
+    if "app_db_name" not in data["database"] or not (data["database"]["app_db_name"]):
         data["database"]["app_db_name"] = _app_name_to_db_name(data["name"])
 
     # Load the DB connection file. Use its values for missing fields from dbos-config.yaml. Use defaults otherwise.
-    data = cast(ConfigFile, data)
     db_connection = load_db_connection()
     if not silent:
         if os.getenv("DBOS_DBHOST"):
@@ -252,26 +372,24 @@ def load_config(
     dbcon_local_suffix = db_connection.get("local_suffix")
     if dbcon_local_suffix is not None:
         local_suffix = dbcon_local_suffix
-    if data["database"].get("local_suffix") is not None:
-        local_suffix = data["database"].get("local_suffix")
+    db_local_suffix = data["database"].get("local_suffix")
+    if db_local_suffix is not None:
+        local_suffix = db_local_suffix
     if dbos_dblocalsuffix is not None:
         local_suffix = dbos_dblocalsuffix
     data["database"]["local_suffix"] = local_suffix
 
-    # Configure the DBOS logger
-    config_logger(data)
-
     # Check the connectivity to the database and make sure it's properly configured
     # Note, never use db wizard if the DBOS is running in debug mode (i.e. DBOS_DEBUG_WORKFLOW_ID env var is set)
     debugWorkflowId = os.getenv("DBOS_DEBUG_WORKFLOW_ID")
     if use_db_wizard and debugWorkflowId is None:
-        data = db_wizard(data, config_file_path)
+        data = db_wizard(data)
 
     if "local_suffix" in data["database"] and data["database"]["local_suffix"]:
         data["database"]["app_db_name"] = f"{data['database']['app_db_name']}_local"
 
     # Return data as ConfigFile type
-    return data  # type: ignore
+    return data
 
 
 def _is_valid_app_name(name: str) -> bool:
@@ -291,3 +409,105 @@ def set_env_vars(config: ConfigFile) -> None:
     for env, value in config.get("env", {}).items():
         if value is not None:
             os.environ[env] = str(value)
+
+
+def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
+    # Load the DBOS configuration file and force the use of:
+    # 1. The database connection parameters (sub the file data to the provided config)
+    # 2. OTLP traces endpoints (add the config data to the provided config)
+    # 3. Use the application name from the file. This is a defensive measure to ensure the application name is whatever it was registered with in the cloud
+    # 4. Remove admin_port is provided in code
+    # 5. Remove env vars if provided in code
+    # Optimistically assume that expected fields in config_from_file are present
+
+    config_from_file = load_config(run_process_config=False)
+    # Be defensive
+    if config_from_file is None:
+        return provided_config
+
+    # Name
+    provided_config["name"] = config_from_file["name"]
+
+    # Database config. Note we disregard a potential database_url in config_from_file because it is not expected from DBOS Cloud
+    if "database" not in provided_config:
+        provided_config["database"] = {}
+    provided_config["database"]["hostname"] = config_from_file["database"]["hostname"]
+    provided_config["database"]["port"] = config_from_file["database"]["port"]
+    provided_config["database"]["username"] = config_from_file["database"]["username"]
+    provided_config["database"]["password"] = config_from_file["database"]["password"]
+    provided_config["database"]["app_db_name"] = config_from_file["database"][
+        "app_db_name"
+    ]
+    provided_config["database"]["sys_db_name"] = config_from_file["database"][
+        "sys_db_name"
+    ]
+    provided_config["database"]["ssl"] = config_from_file["database"]["ssl"]
+    provided_config["database"]["ssl_ca"] = config_from_file["database"]["ssl_ca"]
+
+    # Telemetry config
+    if "telemetry" not in provided_config or provided_config["telemetry"] is None:
+        provided_config["telemetry"] = {
+            "OTLPExporter": {},
+        }
+    elif "OTLPExporter" not in provided_config["telemetry"]:
+        provided_config["telemetry"]["OTLPExporter"] = {}
+
+    # This is a super messy from a typing perspective.
+    # Some of ConfigFile keys are optional -- but in practice they'll always be present in hosted environments
+    # So, for Mypy, we have to (1) check the keys are present in config_from_file and (2) cast telemetry/otlp_exporters to Dict[str, Any]
+    # (2) is required because, even tho we resolved these keys earlier, mypy doesn't remember that
+    if (
+        config_from_file.get("telemetry")
+        and config_from_file["telemetry"]
+        and config_from_file["telemetry"].get("OTLPExporter")
+    ):
+
+        telemetry = cast(Dict[str, Any], provided_config["telemetry"])
+        otlp_exporter = cast(Dict[str, Any], telemetry["OTLPExporter"])
+
+        source_otlp = config_from_file["telemetry"]["OTLPExporter"]
+        if source_otlp:
+            tracesEndpoint = source_otlp.get("tracesEndpoint")
+            if tracesEndpoint:
+                otlp_exporter["tracesEndpoint"] = tracesEndpoint
+            logsEndpoint = source_otlp.get("logsEndpoint")
+            if logsEndpoint:
+                otlp_exporter["logsEndpoint"] = logsEndpoint
+
+    # Runtime config
+    if (
+        "runtimeConfig" in provided_config
+        and "admin_port" in provided_config["runtimeConfig"]
+    ):
+        del provided_config["runtimeConfig"][
+            "admin_port"
+        ]  # Admin port is expected to be 3001 (the default in dbos/_admin_server.py::__init__ ) by DBOS Cloud
+
+    # Env should be set from the hosting provider (e.g., DBOS Cloud)
+    if "env" in provided_config:
+        del provided_config["env"]
+
+    return provided_config
+
+
+def check_config_consistency(
+    *,
+    name: str,
+    config_file_path: str = DBOS_CONFIG_PATH,
+) -> None:
+    # First load the config file and check whether it is present
+    try:
+        config = load_config(config_file_path)
+    except FileNotFoundError:
+        dbos_logger.debug(
+            f"No configuration file {config_file_path} found. Skipping consistency check with provided config."
+        )
+        return
+    except Exception as e:
+        raise e
+
+    # Check the name
+    if name != config["name"]:
+        raise DBOSInitializationError(
+            f"Provided app name '{name}' does not match the app name '{config['name']}' in {config_file_path}."
+        )

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

@@ -8,9 +8,7 @@ language: python
 runtimeConfig:
   start:
     - "fastapi run ${package_name}/main.py"
+database_url: ${DBOS_DATABASE_URL}
 database:
   migrate:
-    - ${migration_command}
-telemetry:
-  logs:
-    logLevel: INFO
+    - ${migration_command}

dbos/dbos-config.schema.json

@@ -12,10 +12,13 @@
         "type": "string",
         "description": "The language used in your application",
         "enum": [
-          "typescript",
           "python"
         ]
       },
+      "database_url": {
+        "type": ["string", "null"],
+        "description": "The URL of the application database"
+      },
       "database": {
         "type": "object",
         "additionalProperties": false,

{dbos-0.24.0a4.dist-info → dbos-0.24.0a5.dist-info}/METADATA

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

{dbos-0.24.0a4.dist-info → dbos-0.24.0a5.dist-info}/RECORD

@@ -1,8 +1,8 @@
-dbos-0.24.0a4.dist-info/METADATA,sha256=WqbCY_vtpMPqlArkZMKDKE3NDx7WhS-NrwTPh6jEj2c,5555
-dbos-0.24.0a4.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-dbos-0.24.0a4.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.24.0a4.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
-dbos/__init__.py,sha256=CxRHBHEthPL4PZoLbZhp3rdm44-KkRTT2-7DkK9d4QQ,724
+dbos-0.24.0a5.dist-info/METADATA,sha256=Dg70KhSEysG1pJLOV16tY2B_631JRLjMg5LbkF78HeM,5555
+dbos-0.24.0a5.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+dbos-0.24.0a5.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.24.0a5.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos/__init__.py,sha256=uq9LP5uY96kIS9N0yKqlvDwADmtg_Hl30uSUhyuUr-4,754
 dbos/__main__.py,sha256=P7jAr-7L9XE5mrsQ7i4b-bLr2ap1tCQfhMByLCRWDj0,568
 dbos/_admin_server.py,sha256=YiVn5lywz2Vg8_juyNHOYl0HVEy48--7b4phwK7r92o,5732
 dbos/_app_db.py,sha256=QFL1ceCugJFj_LBvK_G_0tt5jjyTM-4KnqmhbuC1ggg,5826
@@ -15,9 +15,9 @@ dbos/_conductor/protocol.py,sha256=Lo-DjvKevTS2uKyITLjjVp56rBRzaQfKkKpieZz3VAs,5
 dbos/_context.py,sha256=Ue5qu3rzLfRmPkz-UUZi9ZS8iXpapRN0NTM4mbA2QmQ,17738
 dbos/_core.py,sha256=UQb068FT59Op-F5RmtxreSeSQ1_wljOso0dQCUOPrC4,37528
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_db_wizard.py,sha256=6tfJaCRa1NtkUdNW75a2yvi_mEgnPJ9C1HP2zPG1hCU,8067
-dbos/_dbos.py,sha256=0kX3fgdTqAn-eMKSbh73LFVR08YPMoB030g4dzvc9Yk,41150
-dbos/_dbos_config.py,sha256=_VETbEsMZ66563A8sX05B_coKz2BrILbIm9H5BmnPmk,9572
+dbos/_db_wizard.py,sha256=YEW2qoy6hfHQv2fZ_4nHiPUeHMFofPpNTolJ1Kvw7AQ,8394
+dbos/_dbos.py,sha256=2A1_5Fjv54G_bNKpSsYOFwEXDWJcaM-x1i2sY_h581w,42523
+dbos/_dbos_config.py,sha256=MJOJu0dCzdcxJi2gUMkTcJaxm_XVr2a2Dfq7vL_nEL0,17844
 dbos/_debug.py,sha256=mmgvLkqlrljMBBow9wk01PPur9kUf2rI_11dTJXY4gw,1822
 dbos/_error.py,sha256=xqB7b7g5AF_OwOvqLKLXL1xldn2gAtORix2ZC2B8zK0,5089
 dbos/_fastapi.py,sha256=ke03vqsSYDnO6XeOtOVFXj0-f-v1MGsOxa9McaROvNc,3616
@@ -51,7 +51,7 @@ dbos/_templates/dbos-db-starter/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-
 dbos/_templates/dbos-db-starter/__package/main.py,sha256=eI0SS9Nwj-fldtiuSzIlIG6dC91GXXwdRsoHxv6S_WI,2719
 dbos/_templates/dbos-db-starter/__package/schema.py,sha256=7Z27JGC8yy7Z44cbVXIREYxtUhU4JVkLCp5Q7UahVQ0,260
 dbos/_templates/dbos-db-starter/alembic.ini,sha256=VKBn4Gy8mMuCdY7Hip1jmo3wEUJ1VG1aW7EqY0_n-as,3695
-dbos/_templates/dbos-db-starter/dbos-config.yaml.dbos,sha256=OMlcpdYUJKjyAme7phOz3pbn9upcIRjm42iwEThWUEQ,495
+dbos/_templates/dbos-db-starter/dbos-config.yaml.dbos,sha256=Z-JC7wp-E9l7NiacjT7E66M812fYFVU3FSS7mNjb6XE,492
 dbos/_templates/dbos-db-starter/migrations/env.py.dbos,sha256=GUV6sjkDzf9Vl6wkGEd0RSkK-ftRfV6EUwSQdd0qFXg,2392
 dbos/_templates/dbos-db-starter/migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
 dbos/_templates/dbos-db-starter/migrations/versions/2024_07_31_180642_init.py,sha256=MpS7LGaJS0CpvsjhfDkp9EJqvMvVCjRPfUp4c0aE2ys,941
@@ -62,7 +62,7 @@ dbos/_workflow_commands.py,sha256=CEzR5XghoZscbc2RHb9G-7Eoo4MMuzfeTo-QBZu4VPY,46
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=AfuMaO8bmr9WsPNHr6j2cp7kjVVZDUpH7KpbTg0hhFs,2722
 dbos/cli/cli.py,sha256=ThomRytw7EP5iOcrjEgwnpaWgXNTLfnFEBBvCGHxtJs,15590
-dbos/dbos-config.schema.json,sha256=X5TpXNcARGceX0zQs0fVgtZW_Xj9uBbY5afPt9Rz9yk,5741
+dbos/dbos-config.schema.json,sha256=HtF_njVTGHLdzBGZ4OrGQz3qbPPT0Go-iwd1PgFVTNg,5847
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.24.0a4.dist-info/RECORD,,
+dbos-0.24.0a5.dist-info/RECORD,,