dbos 0.26.0a8__tar.gz → 0.26.0a10__tar.gz

{dbos-0.26.0a8 → dbos-0.26.0a10}/PKG-INFO

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

{dbos-0.26.0a8 → dbos-0.26.0a10}/dbos/_client.py

@@ -1,7 +1,7 @@
 import asyncio
 import sys
 import uuid
-from typing import Any, Generic, Optional, TypedDict, TypeVar
+from typing import Any, Generic, List, Optional, TypedDict, TypeVar
 
 if sys.version_info < (3, 11):
     from typing_extensions import NotRequired
@@ -15,7 +15,12 @@ from dbos._error import DBOSNonExistentWorkflowError
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
 from dbos._serialization import WorkflowInputs
 from dbos._sys_db import SystemDatabase, WorkflowStatusInternal, WorkflowStatusString
-from dbos._workflow_commands import WorkflowStatus, get_workflow
+from dbos._workflow_commands import (
+    WorkflowStatus,
+    get_workflow,
+    list_queued_workflows,
+    list_workflows,
+)
 
 R = TypeVar("R", covariant=True)  # A generic type for workflow return values
 
@@ -202,3 +207,119 @@ class DBOSClient:
         return await asyncio.to_thread(
             self.get_event, workflow_id, key, timeout_seconds
         )
+
+    def cancel_workflow(self, workflow_id: str) -> None:
+        self._sys_db.cancel_workflow(workflow_id)
+
+    async def cancel_workflow_async(self, workflow_id: str) -> None:
+        await asyncio.to_thread(self.cancel_workflow, workflow_id)
+
+    def resume_workflow(self, workflow_id: str) -> None:
+        self._sys_db.resume_workflow(workflow_id)
+
+    async def resume_workflow_async(self, workflow_id: str) -> None:
+        await asyncio.to_thread(self.resume_workflow, workflow_id)
+
+    def list_workflows(
+        self,
+        *,
+        workflow_ids: Optional[List[str]] = None,
+        status: Optional[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,
+    ) -> List[WorkflowStatus]:
+        return list_workflows(
+            self._sys_db,
+            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,
+        )
+
+    async def list_workflows_async(
+        self,
+        *,
+        workflow_ids: Optional[List[str]] = None,
+        status: Optional[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,
+    ) -> List[WorkflowStatus]:
+        return await asyncio.to_thread(
+            self.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,
+        )
+
+    def list_queued_workflows(
+        self,
+        *,
+        queue_name: Optional[str] = None,
+        status: Optional[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,
+    ) -> List[WorkflowStatus]:
+        return list_queued_workflows(
+            self._sys_db,
+            queue_name=queue_name,
+            status=status,
+            start_time=start_time,
+            end_time=end_time,
+            name=name,
+            limit=limit,
+            offset=offset,
+            sort_desc=sort_desc,
+        )
+
+    async def list_queued_workflows_async(
+        self,
+        *,
+        queue_name: Optional[str] = None,
+        status: Optional[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,
+    ) -> List[WorkflowStatus]:
+        return await asyncio.to_thread(
+            self.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,
+        )

{dbos-0.26.0a8 → dbos-0.26.0a10}/dbos/_dbos_config.py

@@ -15,7 +15,6 @@ from jsonschema import ValidationError, validate
 from rich import print
 from sqlalchemy import URL, make_url
 
-from ._db_wizard import db_wizard, load_db_connection
 from ._error import DBOSInitializationError
 from ._logger import dbos_logger
 
@@ -70,7 +69,6 @@ class DatabaseConfig(TypedDict, total=False):
     sys_db_pool_size: Optional[int]
     ssl: Optional[bool]
     ssl_ca: Optional[str]
-    local_suffix: Optional[bool]
     migrate: Optional[List[str]]
     rollback: Optional[List[str]]
 
@@ -288,7 +286,6 @@ def load_config(
     config_file_path: str = DBOS_CONFIG_PATH,
     *,
     run_process_config: bool = True,
-    use_db_wizard: bool = True,
     silent: bool = False,
 ) -> ConfigFile:
     """
@@ -339,13 +336,12 @@ def load_config(
 
     data = cast(ConfigFile, data)
     if run_process_config:
-        data = process_config(data=data, use_db_wizard=use_db_wizard, silent=silent)
+        data = process_config(data=data, silent=silent)
     return data  # type: ignore
 
 
 def process_config(
     *,
-    use_db_wizard: bool = True,
     data: ConfigFile,
     silent: bool = False,
 ) -> ConfigFile:
@@ -372,22 +368,17 @@ def process_config(
     # 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 connection parameters. Use defaults otherwise.
-    db_connection = load_db_connection()
     connection_passed_in = data["database"].get("hostname", None) is not None
 
     dbos_dbport: Optional[int] = None
@@ -397,49 +388,22 @@ def process_config(
             dbos_dbport = int(dbport_env)
         except ValueError:
             pass
-    dbos_dblocalsuffix: Optional[bool] = None
-    dblocalsuffix_env = os.getenv("DBOS_DBLOCALSUFFIX")
-    if dblocalsuffix_env:
-        try:
-            dbos_dblocalsuffix = dblocalsuffix_env.casefold() == "true".casefold()
-        except ValueError:
-            pass
 
     data["database"]["hostname"] = (
-        os.getenv("DBOS_DBHOST")
-        or data["database"].get("hostname")
-        or db_connection.get("hostname")
-        or "localhost"
+        os.getenv("DBOS_DBHOST") or data["database"].get("hostname") or "localhost"
     )
 
-    data["database"]["port"] = (
-        dbos_dbport or data["database"].get("port") or db_connection.get("port") or 5432
-    )
+    data["database"]["port"] = dbos_dbport or data["database"].get("port") or 5432
     data["database"]["username"] = (
-        os.getenv("DBOS_DBUSER")
-        or data["database"].get("username")
-        or db_connection.get("username")
-        or "postgres"
+        os.getenv("DBOS_DBUSER") or data["database"].get("username") or "postgres"
     )
     data["database"]["password"] = (
         os.getenv("DBOS_DBPASSWORD")
         or data["database"].get("password")
-        or db_connection.get("password")
         or os.environ.get("PGPASSWORD")
         or "dbos"
     )
 
-    local_suffix = False
-    dbcon_local_suffix = db_connection.get("local_suffix")
-    if dbcon_local_suffix is not None:
-        local_suffix = dbcon_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
-
     if not data["database"].get("app_db_pool_size"):
         data["database"]["app_db_pool_size"] = 20
     if not data["database"].get("sys_db_pool_size"):
@@ -454,10 +418,6 @@ def process_config(
     elif "run_admin_server" not in data["runtimeConfig"]:
         data["runtimeConfig"]["run_admin_server"] = True
 
-    # 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")
-
     # Pretty-print where we've loaded database connection information from, respecting the log level
     if not silent and logs["logLevel"] == "INFO" or logs["logLevel"] == "DEBUG":
         d = data["database"]
@@ -470,21 +430,11 @@ def process_config(
             print(
                 f"[bold blue]Using database connection string: {conn_string}[/bold blue]"
             )
-        elif db_connection.get("hostname"):
-            print(
-                f"[bold blue]Loading database connection string from .dbos/db_connection: {conn_string}[/bold blue]"
-            )
         else:
             print(
                 f"[bold blue]Using default database connection string: {conn_string}[/bold blue]"
             )
 
-    if use_db_wizard and debugWorkflowId is None:
-        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
 

dbos-0.26.0a10/dbos/_docker_pg_helper.py

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

{dbos-0.26.0a8 → dbos-0.26.0a10}/dbos/cli/cli.py

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

{dbos-0.26.0a8 → dbos-0.26.0a10}/dbos/dbos-config.schema.json

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

{dbos-0.26.0a8 → dbos-0.26.0a10}/pyproject.toml

@@ -28,7 +28,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.26.0a8"
+version = "0.26.0a10"
 
 [project.license]
 text = "MIT"
@@ -88,4 +88,5 @@ dev = [
     "pdm-backend>=2.4.2",
     "pytest-asyncio>=0.25.0",
     "pyright>=1.1.398",
+    "types-docker>=7.1.0.20241229",
 ]