dbos 0.28.0a7__py3-none-any.whl → 0.28.0a12__py3-none-any.whl

dbos/__init__.py

@@ -8,13 +8,12 @@ from ._context import (
     SetWorkflowTimeout,
 )
 from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle, WorkflowHandleAsync
-from ._dbos_config import ConfigFile, DBOSConfig, get_dbos_database_url, load_config
+from ._dbos_config import DBOSConfig
 from ._kafka_message import KafkaMessage
 from ._queue import Queue
 from ._sys_db import GetWorkflowsInput, WorkflowStatus, WorkflowStatusString
 
 __all__ = [
-    "ConfigFile",
     "DBOSConfig",
     "DBOS",
     "DBOSClient",
@@ -31,8 +30,6 @@ __all__ = [
     "WorkflowHandleAsync",
     "WorkflowStatus",
     "WorkflowStatusString",
-    "load_config",
-    "get_dbos_database_url",
     "error",
     "Queue",
 ]

dbos/_admin_server.py

@@ -171,9 +171,17 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
     def _handle_restart(self, workflow_id: str) -> None:
         try:
             print(f"Restarting workflow {workflow_id}")
-            self.dbos.restart_workflow(workflow_id)
-            self.send_response(204)
+            handle = self.dbos.restart_workflow(workflow_id)
+            response_body = json.dumps(
+                {
+                    "workflow_id": handle.workflow_id,
+                }
+            ).encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(response_body)))
             self._end_headers()
+            self.wfile.write(response_body)
         except DBOSException as e:
             print(f"Error restarting workflow: {e}")
             self.send_response(500)
@@ -185,9 +193,17 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
 
     def _handle_fork(self, workflow_id: str, start_step: int) -> None:
         try:
-            self.dbos.fork_workflow(workflow_id, start_step)
-            self.send_response(204)
+            handle = self.dbos.fork_workflow(workflow_id, start_step)
+            response_body = json.dumps(
+                {
+                    "workflow_id": handle.workflow_id,
+                }
+            ).encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(response_body)))
             self._end_headers()
+            self.wfile.write(response_body)
         except DBOSException as e:
             print(f"Error forking workflow: {e}")
             self.send_response(500)

dbos/_client.py

@@ -302,6 +302,7 @@ class DBOSClient:
         limit: Optional[int] = None,
         offset: Optional[int] = None,
         sort_desc: bool = False,
+        workflow_id_prefix: Optional[str] = None,
     ) -> List[WorkflowStatus]:
         return await asyncio.to_thread(
             self.list_workflows,
@@ -315,6 +316,7 @@ class DBOSClient:
             limit=limit,
             offset=offset,
             sort_desc=sort_desc,
+            workflow_id_prefix=workflow_id_prefix,
         )
 
     def list_queued_workflows(

dbos/_conductor/conductor.py

@@ -35,7 +35,7 @@ class ConductorWebsocket(threading.Thread):
         self.websocket: Optional[Connection] = None
         self.evt = evt
         self.dbos = dbos
-        self.app_name = dbos.config["name"]
+        self.app_name = dbos._config["name"]
         self.url = (
             conductor_url.rstrip("/") + f"/websocket/{self.app_name}/{conductor_key}"
         )

dbos/_dbos.py

@@ -94,8 +94,6 @@ from ._dbos_config import (
     ConfigFile,
     DBOSConfig,
     check_config_consistency,
-    is_dbos_configfile,
-    load_config,
     overwrite_config,
     process_config,
     set_env_vars,
@@ -160,7 +158,6 @@ class DBOSRegistry:
         self.queue_info_map: dict[str, Queue] = {}
         self.pollers: list[RegisteredJob] = []
         self.dbos: Optional[DBOS] = None
-        self.config: Optional[ConfigFile] = None
 
     def register_wf_function(self, name: str, wrapped_func: F, functype: str) -> None:
         if name in self.function_type_map:
@@ -264,7 +261,7 @@ class DBOS:
     def __new__(
         cls: Type[DBOS],
         *,
-        config: Optional[Union[ConfigFile, DBOSConfig]] = None,
+        config: DBOSConfig,
         fastapi: Optional["FastAPI"] = None,
         flask: Optional["Flask"] = None,
         conductor_url: Optional[str] = None,
@@ -273,25 +270,8 @@ class DBOS:
         global _dbos_global_instance
         global _dbos_global_registry
         if _dbos_global_instance is None:
-            if (
-                _dbos_global_registry is not None
-                and _dbos_global_registry.config is not None
-            ):
-                if config is not None and config is not _dbos_global_registry.config:
-                    raise DBOSException(
-                        f"DBOS configured multiple times with conflicting information"
-                    )
-                config = _dbos_global_registry.config
-
             _dbos_global_instance = super().__new__(cls)
             _dbos_global_instance.__init__(fastapi=fastapi, config=config, flask=flask, conductor_url=conductor_url, conductor_key=conductor_key)  # type: ignore
-        else:
-            if (config is not None and _dbos_global_instance.config is not config) or (
-                _dbos_global_instance.fastapi is not fastapi
-            ):
-                raise DBOSException(
-                    f"DBOS Initialized multiple times with conflicting configuration / fastapi information"
-                )
         return _dbos_global_instance
 
     @classmethod
@@ -309,7 +289,7 @@ class DBOS:
     def __init__(
         self,
         *,
-        config: Optional[Union[ConfigFile, DBOSConfig]] = None,
+        config: DBOSConfig,
         fastapi: Optional["FastAPI"] = None,
         flask: Optional["Flask"] = None,
         conductor_url: Optional[str] = None,
@@ -342,26 +322,11 @@ class DBOS:
 
         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):
-            dbos_logger.warning(
-                "ConfigFile config strutcture detected. This will be deprecated in favor of DBOSConfig in an upcoming release."
-            )
-            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"])
+        # Translate user provided config to an internal format
+        unvalidated_config = translate_dbos_config_to_config_file(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)
@@ -1086,21 +1051,6 @@ class DBOS:
         """Return the DBOS `Logger` for the current context."""
         return dbos_logger  # TODO get from context if appropriate...
 
-    @classproperty
-    def config(cls) -> ConfigFile:
-        """Return the DBOS `ConfigFile` for the current context."""
-        global _dbos_global_instance
-        if _dbos_global_instance is not None:
-            return _dbos_global_instance._config
-        reg = _get_or_create_dbos_registry()
-        if reg.config is not None:
-            return reg.config
-        loaded_config = (
-            load_config()
-        )  # This will return the processed & validated config (with defaults)
-        reg.config = loaded_config
-        return loaded_config
-
     @classproperty
     def sql_session(cls) -> Session:
         """Return the SQLAlchemy `Session` for the current context, which must be within a transaction function."""

dbos/_dbos_config.py

@@ -1,19 +1,13 @@
 import json
 import os
 import re
-import sys
 from importlib import resources
-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
+from typing import Any, Dict, List, Optional, TypedDict, cast
 
 import yaml
 from jsonschema import ValidationError, validate
 from rich import print
-from sqlalchemy import URL, make_url
+from sqlalchemy import make_url
 
 from ._error import DBOSInitializationError
 from ._logger import dbos_logger
@@ -146,28 +140,6 @@ class ConfigFile(TypedDict, total=False):
     env: Dict[str, str]
 
 
-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")
@@ -271,32 +243,6 @@ def _substitute_env_vars(content: str, silent: bool = False) -> str:
     return re.sub(env_regex, replace_env_func, content)
 
 
-def get_dbos_database_url(config_file_path: str = DBOS_CONFIG_PATH) -> str:
-    """
-    Retrieve application database URL from configuration `.yaml` file.
-
-    Loads the DBOS `ConfigFile` from the specified path (typically `dbos-config.yaml`),
-        and returns the database URL for the application database.
-
-    Args:
-        config_file_path (str): The path to the yaml configuration file.
-
-    Returns:
-        str: Database URL for the application database
-
-    """
-    dbos_config = load_config(config_file_path, run_process_config=True)
-    db_url = URL.create(
-        "postgresql+psycopg",
-        username=dbos_config["database"]["username"],
-        password=dbos_config["database"]["password"],
-        host=dbos_config["database"]["hostname"],
-        port=dbos_config["database"]["port"],
-        database=dbos_config["database"]["app_db_name"],
-    )
-    return db_url.render_as_string(hide_password=False)
-
-
 def load_config(
     config_file_path: str = DBOS_CONFIG_PATH,
     *,

dbos/_docker_pg_helper.py

@@ -83,6 +83,7 @@ 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"
+    image_name = "pgvector/pgvector:pg16"
 
     try:
         client = docker.from_env()
@@ -103,9 +104,15 @@ def start_docker_postgres(pool_config: Dict[str, Any]) -> bool:
             # Container doesn't exist, proceed with creation
             pass
 
+        # Pull the image if it doesn't exist
+        imgs = client.images.list(name=image_name)
+        if len(imgs) == 0:
+            logging.info(f"Pulling Docker image {image_name}...")
+            client.images.pull(image_name)
+
         # Create and start the container
         container = client.containers.run(
-            image="pgvector/pgvector:pg16",
+            image=image_name,
             name=container_name,
             detach=True,
             environment={

dbos/_sys_db.py

@@ -1735,14 +1735,29 @@ class SystemDatabase:
                 available_tasks = max(0, queue.concurrency - total_running_tasks)
                 max_tasks = min(max_tasks, available_tasks)
 
-            # Lookup unstarted/uncompleted tasks (not running)
+            # Retrieve the first max_tasks workflows in the queue.
+            # Only retrieve workflows of the appropriate version (or without version set)
             query = (
                 sa.select(
                     SystemSchema.workflow_queue.c.workflow_uuid,
                 )
+                .select_from(
+                    SystemSchema.workflow_queue.join(
+                        SystemSchema.workflow_status,
+                        SystemSchema.workflow_queue.c.workflow_uuid
+                        == SystemSchema.workflow_status.c.workflow_uuid,
+                    )
+                )
                 .where(SystemSchema.workflow_queue.c.queue_name == queue.name)
                 .where(SystemSchema.workflow_queue.c.started_at_epoch_ms == None)
                 .where(SystemSchema.workflow_queue.c.completed_at_epoch_ms == None)
+                .where(
+                    sa.or_(
+                        SystemSchema.workflow_status.c.application_version
+                        == app_version,
+                        SystemSchema.workflow_status.c.application_version.is_(None),
+                    )
+                )
                 .order_by(
                     SystemSchema.workflow_queue.c.priority.asc(),
                     SystemSchema.workflow_queue.c.created_at_epoch_ms.asc(),
@@ -1778,15 +1793,6 @@ class SystemDatabase:
                         SystemSchema.workflow_status.c.status
                         == WorkflowStatusString.ENQUEUED.value
                     )
-                    .where(
-                        sa.or_(
-                            SystemSchema.workflow_status.c.application_version
-                            == app_version,
-                            SystemSchema.workflow_status.c.application_version.is_(
-                                None
-                            ),
-                        )
-                    )
                     .values(
                         status=WorkflowStatusString.PENDING.value,
                         application_version=app_version,

dbos/_templates/dbos-db-starter/__package/{main.py → main.py.dbos}

@@ -6,16 +6,21 @@
 
 # First, let's do imports, create a FastAPI app, and initialize DBOS.
 
+import os
 import uvicorn
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
 
-from dbos import DBOS
+from dbos import DBOS, DBOSConfig
 
 from .schema import dbos_hello
 
 app = FastAPI()
-DBOS(fastapi=app)
+dbos_config: DBOSConfig = {
+    "name": "${project_name}",
+    "database_url": os.environ.get("DBOS_DATABASE_URL", "postgresql+psycopg://postgres:dbos@localhost:5432/${default_db_name}?connect_timeout=5")
+}
+DBOS(fastapi=app, config=dbos_config)
 
 # Next, let's write a function that greets visitors.
 # To make it more interesting, we'll keep track of how

dbos/_templates/dbos-db-starter/migrations/env.py.dbos

@@ -1,11 +1,10 @@
 import re
+import os
 from logging.config import fileConfig
 
 from alembic import context
 from sqlalchemy import engine_from_config, pool
 
-from dbos import get_dbos_database_url
-
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
 config = context.config
@@ -15,12 +14,13 @@ config = context.config
 if config.config_file_name is not None:
     fileConfig(config.config_file_name)
 
-# programmatically set the sqlalchemy.url field from DBOS Config
-# Alembic requires the % in URL-escaped parameters to itself be escaped to %%.
+# Programmatically set the sqlalchemy.url field to the DBOS application database URL
+conn_string = os.environ.get("DBOS_DATABASE_URL", "postgresql+psycopg://postgres:dbos@localhost:5432/${default_db_name}?connect_timeout=5")
+# Alembic requires the % in URL-escaped parameters to itself be escaped to %%
 escaped_conn_string = re.sub(
     r"%(?=[0-9A-Fa-f]{2})",
     "%%",
-    get_dbos_database_url(),
+    conn_string,
 )
 config.set_main_option("sqlalchemy.url", escaped_conn_string)
 

dbos/cli/_template_init.py

@@ -7,6 +7,8 @@ from typing import Any
 import tomlkit
 from rich import print
 
+from dbos._dbos_config import _app_name_to_db_name
+
 
 def get_templates_directory() -> str:
     import dbos
@@ -64,6 +66,7 @@ def copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
 """
     ctx = {
         "project_name": project_name,
+        "default_db_name": _app_name_to_db_name(project_name),
         "package_name": package_name,
         "start_command": f"python3 -m {package_name}.main",
         "migration_section": default_migration_section,

dbos/cli/cli.py

@@ -6,7 +6,6 @@ import time
 import typing
 from os import path
 from typing import Any, Optional
-from urllib.parse import quote
 
 import jsonpickle  # type: ignore
 import sqlalchemy as sa
@@ -17,10 +16,9 @@ from typing_extensions import Annotated
 
 from dbos._debug import debug_workflow, parse_start_command
 
-from .. import load_config
 from .._app_db import ApplicationDatabase
 from .._client import DBOSClient
-from .._dbos_config import _is_valid_app_name
+from .._dbos_config import _is_valid_app_name, load_config
 from .._docker_pg_helper import start_docker_pg, stop_docker_pg
 from .._schemas.system_database import SystemSchema
 from .._sys_db import SystemDatabase, reset_system_database
@@ -33,12 +31,11 @@ def start_client(db_url: Optional[str] = None) -> DBOSClient:
     database_url = db_url
     if database_url is None:
         database_url = os.getenv("DBOS_DATABASE_URL")
-        if database_url is None:
-            config = load_config(silent=True)
-            database = config["database"]
-            username = quote(database["username"])
-            password = quote(database["password"])
-            database_url = f"postgresql://{username}:{password}@{database['hostname']}:{database['port']}/{database['app_db_name']}"
+    if database_url is None:
+        raise ValueError(
+            "Missing database URL: please set it using the --db-url flag or the DBOS_DATABASE_URL environment variable."
+        )
+
     return DBOSClient(database_url=database_url)
 
 

{dbos-0.28.0a7.dist-info → dbos-0.28.0a12.dist-info}/METADATA

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

{dbos-0.28.0a7.dist-info → dbos-0.28.0a12.dist-info}/RECORD

@@ -1,22 +1,22 @@
-dbos-0.28.0a7.dist-info/METADATA,sha256=qUA4yCy56WYU15e1V8V2Pb_xNM9ccKpov9vvnfMGYYM,13268
-dbos-0.28.0a7.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-0.28.0a7.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.28.0a7.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
-dbos/__init__.py,sha256=-FdBlOlr-f2tY__C23J4v22MoCAXqcDN_-zXsJXdoZ0,1005
+dbos-0.28.0a12.dist-info/METADATA,sha256=nxjIfoX9CdMPTCpI-L-iIAHRyTjDDbjJKNbwI6gtiqc,13269
+dbos-0.28.0a12.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-0.28.0a12.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.28.0a12.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos/__init__.py,sha256=NssPCubaBxdiKarOWa-wViz1hdJSkmBGcpLX_gQ4NeA,891
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
-dbos/_admin_server.py,sha256=CM02jyC9H21fM7Pjn1BhPxNwAOV7CXmMJd0SdaNq8dQ,9062
+dbos/_admin_server.py,sha256=A_28_nJ1nBBYDmCxtklJR9O2v14JRMtD1rAo_D4y8Kc,9764
 dbos/_app_db.py,sha256=3j8_5-MlSDY0otLRszFE-GfenU6JC20fcfSL-drSNYk,11800
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=mGrricoU6437QM4SWV-6Vm806AgVru8ygKgGgK1LZGA,13823
-dbos/_conductor/conductor.py,sha256=L8va6dGae0BlH43AHWAAW8_z04QUYPWPhjUK64sn3P4,19692
+dbos/_client.py,sha256=PPktnvaLfl8Fj27YoOjy_kfgeQm_c3QQZztPyts5GZo,13924
+dbos/_conductor/conductor.py,sha256=qP3fTe74gdaIN9SU9nCn2B5GYMBnhQ6shEhGezEcSPg,19693
 dbos/_conductor/protocol.py,sha256=jwX8ZjmAIlXu1vw9R3b5PfHSNdwofeYOKj8rkfAFVg0,6630
 dbos/_context.py,sha256=Ly1CXF1nWxICQgIpDZSaONGlz1yERBs63gqmR-yqCzM,24476
 dbos/_core.py,sha256=UDpSgRA9m_YuViNXR9tVgNFLC-zxKZPxjlkj2a-Kj00,48317
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=nne4oaIEC0tR2OV766y7mjTLjGaqKz7EnuY-T2CbTtc,48431
-dbos/_dbos_config.py,sha256=L0Z0OOB5FoPM9g-joZqXGeJnlxWQsEUtgPtgtg9Uf48,21732
+dbos/_dbos.py,sha256=tPpf_X9oLtpPICryXDMc589XuFeJtZ4cIq7vmsNDcls,46220
+dbos/_dbos_config.py,sha256=pgzE5UP3LV_nhwIV4d1-W9q2LumQb1kla75xdx9mBcI,20136
 dbos/_debug.py,sha256=MNlQVZ6TscGCRQeEEL0VE8Uignvr6dPeDDDefS3xgIE,1823
-dbos/_docker_pg_helper.py,sha256=NmcgqmR5rQA_4igfeqh8ugNT2z3YmoOvuep_MEtxTiY,5854
+dbos/_docker_pg_helper.py,sha256=tLJXWqZ4S-ExcaPnxg_i6cVxL6ZxrYlZjaGsklY-s2I,6115
 dbos/_error.py,sha256=EN4eVBjMT3k7O7hfqJl6mIf4sxWPsiAOM086yhcGH_g,8012
 dbos/_event_loop.py,sha256=NmaLbEQFfEK36S_0KhVD39YdYrGce3qSKCTJ-5RqKQ0,2136
 dbos/_fastapi.py,sha256=m4SL3H9P-NBQ_ZrbFxAWMOqNyIi3HGEn2ODR7xAK038,3118
@@ -47,14 +47,14 @@ dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
 dbos/_schemas/system_database.py,sha256=3Z0L72bOgHnusK1hBaETWU9RfiLBP0QnS-fdu41i0yY,5835
 dbos/_serialization.py,sha256=bWuwhXSQcGmiazvhJHA5gwhrRWxtmFmcCFQSDJnqqkU,3666
-dbos/_sys_db.py,sha256=GjRTrN64jUMNUnEhLSkqGMiwJWOZhB9WFeuihJs35aM,82163
+dbos/_sys_db.py,sha256=lceVny4RzQP7DeEJ8CpQ0crg8cJmuTznUsiGmv1oM-E,82486
 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
+dbos/_templates/dbos-db-starter/__package/main.py.dbos,sha256=aQnBPSSQpkB8ERfhf7gB7P9tsU6OPKhZscfeh0yiaD8,2702
 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=0wPktElM7kMB3OPHTXw4xBk9bgGKMqOHrrr7x_R23Z8,446
-dbos/_templates/dbos-db-starter/migrations/env.py.dbos,sha256=GUV6sjkDzf9Vl6wkGEd0RSkK-ftRfV6EUwSQdd0qFXg,2392
+dbos/_templates/dbos-db-starter/migrations/env.py.dbos,sha256=IBB_gz9RjC20HPfOTGZzS6kTbv3jXhiOrnWpbJNk1Gk,2509
 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
 dbos/_templates/dbos-db-starter/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
@@ -62,9 +62,9 @@ dbos/_tracer.py,sha256=yN6GRDKu_1p-EqtQLNarMocPfga2ZuqpzStzzSPYhzo,2732
 dbos/_utils.py,sha256=UbpMYRBSyvJqdXeWAnfSw8xXM1R1mfnyl1oTunhEjJM,513
 dbos/_workflow_commands.py,sha256=2E8FRUv_nLYkpBTwfhh_ELhySYpMrm8qGB9J44g6DSE,3872
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
-dbos/cli/_template_init.py,sha256=-WW3kbq0W_Tq4WbMqb1UGJG3xvJb3woEY5VspG95Srk,2857
-dbos/cli/cli.py,sha256=gXKELYAK9_CTejQ-WbNEIqnEYByJndXHDYSX4naFg8g,19106
+dbos/cli/_template_init.py,sha256=7JBcpMqP1r2mfCnvWatu33z8ctEGHJarlZYKgB83cXE,2972
+dbos/cli/cli.py,sha256=SFmaHlCHtOojETd-P8BpbENQvwQoyq2l2yXZhSVo-50,18892
 dbos/dbos-config.schema.json,sha256=8KcwJb_sQc4-6tQG2TLmjE_nratfrQa0qVLl9XPsvWE,6367
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.28.0a7.dist-info/RECORD,,
+dbos-0.28.0a12.dist-info/RECORD,,