feat: run results and graph execution history

qualibrate_runner/api/routes.py

@@ -2,6 +2,7 @@
 
 from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, status
 from pydantic import BaseModel
+from qualibrate.orchestration.execution_history import ExecutionHistory
 from qualibrate.qualibration_graph import QualibrationGraph
 from qualibrate.qualibration_node import QualibrationNode
 
@@ -87,9 +88,7 @@ def submit_workflow_run(
             for name, params in input_parameters.get("nodes", {}).items()
         },
     }
-    validate_input_parameters(
-        cast(Type[BaseModel], graph.full_parameters), input_parameters
-    )
+    validate_input_parameters(graph.full_parameters_class, input_parameters)
     background_tasks.add_task(run_workflow, graph, input_parameters, state)
     return f"Workflow job {graph.name} is submitted"
 
@@ -156,6 +155,20 @@ def get_last_run(
     return state.last_run
 
 
+@base_router.get("/last_run/workflow/execution_history")
+def get_execution_history(
+    state: Annotated[State, Depends(get_state)],
+) -> Optional[Mapping[str, Any]]:
+    if not isinstance(state.run_item, QualibrationGraph):
+        return None
+    graph: QualibrationGraph = state.run_item
+    orch = graph._orchestrator
+    if orch is None:
+        raise RuntimeError("No graph orchestrator")
+    history: ExecutionHistory = orch.get_execution_history()
+    return cast(Mapping[str, Any], history.model_dump(mode="json"))
+
+
 @base_router.post(
     "/record_state_update",
     description=(

qualibrate_runner/config/models.py

@@ -1,18 +1,21 @@
 from pathlib import Path
-from typing import Any, Callable, Mapping, Optional
+from typing import Any, Callable, Mapping, Optional, Union
 
-from pydantic import BaseModel, DirectoryPath, ImportString
+from pydantic import BaseModel, ConfigDict, DirectoryPath, ImportString
 from pydantic_settings import BaseSettings, SettingsConfigDict
+from qualibrate.qualibration_graph import QualibrationGraph
 from qualibrate.qualibration_library import QualibrationLibrary
+from qualibrate.qualibration_node import QualibrationNode
 
 from qualibrate_runner.core.models.last_run import LastRun, RunStatus
 
 
 class State(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
     passed_parameters: Mapping[str, Any] = {}
-    persistent: dict[str, Any] = {}
     last_run: Optional[LastRun] = None
-    node: Optional[str] = None
+    run_item: Optional[Union[QualibrationNode, QualibrationGraph]] = None
 
     @property
     def is_running(self) -> bool:

qualibrate_runner/core/models/last_run.py

@@ -2,6 +2,8 @@
 from typing import Any, Mapping, Optional, Union
 
 from pydantic import BaseModel, Field
+from qualibrate.run_summary.graph import GraphRunSummary
+from qualibrate.run_summary.node import NodeRunSummary
 
 
 class RunStatus(Enum):
@@ -28,5 +30,6 @@ class LastRun(BaseModel):
     status: RunStatus
     name: str
     idx: int
+    run_result: Optional[Union[NodeRunSummary, GraphRunSummary]] = None
     state_updates: Mapping[str, StateUpdate] = Field(default_factory=dict)
     error: Optional[RunError] = None

qualibrate_runner/core/run_job.py

@@ -12,11 +12,11 @@
 
 
 def validate_input_parameters(
-    node_parameters: Type[BaseModel],
+    parameters_class: Type[BaseModel],
     passed_parameters: Mapping[str, Any],
 ) -> BaseModel:
     try:
-        return node_parameters.model_validate(passed_parameters)
+        return parameters_class.model_validate(passed_parameters)
     except ValidationError as ex:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=ex.errors()
@@ -29,6 +29,7 @@ def run_node(
     state: State,
 ) -> None:
     state.passed_parameters = passed_input_parameters
+    state.run_item = node
     state.last_run = LastRun(
         name=node.name,
         status=RunStatus.RUNNING,
@@ -37,7 +38,7 @@ def run_node(
     try:
         library = QualibrationLibrary.active_library
         node = library.nodes[node.name]
-        library.run_node(
+        result = library.run_node(
             node.name, node.parameters_class(**passed_input_parameters)
         )
     except Exception as ex:
@@ -59,6 +60,7 @@ def run_node(
             name=state.last_run.name,
             status=RunStatus.FINISHED,
             idx=idx,
+            run_result=result,
             state_updates=node.state_updates,
         )
 
@@ -74,12 +76,15 @@ def run_workflow(
         status=RunStatus.RUNNING,
         idx=-1,
     )
+    state.run_item = workflow
     try:
         library = QualibrationLibrary.active_library
         workflow = library.graphs[workflow.name]
-        library.run_graph(
-            workflow.name, workflow.full_parameters(**passed_input_parameters)
+        result = library.run_graph(
+            workflow.name,
+            workflow.full_parameters_class(**passed_input_parameters),
         )
+        print("Graph completed. Result:", result)
     except Exception as ex:
         state.last_run = LastRun(
             name=state.last_run.name,
@@ -99,6 +104,7 @@ def run_workflow(
             name=state.last_run.name,
             status=RunStatus.FINISHED,
             idx=idx,
+            run_result=result,
             state_updates=(
                 workflow.state_updates
                 if hasattr(workflow, "state_updates")