dbos 0.5.0a7__tar.gz → 0.5.0a12__tar.gz

dbos-0.5.0a12/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.1
+Name: dbos
+Version: 0.5.0a12
+Summary: Ultra-lightweight durable execution in Python
+Author-Email: "DBOS, Inc." <contact@dbos.dev>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: jsonschema>=4.23.0
+Requires-Dist: alembic>=1.13.2
+Requires-Dist: psycopg2-binary>=2.9.9
+Requires-Dist: typing-extensions>=4.12.2; python_version < "3.10"
+Requires-Dist: typer>=0.12.3
+Requires-Dist: jsonpickle>=3.2.2
+Requires-Dist: opentelemetry-api>=1.26.0
+Requires-Dist: opentelemetry-sdk>=1.26.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.26.0
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: fastapi[standard]>=0.112.1
+Requires-Dist: psutil>=6.0.0
+Requires-Dist: tomlkit>=0.13.2
+Description-Content-Type: text/markdown
+
+## 🚀 DBOS Transact - Ultra-Lightweight Durable Execution in Python 🚀
+
+---
+
+📚 **Documentation**: Under Construction 🚧
+
+💬 **Join the Discussion**: [Discord Community](https://discord.gg/fMwQjeW5zg)
+
+---
+
+
+**DBOS Python is under construction! 🚧🚧🚧 Check back regularly for updates, release coming in mid-September!**
+
+DBOS Transact is a **Python library** providing ultra-lightweight durable execution.
+For example:
+
+```python
+@DBOS.step()
+def step_one():
+    ...
+
+@DBOS.step()
+def step_two():
+    ...
+
+@DBOS.workflow()
+def workflow()
+    step_one()
+    step_two()
+```
+
+Durable execution means your program is **resilient to any failure**.
+If it is ever interrupted or crashes, all your workflows will automatically resume from the last completed step.
+If you want to see durable execution in action, check out [this demo app](https://demo-widget-store.cloud.dbos.dev/) (source code [here](https://github.com/dbos-inc/dbos-demo-apps/tree/main/python/widget-store)).
+No matter how many times you try to crash it, it always resumes from exactly where it left off!
+
+Under the hood, DBOS Transact works by storing your program's execution state (which workflows are currently executing and which steps they've completed) in a Postgres database.
+So all you need to use it is a Postgres database to connect to&mdash;there's no need for a "workflow server."
+This approach is also incredibly fast, for example [25x faster than AWS Step Functions](https://www.dbos.dev/blog/dbos-vs-aws-step-functions-benchmark).
+
+Some more cool features include:
+
+- Scheduled jobs&mdash;run your workflows exactly-once per time interval.
+- Exactly-once event processing&mdash;use workflows to process incoming events (for example, from a Kafka topic) exactly-once.
+- Observability&mdash;all workflows automatically emit [OpenTelemetry](https://opentelemetry.io/) traces.
+
+## Getting Started
+
+To try out the latest pre-release version, install and configure with:
+
+```shell
+pip install --pre dbos
+dbos init --config
+```
+
+Try it out with this simple program (requires Postgres):
+
+```python
+from fastapi import FastAPI
+from dbos import DBOS
+
+app = FastAPI()
+DBOS(fastapi=app)
+
+@DBOS.step()
+def step_one():
+    print("Step one completed!")
+
+@DBOS.step()
+def step_two():
+    print("Step two completed!")
+
+@DBOS.workflow()
+def workflow():
+    step_one()
+    for _ in range(5):
+        print("Press Control + \ to stop the app...")
+        DBOS.sleep(1)
+    step_two()
+
+@app.get("/")
+def endpoint():
+    workflow()
+```
+
+Save the program into `main.py`, tell it your local Postgres password via `export PGPASSWORD=<your password>` and start it with `fastapi run`.
+Visit `localhost:8000` in your browser (or curl it) to start the workflow.
+When prompted, press `Control + \` to force quit your application.
+It should crash midway through the workflow, having completed step one but not step two.
+Then, restart your app with `fastapi run`.
+It should resume the workflow from where it left off, completing step two without re-executing step one.
+
+To learn how to build more complex examples, see our programming guide (coming soon).
+
+## Documentation
+
+Coming soon! 🚧
+
+## Examples
+
+Check out some cool demo apps here: [https://github.com/dbos-inc/dbos-demo-apps/tree/main/python](https://github.com/dbos-inc/dbos-demo-apps/tree/main/python)
+
+## Community
+
+If you're interested in building with us, please star our repository and join our community on [Discord](https://discord.gg/fMwQjeW5zg)!
+If you see a bug or have a feature request, don't hesitate to open an issue here on GitHub.
+If you're interested in contributing, check out our [contributions guide](./CONTRIBUTING.md).

dbos-0.5.0a12/README.md

@@ -0,0 +1,107 @@
+## 🚀 DBOS Transact - Ultra-Lightweight Durable Execution in Python 🚀
+
+---
+
+📚 **Documentation**: Under Construction 🚧
+
+💬 **Join the Discussion**: [Discord Community](https://discord.gg/fMwQjeW5zg)
+
+---
+
+
+**DBOS Python is under construction! 🚧🚧🚧 Check back regularly for updates, release coming in mid-September!**
+
+DBOS Transact is a **Python library** providing ultra-lightweight durable execution.
+For example:
+
+```python
+@DBOS.step()
+def step_one():
+    ...
+
+@DBOS.step()
+def step_two():
+    ...
+
+@DBOS.workflow()
+def workflow()
+    step_one()
+    step_two()
+```
+
+Durable execution means your program is **resilient to any failure**.
+If it is ever interrupted or crashes, all your workflows will automatically resume from the last completed step.
+If you want to see durable execution in action, check out [this demo app](https://demo-widget-store.cloud.dbos.dev/) (source code [here](https://github.com/dbos-inc/dbos-demo-apps/tree/main/python/widget-store)).
+No matter how many times you try to crash it, it always resumes from exactly where it left off!
+
+Under the hood, DBOS Transact works by storing your program's execution state (which workflows are currently executing and which steps they've completed) in a Postgres database.
+So all you need to use it is a Postgres database to connect to—there's no need for a "workflow server."
+This approach is also incredibly fast, for example [25x faster than AWS Step Functions](https://www.dbos.dev/blog/dbos-vs-aws-step-functions-benchmark).
+
+Some more cool features include:
+
+- Scheduled jobs—run your workflows exactly-once per time interval.
+- Exactly-once event processing—use workflows to process incoming events (for example, from a Kafka topic) exactly-once.
+- Observability—all workflows automatically emit [OpenTelemetry](https://opentelemetry.io/) traces.
+
+## Getting Started
+
+To try out the latest pre-release version, install and configure with:
+
+```shell
+pip install --pre dbos
+dbos init --config
+```
+
+Try it out with this simple program (requires Postgres):
+
+```python
+from fastapi import FastAPI
+from dbos import DBOS
+
+app = FastAPI()
+DBOS(fastapi=app)
+
+@DBOS.step()
+def step_one():
+    print("Step one completed!")
+
+@DBOS.step()
+def step_two():
+    print("Step two completed!")
+
+@DBOS.workflow()
+def workflow():
+    step_one()
+    for _ in range(5):
+        print("Press Control + \ to stop the app...")
+        DBOS.sleep(1)
+    step_two()
+
+@app.get("/")
+def endpoint():
+    workflow()
+```
+
+Save the program into `main.py`, tell it your local Postgres password via `export PGPASSWORD=<your password>` and start it with `fastapi run`.
+Visit `localhost:8000` in your browser (or curl it) to start the workflow.
+When prompted, press `Control + \` to force quit your application.
+It should crash midway through the workflow, having completed step one but not step two.
+Then, restart your app with `fastapi run`.
+It should resume the workflow from where it left off, completing step two without re-executing step one.
+
+To learn how to build more complex examples, see our programming guide (coming soon).
+
+## Documentation
+
+Coming soon! 🚧
+
+## Examples
+
+Check out some cool demo apps here: [https://github.com/dbos-inc/dbos-demo-apps/tree/main/python](https://github.com/dbos-inc/dbos-demo-apps/tree/main/python)
+
+## Community
+
+If you're interested in building with us, please star our repository and join our community on [Discord](https://discord.gg/fMwQjeW5zg)!
+If you see a bug or have a feature request, don't hesitate to open an issue here on GitHub.
+If you're interested in contributing, check out our [contributions guide](./CONTRIBUTING.md).

{dbos-0.5.0a7 → dbos-0.5.0a12}/dbos/admin_sever.py

@@ -28,11 +28,11 @@ class AdminServer:
         self.server_thread = threading.Thread(target=self.server.serve_forever)
         self.server_thread.daemon = True
 
-        dbos_logger.info("Starting DBOS admin server on port %d", self.port)
+        dbos_logger.debug("Starting DBOS admin server on port %d", self.port)
         self.server_thread.start()
 
     def stop(self) -> None:
-        dbos_logger.info("Stopping DBOS admin server")
+        dbos_logger.debug("Stopping DBOS admin server")
         self.server.shutdown()
         self.server.server_close()
         self.server_thread.join()

{dbos-0.5.0a7 → dbos-0.5.0a12}/dbos/cli.py

@@ -119,7 +119,7 @@ def copy_template_dir(src_dir: str, dst_dir: str, ctx: dict[str, str]) -> None:
                 shutil.copy(src, dst)
 
 
-def copy_template(src_dir: str, project_name: str) -> None:
+def copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
 
     dst_dir = path.abspath(".")
 
@@ -131,10 +131,17 @@ def copy_template(src_dir: str, project_name: str) -> None:
         "db_name": db_name,
     }
 
-    copy_template_dir(src_dir, dst_dir, ctx)
-    copy_template_dir(
-        path.join(src_dir, "__package"), path.join(dst_dir, package_name), ctx
-    )
+    if config_mode:
+        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]:
@@ -173,6 +180,10 @@ def init(
         typing.Optional[str],
         typer.Option("--template", "-t", help="Specify template to use"),
     ] = None,
+    config: Annotated[
+        bool,
+        typer.Option("--config", "-c", help="Only add dbos-config.yaml"),
+    ] = False,
 ) -> None:
     try:
         if project_name is None:
@@ -199,7 +210,9 @@ def init(
             if template not in templates:
                 raise Exception(f"template {template} not found in {templates_dir}")
 
-        copy_template(path.join(templates_dir, template), project_name)
+        copy_template(
+            path.join(templates_dir, template), project_name, config_mode=config
+        )
     except Exception as e:
         print(f"[red]{e}[/red]")
 

{dbos-0.5.0a7 → dbos-0.5.0a12}/dbos/context.py

@@ -8,13 +8,10 @@ from types import TracebackType
 from typing import TYPE_CHECKING, List, Literal, Optional, Type, TypedDict
 
 from opentelemetry.trace import Span, Status, StatusCode
-
-if TYPE_CHECKING:
-    from .fastapi import Request
-
 from sqlalchemy.orm import Session
 
 from .logger import dbos_logger
+from .request import Request
 from .tracer import dbos_tracer
 
 

{dbos-0.5.0a7 → dbos-0.5.0a12}/dbos/dbos.py

@@ -52,7 +52,7 @@ from .tracer import dbos_tracer
 
 if TYPE_CHECKING:
     from fastapi import FastAPI
-    from .fastapi import Request
+    from .request import Request
 
 from sqlalchemy.orm import Session
 
@@ -202,8 +202,9 @@ class DBOS:
 
     def __new__(
         cls: Type[DBOS],
-        fastapi: Optional["FastAPI"] = None,
+        *,
         config: Optional[ConfigFile] = None,
+        fastapi: Optional["FastAPI"] = None,
     ) -> DBOS:
         global _dbos_global_instance
         global _dbos_global_registry
@@ -239,8 +240,9 @@ class DBOS:
 
     def __init__(
         self,
-        fastapi: Optional["FastAPI"] = None,
+        *,
         config: Optional[ConfigFile] = None,
+        fastapi: Optional["FastAPI"] = None,
     ) -> None:
         if hasattr(self, "_initialized") and self._initialized:
             return
@@ -267,7 +269,8 @@ class DBOS:
             from dbos.fastapi import setup_fastapi_middleware
 
             setup_fastapi_middleware(self.fastapi)
-            self.fastapi.on_event("startup")(self.launch)
+            self.fastapi.on_event("startup")(self._launch)
+            self.fastapi.on_event("shutdown")(self._destroy)
 
         # Register send_stub as a workflow
         def send_temp_workflow(
@@ -313,7 +316,12 @@ class DBOS:
         rv: AdminServer = self._admin_server
         return rv
 
-    def launch(self) -> None:
+    @classmethod
+    def launch(cls) -> None:
+        if _dbos_global_instance is not None:
+            _dbos_global_instance._launch()
+
+    def _launch(self) -> None:
         if self._launched:
             dbos_logger.warning(f"DBOS was already launched")
             return
@@ -651,7 +659,7 @@ class DBOS:
 
     @classproperty
     def request(cls) -> Optional["Request"]:
-        """Return the FastAPI `Request`, if any, associated with the current context."""
+        """Return the HTTP `Request`, if any, associated with the current context."""
         ctx = assert_current_dbos_context()
         return ctx.request
 

{dbos-0.5.0a7 → dbos-0.5.0a12}/dbos/fastapi.py

@@ -11,6 +11,7 @@ from .context import (
     TracedAttributes,
     assert_current_dbos_context,
 )
+from .request import Address, Request
 
 request_id_header = "x-request-id"
 
@@ -23,31 +24,17 @@ def get_or_generate_request_id(request: FastAPIRequest) -> str:
         return str(uuid.uuid4())
 
 
-class Request:
-    """
-    Serializable subset of the FastAPI Request object.
-
-    Attributes:
-        base_url(URL): Base of URL requested, as in application code
-        client(Address): HTTP Client
-        cookies(Dict[str, str]): HTTP Cookies
-        headers(Headers): HTTP headers
-        method(str): HTTP verb
-        path_params(Dict[str,Any]): Parameters extracted from URL path sections
-        query_params(QueryParams): URL query string parameters
-        url(URL): Full URL accessed
-
-    """
-
-    def __init__(self, req: FastAPIRequest):
-        self.headers = req.headers
-        self.path_params = req.path_params
-        self.query_params = req.query_params
-        self.url = req.url
-        self.base_url = req.base_url
-        self.client = req.client
-        self.cookies = req.cookies
-        self.method = req.method
+def make_request(request: FastAPIRequest) -> Request:
+    return Request(
+        headers=request.headers,
+        path_params=request.path_params,
+        query_params=request.query_params,
+        url=str(request.url),
+        base_url=str(request.base_url),
+        client=Address(*request.client) if request.client is not None else None,
+        cookies=request.cookies,
+        method=request.method,
+    )
 
 
 def setup_fastapi_middleware(app: FastAPI) -> None:
@@ -65,7 +52,7 @@ def setup_fastapi_middleware(app: FastAPI) -> None:
         }
         with EnterDBOSHandler(attributes):
             ctx = assert_current_dbos_context()
-            ctx.request = Request(request)
+            ctx.request = make_request(request)
             workflow_id = request.headers.get("dbos-idempotency-key", "")
             with SetWorkflowID(workflow_id):
                 response = await call_next(request)

dbos-0.5.0a12/dbos/request.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Any, Mapping, NamedTuple, Optional
+
+
+class Address(NamedTuple):
+    hostname: str
+    port: int
+
+
+@dataclass
+class Request:
+    """
+    Serializable HTTP Request object.
+    Attributes:
+        base_url(str): Base of URL requested, as in application code
+        client(Optional[Address]): HTTP Client
+        cookies(Mapping[str, str]): HTTP Cookies
+        headers(Mapping[str, str]): HTTP headers
+        method(str): HTTP verb
+        path_params(Mapping[str, Any]): Parameters extracted from URL path sections
+        query_params(Mapping[str, str]): URL query string parameters
+        url(str): Full URL accessed
+    """
+
+    headers: Mapping[str, str]
+    path_params: Mapping[str, Any]
+    query_params: Mapping[str, str]
+    url: str
+    base_url: str
+    client: Optional[Address]
+    cookies: Mapping[str, str]
+    method: str

{dbos-0.5.0a7 → dbos-0.5.0a12}/dbos/system_database.py

@@ -230,7 +230,7 @@ class SystemDatabase:
     def wait_for_buffer_flush(self) -> None:
         # Wait until the buffers are flushed.
         while self._is_flushing_status_buffer or not self._is_buffers_empty:
-            dbos_logger.info("Waiting for system buffers to be exported")
+            dbos_logger.debug("Waiting for system buffers to be exported")
             time.sleep(1)
 
     def update_workflow_status(

{dbos-0.5.0a7 → dbos-0.5.0a12}/dbos/templates/hello/__package/main.py

@@ -15,7 +15,7 @@ from dbos import DBOS
 from .schema import dbos_hello
 
 app = FastAPI()
-DBOS(app)
+DBOS(fastapi=app)
 
 # Next, let's write a function that greets visitors.
 # To make it more interesting, we'll keep track of how

{dbos-0.5.0a7 → dbos-0.5.0a12}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "dbos"
 dynamic = []
-description = "A Python framework for backends that scale"
+description = "Ultra-lightweight durable execution in Python"
 authors = [
     { name = "DBOS, Inc.", email = "contact@dbos.dev" },
 ]
@@ -23,7 +23,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.5.0a7"
+version = "0.5.0a12"
 
 [project.license]
 text = "MIT"

{dbos-0.5.0a7 → dbos-0.5.0a12}/tests/conftest.py

@@ -1,6 +1,7 @@
 import glob
 import os
 import subprocess
+import warnings
 from typing import Any, Generator, Tuple
 
 import pytest
@@ -104,7 +105,7 @@ def dbos(
     # If your test is tricky and has a problem with this, use a different
     #   fixture that does not launch.
     dbos = DBOS(config=config)
-    dbos.launch()
+    DBOS.launch()
 
     yield dbos
     DBOS.destroy()
@@ -116,11 +117,19 @@ def dbos_fastapi(
 ) -> Generator[Tuple[DBOS, FastAPI], Any, None]:
     DBOS.destroy()
     app = FastAPI()
-    dbos = DBOS(fastapi=app, config=config)
+
+    # ignore the on_event deprecation warnings
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message="\s*on_event is deprecated, use lifespan event handlers instead\.",
+        )
+        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.launch()
+    DBOS.launch()
 
     yield dbos, app
     DBOS.destroy()

{dbos-0.5.0a7 → dbos-0.5.0a12}/tests/test_concurrency.py

@@ -34,24 +34,20 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     condition = threading.Condition()
     step_count = 0
     txn_count = 0
-    notified = False
 
     @DBOS.step()
     def test_step() -> str:
-        nonlocal step_count, notified
+        nonlocal step_count
+        condition.acquire()
         step_count += 1
-        if step_count == 1:
+        if step_count % 2 == 1:
             # Wait for the other one to notify
-            condition.acquire()
             condition.wait()
-            notified = True
-            condition.release()
         else:
-            while not notified:
-                condition.acquire()
-                condition.notify()
-                condition.release()
-                time.sleep(0.1)
+            # Notify the other one
+            condition.notify()
+        condition.release()
+
         return DBOS.workflow_id
 
     @DBOS.workflow()
@@ -67,20 +63,17 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     @DBOS.transaction(isolation_level="REPEATABLE READ")
     def test_transaction() -> str:
         DBOS.sql_session.execute(text("SELECT 1")).fetchall()
-        nonlocal txn_count, notified
+        nonlocal txn_count
+        condition.acquire()
         txn_count += 1
-        if txn_count == 1:
+        if txn_count % 2 == 1:
             # Wait for the other one to notify
-            condition.acquire()
             condition.wait()
-            notified = True
-            condition.release()
         else:
-            while not notified:
-                condition.acquire()
-                condition.notify()
-                condition.release()
-                time.sleep(0.1)
+            # Notify the other one
+            condition.notify()
+        condition.release()
+
         return DBOS.workflow_id
 
     def test_txn_thread(id: str) -> str:
@@ -99,8 +92,6 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
     assert wf_handle2.get_result() == wfuuid
 
     # Make sure temp workflows can handle conflicts as well.
-    step_count = 0
-    notified = False
     wfuuid = str(uuid.uuid4())
     with ThreadPoolExecutor(max_workers=2) as executor:
         future1 = executor.submit(test_comm_thread, wfuuid)
@@ -111,7 +102,6 @@ def test_concurrent_conflict_uuid(dbos: DBOS) -> None:
 
     # Make sure temp transactions can handle conflicts as well.
     wfuuid = str(uuid.uuid4())
-    notified = False
     with ThreadPoolExecutor(max_workers=2) as executor:
         future1 = executor.submit(test_txn_thread, wfuuid)
         future2 = executor.submit(test_txn_thread, wfuuid)

{dbos-0.5.0a7 → dbos-0.5.0a12}/tests/test_dbos.py

@@ -481,7 +481,7 @@ def test_recovery_thread(config: ConfigFile, dbos: DBOS) -> None:
             wf_counter += 1
         return var
 
-    dbos.launch()  # Usually the framework does this but we destroyed it above
+    DBOS.launch()  # Usually the framework does this but we destroyed it above
 
     # Upon re-initialization, the background thread should recover the workflow safely.
     max_retries = 10
@@ -685,7 +685,7 @@ def test_without_fastapi() -> None:
         sys.meta_path.remove(blocker)
 
     dbos = DBOS(config=config)
-    dbos.launch()
+    DBOS.launch()
 
     try:
 

{dbos-0.5.0a7 → dbos-0.5.0a12}/tests/test_schema_migration.py

@@ -65,7 +65,7 @@ def test_custom_sysdb_name_migration(
     # Test migrating up
     DBOS.destroy()  # In case of other tests leaving it
     dbos = DBOS(config=config)
-    dbos.launch()
+    DBOS.launch()
 
     # Make sure all tables exist
     with dbos.sys_db.engine.connect() as connection:

{dbos-0.5.0a7 → dbos-0.5.0a12}/tests/test_singleton.py

@@ -22,11 +22,11 @@ def test_dbos_singleton(cleanup_test_databases: None) -> None:
     #    then imports more
     from tests.classdefs import DBOSSendRecv, DBOSTestClass, DBOSTestRoles
 
-    dbos: DBOS = DBOS(None, default_config())
+    dbos: DBOS = DBOS(config=default_config())
 
     from tests.more_classdefs import DBOSWFEvents, wfFunc
 
-    dbos.launch()  # Usually framework (fastapi) does this via lifecycle event
+    DBOS.launch()  # Usually framework (fastapi) does this via lifecycle event
 
     # Basics
     with SetWorkflowID("wfid"):
@@ -120,11 +120,11 @@ def test_dbos_singleton_negative(cleanup_test_databases: None) -> None:
     #    then imports more
     from tests.classdefs import DBOSTestClass
 
-    dbos: DBOS = DBOS(None, default_config())
+    dbos: DBOS = DBOS(config=default_config())
 
     # Don't initialize DBOS twice
     with pytest.raises(Exception) as exc_info:
-        DBOS(None, default_config())
+        DBOS(config=default_config())
     assert "conflicting configuration" in str(exc_info.value)
 
     # Something should have launched
@@ -188,7 +188,7 @@ def test_config_before_singleton_negative(cleanup_test_databases: None) -> None:
 
         # Not OK, config already loaded in the default way
         with pytest.raises(Exception) as exc_info:
-            DBOS(None, config=default_config())
+            DBOS(config=default_config())
         assert "configured multiple" in str(exc_info.value)
     finally:
         DBOS.destroy()

dbos-0.5.0a7/PKG-INFO

@@ -1,78 +0,0 @@
-Metadata-Version: 2.1
-Name: dbos
-Version: 0.5.0a7
-Summary: A Python framework for backends that scale
-Author-Email: "DBOS, Inc." <contact@dbos.dev>
-License: MIT
-Requires-Python: >=3.9
-Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: jsonschema>=4.23.0
-Requires-Dist: alembic>=1.13.2
-Requires-Dist: psycopg2-binary>=2.9.9
-Requires-Dist: typing-extensions>=4.12.2; python_version < "3.10"
-Requires-Dist: typer>=0.12.3
-Requires-Dist: jsonpickle>=3.2.2
-Requires-Dist: opentelemetry-api>=1.26.0
-Requires-Dist: opentelemetry-sdk>=1.26.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.26.0
-Requires-Dist: python-dateutil>=2.9.0.post0
-Requires-Dist: fastapi[standard]>=0.112.1
-Requires-Dist: psutil>=6.0.0
-Requires-Dist: tomlkit>=0.13.2
-Description-Content-Type: text/markdown
-
-# DBOS Transact Python
-
-**DBOS Python is under construction! 🚧🚧🚧 Check back regularly for updates, release coming in mid-September!**
-
-DBOS Transact is a **Python library** for building durable and scalable applications.
-
-You want to use DBOS Transact in your application because you need:
-
-- **Resilience to any failure**.  If your app is interrupted for any reason, it automatically resumes from where it left off.  Reliable message delivery is built in. Idempotency is built in.
-- **Reliable event processing**. Need to consume Kafka events exactly-once? Just add one line of code to your app. Need to run a task exactly once per hour, day, or month? Just one more line of code.
-- **Built-in observability**. Automatically emit [OpenTelemetry](https://opentelemetry.io/)-compatible logs and traces from any application. Query your app's history from the command line or with SQL.
-- **Blazing-fast, developer-friendly serverless**.  Develop your project locally and run it anywhere. When you're ready, [deploy it for free to DBOS Cloud](https://docs.dbos.dev/getting-started/quickstart#deploying-to-dbos-cloud) and we'll host it for you, [25x faster](https://www.dbos.dev/blog/dbos-vs-aws-step-functions-benchmark) and [15x cheaper](https://www.dbos.dev/blog/dbos-vs-lambda-cost) than AWS Lambda.
-
-## Getting Started
-
-To try out the latest pre-release version, install with:
-
-```shell
-pip install --pre dbos
-```
-
-## Documentation
-
-Coming soon! 🚧
-
-But we have some cool demo apps for you to check out: [https://github.com/dbos-inc/dbos-demo-apps/tree/main/python](https://github.com/dbos-inc/dbos-demo-apps/tree/main/python)
-
-## Main Features
-
-Here are some of the core features of DBOS Transact:
-
-| Feature                                                                       | Description
-| ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| [Transactions](https://www.dbos.dev/dbos-transact-python)                                      | Easily and safely query your application database using [SQLAlchemy](https://www.sqlalchemy.org/) or raw SQL.
-| [Workflows](https://www.dbos.dev/dbos-transact-python)                                         | Reliable workflow orchestration&#8212;resume your program after any failure.
-| [Idempotency](https://www.dbos.dev/dbos-transact-python)                                       | Automatically make any request idempotent, so your requests happen exactly once.
-| [Authentication and Authorization](https://www.dbos.dev/dbos-transact-python)                  | Secure your HTTP endpoints so only authorized users can access them.
-| [Kafka Integration](https://www.dbos.dev/dbos-transact-python)                                 | Consume Kafka messages exactly-once with transactions or workflows.
-| [Scheduled Workflows](https://www.dbos.dev/dbos-transact-python)                               | Schedule your workflows to run exactly-once per time interval with cron-like syntax.
-| [Self-Hosting](https://www.dbos.dev/dbos-transact-python)                                      | Host your applications anywhere, as long as they have a Postgres database to connect to.
-
-And DBOS Cloud:
-
-| Feature                                                                       | Description
-| ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| [Serverless App Deployment](https://docs.dbos.dev/cloud-tutorials/application-management)      | Deploy apps to DBOS Cloud in minutes.
-| [Interactive Time Travel](https://docs.dbos.dev/cloud-tutorials/interactive-timetravel)        | Query your application database as of any past point in time.
-| [Cloud Database Management](https://docs.dbos.dev/cloud-tutorials/database-management)         | Provision cloud Postgres instances for your applications. Alternatively, [bring your own database](https://docs.dbos.dev/cloud-tutorials/byod-management).
-| [Built-in Observability](https://docs.dbos.dev/cloud-tutorials/monitoring-dashboard)           | Built-in log capture, request tracing, and dashboards.
-
-## Community
-
-If you're interested in building with us, please star our repository and join our community on [Discord](https://discord.gg/fMwQjeW5zg)!
-If you see a bug or have a feature request, don't hesitate to open an issue here on GitHub.
-If you're interested in contributing, check out our [contributions guide](./CONTRIBUTING.md).

dbos-0.5.0a7/README.md

@@ -1,55 +0,0 @@
-# DBOS Transact Python
-
-**DBOS Python is under construction! 🚧🚧🚧 Check back regularly for updates, release coming in mid-September!**
-
-DBOS Transact is a **Python library** for building durable and scalable applications.
-
-You want to use DBOS Transact in your application because you need:
-
-- **Resilience to any failure**.  If your app is interrupted for any reason, it automatically resumes from where it left off.  Reliable message delivery is built in. Idempotency is built in.
-- **Reliable event processing**. Need to consume Kafka events exactly-once? Just add one line of code to your app. Need to run a task exactly once per hour, day, or month? Just one more line of code.
-- **Built-in observability**. Automatically emit [OpenTelemetry](https://opentelemetry.io/)-compatible logs and traces from any application. Query your app's history from the command line or with SQL.
-- **Blazing-fast, developer-friendly serverless**.  Develop your project locally and run it anywhere. When you're ready, [deploy it for free to DBOS Cloud](https://docs.dbos.dev/getting-started/quickstart#deploying-to-dbos-cloud) and we'll host it for you, [25x faster](https://www.dbos.dev/blog/dbos-vs-aws-step-functions-benchmark) and [15x cheaper](https://www.dbos.dev/blog/dbos-vs-lambda-cost) than AWS Lambda.
-
-## Getting Started
-
-To try out the latest pre-release version, install with:
-
-```shell
-pip install --pre dbos
-```
-
-## Documentation
-
-Coming soon! 🚧
-
-But we have some cool demo apps for you to check out: [https://github.com/dbos-inc/dbos-demo-apps/tree/main/python](https://github.com/dbos-inc/dbos-demo-apps/tree/main/python)
-
-## Main Features
-
-Here are some of the core features of DBOS Transact:
-
-| Feature                                                                       | Description
-| ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| [Transactions](https://www.dbos.dev/dbos-transact-python)                                      | Easily and safely query your application database using [SQLAlchemy](https://www.sqlalchemy.org/) or raw SQL.
-| [Workflows](https://www.dbos.dev/dbos-transact-python)                                         | Reliable workflow orchestration—resume your program after any failure.
-| [Idempotency](https://www.dbos.dev/dbos-transact-python)                                       | Automatically make any request idempotent, so your requests happen exactly once.
-| [Authentication and Authorization](https://www.dbos.dev/dbos-transact-python)                  | Secure your HTTP endpoints so only authorized users can access them.
-| [Kafka Integration](https://www.dbos.dev/dbos-transact-python)                                 | Consume Kafka messages exactly-once with transactions or workflows.
-| [Scheduled Workflows](https://www.dbos.dev/dbos-transact-python)                               | Schedule your workflows to run exactly-once per time interval with cron-like syntax.
-| [Self-Hosting](https://www.dbos.dev/dbos-transact-python)                                      | Host your applications anywhere, as long as they have a Postgres database to connect to.
-
-And DBOS Cloud:
-
-| Feature                                                                       | Description
-| ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| [Serverless App Deployment](https://docs.dbos.dev/cloud-tutorials/application-management)      | Deploy apps to DBOS Cloud in minutes.
-| [Interactive Time Travel](https://docs.dbos.dev/cloud-tutorials/interactive-timetravel)        | Query your application database as of any past point in time.
-| [Cloud Database Management](https://docs.dbos.dev/cloud-tutorials/database-management)         | Provision cloud Postgres instances for your applications. Alternatively, [bring your own database](https://docs.dbos.dev/cloud-tutorials/byod-management).
-| [Built-in Observability](https://docs.dbos.dev/cloud-tutorials/monitoring-dashboard)           | Built-in log capture, request tracing, and dashboards.
-
-## Community
-
-If you're interested in building with us, please star our repository and join our community on [Discord](https://discord.gg/fMwQjeW5zg)!
-If you see a bug or have a feature request, don't hesitate to open an issue here on GitHub.
-If you're interested in contributing, check out our [contributions guide](./CONTRIBUTING.md).