dbos 0.26.0a11__py3-none-any.whl → 0.26.0a14__py3-none-any.whl

dbos/_core.py

@@ -365,7 +365,9 @@ def _execute_workflow_wthread(
                 if isinstance(result, Immediate):
                     return cast(Immediate[R], result)()
                 else:
-                    return asyncio.run(cast(Pending[R], result)())
+                    return dbos._background_event_loop.submit_coroutine(
+                        cast(Pending[R], result)()
+                    )
             except Exception:
                 dbos.logger.error(
                     f"Exception encountered in asynchronous workflow: {traceback.format_exc()}"

dbos/_dbos.py

@@ -4,7 +4,6 @@ import asyncio
 import atexit
 import hashlib
 import inspect
-import json
 import os
 import sys
 import threading
@@ -31,7 +30,6 @@ from typing import (
 
 from opentelemetry.trace import Span
 
-from dbos import _serialization
 from dbos._conductor.conductor import ConductorWebsocket
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 from dbos._workflow_commands import (
@@ -62,6 +60,7 @@ from ._recovery import recover_pending_workflows, startup_recovery_thread
 from ._registrations import (
     DEFAULT_MAX_RECOVERY_ATTEMPTS,
     DBOSClassInfo,
+    _class_fqn,
     get_or_create_class_info,
     set_dbos_func_name,
     set_temp_workflow_type,
@@ -111,6 +110,7 @@ from ._error import (
     DBOSException,
     DBOSNonExistentWorkflowError,
 )
+from ._event_loop import BackgroundEventLoop
 from ._logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
 from ._sys_db import SystemDatabase
 from ._workflow_commands import WorkflowStatus, get_workflow
@@ -181,15 +181,17 @@ class DBOSRegistry:
         self.workflow_info_map[name] = wrapped_func
 
     def register_class(self, cls: type, ci: DBOSClassInfo) -> None:
-        class_name = cls.__name__
+        class_name = _class_fqn(cls)
         if class_name in self.class_info_map:
             if self.class_info_map[class_name] is not cls:
                 raise Exception(f"Duplicate type registration for class '{class_name}'")
         else:
             self.class_info_map[class_name] = cls
 
-    def create_class_info(self, cls: Type[T]) -> Type[T]:
-        ci = get_or_create_class_info(cls)
+    def create_class_info(
+        self, cls: Type[T], class_name: Optional[str] = None
+    ) -> Type[T]:
+        ci = get_or_create_class_info(cls, class_name)
         self.register_class(cls, ci)
         return cls
 
@@ -204,7 +206,7 @@ class DBOSRegistry:
 
     def register_instance(self, inst: object) -> None:
         config_name = getattr(inst, "config_name")
-        class_name = inst.__class__.__name__
+        class_name = _class_fqn(inst.__class__)
         fn = f"{class_name}/{config_name}"
         if fn in self.instance_info_map:
             if self.instance_info_map[fn] is not inst:
@@ -338,6 +340,7 @@ class DBOS:
         self.conductor_url: Optional[str] = conductor_url
         self.conductor_key: Optional[str] = conductor_key
         self.conductor_websocket: Optional[ConductorWebsocket] = None
+        self._background_event_loop: BackgroundEventLoop = BackgroundEventLoop()
 
         init_logger()
 
@@ -448,6 +451,7 @@ class DBOS:
             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._background_event_loop.start()
             self._sys_db_field = SystemDatabase(
                 self.config["database"], debug_mode=debug_mode
             )
@@ -565,6 +569,7 @@ class DBOS:
         self._initialized = False
         for event in self.stop_events:
             event.set()
+        self._background_event_loop.stop()
         if self._sys_db_field is not None:
             self._sys_db_field.destroy()
             self._sys_db_field = None
@@ -641,15 +646,22 @@ class DBOS:
         )
 
     @classmethod
-    def dbos_class(cls) -> Callable[[Type[T]], Type[T]]:
+    def dbos_class(
+        cls, class_name: Optional[str] = None
+    ) -> Callable[[Type[T]], Type[T]]:
         """
         Decorate a class that contains DBOS member functions.
 
         All DBOS classes must be decorated, as this associates the class with
-        its member functions.
+        its member functions. Class names must be globally unique. By default, the class name is class.__qualname__  but you can optionally provide a class name that is different from the default name.
         """
 
-        return _get_or_create_dbos_registry().create_class_info
+        def register_class(cls: Type[T]) -> Type[T]:
+            # Register the class with the DBOS registry
+            _get_or_create_dbos_registry().create_class_info(cls, class_name)
+            return cls
+
+        return register_class
 
     @classmethod
     def default_required_roles(cls, roles: List[str]) -> Callable[[Type[T]], Type[T]]:

dbos/_docker_pg_helper.py

@@ -46,7 +46,7 @@ def start_docker_pg() -> None:
     if has_docker:
         start_docker_postgres(pool_config)
         logging.info(
-            f"Postgres available at postgres://postgres:{pool_config['password']}@{pool_config['host']}:{pool_config['port']}"
+            f"Postgres available at postgresql://postgres:{pool_config['password']}@{pool_config['host']}:{pool_config['port']}"
         )
     else:
         logging.warning("Docker not detected locally")

dbos/_error.py

@@ -26,6 +26,29 @@ class DBOSException(Exception):
         return f"DBOS Error: {self.message}"
 
 
+class DBOSBaseException(BaseException):
+    """
+    This class is for DBOS exceptions that should not be caught by user code.
+    It inherits from BaseException instead of Exception so it cannot be caught
+    except by code specifically trying to catch it.
+
+    Attributes:
+        message(str): The error message string
+        dbos_error_code(DBOSErrorCode): The error code, from the `DBOSErrorCode` enum
+    """
+
+    def __init__(self, message: str, dbos_error_code: Optional[int] = None):
+        self.message = message
+        self.dbos_error_code = dbos_error_code
+        self.status_code: Optional[int] = None
+        super().__init__(self.message)
+
+    def __str__(self) -> str:
+        if self.dbos_error_code:
+            return f"DBOS Error {self.dbos_error_code}: {self.message}"
+        return f"DBOS Error: {self.message}"
+
+
 class DBOSErrorCode(Enum):
     ConflictingIDError = 1
     RecoveryError = 2
@@ -41,14 +64,9 @@ class DBOSErrorCode(Enum):
     ConflictingRegistrationError = 25
 
 
-class DBOSWorkflowConflictIDError(DBOSException):
-    """Exception raised when a workflow database record already exists."""
-
-    def __init__(self, workflow_id: str):
-        super().__init__(
-            f"Conflicting workflow ID {workflow_id}",
-            dbos_error_code=DBOSErrorCode.ConflictingIDError.value,
-        )
+#######################################
+## Exception
+#######################################
 
 
 class DBOSConflictingWorkflowError(DBOSException):
@@ -138,16 +156,6 @@ class DBOSMaxStepRetriesExceeded(DBOSException):
         return (self.__class__, (self.step_name, self.max_retries))
 
 
-class DBOSWorkflowCancelledError(DBOSException):
-    """Exception raised when the workflow has already been cancelled."""
-
-    def __init__(self, msg: str) -> None:
-        super().__init__(
-            msg,
-            dbos_error_code=DBOSErrorCode.WorkflowCancelled.value,
-        )
-
-
 class DBOSConflictingRegistrationError(DBOSException):
     """Exception raised when conflicting decorators are applied to the same function."""
 
@@ -168,3 +176,28 @@ class DBOSUnexpectedStepError(DBOSException):
             f"During execution of workflow {workflow_id} step {step_id}, function {recorded_name} was recorded when {expected_name} was expected. Check that your workflow is deterministic.",
             dbos_error_code=DBOSErrorCode.UnexpectedStep.value,
         )
+
+
+#######################################
+## BaseException
+#######################################
+
+
+class DBOSWorkflowCancelledError(DBOSBaseException):
+    """BaseException raised when the workflow has already been cancelled."""
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(
+            msg,
+            dbos_error_code=DBOSErrorCode.WorkflowCancelled.value,
+        )
+
+
+class DBOSWorkflowConflictIDError(DBOSBaseException):
+    """BaseException raised when a workflow database record already exists."""
+
+    def __init__(self, workflow_id: str):
+        super().__init__(
+            f"Conflicting workflow ID {workflow_id}",
+            dbos_error_code=DBOSErrorCode.ConflictingIDError.value,
+        )

dbos/_event_loop.py

@@ -0,0 +1,67 @@
+import asyncio
+import threading
+from typing import Any, Coroutine, Optional, TypeVar
+
+
+class BackgroundEventLoop:
+    """
+    This is the event loop to which DBOS submits any coroutines that are not started from within an event loop.
+    In particular, coroutines submitted to queues (such as from scheduled workflows) run on this event loop.
+    """
+
+    def __init__(self) -> None:
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+        self._ready = threading.Event()
+
+    def start(self) -> None:
+        if self._running:
+            return
+
+        self._thread = threading.Thread(target=self._run_event_loop, daemon=True)
+        self._thread.start()
+        self._ready.wait()  # Wait until the loop is running
+
+    def stop(self) -> None:
+        if not self._running or self._loop is None or self._thread is None:
+            return
+
+        asyncio.run_coroutine_threadsafe(self._shutdown(), self._loop)
+        self._thread.join()
+        self._running = False
+
+    def _run_event_loop(self) -> None:
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+
+        self._running = True
+        self._ready.set()  # Signal that the loop is ready
+
+        try:
+            self._loop.run_forever()
+        finally:
+            self._loop.close()
+
+    async def _shutdown(self) -> None:
+        if self._loop is None:
+            raise RuntimeError("Event loop not started")
+        tasks = [
+            task
+            for task in asyncio.all_tasks(self._loop)
+            if task is not asyncio.current_task(self._loop)
+        ]
+
+        for task in tasks:
+            task.cancel()
+
+        await asyncio.gather(*tasks, return_exceptions=True)
+        self._loop.stop()
+
+    T = TypeVar("T")
+
+    def submit_coroutine(self, coro: Coroutine[Any, Any, T]) -> T:
+        """Submit a coroutine to the background event loop"""
+        if self._loop is None:
+            raise RuntimeError("Event loop not started")
+        return asyncio.run_coroutine_threadsafe(coro, self._loop).result()

dbos/_registrations.py

@@ -34,6 +34,7 @@ def set_temp_workflow_type(f: Any, name: TempWorkflowType) -> None:
 
 @dataclass
 class DBOSClassInfo:
+    registered_name: str
     def_required_roles: Optional[List[str]] = None
 
 
@@ -53,11 +54,17 @@ class DBOSFuncInfo:
     max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS
 
 
-def get_or_create_class_info(cls: Type[Any]) -> DBOSClassInfo:
+def get_or_create_class_info(
+    cls: Type[Any], provided_name: Optional[str] = None
+) -> DBOSClassInfo:
     if hasattr(cls, "dbos_class_decorator_info"):
         ci: DBOSClassInfo = getattr(cls, "dbos_class_decorator_info")
         return ci
-    ci = DBOSClassInfo()
+    class_name = _class_fqn(cls)
+    # Use the provided name instead of the class name if it is not None
+    if provided_name is not None:
+        class_name = provided_name
+    ci = DBOSClassInfo(registered_name=class_name)
     setattr(cls, "dbos_class_decorator_info", ci)
 
     # Tell all DBOS functions about this
@@ -166,16 +173,24 @@ def get_config_name(
     return None
 
 
+def _class_fqn(cls: type) -> str:
+    """Returns the registered name of the given class. If the class name was not overridden at registration time, it returns the qualified name of the class."""
+    ci = get_class_info(cls)
+    if ci is not None:
+        return ci.registered_name
+    return cls.__qualname__
+
+
 def get_dbos_class_name(
     fi: Optional[DBOSFuncInfo], func: Callable[..., Any], args: Tuple[Any, ...]
 ) -> Optional[str]:
     if fi and fi.func_type != DBOSFuncType.Unknown and len(args) > 0:
         if fi.func_type == DBOSFuncType.Instance:
             first_arg = args[0]
-            return str(first_arg.__class__.__name__)
+            return _class_fqn(first_arg.__class__)
         if fi.func_type == DBOSFuncType.Class:
             first_arg = args[0]
-            return str(first_arg.__name__)
+            return _class_fqn(first_arg)
         return None
 
     # Check for improperly-registered functions

{dbos-0.26.0a11.dist-info → dbos-0.26.0a14.dist-info}/METADATA

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

{dbos-0.26.0a11.dist-info → dbos-0.26.0a14.dist-info}/RECORD

@@ -1,7 +1,7 @@
-dbos-0.26.0a11.dist-info/METADATA,sha256=sw5u9uXooyqFBMqX-mEFYFXehYWd-ism0o9xcqokW4g,5554
-dbos-0.26.0a11.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-0.26.0a11.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.26.0a11.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.26.0a14.dist-info/METADATA,sha256=KmqNCgW2bcxs1qddgonsP0MDPe1tt5tlUvs07bN-XDY,5554
+dbos-0.26.0a14.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-0.26.0a14.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.26.0a14.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=3NQfGlBiiUSM_v88STdVP3rNZvGkUL_9WbSotKb8Voo,873
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=vxPG_YJ6lYrkfPCSp42FiATVLBOij7Fm52Yngg5Z_tE,7027
@@ -11,13 +11,14 @@ dbos/_client.py,sha256=5iaoFsu5wAqwjjj3EWusZ1eDbBAW8FwYazhokdCJ9h4,10964
 dbos/_conductor/conductor.py,sha256=HYzVL29IMMrs2Mnms_7cHJynCnmmEN5SDQOMjzn3UoU,16840
 dbos/_conductor/protocol.py,sha256=xN7pmooyF1pqbH1b6WhllU5718P7zSb_b0KCwA6bzcs,6716
 dbos/_context.py,sha256=I8sLkdKTTkZEz7wG-MjynaQB6XEF2bLXuwNksiauP7w,19430
-dbos/_core.py,sha256=tjBGVbSgOn59lR29gcYi5f6fcKNKQM5EP1QXrQGUkXA,45426
+dbos/_core.py,sha256=de8GecFmW5DNf5dYfnpSX3IDO24Wc6pBpCC1VZ1iVyI,45505
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=rc5MLk6k-B0BlDpsQ9mYW509M1HUYa9SZvdWPpZS35o,45587
+dbos/_dbos.py,sha256=byXhhiG14nS3iU85NphvQ26vvnJ-gu1tMwTIoUc3dYc,46239
 dbos/_dbos_config.py,sha256=m05IFjM0jSwZBsnFMF_4qP2JkjVFc0gqyM2tnotXq20,20636
 dbos/_debug.py,sha256=MNlQVZ6TscGCRQeEEL0VE8Uignvr6dPeDDDefS3xgIE,1823
-dbos/_docker_pg_helper.py,sha256=9OGbuavRA_cwE-uPiLZJSdpbQu-6PPgl9clQZB2zT_U,5852
-dbos/_error.py,sha256=HtdV6Qy7qRyGD57wxLwE7YT0WdYtlx5ZLEe_Kv_gC-U,5953
+dbos/_docker_pg_helper.py,sha256=NmcgqmR5rQA_4igfeqh8ugNT2z3YmoOvuep_MEtxTiY,5854
+dbos/_error.py,sha256=9ITvFsN_Udpx0xXtYQHXXXb6PjPr3TmMondGmprV-L0,7003
+dbos/_event_loop.py,sha256=NmaLbEQFfEK36S_0KhVD39YdYrGce3qSKCTJ-5RqKQ0,2136
 dbos/_fastapi.py,sha256=PhaKftbApHnjtYEOw0EYna_3K0cmz__J9of7mRJWzu4,3704
 dbos/_flask.py,sha256=DZKUZR5-xOzPI7tYZ53r2PvvHVoAb8SYwLzMVFsVfjI,2608
 dbos/_kafka.py,sha256=pz0xZ9F3X9Ky1k-VSbeF3tfPhP3UPr3lUUhUfE41__U,4198
@@ -36,7 +37,7 @@ dbos/_migrations/versions/f4b9b32ba814_functionname_childid_op_outputs.py,sha256
 dbos/_outcome.py,sha256=EXxBg4jXCVJsByDQ1VOCIedmbeq_03S6d-p1vqQrLFU,6810
 dbos/_queue.py,sha256=l0g_CXJbxEmftCA9yhy-cyaR_sddfQSCfm-5XgIWzqU,3397
 dbos/_recovery.py,sha256=98Py7icfytyIELJ54gIsdvmURBvTb0HmWaxEAuYL0dc,2546
-dbos/_registrations.py,sha256=_zy6k944Ll8QwqU12Kr3OP23ukVtm8axPNN1TS_kJRc,6717
+dbos/_registrations.py,sha256=ZDC5lghy_1ZMdMGsSBrXSyS96DH3baA4nyCkFdUmIlc,7292
 dbos/_request.py,sha256=cX1B3Atlh160phgS35gF1VEEV4pD126c9F3BDgBmxZU,929
 dbos/_roles.py,sha256=iOsgmIAf1XVzxs3gYWdGRe1B880YfOw5fpU7Jwx8_A8,2271
 dbos/_scheduler.py,sha256=SR1oRZRcVzYsj-JauV2LA8JtwTkt8mru7qf6H1AzQ1U,2027
@@ -64,4 +65,4 @@ dbos/cli/cli.py,sha256=Lb_RYmXoT5KH0xDbwaYpROE4c-svZ0eCq2Kxg7cAxTw,16537
 dbos/dbos-config.schema.json,sha256=i7jcxXqByKq0Jzv3nAUavONtj03vTwj6vWP4ylmBr8o,5694
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.26.0a11.dist-info/RECORD,,
+dbos-0.26.0a14.dist-info/RECORD,,