ddeutil-workflow 0.0.63__py3-none-any.whl → 0.0.65__py3-none-any.whl

ddeutil/workflow/params.py

@@ -21,7 +21,7 @@ from ddeutil.core import str2dict, str2list
 from pydantic import BaseModel, Field
 
 from .__types import StrOrInt
-from .exceptions import ParamValueException
+from .errors import ParamError
 from .utils import get_d_now, get_dt_now
 
 T = TypeVar("T")
@@ -101,14 +101,14 @@ class DateParam(DefaultParam):  # pragma: no cov
         elif isinstance(value, date):
             return value
         elif not isinstance(value, str):
-            raise ParamValueException(
+            raise ParamError(
                 f"Value that want to convert to date does not support for "
                 f"type: {type(value)}"
             )
         try:
             return date.fromisoformat(value)
         except ValueError:
-            raise ParamValueException(
+            raise ParamError(
                 f"Invalid the ISO format string for date: {value!r}"
             ) from None
 
@@ -143,14 +143,14 @@ class DatetimeParam(DefaultParam):
         elif isinstance(value, date):
             return datetime(value.year, value.month, value.day)
         elif not isinstance(value, str):
-            raise ParamValueException(
+            raise ParamError(
                 f"Value that want to convert to datetime does not support for "
                 f"type: {type(value)}"
             )
         try:
             return datetime.fromisoformat(value)
         except ValueError:
-            raise ParamValueException(
+            raise ParamError(
                 f"Invalid the ISO format string for datetime: {value!r}"
             ) from None
 
@@ -189,7 +189,7 @@ class IntParam(DefaultParam):
             try:
                 return int(str(value))
             except ValueError as err:
-                raise ParamValueException(
+                raise ParamError(
                     f"Value can not convert to int, {value}, with base 10"
                 ) from err
         return value
@@ -299,7 +299,7 @@ class ChoiceParam(BaseParam):
         if value is None:
             return self.options[0]
         if value not in self.options:
-            raise ParamValueException(
+            raise ParamError(
                 f"{value!r} does not match any value in choice options."
             )
         return value
@@ -331,12 +331,12 @@ class MapParam(DefaultParam):
             try:
                 value: dict[Any, Any] = str2dict(value)
             except ValueError as e:
-                raise ParamValueException(
+                raise ParamError(
                     f"Value that want to convert to map does not support for "
                     f"type: {type(value)}"
                 ) from e
         elif not isinstance(value, dict):
-            raise ParamValueException(
+            raise ParamError(
                 f"Value of map param support only string-dict or dict type, "
                 f"not {type(value)}"
             )
@@ -366,14 +366,14 @@ class ArrayParam(DefaultParam):
             try:
                 value: list[T] = str2list(value)
             except ValueError as e:
-                raise ParamValueException(
+                raise ParamError(
                     f"Value that want to convert to array does not support for "
                     f"type: {type(value)}"
                 ) from e
         elif isinstance(value, (tuple, set)):
             return list(value)
         elif not isinstance(value, list):
-            raise ParamValueException(
+            raise ParamError(
                 f"Value of map param support only string-list or list type, "
                 f"not {type(value)}"
             )

ddeutil/workflow/result.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 
 from dataclasses import field
 from datetime import datetime
-from enum import IntEnum
+from enum import IntEnum, auto
 from typing import Optional, Union
 
 from pydantic import ConfigDict
@@ -19,9 +19,20 @@ from pydantic.dataclasses import dataclass
 from pydantic.functional_validators import model_validator
 from typing_extensions import Self
 
+from . import (
+    JobCancelError,
+    JobError,
+    JobSkipError,
+    StageCancelError,
+    StageError,
+    StageSkipError,
+    WorkflowCancelError,
+    WorkflowError,
+    WorkflowSkipError,
+)
 from .__types import DictData
 from .conf import dynamic
-from .exceptions import ResultException
+from .errors import ResultError
 from .logs import TraceModel, get_dt_tznow, get_trace
 from .utils import default_gen_id, gen_id, get_dt_now
 
@@ -31,11 +42,11 @@ class Status(IntEnum):
     Result dataclass object.
     """
 
-    SUCCESS = 0
-    FAILED = 1
-    WAIT = 2
-    SKIP = 3
-    CANCEL = 4
+    SUCCESS = auto()
+    FAILED = auto()
+    WAIT = auto()
+    SKIP = auto()
+    CANCEL = auto()
 
     @property
     def emoji(self) -> str:  # pragma: no cov
@@ -43,7 +54,19 @@ class Status(IntEnum):
 
         :rtype: str
         """
-        return {0: "✅", 1: "❌", 2: "🟡", 3: "⏩", 4: "🚫"}[self.value]
+        return {
+            "SUCCESS": "✅",
+            "FAILED": "❌",
+            "WAIT": "🟡",
+            "SKIP": "⏩",
+            "CANCEL": "🚫",
+        }[self.name]
+
+    def __repr__(self) -> str:
+        return self.name
+
+    def __str__(self) -> str:
+        return self.name
 
 
 SUCCESS = Status.SUCCESS
@@ -53,6 +76,55 @@ SKIP = Status.SKIP
 CANCEL = Status.CANCEL
 
 
+def validate_statuses(statuses: list[Status]) -> Status:
+    """Validate the final status from list of Status object.
+
+    :param statuses: (list[Status]) A list of status that want to validate the
+        final status.
+
+    :rtype: Status
+    """
+    if any(s == CANCEL for s in statuses):
+        return CANCEL
+    elif any(s == FAILED for s in statuses):
+        return FAILED
+    elif any(s == WAIT for s in statuses):
+        return WAIT
+    for status in (SUCCESS, SKIP):
+        if all(s == status for s in statuses):
+            return status
+    return FAILED if FAILED in statuses else SUCCESS
+
+
+def get_status_from_error(
+    error: Union[
+        StageError,
+        StageCancelError,
+        StageSkipError,
+        JobError,
+        JobCancelError,
+        JobSkipError,
+        WorkflowError,
+        WorkflowCancelError,
+        WorkflowSkipError,
+        Exception,
+        BaseException,
+    ]
+) -> Status:
+    """Get the Status from the error object."""
+    if isinstance(error, (StageSkipError, JobSkipError, WorkflowSkipError)):
+        return SKIP
+    elif isinstance(
+        error, (StageCancelError, JobCancelError, WorkflowCancelError)
+    ):
+        return CANCEL
+    return FAILED
+
+
+def default_context() -> DictData:
+    return {"status": WAIT}
+
+
 @dataclass(
     config=ConfigDict(arbitrary_types_allowed=True, use_enum_values=True),
 )
@@ -70,7 +142,7 @@ class Result:
     """
 
     status: Status = field(default=WAIT)
-    context: DictData = field(default_factory=dict)
+    context: DictData = field(default_factory=default_context)
     run_id: Optional[str] = field(default_factory=default_gen_id)
     parent_run_id: Optional[str] = field(default=None, compare=False)
     ts: datetime = field(default_factory=get_dt_tznow, compare=False)
@@ -160,12 +232,16 @@ class Result:
             Status(status) if isinstance(status, int) else status
         )
         self.__dict__["context"].update(context or {})
+        self.__dict__["context"]["status"] = self.status
         if kwargs:
             for k in kwargs:
                 if k in self.__dict__["context"]:
                     self.__dict__["context"][k].update(kwargs[k])
+                # NOTE: Exclude the `info` key for update information data.
+                elif k == "info":
+                    self.__dict__["context"][k].update(kwargs[k])
                 else:
-                    raise ResultException(
+                    raise ResultError(
                         f"The key {k!r} does not exists on context data."
                     )
         return self

ddeutil/workflow/reusables.py

@@ -15,6 +15,7 @@ from datetime import datetime
 from functools import wraps
 from importlib import import_module
 from typing import (
+    Annotated,
     Any,
     Callable,
     Literal,
@@ -32,12 +33,13 @@ except ImportError:
 
 from ddeutil.core import getdot, import_string, lazy
 from ddeutil.io import search_env_replace
-from pydantic import BaseModel, create_model
+from pydantic import BaseModel, ConfigDict, Field, create_model
+from pydantic.alias_generators import to_pascal
 from pydantic.dataclasses import dataclass
 
 from .__types import DictData, Re
 from .conf import dynamic
-from .exceptions import UtilException
+from .errors import UtilError
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -121,7 +123,7 @@ def make_filter_registry(
             if not (
                 hasattr(func, "filter")
                 and str(getattr(func, "mark", "NOT SET")) == "filter"
-            ):
+            ):  # pragma: no cov
                 continue
 
             func: FilterFunc
@@ -144,13 +146,13 @@ def get_args_const(
     try:
         mod: Module = parse(expr)
     except SyntaxError:
-        raise UtilException(
+        raise UtilError(
             f"Post-filter: {expr} does not valid because it raise syntax error."
         ) from None
 
     body: list[Expr] = mod.body
     if len(body) > 1:
-        raise UtilException(
+        raise UtilError(
             "Post-filter function should be only one calling per workflow."
         )
 
@@ -158,7 +160,7 @@ def get_args_const(
     if isinstance((caller := body[0].value), Name):
         return caller.id, [], {}
     elif not isinstance(caller, Call):
-        raise UtilException(
+        raise UtilError(
             f"Get arguments does not support for caller type: {type(caller)}"
         )
 
@@ -167,10 +169,10 @@ def get_args_const(
     keywords: dict[str, Constant] = {k.arg: k.value for k in caller.keywords}
 
     if any(not isinstance(i, Constant) for i in args):
-        raise UtilException(f"Argument of {expr} should be constant.")
+        raise UtilError(f"Argument of {expr} should be constant.")
 
     if any(not isinstance(i, Constant) for i in keywords.values()):
-        raise UtilException(f"Keyword argument of {expr} should be constant.")
+        raise UtilError(f"Keyword argument of {expr} should be constant.")
 
     return name.id, args, keywords
 
@@ -192,12 +194,10 @@ def get_args_from_filter(
     kwargs: dict[Any, Any] = {k: v.value for k, v in _kwargs.items()}
 
     if func_name not in filters:
-        raise UtilException(
-            f"The post-filter: {func_name!r} does not support yet."
-        )
+        raise UtilError(f"The post-filter: {func_name!r} does not support yet.")
 
     if isinstance((f_func := filters[func_name]), list) and (args or kwargs):
-        raise UtilException(
+        raise UtilError(
             "Chain filter function does not support for passing arguments."
         )
 
@@ -226,10 +226,10 @@ def map_post_filter(
                     value: T = func(value)
             else:
                 value: T = f_func(value, *args, **kwargs)
-        except UtilException:
+        except UtilError:
             raise
         except Exception:
-            raise UtilException(
+            raise UtilError(
                 f"The post-filter: {func_name!r} does not fit with {value!r} "
                 f"(type: {type(value).__name__})."
             ) from None
@@ -320,7 +320,7 @@ def str2template(
         try:
             getter: Any = getdot(caller, params)
         except ValueError:
-            raise UtilException(
+            raise UtilError(
                 f"Parameters does not get dot with caller: {caller!r}."
             ) from None
 
@@ -402,7 +402,7 @@ def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
     """
     if isinstance(value, datetime):
         return value.strftime(fmt)
-    raise UtilException(
+    raise UtilError(
         "This custom function should pass input value with datetime type."
     )
 
@@ -435,7 +435,7 @@ def get_item(
 
     """
     if not isinstance(value, dict):
-        raise UtilException(
+        raise UtilError(
             f"The value that pass to `getitem` filter should be `dict` not "
             f"`{type(value)}`."
         )
@@ -452,14 +452,14 @@ def get_index(value: list[Any], index: int) -> Any:
 
     """
     if not isinstance(value, list):
-        raise UtilException(
+        raise UtilError(
             f"The value that pass to `getindex` filter should be `list` not "
             f"`{type(value)}`."
         )
     try:
         return value[index]
     except IndexError as e:
-        raise UtilException(
+        raise UtilError(
             f"Index: {index} is out of range of value (The maximum range is "
             f"{len(value)})."
         ) from e
@@ -635,12 +635,25 @@ def extract_call(
     return rgt[call.func][call.tag]
 
 
+class BaseCallerArgs(BaseModel):  # pragma: no cov
+    """Base Caller Args model."""
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        use_enum_values=True,
+    )
+
+
 def create_model_from_caller(func: Callable) -> BaseModel:  # pragma: no cov
     """Create model from the caller function. This function will use for
     validate the caller function argument typed-hint that valid with the args
     field.
 
-    :param func: A caller function.
+    Reference:
+        - https://github.com/lmmx/pydantic-function-models
+        - https://docs.pydantic.dev/1.10/usage/models/#dynamic-model-creation
+
+    :param func: (Callable) A caller function.
 
     :rtype: BaseModel
     """
@@ -649,16 +662,34 @@ def create_model_from_caller(func: Callable) -> BaseModel:  # pragma: no cov
     fields: dict[str, Any] = {}
     for name in sig.parameters:
         param: inspect.Parameter = sig.parameters[name]
+
+        # NOTE: Skip all `*args` and `**kwargs` parameters.
         if param.kind in (
             inspect.Parameter.VAR_KEYWORD,
             inspect.Parameter.VAR_POSITIONAL,
         ):
             continue
+
+        if name.startswith("_"):
+            kwargs = {"serialization_alias": name}
+            rename: str = name.removeprefix("_")
+        else:
+            kwargs = {}
+            rename: str = name
+
         if param.default != inspect.Parameter.empty:
-            fields[name] = (type_hints[name], param.default)
+            fields[rename] = Annotated[
+                type_hints[name],
+                Field(default=param.default, **kwargs),
+            ]
         else:
-            fields[name] = (type_hints[name], ...)
+            fields[rename] = Annotated[
+                type_hints[name],
+                Field(..., **kwargs),
+            ]
 
     return create_model(
-        "".join(i.title() for i in func.__name__.split("_")), **fields
+        to_pascal(func.__name__),
+        __base__=BaseCallerArgs,
+        **fields,
     )