dbos 1.13.1__py3-none-any.whl → 1.14.0__py3-none-any.whl

dbos/__init__.py

@@ -9,6 +9,7 @@ from ._context import (
 )
 from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle, WorkflowHandleAsync
 from ._dbos_config import DBOSConfig
+from ._debouncer import Debouncer, DebouncerClient
 from ._kafka_message import KafkaMessage
 from ._queue import Queue
 from ._sys_db import GetWorkflowsInput, WorkflowStatus, WorkflowStatusString
@@ -32,4 +33,6 @@ __all__ = [
     "WorkflowStatusString",
     "error",
     "Queue",
+    "Debouncer",
+    "DebouncerClient",
 ]

dbos/_client.py

@@ -3,6 +3,7 @@ import sys
 import time
 import uuid
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncGenerator,
     Generator,
@@ -24,7 +25,10 @@ else:
     from typing import NotRequired
 
 from dbos import _serialization
-from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
+
+if TYPE_CHECKING:
+    from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
+
 from dbos._dbos_config import (
     get_application_database_url,
     get_system_database_url,
@@ -224,23 +228,25 @@ class DBOSClient:
 
     def enqueue(
         self, options: EnqueueOptions, *args: Any, **kwargs: Any
-    ) -> WorkflowHandle[R]:
+    ) -> "WorkflowHandle[R]":
         workflow_id = self._enqueue(options, *args, **kwargs)
         return WorkflowHandleClientPolling[R](workflow_id, self._sys_db)
 
     async def enqueue_async(
         self, options: EnqueueOptions, *args: Any, **kwargs: Any
-    ) -> WorkflowHandleAsync[R]:
+    ) -> "WorkflowHandleAsync[R]":
         workflow_id = await asyncio.to_thread(self._enqueue, options, *args, **kwargs)
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
 
-    def retrieve_workflow(self, workflow_id: str) -> WorkflowHandle[R]:
+    def retrieve_workflow(self, workflow_id: str) -> "WorkflowHandle[R]":
         status = get_workflow(self._sys_db, workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandleClientPolling[R](workflow_id, self._sys_db)
 
-    async def retrieve_workflow_async(self, workflow_id: str) -> WorkflowHandleAsync[R]:
+    async def retrieve_workflow_async(
+        self, workflow_id: str
+    ) -> "WorkflowHandleAsync[R]":
         status = await asyncio.to_thread(get_workflow, self._sys_db, workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
@@ -311,11 +317,13 @@ class DBOSClient:
     async def cancel_workflow_async(self, workflow_id: str) -> None:
         await asyncio.to_thread(self.cancel_workflow, workflow_id)
 
-    def resume_workflow(self, workflow_id: str) -> WorkflowHandle[Any]:
+    def resume_workflow(self, workflow_id: str) -> "WorkflowHandle[Any]":
         self._sys_db.resume_workflow(workflow_id)
         return WorkflowHandleClientPolling[Any](workflow_id, self._sys_db)
 
-    async def resume_workflow_async(self, workflow_id: str) -> WorkflowHandleAsync[Any]:
+    async def resume_workflow_async(
+        self, workflow_id: str
+    ) -> "WorkflowHandleAsync[Any]":
         await asyncio.to_thread(self.resume_workflow, workflow_id)
         return WorkflowHandleClientAsyncPolling[Any](workflow_id, self._sys_db)
 
@@ -451,7 +459,7 @@ class DBOSClient:
         start_step: int,
         *,
         application_version: Optional[str] = None,
-    ) -> WorkflowHandle[Any]:
+    ) -> "WorkflowHandle[Any]":
         forked_workflow_id = fork_workflow(
             self._sys_db,
             self._app_db,
@@ -467,7 +475,7 @@ class DBOSClient:
         start_step: int,
         *,
         application_version: Optional[str] = None,
-    ) -> WorkflowHandleAsync[Any]:
+    ) -> "WorkflowHandleAsync[Any]":
         forked_workflow_id = await asyncio.to_thread(
             fork_workflow,
             self._sys_db,

dbos/_context.py

@@ -215,11 +215,18 @@ class DBOSContext:
     def end_handler(self, exc_value: Optional[BaseException]) -> None:
         self._end_span(exc_value)
 
-    def get_current_span(self) -> Optional[Span]:
+    """ Return the current DBOS span if any. It must be a span created by DBOS."""
+
+    def get_current_dbos_span(self) -> Optional[Span]:
         if len(self.context_spans) > 0:
             return self.context_spans[-1].span
         return None
 
+    """ Return the current active span if any. It might not be a DBOS span."""
+
+    def get_current_active_span(self) -> Optional[Span]:
+        return dbos_tracer.get_current_span()
+
     def _start_span(self, attributes: TracedAttributes) -> None:
         if dbos_tracer.disable_otlp:
             return
@@ -235,7 +242,7 @@ class DBOSContext:
         attributes["authenticatedUserAssumedRole"] = self.assumed_role
         span = dbos_tracer.start_span(
             attributes,
-            parent=self.context_spans[-1].span if len(self.context_spans) > 0 else None,
+            parent=None,  # It'll use the current active span as the parent
         )
         # Activate the current span
         cm = use_span(
@@ -517,6 +524,7 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         self.saved_workflow_timeout: Optional[int] = None
         self.saved_deduplication_id: Optional[str] = None
         self.saved_priority: Optional[int] = None
+        self.saved_is_within_set_workflow_id_block: bool = False
 
     def __enter__(self) -> DBOSContext:
         # Code to create a basic context
@@ -526,6 +534,9 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
             ctx = DBOSContext()
             _set_local_dbos_context(ctx)
         assert not ctx.is_within_workflow()
+        # Unset is_within_set_workflow_id_block as the workflow is not within a block
+        self.saved_is_within_set_workflow_id_block = ctx.is_within_set_workflow_id_block
+        ctx.is_within_set_workflow_id_block = False
         # Unset the workflow_timeout_ms context var so it is not applied to this
         # workflow's children (instead we propagate the deadline)
         self.saved_workflow_timeout = ctx.workflow_timeout_ms
@@ -550,6 +561,8 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         ctx = assert_current_dbos_context()
         assert ctx.is_within_workflow()
         ctx.end_workflow(exc_value)
+        # Restore is_within_set_workflow_id_block
+        ctx.is_within_set_workflow_id_block = self.saved_is_within_set_workflow_id_block
         # Restore the saved workflow timeout
         ctx.workflow_timeout_ms = self.saved_workflow_timeout
         # Clear any propagating timeout

dbos/_core.py

@@ -19,8 +19,6 @@ from typing import (
     cast,
 )
 
-import psycopg
-
 from dbos._outcome import Immediate, NoResult, Outcome, Pending
 from dbos._utils import GlobalParams, retriable_postgres_exception
 
@@ -52,12 +50,14 @@ from ._error import (
     DBOSException,
     DBOSMaxStepRetriesExceeded,
     DBOSNonExistentWorkflowError,
+    DBOSQueueDeduplicatedError,
     DBOSRecoveryError,
     DBOSUnexpectedStepError,
     DBOSWorkflowCancelledError,
     DBOSWorkflowConflictIDError,
     DBOSWorkflowFunctionNotFoundError,
 )
+from ._logger import dbos_logger
 from ._registrations import (
     DEFAULT_MAX_RECOVERY_ATTEMPTS,
     get_config_name,
@@ -96,6 +96,15 @@ R = TypeVar("R", covariant=True)  # A generic type for workflow return values
 F = TypeVar("F", bound=Callable[..., Any])
 
 TEMP_SEND_WF_NAME = "<temp>.temp_send_workflow"
+DEBOUNCER_WORKFLOW_NAME = "_dbos_debouncer_workflow"
+
+
+def check_is_in_coroutine() -> bool:
+    try:
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
 
 
 class WorkflowHandleFuture(Generic[R]):
@@ -303,10 +312,22 @@ def _init_workflow(
     }
 
     # Synchronously record the status and inputs for workflows
-    wf_status, workflow_deadline_epoch_ms = dbos._sys_db.init_workflow(
-        status,
-        max_recovery_attempts=max_recovery_attempts,
-    )
+    try:
+        wf_status, workflow_deadline_epoch_ms = dbos._sys_db.init_workflow(
+            status,
+            max_recovery_attempts=max_recovery_attempts,
+        )
+    except DBOSQueueDeduplicatedError as e:
+        if ctx.has_parent():
+            result: OperationResultInternal = {
+                "workflow_uuid": ctx.parent_workflow_id,
+                "function_id": ctx.parent_workflow_fid,
+                "function_name": wf_name,
+                "output": None,
+                "error": _serialization.serialize_exception(e),
+            }
+            dbos._sys_db.record_operation_result(result)
+        raise
 
     if workflow_deadline_epoch_ms is not None:
         evt = threading.Event()
@@ -830,11 +851,16 @@ def workflow_wrapper(
             dbos._sys_db.record_get_result(workflow_id, serialized_r, None)
             return r
 
+        if check_is_in_coroutine() and not inspect.iscoroutinefunction(func):
+            dbos_logger.warning(
+                f"Sync workflow ({get_dbos_func_name(func)}) shouldn't be invoked from within another async function. Define it as async or use asyncio.to_thread instead."
+            )
+
         outcome = (
-            wfOutcome.wrap(init_wf)
+            wfOutcome.wrap(init_wf, dbos=dbos)
             .also(DBOSAssumeRole(rr))
             .also(enterWorkflowCtxMgr(attributes))
-            .then(record_get_result)
+            .then(record_get_result, dbos=dbos)
         )
         return outcome()  # type: ignore
 
@@ -959,7 +985,7 @@ def decorate_transaction(
                                 dbapi_error
                             ) or dbos._app_db._is_serialization_error(dbapi_error):
                                 # Retry on serialization failure
-                                span = ctx.get_current_span()
+                                span = ctx.get_current_dbos_span()
                                 if span:
                                     span.add_event(
                                         "Transaction Failure",
@@ -1011,6 +1037,10 @@ def decorate_transaction(
                 assert (
                     ctx.is_workflow()
                 ), "Transactions must be called from within workflows"
+                if check_is_in_coroutine():
+                    dbos_logger.warning(
+                        f"Transaction function ({get_dbos_func_name(func)}) shouldn't be invoked from within another async function. Use asyncio.to_thread instead."
+                    )
                 with DBOSAssumeRole(rr):
                     return invoke_tx(*args, **kwargs)
             else:
@@ -1074,7 +1104,7 @@ def decorate_step(
                     exc_info=error,
                 )
                 ctx = assert_current_dbos_context()
-                span = ctx.get_current_span()
+                span = ctx.get_current_dbos_span()
                 if span:
                     span.add_event(
                         f"Step attempt {attempt} failed",
@@ -1146,7 +1176,7 @@ def decorate_step(
 
             outcome = (
                 stepOutcome.then(record_step_result)
-                .intercept(check_existing_result)
+                .intercept(check_existing_result, dbos=dbos)
                 .also(EnterDBOSStep(attributes))
             )
             return outcome()
@@ -1155,6 +1185,10 @@ def decorate_step(
 
         @wraps(func)
         def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if check_is_in_coroutine() and not inspect.iscoroutinefunction(func):
+                dbos_logger.warning(
+                    f"Sync step ({get_dbos_func_name(func)}) shouldn't be invoked from within another async function. Define it as async or use asyncio.to_thread instead."
+                )
             # If the step is called from a workflow, run it as a step.
             # Otherwise, run it as a normal function.
             ctx = get_local_dbos_context()

dbos/_dbos.py

@@ -32,12 +32,14 @@ from opentelemetry.trace import Span
 from rich import print
 
 from dbos._conductor.conductor import ConductorWebsocket
+from dbos._debouncer import debouncer_workflow
 from dbos._sys_db import SystemDatabase, WorkflowStatus
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 from dbos._workflow_commands import fork_workflow, list_queued_workflows, list_workflows
 
 from ._classproperty import classproperty
 from ._core import (
+    DEBOUNCER_WORKFLOW_NAME,
     TEMP_SEND_WF_NAME,
     WorkflowHandleAsyncPolling,
     WorkflowHandlePolling,
@@ -390,11 +392,12 @@ class DBOS:
         ) -> None:
             self.send(destination_id, message, topic)
 
-        temp_send_wf = workflow_wrapper(self._registry, send_temp_workflow)
-        set_dbos_func_name(send_temp_workflow, TEMP_SEND_WF_NAME)
-        set_dbos_func_name(temp_send_wf, TEMP_SEND_WF_NAME)
-        set_temp_workflow_type(send_temp_workflow, "send")
-        self._registry.register_wf_function(TEMP_SEND_WF_NAME, temp_send_wf, "send")
+        decorate_workflow(self._registry, TEMP_SEND_WF_NAME, None)(send_temp_workflow)
+
+        # Register the debouncer workflow
+        decorate_workflow(self._registry, DEBOUNCER_WORKFLOW_NAME, None)(
+            debouncer_workflow
+        )
 
         for handler in dbos_logger.handlers:
             handler.flush()
@@ -1297,7 +1300,7 @@ class DBOS:
     def span(cls) -> Span:
         """Return the tracing `Span` associated with the current context."""
         ctx = assert_current_dbos_context()
-        span = ctx.get_current_span()
+        span = ctx.get_current_active_span()
         assert span
         return span
 

dbos/_debouncer.py

@@ -0,0 +1,395 @@
+import asyncio
+import math
+import sys
+import time
+import types
+import uuid
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generic,
+    Optional,
+    Tuple,
+    TypedDict,
+    TypeVar,
+    Union,
+)
+
+if sys.version_info < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
+
+from dbos._client import (
+    DBOSClient,
+    EnqueueOptions,
+    WorkflowHandleClientAsyncPolling,
+    WorkflowHandleClientPolling,
+)
+from dbos._context import (
+    DBOSContextEnsure,
+    SetEnqueueOptions,
+    SetWorkflowID,
+    SetWorkflowTimeout,
+    assert_current_dbos_context,
+)
+from dbos._core import (
+    DEBOUNCER_WORKFLOW_NAME,
+    WorkflowHandleAsyncPolling,
+    WorkflowHandlePolling,
+)
+from dbos._error import DBOSQueueDeduplicatedError
+from dbos._queue import Queue
+from dbos._registrations import get_dbos_func_name
+from dbos._serialization import WorkflowInputs
+from dbos._utils import INTERNAL_QUEUE_NAME
+
+if TYPE_CHECKING:
+    from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
+
+P = ParamSpec("P")  # A generic type for workflow parameters
+R = TypeVar("R", covariant=True)  # A generic type for workflow return values
+
+
+_DEBOUNCER_TOPIC = "DEBOUNCER_TOPIC"
+
+
+# Options saved from the local context to pass through to the debounced function
+class ContextOptions(TypedDict):
+    workflow_id: str
+    deduplication_id: Optional[str]
+    priority: Optional[int]
+    app_version: Optional[str]
+    workflow_timeout_sec: Optional[float]
+
+
+# Parameters for the debouncer workflow
+class DebouncerOptions(TypedDict):
+    workflow_name: str
+    debounce_timeout_sec: Optional[float]
+    queue_name: Optional[str]
+
+
+# The message sent from a debounce to the debouncer workflow
+class DebouncerMessage(TypedDict):
+    inputs: WorkflowInputs
+    message_id: str
+    debounce_period_sec: float
+
+
+def debouncer_workflow(
+    initial_debounce_period_sec: float,
+    ctx: ContextOptions,
+    options: DebouncerOptions,
+    *args: Tuple[Any, ...],
+    **kwargs: Dict[str, Any],
+) -> None:
+    from dbos._dbos import DBOS, _get_dbos_instance
+
+    dbos = _get_dbos_instance()
+
+    workflow_inputs: WorkflowInputs = {"args": args, "kwargs": kwargs}
+    # Every time the debounced workflow is called, a message is sent to this workflow.
+    # It waits until debounce_period_sec have passed since the last message or until
+    # debounce_timeout_sec has elapsed.
+    debounce_deadline_epoch_sec = (
+        time.time() + options["debounce_timeout_sec"]
+        if options["debounce_timeout_sec"]
+        else math.inf
+    )
+    debounce_period_sec = initial_debounce_period_sec
+    while time.time() < debounce_deadline_epoch_sec:
+        time_until_deadline = max(debounce_deadline_epoch_sec - time.time(), 0)
+        timeout = min(debounce_period_sec, time_until_deadline)
+        message: DebouncerMessage = DBOS.recv(_DEBOUNCER_TOPIC, timeout_seconds=timeout)
+        if message is None:
+            break
+        else:
+            workflow_inputs = message["inputs"]
+            debounce_period_sec = message["debounce_period_sec"]
+            # Acknowledge receipt of the message
+            DBOS.set_event(message["message_id"], message["message_id"])
+    # After the timeout or period has elapsed, start the user workflow with the requested context parameters,
+    # either directly or on a queue.
+    with SetWorkflowID(ctx["workflow_id"]):
+        with SetWorkflowTimeout(ctx["workflow_timeout_sec"]):
+            func = dbos._registry.workflow_info_map.get(options["workflow_name"], None)
+            if not func:
+                raise Exception(
+                    f"Invalid workflow name provided to debouncer: {options['workflow_name']}"
+                )
+            if options["queue_name"]:
+                queue = dbos._registry.queue_info_map.get(options["queue_name"], None)
+                if not queue:
+                    raise Exception(
+                        f"Invalid queue name provided to debouncer: {options['queue_name']}"
+                    )
+                with SetEnqueueOptions(
+                    deduplication_id=ctx["deduplication_id"],
+                    priority=ctx["priority"],
+                    app_version=ctx["app_version"],
+                ):
+                    queue.enqueue(
+                        func, *workflow_inputs["args"], **workflow_inputs["kwargs"]
+                    )
+            else:
+                DBOS.start_workflow(
+                    func, *workflow_inputs["args"], **workflow_inputs["kwargs"]
+                )
+
+
+class Debouncer(Generic[P, R]):
+
+    def __init__(
+        self,
+        workflow_name: str,
+        *,
+        debounce_timeout_sec: Optional[float] = None,
+        queue: Optional[Queue] = None,
+    ):
+        self.func_name = workflow_name
+        self.options: DebouncerOptions = {
+            "debounce_timeout_sec": debounce_timeout_sec,
+            "queue_name": queue.name if queue else None,
+            "workflow_name": workflow_name,
+        }
+
+    @staticmethod
+    def create(
+        workflow: Callable[P, R],
+        *,
+        debounce_timeout_sec: Optional[float] = None,
+        queue: Optional[Queue] = None,
+    ) -> "Debouncer[P, R]":
+
+        if isinstance(workflow, (types.MethodType)):
+            raise TypeError("Only workflow functions may be debounced, not methods")
+        return Debouncer[P, R](
+            get_dbos_func_name(workflow),
+            debounce_timeout_sec=debounce_timeout_sec,
+            queue=queue,
+        )
+
+    @staticmethod
+    def create_async(
+        workflow: Callable[P, Coroutine[Any, Any, R]],
+        *,
+        debounce_timeout_sec: Optional[float] = None,
+        queue: Optional[Queue] = None,
+    ) -> "Debouncer[P, R]":
+
+        if isinstance(workflow, (types.MethodType)):
+            raise TypeError("Only workflow functions may be debounced, not methods")
+        return Debouncer[P, R](
+            get_dbos_func_name(workflow),
+            debounce_timeout_sec=debounce_timeout_sec,
+            queue=queue,
+        )
+
+    def debounce(
+        self,
+        debounce_key: str,
+        debounce_period_sec: float,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> "WorkflowHandle[R]":
+        from dbos._dbos import DBOS, _get_dbos_instance
+
+        dbos = _get_dbos_instance()
+        internal_queue = dbos._registry.get_internal_queue()
+
+        # Read all workflow settings from context, pass them through ContextOptions
+        # into the debouncer to apply to the user workflow, then reset the context
+        # so workflow settings aren't applied to the debouncer.
+        with DBOSContextEnsure():
+            ctx = assert_current_dbos_context()
+
+            # Deterministically generate the user workflow ID and message ID
+            def assign_debounce_ids() -> tuple[str, str]:
+                return str(uuid.uuid4()), ctx.assign_workflow_id()
+
+            message_id, user_workflow_id = dbos._sys_db.call_function_as_step(
+                assign_debounce_ids, "DBOS.assign_debounce_ids"
+            )
+            ctx.id_assigned_for_next_workflow = ""
+            ctx.is_within_set_workflow_id_block = False
+            ctxOptions: ContextOptions = {
+                "workflow_id": user_workflow_id,
+                "app_version": ctx.app_version,
+                "deduplication_id": ctx.deduplication_id,
+                "priority": ctx.priority,
+                "workflow_timeout_sec": (
+                    ctx.workflow_timeout_ms / 1000.0
+                    if ctx.workflow_timeout_ms
+                    else None
+                ),
+            }
+        while True:
+            try:
+                # Attempt to enqueue a debouncer for this workflow.
+                deduplication_id = f"{self.options['workflow_name']}-{debounce_key}"
+                with SetEnqueueOptions(deduplication_id=deduplication_id):
+                    with SetWorkflowTimeout(None):
+                        internal_queue.enqueue(
+                            debouncer_workflow,
+                            debounce_period_sec,
+                            ctxOptions,
+                            self.options,
+                            *args,
+                            **kwargs,
+                        )
+                return WorkflowHandlePolling(user_workflow_id, dbos)
+            except DBOSQueueDeduplicatedError:
+                # If there is already a debouncer, send a message to it.
+                # Deterministically retrieve the ID of the debouncer
+                def get_deduplicated_workflow() -> Optional[str]:
+                    return dbos._sys_db.get_deduplicated_workflow(
+                        queue_name=internal_queue.name,
+                        deduplication_id=deduplication_id,
+                    )
+
+                dedup_wfid = dbos._sys_db.call_function_as_step(
+                    get_deduplicated_workflow, "DBOS.get_deduplicated_workflow"
+                )
+                if dedup_wfid is None:
+                    continue
+                else:
+                    workflow_inputs: WorkflowInputs = {"args": args, "kwargs": kwargs}
+                    message: DebouncerMessage = {
+                        "message_id": message_id,
+                        "inputs": workflow_inputs,
+                        "debounce_period_sec": debounce_period_sec,
+                    }
+                    DBOS.send(dedup_wfid, message, _DEBOUNCER_TOPIC)
+                    # Wait for the debouncer to acknowledge receipt of the message.
+                    # If the message is not acknowledged, this likely means the debouncer started its workflow
+                    # and exited without processing this message, so try again.
+                    if not DBOS.get_event(dedup_wfid, message_id, timeout_seconds=1):
+                        continue
+                    # Retrieve the user workflow ID from the input to the debouncer
+                    # and return a handle to it
+                    dedup_workflow_input = (
+                        DBOS.retrieve_workflow(dedup_wfid).get_status().input
+                    )
+                    assert dedup_workflow_input is not None
+                    user_workflow_id = dedup_workflow_input["args"][1]["workflow_id"]
+                    return WorkflowHandlePolling(user_workflow_id, dbos)
+
+    async def debounce_async(
+        self,
+        debounce_key: str,
+        debounce_period_sec: float,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> "WorkflowHandleAsync[R]":
+        from dbos._dbos import _get_dbos_instance
+
+        dbos = _get_dbos_instance()
+        handle = await asyncio.to_thread(
+            self.debounce, debounce_key, debounce_period_sec, *args, **kwargs
+        )
+        return WorkflowHandleAsyncPolling(handle.workflow_id, dbos)
+
+
+class DebouncerClient:
+
+    def __init__(
+        self,
+        client: DBOSClient,
+        workflow_options: EnqueueOptions,
+        *,
+        debounce_timeout_sec: Optional[float] = None,
+        queue: Optional[Queue] = None,
+    ):
+        self.workflow_options = workflow_options
+        self.debouncer_options: DebouncerOptions = {
+            "debounce_timeout_sec": debounce_timeout_sec,
+            "queue_name": queue.name if queue else None,
+            "workflow_name": workflow_options["workflow_name"],
+        }
+        self.client = client
+
+    def debounce(
+        self, debounce_key: str, debounce_period_sec: float, *args: Any, **kwargs: Any
+    ) -> "WorkflowHandle[R]":
+
+        ctxOptions: ContextOptions = {
+            "workflow_id": (
+                self.workflow_options["workflow_id"]
+                if self.workflow_options.get("workflow_id")
+                else str(uuid.uuid4())
+            ),
+            "app_version": self.workflow_options.get("app_version"),
+            "deduplication_id": self.workflow_options.get("deduplication_id"),
+            "priority": self.workflow_options.get("priority"),
+            "workflow_timeout_sec": self.workflow_options.get("workflow_timeout"),
+        }
+        message_id = str(uuid.uuid4())
+        while True:
+            try:
+                # Attempt to enqueue a debouncer for this workflow.
+                deduplication_id = (
+                    f"{self.debouncer_options['workflow_name']}-{debounce_key}"
+                )
+                debouncer_options: EnqueueOptions = {
+                    "workflow_name": DEBOUNCER_WORKFLOW_NAME,
+                    "queue_name": INTERNAL_QUEUE_NAME,
+                    "deduplication_id": deduplication_id,
+                }
+                self.client.enqueue(
+                    debouncer_options,
+                    debounce_period_sec,
+                    ctxOptions,
+                    self.debouncer_options,
+                    *args,
+                    **kwargs,
+                )
+                return WorkflowHandleClientPolling[R](
+                    ctxOptions["workflow_id"], self.client._sys_db
+                )
+            except DBOSQueueDeduplicatedError:
+                # If there is already a debouncer, send a message to it.
+                dedup_wfid = self.client._sys_db.get_deduplicated_workflow(
+                    queue_name=INTERNAL_QUEUE_NAME,
+                    deduplication_id=deduplication_id,
+                )
+                if dedup_wfid is None:
+                    continue
+                else:
+                    workflow_inputs: WorkflowInputs = {"args": args, "kwargs": kwargs}
+                    message: DebouncerMessage = {
+                        "message_id": message_id,
+                        "inputs": workflow_inputs,
+                        "debounce_period_sec": debounce_period_sec,
+                    }
+                    self.client.send(dedup_wfid, message, _DEBOUNCER_TOPIC)
+                    # Wait for the debouncer to acknowledge receipt of the message.
+                    # If the message is not acknowledged, this likely means the debouncer started its workflow
+                    # and exited without processing this message, so try again.
+                    if not self.client.get_event(
+                        dedup_wfid, message_id, timeout_seconds=1
+                    ):
+                        continue
+                    # Retrieve the user workflow ID from the input to the debouncer
+                    # and return a handle to it
+                    dedup_workflow_input = (
+                        self.client.retrieve_workflow(dedup_wfid).get_status().input
+                    )
+                    assert dedup_workflow_input is not None
+                    user_workflow_id = dedup_workflow_input["args"][1]["workflow_id"]
+                    return WorkflowHandleClientPolling[R](
+                        user_workflow_id, self.client._sys_db
+                    )
+
+    async def debounce_async(
+        self, deboucne_key: str, debounce_period_sec: float, *args: Any, **kwargs: Any
+    ) -> "WorkflowHandleAsync[R]":
+        handle: "WorkflowHandle[R]" = await asyncio.to_thread(
+            self.debounce, deboucne_key, debounce_period_sec, *args, **kwargs
+        )
+        return WorkflowHandleClientAsyncPolling[R](
+            handle.workflow_id, self.client._sys_db
+        )

dbos/_logger.py

@@ -39,7 +39,7 @@ class DBOSLogTransformer(logging.Filter):
         if ctx:
             if ctx.is_within_workflow():
                 record.operationUUID = ctx.workflow_id
-            span = ctx.get_current_span()
+            span = ctx.get_current_active_span()
             if span:
                 trace_id = format_trace_id(span.get_span_context().trace_id)
                 record.traceId = trace_id

dbos/_outcome.py

@@ -2,9 +2,24 @@ import asyncio
 import contextlib
 import inspect
 import time
-from typing import Any, Callable, Coroutine, Optional, Protocol, TypeVar, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Optional,
+    Protocol,
+    TypeVar,
+    Union,
+    cast,
+)
 
 from dbos._context import EnterDBOSStepRetry
+from dbos._error import DBOSException
+from dbos._registrations import get_dbos_func_name
+
+if TYPE_CHECKING:
+    from ._dbos import DBOS
 
 T = TypeVar("T")
 R = TypeVar("R")
@@ -24,10 +39,15 @@ class NoResult:
 class Outcome(Protocol[T]):
 
     def wrap(
-        self, before: Callable[[], Callable[[Callable[[], T]], R]]
+        self,
+        before: Callable[[], Callable[[Callable[[], T]], R]],
+        *,
+        dbos: Optional["DBOS"] = None,
     ) -> "Outcome[R]": ...
 
-    def then(self, next: Callable[[Callable[[], T]], R]) -> "Outcome[R]": ...
+    def then(
+        self, next: Callable[[Callable[[], T]], R], *, dbos: Optional["DBOS"] = None
+    ) -> "Outcome[R]": ...
 
     def also(
         self, cm: contextlib.AbstractContextManager[Any, bool]
@@ -41,7 +61,10 @@ class Outcome(Protocol[T]):
     ) -> "Outcome[T]": ...
 
     def intercept(
-        self, interceptor: Callable[[], Union[NoResult, T]]
+        self,
+        interceptor: Callable[[], Union[NoResult, T]],
+        *,
+        dbos: Optional["DBOS"] = None,
     ) -> "Outcome[T]": ...
 
     def __call__(self) -> Union[T, Coroutine[Any, Any, T]]: ...
@@ -63,11 +86,17 @@ class Immediate(Outcome[T]):
     def __init__(self, func: Callable[[], T]):
         self._func = func
 
-    def then(self, next: Callable[[Callable[[], T]], R]) -> "Immediate[R]":
+    def then(
+        self,
+        next: Callable[[Callable[[], T]], R],
+        dbos: Optional["DBOS"] = None,
+    ) -> "Immediate[R]":
         return Immediate(lambda: next(self._func))
 
     def wrap(
-        self, before: Callable[[], Callable[[Callable[[], T]], R]]
+        self,
+        before: Callable[[], Callable[[Callable[[], T]], R]],
+        dbos: Optional["DBOS"] = None,
     ) -> "Immediate[R]":
         return Immediate(lambda: before()(self._func))
 
@@ -79,7 +108,10 @@ class Immediate(Outcome[T]):
         return intercepted if not isinstance(intercepted, NoResult) else func()
 
     def intercept(
-        self, interceptor: Callable[[], Union[NoResult, T]]
+        self,
+        interceptor: Callable[[], Union[NoResult, T]],
+        *,
+        dbos: Optional["DBOS"] = None,
     ) -> "Immediate[T]":
         return Immediate[T](lambda: Immediate._intercept(self._func, interceptor))
 
@@ -142,7 +174,12 @@ class Pending(Outcome[T]):
     async def _wrap(
         func: Callable[[], Coroutine[Any, Any, T]],
         before: Callable[[], Callable[[Callable[[], T]], R]],
+        *,
+        dbos: Optional["DBOS"] = None,
     ) -> R:
+        # Make sure the executor pool is configured correctly
+        if dbos is not None:
+            await dbos._configure_asyncio_thread_pool()
         after = await asyncio.to_thread(before)
         try:
             value = await func()
@@ -151,12 +188,17 @@ class Pending(Outcome[T]):
             return await asyncio.to_thread(after, lambda: Pending._raise(exp))
 
     def wrap(
-        self, before: Callable[[], Callable[[Callable[[], T]], R]]
+        self,
+        before: Callable[[], Callable[[Callable[[], T]], R]],
+        *,
+        dbos: Optional["DBOS"] = None,
     ) -> "Pending[R]":
-        return Pending[R](lambda: Pending._wrap(self._func, before))
+        return Pending[R](lambda: Pending._wrap(self._func, before, dbos=dbos))
 
-    def then(self, next: Callable[[Callable[[], T]], R]) -> "Pending[R]":
-        return Pending[R](lambda: Pending._wrap(self._func, lambda: next))
+    def then(
+        self, next: Callable[[Callable[[], T]], R], *, dbos: Optional["DBOS"] = None
+    ) -> "Pending[R]":
+        return Pending[R](lambda: Pending._wrap(self._func, lambda: next, dbos=dbos))
 
     @staticmethod
     async def _also(  # type: ignore
@@ -173,12 +215,24 @@ class Pending(Outcome[T]):
     async def _intercept(
         func: Callable[[], Coroutine[Any, Any, T]],
         interceptor: Callable[[], Union[NoResult, T]],
+        *,
+        dbos: Optional["DBOS"] = None,
     ) -> T:
+        # Make sure the executor pool is configured correctly
+        if dbos is not None:
+            await dbos._configure_asyncio_thread_pool()
         intercepted = await asyncio.to_thread(interceptor)
         return intercepted if not isinstance(intercepted, NoResult) else await func()
 
-    def intercept(self, interceptor: Callable[[], Union[NoResult, T]]) -> "Pending[T]":
-        return Pending[T](lambda: Pending._intercept(self._func, interceptor))
+    def intercept(
+        self,
+        interceptor: Callable[[], Union[NoResult, T]],
+        *,
+        dbos: Optional["DBOS"] = None,
+    ) -> "Pending[T]":
+        return Pending[T](
+            lambda: Pending._intercept(self._func, interceptor, dbos=dbos)
+        )
 
     @staticmethod
     async def _retry(

dbos/_serialization.py

@@ -12,8 +12,13 @@ class WorkflowInputs(TypedDict):
 
 
 def _validate_item(data: Any) -> None:
-    if isinstance(data, (types.FunctionType, types.MethodType)):
-        raise TypeError("Serialized data item should not be a function")
+    if isinstance(data, (types.MethodType)):
+        raise TypeError("Serialized data item should not be a class method")
+    if isinstance(data, (types.FunctionType)):
+        if jsonpickle.decode(jsonpickle.encode(data, unpicklable=True)) is None:
+            raise TypeError(
+                "Serialized function should be defined at the top level of a module"
+            )
 
 
 def serialize(data: Any) -> str:

dbos/_sys_db.py

@@ -740,6 +740,33 @@ class SystemDatabase(ABC):
             }
             return status
 
+    @db_retry()
+    def get_deduplicated_workflow(
+        self, queue_name: str, deduplication_id: str
+    ) -> Optional[str]:
+        """
+        Get the workflow ID associated with a given queue name and deduplication ID.
+
+        Args:
+            queue_name: The name of the queue
+            deduplication_id: The deduplication ID
+
+        Returns:
+            The workflow UUID if found, None otherwise
+        """
+        with self.engine.begin() as c:
+            row = c.execute(
+                sa.select(SystemSchema.workflow_status.c.workflow_uuid).where(
+                    SystemSchema.workflow_status.c.queue_name == queue_name,
+                    SystemSchema.workflow_status.c.deduplication_id == deduplication_id,
+                )
+            ).fetchone()
+
+            if row is None:
+                return None
+            workflow_id: str = row[0]
+            return workflow_id
+
     @db_retry()
     def await_workflow_result(self, workflow_id: str) -> Any:
         while True:
@@ -1221,7 +1248,10 @@ class SystemDatabase(ABC):
     def check_child_workflow(
         self, workflow_uuid: str, function_id: int
     ) -> Optional[str]:
-        sql = sa.select(SystemSchema.operation_outputs.c.child_workflow_id).where(
+        sql = sa.select(
+            SystemSchema.operation_outputs.c.child_workflow_id,
+            SystemSchema.operation_outputs.c.error,
+        ).where(
             SystemSchema.operation_outputs.c.workflow_uuid == workflow_uuid,
             SystemSchema.operation_outputs.c.function_id == function_id,
         )
@@ -1233,7 +1263,10 @@ class SystemDatabase(ABC):
 
         if row is None:
             return None
-        return str(row[0])
+        elif row[1]:
+            raise _serialization.deserialize_exception(row[1])
+        else:
+            return str(row[0])
 
     @db_retry()
     def send(
@@ -1901,8 +1934,13 @@ class SystemDatabase(ABC):
             )
             if self._debug_mode and recorded_output is None:
                 raise Exception(
-                    "called set_event in debug mode without a previous execution"
+                    "called writeStream in debug mode without a previous execution"
                 )
+            if recorded_output is not None:
+                dbos_logger.debug(
+                    f"Replaying writeStream, id: {function_id}, key: {key}"
+                )
+                return
             # Find the maximum offset for this workflow_uuid and key combination
             max_offset_result = c.execute(
                 sa.select(sa.func.max(SystemSchema.streams.c.offset)).where(

dbos/_tracer.py

@@ -77,5 +77,12 @@ class DBOSTracer:
     def end_span(self, span: Span) -> None:
         span.end()
 
+    def get_current_span(self) -> Optional[Span]:
+        # Return the current active span if any. It might not be a DBOS span.
+        span = trace.get_current_span()
+        if span.get_span_context().is_valid:
+            return span
+        return None
+
 
 dbos_tracer = DBOSTracer()

{dbos-1.13.1.dist-info → dbos-1.14.0.dist-info}/METADATA

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

{dbos-1.13.1.dist-info → dbos-1.14.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-dbos-1.13.1.dist-info/METADATA,sha256=AQTtBm1syUdzqI-4PCAbtyr0W222GWMAjePpoRaxa48,13266
-dbos-1.13.1.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-dbos-1.13.1.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-1.13.1.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
-dbos/__init__.py,sha256=NssPCubaBxdiKarOWa-wViz1hdJSkmBGcpLX_gQ4NeA,891
+dbos-1.14.0.dist-info/METADATA,sha256=5Fr-NGWHu3DheyFCoQnaLRzltjBocycWHP6sG6fZLU8,13266
+dbos-1.14.0.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+dbos-1.14.0.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-1.14.0.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos/__init__.py,sha256=pT4BuNLDCrIQX27vQG8NlfxX6PZRU7r9miq4thJTszU,982
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=e8ELhcDWqR3_PNobnNgUvLGh5lzZq0yFSF6dvtzoQRI,16267
 dbos/_alembic_migrations/env.py,sha256=38SIGVbmn_VV2x2u1aHLcPOoWgZ84eCymf3g_NljmbU,1626
@@ -24,14 +24,15 @@ dbos/_alembic_migrations/versions/eab0cc1d9a14_job_queue.py,sha256=uvhFOtqbBreCe
 dbos/_alembic_migrations/versions/f4b9b32ba814_functionname_childid_op_outputs.py,sha256=m90Lc5YH0ZISSq1MyxND6oq3RZrZKrIqEsZtwJ1jWxA,1049
 dbos/_app_db.py,sha256=GsV-uYU0QsChWwQDxnrh8_iiZ_zMQB-bsP2jPGIe2aM,16094
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=_3Wc2QQc5VDcBuJ3cNb-lWg439OuITo2ex4Y7qb9l44,18800
+dbos/_client.py,sha256=NgLpGQAPN1ehn6vIto2ToIvFUtprTWdEAbixu9wFZMU,18887
 dbos/_conductor/conductor.py,sha256=3E_hL3c9g9yWqKZkvI6KA0-ZzPMPRo06TOzT1esMiek,24114
 dbos/_conductor/protocol.py,sha256=q3rgLxINFtWFigdOONc-4gX4vn66UmMlJQD6Kj8LnL4,7420
-dbos/_context.py,sha256=IMboNgbCqTxfIORqeifE3da-Ce5siMz7MYMLPk5M-AQ,26851
-dbos/_core.py,sha256=2IWEkewiYL3d3MrhMfqj0JDWNyNM54rpW7CRGjBTPfk,48788
+dbos/_context.py,sha256=DC0yC8feklTckClG0Nc-uSDeRuTu7emLP5NmcuJiogk,27542
+dbos/_core.py,sha256=plF80l5Rh_bBpy5PFZy3p3ux6agmYkUgZq8e36i68F4,50443
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=wKLN7W1ej6cyEOHnCtt3-awnU6SR6MQAlOvTTt5_N-E,58219
+dbos/_dbos.py,sha256=AgkcE9YSC9KWsDUNfEhdbkfR9NjT0seZDAOunb3n61w,58201
 dbos/_dbos_config.py,sha256=_26ktif8qAZW4Ujg6dZfLkYO7dE4CI8b3IQbw_5YkpA,25710
+dbos/_debouncer.py,sha256=KMu64pbq7mUAY4g_9_gzP4a4FKDOv5BbLhkkh9PcBuA,15217
 dbos/_debug.py,sha256=99j2SChWmCPAlZoDmjsJGe77tpU2LEa8E2TtLAnnh7o,1831
 dbos/_docker_pg_helper.py,sha256=tLJXWqZ4S-ExcaPnxg_i6cVxL6ZxrYlZjaGsklY-s2I,6115
 dbos/_error.py,sha256=GwO0Ng4d4iB52brY09-Ss6Cz_V28Xc0D0cRCzZ6XmNM,8688
@@ -40,9 +41,9 @@ dbos/_fastapi.py,sha256=D0H6TPYYTJ0LnkKn7t9sfPwPgDx6fO8AZQtvBcH3ibI,3277
 dbos/_flask.py,sha256=Npnakt-a3W5OykONFRkDRnumaDhTQmA0NPdUCGRYKXE,1652
 dbos/_kafka.py,sha256=Gm4fHWl7gYb-i5BMvwNwm5Km3z8zQpseqdMgqgFjlGI,4252
 dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
-dbos/_logger.py,sha256=vvBL4kzJWBPtfcHIuL0nJAq5cgpeo_D3IiIUDicWLOg,4732
+dbos/_logger.py,sha256=iS4AviQViSKiz-IYCjZLWmW9x616IA-Ms9Xtwq1dcx4,4739
 dbos/_migration.py,sha256=wJrSTYerlkYDFYmkTqo4a7n4WaKmqXh8BdkUEzgSEQQ,10898
-dbos/_outcome.py,sha256=Kz3aL7517q9UEFTx3Cq9zzztjWyWVOx_08fZyHo9dvg,7035
+dbos/_outcome.py,sha256=7HvosMfEHTh1U5P6xok7kFTGLwa2lPaul0YApb3UnN4,8191
 dbos/_queue.py,sha256=0kJTPwXy3nZ4Epzt-lHky9M9S4L31645drPGFR8fIJY,4854
 dbos/_recovery.py,sha256=K-wlFhdf4yGRm6cUzyhcTjQUS0xp2T5rdNMLiiBErYg,2882
 dbos/_registrations.py,sha256=bEOntObnWaBylnebr5ZpcX2hk7OVLDd1z4BvW4_y3zA,7380
@@ -51,8 +52,8 @@ dbos/_scheduler.py,sha256=CWeGVfl9h51VXfxt80y5Da_5pE8SPty_AYkfpJkkMxQ,2117
 dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
 dbos/_schemas/system_database.py,sha256=-dAKk-_Y3vzbpLT4ei-sIrBQgFyQiwPj1enZb1TYc8I,4943
-dbos/_serialization.py,sha256=bWuwhXSQcGmiazvhJHA5gwhrRWxtmFmcCFQSDJnqqkU,3666
-dbos/_sys_db.py,sha256=DhpthOe2hbG7Cp8CxJd5tRUyqgKJ7HWbgEySpt6GTwY,81756
+dbos/_serialization.py,sha256=VOMpwuJ6IskOUEegFDPqjIoV5PoBWfH9BgtnuI1jLok,3906
+dbos/_sys_db.py,sha256=SspVk-wYmE6xZLuyYQUclwh_AMjnkDXcog5g5WmYn7c,83036
 dbos/_sys_db_postgres.py,sha256=WcG-f1CUzUNBGEOjqKEp6DDraN63jTnJ6CAfieCcxOs,7555
 dbos/_sys_db_sqlite.py,sha256=xT9l-czMhLmfuu5UcnBzAyUxSFgzt3XtEWx9t_D8mZs,7361
 dbos/_templates/dbos-db-starter/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
@@ -65,7 +66,7 @@ dbos/_templates/dbos-db-starter/migrations/env.py.dbos,sha256=IBB_gz9RjC20HPfOTG
 dbos/_templates/dbos-db-starter/migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
 dbos/_templates/dbos-db-starter/migrations/versions/2024_07_31_180642_init.py,sha256=MpS7LGaJS0CpvsjhfDkp9EJqvMvVCjRPfUp4c0aE2ys,941
 dbos/_templates/dbos-db-starter/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
-dbos/_tracer.py,sha256=8aOAVTBnj2q9DcOb5KJCfo56CVZ1ZvsWBscaNlIX-7k,3150
+dbos/_tracer.py,sha256=1MtRa0bS3ZfpZN3dw-O57_M1lc76WYK2bAThLWW2TSc,3408
 dbos/_utils.py,sha256=ZdoM1MDbHnlJrh31zfhp3iX62bAxK1kyvMwXnltC_84,1779
 dbos/_workflow_commands.py,sha256=EmmAaQfRWeOZm_WPTznuU-O3he3jiSzzT9VpYrhxugE,4835
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
@@ -75,4 +76,4 @@ dbos/cli/migration.py,sha256=5GiyagLZkyVvDz3StYxtFdkFoKFCmh6eSXjzsIGhZ_A,3330
 dbos/dbos-config.schema.json,sha256=LyUT1DOTaAwOP6suxQGS5KemVIqXGPyu_q7Hbo0neA8,6192
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-1.13.1.dist-info/RECORD,,
+dbos-1.14.0.dist-info/RECORD,,