dbos 0.26.0a8__py3-none-any.whl → 0.26.0a9__py3-none-any.whl

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/_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/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/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.dist-info → dbos-0.26.0a9.dist-info}/METADATA

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

{dbos-0.26.0a8.dist-info → dbos-0.26.0a9.dist-info}/RECORD

@@ -1,25 +1,22 @@
-dbos-0.26.0a8.dist-info/METADATA,sha256=Ll7QmuHMijtBbtmGEJuVaYbcmNMKKSbZTh1aWcQUU9I,5553
-dbos-0.26.0a8.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-0.26.0a8.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.26.0a8.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.26.0a9.dist-info/METADATA,sha256=Olpmk9xnLEbfqKPtj7_cLfCShqh_RFowiykc6KtBTNQ,5553
+dbos-0.26.0a9.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-0.26.0a9.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.26.0a9.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=3NQfGlBiiUSM_v88STdVP3rNZvGkUL_9WbSotKb8Voo,873
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=vxPG_YJ6lYrkfPCSp42FiATVLBOij7Fm52Yngg5Z_tE,7027
 dbos/_app_db.py,sha256=IwnNlHEQYp2bl5BM66vVPFa40h8DOtvRgUWTJ1dz20A,8963
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
 dbos/_client.py,sha256=fzW_Gagh-oyWyDYtREcQDBesoVl_LsEoMeJAsn5-C5s,7262
-dbos/_cloudutils/authentication.py,sha256=V0fCWQN9stCkhbuuxgPTGpvuQcDqfU3KAxPAh01vKW4,5007
-dbos/_cloudutils/cloudutils.py,sha256=YC7jGsIopT0KveLsqbRpQk2KlRBk-nIRC_UCgep4f3o,7797
-dbos/_cloudutils/databases.py,sha256=_shqaqSvhY4n2ScgQ8IP5PDZvzvcx3YBKV8fj-cxhSY,8543
 dbos/_conductor/conductor.py,sha256=HYzVL29IMMrs2Mnms_7cHJynCnmmEN5SDQOMjzn3UoU,16840
 dbos/_conductor/protocol.py,sha256=xN7pmooyF1pqbH1b6WhllU5718P7zSb_b0KCwA6bzcs,6716
 dbos/_context.py,sha256=I8sLkdKTTkZEz7wG-MjynaQB6XEF2bLXuwNksiauP7w,19430
 dbos/_core.py,sha256=tjBGVbSgOn59lR29gcYi5f6fcKNKQM5EP1QXrQGUkXA,45426
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_db_wizard.py,sha256=VnMa6OL87Lc-XPDD1RnXp8NjsJE8YgiQLj3wtWAXp-8,8252
 dbos/_dbos.py,sha256=TOLi95Aca50huyOAWl9H5fii4nMYaGwN-zQ8GlLWdOg,45569
-dbos/_dbos_config.py,sha256=rTn30Hgh-RzTxqHbnYh2pC3Ioo30eJV9K4YxhJd-Gj4,22718
+dbos/_dbos_config.py,sha256=m05IFjM0jSwZBsnFMF_4qP2JkjVFc0gqyM2tnotXq20,20636
 dbos/_debug.py,sha256=MNlQVZ6TscGCRQeEEL0VE8Uignvr6dPeDDDefS3xgIE,1823
+dbos/_docker_pg_helper.py,sha256=9OGbuavRA_cwE-uPiLZJSdpbQu-6PPgl9clQZB2zT_U,5852
 dbos/_error.py,sha256=HtdV6Qy7qRyGD57wxLwE7YT0WdYtlx5ZLEe_Kv_gC-U,5953
 dbos/_fastapi.py,sha256=PhaKftbApHnjtYEOw0EYna_3K0cmz__J9of7mRJWzu4,3704
 dbos/_flask.py,sha256=DZKUZR5-xOzPI7tYZ53r2PvvHVoAb8SYwLzMVFsVfjI,2608
@@ -63,8 +60,8 @@ dbos/_utils.py,sha256=nFRUHzVjXG5AusF85AlYHikj63Tzi-kQm992ihsrAxA,201
 dbos/_workflow_commands.py,sha256=Tf7_hZQoPgP90KHQjMNlBggCNrLLCNRJxHtAJLvarc4,6153
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=-WW3kbq0W_Tq4WbMqb1UGJG3xvJb3woEY5VspG95Srk,2857
-dbos/cli/cli.py,sha256=FnI5ZAo-kAic-ij5wBqNJ2EJiYoBK1Ot-tTMh1WcXEM,16132
-dbos/dbos-config.schema.json,sha256=4z2OXPfp7H0uNT1m5dKxjg31qbAfPyKkFXwHufuUMec,5910
+dbos/cli/cli.py,sha256=Lb_RYmXoT5KH0xDbwaYpROE4c-svZ0eCq2Kxg7cAxTw,16537
+dbos/dbos-config.schema.json,sha256=i7jcxXqByKq0Jzv3nAUavONtj03vTwj6vWP4ylmBr8o,5694
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.26.0a8.dist-info/RECORD,,
+dbos-0.26.0a9.dist-info/RECORD,,

dbos/_cloudutils/authentication.py

@@ -1,163 +0,0 @@
-import os
-import time
-from dataclasses import dataclass
-from typing import Any, Dict, Optional
-
-import jwt
-import requests
-from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
-from cryptography.x509 import load_pem_x509_certificate
-from rich import print
-
-from .._logger import dbos_logger
-
-# Constants
-DBOS_CLOUD_HOST = os.getenv("DBOS_DOMAIN", "cloud.dbos.dev")
-PRODUCTION_ENVIRONMENT = DBOS_CLOUD_HOST == "cloud.dbos.dev"
-AUTH0_DOMAIN = "login.dbos.dev" if PRODUCTION_ENVIRONMENT else "dbos-inc.us.auth0.com"
-DBOS_CLIENT_ID = (
-    "6p7Sjxf13cyLMkdwn14MxlH7JdhILled"
-    if PRODUCTION_ENVIRONMENT
-    else "G38fLmVErczEo9ioCFjVIHea6yd0qMZu"
-)
-DBOS_CLOUD_IDENTIFIER = "dbos-cloud-api"
-
-
-@dataclass
-class DeviceCodeResponse:
-    device_code: str
-    user_code: str
-    verification_uri: str
-    verification_uri_complete: str
-    expires_in: int
-    interval: int
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "DeviceCodeResponse":
-        return cls(
-            device_code=data["device_code"],
-            user_code=data["user_code"],
-            verification_uri=data["verification_uri"],
-            verification_uri_complete=data["verification_uri_complete"],
-            expires_in=data["expires_in"],
-            interval=data["interval"],
-        )
-
-
-@dataclass
-class TokenResponse:
-    access_token: str
-    token_type: str
-    expires_in: int
-    refresh_token: Optional[str] = None
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "TokenResponse":
-        return cls(
-            access_token=data["access_token"],
-            token_type=data["token_type"],
-            expires_in=data["expires_in"],
-            refresh_token=data.get("refresh_token"),
-        )
-
-
-@dataclass
-class AuthenticationResponse:
-    token: str
-    refresh_token: Optional[str] = None
-
-
-class JWKSClient:
-    def __init__(self, jwks_uri: str):
-        self.jwks_uri = jwks_uri
-
-    def get_signing_key(self, kid: str) -> RSAPublicKey:
-        response = requests.get(self.jwks_uri)
-        jwks = response.json()
-        for key in jwks["keys"]:
-            if key["kid"] == kid:
-                cert_text = f"-----BEGIN CERTIFICATE-----\n{key['x5c'][0]}\n-----END CERTIFICATE-----"
-                cert = load_pem_x509_certificate(cert_text.encode())
-                return cert.public_key()  # type: ignore
-        raise Exception(f"Unable to find signing key with kid: {kid}")
-
-
-def verify_token(token: str) -> None:
-    header = jwt.get_unverified_header(token)
-
-    if not header.get("kid"):
-        raise ValueError("Invalid token: No 'kid' in header")
-
-    client = JWKSClient(f"https://{AUTH0_DOMAIN}/.well-known/jwks.json")
-    signing_key = client.get_signing_key(header["kid"])
-    jwt.decode(
-        token,
-        signing_key,
-        algorithms=["RS256"],
-        audience=DBOS_CLOUD_IDENTIFIER,
-        options={
-            "verify_iat": False,
-            "clock_tolerance": 60,
-        },
-    )
-
-
-def authenticate(get_refresh_token: bool = False) -> Optional[AuthenticationResponse]:
-    print(
-        "[bold blue]Please authenticate with DBOS Cloud to access a Postgres database[/bold blue]"
-    )
-
-    # Get device code
-    device_code_data = {
-        "client_id": DBOS_CLIENT_ID,
-        "scope": "offline_access" if get_refresh_token else "sub",
-        "audience": DBOS_CLOUD_IDENTIFIER,
-    }
-
-    try:
-        response = requests.post(
-            f"https://{AUTH0_DOMAIN}/oauth/device/code",
-            data=device_code_data,
-            headers={"content-type": "application/x-www-form-urlencoded"},
-        )
-        device_code_response = DeviceCodeResponse.from_dict(response.json())
-    except Exception as e:
-        dbos_logger.error(f"Failed to log in: {str(e)}")
-        return None
-
-    login_url = device_code_response.verification_uri_complete
-    print(f"[bold blue]Login URL:[/bold blue] {login_url}")
-
-    # Poll for token
-    token_data = {
-        "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
-        "device_code": device_code_response.device_code,
-        "client_id": DBOS_CLIENT_ID,
-    }
-
-    elapsed_time_sec = 0
-    token_response = None
-
-    while elapsed_time_sec < device_code_response.expires_in:
-        try:
-            time.sleep(device_code_response.interval)
-            elapsed_time_sec += device_code_response.interval
-
-            response = requests.post(
-                f"https://{AUTH0_DOMAIN}/oauth/token",
-                data=token_data,
-                headers={"content-type": "application/x-www-form-urlencoded"},
-            )
-            if response.status_code == 200:
-                token_response = TokenResponse.from_dict(response.json())
-                break
-        except Exception:
-            dbos_logger.info("Waiting for login...")
-
-    if not token_response:
-        return None
-
-    verify_token(token_response.access_token)
-    return AuthenticationResponse(
-        token=token_response.access_token, refresh_token=token_response.refresh_token
-    )

dbos/_cloudutils/cloudutils.py

@@ -1,254 +0,0 @@
-import json
-import os
-import re
-import time
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any, Optional, Union
-
-import jwt
-import requests
-import typer
-from rich import print
-
-from dbos._error import DBOSInitializationError
-
-from .._logger import dbos_logger
-from .authentication import authenticate
-
-
-# Must be the same as in TS
-@dataclass
-class DBOSCloudCredentials:
-    token: str
-    userName: str
-    organization: str
-    refreshToken: Optional[str] = None
-
-
-@dataclass
-class UserProfile:
-    Name: str
-    Organization: str
-
-    def __init__(self, **kwargs: Any) -> None:
-        self.Name = kwargs.get("Name", "")
-        self.Organization = kwargs.get("Organization", "")
-
-
-class AppLanguages(Enum):
-    Node = "node"
-    Python = "python"
-
-
-dbos_config_file_path = "dbos-config.yaml"
-DBOS_CLOUD_HOST = os.getenv("DBOS_DOMAIN", "cloud.dbos.dev")
-dbos_env_path = ".dbos"
-
-
-def is_token_expired(token: str) -> bool:
-    try:
-        decoded = jwt.decode(token, options={"verify_signature": False})
-        exp: int = decoded.get("exp")
-        if not exp:
-            return False
-        return time.time() >= exp
-    except Exception:
-        return True
-
-
-def credentials_exist() -> bool:
-    return os.path.exists(os.path.join(dbos_env_path, "credentials"))
-
-
-def delete_credentials() -> None:
-    credentials_path = os.path.join(dbos_env_path, "credentials")
-    if os.path.exists(credentials_path):
-        os.unlink(credentials_path)
-
-
-def write_credentials(credentials: DBOSCloudCredentials) -> None:
-    os.makedirs(dbos_env_path, exist_ok=True)
-    with open(os.path.join(dbos_env_path, "credentials"), "w", encoding="utf-8") as f:
-        json.dump(credentials.__dict__, f)
-
-
-def check_read_file(path: str, encoding: str = "utf-8") -> Union[str, bytes]:
-    # Check if file exists and is a file
-    if not os.path.exists(path):
-        raise FileNotFoundError(f"File {path} does not exist")
-    if not os.path.isfile(path):
-        raise IsADirectoryError(f"Path {path} is not a file")
-
-    # Read file content
-    with open(path, encoding=encoding) as f:
-        return f.read()
-
-
-@dataclass
-class CloudAPIErrorResponse:
-    message: str
-    status_code: int
-    request_id: str
-    detailed_error: Optional[str] = None
-
-
-def is_cloud_api_error_response(obj: Any) -> bool:
-    return (
-        isinstance(obj, dict)
-        and "message" in obj
-        and isinstance(obj["message"], str)
-        and "statusCode" in obj
-        and isinstance(obj["statusCode"], int)
-        and "requestID" in obj
-        and isinstance(obj["requestID"], str)
-    )
-
-
-def handle_api_errors(label: str, e: requests.exceptions.RequestException) -> None:
-    if hasattr(e, "response") and e.response is not None:
-        resp = e.response.json()
-        if is_cloud_api_error_response(resp):
-            message = f"[{resp['requestID']}] {label}: {resp['message']}."
-            dbos_logger.error(message)
-            raise DBOSInitializationError(message)
-
-
-def is_valid_username(value: str) -> Union[bool, str]:
-    if len(value) < 3 or len(value) > 30:
-        return "Username must be 3~30 characters long"
-    if not re.match("^[a-z0-9_]+$", value):
-        return "Username must contain only lowercase letters, numbers, and underscores."
-    return True
-
-
-def check_user_profile(credentials: DBOSCloudCredentials) -> bool:
-    bearer_token = f"Bearer {credentials.token}"
-    try:
-        response = requests.get(
-            f"https://{DBOS_CLOUD_HOST}/v1alpha1/user/profile",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": bearer_token,
-            },
-        )
-        response.raise_for_status()
-        profile = UserProfile(**response.json())
-        credentials.userName = profile.Name
-        credentials.organization = profile.Organization
-        return True
-    except requests.exceptions.RequestException as e:
-        error_label = "Failed to login"
-        if hasattr(e, "response") and e.response is not None:
-            resp = e.response.json()
-            if is_cloud_api_error_response(resp):
-                if "user not found in DBOS Cloud" not in resp["message"]:
-                    handle_api_errors(error_label, e)
-                    exit(1)
-        else:
-            dbos_logger.error(f"{error_label}: {str(e)}")
-            exit(1)
-    return False
-
-
-def register_user(credentials: DBOSCloudCredentials) -> None:
-    print("Please register for DBOS Cloud")
-
-    user_name = None
-    while not user_name:
-        user_name = typer.prompt("Choose your username")
-        validation_result = is_valid_username(user_name)
-        if validation_result is not True:
-            print(f"[red]Invalid username: {validation_result}[/red]")
-            user_name = None
-            continue
-
-    bearer_token = f"Bearer {credentials.token}"
-    try:
-        # Register user
-        response = requests.put(
-            f"https://{DBOS_CLOUD_HOST}/v1alpha1/user",
-            json={
-                "name": user_name,
-            },
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": bearer_token,
-            },
-        )
-        response.raise_for_status()
-
-        # Get user profile
-        response = requests.get(
-            f"https://{DBOS_CLOUD_HOST}/v1alpha1/user/profile",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": bearer_token,
-            },
-        )
-        response.raise_for_status()
-        profile = UserProfile(**response.json())
-        credentials.userName = profile.Name
-        credentials.organization = profile.Organization
-        print(f"[green]Successfully registered as {credentials.userName}[/green]")
-
-    except requests.exceptions.RequestException as e:
-        error_label = f"Failed to register user {user_name}"
-        if hasattr(e, "response") and e.response is not None:
-            handle_api_errors(error_label, e)
-        else:
-            dbos_logger.error(f"{error_label}: {str(e)}")
-        exit(1)
-
-
-def check_credentials() -> DBOSCloudCredentials:
-    empty_credentials = DBOSCloudCredentials(token="", userName="", organization="")
-
-    if not credentials_exist():
-        return empty_credentials
-
-    try:
-        with open(os.path.join(dbos_env_path, "credentials"), "r") as f:
-            cred_data = json.load(f)
-            credentials = DBOSCloudCredentials(**cred_data)
-
-        # Trim trailing /r /n
-        credentials.token = credentials.token.strip()
-
-        if is_token_expired(credentials.token):
-            print("Credentials expired. Logging in again...")
-            delete_credentials()
-            return empty_credentials
-
-        return credentials
-    except Exception as e:
-        dbos_logger.error(f"Error loading credentials: {str(e)}")
-        return empty_credentials
-
-
-def get_cloud_credentials() -> DBOSCloudCredentials:
-    # Check if credentials exist and are not expired
-    credentials = check_credentials()
-
-    # Log in the user
-    if not credentials.token:
-        auth_response = authenticate()
-        if auth_response is None:
-            dbos_logger.error("Failed to login. Exiting...")
-            exit(1)
-        credentials.token = auth_response.token
-        credentials.refreshToken = auth_response.refresh_token
-        write_credentials(credentials)
-
-    # Check if the user exists in DBOS Cloud
-    user_exists = check_user_profile(credentials)
-    if user_exists:
-        write_credentials(credentials)
-        print(f"[green]Successfully logged in as {credentials.userName}[/green]")
-        return credentials
-
-    # User doesn't exist, register the user in DBOS Cloud
-    register_user(credentials)
-    write_credentials(credentials)
-
-    return credentials

dbos/_cloudutils/databases.py

@@ -1,241 +0,0 @@
-import base64
-import random
-import time
-from dataclasses import dataclass
-from typing import Any, List, Optional
-
-import requests
-from rich import print
-
-from dbos._cloudutils.cloudutils import (
-    DBOS_CLOUD_HOST,
-    DBOSCloudCredentials,
-    handle_api_errors,
-    is_cloud_api_error_response,
-)
-from dbos._error import DBOSInitializationError
-
-from .._logger import dbos_logger
-
-
-@dataclass
-class UserDBCredentials:
-    RoleName: str
-    Password: str
-
-    def __init__(self, **kwargs: Any) -> None:
-        self.RoleName = kwargs.get("RoleName", "")
-        self.Password = kwargs.get("Password", "")
-
-
-@dataclass
-class UserDBInstance:
-    PostgresInstanceName: str = ""
-    Status: str = ""
-    HostName: str = ""
-    Port: int = 0
-    DatabaseUsername: str = ""
-    IsLinked: bool = False
-    SupabaseReference: Optional[str] = None
-
-    def __init__(self, **kwargs: Any) -> None:
-        self.PostgresInstanceName = kwargs.get("PostgresInstanceName", "")
-        self.Status = kwargs.get("Status", "")
-        self.HostName = kwargs.get("HostName", "")
-        self.Port = kwargs.get("Port", 0)
-        self.DatabaseUsername = kwargs.get("DatabaseUsername", "")
-        self.IsLinked = kwargs.get("IsLinked", False)
-        self.SupabaseReference = kwargs.get("SupabaseReference", None)
-
-
-def get_user_db_info(credentials: DBOSCloudCredentials, db_name: str) -> UserDBInstance:
-    bearer_token = f"Bearer {credentials.token}"
-
-    try:
-        response = requests.get(
-            f"https://{DBOS_CLOUD_HOST}/v1alpha1/{credentials.organization}/databases/userdb/info/{db_name}",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": bearer_token,
-            },
-        )
-        response.raise_for_status()
-        data = response.json()
-        return UserDBInstance(**data)
-    except requests.exceptions.RequestException as e:
-        error_label = f"Failed to get status of database {db_name}"
-        if hasattr(e, "response") and e.response is not None:
-            resp = e.response.json()
-            if is_cloud_api_error_response(resp):
-                handle_api_errors(error_label, e)
-        else:
-            dbos_logger.error(f"{error_label}: {str(e)}")
-        raise DBOSInitializationError(f"{error_label}: {str(e)}")
-
-
-def get_user_db_credentials(
-    credentials: DBOSCloudCredentials, db_name: str
-) -> UserDBCredentials:
-    bearer_token = f"Bearer {credentials.token}"
-    try:
-        response = requests.get(
-            f"https://{DBOS_CLOUD_HOST}/v1alpha1/{credentials.organization}/databases/userdb/{db_name}/credentials",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": bearer_token,
-            },
-        )
-        response.raise_for_status()
-        data = response.json()
-        return UserDBCredentials(**data)
-    except requests.exceptions.RequestException as e:
-        error_label = f"Failed to get credentials for database {db_name}"
-        if hasattr(e, "response") and e.response is not None:
-            resp = e.response.json()
-            if is_cloud_api_error_response(resp):
-                handle_api_errors(error_label, e)
-        else:
-            dbos_logger.error(f"{error_label}: {str(e)}")
-        raise DBOSInitializationError(f"{error_label}: {str(e)}")
-
-
-def create_user_role(credentials: DBOSCloudCredentials, db_name: str) -> None:
-    bearer_token = f"Bearer {credentials.token}"
-    try:
-        response = requests.post(
-            f"https://{DBOS_CLOUD_HOST}/v1alpha1/{credentials.organization}/databases/userdb/{db_name}/createuserdbrole",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": bearer_token,
-            },
-        )
-        response.raise_for_status()
-    except requests.exceptions.RequestException as e:
-        error_label = f"Failed to create a user role for database {db_name}"
-        if hasattr(e, "response") and e.response is not None:
-            resp = e.response.json()
-            if is_cloud_api_error_response(resp):
-                handle_api_errors(error_label, e)
-        else:
-            dbos_logger.error(f"{error_label}: {str(e)}")
-        raise DBOSInitializationError(f"{error_label}: {str(e)}")
-
-
-def create_user_db(
-    credentials: DBOSCloudCredentials,
-    db_name: str,
-    app_db_username: str,
-    app_db_password: str,
-) -> int:
-    bearer_token = f"Bearer {credentials.token}"
-
-    try:
-        response = requests.post(
-            f"https://{DBOS_CLOUD_HOST}/v1alpha1/{credentials.organization}/databases/userdb",
-            json={
-                "Name": db_name,
-                "AdminName": app_db_username,
-                "AdminPassword": app_db_password,
-            },
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": bearer_token,
-            },
-        )
-        response.raise_for_status()
-
-        print(f"Successfully started provisioning {db_name}")
-
-        status = ""
-        while status not in ["available", "backing-up"]:
-            if status == "":
-                time.sleep(5)  # First time sleep 5 sec
-            else:
-                time.sleep(30)  # Otherwise, sleep 30 sec
-
-            user_db_info = get_user_db_info(credentials, db_name)
-            status = user_db_info.Status
-            print(
-                f"[bold blue]Waiting for cloud database to finish provisioning. Status:[/bold blue] [yellow]{status}[/yellow]"
-            )
-
-        print("[green]Database successfully provisioned![/green]")
-        return 0
-
-    except requests.exceptions.RequestException as e:
-        error_label = f"Failed to create database {db_name}"
-        if hasattr(e, "response") and e.response is not None:
-            resp = e.response.json()
-            if is_cloud_api_error_response(resp):
-                handle_api_errors(error_label, e)
-        else:
-            dbos_logger.error(f"{error_label}: {str(e)}")
-        return 1
-
-
-def choose_database(credentials: DBOSCloudCredentials) -> Optional[UserDBInstance]:
-    # List existing database instances
-    user_dbs: List[UserDBInstance] = []
-    bearer_token = f"Bearer {credentials.token}"
-
-    try:
-        response = requests.get(
-            f"https://{DBOS_CLOUD_HOST}/v1alpha1/{credentials.organization}/databases",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": bearer_token,
-            },
-        )
-        response.raise_for_status()
-        data = response.json()
-        user_dbs = [UserDBInstance(**db) for db in data]
-
-    except requests.exceptions.RequestException as e:
-        error_label = "Failed to list databases"
-        if hasattr(e, "response") and e.response is not None:
-            resp = e.response.json()
-            if is_cloud_api_error_response(resp):
-                handle_api_errors(error_label, e)
-        else:
-            dbos_logger.error(f"{error_label}: {str(e)}")
-        return None
-
-    if not user_dbs:
-        # If not, prompt the user to provision one
-        print("Provisioning a cloud Postgres database server")
-        user_db_name = f"{credentials.userName}-db-server"
-
-        # Use a default user name and auto generated password
-        app_db_username = "dbos_user"
-        app_db_password = base64.b64encode(str(random.random()).encode()).decode()
-        res = create_user_db(
-            credentials, user_db_name, app_db_username, app_db_password
-        )
-        if res != 0:
-            return None
-    elif len(user_dbs) > 1:
-        # If there is more than one database instance, prompt the user to select one
-        choices = [db.PostgresInstanceName for db in user_dbs]
-        print("Choose a database instance for this app:")
-        for i, entry in enumerate(choices, 1):
-            print(f"{i}. {entry}")
-        while True:
-            try:
-                choice = int(input("Enter number: ")) - 1
-                if 0 <= choice < len(choices):
-                    user_db_name = choices[choice]
-                    break
-            except ValueError:
-                continue
-            print("Invalid choice, please try again")
-    else:
-        # Use the only available database server
-        user_db_name = user_dbs[0].PostgresInstanceName
-        print(f"[green]Using database instance:[/green] {user_db_name}")
-
-    info = get_user_db_info(credentials, user_db_name)
-
-    if not info.IsLinked:
-        create_user_role(credentials, user_db_name)
-
-    return info

dbos/_db_wizard.py

@@ -1,220 +0,0 @@
-import json
-import os
-import time
-from typing import TYPE_CHECKING, Optional, TypedDict, cast
-
-import docker  # type: ignore
-import typer
-import yaml
-from rich import print
-from sqlalchemy import URL, create_engine, text
-
-if TYPE_CHECKING:
-    from ._dbos_config import ConfigFile
-
-from ._cloudutils.cloudutils import get_cloud_credentials
-from ._cloudutils.databases import choose_database, get_user_db_credentials
-from ._error import DBOSInitializationError
-from ._logger import dbos_logger
-
-DB_CONNECTION_PATH = os.path.join(".dbos", "db_connection")
-
-
-class DatabaseConnection(TypedDict):
-    hostname: Optional[str]
-    port: Optional[int]
-    username: Optional[str]
-    password: Optional[str]
-    local_suffix: Optional[bool]
-
-
-def db_wizard(config: "ConfigFile") -> "ConfigFile":
-    """Checks database connectivity and helps the user start a database if needed
-
-    First, check connectivity to the database configured in the provided `config` object.
-    If it fails:
-     - Return an error if the connection failed due to incorrect credentials.
-     - Return an error if it detects a non-default configuration.
-     - Otherwise assume the configured database is not running and guide the user through setting it up.
-
-     The wizard will first attempt to start a local Postgres instance using Docker.
-     If Docker is not available, it will prompt the user to connect to a DBOS Cloud database.
-
-     Finally, if a database was configured, its connection details will be saved in the local `.dbos/db_connection` file.
-    """
-    # 1. Check the connectivity to the database. Return if successful. If cannot connect, continue to the following steps.
-    db_connection_error = _check_db_connectivity(config)
-    if db_connection_error is None:
-        return config
-
-    # 2. If the error is due to password authentication or the configuration is non-default, surface the error and exit.
-    error_str = str(db_connection_error)
-    dbos_logger.debug(f"Error connecting to Postgres: {error_str}")
-    if (
-        "password authentication failed" in error_str
-        or "28P01" in error_str
-        or "no password supplied" in error_str
-    ):
-        raise DBOSInitializationError(
-            f"Could not connect to Postgres: password authentication failed: {db_connection_error}"
-        )
-
-    # If the database config is not the default one, surface the error and exit.
-    db_config = config["database"]  # FIXME: what if database is not in config?
-    if (
-        db_config["hostname"] != "localhost"
-        or db_config["port"] != 5432
-        or db_config["username"] != "postgres"
-    ):
-        raise DBOSInitializationError(
-            f"Could not connect to the database. Exception: {db_connection_error}"
-        )
-
-    print("[yellow]Postgres not detected locally[/yellow]")
-
-    # 3. If the database config is the default one, check if the user has Docker properly installed.
-    print("Attempting to start Postgres via Docker")
-    has_docker = _check_docker_installed()
-
-    # 4. If Docker is installed, prompt the user to start a local Docker based Postgres, and then set the PGPASSWORD to 'dbos' and try to connect to the database.
-    docker_started = False
-    if has_docker:
-        docker_started = _start_docker_postgres(config)
-    else:
-        print("[yellow]Docker not detected locally[/yellow]")
-
-    # 5. If no Docker, then prompt the user to log in to DBOS Cloud and provision a DB there. Wait for the remote DB to be ready, and then create a copy of the original config file, and then load the remote connection string to the local config file.
-    if not docker_started:
-        print("Attempting to connect to Postgres via DBOS Cloud")
-        cred = get_cloud_credentials()
-        db = choose_database(cred)
-        if db is None:
-            raise DBOSInitializationError("Error connecting to cloud database")
-        config["database"]["hostname"] = db.HostName
-        config["database"]["port"] = db.Port
-        if db.SupabaseReference is not None:
-            config["database"]["username"] = f"postgres.{db.SupabaseReference}"
-            supabase_password = typer.prompt(
-                "Enter your Supabase database password", hide_input=True
-            )
-            config["database"]["password"] = supabase_password
-        else:
-            config["database"]["username"] = db.DatabaseUsername
-            db_credentials = get_user_db_credentials(cred, db.PostgresInstanceName)
-            config["database"]["password"] = db_credentials.Password
-        config["database"]["local_suffix"] = True
-
-        # Verify these new credentials work
-        db_connection_error = _check_db_connectivity(config)
-        if db_connection_error is not None:
-            raise DBOSInitializationError(
-                f"Could not connect to the database. Exception: {db_connection_error}"
-            )
-
-    # 6. Save the config to the database connection file
-    updated_connection = DatabaseConnection(
-        hostname=config["database"]["hostname"],
-        port=config["database"]["port"],
-        username=config["database"]["username"],
-        password=config["database"]["password"],
-        local_suffix=config["database"]["local_suffix"],
-    )
-    save_db_connection(updated_connection)
-    return config
-
-
-def _start_docker_postgres(config: "ConfigFile") -> bool:
-    print("Starting a Postgres Docker container...")
-    client = docker.from_env()
-    pg_data = "/var/lib/postgresql/data"
-    container_name = "dbos-db"
-    client.containers.run(
-        image="pgvector/pgvector:pg16",
-        detach=True,
-        environment={
-            "POSTGRES_PASSWORD": config["database"]["password"],
-            "PGDATA": pg_data,
-        },
-        volumes={pg_data: {"bind": pg_data, "mode": "rw"}},
-        ports={"5432/tcp": config["database"]["port"]},
-        name=container_name,
-        remove=True,
-    )
-
-    container = client.containers.get(container_name)
-    attempts = 30
-    while attempts > 0:
-        if attempts % 5 == 0:
-            print("Waiting for Postgres Docker container to start...")
-        try:
-            res = container.exec_run("psql -U postgres -c 'SELECT 1;'")
-            if res.exit_code != 0:
-                attempts -= 1
-                time.sleep(1)
-                continue
-            print("[green]Postgres Docker container started successfully![/green]")
-            break
-        except:
-            attempts -= 1
-            time.sleep(1)
-
-    if attempts == 0:
-        print("[yellow]Failed to start Postgres Docker container.[/yellow]")
-        return False
-
-    return True
-
-
-def _check_docker_installed() -> bool:
-    # Check if Docker is installed
-    try:
-        client = docker.from_env()
-        client.ping()
-    except Exception:
-        return False
-    return True
-
-
-def _check_db_connectivity(config: "ConfigFile") -> Optional[Exception]:
-    postgres_db_url = URL.create(
-        "postgresql+psycopg",
-        username=config["database"]["username"],
-        password=config["database"]["password"],
-        host=config["database"]["hostname"],
-        port=config["database"]["port"],
-        database="postgres",
-        query={"connect_timeout": "2"},
-    )
-    postgres_db_engine = create_engine(postgres_db_url)
-    try:
-        with postgres_db_engine.connect() as conn:
-            conn.execute(text("SELECT 1")).scalar()
-    except Exception as e:
-        return e
-    finally:
-        postgres_db_engine.dispose()
-
-    return None
-
-
-def load_db_connection() -> DatabaseConnection:
-    try:
-        with open(DB_CONNECTION_PATH, "r") as f:
-            data = json.load(f)
-            return DatabaseConnection(
-                hostname=data.get("hostname", None),
-                port=data.get("port", None),
-                username=data.get("username", None),
-                password=data.get("password", None),
-                local_suffix=data.get("local_suffix", None),
-            )
-    except:
-        return DatabaseConnection(
-            hostname=None, port=None, username=None, password=None, local_suffix=None
-        )
-
-
-def save_db_connection(connection: DatabaseConnection) -> None:
-    os.makedirs(".dbos", exist_ok=True)
-    with open(DB_CONNECTION_PATH, "w") as f:
-        json.dump(connection, f)