dbos 1.14.0a6__tar.gz → 1.14.0a9__tar.gz

{dbos-1.14.0a6 → dbos-1.14.0a9}/PKG-INFO

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

{dbos-1.14.0a6 → dbos-1.14.0a9}/dbos/_debouncer.py

@@ -147,7 +147,6 @@ class Debouncer(Generic[P, R]):
         self,
         workflow_name: str,
         *,
-        debounce_key: str,
         debounce_timeout_sec: Optional[float] = None,
         queue: Optional[Queue] = None,
     ):
@@ -157,13 +156,11 @@ class Debouncer(Generic[P, R]):
             "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]":
@@ -172,7 +169,6 @@ class Debouncer(Generic[P, R]):
             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,
         )
@@ -181,7 +177,6 @@ class Debouncer(Generic[P, R]):
     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]":
@@ -190,13 +185,16 @@ class Debouncer(Generic[P, R]):
             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
+        self,
+        debounce_key: str,
+        debounce_period_sec: float,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> "WorkflowHandle[R]":
         from dbos._dbos import DBOS, _get_dbos_instance
 
@@ -232,7 +230,8 @@ class Debouncer(Generic[P, R]):
         while True:
             try:
                 # Attempt to enqueue a debouncer for this workflow.
-                with SetEnqueueOptions(deduplication_id=self.debounce_key):
+                deduplication_id = f"{self.options['workflow_name']}-{debounce_key}"
+                with SetEnqueueOptions(deduplication_id=deduplication_id):
                     with SetWorkflowTimeout(None):
                         internal_queue.enqueue(
                             debouncer_workflow,
@@ -249,7 +248,7 @@ class Debouncer(Generic[P, R]):
                 def get_deduplicated_workflow() -> Optional[str]:
                     return dbos._sys_db.get_deduplicated_workflow(
                         queue_name=internal_queue.name,
-                        deduplication_id=self.debounce_key,
+                        deduplication_id=deduplication_id,
                     )
 
                 dedup_wfid = dbos._sys_db.call_function_as_step(
@@ -281,6 +280,7 @@ class Debouncer(Generic[P, R]):
 
     async def debounce_async(
         self,
+        debounce_key: str,
         debounce_period_sec: float,
         *args: P.args,
         **kwargs: P.kwargs,
@@ -289,7 +289,7 @@ class Debouncer(Generic[P, R]):
 
         dbos = _get_dbos_instance()
         handle = await asyncio.to_thread(
-            self.debounce, debounce_period_sec, *args, **kwargs
+            self.debounce, debounce_key, debounce_period_sec, *args, **kwargs
         )
         return WorkflowHandleAsyncPolling(handle.workflow_id, dbos)
 
@@ -301,7 +301,6 @@ class DebouncerClient:
         client: DBOSClient,
         workflow_options: EnqueueOptions,
         *,
-        debounce_key: str,
         debounce_timeout_sec: Optional[float] = None,
         queue: Optional[Queue] = None,
     ):
@@ -311,11 +310,10 @@ class DebouncerClient:
             "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
+        self, debounce_key: str, debounce_period_sec: float, *args: Any, **kwargs: Any
     ) -> "WorkflowHandle[R]":
 
         ctxOptions: ContextOptions = {
@@ -333,10 +331,13 @@ class DebouncerClient:
         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": self.debounce_key,
+                    "deduplication_id": deduplication_id,
                 }
                 self.client.enqueue(
                     debouncer_options,
@@ -353,7 +354,7 @@ class DebouncerClient:
                 # 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,
+                    deduplication_id=deduplication_id,
                 )
                 if dedup_wfid is None:
                     continue
@@ -384,10 +385,10 @@ class DebouncerClient:
                     )
 
     async def debounce_async(
-        self, debounce_period_sec: float, *args: Any, **kwargs: Any
+        self, deboucne_key: str, debounce_period_sec: float, *args: Any, **kwargs: Any
     ) -> "WorkflowHandleAsync[R]":
         handle: "WorkflowHandle[R]" = await asyncio.to_thread(
-            self.debounce, debounce_period_sec, *args, **kwargs
+            self.debounce, deboucne_key, debounce_period_sec, *args, **kwargs
         )
         return WorkflowHandleClientAsyncPolling[R](
             handle.workflow_id, self.client._sys_db

{dbos-1.14.0a6 → dbos-1.14.0a9}/dbos/_sys_db.py

@@ -1934,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-1.14.0a6 → dbos-1.14.0a9}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "1.14.0a6"
+version = "1.14.0a9"
 
 [project.license]
 text = "MIT"

{dbos-1.14.0a6 → dbos-1.14.0a9}/tests/test_debouncer.py

@@ -17,17 +17,12 @@ from dbos._queue import Queue
 from dbos._utils import GlobalParams
 
 
-def workflow(x: int) -> int:
-    return x
-
-
-async def workflow_async(x: int) -> int:
-    return x
-
-
 def test_debouncer(dbos: DBOS) -> None:
 
-    DBOS.workflow()(workflow)
+    @DBOS.workflow()
+    def workflow(x: int) -> int:
+        return x
+
     first_value, second_value, third_value, fourth_value = 0, 1, 2, 3
 
     @DBOS.step()
@@ -35,18 +30,21 @@ def test_debouncer(dbos: DBOS) -> None:
         return str(uuid.uuid4())
 
     def debouncer_test() -> None:
-        debouncer = Debouncer.create(workflow, debounce_key="key")
 
         debounce_period = 2
 
-        first_handle = debouncer.debounce(debounce_period, first_value)
-        second_handle = debouncer.debounce(debounce_period, second_value)
+        debouncer = Debouncer.create(workflow)
+        first_handle = debouncer.debounce("key", debounce_period, first_value)
+        debouncer = Debouncer.create(workflow)
+        second_handle = debouncer.debounce("key", debounce_period, second_value)
         assert first_handle.workflow_id == second_handle.workflow_id
         assert first_handle.get_result() == second_value
         assert second_handle.get_result() == second_value
 
-        third_handle = debouncer.debounce(debounce_period, third_value)
-        fourth_handle = debouncer.debounce(debounce_period, fourth_value)
+        debouncer = Debouncer.create(workflow)
+        third_handle = debouncer.debounce("key", debounce_period, third_value)
+        debouncer = Debouncer.create(workflow)
+        fourth_handle = debouncer.debounce("key", debounce_period, fourth_value)
         assert third_handle.workflow_id != first_handle.workflow_id
         assert third_handle.workflow_id == fourth_handle.workflow_id
         assert third_handle.get_result() == fourth_value
@@ -55,7 +53,7 @@ def test_debouncer(dbos: DBOS) -> None:
         # Test SetWorkflowID works
         wfid = generate_uuid()
         with SetWorkflowID(wfid):
-            handle = debouncer.debounce(debounce_period, first_value)
+            handle = debouncer.debounce("key", debounce_period, first_value)
         assert handle.workflow_id == wfid
         assert handle.get_result() == first_value
 
@@ -76,25 +74,27 @@ def test_debouncer(dbos: DBOS) -> None:
 
 def test_debouncer_timeout(dbos: DBOS) -> None:
 
-    DBOS.workflow()(workflow)
+    @DBOS.workflow()
+    def workflow(x: int) -> int:
+        return x
+
     first_value, second_value, third_value, fourth_value = 0, 1, 2, 3
 
     # Set a huge period but small timeout, verify workflows start after the timeout
     debouncer = Debouncer.create(
         workflow,
-        debounce_key="key",
         debounce_timeout_sec=2,
     )
     long_debounce_period = 10000000
 
-    first_handle = debouncer.debounce(long_debounce_period, first_value)
-    second_handle = debouncer.debounce(long_debounce_period, second_value)
+    first_handle = debouncer.debounce("key", long_debounce_period, first_value)
+    second_handle = debouncer.debounce("key", long_debounce_period, second_value)
     assert first_handle.workflow_id == second_handle.workflow_id
     assert first_handle.get_result() == second_value
     assert second_handle.get_result() == second_value
 
-    third_handle = debouncer.debounce(long_debounce_period, third_value)
-    fourth_handle = debouncer.debounce(long_debounce_period, fourth_value)
+    third_handle = debouncer.debounce("key", long_debounce_period, third_value)
+    fourth_handle = debouncer.debounce("key", long_debounce_period, fourth_value)
     assert third_handle.workflow_id != first_handle.workflow_id
     assert third_handle.workflow_id == fourth_handle.workflow_id
     assert third_handle.get_result() == fourth_value
@@ -103,29 +103,57 @@ def test_debouncer_timeout(dbos: DBOS) -> None:
     # Submit first with a long period then with a short one, verify workflows start on time
     debouncer = Debouncer.create(
         workflow,
-        debounce_key="key",
     )
     short_debounce_period = 1
 
-    first_handle = debouncer.debounce(long_debounce_period, first_value)
-    second_handle = debouncer.debounce(short_debounce_period, second_value)
+    first_handle = debouncer.debounce("key", long_debounce_period, first_value)
+    second_handle = debouncer.debounce("key", short_debounce_period, second_value)
     assert fourth_handle.workflow_id != first_handle.workflow_id
     assert first_handle.workflow_id == second_handle.workflow_id
     assert first_handle.get_result() == second_value
     assert second_handle.get_result() == second_value
 
 
+def test_multiple_debouncers(dbos: DBOS) -> None:
+
+    @DBOS.workflow()
+    def workflow(x: int) -> int:
+        return x
+
+    first_value, second_value, third_value, fourth_value = 0, 1, 2, 3
+
+    # Set a huge period but small timeout, verify workflows start after the timeout
+    debouncer_one = Debouncer.create(workflow)
+    debouncer_two = Debouncer.create(workflow)
+    debounce_period = 2
+
+    first_handle = debouncer_one.debounce("key_one", debounce_period, first_value)
+    second_handle = debouncer_one.debounce("key_one", debounce_period, second_value)
+    third_handle = debouncer_two.debounce("key_two", debounce_period, third_value)
+    fourth_handle = debouncer_two.debounce("key_two", debounce_period, fourth_value)
+    assert first_handle.workflow_id == second_handle.workflow_id
+    assert first_handle.workflow_id != third_handle.workflow_id
+    assert third_handle.workflow_id == fourth_handle.workflow_id
+    assert first_handle.get_result() == second_value
+    assert second_handle.get_result() == second_value
+    assert third_handle.get_result() == fourth_value
+    assert fourth_handle.get_result() == fourth_value
+
+
 def test_debouncer_queue(dbos: DBOS) -> None:
 
-    DBOS.workflow()(workflow)
+    @DBOS.workflow()
+    def workflow(x: int) -> int:
+        return x
+
     first_value, second_value, third_value, fourth_value = 0, 1, 2, 3
     queue = Queue("test-queue")
 
-    debouncer = Debouncer.create(workflow, debounce_key="key", queue=queue)
+    debouncer = Debouncer.create(workflow, queue=queue)
     debounce_period_sec = 2
 
-    first_handle = debouncer.debounce(debounce_period_sec, first_value)
-    second_handle = debouncer.debounce(debounce_period_sec, second_value)
+    first_handle = debouncer.debounce("key", debounce_period_sec, first_value)
+    second_handle = debouncer.debounce("key", debounce_period_sec, second_value)
     assert first_handle.workflow_id == second_handle.workflow_id
     assert first_handle.get_result() == second_value
     assert second_handle.get_result() == second_value
@@ -133,8 +161,8 @@ def test_debouncer_queue(dbos: DBOS) -> None:
 
     # Test SetWorkflowTimeout works
     with SetWorkflowTimeout(5.0):
-        third_handle = debouncer.debounce(debounce_period_sec, third_value)
-        fourth_handle = debouncer.debounce(debounce_period_sec, fourth_value)
+        third_handle = debouncer.debounce("key", debounce_period_sec, third_value)
+        fourth_handle = debouncer.debounce("key", debounce_period_sec, fourth_value)
     assert third_handle.workflow_id != first_handle.workflow_id
     assert third_handle.workflow_id == fourth_handle.workflow_id
     assert third_handle.get_result() == fourth_value
@@ -146,7 +174,7 @@ def test_debouncer_queue(dbos: DBOS) -> None:
     # Test SetWorkflowID works
     wfid = str(uuid.uuid4())
     with SetWorkflowID(wfid):
-        handle = debouncer.debounce(debounce_period_sec, first_value)
+        handle = debouncer.debounce("key", debounce_period_sec, first_value)
     assert handle.workflow_id == wfid
     assert handle.get_result() == first_value
     assert handle.get_status().queue_name == queue.name
@@ -157,7 +185,7 @@ def test_debouncer_queue(dbos: DBOS) -> None:
     with SetEnqueueOptions(
         priority=1, deduplication_id="test", app_version=test_version
     ):
-        handle = debouncer.debounce(debounce_period_sec, first_value)
+        handle = debouncer.debounce("key", debounce_period_sec, first_value)
     assert handle.get_result() == first_value
     assert handle.get_status().queue_name == queue.name
     assert handle.get_status().app_version == test_version
@@ -166,20 +194,31 @@ def test_debouncer_queue(dbos: DBOS) -> None:
 @pytest.mark.asyncio
 async def test_debouncer_async(dbos: DBOS) -> None:
 
-    DBOS.workflow()(workflow_async)
+    @DBOS.workflow()
+    async def workflow_async(x: int) -> int:
+        return x
+
     first_value, second_value, third_value, fourth_value = 0, 1, 2, 3
 
-    debouncer = Debouncer.create_async(workflow_async, debounce_key="key")
+    debouncer = Debouncer.create_async(workflow_async)
     debounce_period_sec = 2
 
-    first_handle = await debouncer.debounce_async(debounce_period_sec, first_value)
-    second_handle = await debouncer.debounce_async(debounce_period_sec, second_value)
+    first_handle = await debouncer.debounce_async(
+        "key", debounce_period_sec, first_value
+    )
+    second_handle = await debouncer.debounce_async(
+        "key", debounce_period_sec, second_value
+    )
     assert first_handle.workflow_id == second_handle.workflow_id
     assert await first_handle.get_result() == second_value
     assert await second_handle.get_result() == second_value
 
-    third_handle = await debouncer.debounce_async(debounce_period_sec, third_value)
-    fourth_handle = await debouncer.debounce_async(debounce_period_sec, fourth_value)
+    third_handle = await debouncer.debounce_async(
+        "key", debounce_period_sec, third_value
+    )
+    fourth_handle = await debouncer.debounce_async(
+        "key", debounce_period_sec, fourth_value
+    )
     assert third_handle.workflow_id != first_handle.workflow_id
     assert third_handle.workflow_id == fourth_handle.workflow_id
     assert await third_handle.get_result() == fourth_value
@@ -188,32 +227,35 @@ async def test_debouncer_async(dbos: DBOS) -> None:
 
 def test_debouncer_client(dbos: DBOS, client: DBOSClient) -> None:
 
-    DBOS.workflow()(workflow)
+    @DBOS.workflow()
+    def workflow(x: int) -> int:
+        return x
+
     first_value, second_value, third_value, fourth_value = 0, 1, 2, 3
     queue = Queue("test-queue")
 
     options: EnqueueOptions = {
-        "workflow_name": workflow.__name__,
+        "workflow_name": workflow.__qualname__,
         "queue_name": queue.name,
     }
-    debouncer = DebouncerClient(client, options, debounce_key="key")
+    debouncer = DebouncerClient(client, options)
     debounce_period_sec = 2
 
     first_handle: WorkflowHandle[int] = debouncer.debounce(
-        debounce_period_sec, first_value
+        "key", debounce_period_sec, first_value
     )
     second_handle: WorkflowHandle[int] = debouncer.debounce(
-        debounce_period_sec, second_value
+        "key", debounce_period_sec, second_value
     )
     assert first_handle.workflow_id == second_handle.workflow_id
     assert first_handle.get_result() == second_value
     assert second_handle.get_result() == second_value
 
     third_handle: WorkflowHandle[int] = debouncer.debounce(
-        debounce_period_sec, third_value
+        "key", debounce_period_sec, third_value
     )
     fourth_handle: WorkflowHandle[int] = debouncer.debounce(
-        debounce_period_sec, fourth_value
+        "key", debounce_period_sec, fourth_value
     )
     assert third_handle.workflow_id != first_handle.workflow_id
     assert third_handle.workflow_id == fourth_handle.workflow_id
@@ -222,7 +264,9 @@ def test_debouncer_client(dbos: DBOS, client: DBOSClient) -> None:
 
     wfid = str(uuid.uuid4())
     options["workflow_id"] = wfid
-    handle: WorkflowHandle[int] = debouncer.debounce(debounce_period_sec, first_value)
+    handle: WorkflowHandle[int] = debouncer.debounce(
+        "key", debounce_period_sec, first_value
+    )
     assert handle.workflow_id == wfid
     assert handle.get_result() == first_value
 
@@ -230,32 +274,35 @@ def test_debouncer_client(dbos: DBOS, client: DBOSClient) -> None:
 @pytest.mark.asyncio
 async def test_debouncer_client_async(dbos: DBOS, client: DBOSClient) -> None:
 
-    DBOS.workflow()(workflow_async)
+    @DBOS.workflow()
+    async def workflow_async(x: int) -> int:
+        return x
+
     first_value, second_value, third_value, fourth_value = 0, 1, 2, 3
     queue = Queue("test-queue")
 
     options: EnqueueOptions = {
-        "workflow_name": workflow_async.__name__,
+        "workflow_name": workflow_async.__qualname__,
         "queue_name": queue.name,
     }
-    debouncer = DebouncerClient(client, options, debounce_key="key")
+    debouncer = DebouncerClient(client, options)
     debounce_period_sec = 2
 
     first_handle: WorkflowHandleAsync[int] = await debouncer.debounce_async(
-        debounce_period_sec, first_value
+        "key", debounce_period_sec, first_value
     )
     second_handle: WorkflowHandleAsync[int] = await debouncer.debounce_async(
-        debounce_period_sec, second_value
+        "key", debounce_period_sec, second_value
     )
     assert first_handle.workflow_id == second_handle.workflow_id
     assert await first_handle.get_result() == second_value
     assert await second_handle.get_result() == second_value
 
     third_handle: WorkflowHandleAsync[int] = await debouncer.debounce_async(
-        debounce_period_sec, third_value
+        "key", debounce_period_sec, third_value
     )
     fourth_handle: WorkflowHandleAsync[int] = await debouncer.debounce_async(
-        debounce_period_sec, fourth_value
+        "key", debounce_period_sec, fourth_value
     )
     assert third_handle.workflow_id != first_handle.workflow_id
     assert third_handle.workflow_id == fourth_handle.workflow_id
@@ -265,7 +312,7 @@ async def test_debouncer_client_async(dbos: DBOS, client: DBOSClient) -> None:
     wfid = str(uuid.uuid4())
     options["workflow_id"] = wfid
     handle: WorkflowHandleAsync[int] = await debouncer.debounce_async(
-        debounce_period_sec, first_value
+        "key", debounce_period_sec, first_value
     )
     assert handle.workflow_id == wfid
     assert await handle.get_result() == first_value

{dbos-1.14.0a6 → dbos-1.14.0a9}/tests/test_streaming.py

@@ -231,16 +231,19 @@ def test_stream_error_cases(dbos: DBOS) -> None:
 def test_stream_workflow_recovery(dbos: DBOS) -> None:
     """Test that stream operations are properly recovered during workflow replay."""
 
-    call_count = 0
+    workflow_call_count = 0
+    step_call_count = 0
 
     @DBOS.step()
     def counting_step() -> int:
-        nonlocal call_count
-        call_count += 1
-        return call_count
+        nonlocal step_call_count
+        step_call_count += 1
+        return step_call_count
 
     @DBOS.workflow()
     def recovery_test_workflow() -> None:
+        nonlocal workflow_call_count
+        workflow_call_count += 1
         count1 = counting_step()
         DBOS.write_stream("recovery_stream", f"step_{count1}")
 
@@ -254,13 +257,18 @@ def test_stream_workflow_recovery(dbos: DBOS) -> None:
     with SetWorkflowID(wfid):
         recovery_test_workflow()
 
+    # Validate stream contents
+    values = list(DBOS.read_stream(wfid, "recovery_stream"))
+    assert values == ["step_1", "step_2"]
+
     # Reset call count and run the same workflow ID again (should replay)
-    call_count = 0
+    dbos._sys_db.update_workflow_outcome(wfid, "PENDING")
     with SetWorkflowID(wfid):
         recovery_test_workflow()
 
-    # The counting step should not have been called again (replayed from recorded results)
-    assert call_count == 0
+    # The workflow should have been called again
+    assert workflow_call_count == 2
+    assert step_call_count == 2
 
     # Stream should still be readable and contain the same values
     values = list(DBOS.read_stream(wfid, "recovery_stream"))