Merge pull request #48 from qua-platform/run_error

Run error

qualibrate/orchestration/basic_orchestrator.py

@@ -1,3 +1,4 @@
+import traceback
 from datetime import datetime
 from queue import Queue
 from typing import Any, Optional, Sequence
@@ -11,6 +12,7 @@
 )
 from qualibrate.outcome import Outcome
 from qualibrate.qualibration_graph import NodeState
+from qualibrate.run_summary.run_error import RunError
 from qualibrate.utils.logger_m import logger
 
 
@@ -90,6 +92,7 @@ def traverse_graph(
                 raise exc
             node_to_run_parameters = getattr(nodes_parameters, node_to_run.name)
             run_start = datetime.now()
+            run_error: Optional[RunError] = None
             try:
                 self._active_node = node_to_run
                 node_parameters = node_to_run_parameters.model_dump()
@@ -112,6 +115,11 @@ def traverse_graph(
                     ),
                     exc_info=ex,
                 )
+                run_error = RunError(
+                    error_class=ex.__class__.__name__,
+                    message=str(ex),
+                    traceback=traceback.format_tb(ex.__traceback__),
+                )
             else:
                 new_state = NodeState.successful
             finally:
@@ -122,6 +130,7 @@ def traverse_graph(
                         snapshot_idx=node_to_run.snapshot_idx,
                         outcomes=node_to_run.outcomes,
                         state=new_state,
+                        error=run_error,
                         run_start=run_start,
                         run_end=datetime.now(),
                         parameters=node_to_run_parameters,

qualibrate/orchestration/execution_history.py

@@ -6,6 +6,7 @@
 from qualibrate import NodeParameters
 from qualibrate.outcome import Outcome
 from qualibrate.qualibration_graph import NodeState
+from qualibrate.run_summary.run_error import RunError
 
 
 class ExecutionHistoryItem(BaseModel):
@@ -18,6 +19,7 @@ class ExecutionHistoryItem(BaseModel):
     run_start: datetime
     run_end: datetime
     parameters: NodeParameters
+    error: Optional[RunError] = None
     outcomes: Dict[Hashable, Outcome] = Field(default_factory=dict)
 
     @computed_field

qualibrate/qualibration_graph.py

@@ -1,3 +1,4 @@
+import traceback
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
@@ -29,9 +30,11 @@
 from qualibrate.qualibration_node import QualibrationNode
 from qualibrate.run_summary.base import BaseRunSummary
 from qualibrate.run_summary.graph import GraphRunSummary
+from qualibrate.run_summary.run_error import RunError
 from qualibrate.utils.exceptions import StopInspection
 from qualibrate.utils.logger_m import logger
 from qualibrate.utils.read_files import get_module_name, import_from_path
+from qualibrate.utils.type_protocols import TargetType
 
 if TYPE_CHECKING:
     from qualibrate import QualibrationLibrary
@@ -201,13 +204,7 @@ def _get_all_nodes_parameters(
             for name in cast(NodesParameters, nodes_class).model_fields.keys()
         }
 
-    def run(self, **passed_parameters: Any) -> BaseRunSummary:
-        """
-        :param passed_parameters: Graph parameters. Should contain `nodes` key.
-        """
-        logger.info(
-            f"Run graph {self.name} with parameters: {passed_parameters}"
-        )
+    def _run(self, **passed_parameters: Any) -> Sequence[TargetType]:
         if self._orchestrator is None:
             ex = ValueError("Orchestrator not specified")
             logger.exception("", exc_info=ex)
@@ -228,17 +225,37 @@ def run(self, **passed_parameters: Any) -> BaseRunSummary:
             node_parameters_model = getattr(nodes_parameters_model, node_name)
             if node_parameters_model.targets_name is not None:
                 node_parameters_model.targets = targets
-        created_at = datetime.now()
         self._orchestrator.traverse_graph(self, targets)
         self.outcomes = self._orchestrator.final_outcomes
+        return targets
+
+    def run(self, **passed_parameters: Any) -> BaseRunSummary:
+        """
+        :param passed_parameters: Graph parameters. Should contain `nodes` key.
+        """
+        logger.info(
+            f"Run graph {self.name} with parameters: {passed_parameters}"
+        )
+        created_at = datetime.now()
+        run_error: Optional[RunError] = None
+        initial_targets: Sequence[TargetType] = []
+        try:
+            initial_targets = self._run(**passed_parameters)
+        except Exception as ex:
+            run_error = RunError(
+                error_class=ex.__class__.__name__,
+                message=str(ex),
+                traceback=traceback.format_tb(ex.__traceback__),
+            )
         run_summary = GraphRunSummary(
             name=self.name,
             description=self.description,
             created_at=created_at,
             completed_at=datetime.now(),
             parameters=self.full_parameters,
             outcomes=self.outcomes,
-            initial_targets=targets,
+            initial_targets=initial_targets,
+            error=run_error,
             successful_targets=[
                 name
                 for name, status in self.outcomes.items()

qualibrate/qualibration_node.py

@@ -1,3 +1,4 @@
+import traceback
 from collections import UserDict, UserList
 from contextlib import contextmanager
 from copy import copy
@@ -24,6 +25,7 @@
 from qualibrate.q_runnnable import QRunnable, file_is_calibration_instance
 from qualibrate.run_summary.base import BaseRunSummary
 from qualibrate.run_summary.node import NodeRunSummary
+from qualibrate.run_summary.run_error import RunError
 from qualibrate.storage import StorageManager
 from qualibrate.storage.local_storage_manager import LocalStorageManager
 from qualibrate.utils.exceptions import StopInspection
@@ -195,14 +197,20 @@ def run(self, **passed_parameters: Any) -> BaseRunSummary:
         parameters = self.parameters_class.model_validate(params_dict)
         initial_targets = copy(parameters.targets) if parameters.targets else []
         created_at = datetime.now()
+        run_error: Optional[RunError] = None
         try:
             self.modes.external = True
             self.modes.interactive = True
             self._parameters = parameters
             self.run_node_file(self.filepath)
-        except Exception as e:
-            logger.exception("", exc_info=e)
-            raise e
+        except Exception as ex:
+            run_error = RunError(
+                error_class=ex.__class__.__name__,
+                message=str(ex),
+                traceback=traceback.format_tb(ex.__traceback__),
+            )
+            logger.exception("", exc_info=ex)
+            raise ex
         finally:
             self.modes.external = external
             self.modes.interactive = interactive
@@ -223,6 +231,7 @@ def run(self, **passed_parameters: Any) -> BaseRunSummary:
             initial_targets=initial_targets,
             parameters=parameters,
             outcomes=self.outcomes,
+            error=run_error,
             successful_targets=[
                 name
                 for name, status in self.outcomes.items()

qualibrate/run_summary/base.py

@@ -5,6 +5,7 @@
 
 from qualibrate.outcome import Outcome
 from qualibrate.parameters import RunnableParameters
+from qualibrate.run_summary.run_error import RunError
 from qualibrate.utils.type_protocols import TargetType
 
 __all__ = ["BaseRunSummary"]
@@ -15,8 +16,9 @@ class BaseRunSummary(BaseModel):
     description: Optional[str] = None
     created_at: datetime
     completed_at: datetime
-    parameters: RunnableParameters
+    parameters: Optional[RunnableParameters] = None
     outcomes: Dict[TargetType, Outcome]
+    error: Optional[RunError] = None
 
     initial_targets: Sequence[TargetType] = Field(default_factory=list)
     successful_targets: List[TargetType] = Field(default_factory=list)

qualibrate/run_summary/graph.py

@@ -1,8 +1,10 @@
+from typing import Optional
+
 from qualibrate import ExecutionParameters
 from qualibrate.run_summary.base import BaseRunSummary
 
 __all__ = ["GraphRunSummary"]
 
 
 class GraphRunSummary(BaseRunSummary):
-    parameters: ExecutionParameters
+    parameters: Optional[ExecutionParameters] = None

qualibrate/run_summary/run_error.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+__all__ = ["RunError"]
+
+
+class RunError(BaseModel):
+    error_class: str
+    message: str
+    traceback: list[str]