dbos 0.25.0a9__py3-none-any.whl → 0.25.0a13__py3-none-any.whl

dbos/_conductor/conductor.py

@@ -9,7 +9,12 @@ from websockets.sync.client import connect
 from websockets.sync.connection import Connection
 
 from dbos._utils import GlobalParams
-from dbos._workflow_commands import get_workflow, list_queued_workflows, list_workflows
+from dbos._workflow_commands import (
+    get_workflow,
+    list_queued_workflows,
+    list_workflow_steps,
+    list_workflows,
+)
 
 from . import protocol as p
 
@@ -243,6 +248,32 @@ class ConductorWebsocket(threading.Thread):
                                 )
                             )
                             websocket.send(exist_pending_workflows_response.to_json())
+                        elif msg_type == p.MessageType.LIST_STEPS:
+                            list_steps_message = p.ListStepsRequest.from_json(message)
+                            step_info = None
+                            try:
+                                step_info = list_workflow_steps(
+                                    self.dbos._sys_db,
+                                    list_steps_message.workflow_id,
+                                )
+                            except Exception as e:
+                                error_message = f"Exception encountered when getting workflow {list_steps_message.workflow_id}: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
+
+                            list_steps_response = p.ListStepsResponse(
+                                type=p.MessageType.LIST_STEPS,
+                                request_id=base_message.request_id,
+                                output=(
+                                    [
+                                        p.WorkflowSteps.from_step_info(i)
+                                        for i in step_info
+                                    ]
+                                    if step_info is not None
+                                    else None
+                                ),
+                                error_message=error_message,
+                            )
+                            websocket.send(list_steps_response.to_json())
                         else:
                             self.dbos.logger.warning(
                                 f"Unexpected message type: {msg_type}"

dbos/_conductor/protocol.py

@@ -3,6 +3,7 @@ from dataclasses import asdict, dataclass
 from enum import Enum
 from typing import List, Optional, Type, TypedDict, TypeVar
 
+from dbos._sys_db import StepInfo
 from dbos._workflow_commands import WorkflowStatus
 
 
@@ -16,6 +17,7 @@ class MessageType(str, Enum):
     RESTART = "restart"
     GET_WORKFLOW = "get_workflow"
     EXIST_PENDING_WORKFLOWS = "exist_pending_workflows"
+    LIST_STEPS = "list_steps"
 
 
 T = TypeVar("T", bound="BaseMessage")
@@ -176,6 +178,27 @@ class WorkflowsOutput:
         )
 
 
+@dataclass
+class WorkflowSteps:
+    function_id: int
+    function_name: str
+    output: Optional[str]
+    error: Optional[str]
+    child_workflow_id: Optional[str]
+
+    @classmethod
+    def from_step_info(cls, info: StepInfo) -> "WorkflowSteps":
+        output_str = str(info["output"]) if info["output"] is not None else None
+        error_str = str(info["error"]) if info["error"] is not None else None
+        return cls(
+            function_id=info["function_id"],
+            function_name=info["function_name"],
+            output=output_str,
+            error=error_str,
+            child_workflow_id=info["child_workflow_id"],
+        )
+
+
 @dataclass
 class ListWorkflowsRequest(BaseMessage):
     body: ListWorkflowsBody
@@ -230,3 +253,14 @@ class ExistPendingWorkflowsRequest(BaseMessage):
 class ExistPendingWorkflowsResponse(BaseMessage):
     exist: bool
     error_message: Optional[str] = None
+
+
+@dataclass
+class ListStepsRequest(BaseMessage):
+    workflow_id: str
+
+
+@dataclass
+class ListStepsResponse(BaseMessage):
+    output: Optional[List[WorkflowSteps]]
+    error_message: Optional[str] = None

dbos/_core.py

@@ -108,7 +108,15 @@ class WorkflowHandleFuture(Generic[R]):
         return self.workflow_id
 
     def get_result(self) -> R:
-        return self.future.result()
+        try:
+            r = self.future.result()
+        except Exception as e:
+            serialized_e = _serialization.serialize_exception(e)
+            self.dbos._sys_db.record_get_result(self.workflow_id, None, serialized_e)
+            raise
+        serialized_r = _serialization.serialize(r)
+        self.dbos._sys_db.record_get_result(self.workflow_id, serialized_r, None)
+        return r
 
     def get_status(self) -> "WorkflowStatus":
         stat = self.dbos.get_workflow_status(self.workflow_id)
@@ -127,8 +135,15 @@ class WorkflowHandlePolling(Generic[R]):
         return self.workflow_id
 
     def get_result(self) -> R:
-        res: R = self.dbos._sys_db.await_workflow_result(self.workflow_id)
-        return res
+        try:
+            r: R = self.dbos._sys_db.await_workflow_result(self.workflow_id)
+        except Exception as e:
+            serialized_e = _serialization.serialize_exception(e)
+            self.dbos._sys_db.record_get_result(self.workflow_id, None, serialized_e)
+            raise
+        serialized_r = _serialization.serialize(r)
+        self.dbos._sys_db.record_get_result(self.workflow_id, serialized_r, None)
+        return r
 
     def get_status(self) -> "WorkflowStatus":
         stat = self.dbos.get_workflow_status(self.workflow_id)
@@ -148,7 +163,22 @@ class WorkflowHandleAsyncTask(Generic[R]):
         return self.workflow_id
 
     async def get_result(self) -> R:
-        return await self.task
+        try:
+            r = await self.task
+        except Exception as e:
+            serialized_e = _serialization.serialize_exception(e)
+            await asyncio.to_thread(
+                self.dbos._sys_db.record_get_result,
+                self.workflow_id,
+                None,
+                serialized_e,
+            )
+            raise
+        serialized_r = _serialization.serialize(r)
+        await asyncio.to_thread(
+            self.dbos._sys_db.record_get_result, self.workflow_id, serialized_r, None
+        )
+        return r
 
     async def get_status(self) -> "WorkflowStatus":
         stat = await asyncio.to_thread(self.dbos.get_workflow_status, self.workflow_id)
@@ -167,10 +197,24 @@ class WorkflowHandleAsyncPolling(Generic[R]):
         return self.workflow_id
 
     async def get_result(self) -> R:
-        res: R = await asyncio.to_thread(
-            self.dbos._sys_db.await_workflow_result, self.workflow_id
+        try:
+            r: R = await asyncio.to_thread(
+                self.dbos._sys_db.await_workflow_result, self.workflow_id
+            )
+        except Exception as e:
+            serialized_e = _serialization.serialize_exception(e)
+            await asyncio.to_thread(
+                self.dbos._sys_db.record_get_result,
+                self.workflow_id,
+                None,
+                serialized_e,
+            )
+            raise
+        serialized_r = _serialization.serialize(r)
+        await asyncio.to_thread(
+            self.dbos._sys_db.record_get_result, self.workflow_id, serialized_r, None
         )
-        return res
+        return r
 
     async def get_status(self) -> "WorkflowStatus":
         stat = await asyncio.to_thread(self.dbos.get_workflow_status, self.workflow_id)
@@ -235,25 +279,14 @@ def _init_workflow(
             raise DBOSNonExistentWorkflowError(wfid)
         wf_status = get_status_result["status"]
     else:
-        if temp_wf_type != "transaction" or queue is not None:
-            # Synchronously record the status and inputs for workflows and single-step workflows
-            # We also have to do this for single-step workflows because of the foreign key constraint on the operation outputs table
-            # TODO: Make this transactional (and with the queue step below)
-            wf_status = dbos._sys_db.insert_workflow_status(
-                status, max_recovery_attempts=max_recovery_attempts
-            )
-
-            # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
-            dbos._sys_db.update_workflow_inputs(
-                wfid, _serialization.serialize_args(inputs)
-            )
-
-        else:
-            # Buffer the inputs for single-transaction workflows, but don't buffer the status
+        # Synchronously record the status and inputs for workflows
+        # TODO: Make this transactional (and with the queue step below)
+        wf_status = dbos._sys_db.insert_workflow_status(
+            status, max_recovery_attempts=max_recovery_attempts
+        )
 
-            dbos._sys_db.buffer_workflow_inputs(
-                wfid, _serialization.serialize_args(inputs)
-            )
+        # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
+        dbos._sys_db.update_workflow_inputs(wfid, _serialization.serialize_args(inputs))
 
         if queue is not None and wf_status == WorkflowStatusString.ENQUEUED.value:
             dbos._sys_db.enqueue(wfid, queue)
@@ -267,6 +300,18 @@ def _get_wf_invoke_func(
     status: WorkflowStatusInternal,
 ) -> Callable[[Callable[[], R]], R]:
     def persist(func: Callable[[], R]) -> R:
+        if not dbos.debug_mode and (
+            status["status"] == WorkflowStatusString.ERROR.value
+            or status["status"] == WorkflowStatusString.SUCCESS.value
+        ):
+            dbos.logger.debug(
+                f"Workflow {status['workflow_uuid']} is already completed with status {status['status']}"
+            )
+            # Directly return the result if the workflow is already completed
+            recorded_result: R = dbos._sys_db.await_workflow_result(
+                status["workflow_uuid"]
+            )
+            return recorded_result
         try:
             output = func()
             status["status"] = "SUCCESS"
@@ -275,16 +320,12 @@ def _get_wf_invoke_func(
                 if status["queue_name"] is not None:
                     queue = dbos._registry.queue_info_map[status["queue_name"]]
                     dbos._sys_db.remove_from_queue(status["workflow_uuid"], queue)
-                dbos._sys_db.buffer_workflow_status(status)
+                dbos._sys_db.update_workflow_status(status)
             return output
         except DBOSWorkflowConflictIDError:
-            # Retrieve the workflow handle and wait for the result.
-            # Must use existing_workflow=False because workflow status might not be set yet for single transaction workflows.
-            wf_handle: "WorkflowHandle[R]" = dbos.retrieve_workflow(
-                status["workflow_uuid"], existing_workflow=False
-            )
-            output = wf_handle.get_result()
-            return output
+            # Await the workflow result
+            r: R = dbos._sys_db.await_workflow_result(status["workflow_uuid"])
+            return r
         except DBOSWorkflowCancelledError as error:
             raise
         except Exception as error:
@@ -504,7 +545,7 @@ def start_workflow(
             ctx.parent_workflow_id,
             new_child_workflow_id,
             ctx.parent_workflow_fid,
-            func.__name__,
+            get_dbos_func_name(func),
         )
 
     if not execute_workflow or (
@@ -589,7 +630,7 @@ async def start_workflow_async(
             ctx.parent_workflow_id,
             new_child_workflow_id,
             ctx.parent_workflow_fid,
-            func.__name__,
+            get_dbos_func_name(func),
         )
 
     wf_status = status["status"]
@@ -631,8 +672,6 @@ def workflow_wrapper(
 ) -> Callable[P, R]:
     func.__orig_func = func  # type: ignore
 
-    funcName = func.__name__
-
     fi = get_or_create_func_info(func)
     fi.max_recovery_attempts = max_recovery_attempts
 
@@ -662,17 +701,22 @@ def workflow_wrapper(
 
         wfOutcome = Outcome[R].make(functools.partial(func, *args, **kwargs))
 
+        workflow_id = None
+
         def init_wf() -> Callable[[Callable[[], R]], R]:
 
             def recorded_result(
                 c_wfid: str, dbos: "DBOS"
             ) -> Callable[[Callable[[], R]], R]:
                 def recorded_result_inner(func: Callable[[], R]) -> R:
-                    return WorkflowHandlePolling(c_wfid, dbos).get_result()
+                    r: R = dbos._sys_db.await_workflow_result(c_wfid)
+                    return r
 
                 return recorded_result_inner
 
             ctx = assert_current_dbos_context()  # Now the child ctx
+            nonlocal workflow_id
+            workflow_id = ctx.workflow_id
 
             if ctx.has_parent():
                 child_workflow_id = dbos._sys_db.check_child_workflow(
@@ -702,15 +746,33 @@ def workflow_wrapper(
                     ctx.parent_workflow_id,
                     ctx.workflow_id,
                     ctx.parent_workflow_fid,
-                    funcName,
+                    get_dbos_func_name(func),
                 )
 
             return _get_wf_invoke_func(dbos, status)
 
+        def record_get_result(func: Callable[[], R]) -> R:
+            """
+            If a child workflow is invoked synchronously, this records the implicit "getResult" where the
+            parent retrieves the child's output. It executes in the CALLER'S context, not the workflow's.
+            """
+            try:
+                r = func()
+            except Exception as e:
+                serialized_e = _serialization.serialize_exception(e)
+                assert workflow_id is not None
+                dbos._sys_db.record_get_result(workflow_id, None, serialized_e)
+                raise
+            serialized_r = _serialization.serialize(r)
+            assert workflow_id is not None
+            dbos._sys_db.record_get_result(workflow_id, serialized_r, None)
+            return r
+
         outcome = (
             wfOutcome.wrap(init_wf)
             .also(DBOSAssumeRole(rr))
             .also(enterWorkflowCtxMgr(attributes))
+            .then(record_get_result)
         )
         return outcome()  # type: ignore
 
@@ -913,7 +975,7 @@ def decorate_step(
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def decorator(func: Callable[P, R]) -> Callable[P, R]:
 
-        stepName = func.__name__
+        stepName = func.__qualname__
 
         def invoke_step(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:

dbos/_dbos.py

@@ -485,14 +485,6 @@ class DBOS:
             notification_listener_thread.start()
             self._background_threads.append(notification_listener_thread)
 
-            # Start flush workflow buffers thread
-            flush_workflow_buffers_thread = threading.Thread(
-                target=self._sys_db.flush_workflow_buffers,
-                daemon=True,
-            )
-            flush_workflow_buffers_thread.start()
-            self._background_threads.append(flush_workflow_buffers_thread)
-
             # Start the queue thread
             evt = threading.Event()
             self.stop_events.append(evt)
@@ -548,6 +540,10 @@ class DBOS:
         """
         if _dbos_global_instance is not None:
             _dbos_global_instance._reset_system_database()
+        else:
+            dbos_logger.warning(
+                "reset_system_database has no effect because global DBOS object does not exist"
+            )
 
     def _reset_system_database(self) -> None:
         assert (

dbos/_sys_db.py

@@ -33,7 +33,6 @@ from ._dbos_config import ConfigFile
 from ._error import (
     DBOSConflictingWorkflowError,
     DBOSDeadLetterQueueError,
-    DBOSException,
     DBOSNonExistentWorkflowError,
     DBOSWorkflowConflictIDError,
 )
@@ -154,16 +153,19 @@ class GetPendingWorkflowsOutput:
 
 
 class StepInfo(TypedDict):
+    # The unique ID of the step in the workflow
     function_id: int
+    # The (fully qualified) name of the step
     function_name: str
-    output: Optional[str]  # JSON (jsonpickle)
-    error: Optional[str]  # JSON (jsonpickle)
+    # The step's output, if any
+    output: Optional[Any]
+    # The error the step threw, if any
+    error: Optional[Exception]
+    # If the step starts or retrieves the result of a workflow, its ID
     child_workflow_id: Optional[str]
 
 
 _dbos_null_topic = "__null__topic__"
-_buffer_flush_batch_size = 100
-_buffer_flush_interval_secs = 1.0
 
 
 class SystemDatabase:
@@ -260,32 +262,17 @@ class SystemDatabase:
         self.notifications_map: Dict[str, threading.Condition] = {}
         self.workflow_events_map: Dict[str, threading.Condition] = {}
 
-        # Initialize the workflow status and inputs buffers
-        self._workflow_status_buffer: Dict[str, WorkflowStatusInternal] = {}
-        self._workflow_inputs_buffer: Dict[str, str] = {}
-        # Two sets for tracking which single-transaction workflows have been exported to the status table
-        self._exported_temp_txn_wf_status: Set[str] = set()
-        self._temp_txn_wf_ids: Set[str] = set()
-        self._is_flushing_status_buffer = False
-
         # Now we can run background processes
         self._run_background_processes = True
         self._debug_mode = debug_mode
 
     # Destroy the pool when finished
     def destroy(self) -> None:
-        self.wait_for_buffer_flush()
         self._run_background_processes = False
         if self.notification_conn is not None:
             self.notification_conn.close()
         self.engine.dispose()
 
-    def wait_for_buffer_flush(self) -> None:
-        # Wait until the buffers are flushed.
-        while self._is_flushing_status_buffer or not self._is_buffers_empty:
-            dbos_logger.debug("Waiting for system buffers to be exported")
-            time.sleep(1)
-
     def insert_workflow_status(
         self,
         status: WorkflowStatusInternal,
@@ -436,10 +423,6 @@ class SystemDatabase:
             with self.engine.begin() as c:
                 c.execute(cmd)
 
-        # If this is a single-transaction workflow, record that its status has been exported
-        if status["workflow_uuid"] in self._temp_txn_wf_ids:
-            self._exported_temp_txn_wf_status.add(status["workflow_uuid"])
-
     def cancel_workflow(
         self,
         workflow_id: str,
@@ -617,10 +600,7 @@ class SystemDatabase:
                     f"Workflow {workflow_uuid} has been called multiple times with different inputs"
                 )
             # TODO: actually changing the input
-        if workflow_uuid in self._temp_txn_wf_ids:
-            # Clean up the single-transaction tracking sets
-            self._exported_temp_txn_wf_status.discard(workflow_uuid)
-            self._temp_txn_wf_ids.discard(workflow_uuid)
+
         return
 
     def get_workflow_inputs(
@@ -771,8 +751,16 @@ class SystemDatabase:
                 StepInfo(
                     function_id=row[0],
                     function_name=row[1],
-                    output=row[2],  # Preserve JSON data
-                    error=row[3],
+                    output=(
+                        _serialization.deserialize(row[2])
+                        if row[2] is not None
+                        else row[2]
+                    ),
+                    error=(
+                        _serialization.deserialize_exception(row[3])
+                        if row[3] is not None
+                        else row[3]
+                    ),
                     child_workflow_id=row[4],
                 )
                 for row in rows
@@ -804,6 +792,31 @@ class SystemDatabase:
                 raise DBOSWorkflowConflictIDError(result["workflow_uuid"])
             raise
 
+    def record_get_result(
+        self, result_workflow_id: str, output: Optional[str], error: Optional[str]
+    ) -> None:
+        ctx = get_local_dbos_context()
+        # Only record get_result called in workflow functions
+        if ctx is None or not ctx.is_workflow():
+            return
+        ctx.function_id += 1  # Record the get_result as a step
+        # Because there's no corresponding check, we do nothing on conflict
+        # and do not raise a DBOSWorkflowConflictIDError
+        sql = (
+            pg.insert(SystemSchema.operation_outputs)
+            .values(
+                workflow_uuid=ctx.workflow_id,
+                function_id=ctx.function_id,
+                function_name="DBOS.getResult",
+                output=output,
+                error=error,
+                child_workflow_id=result_workflow_id,
+            )
+            .on_conflict_do_nothing()
+        )
+        with self.engine.begin() as c:
+            c.execute(sql)
+
     def record_child_workflow(
         self,
         parentUUID: str,
@@ -1238,106 +1251,6 @@ class SystemDatabase:
             )
         return value
 
-    def _flush_workflow_status_buffer(self) -> None:
-        if self._debug_mode:
-            raise Exception("called _flush_workflow_status_buffer in debug mode")
-
-        """Export the workflow status buffer to the database, up to the batch size."""
-        if len(self._workflow_status_buffer) == 0:
-            return
-
-        # Record the exported status so far, and add them back on errors.
-        exported_status: Dict[str, WorkflowStatusInternal] = {}
-        with self.engine.begin() as c:
-            exported = 0
-            status_iter = iter(list(self._workflow_status_buffer))
-            wf_id: Optional[str] = None
-            while (
-                exported < _buffer_flush_batch_size
-                and (wf_id := next(status_iter, None)) is not None
-            ):
-                # Pop the first key in the buffer (FIFO)
-                status = self._workflow_status_buffer.pop(wf_id, None)
-                if status is None:
-                    continue
-                exported_status[wf_id] = status
-                try:
-                    self.update_workflow_status(status, conn=c)
-                    exported += 1
-                except Exception as e:
-                    dbos_logger.error(f"Error while flushing status buffer: {e}")
-                    c.rollback()
-                    # Add the exported status back to the buffer, so they can be retried next time
-                    self._workflow_status_buffer.update(exported_status)
-                    break
-
-    def _flush_workflow_inputs_buffer(self) -> None:
-        if self._debug_mode:
-            raise Exception("called _flush_workflow_inputs_buffer in debug mode")
-
-        """Export the workflow inputs buffer to the database, up to the batch size."""
-        if len(self._workflow_inputs_buffer) == 0:
-            return
-
-        # Record exported inputs so far, and add them back on errors.
-        exported_inputs: Dict[str, str] = {}
-        with self.engine.begin() as c:
-            exported = 0
-            input_iter = iter(list(self._workflow_inputs_buffer))
-            wf_id: Optional[str] = None
-            while (
-                exported < _buffer_flush_batch_size
-                and (wf_id := next(input_iter, None)) is not None
-            ):
-                if wf_id not in self._exported_temp_txn_wf_status:
-                    # Skip exporting inputs if the status has not been exported yet
-                    continue
-                inputs = self._workflow_inputs_buffer.pop(wf_id, None)
-                if inputs is None:
-                    continue
-                exported_inputs[wf_id] = inputs
-                try:
-                    self.update_workflow_inputs(wf_id, inputs, conn=c)
-                    exported += 1
-                except Exception as e:
-                    dbos_logger.error(f"Error while flushing inputs buffer: {e}")
-                    c.rollback()
-                    # Add the exported inputs back to the buffer, so they can be retried next time
-                    self._workflow_inputs_buffer.update(exported_inputs)
-                    break
-
-    def flush_workflow_buffers(self) -> None:
-        """Flush the workflow status and inputs buffers periodically, via a background thread."""
-        while self._run_background_processes:
-            try:
-                self._is_flushing_status_buffer = True
-                # Must flush the status buffer first, as the inputs table has a foreign key constraint on the status table.
-                self._flush_workflow_status_buffer()
-                self._flush_workflow_inputs_buffer()
-                self._is_flushing_status_buffer = False
-                if self._is_buffers_empty:
-                    # Only sleep if both buffers are empty
-                    time.sleep(_buffer_flush_interval_secs)
-            except Exception as e:
-                dbos_logger.error(f"Error while flushing buffers: {e}")
-                time.sleep(_buffer_flush_interval_secs)
-                # Will retry next time
-
-    def buffer_workflow_status(self, status: WorkflowStatusInternal) -> None:
-        self._workflow_status_buffer[status["workflow_uuid"]] = status
-
-    def buffer_workflow_inputs(self, workflow_id: str, inputs: str) -> None:
-        # inputs is a serialized WorkflowInputs string
-        self._workflow_inputs_buffer[workflow_id] = inputs
-        self._temp_txn_wf_ids.add(workflow_id)
-
-    @property
-    def _is_buffers_empty(self) -> bool:
-        return (
-            len(self._workflow_status_buffer) == 0
-            and len(self._workflow_inputs_buffer) == 0
-        )
-
     def enqueue(self, workflow_id: str, queue_name: str) -> None:
         if self._debug_mode:
             raise Exception("called enqueue in debug mode")

{dbos-0.25.0a9.dist-info → dbos-0.25.0a13.dist-info}/METADATA

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

{dbos-0.25.0a9.dist-info → dbos-0.25.0a13.dist-info}/RECORD

@@ -1,7 +1,7 @@
-dbos-0.25.0a9.dist-info/METADATA,sha256=zE1UQqo38SY2JASBzAeKriGW_47W7Y3Z0atOx1frcVk,5553
-dbos-0.25.0a9.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-dbos-0.25.0a9.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.25.0a9.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.25.0a13.dist-info/METADATA,sha256=53Gij6b4Z6I2vTd2kr_izPtVtXH5YTGu-KKbwFW-W3w,5554
+dbos-0.25.0a13.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+dbos-0.25.0a13.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.25.0a13.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=2Ur8QyNElSVn7CeL9Ovek2Zsye8A_ZCyjb9djF-N4A4,785
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=7kguOf9jEt4vg9LO-QJdh4jYddp6Uqtrt14gh7mKA2Y,6387
@@ -10,13 +10,13 @@ dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
 dbos/_cloudutils/authentication.py,sha256=V0fCWQN9stCkhbuuxgPTGpvuQcDqfU3KAxPAh01vKW4,5007
 dbos/_cloudutils/cloudutils.py,sha256=YC7jGsIopT0KveLsqbRpQk2KlRBk-nIRC_UCgep4f3o,7797
 dbos/_cloudutils/databases.py,sha256=_shqaqSvhY4n2ScgQ8IP5PDZvzvcx3YBKV8fj-cxhSY,8543
-dbos/_conductor/conductor.py,sha256=oDlRpGxLT-uLDjEX1JwTwcJiH2FzDsrOTtnrkt_X_1U,15253
-dbos/_conductor/protocol.py,sha256=Bj4dhbAhAfj4IrMs_8OYJda2SdjAv1lcePXXG1MejPM,5800
+dbos/_conductor/conductor.py,sha256=7elKINsgl4s1Tg5DwrU-K7xQ5vQvmDAIfAvUgfwpGN0,16784
+dbos/_conductor/protocol.py,sha256=xN7pmooyF1pqbH1b6WhllU5718P7zSb_b0KCwA6bzcs,6716
 dbos/_context.py,sha256=3He4w46OTFbR7h8U1MLcdaU10wNyIPBSRqzLkdggv7U,19368
-dbos/_core.py,sha256=b7ndBxicB66j2LW61pUWbFVAQR0RO9fAefqn9vqSh40,43303
+dbos/_core.py,sha256=kIj_4wlIff8ptlACJKXAPSNoyJIt2h44swjMKxfwv0k,45789
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
 dbos/_db_wizard.py,sha256=VnMa6OL87Lc-XPDD1RnXp8NjsJE8YgiQLj3wtWAXp-8,8252
-dbos/_dbos.py,sha256=UP5Dl8Tp0xMMv63E7-9r6qnnQxbVKk2nMNad4XbNi10,45331
+dbos/_dbos.py,sha256=IZ3Qj8UBUqYYJiG6HVz35A0GQnQyI1Po_-E6DDvWlQg,45147
 dbos/_dbos_config.py,sha256=7Qm3FARP3lTKZS0gSxDHLbpaDCT30GzfyERxfCde4bc,21566
 dbos/_debug.py,sha256=mmgvLkqlrljMBBow9wk01PPur9kUf2rI_11dTJXY4gw,1822
 dbos/_error.py,sha256=B6Y9XLS1f6yrawxB2uAEYFMxFwk9BHhdxPNddKco-Fw,5399
@@ -46,7 +46,7 @@ dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=KeyoPrF7hy_ODXV7QNike_VFSD74QBRfQ76D7QyE9HI,966
 dbos/_schemas/system_database.py,sha256=W9eSpL7SZzQkxcEZ4W07BOcwkkDr35b9oCjUOgfHWek,5336
 dbos/_serialization.py,sha256=YCYv0qKAwAZ1djZisBC7khvKqG-5OcIv9t9EC5PFIog,1743
-dbos/_sys_db.py,sha256=vA8G_r2OpX3lQr0JbxRkpIe6A5Cs7ED1wqVV1BosSf0,66759
+dbos/_sys_db.py,sha256=33euvXfpbpVaCpR0Sx5eQ4yBt1gRKGdvfGQUugqoJBY,62320
 dbos/_templates/dbos-db-starter/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
 dbos/_templates/dbos-db-starter/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_templates/dbos-db-starter/__package/main.py,sha256=nJMN3ZD2lmwg4Dcgmiwqc-tQGuCJuJal2Xl85iA277U,2453
@@ -66,4 +66,4 @@ dbos/cli/cli.py,sha256=ut47q-R6A423je0zvBTEgwdxENagaKKoyIvyTeACFIU,15977
 dbos/dbos-config.schema.json,sha256=HtF_njVTGHLdzBGZ4OrGQz3qbPPT0Go-iwd1PgFVTNg,5847
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.25.0a9.dist-info/RECORD,,
+dbos-0.25.0a13.dist-info/RECORD,,