dbos 1.10.0a2__py3-none-any.whl → 1.11.0a2__py3-none-any.whl

dbos/_app_db.py

@@ -74,10 +74,19 @@ class ApplicationDatabase:
 
         # Create the dbos schema and transaction_outputs table in the application database
         with self.engine.begin() as conn:
-            schema_creation_query = sa.text(
-                f"CREATE SCHEMA IF NOT EXISTS {ApplicationSchema.schema}"
-            )
-            conn.execute(schema_creation_query)
+            # Check if schema exists first
+            schema_exists = conn.execute(
+                sa.text(
+                    "SELECT 1 FROM information_schema.schemata WHERE schema_name = :schema_name"
+                ),
+                parameters={"schema_name": ApplicationSchema.schema},
+            ).scalar()
+
+            if not schema_exists:
+                schema_creation_query = sa.text(
+                    f"CREATE SCHEMA {ApplicationSchema.schema}"
+                )
+                conn.execute(schema_creation_query)
 
         inspector = inspect(self.engine)
         if not inspector.has_table(

dbos/_client.py

@@ -1,7 +1,18 @@
 import asyncio
 import sys
+import time
 import uuid
-from typing import Any, Generic, List, Optional, TypedDict, TypeVar, Union
+from typing import (
+    Any,
+    AsyncGenerator,
+    Generator,
+    Generic,
+    List,
+    Optional,
+    TypedDict,
+    TypeVar,
+    Union,
+)
 
 from dbos._app_db import ApplicationDatabase
 from dbos._context import MaxPriority, MinPriority
@@ -24,6 +35,8 @@ from dbos._sys_db import (
     WorkflowStatus,
     WorkflowStatusInternal,
     WorkflowStatusString,
+    _dbos_stream_closed_sentinel,
+    workflow_is_active,
 )
 from dbos._workflow_commands import (
     fork_workflow,
@@ -449,3 +462,71 @@ class DBOSClient:
             application_version=application_version,
         )
         return WorkflowHandleClientAsyncPolling[Any](forked_workflow_id, self._sys_db)
+
+    def read_stream(self, workflow_id: str, key: str) -> Generator[Any, Any, None]:
+        """
+        Read values from a stream as a generator.
+        This function reads values from a stream identified by the workflow_id and key,
+        yielding each value in order until the stream is closed or the workflow terminates.
+
+        Args:
+            workflow_id: The ID of the workflow that wrote to the stream
+            key: The stream key to read from
+
+        Yields:
+            The values written to the stream in order
+        """
+        offset = 0
+        while True:
+            try:
+                value = self._sys_db.read_stream(workflow_id, key, offset)
+                if value == _dbos_stream_closed_sentinel:
+                    break
+                yield value
+                offset += 1
+            except ValueError:
+                # Poll the offset until a value arrives or the workflow terminates
+                status = get_workflow(self._sys_db, workflow_id)
+                if status is None:
+                    break
+                if not workflow_is_active(status.status):
+                    break
+                time.sleep(1.0)
+                continue
+
+    async def read_stream_async(
+        self, workflow_id: str, key: str
+    ) -> AsyncGenerator[Any, None]:
+        """
+        Read values from a stream as an async generator.
+        This function reads values from a stream identified by the workflow_id and key,
+        yielding each value in order until the stream is closed or the workflow terminates.
+
+        Args:
+            workflow_id: The ID of the workflow that wrote to the stream
+            key: The stream key to read from
+
+        Yields:
+            The values written to the stream in order
+        """
+        offset = 0
+        while True:
+            try:
+                value = await asyncio.to_thread(
+                    self._sys_db.read_stream, workflow_id, key, offset
+                )
+                if value == _dbos_stream_closed_sentinel:
+                    break
+                yield value
+                offset += 1
+            except ValueError:
+                # Poll the offset until a value arrives or the workflow terminates
+                status = await asyncio.to_thread(
+                    get_workflow, self._sys_db, workflow_id
+                )
+                if status is None:
+                    break
+                if not workflow_is_active(status.status):
+                    break
+                await asyncio.sleep(1.0)
+                continue

dbos/_dbos.py

@@ -6,14 +6,17 @@ import inspect
 import os
 import sys
 import threading
+import time
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 from logging import Logger
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncGenerator,
     Callable,
     Coroutine,
+    Generator,
     Generic,
     List,
     Literal,
@@ -62,7 +65,14 @@ from ._registrations import (
 )
 from ._roles import default_required_roles, required_roles
 from ._scheduler import ScheduledWorkflow, scheduled
-from ._sys_db import StepInfo, SystemDatabase, WorkflowStatus, reset_system_database
+from ._sys_db import (
+    StepInfo,
+    SystemDatabase,
+    WorkflowStatus,
+    _dbos_stream_closed_sentinel,
+    reset_system_database,
+    workflow_is_active,
+)
 from ._tracer import DBOSTracer, dbos_tracer
 
 if TYPE_CHECKING:
@@ -1304,6 +1314,171 @@ class DBOS:
         ctx.authenticated_user = authenticated_user
         ctx.authenticated_roles = authenticated_roles
 
+    @classmethod
+    def write_stream(cls, key: str, value: Any) -> None:
+        """
+        Write a value to a stream.
+
+        Args:
+            key(str): The stream key / name within the workflow
+            value(Any): A serializable value to write to the stream
+
+        """
+        ctx = get_local_dbos_context()
+        if ctx is not None:
+            # Must call it within a workflow
+            if ctx.is_workflow():
+                attributes: TracedAttributes = {
+                    "name": "write_stream",
+                }
+                with EnterDBOSStep(attributes):
+                    ctx = assert_current_dbos_context()
+                    _get_dbos_instance()._sys_db.write_stream_from_workflow(
+                        ctx.workflow_id, ctx.function_id, key, value
+                    )
+            elif ctx.is_step():
+                _get_dbos_instance()._sys_db.write_stream_from_step(
+                    ctx.workflow_id, key, value
+                )
+            else:
+                raise DBOSException(
+                    "write_stream() must be called from within a workflow or step"
+                )
+        else:
+            # Cannot call it from outside of a workflow
+            raise DBOSException(
+                "write_stream() must be called from within a workflow or step"
+            )
+
+    @classmethod
+    def close_stream(cls, key: str) -> None:
+        """
+        Close a stream.
+
+        Args:
+            key(str): The stream key / name within the workflow
+
+        """
+        ctx = get_local_dbos_context()
+        if ctx is not None:
+            # Must call it within a workflow
+            if ctx.is_workflow():
+                attributes: TracedAttributes = {
+                    "name": "close_stream",
+                }
+                with EnterDBOSStep(attributes):
+                    ctx = assert_current_dbos_context()
+                    _get_dbos_instance()._sys_db.close_stream(
+                        ctx.workflow_id, ctx.function_id, key
+                    )
+            else:
+                raise DBOSException(
+                    "close_stream() must be called from within a workflow"
+                )
+        else:
+            # Cannot call it from outside of a workflow
+            raise DBOSException("close_stream() must be called from within a workflow")
+
+    @classmethod
+    def read_stream(cls, workflow_id: str, key: str) -> Generator[Any, Any, None]:
+        """
+        Read values from a stream as a generator.
+
+        This function reads values from a stream identified by the workflow_id and key,
+        yielding each value in order until the stream is closed or the workflow terminates.
+
+        Args:
+            workflow_id(str): The workflow instance ID that owns the stream
+            key(str): The stream key / name within the workflow
+
+        Yields:
+            Any: Each value in the stream until the stream is closed
+
+        """
+        offset = 0
+        sys_db = _get_dbos_instance()._sys_db
+
+        while True:
+            try:
+                value = sys_db.read_stream(workflow_id, key, offset)
+                if value == _dbos_stream_closed_sentinel:
+                    break
+                yield value
+                offset += 1
+            except ValueError:
+                # Poll the offset until a value arrives or the workflow terminates
+                status = cls.retrieve_workflow(workflow_id).get_status().status
+                if not workflow_is_active(status):
+                    break
+                time.sleep(1.0)
+                continue
+
+    @classmethod
+    async def write_stream_async(cls, key: str, value: Any) -> None:
+        """
+        Write a value to a stream asynchronously.
+
+        Args:
+            key(str): The stream key / name within the workflow
+            value(Any): A serializable value to write to the stream
+
+        """
+        await cls._configure_asyncio_thread_pool()
+        await asyncio.to_thread(lambda: DBOS.write_stream(key, value))
+
+    @classmethod
+    async def close_stream_async(cls, key: str) -> None:
+        """
+        Close a stream asynchronously.
+
+        Args:
+            key(str): The stream key / name within the workflow
+
+        """
+        await cls._configure_asyncio_thread_pool()
+        await asyncio.to_thread(lambda: DBOS.close_stream(key))
+
+    @classmethod
+    async def read_stream_async(
+        cls, workflow_id: str, key: str
+    ) -> AsyncGenerator[Any, None]:
+        """
+        Read values from a stream as an async generator.
+
+        This function reads values from a stream identified by the workflow_id and key,
+        yielding each value in order until the stream is closed or the workflow terminates.
+
+        Args:
+            workflow_id(str): The workflow instance ID that owns the stream
+            key(str): The stream key / name within the workflow
+
+        Yields:
+            Any: Each value in the stream until the stream is closed
+
+        """
+        await cls._configure_asyncio_thread_pool()
+        offset = 0
+        sys_db = _get_dbos_instance()._sys_db
+
+        while True:
+            try:
+                value = await asyncio.to_thread(
+                    sys_db.read_stream, workflow_id, key, offset
+                )
+                if value == _dbos_stream_closed_sentinel:
+                    break
+                yield value
+                offset += 1
+            except ValueError:
+                # Poll the offset until a value arrives or the workflow terminates
+                status = (
+                    await (await cls.retrieve_workflow_async(workflow_id)).get_status()
+                ).status
+                if not workflow_is_active(status):
+                    break
+                await asyncio.sleep(1.0)
+                continue
+
     @classproperty
     def tracer(self) -> DBOSTracer:
         """Return the DBOS OpenTelemetry tracer."""

dbos/_migrations/versions/01ce9f07bd10_streaming.py

@@ -0,0 +1,42 @@
+"""streaming
+
+Revision ID: 01ce9f07bd10
+Revises: d994145b47b6
+Create Date: 2025-08-05 10:20:46.424975
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "01ce9f07bd10"
+down_revision: Union[str, None] = "d994145b47b6"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Create streams table
+    op.create_table(
+        "streams",
+        sa.Column("workflow_uuid", sa.Text(), nullable=False),
+        sa.Column("key", sa.Text(), nullable=False),
+        sa.Column("value", sa.Text(), nullable=False),
+        sa.Column("offset", sa.Integer(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["workflow_uuid"],
+            ["dbos.workflow_status.workflow_uuid"],
+            onupdate="CASCADE",
+            ondelete="CASCADE",
+        ),
+        sa.PrimaryKeyConstraint("workflow_uuid", "key", "offset"),
+        schema="dbos",
+    )
+
+
+def downgrade() -> None:
+    # Drop streams table
+    op.drop_table("streams", schema="dbos")

dbos/_schemas/system_database.py

@@ -132,3 +132,20 @@ class SystemSchema:
         Column("value", Text, nullable=False),
         PrimaryKeyConstraint("workflow_uuid", "key"),
     )
+
+    streams = Table(
+        "streams",
+        metadata_obj,
+        Column(
+            "workflow_uuid",
+            Text,
+            ForeignKey(
+                "workflow_status.workflow_uuid", onupdate="CASCADE", ondelete="CASCADE"
+            ),
+            nullable=False,
+        ),
+        Column("key", Text, nullable=False),
+        Column("value", Text, nullable=False),
+        Column("offset", Integer, nullable=False),
+        PrimaryKeyConstraint("workflow_uuid", "key", "offset"),
+    )

dbos/_sys_db.py

@@ -62,6 +62,13 @@ class WorkflowStatusString(Enum):
     ENQUEUED = "ENQUEUED"
 
 
+def workflow_is_active(status: str) -> bool:
+    return (
+        status == WorkflowStatusString.ENQUEUED.value
+        or status == WorkflowStatusString.PENDING.value
+    )
+
+
 WorkflowStatuses = Literal[
     "PENDING",
     "SUCCESS",
@@ -243,6 +250,7 @@ class StepInfo(TypedDict):
 
 
 _dbos_null_topic = "__null__topic__"
+_dbos_stream_closed_sentinel = "__DBOS_STREAM_CLOSED__"
 
 
 class ConditionCount(TypedDict):
@@ -1882,6 +1890,127 @@ class SystemDatabase:
             dbos_logger.error(f"Error connecting to the DBOS system database: {e}")
             raise
 
+    def write_stream_from_step(self, workflow_uuid: str, key: str, value: Any) -> None:
+        """
+        Write a key-value pair to the stream at the first unused offset.
+        """
+        if self._debug_mode:
+            raise Exception("called write_stream in debug mode")
+
+        with self.engine.begin() as c:
+            # Find the maximum offset for this workflow_uuid and key combination
+            max_offset_result = c.execute(
+                sa.select(sa.func.max(SystemSchema.streams.c.offset)).where(
+                    SystemSchema.streams.c.workflow_uuid == workflow_uuid,
+                    SystemSchema.streams.c.key == key,
+                )
+            ).fetchone()
+
+            # Next offset is max + 1, or 0 if no records exist
+            next_offset = (
+                (max_offset_result[0] + 1)
+                if max_offset_result is not None and max_offset_result[0] is not None
+                else 0
+            )
+
+            # Serialize the value before storing
+            serialized_value = _serialization.serialize(value)
+
+            # Insert the new stream entry
+            c.execute(
+                sa.insert(SystemSchema.streams).values(
+                    workflow_uuid=workflow_uuid,
+                    key=key,
+                    value=serialized_value,
+                    offset=next_offset,
+                )
+            )
+
+    @db_retry()
+    def write_stream_from_workflow(
+        self, workflow_uuid: str, function_id: int, key: str, value: Any
+    ) -> None:
+        """
+        Write a key-value pair to the stream at the first unused offset.
+        """
+        function_name = (
+            "DBOS.closeStream"
+            if value == _dbos_stream_closed_sentinel
+            else "DBOS.writeStream"
+        )
+
+        with self.engine.begin() as c:
+
+            recorded_output = self._check_operation_execution_txn(
+                workflow_uuid, function_id, function_name, conn=c
+            )
+            if self._debug_mode and recorded_output is None:
+                raise Exception(
+                    "called set_event in debug mode without a previous execution"
+                )
+            # Find the maximum offset for this workflow_uuid and key combination
+            max_offset_result = c.execute(
+                sa.select(sa.func.max(SystemSchema.streams.c.offset)).where(
+                    SystemSchema.streams.c.workflow_uuid == workflow_uuid,
+                    SystemSchema.streams.c.key == key,
+                )
+            ).fetchone()
+
+            # Next offset is max + 1, or 0 if no records exist
+            next_offset = (
+                (max_offset_result[0] + 1)
+                if max_offset_result is not None and max_offset_result[0] is not None
+                else 0
+            )
+
+            # Serialize the value before storing
+            serialized_value = _serialization.serialize(value)
+
+            # Insert the new stream entry
+            c.execute(
+                sa.insert(SystemSchema.streams).values(
+                    workflow_uuid=workflow_uuid,
+                    key=key,
+                    value=serialized_value,
+                    offset=next_offset,
+                )
+            )
+            output: OperationResultInternal = {
+                "workflow_uuid": workflow_uuid,
+                "function_id": function_id,
+                "function_name": function_name,
+                "output": None,
+                "error": None,
+            }
+            self._record_operation_result_txn(output, conn=c)
+
+    def close_stream(self, workflow_uuid: str, function_id: int, key: str) -> None:
+        """Write a sentinel value to the stream at the first unused offset to mark it as closed."""
+        self.write_stream_from_workflow(
+            workflow_uuid, function_id, key, _dbos_stream_closed_sentinel
+        )
+
+    @db_retry()
+    def read_stream(self, workflow_uuid: str, key: str, offset: int) -> Any:
+        """Read the value at the specified offset for the given workflow_uuid and key."""
+
+        with self.engine.begin() as c:
+            result = c.execute(
+                sa.select(SystemSchema.streams.c.value).where(
+                    SystemSchema.streams.c.workflow_uuid == workflow_uuid,
+                    SystemSchema.streams.c.key == key,
+                    SystemSchema.streams.c.offset == offset,
+                )
+            ).fetchone()
+
+            if result is None:
+                raise ValueError(
+                    f"No value found for workflow_uuid={workflow_uuid}, key={key}, offset={offset}"
+                )
+
+            # Deserialize the value before returning
+            return _serialization.deserialize(result[0])
+
     def garbage_collect(
         self, cutoff_epoch_timestamp_ms: Optional[int], rows_threshold: Optional[int]
     ) -> Optional[tuple[int, list[str]]]:

dbos/cli/cli.py

@@ -15,6 +15,7 @@ from rich.prompt import IntPrompt
 from typing_extensions import Annotated, List
 
 from dbos._debug import debug_workflow, parse_start_command
+from dbos.cli.migration import grant_dbos_schema_permissions, migrate_dbos_databases
 
 from .._app_db import ApplicationDatabase
 from .._client import DBOSClient
@@ -278,6 +279,14 @@ def migrate(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    application_role: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--app-role",
+            "-r",
+            help="The role with which you will run your DBOS application",
+        ),
+    ] = None,
 ) -> None:
     app_database_url = _get_db_url(app_database_url)
     system_database_url = get_system_database_url(
@@ -293,37 +302,18 @@ def migrate(
     typer.echo(f"System database: {sa.make_url(system_database_url)}")
 
     # First, run DBOS migrations on the system database and the application database
-    app_db = None
-    sys_db = None
-    try:
-        sys_db = SystemDatabase(
-            system_database_url=system_database_url,
-            engine_kwargs={
-                "pool_timeout": 30,
-                "max_overflow": 0,
-                "pool_size": 2,
-            },
+    migrate_dbos_databases(
+        app_database_url=app_database_url, system_database_url=system_database_url
+    )
+
+    # Next, assign permissions on the DBOS schema to the application role, if any
+    if application_role:
+        grant_dbos_schema_permissions(
+            database_url=app_database_url, role_name=application_role
         )
-        app_db = ApplicationDatabase(
-            database_url=app_database_url,
-            engine_kwargs={
-                "pool_timeout": 30,
-                "max_overflow": 0,
-                "pool_size": 2,
-            },
+        grant_dbos_schema_permissions(
+            database_url=system_database_url, role_name=application_role
         )
-        sys_db.run_migrations()
-        app_db.run_migrations()
-    except Exception as e:
-        typer.echo(f"DBOS migrations failed: {e}")
-        raise typer.Exit(code=1)
-    finally:
-        if sys_db:
-            sys_db.destroy()
-        if app_db:
-            app_db.destroy()
-
-    typer.echo(f"DBOS migrations successful")
 
     # Next, run any custom migration commands specified in the configuration
     if os.path.exists("dbos-config.yaml"):

dbos/cli/migration.py

@@ -0,0 +1,91 @@
+import sqlalchemy as sa
+import typer
+
+from dbos._app_db import ApplicationDatabase
+from dbos._sys_db import SystemDatabase
+
+
+def migrate_dbos_databases(app_database_url: str, system_database_url: str) -> None:
+    app_db = None
+    sys_db = None
+    try:
+        sys_db = SystemDatabase(
+            system_database_url=system_database_url,
+            engine_kwargs={
+                "pool_timeout": 30,
+                "max_overflow": 0,
+                "pool_size": 2,
+            },
+        )
+        app_db = ApplicationDatabase(
+            database_url=app_database_url,
+            engine_kwargs={
+                "pool_timeout": 30,
+                "max_overflow": 0,
+                "pool_size": 2,
+            },
+        )
+        sys_db.run_migrations()
+        app_db.run_migrations()
+    except Exception as e:
+        typer.echo(f"DBOS migrations failed: {e}")
+        raise typer.Exit(code=1)
+    finally:
+        if sys_db:
+            sys_db.destroy()
+        if app_db:
+            app_db.destroy()
+
+
+def grant_dbos_schema_permissions(database_url: str, role_name: str) -> None:
+    """
+    Grant all permissions on all entities in the dbos schema to the specified role.
+    """
+    typer.echo(
+        f"Granting permissions for DBOS schema to {role_name} in database {sa.make_url(database_url)}"
+    )
+    engine = None
+    try:
+        engine = sa.create_engine(database_url)
+        with engine.connect() as connection:
+            connection.execution_options(isolation_level="AUTOCOMMIT")
+
+            # Grant usage on the dbos schema
+            sql = f"GRANT USAGE ON SCHEMA dbos TO {role_name}"
+            typer.echo(sql)
+            connection.execute(sa.text(sql))
+
+            # Grant all privileges on all existing tables in dbos schema (includes views)
+            sql = f"GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA dbos TO {role_name}"
+            typer.echo(sql)
+            connection.execute(sa.text(sql))
+
+            # Grant all privileges on all sequences in dbos schema
+            sql = f"GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA dbos TO {role_name}"
+            typer.echo(sql)
+            connection.execute(sa.text(sql))
+
+            # Grant execute on all functions and procedures in dbos schema
+            sql = f"GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA dbos TO {role_name}"
+            typer.echo(sql)
+            connection.execute(sa.text(sql))
+
+            # Grant default privileges for future objects in dbos schema
+            sql = f"ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT ALL ON TABLES TO {role_name}"
+            typer.echo(sql)
+            connection.execute(sa.text(sql))
+
+            sql = f"ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT ALL ON SEQUENCES TO {role_name}"
+            typer.echo(sql)
+            connection.execute(sa.text(sql))
+
+            sql = f"ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT EXECUTE ON FUNCTIONS TO {role_name}"
+            typer.echo(sql)
+            connection.execute(sa.text(sql))
+
+    except Exception as e:
+        typer.echo(f"Failed to grant permissions to role {role_name}: {e}")
+        raise typer.Exit(code=1)
+    finally:
+        if engine:
+            engine.dispose()

{dbos-1.10.0a2.dist-info → dbos-1.11.0a2.dist-info}/METADATA

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

{dbos-1.10.0a2.dist-info → dbos-1.11.0a2.dist-info}/RECORD

@@ -1,19 +1,19 @@
-dbos-1.10.0a2.dist-info/METADATA,sha256=ywrX1FOObxV8Hf1VcJzBEhSe9Kfte-J3CdetTHIufhE,13268
-dbos-1.10.0a2.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-dbos-1.10.0a2.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-1.10.0a2.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-1.11.0a2.dist-info/METADATA,sha256=jTYKGbbzmSgXEsQVMTTRai4_6dj_Sf-eMxSNXQScVa4,13268
+dbos-1.11.0a2.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+dbos-1.11.0a2.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-1.11.0a2.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=NssPCubaBxdiKarOWa-wViz1hdJSkmBGcpLX_gQ4NeA,891
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=e8ELhcDWqR3_PNobnNgUvLGh5lzZq0yFSF6dvtzoQRI,16267
-dbos/_app_db.py,sha256=htblDPfqrpb_uZoFcvaud7cgQ-PDyn6Bn-cBidxdCTA,10603
+dbos/_app_db.py,sha256=bUXQqzc0C9PHh4Zl2tHfBrQWNBURdI7F7XXjCpYirmw,10959
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=6ReC_VF1JhscxtMjmjwJH_X7HV0L9Zoj_OiYhs4el40,15517
+dbos/_client.py,sha256=_wMe4qnRSwiRZo74xdqTBetbHlIVy3vQifdSd7os1ZY,18213
 dbos/_conductor/conductor.py,sha256=3E_hL3c9g9yWqKZkvI6KA0-ZzPMPRo06TOzT1esMiek,24114
 dbos/_conductor/protocol.py,sha256=q3rgLxINFtWFigdOONc-4gX4vn66UmMlJQD6Kj8LnL4,7420
 dbos/_context.py,sha256=0vFtLAk3WF5BQYIYNFImDRBppKO2CTKOSy51zQC-Cu8,25723
 dbos/_core.py,sha256=TA-UOSO_BhvM6L6j4__dwesK7x5Y93dk6mV1xx0WZBY,49593
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=0CDsUKvqfoX6i2Q74khU1hvJVpfy2tcGpQIDtEtWCAM,51469
+dbos/_dbos.py,sha256=h0ZtJNElMB4R2T1320jYD3PXKenn-xCLxnSkIiqpFVg,57386
 dbos/_dbos_config.py,sha256=er8oF3e9zGlEG9KntX7uBSXrDuVvROtkzVidzXjOwUU,21746
 dbos/_debug.py,sha256=99j2SChWmCPAlZoDmjsJGe77tpU2LEa8E2TtLAnnh7o,1831
 dbos/_docker_pg_helper.py,sha256=tLJXWqZ4S-ExcaPnxg_i6cVxL6ZxrYlZjaGsklY-s2I,6115
@@ -26,6 +26,7 @@ dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
 dbos/_logger.py,sha256=Dp6bHZKUtcm5gWwYHj_HA5Wj5OMuJGUrpl2g2i4xDZg,4620
 dbos/_migrations/env.py,sha256=38SIGVbmn_VV2x2u1aHLcPOoWgZ84eCymf3g_NljmbU,1626
 dbos/_migrations/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
+dbos/_migrations/versions/01ce9f07bd10_streaming.py,sha256=5F2tCCXbjP3ZrRFVBwJdaf4FHLlWuhQkMQiYmypfSNM,1123
 dbos/_migrations/versions/04ca4f231047_workflow_queues_executor_id.py,sha256=ICLPl8CN9tQXMsLDsAj8z1TsL831-Z3F8jSBvrR-wyw,736
 dbos/_migrations/versions/27ac6900c6ad_add_queue_dedup.py,sha256=56w1v6TdofW3V18iwm0MP0SAeSaAUPSS40HIcn6qYIE,1072
 dbos/_migrations/versions/50f3227f0b4b_fix_job_queue.py,sha256=ZBYrtTdxy64HxIAlOes89fVIk2P1gNaJack7wuC_epg,873
@@ -47,9 +48,9 @@ dbos/_roles.py,sha256=kCuhhg8XLtrHCgKgm44I0abIRTGHltf88OwjEKAUggk,2317
 dbos/_scheduler.py,sha256=CWeGVfl9h51VXfxt80y5Da_5pE8SPty_AYkfpJkkMxQ,2117
 dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
-dbos/_schemas/system_database.py,sha256=rbFKggONdvvbb45InvGz0TM6a7c-Ux9dcaL-h_7Z7pU,4438
+dbos/_schemas/system_database.py,sha256=-dAKk-_Y3vzbpLT4ei-sIrBQgFyQiwPj1enZb1TYc8I,4943
 dbos/_serialization.py,sha256=bWuwhXSQcGmiazvhJHA5gwhrRWxtmFmcCFQSDJnqqkU,3666
-dbos/_sys_db.py,sha256=0GAWwxxelTxukYHQIwLr9JOlwy0vENkxbyGcfnv8_Ko,81321
+dbos/_sys_db.py,sha256=MWSrGeCUMgctOMxJ3SViswVzC9URUMy7COdI7vRSLv8,86256
 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.dbos,sha256=aQnBPSSQpkB8ERfhf7gB7P9tsU6OPKhZscfeh0yiaD8,2702
@@ -65,8 +66,9 @@ dbos/_utils.py,sha256=uywq1QrjMwy17btjxW4bES49povlQwYwYbvKwMT6C2U,1575
 dbos/_workflow_commands.py,sha256=EmmAaQfRWeOZm_WPTznuU-O3he3jiSzzT9VpYrhxugE,4835
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=7JBcpMqP1r2mfCnvWatu33z8ctEGHJarlZYKgB83cXE,2972
-dbos/cli/cli.py,sha256=BaWqdMZbUsJkq0zEaS2Ez2FgRgD5nTD24hCsrAlitbA,22289
+dbos/cli/cli.py,sha256=ey7E-lNFgvUWhsd-mkFwZvTdYorv6hU2zsMOS23n1yQ,22214
+dbos/cli/migration.py,sha256=M65qa5ao1rmZnGtnRpg8wlbZH_aGiWBhAvwgG97jde4,3198
 dbos/dbos-config.schema.json,sha256=CjaspeYmOkx6Ip_pcxtmfXJTn_YGdSx_0pcPBF7KZmo,6060
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-1.10.0a2.dist-info/RECORD,,
+dbos-1.11.0a2.dist-info/RECORD,,