dbos 1.6.0a4__tar.gz → 1.7.0a2__tar.gz

{dbos-1.6.0a4 → dbos-1.7.0a2}/PKG-INFO

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

{dbos-1.6.0a4 → dbos-1.7.0a2}/dbos/_admin_server.py

@@ -3,12 +3,14 @@ from __future__ import annotations
 import json
 import re
 import threading
+from dataclasses import asdict
 from functools import partial
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict
 
 from dbos._workflow_commands import garbage_collect, global_timeout
 
+from ._conductor import protocol as conductor_protocol
 from ._context import SetWorkflowID
 from ._error import DBOSException
 from ._logger import dbos_logger
@@ -326,20 +328,24 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
 
     def _handle_workflows(self, filters: Dict[str, Any]) -> None:
         workflows = self.dbos.list_workflows(
-            workflow_ids=filters.get("workflow_ids"),
-            name=filters.get("name"),
+            workflow_ids=filters.get("workflow_uuids"),
+            user=filters.get("authenticated_user"),
             start_time=filters.get("start_time"),
             end_time=filters.get("end_time"),
             status=filters.get("status"),
             app_version=filters.get("application_version"),
+            name=filters.get("workflow_name"),
             limit=filters.get("limit"),
             offset=filters.get("offset"),
             sort_desc=filters.get("sort_desc", False),
             workflow_id_prefix=filters.get("workflow_id_prefix"),
         )
-
+        workflows_output = [
+            conductor_protocol.WorkflowsOutput.from_workflow_information(i)
+            for i in workflows
+        ]
         response_body = json.dumps(
-            [workflow.__dict__ for workflow in workflows]
+            [workflow.__dict__ for workflow in workflows_output]
         ).encode("utf-8")
         self.send_response(200)
         self.send_header("Content-Type", "application/json")
@@ -349,18 +355,21 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
 
     def _handle_queued_workflows(self, filters: Dict[str, Any]) -> None:
         workflows = self.dbos.list_queued_workflows(
-            queue_name=filters.get("queue_name"),
-            name=filters.get("name"),
             start_time=filters.get("start_time"),
             end_time=filters.get("end_time"),
             status=filters.get("status"),
+            name=filters.get("workflow_name"),
             limit=filters.get("limit"),
             offset=filters.get("offset"),
+            queue_name=filters.get("queue_name"),
             sort_desc=filters.get("sort_desc", False),
         )
-
+        workflows_output = [
+            conductor_protocol.WorkflowsOutput.from_workflow_information(i)
+            for i in workflows
+        ]
         response_body = json.dumps(
-            [workflow.__dict__ for workflow in workflows]
+            [workflow.__dict__ for workflow in workflows_output]
         ).encode("utf-8")
         self.send_response(200)
         self.send_header("Content-Type", "application/json")

{dbos-1.6.0a4 → dbos-1.7.0a2}/dbos/_context.py

@@ -140,23 +140,18 @@ class DBOSContext:
         self,
         wfid: Optional[str],
         attributes: TracedAttributes,
-        is_temp_workflow: bool = False,
     ) -> None:
         if wfid is None or len(wfid) == 0:
             wfid = self.assign_workflow_id()
             self.id_assigned_for_next_workflow = ""
         self.workflow_id = wfid
         self.function_id = 0
-        if not is_temp_workflow:
-            self._start_span(attributes)
+        self._start_span(attributes)
 
-    def end_workflow(
-        self, exc_value: Optional[BaseException], is_temp_workflow: bool = False
-    ) -> None:
+    def end_workflow(self, exc_value: Optional[BaseException]) -> None:
         self.workflow_id = ""
         self.function_id = -1
-        if not is_temp_workflow:
-            self._end_span(exc_value)
+        self._end_span(exc_value)
 
     def is_within_workflow(self) -> bool:
         return len(self.workflow_id) > 0
@@ -490,7 +485,6 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
     def __init__(self, attributes: TracedAttributes) -> None:
         self.created_ctx = False
         self.attributes = attributes
-        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
@@ -514,7 +508,7 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
         self.saved_priority = ctx.priority
         ctx.priority = None
         ctx.start_workflow(
-            None, self.attributes, self.is_temp_workflow
+            None, self.attributes
         )  # Will get from the context's next workflow ID
         return ctx
 
@@ -526,7 +520,7 @@ class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
     ) -> Literal[False]:
         ctx = assert_current_dbos_context()
         assert ctx.is_within_workflow()
-        ctx.end_workflow(exc_value, self.is_temp_workflow)
+        ctx.end_workflow(exc_value)
         # Restore the saved workflow timeout
         ctx.workflow_timeout_ms = self.saved_workflow_timeout
         # Clear any propagating timeout

{dbos-1.6.0a4 → dbos-1.7.0a2}/dbos/_core.py

@@ -1187,11 +1187,6 @@ def decorate_step(
         async def temp_wf_async(*args: Any, **kwargs: Any) -> Any:
             return await wrapper(*args, **kwargs)
 
-        # Other code in transact-py depends on the name of temporary workflow functions to be "temp_wf"
-        # so set the name of both sync and async temporary workflow functions explicitly
-        temp_wf_sync.__name__ = "temp_wf"
-        temp_wf_async.__name__ = "temp_wf"
-
         temp_wf = temp_wf_async if inspect.iscoroutinefunction(func) else temp_wf_sync
         wrapped_wf = workflow_wrapper(dbosreg, temp_wf)
         set_dbos_func_name(temp_wf, "<temp>." + step_name)

{dbos-1.6.0a4 → dbos-1.7.0a2}/dbos/_dbos.py

@@ -7,7 +7,6 @@ import inspect
 import os
 import sys
 import threading
-import traceback
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 from logging import Logger
@@ -28,6 +27,7 @@ from typing import (
 )
 
 from opentelemetry.trace import Span
+from rich import print
 
 from dbos._conductor.conductor import ConductorWebsocket
 from dbos._sys_db import WorkflowStatus
@@ -517,6 +517,16 @@ class DBOS:
 
             dbos_logger.info("DBOS launched!")
 
+            if self.conductor_key is None and os.environ.get("DBOS__CLOUD") != "true":
+                # Hint the user to open the URL to register and set up Conductor
+                app_name = self._config["name"]
+                conductor_registration_url = (
+                    f"https://console.dbos.dev/self-host?appname={app_name}"
+                )
+                print(
+                    f"[bold]To view and manage workflows, connect to DBOS Conductor at:[/bold] [bold blue]{conductor_registration_url}[/bold blue]"
+                )
+
             # Flush handlers and add OTLP to all loggers if enabled
             # to enable their export in DBOS Cloud
             for handler in dbos_logger.handlers:

{dbos-1.6.0a4 → dbos-1.7.0a2}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "1.6.0a4"
+version = "1.7.0a2"
 
 [project.license]
 text = "MIT"

{dbos-1.6.0a4 → dbos-1.7.0a2}/tests/test_admin_server.py

@@ -3,7 +3,8 @@ import socket
 import threading
 import time
 import uuid
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict
 
 import pytest
 import requests
@@ -462,13 +463,13 @@ def test_list_workflows(dbos: DBOS) -> None:
         pass
 
     @DBOS.workflow()
-    def test_workflow_2() -> None:
-        pass
+    def test_workflow_2(my_time: datetime) -> str:
+        return DBOS.workflow_id + " completed at " + my_time.isoformat()
 
     # Start workflows
     handle_1 = DBOS.start_workflow(test_workflow_1)
     time.sleep(2)  # Sleep for 2 seconds between workflows
-    handle_2 = DBOS.start_workflow(test_workflow_2)
+    handle_2 = DBOS.start_workflow(test_workflow_2, datetime.now())
 
     # Wait for workflows to complete
     handle_1.get_result()
@@ -492,8 +493,8 @@ def test_list_workflows(dbos: DBOS) -> None:
     ).isoformat()
 
     # Test POST /workflows with filters
-    filters = {
-        "workflow_ids": workflow_ids,
+    filters: Dict[str, Any] = {
+        "workflow_uuids": workflow_ids,
         "start_time": start_time_filter,
     }
     response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
@@ -501,7 +502,24 @@ def test_list_workflows(dbos: DBOS) -> None:
 
     workflows = response.json()
     assert len(workflows) == 1, f"Expected 1 workflows, but got {len(workflows)}"
-    assert workflows[0]["workflow_id"] == handle_2.workflow_id, "Workflow ID mismatch"
+
+    # Make sure it contains all the expected fields
+    assert workflows[0]["WorkflowUUID"] == handle_2.workflow_id, "Workflow ID mismatch"
+    assert workflows[0]["WorkflowName"] == test_workflow_2.__qualname__
+    assert workflows[0]["Status"] == "SUCCESS"
+    assert workflows[0]["WorkflowClassName"] is None
+    assert workflows[0]["WorkflowConfigName"] is None
+    assert workflows[0]["AuthenticatedUser"] is None
+    assert workflows[0]["AssumedRole"] is None
+    assert workflows[0]["AuthenticatedRoles"] is None
+    assert workflows[0]["Input"] is not None and len(workflows[0]["Input"]) > 0
+    assert workflows[0]["Output"] is not None and len(workflows[0]["Output"]) > 0
+    assert workflows[0]["Error"] is None
+    assert workflows[0]["CreatedAt"] is not None and len(workflows[0]["CreatedAt"]) > 0
+    assert workflows[0]["UpdatedAt"] is not None and len(workflows[0]["UpdatedAt"]) > 0
+    assert workflows[0]["QueueName"] is None
+    assert workflows[0]["ApplicationVersion"] == GlobalParams.app_version
+    assert workflows[0]["ExecutorID"] == GlobalParams.executor_id
 
     # Test POST /workflows without filters
     response = requests.post("http://localhost:3001/workflows", json={}, timeout=5)
@@ -512,7 +530,106 @@ def test_list_workflows(dbos: DBOS) -> None:
         workflows_list
     ), f"Expected {len(workflows_list)} workflows, but got {len(workflows)}"
     for workflow in workflows:
-        assert workflow["workflow_id"] in workflow_ids, "Workflow ID mismatch"
+        assert workflow["WorkflowUUID"] in workflow_ids, "Workflow ID mismatch"
+
+    # Verify sort_desc inverts the order
+    filters = {
+        "sort_desc": True,
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == len(workflows_list)
+    assert (
+        workflows[0]["WorkflowUUID"] == handle_2.workflow_id
+    ), "First workflow should be the last one started"
+
+    # Test all filters
+    filters = {
+        "workflow_uuids": ["not-a-valid-uuid"],
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 0, "Expected no workflows for invalid UUID"
+
+    filters = {
+        "workflow_uuids": [handle_1.workflow_id, handle_2.workflow_id],
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 2
+
+    filters = {
+        "authenticated_user": "no-user",
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 0
+
+    filters = {
+        "workflow_name": test_workflow_1.__qualname__,
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 1
+    assert workflows[0]["WorkflowUUID"] == handle_1.workflow_id
+
+    filters = {
+        "end_time": (datetime.now(timezone.utc) - timedelta(minutes=10)).isoformat()
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 0
+
+    filters = {
+        "start_time": (datetime.now(timezone.utc) + timedelta(minutes=10)).isoformat(),
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 0
+
+    filters = {
+        "status": ["SUCCESS", "CANCELLED"],
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 2
+
+    filters = {
+        "application_version": GlobalParams.app_version,
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 2
+
+    filters = {
+        "limit": 1,
+        "offset": 1,
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 1
+    assert workflows[0]["WorkflowUUID"] == handle_2.workflow_id
+
+    filters = {
+        "workflow_id_prefix": handle_1.workflow_id[
+            :10
+        ],  # First 10 characters of the workflow name
+    }
+    response = requests.post("http://localhost:3001/workflows", json=filters, timeout=5)
+    assert response.status_code == 200
+    workflows = response.json()
+    assert len(workflows) == 1
+    assert workflows[0]["WorkflowUUID"] == handle_1.workflow_id
 
 
 def test_get_workflow_by_id(dbos: DBOS) -> None:
@@ -606,15 +723,15 @@ def test_queued_workflows_endpoint(dbos: DBOS) -> None:
     test_queue2 = Queue("test-queue-2", concurrency=1)
 
     @DBOS.workflow()
-    def blocking_workflow() -> str:
+    def blocking_workflow(i: int) -> str:
         while True:
             time.sleep(0.1)
 
     # Enqueue some workflows to create queued entries
-    handles = []
-    handles.append(test_queue1.enqueue(blocking_workflow))
-    handles.append(test_queue1.enqueue(blocking_workflow))
-    handles.append(test_queue2.enqueue(blocking_workflow))
+    handles: list[WorkflowHandle[str]] = []
+    handles.append(test_queue1.enqueue(blocking_workflow, 1))
+    handles.append(test_queue1.enqueue(blocking_workflow, 2))
+    handles.append(test_queue2.enqueue(blocking_workflow, 3))
 
     # Test basic queued workflows endpoint
     response = requests.post("http://localhost:3001/queues", json={}, timeout=5)
@@ -628,16 +745,101 @@ def test_queued_workflows_endpoint(dbos: DBOS) -> None:
         len(queued_workflows) == 3
     ), f"Expected 3 queued workflows, got {len(queued_workflows)}"
 
-    # Test with filters
-    filters = {"queue_name": "test-queue-1", "limit": 1}
+    # Make sure it contains all the expected fields
+    assert queued_workflows[0]["WorkflowName"] == blocking_workflow.__qualname__
+    assert (
+        queued_workflows[0]["WorkflowUUID"] == handles[0].workflow_id
+    ), "Workflow ID mismatch"
+    assert (
+        queued_workflows[0]["Status"] == "ENQUEUED"
+        or queued_workflows[0]["Status"] == "PENDING"
+    )
+    assert queued_workflows[0]["WorkflowClassName"] is None
+    assert queued_workflows[0]["WorkflowConfigName"] is None
+    assert queued_workflows[0]["AuthenticatedUser"] is None
+    assert queued_workflows[0]["AssumedRole"] is None
+    assert queued_workflows[0]["AuthenticatedRoles"] is None
+    assert (
+        queued_workflows[0]["Input"] is not None
+        and len(queued_workflows[0]["Input"]) > 0
+    )
+    assert "1" in queued_workflows[0]["Input"]
+    assert queued_workflows[0]["Output"] is None
+    assert queued_workflows[0]["Error"] is None
+    assert (
+        queued_workflows[0]["CreatedAt"] is not None
+        and len(queued_workflows[0]["CreatedAt"]) > 0
+    )
+    assert (
+        queued_workflows[0]["UpdatedAt"] is not None
+        and len(queued_workflows[0]["UpdatedAt"]) > 0
+    )
+    assert queued_workflows[0]["QueueName"] == test_queue1.name
+    assert queued_workflows[0]["ApplicationVersion"] == GlobalParams.app_version
+    assert queued_workflows[0]["ExecutorID"] == GlobalParams.executor_id
+
+    # Verify sort_desc inverts the order
+    filters: Dict[str, Any] = {
+        "sort_desc": True,
+    }
+    response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
+    assert response.status_code == 200
+    filtered_workflows = response.json()
+    assert len(filtered_workflows) == len(handles)
+    assert (
+        filtered_workflows[0]["WorkflowUUID"] == handles[2].workflow_id
+    ), "First workflow should be the last one enqueued"
+
+    # Test all filters
+    filters = {
+        "workflow_name": blocking_workflow.__qualname__,
+    }
+    response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
+    assert response.status_code == 200
+    filtered_workflows = response.json()
+    assert len(filtered_workflows) == len(handles)
+
+    filters = {
+        "end_time": (datetime.now(timezone.utc) - timedelta(minutes=10)).isoformat(),
+    }
     response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
     assert response.status_code == 200
+    filtered_workflows = response.json()
+    assert len(filtered_workflows) == 0
+
+    filters = {
+        "start_time": (datetime.now(timezone.utc) + timedelta(minutes=10)).isoformat(),
+    }
+    response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
+    assert response.status_code == 200
+    filtered_workflows = response.json()
+    assert len(filtered_workflows) == 0
 
+    filters = {
+        "status": ["PENDING", "ENQUEUED"],
+    }
+    response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
+    assert response.status_code == 200
+    filtered_workflows = response.json()
+    assert len(filtered_workflows) == len(handles)
+
+    filters = {
+        "queue_name": test_queue1.name,
+    }
+    response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
+    assert response.status_code == 200
+    filtered_workflows = response.json()
+    assert len(filtered_workflows) == 2
+
+    filters = {"queue_name": test_queue1.name, "limit": 1, "offset": 1}
+    response = requests.post("http://localhost:3001/queues", json=filters, timeout=5)
+    assert response.status_code == 200
     filtered_workflows = response.json()
     assert isinstance(filtered_workflows, list), "Response should be a list"
     assert (
         len(filtered_workflows) == 1
     ), f"Expected 1 workflow, got {len(filtered_workflows)}"
+    assert filtered_workflows[0]["WorkflowUUID"] == handles[1].workflow_id
 
     # Test with non-existent queue name
     filters = {"queue_name": "non-existent-queue"}