dbos 1.8.0a3__tar.gz → 1.8.0a8__tar.gz

{dbos-1.8.0a3 → dbos-1.8.0a8}/PKG-INFO

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

{dbos-1.8.0a3 → dbos-1.8.0a8}/dbos/_client.py

@@ -13,7 +13,7 @@ else:
 
 from dbos import _serialization
 from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
-from dbos._dbos_config import is_valid_database_url
+from dbos._dbos_config import get_system_database_url, is_valid_database_url
 from dbos._error import DBOSException, DBOSNonExistentWorkflowError
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
 from dbos._serialization import WorkflowInputs
@@ -97,17 +97,28 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
 
 
 class DBOSClient:
-    def __init__(self, database_url: str, *, system_database: Optional[str] = None):
+    def __init__(
+        self,
+        database_url: str,
+        *,
+        system_database_url: Optional[str] = None,
+        system_database: Optional[str] = None,
+    ):
         assert is_valid_database_url(database_url)
         # We only create database connections but do not run migrations
         self._sys_db = SystemDatabase(
-            database_url=database_url,
+            system_database_url=get_system_database_url(
+                {
+                    "system_database_url": system_database_url,
+                    "database_url": database_url,
+                    "database": {"sys_db_name": system_database},
+                }
+            ),
             engine_kwargs={
                 "pool_timeout": 30,
                 "max_overflow": 0,
                 "pool_size": 2,
             },
-            sys_db_name=system_database,
         )
         self._sys_db.check_connection()
         self._app_db = ApplicationDatabase(

{dbos-1.8.0a3 → dbos-1.8.0a8}/dbos/_dbos.py

@@ -91,6 +91,7 @@ from ._context import (
 from ._dbos_config import (
     ConfigFile,
     DBOSConfig,
+    get_system_database_url,
     overwrite_config,
     process_config,
     translate_dbos_config_to_config_file,
@@ -424,9 +425,8 @@ class DBOS:
             assert self._config["database_url"] is not None
             assert self._config["database"]["sys_db_engine_kwargs"] is not None
             self._sys_db_field = SystemDatabase(
-                database_url=self._config["database_url"],
+                system_database_url=get_system_database_url(self._config),
                 engine_kwargs=self._config["database"]["sys_db_engine_kwargs"],
-                sys_db_name=self._config["database"]["sys_db_name"],
                 debug_mode=debug_mode,
             )
             assert self._config["database"]["db_engine_kwargs"] is not None
@@ -966,6 +966,12 @@ class DBOS:
             fn, "DBOS.cancelWorkflow"
         )
 
+    @classmethod
+    async def cancel_workflow_async(cls, workflow_id: str) -> None:
+        """Cancel a workflow by ID."""
+        await cls._configure_asyncio_thread_pool()
+        await asyncio.to_thread(cls.cancel_workflow, workflow_id)
+
     @classmethod
     async def _configure_asyncio_thread_pool(cls) -> None:
         """
@@ -987,11 +993,23 @@ class DBOS:
         _get_dbos_instance()._sys_db.call_function_as_step(fn, "DBOS.resumeWorkflow")
         return cls.retrieve_workflow(workflow_id)
 
+    @classmethod
+    async def resume_workflow_async(cls, workflow_id: str) -> WorkflowHandleAsync[Any]:
+        """Resume a workflow by ID."""
+        await cls._configure_asyncio_thread_pool()
+        await asyncio.to_thread(cls.resume_workflow, workflow_id)
+        return await cls.retrieve_workflow_async(workflow_id)
+
     @classmethod
     def restart_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Restart a workflow with a new workflow ID"""
         return cls.fork_workflow(workflow_id, 1)
 
+    @classmethod
+    async def restart_workflow_async(cls, workflow_id: str) -> WorkflowHandleAsync[Any]:
+        """Restart a workflow with a new workflow ID"""
+        return await cls.fork_workflow_async(workflow_id, 1)
+
     @classmethod
     def fork_workflow(
         cls,
@@ -1017,6 +1035,23 @@ class DBOS:
         )
         return cls.retrieve_workflow(new_id)
 
+    @classmethod
+    async def fork_workflow_async(
+        cls,
+        workflow_id: str,
+        start_step: int,
+        *,
+        application_version: Optional[str] = None,
+    ) -> WorkflowHandleAsync[Any]:
+        """Restart a workflow with a new workflow ID from a specific step"""
+        await cls._configure_asyncio_thread_pool()
+        new_id = await asyncio.to_thread(
+            lambda: cls.fork_workflow(
+                workflow_id, start_step, application_version=application_version
+            ).get_workflow_id()
+        )
+        return await cls.retrieve_workflow_async(new_id)
+
     @classmethod
     def list_workflows(
         cls,
@@ -1057,6 +1092,42 @@ class DBOS:
             fn, "DBOS.listWorkflows"
         )
 
+    @classmethod
+    async def list_workflows_async(
+        cls,
+        *,
+        workflow_ids: Optional[List[str]] = None,
+        status: Optional[Union[str, List[str]]] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        name: Optional[str] = None,
+        app_version: Optional[str] = None,
+        user: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        sort_desc: bool = False,
+        workflow_id_prefix: Optional[str] = None,
+        load_input: bool = True,
+        load_output: bool = True,
+    ) -> List[WorkflowStatus]:
+        await cls._configure_asyncio_thread_pool()
+        return await asyncio.to_thread(
+            cls.list_workflows,
+            workflow_ids=workflow_ids,
+            status=status,
+            start_time=start_time,
+            end_time=end_time,
+            name=name,
+            app_version=app_version,
+            user=user,
+            limit=limit,
+            offset=offset,
+            sort_desc=sort_desc,
+            workflow_id_prefix=workflow_id_prefix,
+            load_input=load_input,
+            load_output=load_output,
+        )
+
     @classmethod
     def list_queued_workflows(
         cls,
@@ -1089,6 +1160,34 @@ class DBOS:
             fn, "DBOS.listQueuedWorkflows"
         )
 
+    @classmethod
+    async def list_queued_workflows_async(
+        cls,
+        *,
+        queue_name: Optional[str] = None,
+        status: Optional[Union[str, List[str]]] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        name: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        sort_desc: bool = False,
+        load_input: bool = True,
+    ) -> List[WorkflowStatus]:
+        await cls._configure_asyncio_thread_pool()
+        return await asyncio.to_thread(
+            cls.list_queued_workflows,
+            queue_name=queue_name,
+            status=status,
+            start_time=start_time,
+            end_time=end_time,
+            name=name,
+            limit=limit,
+            offset=offset,
+            sort_desc=sort_desc,
+            load_input=load_input,
+        )
+
     @classmethod
     def list_workflow_steps(cls, workflow_id: str) -> List[StepInfo]:
         def fn() -> List[StepInfo]:
@@ -1100,6 +1199,11 @@ class DBOS:
             fn, "DBOS.listWorkflowSteps"
         )
 
+    @classmethod
+    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 logger(cls) -> Logger:
         """Return the DBOS `Logger` for the current context."""
@@ -1272,31 +1376,3 @@ class DBOSConfiguredInstance:
     def __init__(self, config_name: str) -> None:
         self.config_name = config_name
         DBOS.register_instance(self)
-
-
-# Apps that import DBOS probably don't exit.  If they do, let's see if
-#   it looks like startup was abandoned or a call was forgotten...
-def _dbos_exit_hook() -> None:
-    if _dbos_global_registry is None:
-        # Probably used as or for a support module
-        return
-    if _dbos_global_instance is None:
-        print("DBOS exiting; functions were registered but DBOS() was not called")
-        dbos_logger.warning(
-            "DBOS exiting; functions were registered but DBOS() was not called"
-        )
-        return
-    if not _dbos_global_instance._launched:
-        if _dbos_global_instance.fastapi is not None:
-            # FastAPI lifespan middleware will call launch/destroy, so we can ignore this.
-            # This is likely to happen during fastapi dev runs, where the reloader loads the module multiple times.
-            return
-        print("DBOS exiting; DBOS exists but launch() was not called")
-        dbos_logger.warning("DBOS exiting; DBOS exists but launch() was not called")
-        return
-    # If we get here, we're exiting normally
-    _dbos_global_instance.destroy()
-
-
-# Register the exit hook
-atexit.register(_dbos_exit_hook)

{dbos-1.8.0a3 → dbos-1.8.0a8}/dbos/_dbos_config.py

@@ -23,7 +23,8 @@ class DBOSConfig(TypedDict, total=False):
     Attributes:
         name (str): Application name
         database_url (str): Database connection string
-        sys_db_name (str): System database name
+        system_database_url (str): Connection string for the system database (if different from the application database)
+        sys_db_name (str): System database name (deprecated)
         sys_db_pool_size (int): System database pool size
         db_engine_kwargs (Dict[str, Any]): SQLAlchemy engine kwargs (See https://docs.sqlalchemy.org/en/20/core/engines.html#sqlalchemy.create_engine)
         log_level (str): Log level
@@ -36,6 +37,7 @@ class DBOSConfig(TypedDict, total=False):
 
     name: str
     database_url: Optional[str]
+    system_database_url: Optional[str]
     sys_db_name: Optional[str]
     sys_db_pool_size: Optional[int]
     db_engine_kwargs: Optional[Dict[str, Any]]
@@ -111,6 +113,7 @@ class ConfigFile(TypedDict, total=False):
     runtimeConfig: RuntimeConfig
     database: DatabaseConfig
     database_url: Optional[str]
+    system_database_url: Optional[str]
     telemetry: Optional[TelemetryConfig]
     env: Dict[str, str]
 
@@ -136,6 +139,8 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
 
     if "database_url" in config:
         translated_config["database_url"] = config.get("database_url")
+    if "system_database_url" in config:
+        translated_config["system_database_url"] = config.get("system_database_url")
 
     # Runtime config
     translated_config["runtimeConfig"] = {"run_admin_server": True}
@@ -488,6 +493,8 @@ def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
             "DBOS_DATABASE_URL environment variable is not set. This is required to connect to the database."
         )
     provided_config["database_url"] = db_url
+    if "system_database_url" in provided_config:
+        del provided_config["system_database_url"]
 
     # Telemetry config
     if "telemetry" not in provided_config or provided_config["telemetry"] is None:
@@ -537,3 +544,19 @@ def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
         del provided_config["env"]
 
     return provided_config
+
+
+def get_system_database_url(config: ConfigFile) -> str:
+    if "system_database_url" in config and config["system_database_url"] is not None:
+        return config["system_database_url"]
+    else:
+        assert config["database_url"] is not None
+        app_db_url = make_url(config["database_url"])
+        if config["database"].get("sys_db_name") is not None:
+            sys_db_name = config["database"]["sys_db_name"]
+        else:
+            assert app_db_url.database is not None
+            sys_db_name = app_db_url.database + SystemSchema.sysdb_suffix
+        return app_db_url.set(database=sys_db_name).render_as_string(
+            hide_password=False
+        )

{dbos-1.8.0a3 → dbos-1.8.0a8}/dbos/_error.py

@@ -55,7 +55,7 @@ class DBOSErrorCode(Enum):
     InitializationError = 3
     WorkflowFunctionNotFound = 4
     NonExistentWorkflowError = 5
-    DeadLetterQueueError = 6
+    MaxRecoveryAttemptsExceeded = 6
     MaxStepRetriesExceeded = 7
     NotAuthorized = 8
     ConflictingWorkflowError = 9
@@ -121,13 +121,13 @@ class DBOSNonExistentWorkflowError(DBOSException):
         )
 
 
-class DBOSDeadLetterQueueError(DBOSException):
-    """Exception raised when a workflow database record does not exist for a given ID."""
+class MaxRecoveryAttemptsExceededError(DBOSException):
+    """Exception raised when a workflow exceeds its max recovery attempts."""
 
     def __init__(self, wf_id: str, max_retries: int):
         super().__init__(
-            f"Workflow {wf_id} has been moved to the dead-letter queue after exceeding the maximum of {max_retries} retries",
-            dbos_error_code=DBOSErrorCode.DeadLetterQueueError.value,
+            f"Workflow {wf_id} has exceeded its maximum of {max_retries} execution or recovery attempts. Further attempts to execute or recover it will fail. See documentation for details: https://docs.dbos.dev/python/reference/decorators",
+            dbos_error_code=DBOSErrorCode.MaxRecoveryAttemptsExceeded.value,
         )
 
 

{dbos-1.8.0a3 → dbos-1.8.0a8}/dbos/_sys_db.py

@@ -37,12 +37,12 @@ from ._context import get_local_dbos_context
 from ._error import (
     DBOSAwaitedWorkflowCancelledError,
     DBOSConflictingWorkflowError,
-    DBOSDeadLetterQueueError,
     DBOSNonExistentWorkflowError,
     DBOSQueueDeduplicatedError,
     DBOSUnexpectedStepError,
     DBOSWorkflowCancelledError,
     DBOSWorkflowConflictIDError,
+    MaxRecoveryAttemptsExceededError,
 )
 from ._logger import dbos_logger
 from ._schemas.system_database import SystemSchema
@@ -57,20 +57,25 @@ class WorkflowStatusString(Enum):
     PENDING = "PENDING"
     SUCCESS = "SUCCESS"
     ERROR = "ERROR"
-    RETRIES_EXCEEDED = "RETRIES_EXCEEDED"
+    MAX_RECOVERY_ATTEMPTS_EXCEEDED = "MAX_RECOVERY_ATTEMPTS_EXCEEDED"
     CANCELLED = "CANCELLED"
     ENQUEUED = "ENQUEUED"
 
 
 WorkflowStatuses = Literal[
-    "PENDING", "SUCCESS", "ERROR", "RETRIES_EXCEEDED", "CANCELLED", "ENQUEUED"
+    "PENDING",
+    "SUCCESS",
+    "ERROR",
+    "MAX_RECOVERY_ATTEMPTS_EXCEEDED",
+    "CANCELLED",
+    "ENQUEUED",
 ]
 
 
 class WorkflowStatus:
     # The workflow ID
     workflow_id: str
-    # The workflow status. Must be one of ENQUEUED, PENDING, SUCCESS, ERROR, CANCELLED, or RETRIES_EXCEEDED
+    # The workflow status. Must be one of ENQUEUED, PENDING, SUCCESS, ERROR, CANCELLED, or MAX_RECOVERY_ATTEMPTS_EXCEEDED
     status: str
     # The name of the workflow function
     name: str
@@ -331,22 +336,15 @@ class SystemDatabase:
     def __init__(
         self,
         *,
-        database_url: str,
+        system_database_url: str,
         engine_kwargs: Dict[str, Any],
-        sys_db_name: Optional[str] = None,
         debug_mode: bool = False,
     ):
         # Set driver
-        system_db_url = sa.make_url(database_url).set(drivername="postgresql+psycopg")
-        # Resolve system database name
-        sysdb_name = sys_db_name
-        if not sysdb_name:
-            assert system_db_url.database is not None
-            sysdb_name = system_db_url.database + SystemSchema.sysdb_suffix
-        system_db_url = system_db_url.set(database=sysdb_name)
+        url = sa.make_url(system_database_url).set(drivername="postgresql+psycopg")
 
         self.engine = sa.create_engine(
-            system_db_url,
+            url,
             **engine_kwargs,
         )
         self._engine_kwargs = engine_kwargs
@@ -522,7 +520,7 @@ class SystemDatabase:
                 raise DBOSConflictingWorkflowError(status["workflow_uuid"], err_msg)
 
             # Every time we start executing a workflow (and thus attempt to insert its status), we increment `recovery_attempts` by 1.
-            # When this number becomes equal to `maxRetries + 1`, we mark the workflow as `RETRIES_EXCEEDED`.
+            # When this number becomes equal to `maxRetries + 1`, we mark the workflow as `MAX_RECOVERY_ATTEMPTS_EXCEEDED`.
             if (
                 (wf_status != "SUCCESS" and wf_status != "ERROR")
                 and max_recovery_attempts is not None
@@ -539,7 +537,7 @@ class SystemDatabase:
                         == WorkflowStatusString.PENDING.value
                     )
                     .values(
-                        status=WorkflowStatusString.RETRIES_EXCEEDED.value,
+                        status=WorkflowStatusString.MAX_RECOVERY_ATTEMPTS_EXCEEDED.value,
                         deduplication_id=None,
                         started_at_epoch_ms=None,
                         queue_name=None,
@@ -548,7 +546,7 @@ class SystemDatabase:
                 conn.execute(dlq_cmd)
                 # Need to commit here because we're throwing an exception
                 conn.commit()
-                raise DBOSDeadLetterQueueError(
+                raise MaxRecoveryAttemptsExceededError(
                     status["workflow_uuid"], max_recovery_attempts
                 )
 

{dbos-1.8.0a3 → dbos-1.8.0a8}/dbos/cli/cli.py

@@ -21,6 +21,7 @@ from .._client import DBOSClient
 from .._dbos_config import (
     _app_name_to_db_name,
     _is_valid_app_name,
+    get_system_database_url,
     is_valid_database_url,
     load_config,
 )
@@ -294,13 +295,12 @@ def migrate(
     sys_db = None
     try:
         sys_db = SystemDatabase(
-            database_url=connection_string,
+            system_database_url=get_system_database_url(config),
             engine_kwargs={
                 "pool_timeout": 30,
                 "max_overflow": 0,
                 "pool_size": 2,
             },
-            sys_db_name=sys_db_name,
         )
         app_db = ApplicationDatabase(
             database_url=connection_string,
@@ -450,7 +450,7 @@ def list(
         typer.Option(
             "--status",
             "-S",
-            help="Retrieve workflows with this status (PENDING, SUCCESS, ERROR, RETRIES_EXCEEDED, ENQUEUED, or CANCELLED)",
+            help="Retrieve workflows with this status (PENDING, SUCCESS, ERROR, ENQUEUED, CANCELLED, or MAX_RECOVERY_ATTEMPTS_EXCEEDED)",
         ),
     ] = None,
     appversion: Annotated[
@@ -657,7 +657,7 @@ def list_queue(
         typer.Option(
             "--status",
             "-S",
-            help="Retrieve functions with this status (PENDING, SUCCESS, ERROR, RETRIES_EXCEEDED, ENQUEUED, or CANCELLED)",
+            help="Retrieve functions with this status (PENDING, SUCCESS, ERROR, ENQUEUED, CANCELLED, or MAX_RECOVERY_ATTEMPTS_EXCEEDED)",
         ),
     ] = None,
     queue_name: Annotated[

{dbos-1.8.0a3 → dbos-1.8.0a8}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "1.8.0a3"
+version = "1.8.0a8"
 
 [project.license]
 text = "MIT"

{dbos-1.8.0a3 → dbos-1.8.0a8}/tests/conftest.py

@@ -12,6 +12,7 @@ from flask import Flask
 
 from dbos import DBOS, DBOSClient, DBOSConfig
 from dbos._app_db import ApplicationDatabase
+from dbos._dbos_config import get_system_database_url
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import SystemDatabase
 
@@ -40,7 +41,7 @@ def config() -> DBOSConfig:
 def sys_db(config: DBOSConfig) -> Generator[SystemDatabase, Any, None]:
     assert config["database_url"] is not None
     sys_db = SystemDatabase(
-        database_url=config["database_url"],
+        system_database_url=f"{config['database_url']}_dbos_sys",
         engine_kwargs={
             "pool_timeout": 30,
             "max_overflow": 0,

{dbos-1.8.0a3 → dbos-1.8.0a8}/tests/test_admin_server.py

@@ -104,7 +104,7 @@ def test_deactivate(dbos: DBOS, config: DBOSConfig) -> None:
         assert event.is_set()
     # Verify the scheduled workflow does not run anymore
     time.sleep(5)
-    assert wf_counter <= val + 1
+    assert wf_counter <= val + 2
     # Enqueue a workflow, verify it still runs
     assert queue.enqueue(regular_workflow).get_result() == 5
 

{dbos-1.8.0a3 → dbos-1.8.0a8}/tests/test_async.py

@@ -32,12 +32,12 @@ async def test_async_workflow(dbos: DBOS) -> None:
         nonlocal wf_counter
         wf_counter += 1
         res1 = test_transaction(var1)
-        res2 = test_step(var2)
+        res2 = await test_step(var2)
         DBOS.logger.info("I'm test_workflow")
         return res1 + res2
 
     @DBOS.step()
-    def test_step(var: str) -> str:
+    async def test_step(var: str) -> str:
         nonlocal step_counter
         step_counter += 1
         DBOS.logger.info("I'm test_step")
@@ -73,6 +73,10 @@ async def test_async_workflow(dbos: DBOS) -> None:
     sync_handle = DBOS.start_workflow(test_workflow, "alice", "bob")
     assert sync_handle.get_result() == "alicetxn31bobstep3"  # type: ignore
 
+    # Test DBOS.start_workflow_async on steps
+    handle = await DBOS.start_workflow_async(test_step, "alice")
+    assert (await handle.get_result()) == "alicestep4"
+
 
 @pytest.mark.asyncio
 async def test_async_step(dbos: DBOS) -> None: