dbos 0.25.0a7__tar.gz → 0.25.0a9__tar.gz

{dbos-0.25.0a7 → dbos-0.25.0a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.25.0a7
+Version: 0.25.0a9
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT
@@ -23,6 +23,7 @@ Requires-Dist: cryptography>=43.0.3
 Requires-Dist: rich>=13.9.4
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: websockets>=15.0
+Requires-Dist: pyright>=1.1.398
 Description-Content-Type: text/markdown
 
 

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/__init__.py

@@ -1,10 +1,11 @@
 from . import _error as error
 from ._context import DBOSContextEnsure, DBOSContextSetAuth, SetWorkflowID
-from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle, WorkflowStatus
+from ._dbos import DBOS, DBOSConfiguredInstance, WorkflowHandle
 from ._dbos_config import ConfigFile, DBOSConfig, get_dbos_database_url, load_config
 from ._kafka_message import KafkaMessage
 from ._queue import Queue
 from ._sys_db import GetWorkflowsInput, WorkflowStatusString
+from ._workflow_commands import WorkflowStatus
 
 __all__ = [
     "ConfigFile",

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/_conductor/conductor.py

@@ -203,7 +203,7 @@ class ConductorWebsocket(threading.Thread):
                                 info = get_workflow(
                                     self.dbos._sys_db,
                                     get_workflow_message.workflow_id,
-                                    getRequest=False,
+                                    get_request=False,
                                 )
                             except Exception as e:
                                 error_message = f"Exception encountered when getting workflow {get_workflow_message.workflow_id}: {traceback.format_exc()}"

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/_conductor/protocol.py

@@ -3,7 +3,7 @@ from dataclasses import asdict, dataclass
 from enum import Enum
 from typing import List, Optional, Type, TypedDict, TypeVar
 
-from dbos._workflow_commands import WorkflowInformation
+from dbos._workflow_commands import WorkflowStatus
 
 
 class MessageType(str, Enum):
@@ -141,27 +141,33 @@ class WorkflowsOutput:
     ExecutorID: Optional[str]
 
     @classmethod
-    def from_workflow_information(cls, info: WorkflowInformation) -> "WorkflowsOutput":
+    def from_workflow_information(cls, info: WorkflowStatus) -> "WorkflowsOutput":
         # Convert fields to strings as needed
         created_at_str = str(info.created_at) if info.created_at is not None else None
         updated_at_str = str(info.updated_at) if info.updated_at is not None else None
         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
+        roles_str = (
+            str(info.authenticated_roles)
+            if info.authenticated_roles is not None
+            else None
+        )
 
         return cls(
             WorkflowUUID=info.workflow_id,
             Status=info.status,
-            WorkflowName=info.workflow_name,
-            WorkflowClassName=info.workflow_class_name,
-            WorkflowConfigName=info.workflow_config_name,
+            WorkflowName=info.name,
+            WorkflowClassName=info.class_name,
+            WorkflowConfigName=info.config_name,
             AuthenticatedUser=info.authenticated_user,
             AssumedRole=info.assumed_role,
-            AuthenticatedRoles=info.authenticated_roles,
+            AuthenticatedRoles=roles_str,
             Input=inputs_str,
             Output=outputs_str,
             Request=request_str,
-            Error=info.error,
+            Error=error_str,
             CreatedAt=created_at_str,
             UpdatedAt=updated_at_str,
             QueueName=info.queue_name,

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/_context.py

@@ -5,6 +5,7 @@ import os
 import uuid
 from contextlib import AbstractContextManager
 from contextvars import ContextVar
+from dataclasses import dataclass
 from enum import Enum
 from types import TracebackType
 from typing import List, Literal, Optional, Type, TypedDict
@@ -48,6 +49,23 @@ class TracedAttributes(TypedDict, total=False):
     authenticatedUserAssumedRole: Optional[str]
 
 
+@dataclass
+class StepStatus:
+    """
+    Status of a step execution.
+
+    Attributes:
+        step_id: The unique ID of this step in its workflow.
+        current_attempt: For steps with automatic retries, which attempt number (zero-indexed) is currently executing.
+        max_attempts: For steps with automatic retries, the maximum number of attempts that will be made before the step fails.
+
+    """
+
+    step_id: int
+    current_attempt: Optional[int]
+    max_attempts: Optional[int]
+
+
 class DBOSContext:
     def __init__(self) -> None:
         self.executor_id = GlobalParams.executor_id
@@ -73,6 +91,7 @@ class DBOSContext:
         self.authenticated_user: Optional[str] = None
         self.authenticated_roles: Optional[List[str]] = None
         self.assumed_role: Optional[str] = None
+        self.step_status: Optional[StepStatus] = None
 
     def create_child(self) -> DBOSContext:
         rv = DBOSContext()
@@ -150,10 +169,12 @@ class DBOSContext:
         attributes: TracedAttributes,
     ) -> None:
         self.curr_step_function_id = fid
+        self.step_status = StepStatus(fid, None, None)
         self._start_span(attributes)
 
     def end_step(self, exc_value: Optional[BaseException]) -> None:
         self.curr_step_function_id = -1
+        self.step_status = None
         self._end_span(exc_value)
 
     def start_transaction(
@@ -432,6 +453,30 @@ class EnterDBOSStep:
         return False  # Did not handle
 
 
+class EnterDBOSStepRetry:
+    def __init__(self, current_attempt: int, max_attempts: int) -> None:
+        self.current_attempt = current_attempt
+        self.max_attempts = max_attempts
+
+    def __enter__(self) -> None:
+        ctx = get_local_dbos_context()
+        if ctx is not None and ctx.step_status is not None:
+            ctx.step_status.current_attempt = self.current_attempt
+            ctx.step_status.max_attempts = self.max_attempts
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> Literal[False]:
+        ctx = get_local_dbos_context()
+        if ctx is not None and ctx.step_status is not None:
+            ctx.step_status.current_attempt = None
+            ctx.step_status.max_attempts = None
+        return False  # Did not handle
+
+
 class EnterDBOSTransaction:
     def __init__(self, sqls: Session, attributes: TracedAttributes) -> None:
         self.sqls = sqls

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/_core.py

@@ -81,13 +81,12 @@ from ._sys_db import (
 if TYPE_CHECKING:
     from ._dbos import (
         DBOS,
-        Workflow,
         WorkflowHandle,
         WorkflowHandleAsync,
-        WorkflowStatus,
         DBOSRegistry,
         IsolationLevel,
     )
+    from ._workflow_commands import WorkflowStatus
 
 from sqlalchemy.exc import DBAPIError, InvalidRequestError
 
@@ -304,7 +303,7 @@ def _get_wf_invoke_func(
 def _execute_workflow_wthread(
     dbos: "DBOS",
     status: WorkflowStatusInternal,
-    func: "Workflow[P, R]",
+    func: "Callable[P, R]",
     ctx: DBOSContext,
     *args: Any,
     **kwargs: Any,
@@ -335,7 +334,7 @@ def _execute_workflow_wthread(
 async def _execute_workflow_async(
     dbos: "DBOS",
     status: WorkflowStatusInternal,
-    func: "Workflow[P, Coroutine[Any, Any, R]]",
+    func: "Callable[P, Coroutine[Any, Any, R]]",
     ctx: DBOSContext,
     *args: Any,
     **kwargs: Any,
@@ -449,7 +448,7 @@ def _get_new_wf() -> tuple[str, DBOSContext]:
 
 def start_workflow(
     dbos: "DBOS",
-    func: "Workflow[P, Union[R, Coroutine[Any, Any, R]]]",
+    func: "Callable[P, Union[R, Coroutine[Any, Any, R]]]",
     queue_name: Optional[str],
     execute_workflow: bool,
     *args: P.args,
@@ -515,9 +514,6 @@ def start_workflow(
             or wf_status == WorkflowStatusString.SUCCESS.value
         )
     ):
-        dbos.logger.debug(
-            f"Workflow {new_wf_id} already completed with status {wf_status}. Directly returning a workflow handle."
-        )
         return WorkflowHandlePolling(new_wf_id, dbos)
 
     future = dbos._executor.submit(
@@ -534,7 +530,7 @@ def start_workflow(
 
 async def start_workflow_async(
     dbos: "DBOS",
-    func: "Workflow[P, Coroutine[Any, Any, R]]",
+    func: "Callable[P, Coroutine[Any, Any, R]]",
     queue_name: Optional[str],
     execute_workflow: bool,
     *args: P.args,
@@ -605,9 +601,6 @@ async def start_workflow_async(
             or wf_status == WorkflowStatusString.SUCCESS.value
         )
     ):
-        dbos.logger.debug(
-            f"Workflow {new_wf_id} already completed with status {wf_status}. Directly returning a workflow handle."
-        )
         return WorkflowHandleAsyncPolling(new_wf_id, dbos)
 
     coro = _execute_workflow_async(dbos, status, func, new_wf_ctx, *args, **kwargs)
@@ -946,7 +939,7 @@ def decorate_step(
 
             def on_exception(attempt: int, error: BaseException) -> float:
                 dbos.logger.warning(
-                    f"Step being automatically retried. (attempt {attempt} of {attempts}). {traceback.format_exc()}"
+                    f"Step being automatically retried. (attempt {attempt + 1} of {attempts}). {traceback.format_exc()}"
                 )
                 ctx = assert_current_dbos_context()
                 ctx.get_current_span().add_event(

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/_dbos.py

@@ -11,7 +11,6 @@ import threading
 import traceback
 import uuid
 from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
 from logging import Logger
 from typing import (
     TYPE_CHECKING,
@@ -28,13 +27,18 @@ from typing import (
     TypeVar,
     Union,
     cast,
-    overload,
 )
 
 from opentelemetry.trace import Span
 
+from dbos import _serialization
 from dbos._conductor.conductor import ConductorWebsocket
 from dbos._utils import GlobalParams
+from dbos._workflow_commands import (
+    WorkflowStatus,
+    list_queued_workflows,
+    list_workflows,
+)
 
 from ._classproperty import classproperty
 from ._core import (
@@ -86,6 +90,7 @@ from ._admin_server import AdminServer
 from ._app_db import ApplicationDatabase
 from ._context import (
     EnterDBOSStep,
+    StepStatus,
     TracedAttributes,
     assert_current_dbos_context,
     get_local_dbos_context,
@@ -108,6 +113,7 @@ from ._error import (
 )
 from ._logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
 from ._sys_db import SystemDatabase
+from ._workflow_commands import WorkflowStatus, get_workflow
 
 # Most DBOS functions are just any callable F, so decorators / wrappers work on F
 # There are cases where the parameters P and return value R should be separate
@@ -120,17 +126,6 @@ R = TypeVar("R", covariant=True)  # A generic type for workflow return values
 
 T = TypeVar("T")
 
-
-class DBOSCallProtocol(Protocol[P, R]):
-    __name__: str
-    __qualname__: str
-
-    def __call__(*args: P.args, **kwargs: P.kwargs) -> R: ...
-
-
-Workflow: TypeAlias = DBOSCallProtocol[P, R]
-
-
 IsolationLevel = Literal[
     "SERIALIZABLE",
     "REPEATABLE READ",
@@ -163,7 +158,7 @@ RegisteredJob = Tuple[
 
 class DBOSRegistry:
     def __init__(self) -> None:
-        self.workflow_info_map: dict[str, Workflow[..., Any]] = {}
+        self.workflow_info_map: dict[str, Callable[..., Any]] = {}
         self.function_type_map: dict[str, str] = {}
         self.class_info_map: dict[str, type] = {}
         self.instance_info_map: dict[str, object] = {}
@@ -707,7 +702,7 @@ class DBOS:
     @classmethod
     def start_workflow(
         cls,
-        func: Workflow[P, R],
+        func: Callable[P, R],
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> WorkflowHandle[R]:
@@ -717,7 +712,7 @@ class DBOS:
     @classmethod
     async def start_workflow_async(
         cls,
-        func: Workflow[P, Coroutine[Any, Any, R]],
+        func: Callable[P, Coroutine[Any, Any, R]],
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> WorkflowHandleAsync[R]:
@@ -729,72 +724,39 @@ class DBOS:
     @classmethod
     def get_workflow_status(cls, workflow_id: str) -> Optional[WorkflowStatus]:
         """Return the status of a workflow execution."""
+        sys_db = _get_dbos_instance()._sys_db
         ctx = get_local_dbos_context()
         if ctx and ctx.is_within_workflow():
             ctx.function_id += 1
-            stat = _get_dbos_instance()._sys_db.get_workflow_status_within_wf(
-                workflow_id, ctx.workflow_id, ctx.function_id
+            res = sys_db.check_operation_execution(ctx.workflow_id, ctx.function_id)
+            if res is not None:
+                if res["output"]:
+                    resstat: WorkflowStatus = _serialization.deserialize(res["output"])
+                    return resstat
+                else:
+                    raise DBOSException(
+                        "Workflow status record not found. This should not happen! \033[1m Hint: Check if your workflow is deterministic.\033[0m"
+                    )
+        stat = get_workflow(_get_dbos_instance()._sys_db, workflow_id, True)
+
+        if ctx and ctx.is_within_workflow():
+            sys_db.record_operation_result(
+                {
+                    "workflow_uuid": ctx.workflow_id,
+                    "function_id": ctx.function_id,
+                    "function_name": "DBOS.getStatus",
+                    "output": _serialization.serialize(stat),
+                    "error": None,
+                }
             )
-        else:
-            stat = _get_dbos_instance()._sys_db.get_workflow_status(workflow_id)
-        if stat is None:
-            return None
-
-        return WorkflowStatus(
-            workflow_id=workflow_id,
-            status=stat["status"],
-            name=stat["name"],
-            executor_id=stat["executor_id"],
-            recovery_attempts=stat["recovery_attempts"],
-            class_name=stat["class_name"],
-            config_name=stat["config_name"],
-            queue_name=stat["queue_name"],
-            authenticated_user=stat["authenticated_user"],
-            assumed_role=stat["assumed_role"],
-            authenticated_roles=(
-                json.loads(stat["authenticated_roles"])
-                if stat["authenticated_roles"] is not None
-                else None
-            ),
-        )
+        return stat
 
     @classmethod
     async def get_workflow_status_async(
         cls, workflow_id: str
     ) -> Optional[WorkflowStatus]:
         """Return the status of a workflow execution."""
-        ctx = get_local_dbos_context()
-        if ctx and ctx.is_within_workflow():
-            ctx.function_id += 1
-            stat = await asyncio.to_thread(
-                lambda: _get_dbos_instance()._sys_db.get_workflow_status_within_wf(
-                    workflow_id, ctx.workflow_id, ctx.function_id
-                )
-            )
-        else:
-            stat = await asyncio.to_thread(
-                lambda: _get_dbos_instance()._sys_db.get_workflow_status(workflow_id)
-            )
-        if stat is None:
-            return None
-
-        return WorkflowStatus(
-            workflow_id=workflow_id,
-            status=stat["status"],
-            name=stat["name"],
-            executor_id=stat["executor_id"],
-            recovery_attempts=stat["recovery_attempts"],
-            class_name=stat["class_name"],
-            config_name=stat["config_name"],
-            queue_name=stat["queue_name"],
-            authenticated_user=stat["authenticated_user"],
-            assumed_role=stat["assumed_role"],
-            authenticated_roles=(
-                json.loads(stat["authenticated_roles"])
-                if stat["authenticated_roles"] is not None
-                else None
-            ),
-        )
+        return await asyncio.to_thread(cls.get_workflow_status, workflow_id)
 
     @classmethod
     def retrieve_workflow(
@@ -994,6 +956,60 @@ class DBOS:
         _get_or_create_dbos_registry().clear_workflow_cancelled(workflow_id)
         return execute_workflow_by_id(_get_dbos_instance(), workflow_id, False)
 
+    @classmethod
+    def list_workflows(
+        cls,
+        *,
+        workflow_ids: Optional[List[str]] = None,
+        status: Optional[str] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        name: Optional[str] = None,
+        app_version: Optional[str] = None,
+        user: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        sort_desc: bool = False,
+    ) -> List[WorkflowStatus]:
+        return list_workflows(
+            _get_dbos_instance()._sys_db,
+            workflow_ids=workflow_ids,
+            status=status,
+            start_time=start_time,
+            end_time=end_time,
+            name=name,
+            app_version=app_version,
+            user=user,
+            limit=limit,
+            offset=offset,
+            sort_desc=sort_desc,
+        )
+
+    @classmethod
+    def list_queued_workflows(
+        cls,
+        *,
+        queue_name: Optional[str] = None,
+        status: Optional[str] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        name: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        sort_desc: bool = False,
+    ) -> List[WorkflowStatus]:
+        return list_queued_workflows(
+            _get_dbos_instance()._sys_db,
+            queue_name=queue_name,
+            status=status,
+            start_time=start_time,
+            end_time=end_time,
+            name=name,
+            limit=limit,
+            offset=offset,
+            sort_desc=sort_desc,
+        )
+
     @classproperty
     def logger(cls) -> Logger:
         """Return the DBOS `Logger` for the current context."""
@@ -1041,6 +1057,14 @@ class DBOS:
         ), "step_id is only available within a DBOS workflow."
         return ctx.function_id
 
+    @classproperty
+    def step_status(cls) -> StepStatus:
+        """Return the status of the currently executing step."""
+        ctx = assert_current_dbos_context()
+        assert ctx.is_step(), "step_status is only available within a DBOS step."
+        assert ctx.step_status is not None
+        return ctx.step_status
+
     @classproperty
     def parent_workflow_id(cls) -> str:
         """
@@ -1095,41 +1119,6 @@ class DBOS:
         ctx.authenticated_roles = authenticated_roles
 
 
-@dataclass
-class WorkflowStatus:
-    """
-    Status of workflow execution.
-
-    This captures the state of a workflow execution at a point in time.
-
-    Attributes:
-        workflow_id(str):  The ID of the workflow execution
-        status(str):  The status of the execution, from `WorkflowStatusString`
-        name(str): The workflow function name
-        executor_id(str): The ID of the executor running the workflow
-        class_name(str): For member functions, the name of the class containing the workflow function
-        config_name(str): For instance member functions, the name of the class instance for the execution
-        queue_name(str): For workflows that are or were queued, the queue name
-        authenticated_user(str): The user who invoked the workflow
-        assumed_role(str): The access role used by the user to allow access to the workflow function
-        authenticated_roles(List[str]): List of all access roles available to the authenticated user
-        recovery_attempts(int): Number of times the workflow has been restarted (usually by recovery)
-
-    """
-
-    workflow_id: str
-    status: str
-    name: str
-    executor_id: Optional[str]
-    class_name: Optional[str]
-    config_name: Optional[str]
-    queue_name: Optional[str]
-    authenticated_user: Optional[str]
-    assumed_role: Optional[str]
-    authenticated_roles: Optional[List[str]]
-    recovery_attempts: Optional[int]
-
-
 class WorkflowHandle(Generic[R], Protocol):
     """
     Handle to a workflow function.

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/_outcome.py

@@ -4,6 +4,8 @@ import inspect
 import time
 from typing import Any, Callable, Coroutine, Optional, Protocol, TypeVar, Union, cast
 
+from dbos._context import EnterDBOSStepRetry
+
 T = TypeVar("T")
 R = TypeVar("R")
 
@@ -98,7 +100,8 @@ class Immediate(Outcome[T]):
     ) -> T:
         for i in range(attempts):
             try:
-                return func()
+                with EnterDBOSStepRetry(i, attempts):
+                    return func()
             except Exception as exp:
                 wait_time = on_exception(i, exp)
                 time.sleep(wait_time)
@@ -184,7 +187,8 @@ class Pending(Outcome[T]):
     ) -> T:
         for i in range(attempts):
             try:
-                return await func()
+                with EnterDBOSStepRetry(i, attempts):
+                    return await func()
             except Exception as exp:
                 wait_time = on_exception(i, exp)
                 await asyncio.sleep(wait_time)

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/_queue.py

@@ -1,6 +1,6 @@
 import threading
 import traceback
-from typing import TYPE_CHECKING, Any, Coroutine, Optional, TypedDict
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Optional, TypedDict
 
 from psycopg import errors
 from sqlalchemy.exc import OperationalError
@@ -10,7 +10,7 @@ from dbos._utils import GlobalParams
 from ._core import P, R, execute_workflow_by_id, start_workflow, start_workflow_async
 
 if TYPE_CHECKING:
-    from ._dbos import DBOS, Workflow, WorkflowHandle, WorkflowHandleAsync
+    from ._dbos import DBOS, WorkflowHandle, WorkflowHandleAsync
 
 
 class QueueRateLimit(TypedDict):
@@ -59,7 +59,7 @@ class Queue:
         registry.queue_info_map[self.name] = self
 
     def enqueue(
-        self, func: "Workflow[P, R]", *args: P.args, **kwargs: P.kwargs
+        self, func: "Callable[P, R]", *args: P.args, **kwargs: P.kwargs
     ) -> "WorkflowHandle[R]":
         from ._dbos import _get_dbos_instance
 
@@ -68,7 +68,7 @@ class Queue:
 
     async def enqueue_async(
         self,
-        func: "Workflow[P, Coroutine[Any, Any, R]]",
+        func: "Callable[P, Coroutine[Any, Any, R]]",
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> "WorkflowHandleAsync[R]":

{dbos-0.25.0a7 → dbos-0.25.0a9}/dbos/_sys_db.py

@@ -116,7 +116,7 @@ class GetWorkflowsInput:
         self.authenticated_user: Optional[str] = None  # The user who ran the workflow.
         self.start_time: Optional[str] = None  # Timestamp in ISO 8601 format
         self.end_time: Optional[str] = None  # Timestamp in ISO 8601 format
-        self.status: Optional[WorkflowStatuses] = None
+        self.status: Optional[str] = None
         self.application_version: Optional[str] = (
             None  # The application version that ran this workflow. = None
         )
@@ -541,32 +541,6 @@ class SystemDatabase:
             }
             return status
 
-    def get_workflow_status_within_wf(
-        self, workflow_uuid: str, calling_wf: str, calling_wf_fn: int
-    ) -> Optional[WorkflowStatusInternal]:
-        res = self.check_operation_execution(calling_wf, calling_wf_fn)
-        if res is not None:
-            if res["output"]:
-                resstat: WorkflowStatusInternal = _serialization.deserialize(
-                    res["output"]
-                )
-                return resstat
-            else:
-                raise DBOSException(
-                    "Workflow status record not found. This should not happen! \033[1m Hint: Check if your workflow is deterministic.\033[0m"
-                )
-        stat = self.get_workflow_status(workflow_uuid)
-        self.record_operation_result(
-            {
-                "workflow_uuid": calling_wf,
-                "function_id": calling_wf_fn,
-                "function_name": "DBOS.getStatus",
-                "output": _serialization.serialize(stat),
-                "error": None,
-            }
-        )
-        return stat
-
     def await_workflow_result_internal(self, workflow_uuid: str) -> dict[str, Any]:
         polling_interval_secs: float = 1.000