dbos 1.15.0a4__tar.gz → 1.15.0a6__tar.gz

{dbos-1.15.0a4 → dbos-1.15.0a6}/PKG-INFO

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

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/_client.py

@@ -14,6 +14,8 @@ from typing import (
     Union,
 )
 
+import sqlalchemy as sa
+
 from dbos import _serialization
 from dbos._app_db import ApplicationDatabase
 from dbos._context import MaxPriority, MinPriority
@@ -122,6 +124,7 @@ class DBOSClient:
         database_url: Optional[str] = None,  # DEPRECATED
         *,
         system_database_url: Optional[str] = None,
+        system_database_engine: Optional[sa.Engine] = None,
         application_database_url: Optional[str] = None,
         dbos_system_schema: Optional[str] = "dbos",
     ):
@@ -145,6 +148,7 @@ class DBOSClient:
                 "max_overflow": 0,
                 "pool_size": 2,
             },
+            engine=system_database_engine,
             schema=dbos_system_schema,
         )
         self._sys_db.check_connection()

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/_dbos.py

@@ -449,6 +449,7 @@ class DBOS:
             self._sys_db_field = SystemDatabase.create(
                 system_database_url=get_system_database_url(self._config),
                 engine_kwargs=self._config["database"]["sys_db_engine_kwargs"],
+                engine=self._config["system_database_engine"],
                 debug_mode=debug_mode,
                 schema=schema,
             )
@@ -1222,6 +1223,10 @@ class DBOS:
     async def list_workflow_steps_async(cls, workflow_id: str) -> List[StepInfo]:
         await cls._configure_asyncio_thread_pool()
         return await asyncio.to_thread(cls.list_workflow_steps, workflow_id)
+    
+    @classproperty
+    def application_version(cls) -> str:
+        return GlobalParams.app_version
 
     @classproperty
     def logger(cls) -> Logger:

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/_dbos_config.py

@@ -3,6 +3,7 @@ import re
 from importlib import resources
 from typing import Any, Dict, List, Optional, TypedDict, cast
 
+import sqlalchemy as sa
 import yaml
 from sqlalchemy import make_url
 
@@ -34,6 +35,7 @@ class DBOSConfig(TypedDict, total=False):
         executor_id (str): Executor ID, used to identify the application instance in distributed environments
         dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
         enable_otlp (bool): If True, enable built-in DBOS OTLP tracing and logging.
+        system_database_engine (sa.Engine): A custom system database engine. If provided, DBOS will not create an engine but use this instead.
     """
 
     name: str
@@ -52,6 +54,7 @@ class DBOSConfig(TypedDict, total=False):
     executor_id: Optional[str]
     dbos_system_schema: Optional[str]
     enable_otlp: Optional[bool]
+    system_database_engine: Optional[sa.Engine]
 
 
 class RuntimeConfig(TypedDict, total=False):
@@ -97,20 +100,7 @@ class TelemetryConfig(TypedDict, total=False):
 class ConfigFile(TypedDict, total=False):
     """
     Data structure containing the DBOS Configuration.
-
-    This configuration data is typically loaded from `dbos-config.yaml`.
-    See `https://docs.dbos.dev/python/reference/configuration#dbos-configuration-file`
-
-    Attributes:
-        name (str): Application name
-        runtimeConfig (RuntimeConfig): Configuration for DBOS Cloud
-        database (DatabaseConfig): Configure pool sizes, migrate commands
-        database_url (str): Application database URL
-        system_database_url (str): System database URL
-        telemetry (TelemetryConfig): Configuration for tracing / logging
-        env (Dict[str,str]): Environment variables
-        dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
-
+    The DBOSConfig object is parsed into this.
     """
 
     name: str
@@ -120,6 +110,7 @@ class ConfigFile(TypedDict, total=False):
     system_database_url: Optional[str]
     telemetry: Optional[TelemetryConfig]
     env: Dict[str, str]
+    system_database_engine: Optional[sa.Engine]
     dbos_system_schema: Optional[str]
 
 
@@ -188,6 +179,8 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
     if telemetry:
         translated_config["telemetry"] = telemetry
 
+    translated_config["system_database_engine"] = config.get("system_database_engine")
+
     return translated_config
 
 

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/_debouncer.py

@@ -89,11 +89,13 @@ def debouncer_workflow(
     # Every time the debounced workflow is called, a message is sent to this workflow.
     # It waits until debounce_period_sec have passed since the last message or until
     # debounce_timeout_sec has elapsed.
-    debounce_deadline_epoch_sec = (
-        time.time() + options["debounce_timeout_sec"]
-        if options["debounce_timeout_sec"]
-        else math.inf
-    )
+    def get_debounce_deadline_epoch_sec() -> float:
+        return (
+            time.time() + options["debounce_timeout_sec"]
+            if options["debounce_timeout_sec"]
+            else math.inf
+        )
+    debounce_deadline_epoch_sec = dbos._sys_db.call_function_as_step(get_debounce_deadline_epoch_sec, "get_debounce_deadline_epoch_sec")
     debounce_period_sec = initial_debounce_period_sec
     while time.time() < debounce_deadline_epoch_sec:
         time_until_deadline = max(debounce_deadline_epoch_sec - time.time(), 0)

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/_queue.py

@@ -61,7 +61,7 @@ class Queue:
 
         registry = _get_or_create_dbos_registry()
         if self.name in registry.queue_info_map and self.name != INTERNAL_QUEUE_NAME:
-            dbos_logger.warning(f"Queue {name} has already been declared")
+            raise Exception(f"Queue {name} has already been declared")
         registry.queue_info_map[self.name] = self
 
     def enqueue(
@@ -75,7 +75,7 @@ class Queue:
             and context.priority is not None
             and not self.priority_enabled
         ):
-            dbos_logger.warning(
+            raise Exception(
                 f"Priority is not enabled for queue {self.name}. Setting priority will not have any effect."
             )
 

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/_sys_db.py

@@ -346,17 +346,32 @@ class SystemDatabase(ABC):
         *,
         system_database_url: str,
         engine_kwargs: Dict[str, Any],
+        engine: Optional[sa.Engine],
+        schema: Optional[str],
         debug_mode: bool = False,
     ):
         import sqlalchemy.dialects.postgresql as pg
         import sqlalchemy.dialects.sqlite as sq
 
         self.dialect = sq if system_database_url.startswith("sqlite") else pg
-        self.engine = self._create_engine(system_database_url, engine_kwargs)
+
+        if system_database_url.startswith("sqlite"):
+            self.schema = None
+        else:
+            self.schema = schema if schema else "dbos"
+        SystemSchema.set_schema(self.schema)
+
+        if engine:
+            self.engine = engine
+            self.created_engine = False
+        else:
+            self.engine = self._create_engine(system_database_url, engine_kwargs)
+            self.created_engine = True
         self._engine_kwargs = engine_kwargs
 
         self.notifications_map = ThreadSafeConditionDict()
         self.workflow_events_map = ThreadSafeConditionDict()
+        self._listener_thread_lock = threading.Lock()
 
         # Now we can run background processes
         self._run_background_processes = True
@@ -1443,6 +1458,7 @@ class SystemDatabase(ABC):
     def create(
         system_database_url: str,
         engine_kwargs: Dict[str, Any],
+        engine: Optional[sa.Engine],
         schema: Optional[str],
         debug_mode: bool = False,
     ) -> "SystemDatabase":
@@ -1453,6 +1469,8 @@ class SystemDatabase(ABC):
             return SQLiteSystemDatabase(
                 system_database_url=system_database_url,
                 engine_kwargs=engine_kwargs,
+                engine=engine,
+                schema=schema,
                 debug_mode=debug_mode,
             )
         else:
@@ -1461,8 +1479,9 @@ class SystemDatabase(ABC):
             return PostgresSystemDatabase(
                 system_database_url=system_database_url,
                 engine_kwargs=engine_kwargs,
-                debug_mode=debug_mode,
+                engine=engine,
                 schema=schema,
+                debug_mode=debug_mode,
             )
 
     @db_retry()

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/_sys_db_postgres.py

@@ -1,12 +1,11 @@
 import time
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, cast
 
 import psycopg
 import sqlalchemy as sa
 from sqlalchemy.exc import DBAPIError
 
 from dbos._migration import ensure_dbos_schema, run_dbos_migrations
-from dbos._schemas.system_database import SystemSchema
 
 from ._logger import dbos_logger
 from ._sys_db import SystemDatabase
@@ -15,25 +14,7 @@ from ._sys_db import SystemDatabase
 class PostgresSystemDatabase(SystemDatabase):
     """PostgreSQL-specific implementation of SystemDatabase."""
 
-    def __init__(
-        self,
-        *,
-        system_database_url: str,
-        engine_kwargs: Dict[str, Any],
-        schema: Optional[str],
-        debug_mode: bool = False,
-    ):
-        super().__init__(
-            system_database_url=system_database_url,
-            engine_kwargs=engine_kwargs,
-            debug_mode=debug_mode,
-        )
-        if schema is None:
-            self.schema = "dbos"
-        else:
-            self.schema = schema
-        SystemSchema.set_schema(self.schema)
-        self.notification_conn: Optional[psycopg.connection.Connection] = None
+    notification_conn: Optional[sa.PoolProxiedConnection] = None
 
     def _create_engine(
         self, system_database_url: str, engine_kwargs: Dict[str, Any]
@@ -48,27 +29,35 @@ class PostgresSystemDatabase(SystemDatabase):
             return
         system_db_url = self.engine.url
         sysdb_name = system_db_url.database
-        # If the system database does not already exist, create it
-        engine = sa.create_engine(
-            system_db_url.set(database="postgres"), **self._engine_kwargs
-        )
-        with engine.connect() as conn:
-            conn.execution_options(isolation_level="AUTOCOMMIT")
-            if not conn.execute(
-                sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
-                parameters={"db_name": sysdb_name},
-            ).scalar():
-                dbos_logger.info(f"Creating system database {sysdb_name}")
-                conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
-        engine.dispose()
+        # Unless we were provided an engine, if the system database does not already exist, create it
+        if self.created_engine:
+            engine = sa.create_engine(
+                system_db_url.set(database="postgres"), **self._engine_kwargs
+            )
+            with engine.connect() as conn:
+                conn.execution_options(isolation_level="AUTOCOMMIT")
+                if not conn.execute(
+                    sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
+                    parameters={"db_name": sysdb_name},
+                ).scalar():
+                    dbos_logger.info(f"Creating system database {sysdb_name}")
+                    conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
+            engine.dispose()
+        else:
+            # If we were provided an engine, validate it can connect
+            with self.engine.connect() as conn:
+                conn.execute(sa.text("SELECT 1"))
 
+        assert self.schema
         ensure_dbos_schema(self.engine, self.schema)
         run_dbos_migrations(self.engine, self.schema)
 
     def _cleanup_connections(self) -> None:
         """Clean up PostgreSQL-specific connections."""
-        if self.notification_conn is not None:
-            self.notification_conn.close()
+        with self._listener_thread_lock:
+            if self.notification_conn and self.notification_conn.dbapi_connection:
+                self.notification_conn.dbapi_connection.close()
+                self.notification_conn.invalidate()
 
     def _is_unique_constraint_violation(self, dbapi_error: DBAPIError) -> bool:
         """Check if the error is a unique constraint violation in PostgreSQL."""
@@ -111,20 +100,18 @@ class PostgresSystemDatabase(SystemDatabase):
         """Listen for PostgreSQL notifications using psycopg."""
         while self._run_background_processes:
             try:
-                # since we're using the psycopg connection directly, we need a url without the "+psycopg" suffix
-                url = sa.URL.create(
-                    "postgresql", **self.engine.url.translate_connect_args()
-                )
-                # Listen to notifications
-                self.notification_conn = psycopg.connect(
-                    url.render_as_string(hide_password=False), autocommit=True
-                )
-
-                self.notification_conn.execute("LISTEN dbos_notifications_channel")
-                self.notification_conn.execute("LISTEN dbos_workflow_events_channel")
-
+                with self._listener_thread_lock:
+                    self.notification_conn = self.engine.raw_connection()
+                    self.notification_conn.detach()
+                    psycopg_conn = cast(
+                        psycopg.connection.Connection, self.notification_conn
+                    )
+                    psycopg_conn.set_autocommit(True)
+
+                    psycopg_conn.execute("LISTEN dbos_notifications_channel")
+                    psycopg_conn.execute("LISTEN dbos_workflow_events_channel")
                 while self._run_background_processes:
-                    gen = self.notification_conn.notifies()
+                    gen = psycopg_conn.notifies()
                     for notify in gen:
                         channel = notify.channel
                         dbos_logger.debug(
@@ -162,5 +149,4 @@ class PostgresSystemDatabase(SystemDatabase):
                     time.sleep(1)
                     # Then the loop will try to reconnect and restart the listener
             finally:
-                if self.notification_conn is not None:
-                    self.notification_conn.close()
+                self._cleanup_connections()

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/_sys_db_sqlite.py

@@ -6,7 +6,6 @@ import sqlalchemy as sa
 from sqlalchemy.exc import DBAPIError
 
 from dbos._migration import sqlite_migrations
-from dbos._schemas.system_database import SystemSchema
 
 from ._logger import dbos_logger
 from ._sys_db import SystemDatabase
@@ -19,7 +18,6 @@ class SQLiteSystemDatabase(SystemDatabase):
         self, system_database_url: str, engine_kwargs: Dict[str, Any]
     ) -> sa.Engine:
         """Create a SQLite engine."""
-        SystemSchema.set_schema(None)
         return sa.create_engine(system_database_url)
 
     def run_migrations(self) -> None:

{dbos-1.15.0a4 → dbos-1.15.0a6}/dbos/cli/migration.py

@@ -20,6 +20,7 @@ def migrate_dbos_databases(
                 "max_overflow": 0,
                 "pool_size": 2,
             },
+            engine=None,
             schema=schema,
         )
         sys_db.run_migrations()

{dbos-1.15.0a4 → dbos-1.15.0a6}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
 ]
 requires-python = ">=3.10"
 readme = "README.md"
-version = "1.15.0a4"
+version = "1.15.0a6"
 
 [project.license]
 text = "MIT"

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/conftest.py

@@ -52,7 +52,7 @@ def default_config() -> DBOSConfig:
         "system_database_url": (
             "sqlite:///test.sqlite"
             if using_sqlite()
-            else f"postgresql://postgres:{quote(os.environ.get('PGPASSWORD', 'dbos'), safe='')}@localhost:5432/dbostestpy_dbos_sys"
+            else f"postgresql+psycopg://postgres:{quote(os.environ.get('PGPASSWORD', 'dbos'), safe='')}@localhost:5432/dbostestpy_dbos_sys"
         ),
         "enable_otlp": True,
     }

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_admin_server.py

@@ -520,7 +520,7 @@ def test_list_workflows(dbos: DBOS, skip_with_sqlite_imprecise_time: None) -> No
     assert workflows[0]["CreatedAt"] is not None and len(workflows[0]["CreatedAt"]) > 0
     assert workflows[0]["UpdatedAt"] is not None and len(workflows[0]["UpdatedAt"]) > 0
     assert workflows[0]["QueueName"] is None
-    assert workflows[0]["ApplicationVersion"] == GlobalParams.app_version
+    assert workflows[0]["ApplicationVersion"] == DBOS.application_version
     assert workflows[0]["ExecutorID"] == GlobalParams.executor_id
 
     # Only load input and output as requested
@@ -620,7 +620,7 @@ def test_list_workflows(dbos: DBOS, skip_with_sqlite_imprecise_time: None) -> No
     assert len(workflows) == 2
 
     filters = {
-        "application_version": GlobalParams.app_version,
+        "application_version": DBOS.application_version,
     }
     response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
     assert response.status_code == 200
@@ -699,7 +699,7 @@ def test_get_workflow_by_id(dbos: DBOS) -> None:
         workflow_data["UpdatedAt"] is not None and len(workflow_data["UpdatedAt"]) > 0
     )
     assert workflow_data["QueueName"] is None
-    assert workflow_data["ApplicationVersion"] == GlobalParams.app_version
+    assert workflow_data["ApplicationVersion"] == DBOS.application_version
     assert workflow_data["ExecutorID"] == GlobalParams.executor_id
 
     # Test GET /workflows/:workflow_id for a non-existing workflow
@@ -812,7 +812,7 @@ def test_queued_workflows_endpoint(
         and len(queued_workflows[0]["UpdatedAt"]) > 0
     )
     assert queued_workflows[0]["QueueName"] == test_queue1.name
-    assert queued_workflows[0]["ApplicationVersion"] == GlobalParams.app_version
+    assert queued_workflows[0]["ApplicationVersion"] == DBOS.application_version
     assert queued_workflows[0]["ExecutorID"] == GlobalParams.executor_id
 
     # Verify sort_desc inverts the order

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_client.py

@@ -14,8 +14,6 @@ from sqlalchemy.exc import DBAPIError
 
 from dbos import DBOS, DBOSClient, DBOSConfig, EnqueueOptions, SetWorkflowID
 from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
-from dbos._sys_db import SystemDatabase
-from dbos._utils import GlobalParams
 from tests import client_collateral
 from tests.client_collateral import event_test, retrieve_test, send_test
 
@@ -125,7 +123,7 @@ def test_client_enqueue_appver_not_set(dbos: DBOS, client: DBOSClient) -> None:
     assert wf_status is not None
     assert wf_status.status == "SUCCESS"
     assert wf_status.name == "enqueue_test"
-    assert wf_status.app_version == GlobalParams.app_version
+    assert wf_status.app_version == DBOS.application_version
 
 
 def test_client_enqueue_appver_set(dbos: DBOS, client: DBOSClient) -> None:
@@ -138,7 +136,7 @@ def test_client_enqueue_appver_set(dbos: DBOS, client: DBOSClient) -> None:
         "queue_name": "test_queue",
         "workflow_name": "enqueue_test",
         "workflow_id": wfid,
-        "app_version": GlobalParams.app_version,
+        "app_version": DBOS.application_version,
     }
 
     client.enqueue(options, 42, "test", johnDoe)
@@ -151,7 +149,7 @@ def test_client_enqueue_appver_set(dbos: DBOS, client: DBOSClient) -> None:
     assert wf_status is not None
     assert wf_status.status == "SUCCESS"
     assert wf_status.name == "enqueue_test"
-    assert wf_status.app_version == GlobalParams.app_version
+    assert wf_status.app_version == DBOS.application_version
 
 
 def test_client_enqueue_wrong_appver(dbos: DBOS, client: DBOSClient) -> None:
@@ -205,7 +203,7 @@ def test_client_enqueue_idempotent(config: DBOSConfig, client: DBOSClient) -> No
     assert wf_status is not None
     assert wf_status.status == "SUCCESS"
     assert wf_status.name == "enqueue_test"
-    assert wf_status.app_version == GlobalParams.app_version
+    assert wf_status.app_version == DBOS.application_version
 
     DBOS.destroy(destroy_registry=True)
 
@@ -272,7 +270,7 @@ def test_client_send_idempotent(
     idempotency_key = f"test-idempotency-{now}"
     sendWFID = f"{wfid}-{idempotency_key}"
 
-    run_send_worker(wfid, topic, GlobalParams.app_version)
+    run_send_worker(wfid, topic, DBOS.application_version)
 
     client.send(wfid, message, topic, idempotency_key)
     client.send(wfid, message, topic, idempotency_key)
@@ -315,7 +313,7 @@ def test_client_send_failure(
     idempotency_key = f"test-idempotency-{now}"
     sendWFID = f"{wfid}-{idempotency_key}"
 
-    run_send_worker(wfid, topic, GlobalParams.app_version)
+    run_send_worker(wfid, topic, DBOS.application_version)
 
     client.send(wfid, message, topic, idempotency_key)
 

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_dbos.py

@@ -11,6 +11,7 @@ from typing import Any, Optional
 
 import pytest
 import sqlalchemy as sa
+from sqlalchemy.exc import OperationalError
 
 # Public API
 from dbos import (
@@ -1371,12 +1372,12 @@ def test_app_version(config: DBOSConfig) -> None:
     DBOS.launch()
 
     # Verify that app version is correctly set to a hex string
-    app_version = GlobalParams.app_version
+    app_version = DBOS.application_version
     assert len(app_version) > 0
     assert is_hex(app_version)
 
     DBOS.destroy(destroy_registry=True)
-    assert GlobalParams.app_version == ""
+    assert DBOS.application_version == ""
     dbos = DBOS(config=config)
 
     @DBOS.workflow()
@@ -1390,7 +1391,7 @@ def test_app_version(config: DBOSConfig) -> None:
     DBOS.launch()
 
     # Verify stability--the same workflow source produces the same app version.
-    assert GlobalParams.app_version == app_version
+    assert DBOS.application_version == app_version
 
     DBOS.destroy(destroy_registry=True)
     dbos = DBOS(config=config)
@@ -1401,7 +1402,7 @@ def test_app_version(config: DBOSConfig) -> None:
 
     # Verify that changing the workflow source changes the workflow version
     DBOS.launch()
-    assert GlobalParams.app_version != app_version
+    assert DBOS.application_version != app_version
 
     # Verify that version can be overriden with an environment variable
     app_version = str(uuid.uuid4())
@@ -1415,7 +1416,7 @@ def test_app_version(config: DBOSConfig) -> None:
         return x
 
     DBOS.launch()
-    assert GlobalParams.app_version == app_version
+    assert DBOS.application_version == app_version
 
     del os.environ["DBOS__APPVERSION"]
 
@@ -1434,7 +1435,7 @@ def test_app_version(config: DBOSConfig) -> None:
         return DBOS.workflow_id
 
     DBOS.launch()
-    assert GlobalParams.app_version == app_version
+    assert DBOS.application_version == app_version
     assert GlobalParams.executor_id == executor_id
     wfid = test_workflow()
     handle: WorkflowHandle[str] = DBOS.retrieve_workflow(wfid)
@@ -1827,3 +1828,65 @@ def test_custom_schema(
     steps = client.list_workflow_steps(handle.workflow_id)
     assert len(steps) == 4
     assert "transaction" in steps[0]["function_name"]
+
+
+def test_custom_engine(
+    config: DBOSConfig,
+    cleanup_test_databases: None,
+    db_engine: sa.Engine,
+    skip_with_sqlite: None,
+) -> None:
+    DBOS.destroy(destroy_registry=True)
+    assert config["system_database_url"]
+    config["application_database_url"] = None
+    system_database_url = config["system_database_url"]
+
+    # Create a custom engine
+    engine = sa.create_engine(system_database_url)
+    config["system_database_engine"] = engine
+
+    # Launch DBOS with the engine. It should fail because the database does not exist.
+    dbos = DBOS(config=config)
+    with pytest.raises(OperationalError):
+        DBOS.launch()
+    DBOS.destroy(destroy_registry=True)
+
+    # Create the database
+    with db_engine.connect() as c:
+        c.execution_options(isolation_level="AUTOCOMMIT")
+        sysdb_name = sa.make_url(config["system_database_url"]).database
+        c.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
+
+    # Launch DBOS again using the custom pool. It should succeed despite the bogus URL.
+    config["system_database_url"] = "postgresql://bogus:url@not:42/fake"
+    dbos = DBOS(config=config)
+    DBOS.launch()
+
+    key = "key"
+    val = "val"
+
+    @DBOS.workflow()
+    def recv_workflow() -> Any:
+        DBOS.set_event(key, val)
+        return DBOS.recv()
+
+    assert dbos._sys_db.engine == engine
+    handle = DBOS.start_workflow(recv_workflow)
+    assert DBOS.get_event(handle.workflow_id, key) == val
+    DBOS.send(handle.workflow_id, val)
+    assert handle.get_result() == val
+    assert len(DBOS.list_workflows()) == 2
+    steps = DBOS.list_workflow_steps(handle.workflow_id)
+    assert len(steps) == 3
+    assert "setEvent" in steps[0]["function_name"]
+    DBOS.destroy(destroy_registry=True)
+
+    # Test custom engine with client
+    client = DBOSClient(
+        system_database_url=config["system_database_url"],
+        system_database_engine=config["system_database_engine"],
+    )
+    assert len(client.list_workflows()) == 2
+    steps = client.list_workflow_steps(handle.workflow_id)
+    assert len(steps) == 3
+    assert "setEvent" in steps[0]["function_name"]

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_debouncer.py

@@ -147,7 +147,7 @@ def test_debouncer_queue(dbos: DBOS) -> None:
         return x
 
     first_value, second_value, third_value, fourth_value = 0, 1, 2, 3
-    queue = Queue("test-queue")
+    queue = Queue("test-queue", priority_enabled=True)
 
     debouncer = Debouncer.create(workflow, queue=queue)
     debounce_period_sec = 2

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_failures.py

@@ -136,12 +136,10 @@ def test_notification_errors(dbos: DBOS, skip_with_sqlite: None) -> None:
     system_database = cast(PostgresSystemDatabase, dbos._sys_db)
     while system_database.notification_conn is None:
         time.sleep(1)
-    system_database.notification_conn.close()
-    assert system_database.notification_conn.closed == 1
+    system_database._cleanup_connections()
 
-    # Wait for the connection to be re-established
-    while system_database.notification_conn.closed != 0:
-        time.sleep(1)
+    # Wait for the connection to re-establish
+    time.sleep(3)
 
     dest_uuid = str("sruuid1")
     with SetWorkflowID(dest_uuid):

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_queue.py

@@ -55,6 +55,10 @@ def test_simple_queue(dbos: DBOS) -> None:
 
     queue = Queue("test_queue")
 
+    # Test that redeclaring a queue is an exception
+    with pytest.raises(Exception):
+        Queue(queue.name)
+
     with SetWorkflowID(wfid):
         handle = queue.enqueue(test_workflow, "abc", "123")
     assert handle.get_result() == "abcd123"
@@ -908,7 +912,6 @@ def test_timeout_queue(dbos: DBOS) -> None:
 
     # Verify if a parent called with a timeout enqueues a blocked child
     # then exits the deadline propagates and the child is cancelled.
-    queue = Queue("regular_queue")
 
     @DBOS.workflow()
     def exiting_parent_workflow() -> str:

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_schema_migration.py

@@ -132,8 +132,9 @@ def test_sqlite_systemdb_migration() -> None:
         sys_db = SystemDatabase.create(
             system_database_url=sqlite_url,
             engine_kwargs={},
-            debug_mode=False,
+            engine=None,
             schema=None,
+            debug_mode=False,
         )
 
         # Run migrations

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_spans.py

@@ -76,7 +76,7 @@ def test_spans(config: DBOSConfig) -> None:
     for log in logs:
         assert log.log_record.attributes is not None
         assert (
-            log.log_record.attributes["applicationVersion"] == GlobalParams.app_version
+            log.log_record.attributes["applicationVersion"] == DBOS.application_version
         )
         assert log.log_record.attributes["executorID"] == GlobalParams.executor_id
         assert log.log_record.attributes["foo"] == "bar"
@@ -98,7 +98,7 @@ def test_spans(config: DBOSConfig) -> None:
             # Skip the manual span because it was not created by DBOS.tracer
             continue
         assert span.attributes is not None
-        assert span.attributes["applicationVersion"] == GlobalParams.app_version
+        assert span.attributes["applicationVersion"] == DBOS.application_version
         assert span.attributes["executorID"] == GlobalParams.executor_id
         assert span.context is not None
         assert span.attributes["foo"] == "bar"
@@ -203,7 +203,7 @@ async def test_spans_async(dbos: DBOS) -> None:
     for log in logs:
         assert log.log_record.attributes is not None
         assert (
-            log.log_record.attributes["applicationVersion"] == GlobalParams.app_version
+            log.log_record.attributes["applicationVersion"] == DBOS.application_version
         )
         assert log.log_record.attributes["executorID"] == GlobalParams.executor_id
         # Make sure the log record has a span_id and trace_id
@@ -226,7 +226,7 @@ async def test_spans_async(dbos: DBOS) -> None:
             # Skip the manual span because it was not created by DBOS.tracer
             continue
         assert span.attributes is not None
-        assert span.attributes["applicationVersion"] == GlobalParams.app_version
+        assert span.attributes["applicationVersion"] == DBOS.application_version
         assert span.attributes["executorID"] == GlobalParams.executor_id
         assert span.context is not None
         assert span.context.span_id > 0
@@ -316,7 +316,7 @@ def test_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     assert len(logs) == 1
     assert logs[0].log_record.attributes is not None
     assert (
-        logs[0].log_record.attributes["applicationVersion"] == GlobalParams.app_version
+        logs[0].log_record.attributes["applicationVersion"] == DBOS.application_version
     )
     assert logs[0].log_record.span_id is not None and logs[0].log_record.span_id > 0
     assert logs[0].log_record.trace_id is not None and logs[0].log_record.trace_id > 0
@@ -331,7 +331,7 @@ def test_wf_fastapi(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
 
     for span in spans:
         assert span.attributes is not None
-        assert span.attributes["applicationVersion"] == GlobalParams.app_version
+        assert span.attributes["applicationVersion"] == DBOS.application_version
         assert span.context is not None
         assert span.context.span_id > 0
         assert span.context.trace_id > 0
@@ -389,7 +389,7 @@ def test_disable_otlp_no_spans(config: DBOSConfig) -> None:
     for log in logs:
         assert log.log_record.attributes is not None
         assert (
-            log.log_record.attributes["applicationVersion"] == GlobalParams.app_version
+            log.log_record.attributes["applicationVersion"] == DBOS.application_version
         )
         assert log.log_record.attributes["executorID"] == GlobalParams.executor_id
         assert log.log_record.attributes["foo"] == "bar"

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_workflow_introspection.py

@@ -39,7 +39,7 @@ def test_list_workflow(dbos: DBOS) -> None:
     assert output.updated_at is not None and output.updated_at > 0
     assert output.queue_name == None
     assert output.executor_id == GlobalParams.executor_id
-    assert output.app_version == GlobalParams.app_version
+    assert output.app_version == DBOS.application_version
     assert output.app_id == ""
     assert output.recovery_attempts == 1
     assert output.workflow_timeout_ms is None
@@ -77,7 +77,7 @@ def test_list_workflow(dbos: DBOS) -> None:
     # Test searching by application version
     outputs = DBOS.list_workflows(app_version="no")
     assert len(outputs) == 0
-    outputs = DBOS.list_workflows(app_version=GlobalParams.app_version)
+    outputs = DBOS.list_workflows(app_version=DBOS.application_version)
     assert len(outputs) == 1
 
 
@@ -109,7 +109,7 @@ def test_list_workflow_error(dbos: DBOS) -> None:
     assert output.updated_at is not None and output.updated_at > 0
     assert output.queue_name == None
     assert output.executor_id == GlobalParams.executor_id
-    assert output.app_version == GlobalParams.app_version
+    assert output.app_version == DBOS.application_version
     assert output.app_id == ""
     assert output.recovery_attempts == 1
     assert output.workflow_timeout_ms is None
@@ -289,7 +289,7 @@ def test_queued_workflows(dbos: DBOS, skip_with_sqlite_imprecise_time: None) ->
         assert workflow.error is None
         assert "blocking_step" in workflow.name
         assert workflow.executor_id == GlobalParams.executor_id
-        assert workflow.app_version == GlobalParams.app_version
+        assert workflow.app_version == DBOS.application_version
         assert workflow.created_at is not None and workflow.created_at > 0
         assert workflow.updated_at is not None and workflow.updated_at > 0
         assert workflow.recovery_attempts == 1
@@ -323,7 +323,7 @@ def test_queued_workflows(dbos: DBOS, skip_with_sqlite_imprecise_time: None) ->
         assert workflow.error is None
         assert "blocking_step" in workflow.name
         assert workflow.executor_id == GlobalParams.executor_id
-        assert workflow.app_version == GlobalParams.app_version
+        assert workflow.app_version == DBOS.application_version
         assert workflow.created_at is not None and workflow.created_at > 0
         assert workflow.updated_at is not None and workflow.updated_at > 0
         assert workflow.recovery_attempts == 1

{dbos-1.15.0a4 → dbos-1.15.0a6}/tests/test_workflow_management.py

@@ -1,14 +1,11 @@
 import threading
 import time
 import uuid
-from typing import Callable
 
 import pytest
 import sqlalchemy as sa
 
-# Public API
 from dbos import DBOS, Queue, SetWorkflowID
-from dbos._dbos import DBOSConfiguredInstance
 from dbos._error import DBOSAwaitedWorkflowCancelledError
 from dbos._schemas.application_database import ApplicationSchema
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
@@ -58,7 +55,7 @@ def test_cancel_resume(dbos: DBOS) -> None:
 
     # Resume the workflow. Verify it completes successfully.
     handle = DBOS.resume_workflow(wfid)
-    assert handle.get_status().app_version == GlobalParams.app_version
+    assert handle.get_status().app_version == DBOS.application_version
     assert handle.get_status().queue_name == INTERNAL_QUEUE_NAME
     assert handle.get_result() == input
     assert steps_completed == 2
@@ -231,7 +228,7 @@ def test_fork_steps(
     with SetWorkflowID(fork_id):
         forked_handle = DBOS.fork_workflow(wfid, 3)
     assert forked_handle.workflow_id == fork_id
-    assert forked_handle.get_status().app_version == GlobalParams.app_version
+    assert forked_handle.get_status().app_version == DBOS.application_version
     assert forked_handle.get_result() == output
 
     assert stepOneCount == 1