dbos 0.27.0a10__tar.gz → 0.27.1__tar.gz

{dbos-0.27.0a10 → dbos-0.27.1}/PKG-INFO

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

{dbos-0.27.0a10 → dbos-0.27.1}/dbos/_admin_server.py

@@ -66,11 +66,11 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
         elif self.path == _deactivate_path:
             if not AdminRequestHandler.is_deactivated:
                 dbos_logger.info(
-                    f"Deactivating DBOS executor {GlobalParams.executor_id} with version {GlobalParams.app_version}. This executor will complete existing workflows but will not start new workflows."
+                    f"Deactivating DBOS executor {GlobalParams.executor_id} with version {GlobalParams.app_version}. This executor will complete existing workflows but will not create new workflows."
                 )
                 AdminRequestHandler.is_deactivated = True
-            # Stop all scheduled workflows, queues, and kafka loops
-            for event in self.dbos.stop_events:
+            # Stop all event receivers (scheduler and Kafka threads)
+            for event in self.dbos.poller_stop_events:
                 event.set()
             self.send_response(200)
             self._end_headers()

{dbos-0.27.0a10 → dbos-0.27.1}/dbos/_core.py

@@ -296,7 +296,7 @@ def _init_workflow(
 
     if workflow_deadline_epoch_ms is not None:
         evt = threading.Event()
-        dbos.stop_events.append(evt)
+        dbos.background_thread_stop_events.append(evt)
 
         def timeout_func() -> None:
             try:

{dbos-0.27.0a10 → dbos-0.27.1}/dbos/_dbos.py

@@ -197,7 +197,7 @@ class DBOSRegistry:
         self, evt: threading.Event, func: Callable[..., Any], *args: Any, **kwargs: Any
     ) -> None:
         if self.dbos and self.dbos._launched:
-            self.dbos.stop_events.append(evt)
+            self.dbos.poller_stop_events.append(evt)
             self.dbos._executor.submit(func, *args, **kwargs)
         else:
             self.pollers.append((evt, func, args, kwargs))
@@ -330,7 +330,10 @@ class DBOS:
         self._registry: DBOSRegistry = _get_or_create_dbos_registry()
         self._registry.dbos = self
         self._admin_server_field: Optional[AdminServer] = None
-        self.stop_events: List[threading.Event] = []
+        # Stop internal background threads (queue thread, timeout threads, etc.)
+        self.background_thread_stop_events: List[threading.Event] = []
+        # Stop pollers (event receivers) that can create new workflows (scheduler, Kafka)
+        self.poller_stop_events: List[threading.Event] = []
         self.fastapi: Optional["FastAPI"] = fastapi
         self.flask: Optional["Flask"] = flask
         self._executor_field: Optional[ThreadPoolExecutor] = None
@@ -502,7 +505,7 @@ class DBOS:
 
             # Start the queue thread
             evt = threading.Event()
-            self.stop_events.append(evt)
+            self.background_thread_stop_events.append(evt)
             bg_queue_thread = threading.Thread(
                 target=queue_thread, args=(evt, self), daemon=True
             )
@@ -515,7 +518,7 @@ class DBOS:
                     dbos_domain = os.environ.get("DBOS_DOMAIN", "cloud.dbos.dev")
                     self.conductor_url = f"wss://{dbos_domain}/conductor/v1alpha1"
                 evt = threading.Event()
-                self.stop_events.append(evt)
+                self.background_thread_stop_events.append(evt)
                 self.conductor_websocket = ConductorWebsocket(
                     self,
                     conductor_url=self.conductor_url,
@@ -527,7 +530,7 @@ class DBOS:
 
             # Grab any pollers that were deferred and start them
             for evt, func, args, kwargs in self._registry.pollers:
-                self.stop_events.append(evt)
+                self.poller_stop_events.append(evt)
                 poller_thread = threading.Thread(
                     target=func, args=args, kwargs=kwargs, daemon=True
                 )
@@ -583,7 +586,9 @@ class DBOS:
 
     def _destroy(self) -> None:
         self._initialized = False
-        for event in self.stop_events:
+        for event in self.poller_stop_events:
+            event.set()
+        for event in self.background_thread_stop_events:
             event.set()
         self._background_event_loop.stop()
         if self._sys_db_field is not None:

{dbos-0.27.0a10 → dbos-0.27.1}/dbos/_error.py

@@ -134,12 +134,17 @@ class DBOSNotAuthorizedError(DBOSException):
     """Exception raised by DBOS role-based security when the user is not authorized to access a function."""
 
     def __init__(self, msg: str):
+        self.msg = msg
         super().__init__(
             msg,
             dbos_error_code=DBOSErrorCode.NotAuthorized.value,
         )
         self.status_code = 403
 
+    def __reduce__(self) -> Any:
+        # Tell jsonpickle how to reconstruct this object
+        return (self.__class__, (self.msg,))
+
 
 class DBOSMaxStepRetriesExceeded(DBOSException):
     """Exception raised when a step was retried the maximimum number of times without success."""
@@ -185,11 +190,21 @@ class DBOSQueueDeduplicatedError(DBOSException):
     def __init__(
         self, workflow_id: str, queue_name: str, deduplication_id: str
     ) -> None:
+        self.workflow_id = workflow_id
+        self.queue_name = queue_name
+        self.deduplication_id = deduplication_id
         super().__init__(
             f"Workflow {workflow_id} was deduplicated due to an existing workflow in queue {queue_name} with deduplication ID {deduplication_id}.",
             dbos_error_code=DBOSErrorCode.QueueDeduplicated.value,
         )
 
+    def __reduce__(self) -> Any:
+        # Tell jsonpickle how to reconstruct this object
+        return (
+            self.__class__,
+            (self.workflow_id, self.queue_name, self.deduplication_id),
+        )
+
 
 #######################################
 ## BaseException

{dbos-0.27.0a10 → dbos-0.27.1}/dbos/_recovery.py

@@ -29,7 +29,7 @@ def startup_recovery_thread(
 ) -> None:
     """Attempt to recover local pending workflows on startup using a background thread."""
     stop_event = threading.Event()
-    dbos.stop_events.append(stop_event)
+    dbos.background_thread_stop_events.append(stop_event)
     while not stop_event.is_set() and len(pending_workflows) > 0:
         try:
             for pending_workflow in list(pending_workflows):

dbos-0.27.1/dbos/_serialization.py

@@ -0,0 +1,106 @@
+import types
+from typing import Any, Dict, Optional, Tuple, TypedDict
+
+import jsonpickle  # type: ignore
+
+from ._logger import dbos_logger
+
+
+class WorkflowInputs(TypedDict):
+    args: Tuple[Any, ...]
+    kwargs: Dict[str, Any]
+
+
+def _validate_item(data: Any) -> None:
+    if isinstance(data, (types.FunctionType, types.MethodType)):
+        raise TypeError("Serialized data item should not be a function")
+
+
+def serialize(data: Any) -> str:
+    """Serialize an object to a JSON string using jsonpickle."""
+    _validate_item(data)
+    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
+    return encoded_data
+
+
+def serialize_args(data: WorkflowInputs) -> str:
+    """Serialize args to a JSON string using jsonpickle."""
+    arg: Any
+    for arg in data["args"]:
+        _validate_item(arg)
+    for arg in data["kwargs"].values():
+        _validate_item(arg)
+    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
+    return encoded_data
+
+
+def serialize_exception(data: Exception) -> str:
+    """Serialize an Exception object to a JSON string using jsonpickle."""
+    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
+    return encoded_data
+
+
+def deserialize(serialized_data: str) -> Any:
+    """Deserialize a JSON string back to a Python object using jsonpickle."""
+    return jsonpickle.decode(serialized_data)
+
+
+def deserialize_args(serialized_data: str) -> WorkflowInputs:
+    """Deserialize a JSON string back to a Python object list using jsonpickle."""
+    args: WorkflowInputs = jsonpickle.decode(serialized_data)
+    return args
+
+
+def deserialize_exception(serialized_data: str) -> Exception:
+    """Deserialize JSON string back to a Python Exception using jsonpickle."""
+    exc: Exception = jsonpickle.decode(serialized_data)
+    return exc
+
+
+def safe_deserialize(
+    workflow_id: str,
+    *,
+    serialized_input: Optional[str],
+    serialized_output: Optional[str],
+    serialized_exception: Optional[str],
+) -> tuple[Optional[WorkflowInputs], Optional[Any], Optional[Exception]]:
+    """
+    This function safely deserializes a workflow's recorded input and output/exception.
+    If any of them is not deserializable, it logs a warning and returns a string instead of throwing an exception.
+
+    This function is used in workflow introspection methods (get_workflows and get_queued_workflow)
+    to ensure errors related to nondeserializable objects are observable.
+    """
+    input: Optional[WorkflowInputs]
+    try:
+        input = (
+            deserialize_args(serialized_input) if serialized_input is not None else None
+        )
+    except Exception as e:
+        dbos_logger.warning(
+            f"Warning: input object could not be deserialized for workflow {workflow_id}, returning as string: {e}"
+        )
+        input = serialized_input  # type: ignore
+    output: Optional[Any]
+    try:
+        output = (
+            deserialize(serialized_output) if serialized_output is not None else None
+        )
+    except Exception as e:
+        dbos_logger.warning(
+            f"Warning: output object could not be deserialized for workflow {workflow_id}, returning as string: {e}"
+        )
+        output = serialized_output
+    exception: Optional[Exception]
+    try:
+        exception = (
+            deserialize_exception(serialized_exception)
+            if serialized_exception is not None
+            else None
+        )
+    except Exception as e:
+        dbos_logger.warning(
+            f"Warning: exception object could not be deserialized for workflow {workflow_id}, returning as string: {e}"
+        )
+        exception = serialized_exception  # type: ignore
+    return input, output, exception

{dbos-0.27.0a10 → dbos-0.27.1}/dbos/_sys_db.py

@@ -901,13 +901,15 @@ class SystemDatabase:
             info.app_version = row[14]
             info.app_id = row[15]
 
-            inputs = _serialization.deserialize_args(row[16])
-            if inputs is not None:
-                info.input = inputs
-            if info.status == WorkflowStatusString.SUCCESS.value:
-                info.output = _serialization.deserialize(row[17])
-            elif info.status == WorkflowStatusString.ERROR.value:
-                info.error = _serialization.deserialize_exception(row[18])
+            inputs, output, exception = _serialization.safe_deserialize(
+                info.workflow_id,
+                serialized_input=row[16],
+                serialized_output=row[17],
+                serialized_exception=row[18],
+            )
+            info.input = inputs
+            info.output = output
+            info.error = exception
 
             infos.append(info)
         return infos
@@ -1007,13 +1009,15 @@ class SystemDatabase:
             info.app_version = row[14]
             info.app_id = row[15]
 
-            inputs = _serialization.deserialize_args(row[16])
-            if inputs is not None:
-                info.input = inputs
-            if info.status == WorkflowStatusString.SUCCESS.value:
-                info.output = _serialization.deserialize(row[17])
-            elif info.status == WorkflowStatusString.ERROR.value:
-                info.error = _serialization.deserialize_exception(row[18])
+            inputs, output, exception = _serialization.safe_deserialize(
+                info.workflow_id,
+                serialized_input=row[16],
+                serialized_output=row[17],
+                serialized_exception=row[18],
+            )
+            info.input = inputs
+            info.output = output
+            info.error = exception
 
             infos.append(info)
 

{dbos-0.27.0a10 → dbos-0.27.1}/pyproject.toml

@@ -28,7 +28,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.27.0a10"
+version = "0.27.1"
 
 [project.license]
 text = "MIT"

{dbos-0.27.0a10 → dbos-0.27.1}/tests/test_admin_server.py

@@ -3,6 +3,7 @@ import socket
 import threading
 import time
 import uuid
+from datetime import datetime
 
 import pytest
 import requests
@@ -65,8 +66,59 @@ def test_admin_endpoints(dbos: DBOS) -> None:
     response = requests.get("http://localhost:3001/deactivate", timeout=5)
     assert response.status_code == 200
 
-    for event in dbos.stop_events:
-        assert event.is_set(), "Event is not set!"
+    for event in dbos.poller_stop_events:
+        assert event.is_set()
+
+
+def test_deactivate(dbos: DBOS, config: ConfigFile) -> None:
+    wf_counter: int = 0
+
+    queue = Queue("example-queue")
+
+    @DBOS.scheduled("* * * * * *")
+    @DBOS.workflow()
+    def test_workflow(scheduled: datetime, actual: datetime) -> None:
+        nonlocal wf_counter
+        wf_counter += 1
+
+    @DBOS.workflow()
+    def regular_workflow() -> int:
+        return 5
+
+    # Let the scheduled workflow run
+    time.sleep(2)
+    val = wf_counter
+    assert val > 0
+    # Deactivate--scheduled workflow should stop
+    response = requests.get("http://localhost:3001/deactivate", timeout=5)
+    assert response.status_code == 200
+    for event in dbos.poller_stop_events:
+        assert event.is_set()
+    # Verify the scheduled workflow does not run anymore
+    time.sleep(3)
+    assert wf_counter <= val + 1
+    # Enqueue a workflow, verify it still runs
+    assert queue.enqueue(regular_workflow).get_result() == 5
+
+    # Test deferred event receivers
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.scheduled("* * * * * *")
+    @DBOS.workflow()
+    def deferred_workflow(scheduled: datetime, actual: datetime) -> None:
+        nonlocal wf_counter
+        wf_counter += 1
+
+    DBOS.launch()
+    assert len(dbos.poller_stop_events) > 0
+    for event in dbos.poller_stop_events:
+        assert not event.is_set()
+    # Deactivate--scheduled workflow should stop
+    response = requests.get("http://localhost:3001/deactivate", timeout=5)
+    assert response.status_code == 200
+    for event in dbos.poller_stop_events:
+        assert event.is_set()
 
 
 def test_admin_recovery(config: ConfigFile) -> None:

{dbos-0.27.0a10 → dbos-0.27.1}/tests/test_failures.py

@@ -11,9 +11,16 @@ from dbos import DBOS, Queue, SetWorkflowID
 from dbos._error import (
     DBOSDeadLetterQueueError,
     DBOSMaxStepRetriesExceeded,
+    DBOSNotAuthorizedError,
+    DBOSQueueDeduplicatedError,
     DBOSUnexpectedStepError,
 )
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
+from dbos._serialization import (
+    deserialize_exception,
+    safe_deserialize,
+    serialize_exception,
+)
 from dbos._sys_db import WorkflowStatusString
 
 from .conftest import queue_entries_are_cleaned_up
@@ -434,3 +441,42 @@ def test_keyboardinterrupt_during_retries(dbos: DBOS) -> None:
     recovery_handles = DBOS._recover_pending_workflows()
     assert len(recovery_handles) == 1
     assert recovery_handles[0].get_result() == recovery_handles[0].workflow_id
+
+
+def test_error_serialization() -> None:
+    # Verify that each exception that can be thrown in a workflow
+    # is serializable and deserializable
+    # DBOSMaxStepRetriesExceeded
+    e: Exception = DBOSMaxStepRetriesExceeded("step", 1)
+    d = deserialize_exception(serialize_exception(e))
+    assert isinstance(d, DBOSMaxStepRetriesExceeded)
+    assert str(d) == str(e)
+    # DBOSNotAuthorizedError
+    e = DBOSNotAuthorizedError("no")
+    d = deserialize_exception(serialize_exception(e))
+    assert isinstance(d, DBOSNotAuthorizedError)
+    assert str(d) == str(e)
+    # DBOSQueueDeduplicatedError
+    e = DBOSQueueDeduplicatedError("id", "queue", "dedup")
+    d = deserialize_exception(serialize_exception(e))
+    assert isinstance(d, DBOSQueueDeduplicatedError)
+    assert str(d) == str(e)
+
+    # Test safe_deserialize
+    class BadException(Exception):
+        def __init__(self, one: int, two: int) -> None:
+            super().__init__(f"Message: {one}, {two}")
+
+    bad_exception = BadException(1, 2)
+    with pytest.raises(TypeError):
+        deserialize_exception(serialize_exception(bad_exception))
+    input, output, exception = safe_deserialize(
+        "my_id",
+        serialized_input=None,
+        serialized_exception=serialize_exception(bad_exception),
+        serialized_output=None,
+    )
+    assert input is None
+    assert output is None
+    assert isinstance(exception, str)
+    assert "Message: 1, 2" in exception

{dbos-0.27.0a10 → dbos-0.27.1}/tests/test_scheduler.py

@@ -202,7 +202,8 @@ def test_scheduler_oaoo(dbos: DBOS) -> None:
                 time.sleep(1)
 
     # Stop the scheduled workflow
-    dbos.stop_events[0].set()
+    for evt in dbos.poller_stop_events:
+        evt.set()
 
     dbos._sys_db.update_workflow_status(
         {

dbos-0.27.0a10/dbos/_serialization.py

@@ -1,55 +0,0 @@
-import types
-from typing import Any, Dict, Tuple, TypedDict
-
-import jsonpickle  # type: ignore
-
-
-class WorkflowInputs(TypedDict):
-    args: Tuple[Any, ...]
-    kwargs: Dict[str, Any]
-
-
-def _validate_item(data: Any) -> None:
-    if isinstance(data, (types.FunctionType, types.MethodType)):
-        raise TypeError("Serialized data item should not be a function")
-
-
-def serialize(data: Any) -> str:
-    """Serialize an object to a JSON string using jsonpickle."""
-    _validate_item(data)
-    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
-    return encoded_data
-
-
-def serialize_args(data: WorkflowInputs) -> str:
-    """Serialize args to a JSON string using jsonpickle."""
-    arg: Any
-    for arg in data["args"]:
-        _validate_item(arg)
-    for arg in data["kwargs"].values():
-        _validate_item(arg)
-    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
-    return encoded_data
-
-
-def serialize_exception(data: Exception) -> str:
-    """Serialize an Exception object to a JSON string using jsonpickle."""
-    encoded_data: str = jsonpickle.encode(data, unpicklable=True)
-    return encoded_data
-
-
-def deserialize(serialized_data: str) -> Any:
-    """Deserialize a JSON string back to a Python object using jsonpickle."""
-    return jsonpickle.decode(serialized_data)
-
-
-def deserialize_args(serialized_data: str) -> WorkflowInputs:
-    """Deserialize a JSON string back to a Python object list using jsonpickle."""
-    args: WorkflowInputs = jsonpickle.decode(serialized_data)
-    return args
-
-
-def deserialize_exception(serialized_data: str) -> Exception:
-    """Deserialize JSON string back to a Python Exception using jsonpickle."""
-    upo: Exception = jsonpickle.decode(serialized_data)
-    return upo