dbos 1.14.0a2__tar.gz → 1.14.0a4__tar.gz

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

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

{dbos-1.14.0a2 → dbos-1.14.0a4}/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
 
@@ -58,6 +56,7 @@ from ._error import (
     DBOSWorkflowConflictIDError,
     DBOSWorkflowFunctionNotFoundError,
 )
+from ._logger import dbos_logger
 from ._registrations import (
     DEFAULT_MAX_RECOVERY_ATTEMPTS,
     get_config_name,
@@ -98,6 +97,14 @@ F = TypeVar("F", bound=Callable[..., Any])
 TEMP_SEND_WF_NAME = "<temp>.temp_send_workflow"
 
 
+def check_is_in_coroutine() -> bool:
+    try:
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
+
+
 class WorkflowHandleFuture(Generic[R]):
 
     def __init__(self, workflow_id: str, future: Future[R], dbos: "DBOS"):
@@ -830,11 +837,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
 
@@ -1011,6 +1023,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:
@@ -1146,7 +1162,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 +1171,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-1.14.0a2 → dbos-1.14.0a4}/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-1.14.0a2 → dbos-1.14.0a4}/pyproject.toml

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

{dbos-1.14.0a2 → dbos-1.14.0a4}/tests/test_async.py

@@ -5,6 +5,9 @@ from typing import List, Optional
 
 import pytest
 import sqlalchemy as sa
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, InMemoryLogExporter
 
 # Public API
 from dbos import (
@@ -19,6 +22,8 @@ from dbos._context import assert_current_dbos_context
 from dbos._dbos import WorkflowHandle
 from dbos._dbos_config import ConfigFile
 from dbos._error import DBOSAwaitedWorkflowCancelledError, DBOSException
+from dbos._logger import dbos_logger
+from dbos._registrations import get_dbos_func_name
 
 
 @pytest.mark.asyncio
@@ -31,7 +36,7 @@ async def test_async_workflow(dbos: DBOS) -> None:
     async def test_workflow(var1: str, var2: str) -> str:
         nonlocal wf_counter
         wf_counter += 1
-        res1 = test_transaction(var1)
+        res1 = await asyncio.to_thread(test_transaction, var1)
         res2 = await test_step(var2)
         DBOS.logger.info("I'm test_workflow")
         return res1 + res2
@@ -88,7 +93,7 @@ async def test_async_step(dbos: DBOS) -> None:
     async def test_workflow(var1: str, var2: str) -> str:
         nonlocal wf_counter
         wf_counter += 1
-        res1 = test_transaction(var1)
+        res1 = await asyncio.to_thread(test_transaction, var1)
         res2 = await test_step(var2)
         DBOS.logger.info("I'm test_workflow")
         return res1 + res2
@@ -325,6 +330,7 @@ def test_async_tx_raises(config: ConfigFile) -> None:
         async def test_async_tx() -> None:
             pass
 
+    assert "is a coroutine function" in str(exc_info.value)
     # destroy call needed to avoid "functions were registered but DBOS() was not called" warning
     DBOS.destroy(destroy_registry=True)
 
@@ -343,12 +349,12 @@ async def test_start_workflow_async(dbos: DBOS) -> None:
         wf_el_id = id(asyncio.get_running_loop())
         nonlocal wf_counter
         wf_counter += 1
-        res2 = test_step(var2)
+        res2 = await test_step(var2)
         DBOS.logger.info("I'm test_workflow")
         return var1 + res2
 
     @DBOS.step()
-    def test_step(var: str) -> str:
+    async def test_step(var: str) -> str:
         nonlocal step_el_id
         step_el_id = id(asyncio.get_running_loop())
         nonlocal step_counter
@@ -605,3 +611,83 @@ async def test_workflow_with_task_cancellation(dbos: DBOS) -> None:
     # Verify the workflow completes despite the task cancellation
     handle: WorkflowHandleAsync[str] = await DBOS.retrieve_workflow_async(wfid)
     assert await handle.get_result() == "completed"
+
+
+@pytest.mark.asyncio
+async def test_check_async_violation(dbos: DBOS) -> None:
+    # Set up in-memory log exporter
+    log_exporter = InMemoryLogExporter()  # type: ignore
+    log_processor = BatchLogRecordProcessor(log_exporter)
+    log_provider = LoggerProvider()
+    log_provider.add_log_record_processor(log_processor)
+    set_logger_provider(log_provider)
+    dbos_logger.addHandler(LoggingHandler(logger_provider=log_provider))
+
+    @DBOS.workflow()
+    def sync_workflow() -> str:
+        return "sync"
+
+    @DBOS.step()
+    def sync_step() -> str:
+        return "step"
+
+    @DBOS.workflow()
+    async def async_workflow_sync_step() -> str:
+        return sync_step()
+
+    @DBOS.transaction()
+    def sync_transaction() -> str:
+        return "txn"
+
+    @DBOS.workflow()
+    async def async_workflow_sync_txn() -> str:
+        return sync_transaction()
+
+    # Call a sync workflow should log a warning
+    sync_workflow()
+
+    log_processor.force_flush(timeout_millis=5000)
+    logs = log_exporter.get_finished_logs()
+    assert len(logs) == 1
+    assert (
+        logs[0].log_record.body is not None
+        and f"Sync workflow ({get_dbos_func_name(sync_workflow)}) shouldn't be invoked from within another async function."
+        in logs[0].log_record.body
+    )
+    log_exporter.clear()
+
+    # Call a sync step from within an async workflow should log a warning
+    await async_workflow_sync_step()
+    log_processor.force_flush(timeout_millis=5000)
+    logs = log_exporter.get_finished_logs()
+    assert len(logs) == 1
+    assert (
+        logs[0].log_record.body is not None
+        and f"Sync step ({get_dbos_func_name(sync_step)}) shouldn't be invoked from within another async function."
+        in logs[0].log_record.body
+    )
+    log_exporter.clear()
+
+    # Directly call a sync step should log a warning
+    sync_step()
+    log_processor.force_flush(timeout_millis=5000)
+    logs = log_exporter.get_finished_logs()
+    assert len(logs) == 1
+    assert (
+        logs[0].log_record.body is not None
+        and f"Sync step ({get_dbos_func_name(sync_step)}) shouldn't be invoked from within another async function."
+        in logs[0].log_record.body
+    )
+    log_exporter.clear()
+
+    # Call a sync transaction from within an async workflow should log a warning
+    await async_workflow_sync_txn()
+    log_processor.force_flush(timeout_millis=5000)
+    logs = log_exporter.get_finished_logs()
+    assert len(logs) == 1
+    assert (
+        logs[0].log_record.body is not None
+        and f"Transaction function ({get_dbos_func_name(sync_transaction)}) shouldn't be invoked from within another async function."
+        in logs[0].log_record.body
+    )
+    log_exporter.clear()

{dbos-1.14.0a2 → dbos-1.14.0a4}/tests/test_async_workflow_management.py

@@ -148,7 +148,7 @@ async def test_fork_workflow_async(dbos: DBOS) -> None:
 
     wfid = str(uuid.uuid4())
     with SetWorkflowID(wfid):
-        assert simple_workflow(input_val) == output
+        assert await asyncio.to_thread(simple_workflow, input_val) == output
 
     assert step_one_count == 1
     assert step_two_count == 1

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

@@ -1,5 +1,6 @@
 # mypy: disable-error-code="no-redef"
 
+import asyncio
 import datetime
 import logging
 import os
@@ -1250,12 +1251,43 @@ def test_destroy_semantics(dbos: DBOS, config: DBOSConfig) -> None:
     var = "test"
     assert test_workflow(var) == var
 
+    # Start the workflow asynchornously
+    wf = dbos.start_workflow(test_workflow, var)
+    assert wf.get_result() == var
+
     DBOS.destroy()
     DBOS(config=config)
     DBOS.launch()
 
     assert test_workflow(var) == var
 
+    wf = dbos.start_workflow(test_workflow, var)
+    assert wf.get_result() == var
+
+
+@pytest.mark.asyncio
+async def test_destroy_semantics_async(dbos: DBOS, config: DBOSConfig) -> None:
+
+    @DBOS.workflow()
+    async def test_workflow(var: str) -> str:
+        return var
+
+    var = "test"
+    assert await test_workflow(var) == var
+
+    # Start the workflow asynchornously
+    wf = await dbos.start_workflow_async(test_workflow, var)
+    assert await wf.get_result() == var
+
+    DBOS.destroy()
+    DBOS(config=config)
+    DBOS.launch()
+
+    assert await test_workflow(var) == var
+
+    wf = await dbos.start_workflow_async(test_workflow, var)
+    assert await wf.get_result() == var
+
 
 def test_double_decoration(dbos: DBOS) -> None:
     with pytest.raises(
@@ -1637,17 +1669,17 @@ async def test_step_without_dbos(dbos: DBOS, config: DBOSConfig) -> None:
         assert DBOS.workflow_id is None
         return x
 
-    assert step(5) == 5
+    assert await asyncio.to_thread(step, 5) == 5
     assert await async_step(5) == 5
 
     DBOS(config=config)
 
-    assert step(5) == 5
+    assert await asyncio.to_thread(step, 5) == 5
     assert await async_step(5) == 5
 
     DBOS.launch()
 
-    assert step(5) == 5
+    assert await asyncio.to_thread(step, 5) == 5
     assert await async_step(5) == 5
 
     assert len(DBOS.list_workflows()) == 0

{dbos-1.14.0a2 → dbos-1.14.0a4}/tests/test_workflow_introspection.py

@@ -828,18 +828,18 @@ async def test_callchild_first_asyncio(dbos: DBOS) -> None:
     async def parentWorkflow() -> str:
         handle = await dbos.start_workflow_async(child_workflow)
         child_id = await handle.get_result()
-        stepOne()
-        stepTwo()
+        await stepOne()
+        await stepTwo()
         return child_id
 
     @DBOS.step()
-    def stepOne() -> str:
+    async def stepOne() -> str:
         workflow_id = DBOS.workflow_id
         assert workflow_id is not None
         return workflow_id
 
     @DBOS.step()
-    def stepTwo() -> None:
+    async def stepTwo() -> None:
         return
 
     @DBOS.workflow()