dbos 1.14.0a5__py3-none-any.whl → 1.14.0a6__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

@@ -524,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
@@ -533,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
@@ -557,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

@@ -50,6 +50,7 @@ from ._error import (
     DBOSException,
     DBOSMaxStepRetriesExceeded,
     DBOSNonExistentWorkflowError,
+    DBOSQueueDeduplicatedError,
     DBOSRecoveryError,
     DBOSUnexpectedStepError,
     DBOSWorkflowCancelledError,
@@ -95,6 +96,7 @@ 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:
@@ -310,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()

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()

dbos/_debouncer.py

@@ -0,0 +1,394 @@
+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_key: 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,
+        }
+        self.debounce_key = debounce_key
+
+    @staticmethod
+    def create(
+        workflow: Callable[P, R],
+        *,
+        debounce_key: str,
+        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_key=debounce_key,
+            debounce_timeout_sec=debounce_timeout_sec,
+            queue=queue,
+        )
+
+    @staticmethod
+    def create_async(
+        workflow: Callable[P, Coroutine[Any, Any, R]],
+        *,
+        debounce_key: str,
+        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_key=debounce_key,
+            debounce_timeout_sec=debounce_timeout_sec,
+            queue=queue,
+        )
+
+    def debounce(
+        self, 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.
+                with SetEnqueueOptions(deduplication_id=self.debounce_key):
+                    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=self.debounce_key,
+                    )
+
+                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_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_period_sec, *args, **kwargs
+        )
+        return WorkflowHandleAsyncPolling(handle.workflow_id, dbos)
+
+
+class DebouncerClient:
+
+    def __init__(
+        self,
+        client: DBOSClient,
+        workflow_options: EnqueueOptions,
+        *,
+        debounce_key: str,
+        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.debounce_key = debounce_key
+        self.client = client
+
+    def debounce(
+        self, 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.
+                debouncer_options: EnqueueOptions = {
+                    "workflow_name": DEBOUNCER_WORKFLOW_NAME,
+                    "queue_name": INTERNAL_QUEUE_NAME,
+                    "deduplication_id": self.debounce_key,
+                }
+                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=self.debounce_key,
+                )
+                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, debounce_period_sec: float, *args: Any, **kwargs: Any
+    ) -> "WorkflowHandleAsync[R]":
+        handle: "WorkflowHandle[R]" = await asyncio.to_thread(
+            self.debounce, debounce_period_sec, *args, **kwargs
+        )
+        return WorkflowHandleClientAsyncPolling[R](
+            handle.workflow_id, self.client._sys_db
+        )

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(

{dbos-1.14.0a5.dist-info → dbos-1.14.0a6.dist-info}/METADATA

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

{dbos-1.14.0a5.dist-info → dbos-1.14.0a6.dist-info}/RECORD

@@ -1,8 +1,8 @@
-dbos-1.14.0a5.dist-info/METADATA,sha256=TDRJ02P3spTH9e3UKquTU4V0fhr2Hoq7i_yWosvisGM,13268
-dbos-1.14.0a5.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-dbos-1.14.0a5.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-1.14.0a5.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
-dbos/__init__.py,sha256=NssPCubaBxdiKarOWa-wViz1hdJSkmBGcpLX_gQ4NeA,891
+dbos-1.14.0a6.dist-info/METADATA,sha256=SkLS0HlCdwrO5LyiXP_ls-yAZNRlnUJkFWSUbS4qiqM,13268
+dbos-1.14.0a6.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+dbos-1.14.0a6.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-1.14.0a6.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=fzozSsccFVwjtrJVXOfYBA0_x1S21RvvCTyN-VM644g,27111
-dbos/_core.py,sha256=0F1rNYTYLh3kjZB_APh38fblSaKev-2tG8G-9D0rxms,49876
+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=ftbVR5wAHSnc_PXpecVC1ZylY6c8UyiZRpcT2kSO8NQ,58226
+dbos/_dbos.py,sha256=AgkcE9YSC9KWsDUNfEhdbkfR9NjT0seZDAOunb3n61w,58201
 dbos/_dbos_config.py,sha256=_26ktif8qAZW4Ujg6dZfLkYO7dE4CI8b3IQbw_5YkpA,25710
+dbos/_debouncer.py,sha256=zsfGoFCNs2DnCTSkv6pDgNspzOnqsoquSlHgmi2nbXo,15124
 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
@@ -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=fvrO3F-tOh8zgfxTNbnwksWLVdXYZVQJceIp6ZJOOlw,82838
 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
@@ -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.14.0a5.dist-info/RECORD,,
+dbos-1.14.0a6.dist-info/RECORD,,