dbos 0.25.0a14__py3-none-any.whl → 0.26.0a0__py3-none-any.whl

dbos/__init__.py

@@ -1,4 +1,5 @@
 from . import _error as error
+from ._client import DBOSClient, EnqueueOptions
 from ._context import DBOSContextEnsure, DBOSContextSetAuth, SetWorkflowID
 from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle
 from ._dbos_config import ConfigFile, DBOSConfig, get_dbos_database_url, load_config
@@ -11,9 +12,11 @@ __all__ = [
     "ConfigFile",
     "DBOSConfig",
     "DBOS",
+    "DBOSClient",
     "DBOSConfiguredInstance",
     "DBOSContextEnsure",
     "DBOSContextSetAuth",
+    "EnqueueOptions",
     "GetWorkflowsInput",
     "KafkaMessage",
     "SetWorkflowID",

dbos/_app_db.py

@@ -27,19 +27,18 @@ class RecordedResult(TypedDict):
 
 class ApplicationDatabase:
 
-    def __init__(self, config: ConfigFile, *, debug_mode: bool = False):
-        self.config = config
+    def __init__(self, database: DatabaseConfig, *, debug_mode: bool = False):
 
-        app_db_name = config["database"]["app_db_name"]
+        app_db_name = database["app_db_name"]
 
         # If the application database does not already exist, create it
         if not debug_mode:
             postgres_db_url = sa.URL.create(
                 "postgresql+psycopg",
-                username=config["database"]["username"],
-                password=config["database"]["password"],
-                host=config["database"]["hostname"],
-                port=config["database"]["port"],
+                username=database["username"],
+                password=database["password"],
+                host=database["hostname"],
+                port=database["port"],
                 database="postgres",
             )
             postgres_db_engine = sa.create_engine(postgres_db_url)
@@ -55,25 +54,25 @@ class ApplicationDatabase:
         # Create a connection pool for the application database
         app_db_url = sa.URL.create(
             "postgresql+psycopg",
-            username=config["database"]["username"],
-            password=config["database"]["password"],
-            host=config["database"]["hostname"],
-            port=config["database"]["port"],
+            username=database["username"],
+            password=database["password"],
+            host=database["hostname"],
+            port=database["port"],
             database=app_db_name,
         )
 
         connect_args = {}
         if (
-            "connectionTimeoutMillis" in config["database"]
-            and config["database"]["connectionTimeoutMillis"]
+            "connectionTimeoutMillis" in database
+            and database["connectionTimeoutMillis"]
         ):
             connect_args["connect_timeout"] = int(
-                config["database"]["connectionTimeoutMillis"] / 1000
+                database["connectionTimeoutMillis"] / 1000
             )
 
         self.engine = sa.create_engine(
             app_db_url,
-            pool_size=config["database"]["app_db_pool_size"],
+            pool_size=database["app_db_pool_size"],
             max_overflow=0,
             pool_timeout=30,
             connect_args=connect_args,

dbos/_client.py

@@ -0,0 +1,206 @@
+import asyncio
+import sys
+import uuid
+from typing import Any, Generic, Optional, TypedDict, TypeVar
+
+if sys.version_info < (3, 11):
+    from typing_extensions import NotRequired
+else:
+    from typing import NotRequired
+
+from dbos import _serialization
+from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
+from dbos._dbos_config import parse_database_url_to_dbconfig
+from dbos._error import DBOSNonExistentWorkflowError
+from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
+from dbos._serialization import WorkflowInputs
+from dbos._sys_db import SystemDatabase, WorkflowStatusInternal, WorkflowStatusString
+from dbos._workflow_commands import WorkflowStatus, get_workflow
+
+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]
+
+
+class WorkflowHandleClientPolling(Generic[R]):
+
+    def __init__(self, workflow_id: str, sys_db: SystemDatabase):
+        self.workflow_id = workflow_id
+        self._sys_db = sys_db
+
+    def get_workflow_id(self) -> str:
+        return self.workflow_id
+
+    def get_result(self) -> R:
+        res: R = self._sys_db.await_workflow_result(self.workflow_id)
+        return res
+
+    def get_status(self) -> "WorkflowStatus":
+        status = get_workflow(self._sys_db, self.workflow_id, True)
+        if status is None:
+            raise DBOSNonExistentWorkflowError(self.workflow_id)
+        return status
+
+
+class WorkflowHandleClientAsyncPolling(Generic[R]):
+
+    def __init__(self, workflow_id: str, sys_db: SystemDatabase):
+        self.workflow_id = workflow_id
+        self._sys_db = sys_db
+
+    def get_workflow_id(self) -> str:
+        return self.workflow_id
+
+    async def get_result(self) -> R:
+        res: R = await asyncio.to_thread(
+            self._sys_db.await_workflow_result, self.workflow_id
+        )
+        return res
+
+    async def get_status(self) -> "WorkflowStatus":
+        status = await asyncio.to_thread(
+            get_workflow, self._sys_db, self.workflow_id, True
+        )
+        if status is None:
+            raise DBOSNonExistentWorkflowError(self.workflow_id)
+        return status
+
+
+class DBOSClient:
+    def __init__(self, database_url: str, *, system_database: Optional[str] = None):
+        db_config = parse_database_url_to_dbconfig(database_url)
+        if system_database is not None:
+            db_config["sys_db_name"] = system_database
+        self._sys_db = SystemDatabase(db_config)
+
+    def destroy(self) -> None:
+        self._sys_db.destroy()
+
+    def _enqueue(self, options: EnqueueOptions, *args: Any, **kwargs: Any) -> str:
+        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:
+            max_recovery_attempts = DEFAULT_MAX_RECOVERY_ATTEMPTS
+        workflow_id = options.get("workflow_id")
+        if workflow_id is None:
+            workflow_id = str(uuid.uuid4())
+
+        status: WorkflowStatusInternal = {
+            "workflow_uuid": workflow_id,
+            "status": WorkflowStatusString.ENQUEUED.value,
+            "name": workflow_name,
+            "class_name": workflow_class_name,
+            "queue_name": queue_name,
+            "app_version": app_version,
+            "config_name": None,
+            "authenticated_user": None,
+            "assumed_role": None,
+            "authenticated_roles": None,
+            "request": None,
+            "output": None,
+            "error": None,
+            "created_at": None,
+            "updated_at": None,
+            "executor_id": None,
+            "recovery_attempts": None,
+            "app_id": None,
+        }
+
+        inputs: WorkflowInputs = {
+            "args": args,
+            "kwargs": kwargs,
+        }
+
+        wf_status = self._sys_db.insert_workflow_status(status)
+        self._sys_db.update_workflow_inputs(
+            workflow_id, _serialization.serialize_args(inputs)
+        )
+        if wf_status == WorkflowStatusString.ENQUEUED.value:
+            self._sys_db.enqueue(workflow_id, queue_name)
+        return workflow_id
+
+    def enqueue(
+        self, options: EnqueueOptions, *args: Any, **kwargs: Any
+    ) -> WorkflowHandle[R]:
+        workflow_id = self._enqueue(options, *args, **kwargs)
+        return WorkflowHandleClientPolling[R](workflow_id, self._sys_db)
+
+    async def enqueue_async(
+        self, options: EnqueueOptions, *args: Any, **kwargs: Any
+    ) -> WorkflowHandleAsync[R]:
+        workflow_id = await asyncio.to_thread(self._enqueue, options, *args, **kwargs)
+        return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
+
+    def retrieve_workflow(self, workflow_id: str) -> WorkflowHandle[R]:
+        status = get_workflow(self._sys_db, workflow_id, True)
+        if status is None:
+            raise DBOSNonExistentWorkflowError(workflow_id)
+        return WorkflowHandleClientPolling[R](workflow_id, self._sys_db)
+
+    async def retrieve_workflow_async(self, workflow_id: str) -> WorkflowHandleAsync[R]:
+        status = asyncio.to_thread(get_workflow, self._sys_db, workflow_id, True)
+        if status is None:
+            raise DBOSNonExistentWorkflowError(workflow_id)
+        return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
+
+    def send(
+        self,
+        destination_id: str,
+        message: Any,
+        topic: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> None:
+        idempotency_key = idempotency_key if idempotency_key else str(uuid.uuid4())
+        status: WorkflowStatusInternal = {
+            "workflow_uuid": f"{destination_id}-{idempotency_key}",
+            "status": WorkflowStatusString.SUCCESS.value,
+            "name": "temp_workflow-send-client",
+            "class_name": None,
+            "queue_name": None,
+            "config_name": None,
+            "authenticated_user": None,
+            "assumed_role": None,
+            "authenticated_roles": None,
+            "request": None,
+            "output": None,
+            "error": None,
+            "created_at": None,
+            "updated_at": None,
+            "executor_id": None,
+            "recovery_attempts": None,
+            "app_id": None,
+            "app_version": None,
+        }
+        self._sys_db.insert_workflow_status(status)
+        self._sys_db.send(status["workflow_uuid"], 0, destination_id, message, topic)
+
+    async def send_async(
+        self,
+        destination_id: str,
+        message: Any,
+        topic: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> None:
+        return await asyncio.to_thread(
+            self.send, destination_id, message, topic, idempotency_key
+        )
+
+    def get_event(self, workflow_id: str, key: str, timeout_seconds: float = 60) -> Any:
+        return self._sys_db.get_event(workflow_id, key, timeout_seconds)
+
+    async def get_event_async(
+        self, workflow_id: str, key: str, timeout_seconds: float = 60
+    ) -> Any:
+        return await asyncio.to_thread(
+            self.get_event, workflow_id, key, timeout_seconds
+        )

dbos/_dbos.py

@@ -445,8 +445,12 @@ 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._sys_db_field = SystemDatabase(self.config, debug_mode=debug_mode)
-            self._app_db_field = ApplicationDatabase(self.config, debug_mode=debug_mode)
+            self._sys_db_field = SystemDatabase(
+                self.config["database"], debug_mode=debug_mode
+            )
+            self._app_db_field = ApplicationDatabase(
+                self.config["database"], debug_mode=debug_mode
+            )
 
             if debug_mode:
                 return

dbos/_logger.py

@@ -7,6 +7,7 @@ from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 from opentelemetry.sdk.resources import Resource
+from opentelemetry.trace.span import format_trace_id
 
 from dbos._utils import GlobalParams
 
@@ -26,6 +27,19 @@ class DBOSLogTransformer(logging.Filter):
         record.applicationID = self.app_id
         record.applicationVersion = GlobalParams.app_version
         record.executorID = GlobalParams.executor_id
+
+        # If available, decorate the log entry with Workflow ID and Trace ID
+        from dbos._context import get_local_dbos_context
+
+        ctx = get_local_dbos_context()
+        if ctx:
+            if ctx.is_within_workflow():
+                record.operationUUID = ctx.workflow_id
+            span = ctx.get_current_span()
+            if span:
+                trace_id = format_trace_id(span.get_span_context().trace_id)
+                record.traceId = trace_id
+
         return True
 
 

dbos/_queue.py

@@ -85,7 +85,7 @@ def queue_thread(stop_event: threading.Event, dbos: "DBOS") -> None:
         for _, queue in dbos._registry.queue_info_map.items():
             try:
                 wf_ids = dbos._sys_db.start_queued_workflows(
-                    queue, GlobalParams.executor_id
+                    queue, GlobalParams.executor_id, GlobalParams.app_version
                 )
                 for id in wf_ids:
                     execute_workflow_by_id(dbos, id)

dbos/_sys_db.py

@@ -29,7 +29,7 @@ from dbos._utils import GlobalParams
 
 from . import _serialization
 from ._context import get_local_dbos_context
-from ._dbos_config import ConfigFile
+from ._dbos_config import ConfigFile, DatabaseConfig
 from ._error import (
     DBOSConflictingWorkflowError,
     DBOSDeadLetterQueueError,
@@ -170,23 +170,21 @@ _dbos_null_topic = "__null__topic__"
 
 class SystemDatabase:
 
-    def __init__(self, config: ConfigFile, *, debug_mode: bool = False):
-        self.config = config
-
+    def __init__(self, database: DatabaseConfig, *, debug_mode: bool = False):
         sysdb_name = (
-            config["database"]["sys_db_name"]
-            if "sys_db_name" in config["database"] and config["database"]["sys_db_name"]
-            else config["database"]["app_db_name"] + SystemSchema.sysdb_suffix
+            database["sys_db_name"]
+            if "sys_db_name" in database and database["sys_db_name"]
+            else database["app_db_name"] + SystemSchema.sysdb_suffix
         )
 
         if not debug_mode:
             # If the system database does not already exist, create it
             postgres_db_url = sa.URL.create(
                 "postgresql+psycopg",
-                username=config["database"]["username"],
-                password=config["database"]["password"],
-                host=config["database"]["hostname"],
-                port=config["database"]["port"],
+                username=database["username"],
+                password=database["password"],
+                host=database["hostname"],
+                port=database["port"],
                 database="postgres",
                 # fills the "application_name" column in pg_stat_activity
                 query={"application_name": f"dbos_transact_{GlobalParams.executor_id}"},
@@ -203,19 +201,23 @@ class SystemDatabase:
 
         system_db_url = sa.URL.create(
             "postgresql+psycopg",
-            username=config["database"]["username"],
-            password=config["database"]["password"],
-            host=config["database"]["hostname"],
-            port=config["database"]["port"],
+            username=database["username"],
+            password=database["password"],
+            host=database["hostname"],
+            port=database["port"],
             database=sysdb_name,
             # fills the "application_name" column in pg_stat_activity
             query={"application_name": f"dbos_transact_{GlobalParams.executor_id}"},
         )
 
         # Create a connection pool for the system database
+        pool_size = database.get("sys_db_pool_size")
+        if pool_size is None:
+            pool_size = 20
+
         self.engine = sa.create_engine(
             system_db_url,
-            pool_size=config["database"]["sys_db_pool_size"],
+            pool_size=pool_size,
             max_overflow=0,
             pool_timeout=30,
             connect_args={"connect_timeout": 10},
@@ -1264,7 +1266,9 @@ class SystemDatabase:
                 .on_conflict_do_nothing()
             )
 
-    def start_queued_workflows(self, queue: "Queue", executor_id: str) -> List[str]:
+    def start_queued_workflows(
+        self, queue: "Queue", executor_id: str, app_version: str
+    ) -> List[str]:
         if self._debug_mode:
             return []
 
@@ -1379,26 +1383,36 @@ class SystemDatabase:
                         break
 
                 # To start a function, first set its status to PENDING and update its executor ID
-                c.execute(
+                res = c.execute(
                     SystemSchema.workflow_status.update()
                     .where(SystemSchema.workflow_status.c.workflow_uuid == id)
                     .where(
                         SystemSchema.workflow_status.c.status
                         == WorkflowStatusString.ENQUEUED.value
                     )
+                    .where(
+                        sa.or_(
+                            SystemSchema.workflow_status.c.application_version
+                            == app_version,
+                            SystemSchema.workflow_status.c.application_version.is_(
+                                None
+                            ),
+                        )
+                    )
                     .values(
                         status=WorkflowStatusString.PENDING.value,
+                        application_version=app_version,
                         executor_id=executor_id,
                     )
                 )
-
-                # Then give it a start time and assign the executor ID
-                c.execute(
-                    SystemSchema.workflow_queue.update()
-                    .where(SystemSchema.workflow_queue.c.workflow_uuid == id)
-                    .values(started_at_epoch_ms=start_time_ms)
-                )
-                ret_ids.append(id)
+                if res.rowcount > 0:
+                    # Then give it a start time and assign the executor ID
+                    c.execute(
+                        SystemSchema.workflow_queue.update()
+                        .where(SystemSchema.workflow_queue.c.workflow_uuid == id)
+                        .values(started_at_epoch_ms=start_time_ms)
+                    )
+                    ret_ids.append(id)
 
             # If we have a limiter, garbage-collect all completed functions started
             # before the period. If there's no limiter, there's no need--they were

dbos/cli/cli.py

@@ -189,8 +189,8 @@ def migrate() -> None:
     app_db = None
     sys_db = None
     try:
-        sys_db = SystemDatabase(config)
-        app_db = ApplicationDatabase(config)
+        sys_db = SystemDatabase(config["database"])
+        app_db = ApplicationDatabase(config["database"])
     except Exception as e:
         typer.echo(f"DBOS system schema migration failed: {e}")
     finally:
@@ -314,7 +314,7 @@ def list(
     ] = False,
 ) -> None:
     config = load_config(silent=True)
-    sys_db = SystemDatabase(config)
+    sys_db = SystemDatabase(config["database"])
     workflows = list_workflows(
         sys_db,
         limit=limit,
@@ -338,7 +338,7 @@ def get(
     ] = False,
 ) -> None:
     config = load_config(silent=True)
-    sys_db = SystemDatabase(config)
+    sys_db = SystemDatabase(config["database"])
     print(
         jsonpickle.encode(get_workflow(sys_db, workflow_id, request), unpicklable=False)
     )
@@ -349,7 +349,7 @@ def steps(
     workflow_id: Annotated[str, typer.Argument()],
 ) -> None:
     config = load_config(silent=True)
-    sys_db = SystemDatabase(config)
+    sys_db = SystemDatabase(config["database"])
     print(
         jsonpickle.encode(list_workflow_steps(sys_db, workflow_id), unpicklable=False)
     )
@@ -475,7 +475,7 @@ def list_queue(
     ] = False,
 ) -> None:
     config = load_config(silent=True)
-    sys_db = SystemDatabase(config)
+    sys_db = SystemDatabase(config["database"])
     workflows = list_queued_workflows(
         sys_db=sys_db,
         limit=limit,

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

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

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

@@ -1,12 +1,13 @@
-dbos-0.25.0a14.dist-info/METADATA,sha256=47yo_N6VbWT0oM9z9vavQ9nIVGLzzerDaIJXqeAyI_Q,5554
-dbos-0.25.0a14.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-dbos-0.25.0a14.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-0.25.0a14.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
-dbos/__init__.py,sha256=2Ur8QyNElSVn7CeL9Ovek2Zsye8A_ZCyjb9djF-N4A4,785
+dbos-0.26.0a0.dist-info/METADATA,sha256=duid-oSnv_Stb3_Cb8EpTRZujzf6HfLkVSaCNKLHH_s,5553
+dbos-0.26.0a0.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-0.26.0a0.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-0.26.0a0.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/_app_db.py,sha256=4EGrYL14rVx96TXn34hoibN9ltf4-2DKcj6nd-HvBxA,6262
+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/_cloudutils/authentication.py,sha256=V0fCWQN9stCkhbuuxgPTGpvuQcDqfU3KAxPAh01vKW4,5007
 dbos/_cloudutils/cloudutils.py,sha256=YC7jGsIopT0KveLsqbRpQk2KlRBk-nIRC_UCgep4f3o,7797
 dbos/_cloudutils/databases.py,sha256=_shqaqSvhY4n2ScgQ8IP5PDZvzvcx3YBKV8fj-cxhSY,8543
@@ -16,7 +17,7 @@ dbos/_context.py,sha256=3He4w46OTFbR7h8U1MLcdaU10wNyIPBSRqzLkdggv7U,19368
 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=IZ3Qj8UBUqYYJiG6HVz35A0GQnQyI1Po_-E6DDvWlQg,45147
+dbos/_dbos.py,sha256=AKfB61vvz5shPoEpKxqrqoiDemintKMqyBxhESRRJE8,45231
 dbos/_dbos_config.py,sha256=7Qm3FARP3lTKZS0gSxDHLbpaDCT30GzfyERxfCde4bc,21566
 dbos/_debug.py,sha256=mmgvLkqlrljMBBow9wk01PPur9kUf2rI_11dTJXY4gw,1822
 dbos/_error.py,sha256=B6Y9XLS1f6yrawxB2uAEYFMxFwk9BHhdxPNddKco-Fw,5399
@@ -24,7 +25,7 @@ dbos/_fastapi.py,sha256=PhaKftbApHnjtYEOw0EYna_3K0cmz__J9of7mRJWzu4,3704
 dbos/_flask.py,sha256=DZKUZR5-xOzPI7tYZ53r2PvvHVoAb8SYwLzMVFsVfjI,2608
 dbos/_kafka.py,sha256=o6DbwnsYRDtvVTZVsN7BAK8cdP79AfoWX3Q7CGY2Yuo,4199
 dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
-dbos/_logger.py,sha256=pSP-CyzHUR6ypousTaeKe2zYMKSqvrbsFru8HJpBHsA,3546
+dbos/_logger.py,sha256=qv2srteCF2rSRjCK1VGOck3ieIkwUe9Lvbv60mJc16E,4069
 dbos/_migrations/env.py,sha256=38SIGVbmn_VV2x2u1aHLcPOoWgZ84eCymf3g_NljmbU,1626
 dbos/_migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
 dbos/_migrations/versions/04ca4f231047_workflow_queues_executor_id.py,sha256=ICLPl8CN9tQXMsLDsAj8z1TsL831-Z3F8jSBvrR-wyw,736
@@ -36,7 +37,7 @@ 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=yYwKCjxCSFjtD63vpnRQmb835BZAe9UATgWjMW6dcnY,3341
+dbos/_queue.py,sha256=HqeybpS7kujs9laM-n0j7LWcJdwMl9okqm2hNSrUab8,3367
 dbos/_recovery.py,sha256=4KyZb0XJEUGH7ekYT1kpx38i6y5vygPeH75Ta7RZjYo,2596
 dbos/_registrations.py,sha256=_zy6k944Ll8QwqU12Kr3OP23ukVtm8axPNN1TS_kJRc,6717
 dbos/_request.py,sha256=cX1B3Atlh160phgS35gF1VEEV4pD126c9F3BDgBmxZU,929
@@ -46,7 +47,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=33euvXfpbpVaCpR0Sx5eQ4yBt1gRKGdvfGQUugqoJBY,62320
+dbos/_sys_db.py,sha256=fEkJbIzavLX-7K_TFnJe8ST58cpWShpBIarhEVXu6Po,62816
 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
@@ -62,8 +63,8 @@ dbos/_utils.py,sha256=wjOJzxN66IzL9p4dwcEmQACRQah_V09G6mJI2exQfOM,155
 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
-dbos/cli/cli.py,sha256=ut47q-R6A423je0zvBTEgwdxENagaKKoyIvyTeACFIU,15977
+dbos/cli/cli.py,sha256=G55sZJxfmvUGvWr0hoIWwVZBy-fJdpCsTsZmuHT1CjA,16049
 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.0a14.dist-info/RECORD,,
+dbos-0.26.0a0.dist-info/RECORD,,

{dbos-0.25.0a14.dist-info → dbos-0.26.0a0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.3)
+Generator: pdm-backend (2.4.4)
 Root-Is-Purelib: true
 Tag: py3-none-any