dbos 1.14.0a6__tar.gz → 1.14.0a8__tar.gz

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

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

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

@@ -232,7 +232,10 @@ 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']}-{self.debounce_key}"
+                )
+                with SetEnqueueOptions(deduplication_id=deduplication_id):
                     with SetWorkflowTimeout(None):
                         internal_queue.enqueue(
                             debouncer_workflow,
@@ -249,7 +252,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(
@@ -333,10 +336,13 @@ class DebouncerClient:
         while True:
             try:
                 # Attempt to enqueue a debouncer for this workflow.
+                deduplication_id = (
+                    f"{self.debouncer_options['workflow_name']}-{self.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 +359,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

{dbos-1.14.0a6 → dbos-1.14.0a8}/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.0a8}/pyproject.toml

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

{dbos-1.14.0a6 → dbos-1.14.0a8}/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,17 +30,20 @@ def test_debouncer(dbos: DBOS) -> None:
         return str(uuid.uuid4())
 
     def debouncer_test() -> None:
-        debouncer = Debouncer.create(workflow, debounce_key="key")
 
         debounce_period = 2
 
+        debouncer = Debouncer.create(workflow, debounce_key="key")
         first_handle = debouncer.debounce(debounce_period, first_value)
+        debouncer = Debouncer.create(workflow, debounce_key="key")
         second_handle = debouncer.debounce(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
 
+        debouncer = Debouncer.create(workflow, debounce_key="key")
         third_handle = debouncer.debounce(debounce_period, third_value)
+        debouncer = Debouncer.create(workflow, debounce_key="key")
         fourth_handle = debouncer.debounce(debounce_period, fourth_value)
         assert third_handle.workflow_id != first_handle.workflow_id
         assert third_handle.workflow_id == fourth_handle.workflow_id
@@ -76,7 +74,10 @@ 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
@@ -115,9 +116,38 @@ def test_debouncer_timeout(dbos: DBOS) -> None:
     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, debounce_key="key_one")
+    debouncer_two = Debouncer.create(workflow, debounce_key="key_two")
+    debounce_period = 2
+
+    first_handle = debouncer_one.debounce(debounce_period, first_value)
+    second_handle = debouncer_one.debounce(debounce_period, second_value)
+    third_handle = debouncer_two.debounce(debounce_period, third_value)
+    fourth_handle = debouncer_two.debounce(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")
 
@@ -166,7 +196,10 @@ 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")
@@ -188,12 +221,15 @@ 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")
@@ -230,12 +266,15 @@ 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")

{dbos-1.14.0a6 → dbos-1.14.0a8}/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"))