ddeutil-workflow 0.0.84__py3-none-any.whl → 0.0.86__py3-none-any.whl

ddeutil/workflow/plugins/providers/az.py

@@ -89,9 +89,9 @@ try:
     from azure.core.exceptions import AzureError
     from azure.storage.blob import BlobServiceClient
 
-    AZURE_AVAILABLE = True
+    AZURE_AVAILABLE: bool = True
 except ImportError:
-    AZURE_AVAILABLE = False
+    AZURE_AVAILABLE: bool = False
 
 from pydantic import BaseModel, Field
 

ddeutil/workflow/result.py

@@ -12,30 +12,29 @@ states and the Result dataclass for context transfer between workflow components
 from __future__ import annotations
 
 from dataclasses import field
+from datetime import datetime
 from enum import Enum
 from typing import Any, Optional, TypedDict, Union
 
 from pydantic import ConfigDict
 from pydantic.dataclasses import dataclass
-from pydantic.functional_validators import model_validator
 from typing_extensions import NotRequired, Self
 
-from . import (
+from .__types import DictData
+from .errors import (
+    BaseError,
+    ErrorData,
     JobCancelError,
-    JobError,
     JobSkipError,
+    ResultError,
     StageCancelError,
-    StageError,
     StageNestedCancelError,
-    StageNestedError,
     StageNestedSkipError,
     StageSkipError,
     WorkflowCancelError,
-    WorkflowError,
+    WorkflowSkipError,
 )
-from .__types import DictData
-from .audits import Trace, get_trace
-from .errors import ErrorData, ResultError
+from .traces import Trace, get_trace
 from .utils import default_gen_id
 
 
@@ -110,11 +109,11 @@ def validate_statuses(statuses: list[Status]) -> Status:
         Status: Final consolidated status based on workflow logic
 
     Example:
-        >>> # Mixed statuses - FAILED takes priority
+        Case: Mixed statuses - FAILED takes priority
         >>> validate_statuses([SUCCESS, FAILED, SUCCESS])
         >>> # Returns: FAILED
 
-        >>> # All same status
+        Case: All same status
         >>> validate_statuses([SUCCESS, SUCCESS, SUCCESS])
         >>> # Returns: SUCCESS
     """
@@ -131,21 +130,7 @@ def validate_statuses(statuses: list[Status]) -> Status:
 
 
 def get_status_from_error(
-    error: Union[
-        StageError,
-        StageCancelError,
-        StageSkipError,
-        StageNestedCancelError,
-        StageNestedError,
-        StageNestedSkipError,
-        JobError,
-        JobCancelError,
-        JobSkipError,
-        WorkflowError,
-        WorkflowCancelError,
-        Exception,
-        BaseException,
-    ]
+    error: Union[BaseError, Exception, BaseException]
 ) -> Status:
     """Get the Status from the error object.
 
@@ -155,7 +140,10 @@ def get_status_from_error(
     Returns:
         Status: The status from the specific exception class.
     """
-    if isinstance(error, (StageNestedSkipError, StageSkipError, JobSkipError)):
+    if isinstance(
+        error,
+        (StageNestedSkipError, StageSkipError, JobSkipError, WorkflowSkipError),
+    ):
         return SKIP
     elif isinstance(
         error,
@@ -189,25 +177,8 @@ class Result:
     extras: DictData = field(default_factory=dict, compare=False, repr=False)
     status: Status = field(default=WAIT)
     context: Optional[DictData] = field(default=None)
-    info: DictData = field(default_factory=dict)
     run_id: str = field(default_factory=default_gen_id)
     parent_run_id: Optional[str] = field(default=None)
-    trace: Optional[Trace] = field(default=None, compare=False, repr=False)
-
-    @model_validator(mode="after")
-    def __prepare_trace(self) -> Self:
-        """Prepare trace field that want to pass after its initialize step.
-
-        :rtype: Self
-        """
-        if self.trace is None:  # pragma: no cov
-            self.trace: Trace = get_trace(
-                self.run_id,
-                parent_run_id=self.parent_run_id,
-                extras=self.extras,
-            )
-
-        return self
 
     @classmethod
     def from_trace(cls, trace: Trace):
@@ -216,7 +187,13 @@ class Result:
             run_id=trace.run_id,
             parent_run_id=trace.parent_run_id,
             extras=trace.extras,
-            trace=trace,
+        )
+
+    def gen_trace(self) -> Trace:
+        return get_trace(
+            self.run_id,
+            parent_run_id=self.parent_run_id,
+            extras=self.extras,
         )
 
     def catch(
@@ -251,18 +228,16 @@ class Result:
                     self.__dict__["context"][k].update(kwargs[k])
                 # NOTE: Exclude the `info` key for update information data.
                 elif k == "info":
-                    self.__dict__["info"].update(kwargs["info"])
+                    if "info" in self.__dict__["context"]:
+                        self.__dict__["context"].update(kwargs[k])
+                    else:
+                        self.__dict__["context"]["info"] = kwargs[k]
                 else:
                     raise ResultError(
                         f"The key {k!r} does not exists on context data."
                     )
         return self
 
-    def make_info(self, data: DictData) -> Self:
-        """Making information."""
-        self.__dict__["info"].update(data)
-        return self
-
 
 def catch(
     context: DictData,
@@ -292,19 +267,35 @@ def catch(
             context[k].update(kwargs[k])
         # NOTE: Exclude the `info` key for update information data.
         elif k == "info":
-            context.update({"info": kwargs["info"]})
-        else:
-            raise ResultError(f"The key {k!r} does not exists on context data.")
+            if "info" in context:
+                context.update(kwargs[k])
+            else:
+                context["info"] = kwargs[k]
+        # ARCHIVE:
+        # else:
+        #     raise ResultError(f"The key {k!r} does not exist on context data.")
     return context
 
 
+class Info(TypedDict):
+    exec_start: datetime
+    exec_end: NotRequired[datetime]
+    exec_latency: NotRequired[float]
+
+
+class System(TypedDict):
+    __sys_release_dryrun_mode: NotRequired[bool]
+    __sys_exec_break_circle: NotRequired[str]
+
+
 class Context(TypedDict):
     """Context dict typed."""
 
     status: Status
+    info: Info
+    sys: NotRequired[System]
     context: NotRequired[DictData]
     errors: NotRequired[Union[list[ErrorData], ErrorData]]
-    info: NotRequired[DictData]
 
 
 class Layer(str, Enum):