dbos 0.5.0a12__py3-none-any.whl → 0.6.0__py3-none-any.whl

dbos/__init__.py

@@ -1,19 +1,17 @@
 from . import error as error
-from .context import SetWorkflowID as SetWorkflowID
-from .dbos import DBOS as DBOS
-from .dbos import DBOSConfiguredInstance as DBOSConfiguredInstance
-from .dbos import WorkflowHandle as WorkflowHandle
-from .dbos import WorkflowStatus as WorkflowStatus
-from .dbos_config import ConfigFile as ConfigFile
-from .dbos_config import get_dbos_database_url, load_config
-from .system_database import GetWorkflowsInput as GetWorkflowsInput
-from .system_database import WorkflowStatusString as WorkflowStatusString
+from .context import DBOSContextEnsure, SetWorkflowID
+from .dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle, WorkflowStatus
+from .dbos_config import ConfigFile, get_dbos_database_url, load_config
+from .kafka_message import KafkaMessage
+from .system_database import GetWorkflowsInput, WorkflowStatusString
 
 __all__ = [
     "ConfigFile",
     "DBOS",
     "DBOSConfiguredInstance",
+    "DBOSContextEnsure",
     "GetWorkflowsInput",
+    "KafkaMessage",
     "SetWorkflowID",
     "WorkflowHandle",
     "WorkflowStatus",

dbos/context.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 import uuid
 from contextvars import ContextVar
@@ -39,6 +40,9 @@ class TracedAttributes(TypedDict, total=False):
     applicationID: Optional[str]
     applicationVersion: Optional[str]
     executorID: Optional[str]
+    authenticatedUser: Optional[str]
+    authenticatedUserRoles: Optional[str]
+    authenticatedUserAssumedRole: Optional[str]
 
 
 class DBOSContext:
@@ -159,6 +163,13 @@ class DBOSContext:
         attributes["operationUUID"] = (
             self.workflow_id if len(self.workflow_id) > 0 else None
         )
+        attributes["authenticatedUser"] = self.authenticated_user
+        attributes["authenticatedUserRoles"] = (
+            json.dumps(self.authenticated_roles)
+            if self.authenticated_roles is not None
+            else ""
+        )
+        attributes["authenticatedUserAssumedRole"] = self.assumed_role
         span = dbos_tracer.start_span(
             attributes, parent=self.spans[-1] if len(self.spans) > 0 else None
         )
@@ -178,6 +189,11 @@ class DBOSContext:
     ) -> None:
         self.authenticated_user = user
         self.authenticated_roles = roles
+        if user is not None and len(self.spans) > 0:
+            self.spans[-1].set_attribute("authenticatedUser", user)
+            self.spans[-1].set_attribute(
+                "authenticatedUserRoles", json.dumps(roles) if roles is not None else ""
+            )
 
 
 ##############################################################
@@ -217,13 +233,13 @@ class DBOSContextEnsure:
     def __init__(self) -> None:
         self.created_ctx = False
 
-    def __enter__(self) -> DBOSContextEnsure:
+    def __enter__(self) -> DBOSContext:
         # Code to create a basic context
         ctx = get_local_dbos_context()
         if ctx is None:
             self.created_ctx = True
             set_local_dbos_context(DBOSContext())
-        return self
+        return assert_current_dbos_context()
 
     def __exit__(
         self,

dbos/core.py

@@ -1,9 +1,20 @@
+import json
 import sys
 import time
 import traceback
 from concurrent.futures import Future
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, Tuple, TypeVar, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    TypeVar,
+    cast,
+)
 
 from dbos.application_database import ApplicationDatabase, TransactionResultInternal
 
@@ -134,6 +145,11 @@ def _init_workflow(
         "executor_id": ctx.executor_id,
         "request": (utils.serialize(ctx.request) if ctx.request is not None else None),
         "recovery_attempts": None,
+        "authenticated_user": ctx.authenticated_user,
+        "authenticated_roles": (
+            json.dumps(ctx.authenticated_roles) if ctx.authenticated_roles else None
+        ),
+        "assumed_role": ctx.assumed_role,
     }
 
     # If we have a class name, the first arg is the instance and do not serialize

dbos/dbos.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import atexit
+import json
 import os
 import sys
 import threading
@@ -19,6 +20,7 @@ from typing import (
     Tuple,
     Type,
     TypeVar,
+    cast,
 )
 
 from opentelemetry.trace import Span
@@ -52,10 +54,14 @@ from .tracer import dbos_tracer
 
 if TYPE_CHECKING:
     from fastapi import FastAPI
+    from dbos.kafka import KafkaConsumerWorkflow
     from .request import Request
+    from flask import Flask
 
 from sqlalchemy.orm import Session
 
+from dbos.request import Request
+
 if sys.version_info < (3, 10):
     from typing_extensions import ParamSpec, TypeAlias
 else:
@@ -205,6 +211,7 @@ class DBOS:
         *,
         config: Optional[ConfigFile] = None,
         fastapi: Optional["FastAPI"] = None,
+        flask: Optional["Flask"] = None,
     ) -> DBOS:
         global _dbos_global_instance
         global _dbos_global_registry
@@ -219,7 +226,7 @@ class DBOS:
                     )
                 config = _dbos_global_registry.config
             _dbos_global_instance = super().__new__(cls)
-            _dbos_global_instance.__init__(fastapi=fastapi, config=config)  # type: ignore
+            _dbos_global_instance.__init__(fastapi=fastapi, config=config, flask=flask)  # type: ignore
         else:
             if (config is not None and _dbos_global_instance.config is not config) or (
                 _dbos_global_instance.fastapi is not fastapi
@@ -243,6 +250,7 @@ class DBOS:
         *,
         config: Optional[ConfigFile] = None,
         fastapi: Optional["FastAPI"] = None,
+        flask: Optional["Flask"] = None,
     ) -> None:
         if hasattr(self, "_initialized") and self._initialized:
             return
@@ -264,14 +272,44 @@ class DBOS:
         self._admin_server: Optional[AdminServer] = None
         self.stop_events: List[threading.Event] = []
         self.fastapi: Optional["FastAPI"] = fastapi
+        self.flask: Optional["Flask"] = flask
         self._executor: Optional[ThreadPoolExecutor] = None
+
+        # If using FastAPI, set up middleware and lifecycle events
         if self.fastapi is not None:
+            from fastapi.requests import Request as FARequest
+            from fastapi.responses import JSONResponse
+
+            async def dbos_error_handler(
+                request: FARequest, gexc: Exception
+            ) -> JSONResponse:
+                exc: DBOSException = cast(DBOSException, gexc)
+                status_code = 500
+                if exc.status_code is not None:
+                    status_code = exc.status_code
+                return JSONResponse(
+                    status_code=status_code,
+                    content={
+                        "message": str(exc.message),
+                        "dbos_error_code": str(exc.dbos_error_code),
+                        "dbos_error": str(exc.__class__.__name__),
+                    },
+                )
+
+            self.fastapi.add_exception_handler(DBOSException, dbos_error_handler)
+
             from dbos.fastapi import setup_fastapi_middleware
 
             setup_fastapi_middleware(self.fastapi)
             self.fastapi.on_event("startup")(self._launch)
             self.fastapi.on_event("shutdown")(self._destroy)
 
+        # If using Flask, set up middleware
+        if self.flask is not None:
+            from dbos.flask import setup_flask_middleware
+
+            setup_flask_middleware(self.flask)
+
         # Register send_stub as a workflow
         def send_temp_workflow(
             destination_id: str, message: Any, topic: Optional[str]
@@ -471,6 +509,20 @@ class DBOS:
 
         return scheduled(_get_or_create_dbos_registry(), cron)
 
+    @classmethod
+    def kafka_consumer(
+        cls, config: dict[str, Any], topics: list[str]
+    ) -> Callable[[KafkaConsumerWorkflow], KafkaConsumerWorkflow]:
+        """Decorate a function to be used as a Kafka consumer."""
+        try:
+            from dbos.kafka import kafka_consumer
+
+            return kafka_consumer(_get_or_create_dbos_registry(), config, topics)
+        except ModuleNotFoundError as e:
+            raise DBOSException(
+                f"{e.name} dependency not found. Please install {e.name} via your package manager."
+            ) from e
+
     @classmethod
     def start_workflow(
         cls,
@@ -502,9 +554,13 @@ class DBOS:
             recovery_attempts=stat["recovery_attempts"],
             class_name=stat["class_name"],
             config_name=stat["config_name"],
-            authenticated_user=None,
-            assumed_role=None,
-            authenticatedRoles=None,
+            authenticated_user=stat["authenticated_user"],
+            assumed_role=stat["assumed_role"],
+            authenticated_roles=(
+                json.loads(stat["authenticated_roles"])
+                if stat["authenticated_roles"] is not None
+                else None
+            ),
         )
 
     @classmethod
@@ -663,6 +719,33 @@ class DBOS:
         ctx = assert_current_dbos_context()
         return ctx.request
 
+    @classproperty
+    def authenticated_user(cls) -> Optional[str]:
+        """Return the current authenticated user, if any, associated with the current context."""
+        ctx = assert_current_dbos_context()
+        return ctx.authenticated_user
+
+    @classproperty
+    def authenticated_roles(cls) -> Optional[List[str]]:
+        """Return the roles granted to the current authenticated user, if any, associated with the current context."""
+        ctx = assert_current_dbos_context()
+        return ctx.authenticated_roles
+
+    @classproperty
+    def assumed_role(cls) -> Optional[str]:
+        """Return the role currently assumed by the authenticated user, if any, associated with the current context."""
+        ctx = assert_current_dbos_context()
+        return ctx.assumed_role
+
+    @classmethod
+    def set_authentication(
+        cls, authenticated_user: Optional[str], authenticated_roles: Optional[List[str]]
+    ) -> None:
+        """Set the current authenticated user and granted roles into the current context."""
+        ctx = assert_current_dbos_context()
+        ctx.authenticated_user = authenticated_user
+        ctx.authenticated_roles = authenticated_roles
+
 
 @dataclass
 class WorkflowStatus:
@@ -679,7 +762,7 @@ class WorkflowStatus:
         config_name(str): For instance member functions, the name of the class instance for the execution
         authenticated_user(str): The user who invoked the workflow
         assumed_role(str): The access role used by the user to allow access to the workflow function
-        authenticatedRoles(List[str]): List of all access roles available to the authenticated user
+        authenticated_roles(List[str]): List of all access roles available to the authenticated user
         recovery_attempts(int): Number of times the workflow has been restarted (usually by recovery)
 
     """
@@ -691,7 +774,7 @@ class WorkflowStatus:
     config_name: Optional[str]
     authenticated_user: Optional[str]
     assumed_role: Optional[str]
-    authenticatedRoles: Optional[List[str]]
+    authenticated_roles: Optional[List[str]]
     recovery_attempts: Optional[int]
 
 
@@ -740,13 +823,9 @@ class DBOSConfiguredInstance:
 
     """
 
-    def __init__(self, config_name: str, dbos: Optional[DBOS] = None) -> None:
+    def __init__(self, config_name: str) -> None:
         self.config_name = config_name
-        if dbos is not None:
-            assert isinstance(dbos, DBOS)
-            dbos._registry.register_instance(self)
-        else:
-            DBOS.register_instance(self)
+        DBOS.register_instance(self)
 
 
 # Apps that import DBOS probably don't exit.  If they do, let's see if

dbos/dbos_config.py

@@ -69,6 +69,7 @@ class ConfigFile(TypedDict, total=False):
     database: DatabaseConfig
     telemetry: Optional[TelemetryConfig]
     env: Dict[str, str]
+    application: Dict[str, Any]
 
 
 def substitute_env_vars(content: str) -> str:

dbos/error.py

@@ -17,6 +17,7 @@ class DBOSException(Exception):
     def __init__(self, message: str, dbos_error_code: Optional[int] = None):
         self.message = message
         self.dbos_error_code = dbos_error_code
+        self.status_code: Optional[int] = None
         super().__init__(self.message)
 
     def __str__(self) -> str:
@@ -104,6 +105,7 @@ class DBOSNotAuthorizedError(DBOSException):
             msg,
             dbos_error_code=DBOSErrorCode.NotAuthorized.value,
         )
+        self.status_code = 403
 
 
 class DBOSMaxStepRetriesExceeded(DBOSException):

dbos/fastapi.py

@@ -11,9 +11,7 @@ from .context import (
     TracedAttributes,
     assert_current_dbos_context,
 )
-from .request import Address, Request
-
-request_id_header = "x-request-id"
+from .request import Address, Request, request_id_header
 
 
 def get_or_generate_request_id(request: FastAPIRequest) -> str:

dbos/flask.py

@@ -0,0 +1,79 @@
+import uuid
+from typing import Any
+from urllib.parse import urlparse
+
+from flask import Flask, request
+from werkzeug.wrappers import Request as WRequest
+
+from dbos.context import (
+    EnterDBOSHandler,
+    OperationType,
+    SetWorkflowID,
+    TracedAttributes,
+    assert_current_dbos_context,
+)
+
+from .request import Address, Request, request_id_header
+
+
+class FlaskMiddleware:
+    def __init__(self, app: Any) -> None:
+        self.app = app
+
+    def __call__(self, environ: Any, start_response: Any) -> Any:
+        request = WRequest(environ)
+        attributes: TracedAttributes = {
+            "name": urlparse(request.url).path,
+            "requestID": get_or_generate_request_id(request),
+            "requestIP": (
+                request.remote_addr if request.remote_addr is not None else None
+            ),
+            "requestURL": request.url,
+            "requestMethod": request.method,
+            "operationType": OperationType.HANDLER.value,
+        }
+        with EnterDBOSHandler(attributes):
+            ctx = assert_current_dbos_context()
+            ctx.request = make_request(request)
+            workflow_id = request.headers.get("dbos-idempotency-key", "")
+            with SetWorkflowID(workflow_id):
+                response = self.app(environ, start_response)
+        return response
+
+
+def get_or_generate_request_id(request: WRequest) -> str:
+    request_id = request.headers.get(request_id_header, None)
+    if request_id is not None:
+        return request_id
+    else:
+        return str(uuid.uuid4())
+
+
+def make_request(request: WRequest) -> Request:
+    parsed_url = urlparse(request.url)
+    base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+
+    client = None
+    if request.remote_addr:
+        hostname = request.remote_addr
+        port = request.environ.get("REMOTE_PORT")
+        if port:
+            client = Address(hostname=hostname, port=int(port))
+        else:
+            # If port is not available, use 0 as a placeholder
+            client = Address(hostname=hostname, port=0)
+
+    return Request(
+        headers=dict(request.headers),
+        path_params={},
+        query_params=dict(request.args),
+        url=request.url,
+        base_url=base_url,
+        client=client,
+        cookies=dict(request.cookies),
+        method=request.method,
+    )
+
+
+def setup_flask_middleware(app: Flask) -> None:
+    app.wsgi_app = FlaskMiddleware(app.wsgi_app)  # type: ignore

dbos/kafka.py

@@ -0,0 +1,94 @@
+import threading
+import traceback
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable, Generator, NoReturn, Optional, Union
+
+from confluent_kafka import Consumer, KafkaError, KafkaException
+from confluent_kafka import Message as CTypeMessage
+
+if TYPE_CHECKING:
+    from dbos.dbos import _DBOSRegistry
+
+from .context import SetWorkflowID
+from .kafka_message import KafkaMessage
+from .logger import dbos_logger
+
+KafkaConsumerWorkflow = Callable[[KafkaMessage], None]
+
+
+def _kafka_consumer_loop(
+    func: KafkaConsumerWorkflow,
+    config: dict[str, Any],
+    topics: list[str],
+    stop_event: threading.Event,
+) -> None:
+
+    def on_error(err: KafkaError) -> NoReturn:
+        raise KafkaException(err)
+
+    config["error_cb"] = on_error
+    if "auto.offset.reset" not in config:
+        config["auto.offset.reset"] = "earliest"
+
+    consumer = Consumer(config)
+    try:
+        consumer.subscribe(topics)
+        while not stop_event.is_set():
+            cmsg = consumer.poll(1.0)
+
+            if stop_event.is_set():
+                return
+
+            if cmsg is None:
+                continue
+
+            err = cmsg.error()
+            if err is not None:
+                dbos_logger.error(
+                    f"Kafka error {err.code()} ({err.name()}): {err.str()}"
+                )
+                # fatal errors require an updated consumer instance
+                if err.code() == KafkaError._FATAL or err.fatal():
+                    original_consumer = consumer
+                    try:
+                        consumer = Consumer(config)
+                        consumer.subscribe(topics)
+                    finally:
+                        original_consumer.close()
+            else:
+                msg = KafkaMessage(
+                    headers=cmsg.headers(),
+                    key=cmsg.key(),
+                    latency=cmsg.latency(),
+                    leader_epoch=cmsg.leader_epoch(),
+                    offset=cmsg.offset(),
+                    partition=cmsg.partition(),
+                    timestamp=cmsg.timestamp(),
+                    topic=cmsg.topic(),
+                    value=cmsg.value(),
+                )
+                with SetWorkflowID(
+                    f"kafka-unique-id-{msg.topic}-{msg.partition}-{msg.offset}"
+                ):
+                    try:
+                        func(msg)
+                    except Exception as e:
+                        dbos_logger.error(
+                            f"Exception encountered in Kafka consumer: {traceback.format_exc()}"
+                        )
+
+    finally:
+        consumer.close()
+
+
+def kafka_consumer(
+    dbosreg: "_DBOSRegistry", config: dict[str, Any], topics: list[str]
+) -> Callable[[KafkaConsumerWorkflow], KafkaConsumerWorkflow]:
+    def decorator(func: KafkaConsumerWorkflow) -> KafkaConsumerWorkflow:
+        stop_event = threading.Event()
+        dbosreg.register_poller(
+            stop_event, _kafka_consumer_loop, func, config, topics, stop_event
+        )
+        return func
+
+    return decorator

dbos/kafka_message.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from typing import Optional, Union
+
+
+@dataclass
+class KafkaMessage:
+    headers: Optional[list[tuple[str, Union[str, bytes]]]]
+    key: Optional[Union[str, bytes]]
+    latency: Optional[float]
+    leader_epoch: Optional[int]
+    offset: Optional[int]
+    partition: Optional[int]
+    timestamp: tuple[int, int]
+    topic: Optional[str]
+    value: Optional[Union[str, bytes]]

dbos/request.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass
 from typing import Any, Mapping, NamedTuple, Optional
 
+request_id_header = "x-request-id"
+
 
 class Address(NamedTuple):
     hostname: str

dbos/roles.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Any, Callable, List, Optional, Type, TypeVar,
 from dbos.error import DBOSNotAuthorizedError
 
 if TYPE_CHECKING:
-    from dbos.dbos import DBOS, _DBOSRegistry
+    from dbos.dbos import _DBOSRegistry
 
 from dbos.context import DBOSAssumeRole, get_local_dbos_context
 from dbos.registrations import (

dbos/system_database.py

@@ -4,18 +4,7 @@ import select
 import threading
 import time
 from enum import Enum
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Sequence,
-    Set,
-    TypedDict,
-    cast,
-)
+from typing import Any, Dict, List, Literal, Optional, Sequence, Set, TypedDict, cast
 
 import psycopg2
 import sqlalchemy as sa
@@ -69,6 +58,9 @@ class WorkflowStatusInternal(TypedDict):
     app_id: Optional[str]
     request: Optional[str]  # JSON (jsonpickle)
     recovery_attempts: Optional[int]
+    authenticated_user: Optional[str]
+    assumed_role: Optional[str]
+    authenticated_roles: Optional[str]  # JSON list of roles.
 
 
 class RecordedResult(TypedDict):
@@ -136,7 +128,7 @@ class WorkflowInformation(TypedDict, total=False):
     authenticated_user: str  # The user who ran the workflow. Empty string if not set.
     assumed_role: str
     # The role used to run this workflow.  Empty string if authorization is not required.
-    authenticatedRoles: List[str]
+    authenticated_roles: List[str]
     # All roles the authenticated user has, if any.
     input: Optional[WorkflowInputs]
     output: Optional[str]
@@ -252,6 +244,9 @@ class SystemDatabase:
             application_version=status["app_version"],
             application_id=status["app_id"],
             request=status["request"],
+            authenticated_user=status["authenticated_user"],
+            authenticated_roles=status["authenticated_roles"],
+            assumed_role=status["assumed_role"],
         )
         if replace:
             cmd = cmd.on_conflict_do_update(
@@ -322,6 +317,9 @@ class SystemDatabase:
                     SystemSchema.workflow_status.c.recovery_attempts,
                     SystemSchema.workflow_status.c.config_name,
                     SystemSchema.workflow_status.c.class_name,
+                    SystemSchema.workflow_status.c.authenticated_user,
+                    SystemSchema.workflow_status.c.authenticated_roles,
+                    SystemSchema.workflow_status.c.assumed_role,
                 ).where(SystemSchema.workflow_status.c.workflow_uuid == workflow_uuid)
             ).fetchone()
             if row is None:
@@ -339,6 +337,9 @@ class SystemDatabase:
                 "executor_id": None,
                 "request": row[2],
                 "recovery_attempts": row[3],
+                "authenticated_user": row[6],
+                "authenticated_roles": row[7],
+                "assumed_role": row[8],
             }
             return status
 
@@ -375,6 +376,9 @@ class SystemDatabase:
                     SystemSchema.workflow_status.c.error,
                     SystemSchema.workflow_status.c.config_name,
                     SystemSchema.workflow_status.c.class_name,
+                    SystemSchema.workflow_status.c.authenticated_user,
+                    SystemSchema.workflow_status.c.authenticated_roles,
+                    SystemSchema.workflow_status.c.assumed_role,
                 ).where(SystemSchema.workflow_status.c.workflow_uuid == workflow_uuid)
             ).fetchone()
             if row is None:
@@ -392,6 +396,9 @@ class SystemDatabase:
                 "executor_id": None,
                 "request": row[2],
                 "recovery_attempts": None,
+                "authenticated_user": row[7],
+                "authenticated_roles": row[8],
+                "assumed_role": row[9],
             }
             return status
 

dbos/templates/hello/__package/main.py

@@ -2,13 +2,12 @@
 
 # This is a sample app built with DBOS and FastAPI.
 # It displays greetings to visitors and keeps track of how
-# many times each visitor has been greeted.
+# many times visitors have been greeted.
 
 # First, let's do imports, create a FastAPI app, and initialize DBOS.
 
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
-from sqlalchemy.dialects.postgresql import insert
 
 from dbos import DBOS
 
@@ -19,33 +18,26 @@ DBOS(fastapi=app)
 
 # Next, let's write a function that greets visitors.
 # To make it more interesting, we'll keep track of how
-# many times each visitor has been greeted and store
+# many times visitors have been greeted and store
 # the count in the database.
 
-# We annotate this function with @DBOS.transaction to
-# access to an automatically-configured database client,
-# (DBOS.sql_sesion) then implement the database operations
-# using SQLAlchemy. We serve this function from a FastAPI endpoint.
+# We implement the database operations using SQLAlchemy
+# and serve the function from a FastAPI endpoint.
+# We annotate it with @DBOS.transaction() to access
+# an automatically-configured database client.
 
 
 @app.get("/greeting/{name}")
 @DBOS.transaction()
 def example_transaction(name: str) -> str:
-    query = (
-        insert(dbos_hello)
-        .values(name="dbos", greet_count=1)
-        .on_conflict_do_update(
-            index_elements=["name"], set_={"greet_count": dbos_hello.c.greet_count + 1}
-        )
-        .returning(dbos_hello.c.greet_count)
-    )
+    query = dbos_hello.insert().values(name=name).returning(dbos_hello.c.greet_count)
     greet_count = DBOS.sql_session.execute(query).scalar_one()
     greeting = f"Greetings, {name}! You have been greeted {greet_count} times."
     DBOS.logger.info(greeting)
     return greeting
 
 
-# Finally, let's use FastAPI to serve a simple HTML readme
+# Finally, let's use FastAPI to serve an HTML + CSS readme
 # from the root path.
 
 
@@ -74,13 +66,14 @@ def readme() -> HTMLResponse:
     return HTMLResponse(readme)
 
 
-# To run this app locally:
-# - Make sure you have a Postgres database to connect
-# - "dbos migrate" to set up your database tables
-# - "dbos start" to start the app
-# - Visit localhost:8000 to see your app!
-
 # To deploy this app to DBOS Cloud:
 # - "npm i -g @dbos-inc/dbos-cloud@latest" to install the Cloud CLI (requires Node)
 # - "dbos-cloud app deploy" to deploy your app
 # - Deploy outputs a URL--visit it to see your app!
+
+
+# To run this app locally:
+# - Make sure you have a Postgres database to connect to
+# - "dbos migrate" to set up your database tables
+# - "dbos start" to start the app
+# - Visit localhost:8000 to see your app!

dbos/templates/hello/__package/schema.py

@@ -5,6 +5,6 @@ metadata = MetaData()
 dbos_hello = Table(
     "dbos_hello",
     metadata,
-    Column("name", String, primary_key=True),
-    Column("greet_count", Integer, default=0),
+    Column("greet_count", Integer, primary_key=True, autoincrement=True),
+    Column("name", String, nullable=False),
 )

dbos/templates/hello/migrations/versions/2024_07_31_180642_init.py

@@ -22,9 +22,9 @@ def upgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
     op.create_table(
         "dbos_hello",
+        sa.Column("greet_count", sa.Integer(), autoincrement=True, nullable=False),
         sa.Column("name", sa.String(), nullable=False),
-        sa.Column("greet_count", sa.Integer(), nullable=True),
-        sa.PrimaryKeyConstraint("name"),
+        sa.PrimaryKeyConstraint("greet_count"),
     )
     # ### end Alembic commands ###
 

dbos/tracer.py

@@ -19,6 +19,7 @@ class DBOSTracer:
         self.app_id = os.environ.get("DBOS__APPID", None)
         self.app_version = os.environ.get("DBOS__APPVERSION", None)
         self.executor_id = os.environ.get("DBOS__VMID", "local")
+        self.provider: Optional[TracerProvider] = None
 
     def config(self, config: ConfigFile) -> None:
         if not isinstance(trace.get_tracer_provider(), TracerProvider):
@@ -36,10 +37,17 @@ class DBOSTracer:
                 provider.add_span_processor(processor)
             trace.set_tracer_provider(provider)
 
+    def set_provider(self, provider: Optional[TracerProvider]) -> None:
+        self.provider = provider
+
     def start_span(
         self, attributes: "TracedAttributes", parent: Optional[Span] = None
     ) -> Span:
-        tracer = trace.get_tracer("dbos-tracer")
+        tracer = (
+            self.provider.get_tracer("dbos-tracer")
+            if self.provider is not None
+            else trace.get_tracer("dbos-tracer")
+        )
         context = trace.set_span_in_context(parent) if parent else None
         span: Span = tracer.start_span(name=attributes["name"], context=context)
         attributes["applicationID"] = self.app_id

{dbos-0.5.0a12.dist-info → dbos-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.5.0a12
+Version: 0.6.0
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT
@@ -21,20 +21,17 @@ 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 🚀
 
----
+<div align="center">
 
-📚 **Documentation**: Under Construction 🚧
+# DBOS Transact: Ultra-Lightweight Durable Execution
 
-💬 **Join the Discussion**: [Discord Community](https://discord.gg/fMwQjeW5zg)
+#### [Documentation](https://docs.dbos.dev/) &nbsp;&nbsp;•&nbsp;&nbsp;  [Examples](https://docs.dbos.dev/examples) &nbsp;&nbsp;•&nbsp;&nbsp; [Github](https://github.com/dbos-inc) &nbsp;&nbsp;•&nbsp;&nbsp; [Discord](https://discord.com/invite/jsmC6pXGgX)
+</div>
 
 ---
 
-
-**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.
+DBOS Transact is a Python library providing **ultra-lightweight durable execution**.
 For example:
 
 ```python
@@ -69,14 +66,14 @@ Some more cool features include:
 
 ## Getting Started
 
-To try out the latest pre-release version, install and configure with:
+Install and configure with:
 
 ```shell
-pip install --pre dbos
+pip install dbos
 dbos init --config
 ```
 
-Try it out with this simple program (requires Postgres):
+Then, try it out with this simple program (requires Postgres):
 
 ```python
 from fastapi import FastAPI
@@ -106,22 +103,27 @@ 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.
+Save the program into `main.py`, edit `dbos-config.yaml` to configure your Postgres connection settings, and start it with `fastapi run`.
+Visit `localhost:8000` in your browser 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).
+To learn how to build more complex workflows, see our [programming guide](https://docs.dbos.dev/python/programming-guide) or [examples](https://docs.dbos.dev/examples).
 
 ## Documentation
 
-Coming soon! 🚧
+[https://docs.dbos.dev](https://docs.dbos.dev)
 
 ## 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)
+
+- [**AI-Powered Slackbot**](https://docs.dbos.dev/python/examples/rag-slackbot) &mdash; A Slackbot that answers questions about previous Slack conversations, using DBOS to durably orchestrate its RAG pipeline.
+- [**Widget Store**](https://docs.dbos.dev/python/examples/widget-store) &mdash; An online storefront that uses DBOS durable workflows to be resilient to any failure.
+- [**Earthquake Tracker**](https://docs.dbos.dev/python/examples/earthquake-tracker) &mdash; A real-time earthquake dashboard that uses DBOS to stream data from the USGS into Postgres, then visualizes it with Streamlit.
+
+More examples [here](https://docs.dbos.dev/examples)!
 
 ## Community
 

{dbos-0.5.0a12.dist-info → dbos-0.6.0.dist-info}/RECORD

@@ -1,19 +1,22 @@
-dbos-0.5.0a12.dist-info/METADATA,sha256=w33L3epCZ1uqAdgc-4WZftuNGB61yVGSchxW_j13BFI,4444
-dbos-0.5.0a12.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
-dbos-0.5.0a12.dist-info/entry_points.txt,sha256=3PmOPbM4FYxEmggRRdJw0oAsiBzKR8U0yx7bmwUmMOM,39
-dbos-0.5.0a12.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
-dbos/__init__.py,sha256=X1LdP36NomDtvPfFwoMNtgXf81TO05jj7vltsp79UUw,787
+dbos-0.6.0.dist-info/METADATA,sha256=KmnHNM81muzumN3rCi5ehIHATQepqFl0DyWlKrlV5xY,4998
+dbos-0.6.0.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
+dbos-0.6.0.dist-info/entry_points.txt,sha256=3PmOPbM4FYxEmggRRdJw0oAsiBzKR8U0yx7bmwUmMOM,39
+dbos-0.6.0.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos/__init__.py,sha256=heuB3bqRXlVdfea9sKHBIVKSqFP6UuwhQecQfV4hyas,642
 dbos/admin_sever.py,sha256=Qg5T3YRrbPW05PR_99yAaxgo1ugQrAp_uTeTqSfjm_k,3397
 dbos/application_database.py,sha256=1K3kE96BgGi_QWOd2heXluyNTwFAwlUVuAR6JKKUqf0,5659
 dbos/cli.py,sha256=YARlQiWHUwFni-fEOr0k5P_-pqPS4xkywj_B0oTMXn0,8318
-dbos/context.py,sha256=qAVj_pAIV4YBOAbI0WCv-Roq7aNwPzAoj3CeQaVqlrU,15666
-dbos/core.py,sha256=HfKnPpIaQqIBAHzP2hD67aSIchTHp87NgD21CcujKkE,28300
+dbos/context.py,sha256=NVMGyvAa2RIiBVspvDz-8MBk_BQyGyYdPdorgO-GSng,16407
+dbos/core.py,sha256=jeqO8DABPAUrFlJXOfRfFDSnA8BGwiPnMa1JNbGuYLs,28584
 dbos/dbos-config.schema.json,sha256=azpfmoDZg7WfSy3kvIsk9iEiKB_-VZt03VEOoXJAkqE,5331
-dbos/dbos.py,sha256=bDp-m25V_CkaR4hsr4VmCFCZbDQ4V99Um9bDUxahpag,26561
-dbos/dbos_config.py,sha256=EkO0c0xaIM7_vAAqqnvNNEAKG5fOJbmmalqnZvaKYZA,5312
+dbos/dbos.py,sha256=wzL51K7bY3J8grHXi0k0F0N09vFVBYWKwI0DGxyN4MY,29730
+dbos/dbos_config.py,sha256=ih_TD_1zTKhPKxk8TPdEIp3ihu82R06SGKg-s4rHxws,5344
 dbos/decorators.py,sha256=lbPefsLK6Cya4cb7TrOcLglOpGT3pc6qjZdsQKlfZLg,629
-dbos/error.py,sha256=nBdLC4hxGO_K9V26YbDGOo7xi1CKuN4PsE_cBv7K8Cc,3798
-dbos/fastapi.py,sha256=LkARLITiN_NuQh4g2QL7sfK0oG1GvJjj2tvU7WWO8f8,1898
+dbos/error.py,sha256=DDhB0VHmoZE_CP51ICdFMZSL2gmVS3Dm0aPNWncci94,3876
+dbos/fastapi.py,sha256=s7LnwwYVpJm_QZZwBW5um8NV2Q2Qx85uVZqGcKlSZAo,1881
+dbos/flask.py,sha256=azr4geMEGuuTBCyxIZmgDmmP-6s_pTIF-lGyp9Q4IB8,2430
+dbos/kafka.py,sha256=FtngQHBu2TKfyDF7GFsKJAawFQJiOFxgKEUlNNxrdrw,3055
+dbos/kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
 dbos/logger.py,sha256=D-aFSZUCHBP34J1IZ5YNkTrJW-rDiH3py_v9jLU4Yrk,3565
 dbos/migrations/env.py,sha256=38SIGVbmn_VV2x2u1aHLcPOoWgZ84eCymf3g_NljmbU,1626
 dbos/migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
@@ -22,25 +25,25 @@ dbos/migrations/versions/a3b18ad34abe_added_triggers.py,sha256=Rv0ZsZYZ_WdgGEULY
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 dbos/recovery.py,sha256=xfwQFWNuD8DXg5HD5_-3tG7Neo9j-x1lrqiwtn5FSh8,2015
 dbos/registrations.py,sha256=gMI-u05tv5bpvyddQGtoUgCsqARx51aOY7p0JXPafQo,6539
-dbos/request.py,sha256=FTjmgzqWwKKTSf6PKPdlQ4Ssp39PATQukYmMOW_xP7k,892
-dbos/roles.py,sha256=9u0z4CWmXPeqIKzQWEzaOKIlzOuaagBtMiB-swqjX_U,2291
+dbos/request.py,sha256=-FIwtknayvRl6OjvqO4V2GySVzSdP1Ft3cc9ZBS-PLY,928
+dbos/roles.py,sha256=7Lh7uwUq1dpa6TXCOHre4mPTd5qmXzK_QPkvYR52DXg,2285
 dbos/scheduler/croniter.py,sha256=hbhgfsHBqclUS8VeLnJ9PSE9Z54z6mi4nnrr1aUXn0k,47561
 dbos/scheduler/scheduler.py,sha256=uO4_9jmWW2rLv1ODL3lc1cE_37ZaVTgnvmFx_FAlN50,1472
 dbos/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/schemas/application_database.py,sha256=q_Wr2XbiZNBYFkOtu7uKavo1T_cSOBblxKGHThYGGsY,962
 dbos/schemas/system_database.py,sha256=5V3vqnEzry0Hn7ZbVS9Gs_dJKia8uX8p7mGC82Ru8rk,4303
-dbos/system_database.py,sha256=K2PYGRjXOJxhYW0_wDvu49CwE5L1HH_s0fAhHZw1HO8,39636
+dbos/system_database.py,sha256=BZ8yE79FH9NZhEt8AAYNXy0-wMcKLBAq8VPdZbfidR4,40564
 dbos/templates/hello/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
 dbos/templates/hello/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dbos/templates/hello/__package/main.py,sha256=LFN48qBWt-xsf21Cg1llf5Grr0e7Il_7lcyi60sK4ec,2984
-dbos/templates/hello/__package/schema.py,sha256=XOSeq_vFG0vN1LxWPob-L9K65jq9OMCz2qOmvw5CKN8,235
+dbos/templates/hello/__package/main.py,sha256=eI0SS9Nwj-fldtiuSzIlIG6dC91GXXwdRsoHxv6S_WI,2719
+dbos/templates/hello/__package/schema.py,sha256=7Z27JGC8yy7Z44cbVXIREYxtUhU4JVkLCp5Q7UahVQ0,260
 dbos/templates/hello/alembic.ini,sha256=VKBn4Gy8mMuCdY7Hip1jmo3wEUJ1VG1aW7EqY0_n-as,3695
 dbos/templates/hello/dbos-config.yaml.dbos,sha256=8wxCf_MIEFNWqMXj0nAHUwg1U3YaKz4xcUN6g51WkDE,603
 dbos/templates/hello/migrations/env.py.dbos,sha256=CsiFOea3ZIsahqkfYtioha0ewmlGR78Ng0wOB2t5LQg,2208
 dbos/templates/hello/migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
-dbos/templates/hello/migrations/versions/2024_07_31_180642_init.py,sha256=rcubrMdw-NUKnrY0Qsftgz4is1OEqWXf6Skcv4PVdME,914
+dbos/templates/hello/migrations/versions/2024_07_31_180642_init.py,sha256=U5thFWGqNN4QLrNXT7wUUqftIFDNE5eSdqD8JNW1mec,942
 dbos/templates/hello/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
-dbos/tracer.py,sha256=RPW9oxmX9tSc0Yq7O-FAhpQWBg1QT7Ni1Q06uwhtNDk,2237
+dbos/tracer.py,sha256=GaXDhdKKF_IQp5SAMipGXiDVwteRKjNbrXyYCH1mor0,2520
 dbos/utils.py,sha256=hWj9iWDrby2cVEhb0pG-IdnrxLqP64NhkaWUXiLc8bA,402
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.5.0a12.dist-info/RECORD,,
+dbos-0.6.0.dist-info/RECORD,,