ddeutil-workflow 0.0.38__py3-none-any.whl → 0.0.39__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.38"
+__version__: str = "0.0.39"

ddeutil/workflow/__types.py

@@ -61,8 +61,10 @@ class Re:
     #   Regular expression:
     #       - Version 1:
     #         \${{\s*(?P<caller>[a-zA-Z0-9_.\s'\"\[\]\(\)\-\{}]+?)\s*(?P<post_filters>(?:\|\s*(?:[a-zA-Z0-9_]{3,}[a-zA-Z0-9_.,-\\%\s'\"[\]()\{}]+)\s*)*)}}
+    #
     #       - Version 2: (2024-09-30):
     #         \${{\s*(?P<caller>(?P<caller_prefix>(?:[a-zA-Z_-]+\.)*)(?P<caller_last>[a-zA-Z0-9_\-.'\"(\)[\]{}]+))\s*(?P<post_filters>(?:\|\s*(?:[a-zA-Z0-9_]{3,}[a-zA-Z0-9_.,-\\%\s'\"[\]()\{}]+)\s*)*)}}
+    #
     #       - Version 3: (2024-10-05):
     #         \${{\s*(?P<caller>(?P<caller_prefix>(?:[a-zA-Z_-]+\??\.)*)(?P<caller_last>[a-zA-Z0-9_\-.'\"(\)[\]{}]+\??))\s*(?P<post_filters>(?:\|\s*(?:[a-zA-Z0-9_]{3,}[a-zA-Z0-9_.,-\\%\s'\"[\]()\{}]+)\s*)*)}}
     #

ddeutil/workflow/audit.py

@@ -20,7 +20,7 @@ from typing_extensions import Self
 
 from .__types import DictData, TupleStr
 from .conf import config
-from .logs import TraceLog, get_trace
+from .logs import TraceLog, get_dt_tznow, get_trace
 
 __all__: TupleStr = (
     "get_audit",
@@ -43,10 +43,12 @@ class BaseAudit(BaseModel, ABC):
         default_factory=dict,
         description="A context that receive from a workflow execution result.",
     )
-    parent_run_id: Optional[str] = Field(default=None)
-    run_id: str
-    update: datetime = Field(default_factory=datetime.now)
-    execution_time: float = Field(default=0)
+    parent_run_id: Optional[str] = Field(
+        default=None, description="A parent running ID."
+    )
+    run_id: str = Field(description="A running ID")
+    update: datetime = Field(default_factory=get_dt_tznow)
+    execution_time: float = Field(default=0, description="An execution time.")
 
     @model_validator(mode="after")
     def __model_action(self) -> Self:

ddeutil/workflow/caller.py

@@ -48,9 +48,10 @@ def tag(
     """Tag decorator function that set function attributes, ``tag`` and ``name``
     for making registries variable.
 
-    :param: name: A tag name for make different use-case of a function.
-    :param: alias: A alias function name that keeping in registries. If this
-        value does not supply, it will use original function name from __name__.
+    :param: name: (str) A tag name for make different use-case of a function.
+    :param: alias: (str) A alias function name that keeping in registries.
+        If this value does not supply, it will use original function name
+        from `__name__` argument.
 
     :rtype: Callable[P, TagFunc]
     """
@@ -78,7 +79,7 @@ Registry = dict[str, Callable[[], TagFunc]]
 def make_registry(submodule: str) -> dict[str, Registry]:
     """Return registries of all functions that able to called with task.
 
-    :param submodule: A module prefix that want to import registry.
+    :param submodule: (str) A module prefix that want to import registry.
 
     :rtype: dict[str, Registry]
     """
@@ -134,12 +135,7 @@ def extract_call(call: str) -> Callable[[], TagFunc]:
     """Extract Call function from string value to call partial function that
     does run it at runtime.
 
-    :raise NotImplementedError: When the searching call's function result does
-        not exist in the registry.
-    :raise NotImplementedError: When the searching call's tag result does not
-        exist in the registry with its function key.
-
-    :param call: A call value that able to match with Task regex.
+    :param call: (str) A call value that able to match with Task regex.
 
         The format of call value should contain 3 regular expression groups
     which match with the below config format:
@@ -152,6 +148,11 @@ def extract_call(call: str) -> Callable[[], TagFunc]:
         >>> extract_call("tasks/return-type-not-valid@raise")
         ...
 
+    :raise NotImplementedError: When the searching call's function result does
+        not exist in the registry.
+    :raise NotImplementedError: When the searching call's tag result does not
+        exist in the registry with its function key.
+
     :rtype: Callable[[], TagFunc]
     """
     if not (found := Re.RE_TASK_FMT.search(call)):

ddeutil/workflow/context.py

@@ -18,6 +18,7 @@ class ErrorContext(BaseModel):  # pragma: no cov
 class OutputContext(BaseModel):  # pragma: no cov
     outputs: DictData = Field(default_factory=dict)
     errors: Optional[ErrorContext] = Field(default=None)
+    skipped: bool = Field(default=False)
 
     def is_exception(self) -> bool:
         return self.errors is not None
@@ -57,3 +58,4 @@ class JobContext(BaseModel):  # pragma: no cov
     params: DictData = Field(description="A parameterize value")
     jobs: dict[str, StrategyMatrixContext]
     errors: Optional[ErrorContext] = Field(default=None)
+    skipped: bool = Field(default=False)

ddeutil/workflow/job.py

@@ -40,12 +40,8 @@ from .exceptions import (
 )
 from .result import Result, Status
 from .stages import Stage
-from .templates import has_template
-from .utils import (
-    cross_product,
-    filter_func,
-    gen_id,
-)
+from .templates import has_template, param2template
+from .utils import cross_product, filter_func, gen_id
 
 MatrixFilter = list[dict[str, Union[str, int]]]
 
@@ -54,6 +50,7 @@ __all__: TupleStr = (
     "Strategy",
     "Job",
     "TriggerRules",
+    "TriggerState",
     "RunsOn",
     "RunsOnLocal",
     "RunsOnSelfHosted",
@@ -208,6 +205,16 @@ class TriggerRules(str, Enum):
     none_skipped: str = "none_skipped"
 
 
+class TriggerState(str, Enum):
+    waiting: str = "waiting"
+    passed: str = "passed"
+    skipped: str = "skipped"
+    failed: str = "failed"
+
+    def is_waiting(self):
+        return self.value == "waiting"
+
+
 class RunsOnType(str, Enum):
     """Runs-On enum object."""
 
@@ -312,13 +319,21 @@ class Job(BaseModel):
         description="A target node for this job to use for execution.",
         alias="runs-on",
     )
+    condition: Optional[str] = Field(
+        default=None,
+        description="A job condition statement to allow job executable.",
+        alias="if",
+    )
     stages: list[Stage] = Field(
         default_factory=list,
         description="A list of Stage of this job.",
     )
     trigger_rule: TriggerRules = Field(
         default=TriggerRules.all_success,
-        description="A trigger rule of tracking needed jobs.",
+        description=(
+            "A trigger rule of tracking needed jobs if feature will use when "
+            "the `raise_error` did not set from job and stage executions."
+        ),
         alias="trigger-rule",
     )
     needs: list[str] = Field(
@@ -382,12 +397,87 @@ class Job(BaseModel):
                 return stage
         raise ValueError(f"Stage ID {stage_id} does not exists")
 
-    def check_needs(self, jobs: dict[str, Any]) -> bool:
+    def check_needs(
+        self, jobs: dict[str, Any]
+    ) -> TriggerState:  # pragma: no cov
         """Return True if job's need exists in an input list of job's ID.
 
+        :param jobs: A mapping of job model and its ID.
+
+        :rtype: TriggerState
+        """
+        if not self.needs:
+            return TriggerState.passed
+
+        def make_return(result: bool) -> TriggerState:
+            return TriggerState.passed if result else TriggerState.failed
+
+        need_exist: dict[str, Any] = {
+            need: jobs[need] for need in self.needs if need in jobs
+        }
+        if len(need_exist) != len(self.needs):
+            return TriggerState.waiting
+        elif all("skipped" in need_exist[job] for job in need_exist):
+            return TriggerState.skipped
+        elif self.trigger_rule == TriggerRules.all_done:
+            return TriggerState.passed
+        elif self.trigger_rule == TriggerRules.all_success:
+            rs = all(
+                k not in need_exist[job]
+                for k in ("errors", "skipped")
+                for job in need_exist
+            )
+        elif self.trigger_rule == TriggerRules.all_failed:
+            rs = all("errors" in need_exist[job] for job in need_exist)
+        elif self.trigger_rule == TriggerRules.one_success:
+            rs = sum(
+                k not in need_exist[job]
+                for k in ("errors", "skipped")
+                for job in need_exist
+            ) + 1 == len(self.needs)
+        elif self.trigger_rule == TriggerRules.one_failed:
+            rs = sum("errors" in need_exist[job] for job in need_exist) == 1
+        elif self.trigger_rule == TriggerRules.none_skipped:
+            rs = all("skipped" not in need_exist[job] for job in need_exist)
+        elif self.trigger_rule == TriggerRules.none_failed:
+            rs = all("errors" not in need_exist[job] for job in need_exist)
+        else:  # pragma: no cov
+            raise NotImplementedError(
+                f"Trigger rule: {self.trigger_rule} does not support yet."
+            )
+        return make_return(rs)
+
+    def is_skipped(self, params: DictData | None = None) -> bool:
+        """Return true if condition of this job do not correct. This process
+        use build-in eval function to execute the if-condition.
+
+        :raise JobException: When it has any error raise from the eval
+            condition statement.
+        :raise JobException: When return type of the eval condition statement
+            does not return with boolean type.
+
+        :param params: (DictData) A parameters that want to pass to condition
+            template.
+
         :rtype: bool
         """
-        return all(need in jobs for need in self.needs)
+        if self.condition is None:
+            return False
+
+        params: DictData = {} if params is None else params
+
+        try:
+            # WARNING: The eval build-in function is very dangerous. So, it
+            #   should use the `re` module to validate eval-string before
+            #   running.
+            rs: bool = eval(
+                param2template(self.condition, params), globals() | params, {}
+            )
+            if not isinstance(rs, bool):
+                raise TypeError("Return type of condition does not be boolean")
+            return not rs
+        except Exception as err:
+            raise JobException(f"{err.__class__.__name__}: {err}") from err
 
     def set_outputs(self, output: DictData, to: DictData) -> DictData:
         """Set an outputs from execution process to the received context. The
@@ -436,7 +526,9 @@ class Job(BaseModel):
             {"errors": output.pop("errors", {})} if "errors" in output else {}
         )
 
-        if self.strategy.is_set():
+        if "SKIP" in output:  # pragma: no cov
+            to["jobs"][_id] = output["SKIP"]
+        elif self.strategy.is_set():
             to["jobs"][_id] = {"strategies": output, **errors}
         else:
             _output = output.get(next(iter(output), "FIRST"), {})
@@ -458,8 +550,8 @@ class Job(BaseModel):
         multithread on this metrics to the `stages` field of this job.
 
         :param params: An input parameters that use on job execution.
-        :param run_id: A job running ID for this execution.
-        :param parent_run_id: A parent workflow running ID for this release.
+        :param run_id: (str) A job running ID.
+        :param parent_run_id: (str) A parent workflow running ID.
         :param result: (Result) A result object for keeping context and status
             data.
         :param event: (Event) An event manager that pass to the
@@ -559,6 +651,7 @@ def local_execute_strategy(
 
         if stage.is_skipped(params=context):
             result.trace.info(f"[STAGE]: Skip stage: {stage.iden!r}")
+            stage.set_outputs(output={"skipped": True}, to=context)
             continue
 
         if event and event.is_set():
@@ -623,9 +716,6 @@ def local_execute_strategy(
                 },
             )
 
-        # NOTE: Remove the current stage object for saving memory.
-        del stage
-
     return result.catch(
         status=Status.SUCCESS,
         context={
@@ -680,7 +770,17 @@ def local_execute(
 
         for strategy in job.strategy.make():
 
-            # TODO: stop and raise error if the event was set.
+            if event and event.is_set():  # pragma: no cov
+                return result.catch(
+                    status=Status.FAILED,
+                    context={
+                        "errors": JobException(
+                            "Job strategy was canceled from event that had set "
+                            "before strategy execution."
+                        ).to_dict()
+                    },
+                )
+
             local_execute_strategy(
                 job=job,
                 strategy=strategy,
@@ -694,12 +794,22 @@ def local_execute(
 
     fail_fast_flag: bool = job.strategy.fail_fast
     ls: str = "Fail-Fast" if fail_fast_flag else "All-Completed"
-
     result.trace.info(
         f"[JOB]: Start multithreading: {job.strategy.max_parallel} threads "
         f"with {ls} mode."
     )
 
+    if event and event.is_set():  # pragma: no cov
+        return result.catch(
+            status=Status.FAILED,
+            context={
+                "errors": JobException(
+                    "Job strategy was canceled from event that had set "
+                    "before strategy execution."
+                ).to_dict()
+            },
+        )
+
     # IMPORTANT: Start running strategy execution by multithreading because
     #   it will run by strategy values without waiting previous execution.
     with ThreadPoolExecutor(

ddeutil/workflow/stages.py

@@ -41,7 +41,7 @@ from inspect import Parameter
 from pathlib import Path
 from subprocess import CompletedProcess
 from textwrap import dedent
-from typing import Optional, Union
+from typing import Annotated, Optional, Union
 
 from pydantic import BaseModel, Field
 from pydantic.functional_validators import model_validator
@@ -230,7 +230,10 @@ class BaseStage(BaseModel, ABC):
 
             ... (iii) to: {
                         'stages': {
-                            '<stage-id>': {'outputs': {'foo': 'bar'}}
+                            '<stage-id>': {
+                                'outputs': {'foo': 'bar'},
+                                'skipped': False
+                            }
                         }
                     }
 
@@ -255,8 +258,12 @@ class BaseStage(BaseModel, ABC):
         errors: DictData = (
             {"errors": output.pop("errors", {})} if "errors" in output else {}
         )
-
-        to["stages"][_id] = {"outputs": output, **errors}
+        skipping: dict[str, bool] = (
+            {"skipped": output.pop("skipped", False)}
+            if "skipped" in output
+            else {}
+        )
+        to["stages"][_id] = {"outputs": output, **skipping, **errors}
         return to
 
     def is_skipped(self, params: DictData | None = None) -> bool:
@@ -539,19 +546,11 @@ class PyStage(BaseStage):
 
         :rtype: DictData
         """
-        # NOTE: The output will fileter unnecessary keys from locals.
-        lc: DictData = output.get("locals", {})
+        lc: DictData = output.pop("locals", {})
+        gb: DictData = output.pop("globals", {})
         super().set_outputs(
-            (
-                {k: lc[k] for k in self.filter_locals(lc)}
-                | ({"errors": output["errors"]} if "errors" in output else {})
-            ),
-            to=to,
+            {k: lc[k] for k in self.filter_locals(lc)} | output, to=to
         )
-
-        # NOTE: Override value that changing from the globals that pass via the
-        #   exec function.
-        gb: DictData = output.get("globals", {})
         to.update({k: gb[k] for k in to if k in gb})
         return to
 
@@ -572,17 +571,13 @@ class PyStage(BaseStage):
                 run_id=gen_id(self.name + (self.id or ""), unique=True)
             )
 
-        # NOTE: Replace the run statement that has templating value.
-        run: str = param2template(dedent(self.run), params)
-
-        # NOTE: create custom globals value that will pass to exec function.
-        _globals: DictData = (
+        lc: DictData = {}
+        gb: DictData = (
             globals()
             | params
             | param2template(self.vars, params)
             | {"result": result}
         )
-        lc: DictData = {}
 
         # NOTE: Start exec the run statement.
         result.trace.info(f"[STAGE]: Py-Execute: {self.name}")
@@ -591,14 +586,12 @@ class PyStage(BaseStage):
             "check your statement be safe before execute."
         )
 
-        # TODO: Add Python systax wrapper for checking dangerous code before run
-        #   this statement.
         # WARNING: The exec build-in function is very dangerous. So, it
         #   should use the re module to validate exec-string before running.
-        exec(run, _globals, lc)
+        exec(param2template(dedent(self.run), params), gb, lc)
 
         return result.catch(
-            status=Status.SUCCESS, context={"locals": lc, "globals": _globals}
+            status=Status.SUCCESS, context={"locals": lc, "globals": gb}
         )
 
 
@@ -795,7 +788,9 @@ class ParallelStage(BaseStage):  # pragma: no cov
         ... }
     """
 
-    parallel: dict[str, list[Stage]] = Field()
+    parallel: dict[str, list[Stage]] = Field(
+        description="A mapping of parallel branch ID.",
+    )
     max_parallel_core: int = Field(default=2)
 
     @staticmethod
@@ -807,9 +802,10 @@ class ParallelStage(BaseStage):  # pragma: no cov
     ) -> DictData:
         """Task execution method for passing a branch to each thread.
 
-        :param branch:
-        :param params:
-        :param result:
+        :param branch: A branch ID.
+        :param params: A parameter data that want to use in this execution.
+        :param result: (Result) A result object for keeping context and status
+            data.
         :param stages:
 
         :rtype: DictData
@@ -1008,7 +1004,7 @@ class IfStage(BaseStage):  # pragma: no cov
 
     """
 
-    case: str
+    case: str = Field(description="A case condition for routing.")
     match: list[dict[str, Union[str, Stage]]]
 
     def execute(
@@ -1016,6 +1012,18 @@ class IfStage(BaseStage):  # pragma: no cov
     ) -> Result: ...
 
 
+class RaiseStage(BaseStage):  # pragma: no cov
+    message: str = Field(
+        description="An error message that want to raise",
+        alias="raise",
+    )
+
+    def execute(
+        self, params: DictData, *, result: Result | None = None
+    ) -> Result:
+        raise StageException(self.message)
+
+
 # TODO: Not implement this stages yet
 class HookStage(BaseStage):  # pragma: no cov
     hook: str
@@ -1050,6 +1058,11 @@ class VirtualPyStage(PyStage):  # pragma: no cov
 
     def create_py_file(self, py: str, run_id: str | None): ...
 
+    def execute(
+        self, params: DictData, *, result: Result | None = None
+    ) -> Result:
+        return super().execute(params, result=result)
+
 
 # TODO: Not implement this stages yet
 class SensorStage(BaseStage):  # pragma: no cov
@@ -1064,12 +1077,16 @@ class SensorStage(BaseStage):  # pragma: no cov
 #   From the current build-in stages, they do not have stage that have the same
 #   fields that because of parsing on the Job's stages key.
 #
-Stage = Union[
-    EmptyStage,
-    BashStage,
-    CallStage,
-    TriggerStage,
-    ForEachStage,
-    ParallelStage,
-    PyStage,
+Stage = Annotated[
+    Union[
+        EmptyStage,
+        BashStage,
+        CallStage,
+        TriggerStage,
+        ForEachStage,
+        ParallelStage,
+        PyStage,
+        RaiseStage,
+    ],
+    Field(union_mode="smart"),
 ]

ddeutil/workflow/templates.py

@@ -18,7 +18,7 @@ try:
 except ImportError:
     from typing_extensions import ParamSpec
 
-from ddeutil.core import getdot, hasdot, import_string
+from ddeutil.core import getdot, import_string
 from ddeutil.io import search_env_replace
 
 from .__types import DictData, Re
@@ -59,7 +59,8 @@ def custom_filter(name: str) -> Callable[P, FilterFunc]:
     """Custom filter decorator function that set function attributes, ``filter``
     for making filter registries variable.
 
-    :param: name: A filter name for make different use-case of a function.
+    :param: name: (str) A filter name for make different use-case of a function.
+
     :rtype: Callable[P, FilterFunc]
     """
 
@@ -108,7 +109,7 @@ def get_args_const(
 ) -> tuple[str, list[Constant], dict[str, Constant]]:
     """Get arguments and keyword-arguments from function calling string.
 
-    :param expr: An expr string value.
+    :param expr: (str) An expr string value.
 
     :rtype: tuple[str, list[Constant], dict[str, Constant]]
     """
@@ -154,7 +155,7 @@ def get_args_from_filter(
     and validate it with the filter functions mapping dict.
 
     :param ft:
-    :param filters:
+    :param filters: A mapping of filter registry.
 
     :rtype: tuple[str, FilterRegistry, list[Any], dict[Any, Any]]
     """
@@ -185,7 +186,7 @@ def map_post_filter(
 
     :param value: A string value that want to map with filter function.
     :param post_filter: A list of post-filter function name.
-    :param filters: A filter registry.
+    :param filters: A mapping of filter registry.
 
     :rtype: T
     """
@@ -203,8 +204,8 @@ def map_post_filter(
         except Exception as err:
             logger.warning(str(err))
             raise UtilException(
-                f"The post-filter function: {func_name} does not fit with "
-                f"{value} (type: {type(value).__name__})."
+                f"The post-filter: {func_name!r} does not fit with {value!r} "
+                f"(type: {type(value).__name__})."
             ) from None
     return value
 
@@ -258,10 +259,10 @@ def str2template(
     with the workflow parameter types that is `str`, `int`, `datetime`, and
     `list`.
 
-    :param value: A string value that want to map with params
-    :param params: A parameter value that getting with matched regular
-        expression.
-    :param filters:
+    :param value: (str) A string value that want to map with params.
+    :param params: (DictData) A parameter value that getting with matched
+        regular expression.
+    :param filters: A mapping of filter registry.
 
     :rtype: str
     """
@@ -281,11 +282,14 @@ def str2template(
             for i in (found.post_filters.strip().removeprefix("|").split("|"))
             if i != ""
         ]
-        if not hasdot(caller, params):
-            raise UtilException(f"The params does not set caller: {caller!r}.")
 
         # NOTE: from validate step, it guarantees that caller exists in params.
-        getter: Any = getdot(caller, params)
+        try:
+            getter: Any = getdot(caller, params)
+        except ValueError as err:
+            raise UtilException(
+                f"Params does not set caller: {caller!r}."
+            ) from err
 
         # NOTE:
         #   If type of getter caller is not string type, and it does not use to
@@ -301,25 +305,33 @@ def str2template(
 
         value: str = value.replace(found.full, getter, 1)
 
+    if value == "None":
+        return None
+
     return search_env_replace(value)
 
 
-def param2template(value: T, params: DictData) -> T:
+def param2template(
+    value: T,
+    params: DictData,
+    filters: dict[str, FilterRegistry] | None = None,
+) -> T:
     """Pass param to template string that can search by ``RE_CALLER`` regular
     expression.
 
     :param value: A value that want to map with params
     :param params: A parameter value that getting with matched regular
         expression.
+    :param filters: A filter mapping for mapping with `map_post_filter` func.
 
     :rtype: T
     :returns: An any getter value from the params input.
     """
-    filters: dict[str, FilterRegistry] = make_filter_registry()
+    filters: dict[str, FilterRegistry] = filters or make_filter_registry()
     if isinstance(value, dict):
-        return {k: param2template(value[k], params) for k in value}
+        return {k: param2template(value[k], params, filters) for k in value}
     elif isinstance(value, (list, tuple, set)):
-        return type(value)([param2template(i, params) for i in value])
+        return type(value)([param2template(i, params, filters) for i in value])
     elif not isinstance(value, str):
         return value
     return str2template(value, params, filters=filters)
@@ -329,8 +341,9 @@ def param2template(value: T, params: DictData) -> T:
 def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
     """Format datetime object to string with the format.
 
-    :param value: A datetime value that want to format to string value.
-    :param fmt: A format string pattern that passing to the `dt.strftime`
+    :param value: (datetime) A datetime value that want to format to string
+        value.
+    :param fmt: (str) A format string pattern that passing to the `dt.strftime`
         method.
 
     :rtype: str
@@ -340,3 +353,9 @@ def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
     raise UtilException(
         "This custom function should pass input value with datetime type."
     )
+
+
+@custom_filter("coalesce")  # pragma: no cov
+def coalesce(value: T | None, default: Any) -> T:
+    """Coalesce with default value if the main value is None."""
+    return default if value is None else value

ddeutil/workflow/workflow.py

@@ -34,7 +34,7 @@ from .audit import Audit, get_audit
 from .conf import Loader, config, get_logger
 from .cron import On
 from .exceptions import JobException, WorkflowException
-from .job import Job
+from .job import Job, TriggerState
 from .params import Param
 from .result import Result, Status
 from .templates import has_template, param2template
@@ -882,8 +882,6 @@ class Workflow(BaseModel):
                 f"workflow."
             )
 
-        result.trace.info(f"[WORKFLOW]: Start execute job: {job_id!r}")
-
         if event and event.is_set():  # pragma: no cov
             raise WorkflowException(
                 "Workflow job was canceled from event that had set before "
@@ -898,15 +896,20 @@ class Workflow(BaseModel):
         #
         try:
             job: Job = self.jobs[job_id]
-            job.set_outputs(
-                job.execute(
-                    params=params,
-                    run_id=result.run_id,
-                    parent_run_id=result.parent_run_id,
-                    event=event,
-                ).context,
-                to=params,
-            )
+            if job.is_skipped(params=params):
+                result.trace.info(f"[JOB]: Skip job: {job_id!r}")
+                job.set_outputs(output={"SKIP": {"skipped": True}}, to=params)
+            else:
+                result.trace.info(f"[JOB]: Start execute job: {job_id!r}")
+                job.set_outputs(
+                    job.execute(
+                        params=params,
+                        run_id=result.run_id,
+                        parent_run_id=result.parent_run_id,
+                        event=event,
+                    ).context,
+                    to=params,
+                )
         except JobException as err:
             result.trace.error(f"[WORKFLOW]: {err.__class__.__name__}: {err}")
             if raise_error:
@@ -1054,11 +1057,20 @@ class Workflow(BaseModel):
                 job_id: str = job_queue.get()
                 job: Job = self.jobs[job_id]
 
-                if not job.check_needs(context["jobs"]):
+                if (check := job.check_needs(context["jobs"])).is_waiting():
                     job_queue.task_done()
                     job_queue.put(job_id)
                     time.sleep(0.15)
                     continue
+                elif check == TriggerState.failed:  # pragma: no cov
+                    raise WorkflowException(
+                        "Check job trigger rule was failed."
+                    )
+                elif check == TriggerState.skipped:  # pragma: no cov
+                    result.trace.info(f"[JOB]: Skip job: {job_id!r}")
+                    job.set_outputs({"SKIP": {"skipped": True}}, to=context)
+                    job_queue.task_done()
+                    continue
 
                 # NOTE: Start workflow job execution with deep copy context data
                 #   before release.
@@ -1149,11 +1161,18 @@ class Workflow(BaseModel):
             job: Job = self.jobs[job_id]
 
             # NOTE: Waiting dependency job run successful before release.
-            if not job.check_needs(context["jobs"]):
+            if (check := job.check_needs(context["jobs"])).is_waiting():
                 job_queue.task_done()
                 job_queue.put(job_id)
                 time.sleep(0.075)
                 continue
+            elif check == TriggerState.failed:  # pragma: no cov
+                raise WorkflowException("Check job trigger rule was failed.")
+            elif check == TriggerState.skipped:  # pragma: no cov
+                result.trace.info(f"[JOB]: Skip job: {job_id!r}")
+                job.set_outputs({"SKIP": {"skipped": True}}, to=context)
+                job_queue.task_done()
+                continue
 
             # NOTE: Start workflow job execution with deep copy context data
             #   before release. This job execution process will run until

{ddeutil_workflow-0.0.38.dist-info → ddeutil_workflow-0.0.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.38
+Version: 0.0.39
 Summary: Lightweight workflow orchestration
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -130,7 +130,7 @@ flowchart LR
 > - [Google **Workflows**](https://cloud.google.com/workflows)
 > - [AWS **Step Functions**](https://aws.amazon.com/step-functions/)
 
-## :round_pushpin: Installation
+## 📦 Installation
 
 This project need `ddeutil` and `ddeutil-io` extension namespace packages.
 If you want to install this package with application add-ons, you should add

{ddeutil_workflow-0.0.38.dist-info → ddeutil_workflow-0.0.39.dist-info}/RECORD

@@ -1,22 +1,22 @@
-ddeutil/workflow/__about__.py,sha256=nUvuf0abbrBoZoHVyqcyvfYEilSx2oTLDwA7Az8m5UU,28
+ddeutil/workflow/__about__.py,sha256=lWjP4jp8-3HcVlFUQBiNI9hwnZOyEL0S-RmG6USjiag,28
 ddeutil/workflow/__cron.py,sha256=3i-wmjTlh0ADCzN9pLKaWHzJkXzC72aIBmVEQSbyCCE,26895
 ddeutil/workflow/__init__.py,sha256=hIM2Ha-7F3YF3aLsu4IY3N-UvD_EE1ai6DO6WL2mILg,1908
-ddeutil/workflow/__types.py,sha256=CK1jfzyHP9P-MB0ElhpJZ59ZFGJC9MkQuAop5739_9k,4304
-ddeutil/workflow/audit.py,sha256=wx70RKRdHj1d2431ilpt9OPTInMByjqXkYff7l5pvF4,8230
-ddeutil/workflow/caller.py,sha256=oFjB9zpG93aeVd-T_4QMz5kk64lo-iyxaPmCo_1_AzU,5693
+ddeutil/workflow/__types.py,sha256=8jBdbfb3aZSetjz0mvNrpGHwwxJff7mK8_4v41cLqlc,4316
+ddeutil/workflow/audit.py,sha256=BpzLI6ZKXi6xQO8C2sAHxSi8RAfF31dMPdjn3DbYlw8,8364
+ddeutil/workflow/caller.py,sha256=M7_nan1DbRUAHEIQoQc1qIX4AHgI5fKFNx0KDbzhDMk,5736
 ddeutil/workflow/conf.py,sha256=MHzBeLZukFeIQ-YhxOz5uKCnGYqbhYdpwAEh9A9h_OM,12216
-ddeutil/workflow/context.py,sha256=fdGUuQnsjDCDGibPHKMWc5PA3pArHpfv6Aff2nVvZ0U,1618
+ddeutil/workflow/context.py,sha256=vsk4JQL7t3KsnKPfshw3O7YrPFo2h4rnnNd3B-G9Kj4,1700
 ddeutil/workflow/cron.py,sha256=j8EeoHst70toRfnD_frix41vrI-eLYVJkZ9yeJtpfnI,8871
 ddeutil/workflow/exceptions.py,sha256=fO37f9p7lOjIJgVOpKE_1X44yJTwBepyukZV9a7NNm4,1241
-ddeutil/workflow/job.py,sha256=3oDY-THXYMvmW0kKkHN2VMJyq0u0_4s9H0eX40Iiw6E,24267
+ddeutil/workflow/job.py,sha256=LCQf_3gyTmnj6aAQ0ksz4lJxU10-F5MfVFHczkWt_VE,28669
 ddeutil/workflow/logs.py,sha256=mAKQjNri-oourd3dBLLG3Fqoo4QG27U9IO2h6IqCOU0,10196
 ddeutil/workflow/params.py,sha256=qw9XJyjh2ocf9pf6h_XiYHLOvQN4R5TMqPElmItKnRM,8019
 ddeutil/workflow/result.py,sha256=cDkItrhpzZfMS1Oj8IZX8O-KBD4KZYDi43XJZvvC3Gc,4318
 ddeutil/workflow/scheduler.py,sha256=YMebYpNjqg6RWaE17sicwM3uthupeBGSGCnDGy4aKd8,26286
-ddeutil/workflow/stages.py,sha256=aHMPOPxRiSo2jBFqQOlua01sQ18RMvjaKk2Dotnu7v4,36480
-ddeutil/workflow/templates.py,sha256=A0JgZFGkBv-AX-EskZj656nG5zFd3j1PpLpyXihf6Xg,10967
+ddeutil/workflow/stages.py,sha256=ONBR7GjgLEbA21wNioBrhOucwqj6M1v2ht5JhipoWSg,36994
+ddeutil/workflow/templates.py,sha256=yA2xgrSXcxfBxNT2hc6v06HkVY_0RKsc1UwdJRip9EE,11554
 ddeutil/workflow/utils.py,sha256=Fz5y-LK_JfikDfvMKcFaxad_VvCnr7UC2C9KFCbzPNA,7105
-ddeutil/workflow/workflow.py,sha256=v6LTbXZ34yWmddZquBxpahxCW1PFb3177q1T3Ssf5C0,46636
+ddeutil/workflow/workflow.py,sha256=dbOnLx54KtPERuv5M_QU2nZiyiAnzv6pApX49rJi2eI,47833
 ddeutil/workflow/api/__init__.py,sha256=F53NMBWtb9IKaDWkPU5KvybGGfKAcbehgn6TLBwHuuM,21
 ddeutil/workflow/api/api.py,sha256=gGQtqkzyJNaJIfka_w2M1lrCS3Ep46re2Dznsk9RxYQ,5191
 ddeutil/workflow/api/log.py,sha256=NMTnOnsBrDB5129329xF2myLdrb-z9k1MQrmrP7qXJw,1818
@@ -26,8 +26,8 @@ ddeutil/workflow/api/routes/job.py,sha256=YVta083i8vU8-o4WdKFwDpfdC9vN1dZ6goZSmN
 ddeutil/workflow/api/routes/logs.py,sha256=uEQ6k5PwRg-k0eSiSFArXfyeDq5xzepxILrRnwgAe1I,5373
 ddeutil/workflow/api/routes/schedules.py,sha256=uWYDOwlV8w56hKQmfkQFwdZ6t2gZSJeCdBIzMmJenAQ,4824
 ddeutil/workflow/api/routes/workflows.py,sha256=KVywA7vD9b4QrfmWBdSFF5chj34yJe1zNCzl6iBMeGI,4538
-ddeutil_workflow-0.0.38.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.38.dist-info/METADATA,sha256=haHYX6Ui8EXTi2qJA5x_SOWSmVqmXRKsHLdgyMp7Two,19511
-ddeutil_workflow-0.0.38.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-ddeutil_workflow-0.0.38.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.38.dist-info/RECORD,,
+ddeutil_workflow-0.0.39.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.39.dist-info/METADATA,sha256=r6e0p1K2dUtDOl5XJa-FqxtqgcRzJz7gZWcw9HuhWDc,19500
+ddeutil_workflow-0.0.39.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+ddeutil_workflow-0.0.39.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.39.dist-info/RECORD,,