dbos 0.26.0a1__py3-none-any.whl → 0.26.0a5__py3-none-any.whl

dbos/_admin_server.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Any, List, TypedDict
 
 from ._logger import dbos_logger
 from ._recovery import recover_pending_workflows
+from ._utils import GlobalParams
 
 if TYPE_CHECKING:
     from ._dbos import DBOS
@@ -44,6 +45,7 @@ class AdminServer:
 class AdminRequestHandler(BaseHTTPRequestHandler):
     def __init__(self, dbos: DBOS, *args: Any, **kwargs: Any) -> None:
         self.dbos = dbos
+        self.is_deactivated = False
         super().__init__(*args, **kwargs)
 
     def _end_headers(self) -> None:
@@ -59,10 +61,14 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self._end_headers()
             self.wfile.write("healthy".encode("utf-8"))
         elif self.path == _deactivate_path:
+            if not self.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."
+                )
+                self.is_deactivated = True
             # Stop all scheduled workflows, queues, and kafka loops
             for event in self.dbos.stop_events:
                 event.set()
-
             self.send_response(200)
             self._end_headers()
             self.wfile.write("deactivated".encode("utf-8"))

dbos/_client.py

@@ -22,10 +22,9 @@ R = TypeVar("R", covariant=True)  # A generic type for workflow return values
 
 class EnqueueOptions(TypedDict):
     workflow_name: str
-    workflow_class_name: NotRequired[str]
     queue_name: str
-    app_version: NotRequired[str]
     workflow_id: NotRequired[str]
+    app_version: NotRequired[str]
 
 
 class WorkflowHandleClientPolling(Generic[R]):
@@ -86,7 +85,6 @@ class DBOSClient:
         workflow_name = options["workflow_name"]
         queue_name = options["queue_name"]
 
-        workflow_class_name = options.get("workflow_class_name")
         app_version = options.get("app_version")
         max_recovery_attempts = options.get("max_recovery_attempts")
         if max_recovery_attempts is None:
@@ -99,7 +97,7 @@ class DBOSClient:
             "workflow_uuid": workflow_id,
             "status": WorkflowStatusString.ENQUEUED.value,
             "name": workflow_name,
-            "class_name": workflow_class_name,
+            "class_name": None,
             "queue_name": queue_name,
             "app_version": app_version,
             "config_name": None,

dbos/_context.py

@@ -195,8 +195,10 @@ class DBOSContext:
     def end_handler(self, exc_value: Optional[BaseException]) -> None:
         self._end_span(exc_value)
 
-    def get_current_span(self) -> Span:
-        return self.spans[-1]
+    def get_current_span(self) -> Optional[Span]:
+        if len(self.spans):
+            return self.spans[-1]
+        return None
 
     def _start_span(self, attributes: TracedAttributes) -> None:
         attributes["operationUUID"] = (

dbos/_core.py

@@ -398,9 +398,7 @@ async def _execute_workflow_async(
                 raise
 
 
-def execute_workflow_by_id(
-    dbos: "DBOS", workflow_id: str, startNew: bool = False
-) -> "WorkflowHandle[Any]":
+def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[Any]":
     status = dbos._sys_db.get_workflow_status(workflow_id)
     if not status:
         raise DBOSRecoveryError(workflow_id, "Workflow status not found")
@@ -441,7 +439,7 @@ def execute_workflow_by_id(
             class_object = dbos._registry.class_info_map[class_name]
             inputs["args"] = (class_object,) + inputs["args"]
 
-        if startNew:
+        with SetWorkflowID(workflow_id):
             return start_workflow(
                 dbos,
                 wf_func,
@@ -450,16 +448,6 @@ def execute_workflow_by_id(
                 *inputs["args"],
                 **inputs["kwargs"],
             )
-        else:
-            with SetWorkflowID(workflow_id):
-                return start_workflow(
-                    dbos,
-                    wf_func,
-                    status["queue_name"],
-                    True,
-                    *inputs["args"],
-                    **inputs["kwargs"],
-                )
 
 
 def _get_new_wf() -> tuple[str, DBOSContext]:
@@ -892,10 +880,12 @@ def decorate_transaction(
                         except DBAPIError as dbapi_error:
                             if dbapi_error.orig.sqlstate == "40001":  # type: ignore
                                 # Retry on serialization failure
-                                ctx.get_current_span().add_event(
-                                    "Transaction Serialization Failure",
-                                    {"retry_wait_seconds": retry_wait_seconds},
-                                )
+                                span = ctx.get_current_span()
+                                if span:
+                                    span.add_event(
+                                        "Transaction Serialization Failure",
+                                        {"retry_wait_seconds": retry_wait_seconds},
+                                    )
                                 time.sleep(retry_wait_seconds)
                                 retry_wait_seconds = min(
                                     retry_wait_seconds * backoff_factor,
@@ -1004,13 +994,15 @@ def decorate_step(
                     f"Step being automatically retried. (attempt {attempt + 1} of {attempts}). {traceback.format_exc()}"
                 )
                 ctx = assert_current_dbos_context()
-                ctx.get_current_span().add_event(
-                    f"Step attempt {attempt} failed",
-                    {
-                        "error": str(error),
-                        "retryIntervalSeconds": interval_seconds,
-                    },
-                )
+                span = ctx.get_current_span()
+                if span:
+                    span.add_event(
+                        f"Step attempt {attempt} failed",
+                        {
+                            "error": str(error),
+                            "retryIntervalSeconds": interval_seconds,
+                        },
+                    )
                 return min(
                     interval_seconds * (backoff_rate**attempt),
                     max_retry_interval_seconds,

dbos/_dbos.py

@@ -33,7 +33,7 @@ from opentelemetry.trace import Span
 
 from dbos import _serialization
 from dbos._conductor.conductor import ConductorWebsocket
-from dbos._utils import GlobalParams
+from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 from dbos._workflow_commands import (
     WorkflowStatus,
     list_queued_workflows,
@@ -234,6 +234,13 @@ class DBOSRegistry:
             hasher.update(source.encode("utf-8"))
         return hasher.hexdigest()
 
+    def get_internal_queue(self) -> Queue:
+        """
+        Get or create the internal queue used for the DBOS scheduler, for Kafka, and for
+        programmatic resuming and restarting of workflows.
+        """
+        return Queue(INTERNAL_QUEUE_NAME)
+
 
 class DBOS:
     """
@@ -489,6 +496,9 @@ class DBOS:
             notification_listener_thread.start()
             self._background_threads.append(notification_listener_thread)
 
+            # Create the internal queue if it has not yet been created
+            self._registry.get_internal_queue()
+
             # Start the queue thread
             evt = threading.Event()
             self.stop_events.append(evt)
@@ -929,11 +939,6 @@ class DBOS:
         """Execute a workflow by ID (for recovery)."""
         return execute_workflow_by_id(_get_dbos_instance(), workflow_id)
 
-    @classmethod
-    def restart_workflow(cls, workflow_id: str) -> None:
-        """Execute a workflow by ID (for recovery)."""
-        execute_workflow_by_id(_get_dbos_instance(), workflow_id, True)
-
     @classmethod
     def recover_pending_workflows(
         cls, executor_ids: List[str] = ["local"]
@@ -954,7 +959,13 @@ class DBOS:
         dbos_logger.info(f"Resuming workflow: {workflow_id}")
         _get_dbos_instance()._sys_db.resume_workflow(workflow_id)
         _get_or_create_dbos_registry().clear_workflow_cancelled(workflow_id)
-        return execute_workflow_by_id(_get_dbos_instance(), workflow_id, False)
+        return cls.retrieve_workflow(workflow_id)
+
+    @classmethod
+    def restart_workflow(cls, workflow_id: str) -> WorkflowHandle[Any]:
+        """Restart a workflow with a new workflow ID"""
+        forked_workflow_id = _get_dbos_instance()._sys_db.fork_workflow(workflow_id)
+        return cls.retrieve_workflow(forked_workflow_id)
 
     @classmethod
     def list_workflows(
@@ -1083,7 +1094,9 @@ class DBOS:
     def span(cls) -> Span:
         """Return the tracing `Span` associated with the current context."""
         ctx = assert_current_dbos_context()
-        return ctx.get_current_span()
+        span = ctx.get_current_span()
+        assert span
+        return span
 
     @classproperty
     def request(cls) -> Optional["Request"]:

dbos/_kafka.py

@@ -115,7 +115,7 @@ def kafka_consumer(
                 _in_order_kafka_queues[topic] = queue
         else:
             global _kafka_queue
-            _kafka_queue = Queue("_dbos_internal_queue")
+            _kafka_queue = dbosreg.get_internal_queue()
         stop_event = threading.Event()
         dbosreg.register_poller(
             stop_event, _kafka_consumer_loop, func, config, topics, stop_event, in_order

dbos/_queue.py

@@ -82,7 +82,8 @@ def queue_thread(stop_event: threading.Event, dbos: "DBOS") -> None:
     while not stop_event.is_set():
         if stop_event.wait(timeout=1):
             return
-        for _, queue in dbos._registry.queue_info_map.items():
+        queues = dict(dbos._registry.queue_info_map)
+        for _, queue in queues.items():
             try:
                 wf_ids = dbos._sys_db.start_queued_workflows(
                     queue, GlobalParams.executor_id, GlobalParams.app_version

dbos/_recovery.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 def _recover_workflow(
     dbos: "DBOS", workflow: GetPendingWorkflowsOutput
 ) -> "WorkflowHandle[Any]":
-    if workflow.queue_name and workflow.queue_name != "_dbos_internal_queue":
+    if workflow.queue_name:
         cleared = dbos._sys_db.clear_queue_assignment(workflow.workflow_uuid)
         if cleared:
             return dbos.retrieve_workflow(workflow.workflow_uuid)

dbos/_scheduler.py

@@ -52,7 +52,7 @@ def scheduled(
             )
 
         global scheduler_queue
-        scheduler_queue = Queue("_dbos_internal_queue")
+        scheduler_queue = dbosreg.get_internal_queue()
         stop_event = threading.Event()
         dbosreg.register_poller(stop_event, scheduler_loop, func, cron, stop_event)
         return func

dbos/_sys_db.py

@@ -4,6 +4,7 @@ import os
 import re
 import threading
 import time
+import uuid
 from enum import Enum
 from typing import (
     TYPE_CHECKING,
@@ -25,7 +26,7 @@ from alembic.config import Config
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.sql import func
 
-from dbos._utils import GlobalParams
+from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 
 from . import _serialization
 from ._context import get_local_dbos_context
@@ -447,13 +448,12 @@ class SystemDatabase:
                 )
             )
 
-    def resume_workflow(
-        self,
-        workflow_id: str,
-    ) -> None:
+    def resume_workflow(self, workflow_id: str) -> None:
         if self._debug_mode:
             raise Exception("called resume_workflow in debug mode")
         with self.engine.begin() as c:
+            # Execute with snapshot isolation in case of concurrent calls on the same workflow
+            c.execute(sa.text("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"))
             # Check the status of the workflow. If it is complete, do nothing.
             row = c.execute(
                 sa.select(
@@ -472,12 +472,63 @@ class SystemDatabase:
                     SystemSchema.workflow_queue.c.workflow_uuid == workflow_id
                 )
             )
-            # Set the workflow's status to PENDING and clear its recovery attempts.
+            # Enqueue the workflow on the internal queue
+            c.execute(
+                pg.insert(SystemSchema.workflow_queue).values(
+                    workflow_uuid=workflow_id,
+                    queue_name=INTERNAL_QUEUE_NAME,
+                )
+            )
+            # Set the workflow's status to ENQUEUED and clear its recovery attempts.
             c.execute(
                 sa.update(SystemSchema.workflow_status)
                 .where(SystemSchema.workflow_status.c.workflow_uuid == workflow_id)
-                .values(status=WorkflowStatusString.PENDING.value, recovery_attempts=0)
+                .values(status=WorkflowStatusString.ENQUEUED.value, recovery_attempts=0)
+            )
+
+    def fork_workflow(self, original_workflow_id: str) -> str:
+        status = self.get_workflow_status(original_workflow_id)
+        if status is None:
+            raise Exception(f"Workflow {original_workflow_id} not found")
+        inputs = self.get_workflow_inputs(original_workflow_id)
+        if inputs is None:
+            raise Exception(f"Workflow {original_workflow_id} not found")
+        # Generate a random ID for the forked workflow
+        forked_workflow_id = str(uuid.uuid4())
+        with self.engine.begin() as c:
+            # Create an entry for the forked workflow with the same
+            # initial values as the original.
+            c.execute(
+                pg.insert(SystemSchema.workflow_status).values(
+                    workflow_uuid=forked_workflow_id,
+                    status=WorkflowStatusString.ENQUEUED.value,
+                    name=status["name"],
+                    class_name=status["class_name"],
+                    config_name=status["config_name"],
+                    application_version=status["app_version"],
+                    application_id=status["app_id"],
+                    request=status["request"],
+                    authenticated_user=status["authenticated_user"],
+                    authenticated_roles=status["authenticated_roles"],
+                    assumed_role=status["assumed_role"],
+                    queue_name=INTERNAL_QUEUE_NAME,
+                )
+            )
+            # Copy the original workflow's inputs into the forked workflow
+            c.execute(
+                pg.insert(SystemSchema.workflow_inputs).values(
+                    workflow_uuid=forked_workflow_id,
+                    inputs=_serialization.serialize_args(inputs),
+                )
+            )
+            # Enqueue the forked workflow on the internal queue
+            c.execute(
+                pg.insert(SystemSchema.workflow_queue).values(
+                    workflow_uuid=forked_workflow_id,
+                    queue_name=INTERNAL_QUEUE_NAME,
+                )
             )
+        return forked_workflow_id
 
     def get_workflow_status(
         self, workflow_uuid: str

dbos/_utils.py

@@ -1,5 +1,7 @@
 import os
 
+INTERNAL_QUEUE_NAME = "_dbos_internal_queue"
+
 
 class GlobalParams:
     app_version: str = os.environ.get("DBOS__APPVERSION", "")

{dbos-0.26.0a1.dist-info → dbos-0.26.0a5.dist-info}/METADATA

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

{dbos-0.26.0a1.dist-info → dbos-0.26.0a5.dist-info}/RECORD

@@ -1,29 +1,29 @@
-dbos-0.26.0a1.dist-info/METADATA,sha256=ziHAfEpwbBK6AKLbucZsDQNvMbYjgdfP8b9dp-NJE-8,5553
-dbos-0.26.0a1.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-0.26.0a1.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.26.0a1.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-0.26.0a5.dist-info/METADATA,sha256=2Nl_CWZemlvRczy9jLMeUe2qFV0GhvI-gOcs_Ydgydk,5553
+dbos-0.26.0a5.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-0.26.0a5.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.26.0a5.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=FLUacm9WGIPjB5s3QhdpMCilc8JHJOF0KMNStF82qs0,6625
+dbos/_admin_server.py,sha256=vxPG_YJ6lYrkfPCSp42FiATVLBOij7Fm52Yngg5Z_tE,7027
 dbos/_app_db.py,sha256=R3sbh--84A4i-dTz8IXYmxO4b4s5VSwiPQvi_le52mg,6109
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=XKjR0a3JA9Xfo9VJx48EcdyiVDaA10FvI7Y_I1v27Ng,7384
+dbos/_client.py,sha256=fzW_Gagh-oyWyDYtREcQDBesoVl_LsEoMeJAsn5-C5s,7262
 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=7elKINsgl4s1Tg5DwrU-K7xQ5vQvmDAIfAvUgfwpGN0,16784
 dbos/_conductor/protocol.py,sha256=xN7pmooyF1pqbH1b6WhllU5718P7zSb_b0KCwA6bzcs,6716
-dbos/_context.py,sha256=3He4w46OTFbR7h8U1MLcdaU10wNyIPBSRqzLkdggv7U,19368
-dbos/_core.py,sha256=kIj_4wlIff8ptlACJKXAPSNoyJIt2h44swjMKxfwv0k,45789
+dbos/_context.py,sha256=I8sLkdKTTkZEz7wG-MjynaQB6XEF2bLXuwNksiauP7w,19430
+dbos/_core.py,sha256=9PM2LZcaMhqF628wMGEOLmZadqwo_ViuM6-1j36Qd6k,45645
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
 dbos/_db_wizard.py,sha256=VnMa6OL87Lc-XPDD1RnXp8NjsJE8YgiQLj3wtWAXp-8,8252
-dbos/_dbos.py,sha256=AKfB61vvz5shPoEpKxqrqoiDemintKMqyBxhESRRJE8,45231
+dbos/_dbos.py,sha256=9oZFA9ZbpMO76sPAa59xhTPik6ZaAEumhKZ7t9s44w0,45726
 dbos/_dbos_config.py,sha256=rTn30Hgh-RzTxqHbnYh2pC3Ioo30eJV9K4YxhJd-Gj4,22718
 dbos/_debug.py,sha256=mmgvLkqlrljMBBow9wk01PPur9kUf2rI_11dTJXY4gw,1822
 dbos/_error.py,sha256=B6Y9XLS1f6yrawxB2uAEYFMxFwk9BHhdxPNddKco-Fw,5399
 dbos/_fastapi.py,sha256=PhaKftbApHnjtYEOw0EYna_3K0cmz__J9of7mRJWzu4,3704
 dbos/_flask.py,sha256=DZKUZR5-xOzPI7tYZ53r2PvvHVoAb8SYwLzMVFsVfjI,2608
-dbos/_kafka.py,sha256=o6DbwnsYRDtvVTZVsN7BAK8cdP79AfoWX3Q7CGY2Yuo,4199
+dbos/_kafka.py,sha256=pz0xZ9F3X9Ky1k-VSbeF3tfPhP3UPr3lUUhUfE41__U,4198
 dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
 dbos/_logger.py,sha256=qv2srteCF2rSRjCK1VGOck3ieIkwUe9Lvbv60mJc16E,4069
 dbos/_migrations/env.py,sha256=38SIGVbmn_VV2x2u1aHLcPOoWgZ84eCymf3g_NljmbU,1626
@@ -37,17 +37,17 @@ dbos/_migrations/versions/d76646551a6c_workflow_queue.py,sha256=G942nophZ2uC2vc4
 dbos/_migrations/versions/eab0cc1d9a14_job_queue.py,sha256=uvhFOtqbBreCePhAxZfIT0qCAI7BiZTou9wt6QnbY7c,1412
 dbos/_migrations/versions/f4b9b32ba814_functionname_childid_op_outputs.py,sha256=m90Lc5YH0ZISSq1MyxND6oq3RZrZKrIqEsZtwJ1jWxA,1049
 dbos/_outcome.py,sha256=EXxBg4jXCVJsByDQ1VOCIedmbeq_03S6d-p1vqQrLFU,6810
-dbos/_queue.py,sha256=HqeybpS7kujs9laM-n0j7LWcJdwMl9okqm2hNSrUab8,3367
-dbos/_recovery.py,sha256=4KyZb0XJEUGH7ekYT1kpx38i6y5vygPeH75Ta7RZjYo,2596
+dbos/_queue.py,sha256=l0g_CXJbxEmftCA9yhy-cyaR_sddfQSCfm-5XgIWzqU,3397
+dbos/_recovery.py,sha256=98Py7icfytyIELJ54gIsdvmURBvTb0HmWaxEAuYL0dc,2546
 dbos/_registrations.py,sha256=_zy6k944Ll8QwqU12Kr3OP23ukVtm8axPNN1TS_kJRc,6717
 dbos/_request.py,sha256=cX1B3Atlh160phgS35gF1VEEV4pD126c9F3BDgBmxZU,929
 dbos/_roles.py,sha256=iOsgmIAf1XVzxs3gYWdGRe1B880YfOw5fpU7Jwx8_A8,2271
-dbos/_scheduler.py,sha256=boG4BdcncFa3WxR97T5Oou4ppR0TgrEa2QQkjzpFEHU,2028
+dbos/_scheduler.py,sha256=SR1oRZRcVzYsj-JauV2LA8JtwTkt8mru7qf6H1AzQ1U,2027
 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=fEkJbIzavLX-7K_TFnJe8ST58cpWShpBIarhEVXu6Po,62816
+dbos/_sys_db.py,sha256=VBYVyKqZrwlFbDJ5cFIkeS5WtDOKpkI3lWJbSd5rB2s,65362
 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
@@ -59,7 +59,7 @@ dbos/_templates/dbos-db-starter/migrations/script.py.mako,sha256=MEqL-2qATlST9TA
 dbos/_templates/dbos-db-starter/migrations/versions/2024_07_31_180642_init.py,sha256=MpS7LGaJS0CpvsjhfDkp9EJqvMvVCjRPfUp4c0aE2ys,941
 dbos/_templates/dbos-db-starter/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
 dbos/_tracer.py,sha256=dFDSFlta-rfA3-ahIRLYwnnoAOmlavdxAGllqwFgnCA,2440
-dbos/_utils.py,sha256=wjOJzxN66IzL9p4dwcEmQACRQah_V09G6mJI2exQfOM,155
+dbos/_utils.py,sha256=nFRUHzVjXG5AusF85AlYHikj63Tzi-kQm992ihsrAxA,201
 dbos/_workflow_commands.py,sha256=SYp2khc9RSf6tjllG9CqT1zjBQnFTFq33ePXpvmRwME,5892
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=-WW3kbq0W_Tq4WbMqb1UGJG3xvJb3woEY5VspG95Srk,2857
@@ -67,4 +67,4 @@ dbos/cli/cli.py,sha256=G55sZJxfmvUGvWr0hoIWwVZBy-fJdpCsTsZmuHT1CjA,16049
 dbos/dbos-config.schema.json,sha256=4z2OXPfp7H0uNT1m5dKxjg31qbAfPyKkFXwHufuUMec,5910
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-0.26.0a1.dist-info/RECORD,,
+dbos-0.26.0a5.dist-info/RECORD,,