dbos 0.17.0a2__tar.gz → 0.17.0a4__tar.gz

{dbos-0.17.0a2 → dbos-0.17.0a4}/PKG-INFO

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

{dbos-0.17.0a2 → dbos-0.17.0a4}/dbos/_core.py

@@ -21,7 +21,7 @@ from typing import (
     overload,
 )
 
-from dbos._outcome import Immediate, Outcome, Pending
+from dbos._outcome import Immediate, NoResult, Outcome, Pending
 
 from ._app_db import ApplicationDatabase, TransactionResultInternal
 
@@ -719,7 +719,7 @@ def decorate_step(
                 finally:
                     dbos._sys_db.record_operation_result(step_output)
 
-            def check_existing_result() -> Optional[str]:
+            def check_existing_result() -> Union[NoResult, R]:
                 ctx = assert_current_dbos_context()
                 recorded_output = dbos._sys_db.check_operation_execution(
                     ctx.workflow_id, ctx.function_id
@@ -734,14 +734,16 @@ def decorate_step(
                         )
                         raise deserialized_error
                     elif recorded_output["output"] is not None:
-                        return recorded_output["output"]
+                        return cast(
+                            R, _serialization.deserialize(recorded_output["output"])
+                        )
                     else:
                         raise Exception("Output and error are both None")
                 else:
                     dbos.logger.debug(
                         f"Running step, id: {ctx.function_id}, name: {attributes['name']}"
                     )
-                    return None
+                    return NoResult()
 
             stepOutcome = Outcome[R].make(functools.partial(func, *args, **kwargs))
             if retries_allowed:

{dbos-0.17.0a2 → dbos-0.17.0a4}/dbos/_outcome.py

@@ -4,12 +4,20 @@ import inspect
 import time
 from typing import Any, Callable, Coroutine, Optional, Protocol, TypeVar, Union, cast
 
-from . import _serialization
-
 T = TypeVar("T")
 R = TypeVar("R")
 
 
+class NoResult:
+    _instance: Optional["NoResult"] = None
+    __slots__ = ()
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "NoResult":
+        if not cls._instance:
+            cls._instance = super(NoResult, cls).__new__(cls, *args, **kwargs)
+        return cls._instance
+
+
 # define Outcome protocol w/ common composition methods
 class Outcome(Protocol[T]):
 
@@ -30,7 +38,9 @@ class Outcome(Protocol[T]):
         exceeded_retries: Callable[[int], BaseException],
     ) -> "Outcome[T]": ...
 
-    def intercept(self, interceptor: Callable[[], Optional[str]]) -> "Outcome[T]": ...
+    def intercept(
+        self, interceptor: Callable[[], Union[NoResult, T]]
+    ) -> "Outcome[T]": ...
 
     def __call__(self) -> Union[T, Coroutine[Any, Any, T]]: ...
 
@@ -61,14 +71,14 @@ class Immediate(Outcome[T]):
 
     @staticmethod
     def _intercept(
-        func: Callable[[], T], interceptor: Callable[[], Optional[str]]
+        func: Callable[[], T], interceptor: Callable[[], Union[NoResult, T]]
     ) -> T:
         intercepted = interceptor()
-        return (
-            cast(T, _serialization.deserialize(intercepted)) if intercepted else func()
-        )
+        return intercepted if not isinstance(intercepted, NoResult) else func()
 
-    def intercept(self, interceptor: Callable[[], Optional[str]]) -> "Immediate[T]":
+    def intercept(
+        self, interceptor: Callable[[], Union[NoResult, T]]
+    ) -> "Immediate[T]":
         return Immediate[T](lambda: Immediate._intercept(self._func, interceptor))
 
     @staticmethod
@@ -157,16 +167,12 @@ class Pending(Outcome[T]):
     @staticmethod
     async def _intercept(
         func: Callable[[], Coroutine[Any, Any, T]],
-        interceptor: Callable[[], Optional[str]],
+        interceptor: Callable[[], Union[NoResult, T]],
     ) -> T:
         intercepted = await asyncio.to_thread(interceptor)
-        return (
-            cast(T, _serialization.deserialize(intercepted))
-            if intercepted
-            else await func()
-        )
+        return intercepted if not isinstance(intercepted, NoResult) else await func()
 
-    def intercept(self, interceptor: Callable[[], Optional[str]]) -> "Pending[T]":
+    def intercept(self, interceptor: Callable[[], Union[NoResult, T]]) -> "Pending[T]":
         return Pending[T](lambda: Pending._intercept(self._func, interceptor))
 
     @staticmethod

{dbos-0.17.0a2 → dbos-0.17.0a4}/pyproject.toml

@@ -23,7 +23,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.17.0a2"
+version = "0.17.0a4"
 
 [project.license]
 text = "MIT"

{dbos-0.17.0a2 → dbos-0.17.0a4}/tests/test_dbos.py

@@ -318,6 +318,7 @@ def test_temp_workflow_errors(dbos: DBOS) -> None:
 
 def test_recovery_workflow(dbos: DBOS) -> None:
     txn_counter: int = 0
+    txn_return_none_counter: int = 0
     wf_counter: int = 0
 
     @DBOS.workflow()
@@ -325,6 +326,8 @@ def test_recovery_workflow(dbos: DBOS) -> None:
         nonlocal wf_counter
         wf_counter += 1
         res = test_transaction(var2)
+        should_be_none = test_transaction_return_none()
+        assert should_be_none is None
         return res + var
 
     @DBOS.transaction()
@@ -334,6 +337,13 @@ def test_recovery_workflow(dbos: DBOS) -> None:
         txn_counter += 1
         return var2 + str(rows[0][0])
 
+    @DBOS.transaction()
+    def test_transaction_return_none() -> None:
+        nonlocal txn_return_none_counter
+        DBOS.sql_session.execute(sa.text("SELECT 1")).fetchall()
+        txn_return_none_counter += 1
+        return
+
     wfuuid = str(uuid.uuid4())
     with SetWorkflowID(wfuuid):
         assert test_workflow("bob", "bob") == "bob1bob"
@@ -367,6 +377,7 @@ def test_recovery_workflow(dbos: DBOS) -> None:
     assert workflow_handles[0].get_result() == "bob1bob"
     assert wf_counter == 2
     assert txn_counter == 1
+    assert txn_return_none_counter == 1
 
     # Test that there was a recovery attempt of this
     stat = workflow_handles[0].get_status()
@@ -382,7 +393,8 @@ def test_recovery_workflow_step(dbos: DBOS) -> None:
     def test_workflow(var: str, var2: str) -> str:
         nonlocal wf_counter
         wf_counter += 1
-        test_step(var2)
+        should_be_none = test_step(var2)
+        assert should_be_none is None
         return var
 
     @DBOS.step()
@@ -432,6 +444,63 @@ def test_recovery_workflow_step(dbos: DBOS) -> None:
     assert stat.recovery_attempts == 1
 
 
+def test_workflow_returns_none(dbos: DBOS) -> None:
+    wf_counter: int = 0
+
+    @DBOS.workflow()
+    def test_workflow(var: str, var2: str) -> None:
+        nonlocal wf_counter
+        wf_counter += 1
+        assert var == var2 == "bob"
+        return
+
+    wfuuid = str(uuid.uuid4())
+    with SetWorkflowID(wfuuid):
+        assert test_workflow("bob", "bob") is None
+    assert wf_counter == 1
+
+    dbos._sys_db.wait_for_buffer_flush()
+    with SetWorkflowID(wfuuid):
+        assert test_workflow("bob", "bob") is None
+    assert wf_counter == 2
+
+    handle: WorkflowHandle[None] = DBOS.retrieve_workflow(wfuuid)
+    assert handle.get_result() == None
+    assert wf_counter == 2
+
+    # Change the workflow status to pending
+    dbos._sys_db.update_workflow_status(
+        {
+            "workflow_uuid": wfuuid,
+            "status": "PENDING",
+            "name": test_workflow.__qualname__,
+            "class_name": None,
+            "config_name": None,
+            "output": None,
+            "error": None,
+            "executor_id": None,
+            "app_id": None,
+            "app_version": None,
+            "request": None,
+            "recovery_attempts": None,
+            "authenticated_user": None,
+            "authenticated_roles": None,
+            "assumed_role": None,
+            "queue_name": None,
+        }
+    )
+
+    workflow_handles = DBOS.recover_pending_workflows()
+    assert len(workflow_handles) == 1
+    assert workflow_handles[0].get_result() is None
+    assert wf_counter == 3
+
+    # Test that there was a recovery attempt of this
+    stat = workflow_handles[0].get_status()
+    assert stat
+    assert stat.recovery_attempts == 1
+
+
 def test_recovery_temp_workflow(dbos: DBOS) -> None:
     txn_counter: int = 0