dbos 1.2.0a9__tar.gz → 1.3.0a2__tar.gz

{dbos-1.2.0a9 → dbos-1.3.0a2}/PKG-INFO

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

{dbos-1.2.0a9 → dbos-1.3.0a2}/dbos/_dbos.py

@@ -297,7 +297,6 @@ 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()
@@ -410,7 +409,7 @@ class DBOS:
                 GlobalParams.executor_id = str(uuid.uuid4())
             dbos_logger.info(f"Executor ID: {GlobalParams.executor_id}")
             dbos_logger.info(f"Application version: {GlobalParams.app_version}")
-            self._executor_field = ThreadPoolExecutor(max_workers=64)
+            self._executor_field = ThreadPoolExecutor(max_workers=sys.maxsize)
             self._background_event_loop.start()
             assert self._config["database_url"] is not None
             assert self._config["database"]["sys_db_engine_kwargs"] is not None
@@ -941,11 +940,8 @@ class DBOS:
 
         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]:

{dbos-1.2.0a9 → dbos-1.3.0a2}/dbos/_event_loop.py

@@ -1,6 +1,5 @@
 import asyncio
 import threading
-from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Coroutine, Optional, TypeVar
 
 
@@ -34,17 +33,15 @@ class BackgroundEventLoop:
 
     def _run_event_loop(self) -> None:
         self._loop = asyncio.new_event_loop()
-        with ThreadPoolExecutor(max_workers=64) as thread_pool:
-            self._loop.set_default_executor(thread_pool)
-            asyncio.set_event_loop(self._loop)
+        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.2.0a9 → dbos-1.3.0a2}/dbos/_sys_db.py

@@ -1385,35 +1385,35 @@ class SystemDatabase:
         payload = f"{workflow_uuid}::{topic}"
         condition = threading.Condition()
         # Must acquire first before adding to the map. Otherwise, the notification listener may notify it before the condition is acquired and waited.
-        condition.acquire()
-        success, _ = self.notifications_map.set(payload, condition)
-        if not success:
-            # This should not happen, but if it does, it means the workflow is executed concurrently.
-            condition.release()
-            self.notifications_map.pop(payload)
-            raise DBOSWorkflowConflictIDError(workflow_uuid)
+        try:
+            condition.acquire()
+            success, _ = self.notifications_map.set(payload, condition)
+            if not success:
+                # This should not happen, but if it does, it means the workflow is executed concurrently.
+                raise DBOSWorkflowConflictIDError(workflow_uuid)
 
-        # Check if the key is already in the database. If not, wait for the notification.
-        init_recv: Sequence[Any]
-        with self.engine.begin() as c:
-            init_recv = c.execute(
-                sa.select(
-                    SystemSchema.notifications.c.topic,
-                ).where(
-                    SystemSchema.notifications.c.destination_uuid == workflow_uuid,
-                    SystemSchema.notifications.c.topic == topic,
-                )
-            ).fetchall()
+            # Check if the key is already in the database. If not, wait for the notification.
+            init_recv: Sequence[Any]
+            with self.engine.begin() as c:
+                init_recv = c.execute(
+                    sa.select(
+                        SystemSchema.notifications.c.topic,
+                    ).where(
+                        SystemSchema.notifications.c.destination_uuid == workflow_uuid,
+                        SystemSchema.notifications.c.topic == topic,
+                    )
+                ).fetchall()
 
-        if len(init_recv) == 0:
-            # Wait for the notification
-            # Support OAOO sleep
-            actual_timeout = self.sleep(
-                workflow_uuid, timeout_function_id, timeout_seconds, skip_sleep=True
-            )
-            condition.wait(timeout=actual_timeout)
-        condition.release()
-        self.notifications_map.pop(payload)
+            if len(init_recv) == 0:
+                # Wait for the notification
+                # Support OAOO sleep
+                actual_timeout = self.sleep(
+                    workflow_uuid, timeout_function_id, timeout_seconds, skip_sleep=True
+                )
+                condition.wait(timeout=actual_timeout)
+        finally:
+            condition.release()
+            self.notifications_map.pop(payload)
 
         # Transactionally consume and return the message if it's in the database, otherwise return null.
         with self.engine.begin() as c:

{dbos-1.2.0a9 → dbos-1.3.0a2}/pyproject.toml

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