dbos 1.1.0a4__tar.gz → 1.2.0a2__tar.gz

{dbos-1.1.0a4 → dbos-1.2.0a2}/PKG-INFO

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

{dbos-1.1.0a4 → dbos-1.2.0a2}/dbos/_admin_server.py

@@ -5,8 +5,9 @@ import re
 import threading
 from functools import partial
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from typing import TYPE_CHECKING, Any, List, TypedDict
+from typing import TYPE_CHECKING, Any, List, Optional, TypedDict
 
+from ._context import SetWorkflowID
 from ._error import DBOSException
 from ._logger import dbos_logger
 from ._recovery import recover_pending_workflows
@@ -141,7 +142,11 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
                 try:
                     data = json.loads(post_data.decode("utf-8"))
                     start_step: int = data.get("start_step", 1)
-                    self._handle_fork(workflow_id, start_step)
+                    new_workflow_id: Optional[str] = data.get("new_workflow_id")
+                    application_version: Optional[str] = data.get("application_version")
+                    self._handle_fork(
+                        workflow_id, start_step, new_workflow_id, application_version
+                    )
                 except (json.JSONDecodeError, AttributeError) as e:
                     self.send_response(500)
                     self.send_header("Content-Type", "application/json")
@@ -191,9 +196,24 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(response_body)
 
-    def _handle_fork(self, workflow_id: str, start_step: int) -> None:
+    def _handle_fork(
+        self,
+        workflow_id: str,
+        start_step: int,
+        new_workflow_id: Optional[str],
+        application_version: Optional[str],
+    ) -> None:
         try:
-            handle = self.dbos.fork_workflow(workflow_id, start_step)
+            print(f"Forking workflow {workflow_id} from step {start_step}")
+            if new_workflow_id is not None:
+                with SetWorkflowID(new_workflow_id):
+                    handle = self.dbos.fork_workflow(
+                        workflow_id, start_step, application_version=application_version
+                    )
+            else:
+                handle = self.dbos.fork_workflow(
+                    workflow_id, start_step, application_version=application_version
+                )
             response_body = json.dumps(
                 {
                     "workflow_id": handle.workflow_id,

{dbos-1.1.0a4 → dbos-1.2.0a2}/dbos/_app_db.py

@@ -216,21 +216,6 @@ class ApplicationDatabase:
             for row in rows
         ]
 
-    def get_max_function_id(self, workflow_uuid: str) -> Optional[int]:
-        with self.engine.begin() as conn:
-            max_function_id_row = conn.execute(
-                sa.select(
-                    sa.func.max(ApplicationSchema.transaction_outputs.c.function_id)
-                ).where(
-                    ApplicationSchema.transaction_outputs.c.workflow_uuid
-                    == workflow_uuid
-                )
-            ).fetchone()
-
-            max_function_id = max_function_id_row[0] if max_function_id_row else None
-
-            return max_function_id
-
     def clone_workflow_transactions(
         self, src_workflow_id: str, forked_workflow_id: str, start_step: int
     ) -> None:

{dbos-1.1.0a4 → dbos-1.2.0a2}/dbos/_core.py

@@ -602,7 +602,6 @@ async def start_workflow_async(
     *args: P.args,
     **kwargs: P.kwargs,
 ) -> "WorkflowHandleAsync[R]":
-
     # If the function has a class, add the class object as its first argument
     fself: Optional[object] = None
     if hasattr(func, "__self__"):

{dbos-1.1.0a4 → dbos-1.2.0a2}/dbos/_dbos.py

@@ -299,6 +299,7 @@ class DBOS:
 
         self._launched: bool = False
         self._debug_mode: bool = False
+        self._configured_threadpool: bool = False
         self._sys_db_field: Optional[SystemDatabase] = None
         self._app_db_field: Optional[ApplicationDatabase] = None
         self._registry: DBOSRegistry = _get_or_create_dbos_registry()
@@ -719,6 +720,7 @@ class DBOS:
         **kwargs: P.kwargs,
     ) -> WorkflowHandleAsync[R]:
         """Invoke a workflow function on the event loop, returning a handle to the ongoing execution."""
+        await cls._configure_asyncio_thread_pool()
         return await start_workflow_async(
             _get_dbos_instance(), func, None, True, *args, **kwargs
         )
@@ -736,6 +738,7 @@ class DBOS:
     async def get_workflow_status_async(
         cls, workflow_id: str
     ) -> Optional[WorkflowStatus]:
+        await cls._configure_asyncio_thread_pool()
         """Return the status of a workflow execution."""
         return await asyncio.to_thread(cls.get_workflow_status, workflow_id)
 
@@ -757,6 +760,7 @@ class DBOS:
     ) -> WorkflowHandleAsync[R]:
         """Return a `WorkflowHandle` for a workflow execution."""
         dbos = _get_dbos_instance()
+        await cls._configure_asyncio_thread_pool()
         if existing_workflow:
             stat = await dbos.get_workflow_status_async(workflow_id)
             if stat is None:
@@ -775,6 +779,7 @@ class DBOS:
         cls, destination_id: str, message: Any, topic: Optional[str] = None
     ) -> None:
         """Send a message to a workflow execution."""
+        await cls._configure_asyncio_thread_pool()
         await asyncio.to_thread(lambda: DBOS.send(destination_id, message, topic))
 
     @classmethod
@@ -797,6 +802,7 @@ class DBOS:
         This function is to be called from within a workflow.
         `recv_async` will return the message sent on `topic`, asyncronously waiting if necessary.
         """
+        await cls._configure_asyncio_thread_pool()
         return await asyncio.to_thread(lambda: DBOS.recv(topic, timeout_seconds))
 
     @classmethod
@@ -835,6 +841,7 @@ class DBOS:
         It is important to use `DBOS.sleep` or `DBOS.sleep_async` (as opposed to any other sleep) within workflows,
         as the DBOS sleep methods are durable and completed sleeps will be skipped during recovery.
         """
+        await cls._configure_asyncio_thread_pool()
         await asyncio.to_thread(lambda: DBOS.sleep(seconds))
 
     @classmethod
@@ -869,6 +876,7 @@ class DBOS:
             value(Any): A serializable value to associate with the key
 
         """
+        await cls._configure_asyncio_thread_pool()
         await asyncio.to_thread(lambda: DBOS.set_event(key, value))
 
     @classmethod
@@ -901,6 +909,7 @@ class DBOS:
             timeout_seconds(float): The amount of time to wait, in case `set_event` has not yet been called byt the workflow
 
         """
+        await cls._configure_asyncio_thread_pool()
         return await asyncio.to_thread(
             lambda: DBOS.get_event(workflow_id, key, timeout_seconds)
         )
@@ -929,6 +938,19 @@ class DBOS:
             fn, "DBOS.cancelWorkflow"
         )
 
+    @classmethod
+    async def _configure_asyncio_thread_pool(cls) -> None:
+        """
+        Configure the thread pool for asyncio.to_thread.
+
+        This function is called before the first call to asyncio.to_thread.
+        """
+        if _get_dbos_instance()._configured_threadpool:
+            return
+        loop = asyncio.get_running_loop()
+        loop.set_default_executor(_get_dbos_instance()._executor)
+        _get_dbos_instance()._configured_threadpool = True
+
     @classmethod
     def resume_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
         """Resume a workflow by ID."""

{dbos-1.1.0a4 → dbos-1.2.0a2}/dbos/_event_loop.py

@@ -1,5 +1,6 @@
 import asyncio
 import threading
+from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Coroutine, Optional, TypeVar
 
 
@@ -33,15 +34,17 @@ class BackgroundEventLoop:
 
     def _run_event_loop(self) -> None:
         self._loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self._loop)
+        with ThreadPoolExecutor(max_workers=64) as thread_pool:
+            self._loop.set_default_executor(thread_pool)
+            asyncio.set_event_loop(self._loop)
 
-        self._running = True
-        self._ready.set()  # Signal that the loop is ready
+            self._running = True
+            self._ready.set()  # Signal that the loop is ready
 
-        try:
-            self._loop.run_forever()
-        finally:
-            self._loop.close()
+            try:
+                self._loop.run_forever()
+            finally:
+                self._loop.close()
 
     async def _shutdown(self) -> None:
         if self._loop is None:

{dbos-1.1.0a4 → dbos-1.2.0a2}/dbos/_sys_db.py

@@ -601,18 +601,6 @@ class SystemDatabase:
                 )
             )
 
-    def get_max_function_id(self, workflow_uuid: str) -> Optional[int]:
-        with self.engine.begin() as conn:
-            max_function_id_row = conn.execute(
-                sa.select(
-                    sa.func.max(SystemSchema.operation_outputs.c.function_id)
-                ).where(SystemSchema.operation_outputs.c.workflow_uuid == workflow_uuid)
-            ).fetchone()
-
-            max_function_id = max_function_id_row[0] if max_function_id_row else None
-
-            return max_function_id
-
     def fork_workflow(
         self,
         original_workflow_id: str,

{dbos-1.1.0a4 → dbos-1.2.0a2}/dbos/_workflow_commands.py

@@ -103,16 +103,7 @@ def fork_workflow(
     *,
     application_version: Optional[str],
 ) -> str:
-    def get_max_function_id(workflow_uuid: str) -> int:
-        max_transactions = app_db.get_max_function_id(workflow_uuid) or 0
-        max_operations = sys_db.get_max_function_id(workflow_uuid) or 0
-        return max(max_transactions, max_operations)
-
-    max_function_id = get_max_function_id(workflow_id)
-    if max_function_id > 0 and start_step > max_function_id:
-        raise DBOSException(
-            f"Cannot fork workflow {workflow_id} from step {start_step}. The workflow has {max_function_id} steps."
-        )
+
     ctx = get_local_dbos_context()
     if ctx is not None and len(ctx.id_assigned_for_next_workflow) > 0:
         forked_workflow_id = ctx.id_assigned_for_next_workflow

{dbos-1.1.0a4 → dbos-1.2.0a2}/pyproject.toml

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

{dbos-1.1.0a4 → dbos-1.2.0a2}/tests/test_admin_server.py

@@ -11,7 +11,14 @@ import sqlalchemy as sa
 from requests.exceptions import ConnectionError
 
 # Public API
-from dbos import DBOS, DBOSConfig, Queue, SetWorkflowID, _workflow_commands
+from dbos import (
+    DBOS,
+    DBOSConfig,
+    Queue,
+    SetWorkflowID,
+    WorkflowHandle,
+    _workflow_commands,
+)
 from dbos._error import DBOSWorkflowCancelledError
 from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import SystemDatabase, WorkflowStatusString
@@ -425,4 +432,24 @@ def test_admin_workflow_fork(dbos: DBOS, sys_db: SystemDatabase) -> None:
         time.sleep(1)
         count += 1
 
+    # test for new_workflow_id and app version
+
+    new_version = "my_new_version"
+    GlobalParams.app_version = new_version
+
+    response = requests.post(
+        f"http://localhost:3001/workflows/{wfUuid}/fork",
+        json={"new_workflow_id": "123456", "application_version": new_version},
+        timeout=5,
+    )
+    assert response.status_code == 200
+
+    new_workflow_id = response.json().get("workflow_id")
+    assert new_workflow_id == "123456", "Expected new workflow ID is not 123456"
+
+    handle: WorkflowHandle[None] = dbos.retrieve_workflow(new_workflow_id)
+    assert (
+        handle.get_status().app_version == new_version
+    ), f"Expected application version to be {new_version}, but got {handle.get_status().app_version}"
+
     assert worked, "Workflow did not finish successfully"

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

@@ -1,7 +1,7 @@
 import asyncio
 import time
 import uuid
-from typing import Optional
+from typing import List, Optional
 
 import pytest
 import sqlalchemy as sa
@@ -523,3 +523,44 @@ async def test_workflow_timeout_async(dbos: DBOS) -> None:
     with pytest.raises(Exception) as exc_info:
         await (await DBOS.retrieve_workflow_async(direct_child)).get_result()
     assert "was cancelled" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_max_parallel_workflows(dbos: DBOS) -> None:
+    queue = Queue("parallel_queue")
+
+    @DBOS.workflow()
+    async def test_workflow(i: int) -> int:
+        await DBOS.sleep_async(5)
+        return i
+
+    begin_time = time.time()
+
+    tasks: List[WorkflowHandleAsync[int]] = []
+    for i in range(50):
+        tasks.append(await DBOS.start_workflow_async(test_workflow, i))
+
+    # Wait for all tasks to complete
+    for i in range(50):
+        assert (await tasks[i].get_result()) == i, f"Task {i} should return {i}"
+
+    end_time = time.time()
+    assert (
+        end_time - begin_time < 10
+    ), "All tasks should complete in less than 10 seconds"
+
+    # Test enqueues
+    begin_time = time.time()
+    tasks = []
+
+    for i in range(50):
+        tasks.append(await queue.enqueue_async(test_workflow, i))
+
+    # Wait for all tasks to complete
+    for i in range(50):
+        assert (await tasks[i].get_result()) == i, f"Task {i} should return {i}"
+
+    end_time = time.time()
+    assert (
+        end_time - begin_time < 10
+    ), "All enqueued tasks should complete in less than 10 seconds"

{dbos-1.1.0a4 → dbos-1.2.0a2}/tests/test_workflow_management.py

@@ -482,17 +482,6 @@ def test_restart_fromsteps_steps_tr(
     assert stepFourCount == 2
     assert trFiveCount == 3
 
-    # invalid step
-    try:
-        forked_handle = DBOS.fork_workflow(wfid, 7)
-        assert forked_handle.workflow_id != wfid
-        forked_handle.get_result()
-    except Exception as e:
-        print(f"Exception: {e}")
-        assert isinstance(e, DBOSException)
-        assert "Cannot fork workflow" in str(e)
-        assert trOneCount == 1
-
     # invalid < 1 will default to 1
     forked_handle = DBOS.fork_workflow(wfid, -1)
     assert forked_handle.workflow_id != wfid