dbos 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

dbos/_app_db.py

@@ -8,6 +8,7 @@ from sqlalchemy.orm import Session, sessionmaker
 
 from . import _serialization
 from ._error import DBOSUnexpectedStepError, DBOSWorkflowConflictIDError
+from ._logger import dbos_logger
 from ._schemas.application_database import ApplicationSchema
 from ._sys_db import StepInfo
 
@@ -39,21 +40,6 @@ class ApplicationDatabase:
     ):
         app_db_url = sa.make_url(database_url).set(drivername="postgresql+psycopg")
 
-        # If the application database does not already exist, create it
-        if not debug_mode:
-            postgres_db_engine = sa.create_engine(
-                app_db_url.set(database="postgres"),
-                **engine_kwargs,
-            )
-            with postgres_db_engine.connect() as conn:
-                conn.execution_options(isolation_level="AUTOCOMMIT")
-                if not conn.execute(
-                    sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
-                    parameters={"db_name": app_db_url.database},
-                ).scalar():
-                    conn.execute(sa.text(f"CREATE DATABASE {app_db_url.database}"))
-            postgres_db_engine.dispose()
-
         if engine_kwargs is None:
             engine_kwargs = {}
 
@@ -61,40 +47,61 @@ class ApplicationDatabase:
             app_db_url,
             **engine_kwargs,
         )
+        self._engine_kwargs = engine_kwargs
         self.sessionmaker = sessionmaker(bind=self.engine)
         self.debug_mode = debug_mode
 
+    def run_migrations(self) -> None:
+        if self.debug_mode:
+            dbos_logger.warning(
+                "Application database migrations are skipped in debug mode."
+            )
+            return
+        # Check if the database exists
+        app_db_url = self.engine.url
+        postgres_db_engine = sa.create_engine(
+            app_db_url.set(database="postgres"),
+            **self._engine_kwargs,
+        )
+        with postgres_db_engine.connect() as conn:
+            conn.execution_options(isolation_level="AUTOCOMMIT")
+            if not conn.execute(
+                sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
+                parameters={"db_name": app_db_url.database},
+            ).scalar():
+                conn.execute(sa.text(f"CREATE DATABASE {app_db_url.database}"))
+        postgres_db_engine.dispose()
+
         # Create the dbos schema and transaction_outputs table in the application database
-        if not debug_mode:
-            with self.engine.begin() as conn:
-                schema_creation_query = sa.text(
-                    f"CREATE SCHEMA IF NOT EXISTS {ApplicationSchema.schema}"
-                )
-                conn.execute(schema_creation_query)
+        with self.engine.begin() as conn:
+            schema_creation_query = sa.text(
+                f"CREATE SCHEMA IF NOT EXISTS {ApplicationSchema.schema}"
+            )
+            conn.execute(schema_creation_query)
 
-            inspector = inspect(self.engine)
-            if not inspector.has_table(
+        inspector = inspect(self.engine)
+        if not inspector.has_table(
+            "transaction_outputs", schema=ApplicationSchema.schema
+        ):
+            ApplicationSchema.metadata_obj.create_all(self.engine)
+        else:
+            columns = inspector.get_columns(
                 "transaction_outputs", schema=ApplicationSchema.schema
-            ):
-                ApplicationSchema.metadata_obj.create_all(self.engine)
-            else:
-                columns = inspector.get_columns(
-                    "transaction_outputs", schema=ApplicationSchema.schema
-                )
-                column_names = [col["name"] for col in columns]
+            )
+            column_names = [col["name"] for col in columns]
 
-                if "function_name" not in column_names:
-                    # Column missing, alter table to add it
-                    with self.engine.connect() as conn:
-                        conn.execute(
-                            text(
-                                f"""
-                            ALTER TABLE {ApplicationSchema.schema}.transaction_outputs
-                            ADD COLUMN function_name TEXT NOT NULL DEFAULT '';
-                            """
-                            )
+            if "function_name" not in column_names:
+                # Column missing, alter table to add it
+                with self.engine.connect() as conn:
+                    conn.execute(
+                        text(
+                            f"""
+                        ALTER TABLE {ApplicationSchema.schema}.transaction_outputs
+                        ADD COLUMN function_name TEXT NOT NULL DEFAULT '';
+                        """
                         )
-                        conn.commit()
+                    )
+                    conn.commit()
 
     def destroy(self) -> None:
         self.engine.dispose()

dbos/_client.py

@@ -99,6 +99,7 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
 
 class DBOSClient:
     def __init__(self, database_url: str, *, system_database: Optional[str] = None):
+        # We only create database connections but do not run migrations
         self._sys_db = SystemDatabase(
             database_url=database_url,
             engine_kwargs={

dbos/_context.py

@@ -392,6 +392,7 @@ class SetWorkflowTimeout:
             else None
         )
         self.saved_workflow_timeout: Optional[int] = None
+        self.saved_workflow_deadline_epoch_ms: Optional[int] = None
 
     def __enter__(self) -> SetWorkflowTimeout:
         # Code to create a basic context
@@ -402,6 +403,8 @@ class SetWorkflowTimeout:
         ctx = assert_current_dbos_context()
         self.saved_workflow_timeout = ctx.workflow_timeout_ms
         ctx.workflow_timeout_ms = self.workflow_timeout_ms
+        self.saved_workflow_deadline_epoch_ms = ctx.workflow_deadline_epoch_ms
+        ctx.workflow_deadline_epoch_ms = None
         return self
 
     def __exit__(
@@ -411,6 +414,9 @@ class SetWorkflowTimeout:
         traceback: Optional[TracebackType],
     ) -> Literal[False]:
         assert_current_dbos_context().workflow_timeout_ms = self.saved_workflow_timeout
+        assert_current_dbos_context().workflow_deadline_epoch_ms = (
+            self.saved_workflow_deadline_epoch_ms
+        )
         # Code to clean up the basic context if we created it
         if self.created_ctx:
             _clear_local_dbos_context()

dbos/_dbos.py

@@ -433,6 +433,10 @@ class DBOS:
             if debug_mode:
                 return
 
+            # Run migrations for the system and application databases
+            self._sys_db.run_migrations()
+            self._app_db.run_migrations()
+
             admin_port = self._config.get("runtimeConfig", {}).get("admin_port")
             if admin_port is None:
                 admin_port = 3001

dbos/_error.py

@@ -62,6 +62,7 @@ class DBOSErrorCode(Enum):
     WorkflowCancelled = 10
     UnexpectedStep = 11
     QueueDeduplicated = 12
+    AwaitedWorkflowCancelled = 13
     ConflictingRegistrationError = 25
 
 
@@ -206,6 +207,19 @@ class DBOSQueueDeduplicatedError(DBOSException):
         )
 
 
+class DBOSAwaitedWorkflowCancelledError(DBOSException):
+    def __init__(self, workflow_id: str):
+        self.workflow_id = workflow_id
+        super().__init__(
+            f"Awaited workflow {workflow_id} was cancelled",
+            dbos_error_code=DBOSErrorCode.AwaitedWorkflowCancelled.value,
+        )
+
+    def __reduce__(self) -> Any:
+        # Tell jsonpickle how to reconstruct this object
+        return (self.__class__, (self.workflow_id,))
+
+
 #######################################
 ## BaseException
 #######################################

dbos/_sys_db.py

@@ -32,6 +32,7 @@ from dbos._utils import INTERNAL_QUEUE_NAME
 from . import _serialization
 from ._context import get_local_dbos_context
 from ._error import (
+    DBOSAwaitedWorkflowCancelledError,
     DBOSConflictingWorkflowError,
     DBOSDeadLetterQueueError,
     DBOSNonExistentWorkflowError,
@@ -96,6 +97,10 @@ class WorkflowStatus:
     executor_id: Optional[str]
     # The application version on which this workflow was started
     app_version: Optional[str]
+    # The start-to-close timeout of the workflow in ms
+    workflow_timeout_ms: Optional[int]
+    # The deadline of a workflow, computed by adding its timeout to its start time.
+    workflow_deadline_epoch_ms: Optional[int]
 
     # INTERNAL FIELDS
 
@@ -222,6 +227,47 @@ class StepInfo(TypedDict):
 _dbos_null_topic = "__null__topic__"
 
 
+class ConditionCount(TypedDict):
+    condition: threading.Condition
+    count: int
+
+
+class ThreadSafeConditionDict:
+    def __init__(self) -> None:
+        self._dict: Dict[str, ConditionCount] = {}
+        self._lock = threading.Lock()
+
+    def get(self, key: str) -> Optional[threading.Condition]:
+        with self._lock:
+            if key not in self._dict:
+                # Key does not exist, return None
+                return None
+            return self._dict[key]["condition"]
+
+    def set(
+        self, key: str, value: threading.Condition
+    ) -> tuple[bool, threading.Condition]:
+        with self._lock:
+            if key in self._dict:
+                # Key already exists, do not overwrite. Increment the wait count.
+                cc = self._dict[key]
+                cc["count"] += 1
+                return False, cc["condition"]
+            self._dict[key] = ConditionCount(condition=value, count=1)
+            return True, value
+
+    def pop(self, key: str) -> None:
+        with self._lock:
+            if key in self._dict:
+                cc = self._dict[key]
+                cc["count"] -= 1
+                if cc["count"] == 0:
+                    # No more threads waiting on this condition, remove it
+                    del self._dict[key]
+            else:
+                dbos_logger.warning(f"Key {key} not found in condition dictionary.")
+
+
 class SystemDatabase:
 
     def __init__(
@@ -241,34 +287,63 @@ class SystemDatabase:
             sysdb_name = system_db_url.database + SystemSchema.sysdb_suffix
         system_db_url = system_db_url.set(database=sysdb_name)
 
-        if not debug_mode:
-            # If the system database does not already exist, create it
-            engine = sa.create_engine(
-                system_db_url.set(database="postgres"), **engine_kwargs
-            )
-            with engine.connect() as conn:
-                conn.execution_options(isolation_level="AUTOCOMMIT")
-                if not conn.execute(
-                    sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
-                    parameters={"db_name": sysdb_name},
-                ).scalar():
-                    dbos_logger.info(f"Creating system database {sysdb_name}")
-                    conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
-            engine.dispose()
-
         self.engine = sa.create_engine(
             system_db_url,
             **engine_kwargs,
         )
+        self._engine_kwargs = engine_kwargs
+
+        self.notification_conn: Optional[psycopg.connection.Connection] = None
+        self.notifications_map = ThreadSafeConditionDict()
+        self.workflow_events_map = ThreadSafeConditionDict()
+
+        # Now we can run background processes
+        self._run_background_processes = True
+        self._debug_mode = debug_mode
+
+    # Run migrations
+    def run_migrations(self) -> None:
+        if self._debug_mode:
+            dbos_logger.warning("System database migrations are skipped in debug mode.")
+            return
+        system_db_url = self.engine.url
+        sysdb_name = system_db_url.database
+        # If the system database does not already exist, create it
+        engine = sa.create_engine(
+            system_db_url.set(database="postgres"), **self._engine_kwargs
+        )
+        with engine.connect() as conn:
+            conn.execution_options(isolation_level="AUTOCOMMIT")
+            if not conn.execute(
+                sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
+                parameters={"db_name": sysdb_name},
+            ).scalar():
+                dbos_logger.info(f"Creating system database {sysdb_name}")
+                conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
+        engine.dispose()
 
         # Run a schema migration for the system database
-        if not debug_mode:
-            migration_dir = os.path.join(
-                os.path.dirname(os.path.realpath(__file__)), "_migrations"
+        migration_dir = os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), "_migrations"
+        )
+        alembic_cfg = Config()
+        alembic_cfg.set_main_option("script_location", migration_dir)
+        logging.getLogger("alembic").setLevel(logging.WARNING)
+        # Alembic requires the % in URL-escaped parameters to itself be escaped to %%.
+        escaped_conn_string = re.sub(
+            r"%(?=[0-9A-Fa-f]{2})",
+            "%%",
+            self.engine.url.render_as_string(hide_password=False),
+        )
+        alembic_cfg.set_main_option("sqlalchemy.url", escaped_conn_string)
+        try:
+            command.upgrade(alembic_cfg, "head")
+        except Exception as e:
+            dbos_logger.warning(
+                f"Exception during system database construction. This is most likely because the system database was configured using a later version of DBOS: {e}"
             )
             alembic_cfg = Config()
             alembic_cfg.set_main_option("script_location", migration_dir)
-            logging.getLogger("alembic").setLevel(logging.WARNING)
             # Alembic requires the % in URL-escaped parameters to itself be escaped to %%.
             escaped_conn_string = re.sub(
                 r"%(?=[0-9A-Fa-f]{2})",
@@ -282,29 +357,6 @@ class SystemDatabase:
                 dbos_logger.warning(
                     f"Exception during system database construction. This is most likely because the system database was configured using a later version of DBOS: {e}"
                 )
-                alembic_cfg = Config()
-                alembic_cfg.set_main_option("script_location", migration_dir)
-                # Alembic requires the % in URL-escaped parameters to itself be escaped to %%.
-                escaped_conn_string = re.sub(
-                    r"%(?=[0-9A-Fa-f]{2})",
-                    "%%",
-                    self.engine.url.render_as_string(hide_password=False),
-                )
-                alembic_cfg.set_main_option("sqlalchemy.url", escaped_conn_string)
-                try:
-                    command.upgrade(alembic_cfg, "head")
-                except Exception as e:
-                    dbos_logger.warning(
-                        f"Exception during system database construction. This is most likely because the system database was configured using a later version of DBOS: {e}"
-                    )
-
-        self.notification_conn: Optional[psycopg.connection.Connection] = None
-        self.notifications_map: Dict[str, threading.Condition] = {}
-        self.workflow_events_map: Dict[str, threading.Condition] = {}
-
-        # 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:
@@ -714,9 +766,9 @@ class SystemDatabase:
                         error = row[2]
                         raise _serialization.deserialize_exception(error)
                     elif status == WorkflowStatusString.CANCELLED.value:
-                        # Raise a normal exception here, not the cancellation exception
+                        # Raise AwaitedWorkflowCancelledError here, not the cancellation exception
                         # because the awaiting workflow is not being cancelled.
-                        raise Exception(f"Awaited workflow {workflow_id} was cancelled")
+                        raise DBOSAwaitedWorkflowCancelledError(workflow_id)
                 else:
                     pass  # CB: I guess we're assuming the WF will show up eventually.
             time.sleep(1)
@@ -790,6 +842,8 @@ class SystemDatabase:
             SystemSchema.workflow_inputs.c.inputs,
             SystemSchema.workflow_status.c.output,
             SystemSchema.workflow_status.c.error,
+            SystemSchema.workflow_status.c.workflow_deadline_epoch_ms,
+            SystemSchema.workflow_status.c.workflow_timeout_ms,
         ).join(
             SystemSchema.workflow_inputs,
             SystemSchema.workflow_status.c.workflow_uuid
@@ -871,6 +925,8 @@ class SystemDatabase:
             info.input = inputs
             info.output = output
             info.error = exception
+            info.workflow_deadline_epoch_ms = row[18]
+            info.workflow_timeout_ms = row[19]
 
             infos.append(info)
         return infos
@@ -900,6 +956,8 @@ class SystemDatabase:
             SystemSchema.workflow_inputs.c.inputs,
             SystemSchema.workflow_status.c.output,
             SystemSchema.workflow_status.c.error,
+            SystemSchema.workflow_status.c.workflow_deadline_epoch_ms,
+            SystemSchema.workflow_status.c.workflow_timeout_ms,
         ).select_from(
             SystemSchema.workflow_queue.join(
                 SystemSchema.workflow_status,
@@ -977,6 +1035,8 @@ class SystemDatabase:
             info.input = inputs
             info.output = output
             info.error = exception
+            info.workflow_deadline_epoch_ms = row[18]
+            info.workflow_timeout_ms = row[19]
 
             infos.append(info)
 
@@ -1282,7 +1342,12 @@ class SystemDatabase:
         condition = threading.Condition()
         # Must acquire first before adding to the map. Otherwise, the notification listener may notify it before the condition is acquired and waited.
         condition.acquire()
-        self.notifications_map[payload] = condition
+        success, _ = self.notifications_map.set(payload, condition)
+        if not success:
+            # This should not happen, but if it does, it means the workflow is executed concurrently.
+            condition.release()
+            self.notifications_map.pop(payload)
+            raise DBOSWorkflowConflictIDError(workflow_uuid)
 
         # Check if the key is already in the database. If not, wait for the notification.
         init_recv: Sequence[Any]
@@ -1375,11 +1440,11 @@ class SystemDatabase:
                             f"Received notification on channel: {channel}, payload: {notify.payload}"
                         )
                         if channel == "dbos_notifications_channel":
-                            if (
-                                notify.payload
-                                and notify.payload in self.notifications_map
-                            ):
-                                condition = self.notifications_map[notify.payload]
+                            if notify.payload:
+                                condition = self.notifications_map.get(notify.payload)
+                                if condition is None:
+                                    # No condition found for this payload
+                                    continue
                                 condition.acquire()
                                 condition.notify_all()
                                 condition.release()
@@ -1387,11 +1452,11 @@ class SystemDatabase:
                                     f"Signaled notifications condition for {notify.payload}"
                                 )
                         elif channel == "dbos_workflow_events_channel":
-                            if (
-                                notify.payload
-                                and notify.payload in self.workflow_events_map
-                            ):
-                                condition = self.workflow_events_map[notify.payload]
+                            if notify.payload:
+                                condition = self.workflow_events_map.get(notify.payload)
+                                if condition is None:
+                                    # No condition found for this payload
+                                    continue
                                 condition.acquire()
                                 condition.notify_all()
                                 condition.release()
@@ -1529,8 +1594,13 @@ class SystemDatabase:
 
         payload = f"{target_uuid}::{key}"
         condition = threading.Condition()
-        self.workflow_events_map[payload] = condition
         condition.acquire()
+        success, existing_condition = self.workflow_events_map.set(payload, condition)
+        if not success:
+            # Wait on the existing condition
+            condition.release()
+            condition = existing_condition
+            condition.acquire()
 
         # Check if the key is already in the database. If not, wait for the notification.
         init_recv: Sequence[Any]
@@ -1770,8 +1840,13 @@ class SystemDatabase:
                         # If a timeout is set, set the deadline on dequeue
                         workflow_deadline_epoch_ms=sa.case(
                             (
-                                SystemSchema.workflow_status.c.workflow_timeout_ms.isnot(
-                                    None
+                                sa.and_(
+                                    SystemSchema.workflow_status.c.workflow_timeout_ms.isnot(
+                                        None
+                                    ),
+                                    SystemSchema.workflow_status.c.workflow_deadline_epoch_ms.is_(
+                                        None
+                                    ),
                                 ),
                                 sa.func.extract("epoch", sa.func.now()) * 1000
                                 + SystemSchema.workflow_status.c.workflow_timeout_ms,

dbos/cli/cli.py

@@ -12,7 +12,7 @@ import sqlalchemy as sa
 import typer
 from rich import print
 from rich.prompt import IntPrompt
-from typing_extensions import Annotated
+from typing_extensions import Annotated, List
 
 from dbos._debug import debug_workflow, parse_start_command
 
@@ -147,55 +147,16 @@ def init(
     ] = False,
 ) -> None:
     try:
-
         git_templates = ["dbos-toolbox", "dbos-app-starter", "dbos-cron-starter"]
         templates_dir = get_templates_directory()
-        templates = git_templates + [
-            x.name for x in os.scandir(templates_dir) if x.is_dir()
-        ]
-
-        if config and template is None:
-            template = templates[-1]
 
-        if template:
-            if template not in templates:
-                raise Exception(f"Template {template} not found in {templates_dir}")
-        else:
-            print("\n[bold]Available templates:[/bold]")
-            for idx, template_name in enumerate(templates, 1):
-                print(f"  {idx}. {template_name}")
-            while True:
-                try:
-                    choice = IntPrompt.ask(
-                        "\nSelect template number",
-                        show_choices=False,
-                        show_default=False,
-                    )
-                    if 1 <= choice <= len(templates):
-                        template = templates[choice - 1]
-                        break
-                    else:
-                        print(
-                            "[red]Invalid selection. Please choose a number from the list.[/red]"
-                        )
-                except (KeyboardInterrupt, EOFError):
-                    raise typer.Abort()
-                except ValueError:
-                    print("[red]Please enter a valid number.[/red]")
-
-        if template in git_templates:
-            project_name = template
-        else:
-            if project_name is None:
-                project_name = typing.cast(
-                    str,
-                    typer.prompt("What is your project's name?", get_project_name()),
-                )
-
-        if not _is_valid_app_name(project_name):
-            raise Exception(
-                f"{project_name} is an invalid DBOS app name. App names must be between 3 and 30 characters long and contain only lowercase letters, numbers, dashes, and underscores."
-            )
+        project_name, template = _resolve_project_name_and_template(
+            project_name=project_name,
+            template=template,
+            config=config,
+            git_templates=git_templates,
+            templates_dir=templates_dir,
+        )
 
         if template in git_templates:
             create_template_from_github(app_name=project_name, template_name=template)
@@ -207,6 +168,67 @@ def init(
         print(f"[red]{e}[/red]")
 
 
+def _resolve_project_name_and_template(
+    project_name: Optional[str],
+    template: Optional[str],
+    config: bool,
+    git_templates: List[str],
+    templates_dir: str,
+) -> tuple[str, str]:
+    templates = git_templates + [
+        x.name for x in os.scandir(templates_dir) if x.is_dir()
+    ]
+
+    if config and template is None:
+        template = templates[-1]
+
+    if template:
+        if template not in templates:
+            raise Exception(f"Template {template} not found in {templates_dir}")
+    else:
+        print("\n[bold]Available templates:[/bold]")
+        for idx, template_name in enumerate(templates, 1):
+            print(f"  {idx}. {template_name}")
+        while True:
+            try:
+                choice = IntPrompt.ask(
+                    "\nSelect template number",
+                    show_choices=False,
+                    show_default=False,
+                )
+                if 1 <= choice <= len(templates):
+                    template = templates[choice - 1]
+                    break
+                else:
+                    print(
+                        "[red]Invalid selection. Please choose a number from the list.[/red]"
+                    )
+            except (KeyboardInterrupt, EOFError):
+                raise typer.Abort()
+            except ValueError:
+                print("[red]Please enter a valid number.[/red]")
+
+    if template in git_templates:
+        if project_name is None:
+            project_name = template
+    else:
+        if project_name is None:
+            project_name = typing.cast(
+                str,
+                typer.prompt("What is your project's name?", get_project_name()),
+            )
+
+    if not _is_valid_app_name(project_name):
+        raise Exception(
+            f"{project_name} is an invalid DBOS app name. App names must be between 3 and 30 characters long and contain only lowercase letters, numbers, dashes, and underscores."
+        )
+
+    assert project_name is not None, "Project name cannot be None"
+    assert template is not None, "Template name cannot be None"
+
+    return project_name, template
+
+
 @app.command(
     help="Run your database schema migrations using the migration commands in 'dbos-config.yaml'"
 )
@@ -258,6 +280,8 @@ def migrate(
                 "pool_size": 2,
             },
         )
+        sys_db.run_migrations()
+        app_db.run_migrations()
     except Exception as e:
         typer.echo(f"DBOS system schema migration failed: {e}")
     finally:

{dbos-1.0.0.dist-info → dbos-1.1.0.dist-info}/METADATA

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

{dbos-1.0.0.dist-info → dbos-1.1.0.dist-info}/RECORD

@@ -1,23 +1,23 @@
-dbos-1.0.0.dist-info/METADATA,sha256=NCphJidtQbDmGGSyBfu9NBmbcyTjKvNler7hEaMkM54,13265
-dbos-1.0.0.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dbos-1.0.0.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-1.0.0.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-1.1.0.dist-info/METADATA,sha256=jmrqILlNfqY1zumpckLQnd1HTmTvzjTDZH23TXXvMoU,13265
+dbos-1.1.0.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dbos-1.1.0.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-1.1.0.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=A_28_nJ1nBBYDmCxtklJR9O2v14JRMtD1rAo_D4y8Kc,9764
-dbos/_app_db.py,sha256=56jqU0oxcIkMscOg6DxC8dZ0uEJwG7iMu3aXYs2u66k,10428
+dbos/_app_db.py,sha256=wxZz3ja9QgVuyp5YLsAqa_MpuyD5tl0C5GHTLl8fwF0,10514
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=aPOAVWsH7uovSIsgJRamksra9y9-BVW1Jw4Gg5WjuZA,14114
+dbos/_client.py,sha256=-nK2GjS9D0qnD2DkRDs7gKxNECwYlsvW6hFCjADlnv0,14186
 dbos/_conductor/conductor.py,sha256=o0IaZjwnZ2TOyHeP2H4iSX6UnXLXQ4uODvWAKD9hHMs,21703
 dbos/_conductor/protocol.py,sha256=wgOFZxmS81bv0WCB9dAyg0s6QzldpzVKQDoSPeaX0Ws,6967
-dbos/_context.py,sha256=Ly1CXF1nWxICQgIpDZSaONGlz1yERBs63gqmR-yqCzM,24476
+dbos/_context.py,sha256=5ajoWAmToAfzzmMLylnJZoL4Ny9rBwZWuG05sXadMIA,24798
 dbos/_core.py,sha256=UDpSgRA9m_YuViNXR9tVgNFLC-zxKZPxjlkj2a-Kj00,48317
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=7fQPKfaePD3HwxSjBhziJcVd2heLKefe92skgmuHr34,46275
+dbos/_dbos.py,sha256=f5s9cVgsiMkAkpvctLHE6sjVAEuC-eFEpRddYBIKxiA,46430
 dbos/_dbos_config.py,sha256=IufNrIC-M2xSNTXyT_KXlEdfB3j03pPLv_nE0fEq4_U,20955
 dbos/_debug.py,sha256=MNlQVZ6TscGCRQeEEL0VE8Uignvr6dPeDDDefS3xgIE,1823
 dbos/_docker_pg_helper.py,sha256=tLJXWqZ4S-ExcaPnxg_i6cVxL6ZxrYlZjaGsklY-s2I,6115
-dbos/_error.py,sha256=EN4eVBjMT3k7O7hfqJl6mIf4sxWPsiAOM086yhcGH_g,8012
+dbos/_error.py,sha256=q0OQJZTbR8FFHV9hEpAGpz9oWBT5L509zUhmyff7FJw,8500
 dbos/_event_loop.py,sha256=NmaLbEQFfEK36S_0KhVD39YdYrGce3qSKCTJ-5RqKQ0,2136
 dbos/_fastapi.py,sha256=m4SL3H9P-NBQ_ZrbFxAWMOqNyIi3HGEn2ODR7xAK038,3118
 dbos/_flask.py,sha256=Npnakt-a3W5OykONFRkDRnumaDhTQmA0NPdUCGRYKXE,1652
@@ -47,7 +47,7 @@ dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
 dbos/_schemas/system_database.py,sha256=3Z0L72bOgHnusK1hBaETWU9RfiLBP0QnS-fdu41i0yY,5835
 dbos/_serialization.py,sha256=bWuwhXSQcGmiazvhJHA5gwhrRWxtmFmcCFQSDJnqqkU,3666
-dbos/_sys_db.py,sha256=qLc9A2igeNeRNvJwnEZhK720g0PWlx_zZmj1F8OyrRc,81223
+dbos/_sys_db.py,sha256=gVa5arMBT8rKHkycPS8HyRzfvQdQRxYqIclw0Fcp6CM,84240
 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
@@ -63,8 +63,8 @@ dbos/_utils.py,sha256=UbpMYRBSyvJqdXeWAnfSw8xXM1R1mfnyl1oTunhEjJM,513
 dbos/_workflow_commands.py,sha256=2E8FRUv_nLYkpBTwfhh_ELhySYpMrm8qGB9J44g6DSE,3872
 dbos/cli/_github_init.py,sha256=Y_bDF9gfO2jB1id4FV5h1oIxEJRWyqVjhb7bNEa5nQ0,3224
 dbos/cli/_template_init.py,sha256=7JBcpMqP1r2mfCnvWatu33z8ctEGHJarlZYKgB83cXE,2972
-dbos/cli/cli.py,sha256=YPXZyAD3GIh1cw_kBTAcJxUGO6OgBHWhjQLVe66AY8k,20143
+dbos/cli/cli.py,sha256=HinoCGrAUTiSeq7AAoCFfhdiE0uDw7vLMuDMN1_YTLI,20705
 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.0.0.dist-info/RECORD,,
+dbos-1.1.0.dist-info/RECORD,,