dbos 0.28.0a1__py3-none-any.whl → 0.28.0a6__py3-none-any.whl

dbos/_admin_server.py

@@ -66,11 +66,11 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
         elif self.path == _deactivate_path:
             if not AdminRequestHandler.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."
+                    f"Deactivating DBOS executor {GlobalParams.executor_id} with version {GlobalParams.app_version}. This executor will complete existing workflows but will not create new workflows."
                 )
                 AdminRequestHandler.is_deactivated = True
-            # Stop all scheduled workflows, queues, and kafka loops
-            for event in self.dbos.stop_events:
+            # Stop all event receivers (scheduler and Kafka threads)
+            for event in self.dbos.poller_stop_events:
                 event.set()
             self.send_response(200)
             self._end_headers()

dbos/_client.py

@@ -6,6 +6,7 @@ from typing import Any, Generic, List, Optional, TypedDict, TypeVar
 from sqlalchemy import URL
 
 from dbos._app_db import ApplicationDatabase
+from dbos._context import MaxPriority, MinPriority
 
 if sys.version_info < (3, 11):
     from typing_extensions import NotRequired
@@ -15,7 +16,7 @@ else:
 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._error import DBOSException, DBOSNonExistentWorkflowError
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
 from dbos._serialization import WorkflowInputs
 from dbos._sys_db import (
@@ -44,6 +45,15 @@ class EnqueueOptions(TypedDict):
     app_version: NotRequired[str]
     workflow_timeout: NotRequired[float]
     deduplication_id: NotRequired[str]
+    priority: NotRequired[int]
+
+
+def validate_enqueue_options(options: EnqueueOptions) -> None:
+    priority = options.get("priority")
+    if priority is not None and (priority < MinPriority or priority > MaxPriority):
+        raise DBOSException(
+            f"Invalid priority {priority}. Priority must be between {MinPriority}~{MaxPriority}."
+        )
 
 
 class WorkflowHandleClientPolling(Generic[R]):
@@ -60,7 +70,7 @@ class WorkflowHandleClientPolling(Generic[R]):
         return res
 
     def get_status(self) -> WorkflowStatus:
-        status = get_workflow(self._sys_db, self.workflow_id, False)
+        status = get_workflow(self._sys_db, self.workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
         return status
@@ -82,9 +92,7 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
         return res
 
     async def get_status(self) -> WorkflowStatus:
-        status = await asyncio.to_thread(
-            get_workflow, self._sys_db, self.workflow_id, False
-        )
+        status = await asyncio.to_thread(get_workflow, self._sys_db, self.workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
         return status
@@ -103,6 +111,7 @@ class DBOSClient:
         self._sys_db.destroy()
 
     def _enqueue(self, options: EnqueueOptions, *args: Any, **kwargs: Any) -> str:
+        validate_enqueue_options(options)
         workflow_name = options["workflow_name"]
         queue_name = options["queue_name"]
 
@@ -116,6 +125,7 @@ class DBOSClient:
         workflow_timeout = options.get("workflow_timeout", None)
         enqueue_options_internal: EnqueueOptionsInternal = {
             "deduplication_id": options.get("deduplication_id"),
+            "priority": options.get("priority"),
         }
 
         status: WorkflowStatusInternal = {
@@ -129,7 +139,6 @@ class DBOSClient:
             "authenticated_user": None,
             "assumed_role": None,
             "authenticated_roles": None,
-            "request": None,
             "output": None,
             "error": None,
             "created_at": None,
@@ -169,13 +178,13 @@ class DBOSClient:
         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, False)
+        status = get_workflow(self._sys_db, workflow_id)
         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, False)
+        status = asyncio.to_thread(get_workflow, self._sys_db, workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
@@ -198,7 +207,6 @@ class DBOSClient:
             "authenticated_user": None,
             "assumed_role": None,
             "authenticated_roles": None,
-            "request": None,
             "output": None,
             "error": None,
             "created_at": None,

dbos/_conductor/conductor.py

@@ -143,7 +143,6 @@ class ConductorWebsocket(threading.Thread):
                                     start_time=body["start_time"],
                                     end_time=body["end_time"],
                                     status=body["status"],
-                                    request=False,
                                     app_version=body["application_version"],
                                     name=body["workflow_name"],
                                     limit=body["limit"],
@@ -176,7 +175,6 @@ class ConductorWebsocket(threading.Thread):
                                     start_time=q_body["start_time"],
                                     end_time=q_body["end_time"],
                                     status=q_body["status"],
-                                    request=False,
                                     name=q_body["workflow_name"],
                                     limit=q_body["limit"],
                                     offset=q_body["offset"],
@@ -206,9 +204,7 @@ class ConductorWebsocket(threading.Thread):
                             info = None
                             try:
                                 info = get_workflow(
-                                    self.dbos._sys_db,
-                                    get_workflow_message.workflow_id,
-                                    get_request=False,
+                                    self.dbos._sys_db, get_workflow_message.workflow_id
                                 )
                             except Exception as e:
                                 error_message = f"Exception encountered when getting workflow {get_workflow_message.workflow_id}: {traceback.format_exc()}"

dbos/_conductor/protocol.py

@@ -149,7 +149,7 @@ class WorkflowsOutput:
         inputs_str = str(info.input) if info.input is not None else None
         outputs_str = str(info.output) if info.output is not None else None
         error_str = str(info.error) if info.error is not None else None
-        request_str = str(info.request) if info.request is not None else None
+        request_str = None
         roles_str = (
             str(info.authenticated_roles)
             if info.authenticated_roles is not None

dbos/_context.py

@@ -16,7 +16,6 @@ from sqlalchemy.orm import Session
 from dbos._utils import GlobalParams
 
 from ._logger import dbos_logger
-from ._request import Request
 from ._tracer import dbos_tracer
 
 
@@ -31,6 +30,9 @@ class OperationType(Enum):
 
 OperationTypes = Literal["handler", "workflow", "transaction", "step", "procedure"]
 
+MaxPriority = 2**31 - 1  # 2,147,483,647
+MinPriority = 1
+
 
 # Keys must be the same as in TypeScript Transact
 class TracedAttributes(TypedDict, total=False):
@@ -73,8 +75,6 @@ class DBOSContext:
 
         self.logger = dbos_logger
 
-        self.request: Optional["Request"] = None
-
         self.id_assigned_for_next_workflow: str = ""
         self.is_within_set_workflow_id_block: bool = False
 
@@ -100,6 +100,8 @@ class DBOSContext:
 
         # A user-specified deduplication ID for the enqueuing workflow.
         self.deduplication_id: Optional[str] = None
+        # A user-specified priority for the enqueuing workflow.
+        self.priority: Optional[int] = None
 
     def create_child(self) -> DBOSContext:
         rv = DBOSContext()
@@ -115,7 +117,6 @@ class DBOSContext:
             if self.authenticated_roles is not None
             else None
         )
-        rv.request = self.request
         rv.assumed_role = self.assumed_role
         return rv
 
@@ -422,15 +423,23 @@ class SetEnqueueOptions:
 
     Usage:
         ```
-        with SetEnqueueOptions(deduplication_id=<deduplication id>):
+        with SetEnqueueOptions(deduplication_id=<deduplication id>, priority=<priority>):
             queue.enqueue(...)
         ```
     """
 
-    def __init__(self, *, deduplication_id: Optional[str] = None) -> None:
+    def __init__(
+        self, *, deduplication_id: Optional[str] = None, priority: Optional[int] = None
+    ) -> None:
         self.created_ctx = False
         self.deduplication_id: Optional[str] = deduplication_id
         self.saved_deduplication_id: Optional[str] = None
+        if priority is not None and (priority < MinPriority or priority > MaxPriority):
+            raise Exception(
+                f"Invalid priority {priority}. Priority must be between {MinPriority}~{MaxPriority}."
+            )
+        self.priority: Optional[int] = priority
+        self.saved_priority: Optional[int] = None
 
     def __enter__(self) -> SetEnqueueOptions:
         # Code to create a basic context
@@ -441,6 +450,8 @@ class SetEnqueueOptions:
         ctx = assert_current_dbos_context()
         self.saved_deduplication_id = ctx.deduplication_id
         ctx.deduplication_id = self.deduplication_id
+        self.saved_priority = ctx.priority
+        ctx.priority = self.priority
         return self
 
     def __exit__(
@@ -449,7 +460,9 @@ class SetEnqueueOptions:
         exc_value: Optional[BaseException],
         traceback: Optional[TracebackType],
     ) -> Literal[False]:
-        assert_current_dbos_context().deduplication_id = self.saved_deduplication_id
+        curr_ctx = assert_current_dbos_context()
+        curr_ctx.deduplication_id = self.saved_deduplication_id
+        curr_ctx.priority = self.saved_priority
         # Code to clean up the basic context if we created it
         if self.created_ctx:
             _clear_local_dbos_context()
@@ -463,6 +476,7 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         self.is_temp_workflow = attributes["name"] == "temp_wf"
         self.saved_workflow_timeout: Optional[int] = None
         self.saved_deduplication_id: Optional[str] = None
+        self.saved_priority: Optional[int] = None
 
     def __enter__(self) -> DBOSContext:
         # Code to create a basic context
@@ -476,10 +490,12 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         # workflow's children (instead we propagate the deadline)
         self.saved_workflow_timeout = ctx.workflow_timeout_ms
         ctx.workflow_timeout_ms = None
-        # Unset the deduplication_id context var so it is not applied to this
+        # Unset the deduplication_id and priority context var so it is not applied to this
         # workflow's children
         self.saved_deduplication_id = ctx.deduplication_id
         ctx.deduplication_id = None
+        self.saved_priority = ctx.priority
+        ctx.priority = None
         ctx.start_workflow(
             None, self.attributes, self.is_temp_workflow
         )  # Will get from the context's next workflow ID
@@ -498,7 +514,8 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         ctx.workflow_timeout_ms = self.saved_workflow_timeout
         # Clear any propagating timeout
         ctx.workflow_deadline_epoch_ms = None
-        # Restore the saved deduplication ID
+        # Restore the saved deduplication ID and priority
+        ctx.priority = self.saved_priority
         ctx.deduplication_id = self.saved_deduplication_id
         # Code to clean up the basic context if we created it
         if self.created_ctx:

dbos/_core.py

@@ -266,9 +266,6 @@ def _init_workflow(
         "app_id": ctx.app_id,
         "app_version": GlobalParams.app_version,
         "executor_id": ctx.executor_id,
-        "request": (
-            _serialization.serialize(ctx.request) if ctx.request is not None else None
-        ),
         "recovery_attempts": None,
         "authenticated_user": ctx.authenticated_user,
         "authenticated_roles": (
@@ -296,7 +293,7 @@ def _init_workflow(
 
     if workflow_deadline_epoch_ms is not None:
         evt = threading.Event()
-        dbos.stop_events.append(evt)
+        dbos.background_thread_stop_events.append(evt)
 
         def timeout_func() -> None:
             try:
@@ -443,10 +440,6 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
         )
     with DBOSContextEnsure():
         ctx = assert_current_dbos_context()
-        request = status["request"]
-        ctx.request = (
-            _serialization.deserialize(request) if request is not None else None
-        )
         # If this function belongs to a configured class, add that class instance as its first argument
         if status["config_name"] is not None:
             config_name = status["config_name"]
@@ -544,6 +537,7 @@ def start_workflow(
     )
     enqueue_options = EnqueueOptionsInternal(
         deduplication_id=local_ctx.deduplication_id if local_ctx is not None else None,
+        priority=local_ctx.priority if local_ctx is not None else None,
     )
     new_wf_id, new_wf_ctx = _get_new_wf()
 
@@ -635,6 +629,7 @@ async def start_workflow_async(
     )
     enqueue_options = EnqueueOptionsInternal(
         deduplication_id=local_ctx.deduplication_id if local_ctx is not None else None,
+        priority=local_ctx.priority if local_ctx is not None else None,
     )
     new_wf_id, new_wf_ctx = _get_new_wf()
 

dbos/_dbos.py

@@ -71,14 +71,11 @@ from ._tracer import DBOSTracer, dbos_tracer
 if TYPE_CHECKING:
     from fastapi import FastAPI
     from ._kafka import _KafkaConsumerWorkflow
-    from ._request import Request
     from flask import Flask
 
 from sqlalchemy import URL
 from sqlalchemy.orm import Session
 
-from ._request import Request
-
 if sys.version_info < (3, 10):
     from typing_extensions import ParamSpec
 else:
@@ -197,7 +194,7 @@ class DBOSRegistry:
         self, evt: threading.Event, func: Callable[..., Any], *args: Any, **kwargs: Any
     ) -> None:
         if self.dbos and self.dbos._launched:
-            self.dbos.stop_events.append(evt)
+            self.dbos.poller_stop_events.append(evt)
             self.dbos._executor.submit(func, *args, **kwargs)
         else:
             self.pollers.append((evt, func, args, kwargs))
@@ -247,7 +244,7 @@ class DBOS:
     2. Starting workflow functions
     3. Retrieving workflow status information
     4. Interacting with workflows via events and messages
-    5. Accessing context, including the current user, request, SQL session, logger, and tracer
+    5. Accessing context, including the current user, SQL session, logger, and tracer
 
     """
 
@@ -330,7 +327,10 @@ class DBOS:
         self._registry: DBOSRegistry = _get_or_create_dbos_registry()
         self._registry.dbos = self
         self._admin_server_field: Optional[AdminServer] = None
-        self.stop_events: List[threading.Event] = []
+        # Stop internal background threads (queue thread, timeout threads, etc.)
+        self.background_thread_stop_events: List[threading.Event] = []
+        # Stop pollers (event receivers) that can create new workflows (scheduler, Kafka)
+        self.poller_stop_events: List[threading.Event] = []
         self.fastapi: Optional["FastAPI"] = fastapi
         self.flask: Optional["Flask"] = flask
         self._executor_field: Optional[ThreadPoolExecutor] = None
@@ -371,7 +371,7 @@ class DBOS:
         set_env_vars(self._config)
         config_logger(self._config)
         dbos_tracer.config(self._config)
-        dbos_logger.info("Initializing DBOS")
+        dbos_logger.info(f"Initializing DBOS (v{GlobalParams.dbos_version})")
 
         # If using FastAPI, set up middleware and lifecycle events
         if self.fastapi is not None:
@@ -502,7 +502,7 @@ class DBOS:
 
             # Start the queue thread
             evt = threading.Event()
-            self.stop_events.append(evt)
+            self.background_thread_stop_events.append(evt)
             bg_queue_thread = threading.Thread(
                 target=queue_thread, args=(evt, self), daemon=True
             )
@@ -515,7 +515,7 @@ class DBOS:
                     dbos_domain = os.environ.get("DBOS_DOMAIN", "cloud.dbos.dev")
                     self.conductor_url = f"wss://{dbos_domain}/conductor/v1alpha1"
                 evt = threading.Event()
-                self.stop_events.append(evt)
+                self.background_thread_stop_events.append(evt)
                 self.conductor_websocket = ConductorWebsocket(
                     self,
                     conductor_url=self.conductor_url,
@@ -527,7 +527,7 @@ class DBOS:
 
             # Grab any pollers that were deferred and start them
             for evt, func, args, kwargs in self._registry.pollers:
-                self.stop_events.append(evt)
+                self.poller_stop_events.append(evt)
                 poller_thread = threading.Thread(
                     target=func, args=args, kwargs=kwargs, daemon=True
                 )
@@ -583,7 +583,9 @@ class DBOS:
 
     def _destroy(self) -> None:
         self._initialized = False
-        for event in self.stop_events:
+        for event in self.poller_stop_events:
+            event.set()
+        for event in self.background_thread_stop_events:
             event.set()
         self._background_event_loop.stop()
         if self._sys_db_field is not None:
@@ -760,7 +762,7 @@ class DBOS:
         """Return the status of a workflow execution."""
 
         def fn() -> Optional[WorkflowStatus]:
-            return get_workflow(_get_dbos_instance()._sys_db, workflow_id, True)
+            return get_workflow(_get_dbos_instance()._sys_db, workflow_id)
 
         return _get_dbos_instance()._sys_db.call_function_as_step(fn, "DBOS.getStatus")
 
@@ -1156,12 +1158,6 @@ class DBOS:
         assert span
         return span
 
-    @classproperty
-    def request(cls) -> Optional["Request"]:
-        """Return the HTTP `Request`, if any, associated with the current context."""
-        ctx = assert_current_dbos_context()
-        return ctx.request
-
     @classproperty
     def authenticated_user(cls) -> Optional[str]:
         """Return the current authenticated user, if any, associated with the current context."""

dbos/_fastapi.py

@@ -7,15 +7,9 @@ from fastapi.responses import JSONResponse
 from starlette.types import ASGIApp, Receive, Scope, Send
 
 from . import DBOS
-from ._context import (
-    EnterDBOSHandler,
-    OperationType,
-    SetWorkflowID,
-    TracedAttributes,
-    assert_current_dbos_context,
-)
+from ._context import EnterDBOSHandler, OperationType, SetWorkflowID, TracedAttributes
 from ._error import DBOSException
-from ._request import Address, Request, request_id_header
+from ._utils import request_id_header
 
 
 def _get_or_generate_request_id(request: FastAPIRequest) -> str:
@@ -26,19 +20,6 @@ def _get_or_generate_request_id(request: FastAPIRequest) -> str:
         return str(uuid.uuid4())
 
 
-def _make_request(request: FastAPIRequest) -> Request:
-    return Request(
-        headers=request.headers,
-        path_params=request.path_params,
-        query_params=request.query_params,
-        url=str(request.url),
-        base_url=str(request.base_url),
-        client=Address(*request.client) if request.client is not None else None,
-        cookies=request.cookies,
-        method=request.method,
-    )
-
-
 async def _dbos_error_handler(request: FastAPIRequest, gexc: Exception) -> JSONResponse:
     exc: DBOSException = cast(DBOSException, gexc)
     status_code = 500
@@ -96,8 +77,6 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
             "operationType": OperationType.HANDLER.value,
         }
         with EnterDBOSHandler(attributes):
-            ctx = assert_current_dbos_context()
-            ctx.request = _make_request(request)
             workflow_id = request.headers.get("dbos-idempotency-key")
             if workflow_id is not None:
                 # Set the workflow ID for the handler

dbos/_flask.py

@@ -2,17 +2,11 @@ import uuid
 from typing import Any
 from urllib.parse import urlparse
 
-from flask import Flask, request
+from flask import Flask
 from werkzeug.wrappers import Request as WRequest
 
-from ._context import (
-    EnterDBOSHandler,
-    OperationType,
-    SetWorkflowID,
-    TracedAttributes,
-    assert_current_dbos_context,
-)
-from ._request import Address, Request, request_id_header
+from ._context import EnterDBOSHandler, OperationType, SetWorkflowID, TracedAttributes
+from ._utils import request_id_header
 
 
 class FlaskMiddleware:
@@ -32,8 +26,6 @@ class FlaskMiddleware:
             "operationType": OperationType.HANDLER.value,
         }
         with EnterDBOSHandler(attributes):
-            ctx = assert_current_dbos_context()
-            ctx.request = _make_request(request)
             workflow_id = request.headers.get("dbos-idempotency-key")
             if workflow_id is not None:
                 # Set the workflow ID for the handler
@@ -52,31 +44,5 @@ def _get_or_generate_request_id(request: WRequest) -> str:
         return str(uuid.uuid4())
 
 
-def _make_request(request: WRequest) -> Request:
-    parsed_url = urlparse(request.url)
-    base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
-
-    client = None
-    if request.remote_addr:
-        hostname = request.remote_addr
-        port = request.environ.get("REMOTE_PORT")
-        if port:
-            client = Address(hostname=hostname, port=int(port))
-        else:
-            # If port is not available, use 0 as a placeholder
-            client = Address(hostname=hostname, port=0)
-
-    return Request(
-        headers=dict(request.headers),
-        path_params={},
-        query_params=dict(request.args),
-        url=request.url,
-        base_url=base_url,
-        client=client,
-        cookies=dict(request.cookies),
-        method=request.method,
-    )
-
-
 def setup_flask_middleware(app: Flask) -> None:
     app.wsgi_app = FlaskMiddleware(app.wsgi_app)  # type: ignore

dbos/_migrations/versions/933e86bdac6a_add_queue_priority.py

@@ -0,0 +1,35 @@
+"""add queue priority
+
+Revision ID: 933e86bdac6a
+Revises: 27ac6900c6ad
+Create Date: 2025-04-25 18:17:40.462737
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "933e86bdac6a"
+down_revision: Union[str, None] = "27ac6900c6ad"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "workflow_queue",
+        sa.Column(
+            "priority",
+            sa.Integer(),
+            nullable=False,
+            server_default=sa.text("'0'::int"),
+        ),
+        schema="dbos",
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("workflow_queue", "priority", schema="dbos")

dbos/_recovery.py

@@ -29,7 +29,7 @@ def startup_recovery_thread(
 ) -> None:
     """Attempt to recover local pending workflows on startup using a background thread."""
     stop_event = threading.Event()
-    dbos.stop_events.append(stop_event)
+    dbos.background_thread_stop_events.append(stop_event)
     while not stop_event.is_set() and len(pending_workflows) > 0:
         try:
             for pending_workflow in list(pending_workflows):

dbos/_schemas/system_database.py

@@ -29,7 +29,6 @@ class SystemSchema:
         Column("authenticated_user", Text, nullable=True),
         Column("assumed_role", Text, nullable=True),
         Column("authenticated_roles", Text, nullable=True),
-        Column("request", Text, nullable=True),
         Column("output", Text, nullable=True),
         Column("error", Text, nullable=True),
         Column("executor_id", Text, nullable=True),
@@ -180,6 +179,12 @@ class SystemSchema:
             Text,
             nullable=True,
         ),
+        Column(
+            "priority",
+            Integer,
+            nullable=False,
+            server_default=text("'0'::int"),
+        ),
         UniqueConstraint(
             "queue_name", "deduplication_id", name="uq_workflow_queue_name_dedup_id"
         ),