dbos 0.20.0a2__tar.gz → 0.20.0a5__tar.gz

{dbos-0.20.0a2 → dbos-0.20.0a5}/PKG-INFO

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

{dbos-0.20.0a2 → dbos-0.20.0a5}/dbos/_core.py

@@ -488,6 +488,22 @@ def start_workflow(
     return WorkflowHandleFuture(new_wf_id, future, dbos)
 
 
+if sys.version_info < (3, 12):
+
+    def _mark_coroutine(func: Callable[P, R]) -> Callable[P, R]:
+        @wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> R:
+            return await func(*args, **kwargs)  # type: ignore
+
+        return async_wrapper  # type: ignore
+
+else:
+
+    def _mark_coroutine(func: Callable[P, R]) -> Callable[P, R]:
+        inspect.markcoroutinefunction(func)
+        return func
+
+
 def workflow_wrapper(
     dbosreg: "DBOSRegistry",
     func: Callable[P, R],
@@ -548,7 +564,7 @@ def workflow_wrapper(
         )
         return outcome()  # type: ignore
 
-    return wrapper
+    return _mark_coroutine(wrapper) if inspect.iscoroutinefunction(func) else wrapper
 
 
 def decorate_workflow(
@@ -838,6 +854,10 @@ def decorate_step(
                 assert tempwf
                 return tempwf(*args, **kwargs)
 
+        wrapper = (
+            _mark_coroutine(wrapper) if inspect.iscoroutinefunction(func) else wrapper  # type: ignore
+        )
+
         def temp_wf_sync(*args: Any, **kwargs: Any) -> Any:
             return wrapper(*args, **kwargs)
 

{dbos-0.20.0a2 → dbos-0.20.0a5}/dbos/_fastapi.py

@@ -1,10 +1,10 @@
 import uuid
-from typing import Any, Callable, cast
+from typing import Any, Callable, MutableMapping, cast
 
 from fastapi import FastAPI
 from fastapi import Request as FastAPIRequest
 from fastapi.responses import JSONResponse
-from starlette.types import ASGIApp, Message, Receive, Scope, Send
+from starlette.types import ASGIApp, Receive, Scope, Send
 
 from . import DBOS
 from ._context import (
@@ -61,15 +61,16 @@ class LifespanMiddleware:
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if scope["type"] == "lifespan":
-            while True:
-                message = await receive()
-                if message["type"] == "lifespan.startup":
+
+            async def wrapped_send(message: MutableMapping[str, Any]) -> None:
+                if message["type"] == "lifespan.startup.complete":
                     self.dbos._launch()
-                    await send({"type": "lifespan.startup.complete"})
-                elif message["type"] == "lifespan.shutdown":
+                elif message["type"] == "lifespan.shutdown.complete":
                     self.dbos._destroy()
-                    await send({"type": "lifespan.shutdown.complete"})
-                    break
+                await send(message)
+
+            # Call the original app with our wrapped functions
+            await self.app(scope, receive, wrapped_send)
         else:
             await self.app(scope, receive, send)
 

dbos-0.20.0a5/dbos/cli/_github_init.py

@@ -0,0 +1,107 @@
+import os
+from base64 import b64decode
+from typing import List, TypedDict
+
+import requests
+
+DEMO_REPO_API = "https://api.github.com/repos/dbos-inc/dbos-demo-apps"
+PY_DEMO_PATH = "python/"
+BRANCH = "main"
+
+
+class GitHubTreeItem(TypedDict):
+    path: str
+    mode: str
+    type: str
+    sha: str
+    url: str
+    size: int
+
+
+class GitHubTree(TypedDict):
+    sha: str
+    url: str
+    tree: List[GitHubTreeItem]
+    truncated: bool
+
+
+class GitHubItem(TypedDict):
+    sha: str
+    node_id: str
+    url: str
+    content: str
+    encoding: str
+    size: int
+
+
+def _fetch_github(url: str) -> requests.Response:
+    headers = {}
+    github_token = os.getenv("GITHUB_TOKEN")
+    if github_token:
+        headers["Authorization"] = f"Bearer {github_token}"
+
+    response = requests.get(url, headers=headers)
+
+    if not response.ok:
+        if response.headers.get("x-ratelimit-remaining") == "0":
+            raise Exception(
+                "Error fetching from GitHub API: rate limit exceeded.\n"
+                "Please wait a few minutes and try again.\n"
+                "To increase the limit, you can create a personal access token and set it in the GITHUB_TOKEN environment variable.\n"
+                "Details: https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api"
+            )
+        elif response.status_code == 401:
+            raise Exception(
+                f"Error fetching content from GitHub {url}: {response.status_code} {response.reason}.\n"
+                "Please ensure your GITHUB_TOKEN environment variable is set to a valid personal access token."
+            )
+        raise Exception(
+            f"Error fetching content from GitHub {url}: {response.status_code} {response.reason}"
+        )
+
+    return response
+
+
+def _fetch_github_tree(tag: str) -> List[GitHubTreeItem]:
+    response = _fetch_github(f"{DEMO_REPO_API}/git/trees/{tag}?recursive=1")
+    tree_data: GitHubTree = response.json()
+    return tree_data["tree"]
+
+
+def _fetch_github_item(url: str) -> str:
+    response = _fetch_github(url)
+    item: GitHubItem = response.json()
+    return b64decode(item["content"]).decode("utf-8")
+
+
+def create_template_from_github(app_name: str, template_name: str) -> None:
+    print(
+        f"Creating a new application named {app_name} from the template {template_name}"
+    )
+
+    tree = _fetch_github_tree(BRANCH)
+    template_path = f"{PY_DEMO_PATH}{template_name}/"
+
+    files_to_download = [
+        item
+        for item in tree
+        if item["path"].startswith(template_path) and item["type"] == "blob"
+    ]
+
+    # Download every file from the template
+    for item in files_to_download:
+        raw_content = _fetch_github_item(item["url"])
+        file_path = item["path"].replace(template_path, "")
+        target_path = os.path.join(".", file_path)
+
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(target_path), exist_ok=True)
+
+        # Write file with proper permissions
+        with open(target_path, "w", encoding="utf-8") as f:
+            f.write(raw_content)
+        os.chmod(target_path, int(item["mode"], 8))
+
+    print(
+        f"Downloaded {len(files_to_download)} files from the template GitHub repository"
+    )

dbos-0.20.0a5/dbos/cli/_template_init.py

@@ -0,0 +1,98 @@
+import os
+import shutil
+import typing
+from os import path
+from typing import Any
+
+import tomlkit
+from rich import print
+
+
+def get_templates_directory() -> str:
+    import dbos
+
+    package_dir = path.abspath(path.dirname(dbos.__file__))
+    return path.join(package_dir, "_templates")
+
+
+def _copy_dbos_template(src: str, dst: str, ctx: dict[str, str]) -> None:
+    with open(src, "r") as f:
+        content = f.read()
+
+    for key, value in ctx.items():
+        content = content.replace(f"${{{key}}}", value)
+
+    with open(dst, "w") as f:
+        f.write(content)
+
+
+def _copy_template_dir(src_dir: str, dst_dir: str, ctx: dict[str, str]) -> None:
+
+    for root, dirs, files in os.walk(src_dir, topdown=True):
+        dirs[:] = [d for d in dirs if d != "__package"]
+
+        dst_root = path.join(dst_dir, path.relpath(root, src_dir))
+        if len(dirs) == 0:
+            os.makedirs(dst_root, exist_ok=True)
+        else:
+            for dir in dirs:
+                os.makedirs(path.join(dst_root, dir), exist_ok=True)
+
+        for file in files:
+            src = path.join(root, file)
+            base, ext = path.splitext(file)
+
+            dst = path.join(dst_root, base if ext == ".dbos" else file)
+            if path.exists(dst):
+                print(f"[yellow]File {dst} already exists, skipping[/yellow]")
+                continue
+
+            if ext == ".dbos":
+                _copy_dbos_template(src, dst, ctx)
+            else:
+                shutil.copy(src, dst)
+
+
+def copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
+
+    dst_dir = path.abspath(".")
+
+    package_name = project_name.replace("-", "_")
+    ctx = {
+        "project_name": project_name,
+        "package_name": package_name,
+        "migration_command": "alembic upgrade head",
+    }
+
+    if config_mode:
+        ctx["package_name"] = "."
+        ctx["migration_command"] = "echo 'No migrations specified'"
+        _copy_dbos_template(
+            os.path.join(src_dir, "dbos-config.yaml.dbos"),
+            os.path.join(dst_dir, "dbos-config.yaml"),
+            ctx,
+        )
+    else:
+        _copy_template_dir(src_dir, dst_dir, ctx)
+        _copy_template_dir(
+            path.join(src_dir, "__package"), path.join(dst_dir, package_name), ctx
+        )
+
+
+def get_project_name() -> typing.Union[str, None]:
+    name = None
+    try:
+        with open("pyproject.toml", "rb") as file:
+            pyproj = typing.cast(dict[str, Any], tomlkit.load(file))
+            name = typing.cast(str, pyproj["project"]["name"])
+    except:
+        pass
+
+    if name == None:
+        try:
+            _, parent = path.split(path.abspath("."))
+            name = parent
+        except:
+            pass
+
+    return name

{dbos-0.20.0a2/dbos → dbos-0.20.0a5/dbos/cli}/cli.py

@@ -1,6 +1,5 @@
 import os
 import platform
-import shutil
 import signal
 import subprocess
 import time
@@ -11,19 +10,19 @@ from typing import Any
 import jsonpickle  # type: ignore
 import requests
 import sqlalchemy as sa
-import tomlkit
 import typer
 from rich import print
-from rich.prompt import Prompt
+from rich.prompt import IntPrompt
 from typing_extensions import Annotated
 
-from dbos._schemas.system_database import SystemSchema
-
-from . import _serialization, load_config
-from ._app_db import ApplicationDatabase
-from ._dbos_config import _is_valid_app_name
-from ._sys_db import SystemDatabase
-from ._workflow_commands import _cancel_workflow, _get_workflow, _list_workflows
+from .. import load_config
+from .._app_db import ApplicationDatabase
+from .._dbos_config import _is_valid_app_name
+from .._schemas.system_database import SystemSchema
+from .._sys_db import SystemDatabase
+from .._workflow_commands import _cancel_workflow, _get_workflow, _list_workflows
+from ..cli._github_init import create_template_from_github
+from ._template_init import copy_template, get_project_name, get_templates_directory
 
 app = typer.Typer()
 workflow = typer.Typer()
@@ -86,96 +85,6 @@ def start() -> None:
         process.wait()
 
 
-def _get_templates_directory() -> str:
-    import dbos
-
-    package_dir = path.abspath(path.dirname(dbos.__file__))
-    return path.join(package_dir, "_templates")
-
-
-def _copy_dbos_template(src: str, dst: str, ctx: dict[str, str]) -> None:
-    with open(src, "r") as f:
-        content = f.read()
-
-    for key, value in ctx.items():
-        content = content.replace(f"${{{key}}}", value)
-
-    with open(dst, "w") as f:
-        f.write(content)
-
-
-def _copy_template_dir(src_dir: str, dst_dir: str, ctx: dict[str, str]) -> None:
-
-    for root, dirs, files in os.walk(src_dir, topdown=True):
-        dirs[:] = [d for d in dirs if d != "__package"]
-
-        dst_root = path.join(dst_dir, path.relpath(root, src_dir))
-        if len(dirs) == 0:
-            os.makedirs(dst_root, exist_ok=True)
-        else:
-            for dir in dirs:
-                os.makedirs(path.join(dst_root, dir), exist_ok=True)
-
-        for file in files:
-            src = path.join(root, file)
-            base, ext = path.splitext(file)
-
-            dst = path.join(dst_root, base if ext == ".dbos" else file)
-            if path.exists(dst):
-                print(f"[yellow]File {dst} already exists, skipping[/yellow]")
-                continue
-
-            if ext == ".dbos":
-                _copy_dbos_template(src, dst, ctx)
-            else:
-                shutil.copy(src, dst)
-
-
-def _copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
-
-    dst_dir = path.abspath(".")
-
-    package_name = project_name.replace("-", "_")
-    ctx = {
-        "project_name": project_name,
-        "package_name": package_name,
-        "migration_command": "alembic upgrade head",
-    }
-
-    if config_mode:
-        ctx["package_name"] = "."
-        ctx["migration_command"] = "echo 'No migrations specified'"
-        _copy_dbos_template(
-            os.path.join(src_dir, "dbos-config.yaml.dbos"),
-            os.path.join(dst_dir, "dbos-config.yaml"),
-            ctx,
-        )
-    else:
-        _copy_template_dir(src_dir, dst_dir, ctx)
-        _copy_template_dir(
-            path.join(src_dir, "__package"), path.join(dst_dir, package_name), ctx
-        )
-
-
-def _get_project_name() -> typing.Union[str, None]:
-    name = None
-    try:
-        with open("pyproject.toml", "rb") as file:
-            pyproj = typing.cast(dict[str, Any], tomlkit.load(file))
-            name = typing.cast(str, pyproj["project"]["name"])
-    except:
-        pass
-
-    if name == None:
-        try:
-            _, parent = path.split(path.abspath("."))
-            name = parent
-        except:
-            pass
-
-    return name
-
-
 @app.command(help="Initialize a new DBOS application from a template")
 def init(
     project_name: Annotated[
@@ -191,35 +100,60 @@ def init(
     ] = False,
 ) -> None:
     try:
-        if project_name is None:
-            project_name = typing.cast(
-                str, typer.prompt("What is your project's name?", _get_project_name())
-            )
+        git_templates = ["dbos-app-starter", "dbos-cron-starter"]
+        templates_dir = get_templates_directory()
+        templates = git_templates + [
+            x.name for x in os.scandir(templates_dir) if x.is_dir()
+        ]
+        if len(templates) == 0:
+            raise Exception(f"no DBOS templates found in {templates_dir} ")
+
+        if template:
+            if template not in templates:
+                raise Exception(f"Template {template} not found in {templates_dir}")
+        else:
+            print("\n[bold]Available templates:[/bold]")
+            for idx, template_name in enumerate(templates, 1):
+                print(f"  {idx}. {template_name}")
+            while True:
+                try:
+                    choice = IntPrompt.ask(
+                        "\nSelect template number",
+                        show_choices=False,
+                        show_default=False,
+                    )
+                    if 1 <= choice <= len(templates):
+                        template = templates[choice - 1]
+                        break
+                    else:
+                        print(
+                            "[red]Invalid selection. Please choose a number from the list.[/red]"
+                        )
+                except (KeyboardInterrupt, EOFError):
+                    raise typer.Abort()
+                except ValueError:
+                    print("[red]Please enter a valid number.[/red]")
+
+        if template in git_templates:
+            project_name = template
+        else:
+            if project_name is None:
+                project_name = typing.cast(
+                    str,
+                    typer.prompt("What is your project's name?", get_project_name()),
+                )
 
         if not _is_valid_app_name(project_name):
             raise Exception(
                 f"{project_name} is an invalid DBOS app name. App names must be between 3 and 30 characters long and contain only lowercase letters, numbers, dashes, and underscores."
             )
 
-        templates_dir = _get_templates_directory()
-        templates = [x.name for x in os.scandir(templates_dir) if x.is_dir()]
-        if len(templates) == 0:
-            raise Exception(f"no DBOS templates found in {templates_dir} ")
-
-        if template == None:
-            if len(templates) == 1:
-                template = templates[0]
-            else:
-                template = Prompt.ask(
-                    "Which project template do you want to use?", choices=templates
-                )
+        if template in git_templates:
+            create_template_from_github(app_name=project_name, template_name=template)
         else:
-            if template not in templates:
-                raise Exception(f"template {template} not found in {templates_dir}")
-
-        _copy_template(
-            path.join(templates_dir, template), project_name, config_mode=config
-        )
+            copy_template(
+                path.join(templates_dir, template), project_name, config_mode=config
+            )
     except Exception as e:
         print(f"[red]{e}[/red]")
 

{dbos-0.20.0a2 → dbos-0.20.0a5}/pyproject.toml

@@ -27,13 +27,13 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.20.0a2"
+version = "0.20.0a5"
 
 [project.license]
 text = "MIT"
 
 [project.scripts]
-dbos = "dbos.cli:app"
+dbos = "dbos.cli.cli:app"
 
 [build-system]
 requires = [

{dbos-0.20.0a2 → dbos-0.20.0a5}/tests/conftest.py

@@ -118,15 +118,7 @@ def dbos_fastapi(
 ) -> Generator[Tuple[DBOS, FastAPI], Any, None]:
     DBOS.destroy()
     app = FastAPI()
-
-    # ignore the on_event deprecation warnings
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=r"\s*on_event is deprecated, use lifespan event handlers instead\.",
-        )
-        dbos = DBOS(fastapi=app, config=config)
+    dbos = DBOS(fastapi=app, config=config)
 
     # This is for test convenience.
     #    Usually fastapi itself does launch, but we are not completing the fastapi lifecycle

{dbos-0.20.0a2 → dbos-0.20.0a5}/tests/test_fastapi.py

@@ -1,14 +1,18 @@
+import asyncio
 import logging
 import uuid
-from typing import Tuple
+from contextlib import asynccontextmanager
+from typing import Any, Tuple
 
+import httpx
 import pytest
 import sqlalchemy as sa
+import uvicorn
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 
 # Public API
-from dbos import DBOS
+from dbos import DBOS, ConfigFile
 
 # Private API because this is a unit test
 from dbos._context import assert_current_dbos_context
@@ -157,3 +161,73 @@ def test_endpoint_recovery(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
     workflow_handles = DBOS.recover_pending_workflows()
     assert len(workflow_handles) == 1
     assert workflow_handles[0].get_result() == ("a", wfuuid)
+
+
+@pytest.mark.asyncio
+async def test_custom_lifespan(
+    config: ConfigFile, cleanup_test_databases: None
+) -> None:
+    resource = None
+    port = 8000
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> Any:
+        nonlocal resource
+        resource = 1
+        yield
+        resource = None
+
+    app = FastAPI(lifespan=lifespan)
+
+    DBOS.destroy()
+    DBOS(fastapi=app, config=config)
+
+    @app.get("/")
+    @DBOS.workflow()
+    async def resource_workflow() -> Any:
+        return {"resource": resource}
+
+    uvicorn_config = uvicorn.Config(
+        app=app, host="127.0.0.1", port=port, log_level="error"
+    )
+    server = uvicorn.Server(config=uvicorn_config)
+
+    # Run server in background task
+    server_task = asyncio.create_task(server.serve())
+    await asyncio.sleep(0.2)  # Give server time to start
+
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"http://127.0.0.1:{port}")
+        assert r.json()["resource"] == 1
+
+    server.should_exit = True
+    await server_task
+    assert resource is None
+
+
+def test_stacked_decorators_wf(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
+    dbos, app = dbos_fastapi
+    client = TestClient(app)
+
+    @app.get("/endpoint/{var1}/{var2}")
+    @DBOS.workflow()
+    async def test_endpoint(var1: str, var2: str) -> str:
+        return f"{var1}, {var2}!"
+
+    response = client.get("/endpoint/plums/deify")
+    assert response.status_code == 200
+    assert response.text == '"plums, deify!"'
+
+
+def test_stacked_decorators_step(dbos_fastapi: Tuple[DBOS, FastAPI]) -> None:
+    dbos, app = dbos_fastapi
+    client = TestClient(app)
+
+    @app.get("/endpoint/{var1}/{var2}")
+    @DBOS.step()
+    async def test_endpoint(var1: str, var2: str) -> str:
+        return f"{var1}, {var2}!"
+
+    response = client.get("/endpoint/plums/deify")
+    assert response.status_code == 200
+    assert response.text == '"plums, deify!"'

dbos-0.20.0a5/tests/test_package.py

@@ -0,0 +1,92 @@
+import json
+import os
+import shutil
+import signal
+import subprocess
+import tempfile
+import time
+import urllib.error
+import urllib.request
+
+import sqlalchemy as sa
+
+
+def test_package(build_wheel: str, postgres_db_engine: sa.Engine) -> None:
+
+    # Clean up the database from previous runs
+    for template_name in ["dbos-db-starter", "dbos-app-starter"]:
+        db_starter = template_name == "dbos-db-starter"
+        app_db_name = template_name.replace("-", "_")
+        with postgres_db_engine.connect() as connection:
+            connection.execution_options(isolation_level="AUTOCOMMIT")
+            connection.execute(sa.text(f"DROP DATABASE IF EXISTS {app_db_name}"))
+            connection.execute(
+                sa.text(f"DROP DATABASE IF EXISTS {app_db_name}_dbos_sys")
+            )
+
+        with tempfile.TemporaryDirectory() as temp_path:
+            temp_path = tempfile.mkdtemp(prefix="dbos-")
+            wheel_path = os.path.abspath(build_wheel)
+
+            # Create a new virtual environment in the temp directory
+            venv_path = os.path.join(temp_path, ".venv")
+            if os.path.exists(venv_path):
+                shutil.rmtree(venv_path)
+
+            # To create a venv, we need the system Python executable. TODO: Don't hardcode the path.
+            subprocess.check_call(
+                [os.path.join("/", "usr", "bin", "python3"), "-m", "venv", venv_path]
+            )
+
+            venv = os.environ.copy()
+            venv["PATH"] = f"{os.path.join(venv_path, 'bin')}:{venv['PATH']}"
+            venv["VIRTUAL_ENV"] = venv_path
+
+            # Install the dbos package into the virtual environment
+            subprocess.check_call(
+                ["pip", "install", wheel_path], cwd=temp_path, env=venv
+            )
+
+            # initalize the app with dbos scaffolding
+            subprocess.check_call(
+                ["dbos", "init", template_name, "--template", "dbos-db-starter"],
+                cwd=temp_path,
+                env=venv,
+            )
+
+            # Run schema migration
+            subprocess.check_call(["dbos", "migrate"], cwd=temp_path, env=venv)
+
+            # Launch the application in the virtual environment as a background process
+            process = subprocess.Popen(["dbos", "start"], cwd=temp_path, env=venv)
+
+            try:
+                url = "http://localhost:8000"
+                if db_starter:
+                    url += "/greeting/dbos"
+                max_retries = 10
+                for attempt in range(max_retries):
+                    try:
+                        with urllib.request.urlopen(url, timeout=1) as response:
+                            status_code = response.getcode()
+                            assert status_code == 200
+                            if db_starter:
+                                response_data = response.read().decode("utf-8")
+                                data = json.loads(response_data)
+                                assert (
+                                    data
+                                    == "Greetings, dbos! You have been greeted 1 times."
+                                )
+                            break
+                    except (urllib.error.URLError, AssertionError) as e:
+                        if attempt < max_retries - 1:  # If not the last attempt
+                            print(
+                                f"Attempt {attempt + 1} failed: {e}. Retrying in 1 second..."
+                            )
+                            time.sleep(1)
+                        else:
+                            print(f"All {max_retries} attempts failed. Last error: {e}")
+                            raise
+            finally:
+                os.kill(process.pid, signal.SIGINT)
+                process.wait()

dbos-0.20.0a2/tests/test_package.py

@@ -1,84 +0,0 @@
-import json
-import os
-import shutil
-import signal
-import subprocess
-import tempfile
-import time
-import urllib.error
-import urllib.request
-
-import sqlalchemy as sa
-
-# Public API
-from dbos import load_config
-
-# Private API because this is a unit test
-pass
-
-
-def test_package(build_wheel: str, postgres_db_engine: sa.Engine) -> None:
-
-    # Clean up the database from previous runs
-    app_db_name = "pkgtest"
-    with postgres_db_engine.connect() as connection:
-        connection.execution_options(isolation_level="AUTOCOMMIT")
-        connection.execute(sa.text(f"DROP DATABASE IF EXISTS {app_db_name}"))
-        connection.execute(sa.text(f"DROP DATABASE IF EXISTS {app_db_name}_dbos_sys"))
-
-    with tempfile.TemporaryDirectory() as temp_path:
-        temp_path = tempfile.mkdtemp(prefix="dbos-")
-        wheel_path = os.path.abspath(build_wheel)
-
-        # Create a new virtual environment in the temp directory
-        venv_path = os.path.join(temp_path, ".venv")
-        if os.path.exists(venv_path):
-            shutil.rmtree(venv_path)
-
-        # To create a venv, we need the system Python executable. TODO: Don't hardcode the path.
-        subprocess.check_call(
-            [os.path.join("/", "usr", "bin", "python3"), "-m", "venv", venv_path]
-        )
-
-        venv = os.environ.copy()
-        venv["PATH"] = f"{os.path.join(venv_path, 'bin')}:{venv['PATH']}"
-        venv["VIRTUAL_ENV"] = venv_path
-
-        # Install the dbos package into the virtual environment
-        subprocess.check_call(["pip", "install", wheel_path], cwd=temp_path, env=venv)
-
-        # initalize the app with dbos scaffolding
-        subprocess.check_call(
-            ["dbos", "init", "pkgtest", "--template", "hello"], cwd=temp_path, env=venv
-        )
-
-        # Run schema migration
-        subprocess.check_call(["dbos", "migrate"], cwd=temp_path, env=venv)
-
-        # Launch the application in the virtual environment as a background process
-        process = subprocess.Popen(["dbos", "start"], cwd=temp_path, env=venv)
-
-        try:
-            url = "http://localhost:8000/greeting/dbos"
-            max_retries = 10
-            for attempt in range(max_retries):
-                try:
-                    with urllib.request.urlopen(url, timeout=1) as response:
-                        status_code = response.getcode()
-                        assert status_code == 200
-                        response_data = response.read().decode("utf-8")
-                        data = json.loads(response_data)
-                        assert data == "Greetings, dbos! You have been greeted 1 times."
-                        break
-                except (urllib.error.URLError, AssertionError) as e:
-                    if attempt < max_retries - 1:  # If not the last attempt
-                        print(
-                            f"Attempt {attempt + 1} failed: {e}. Retrying in 1 second..."
-                        )
-                        time.sleep(1)
-                    else:
-                        print(f"All {max_retries} attempts failed. Last error: {e}")
-                        raise
-        finally:
-            os.kill(process.pid, signal.SIGINT)
-            process.wait()