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

ddeutil/workflow/stages.py

@@ -3,9 +3,9 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-"""Stages module include all stage model that use be the minimum execution layer
-of this workflow engine. The stage handle the minimize task that run in some
-thread (same thread at its job owner) that mean it is the lowest executor that
+"""Stages module include all stage model that implemented to be the minimum execution
+layer of this workflow core engine. The stage handle the minimize task that run
+in a thread (same thread at its job owner) that mean it is the lowest executor that
 you can track logs.
 
     The output of stage execution only return SUCCESS or CANCEL status because
@@ -17,9 +17,11 @@ the stage execution method.
 
     Execution   --> Ok      ┬--( handler )--> Result with `SUCCESS` or `CANCEL`
                             |
-                            ╰--( handler )--> Result with `FAILED` (Set `raise_error` flag)
+                            ├--( handler )--> Result with `FAILED` (Set `raise_error` flag)
+                            |
+                            ╰--( handler )---> Result with `SKIP`
 
-                --> Error   ---( handler )--> Raise StageException(...)
+                --> Error   ---( handler )--> Raise StageError(...)
 
     On the context I/O that pass to a stage object at execute process. The
 execute method receives a `params={"params": {...}}` value for passing template
@@ -55,21 +57,40 @@ from textwrap import dedent
 from threading import Event
 from typing import Annotated, Any, Optional, TypeVar, Union, get_type_hints
 
-from pydantic import BaseModel, Field
-from pydantic.functional_validators import model_validator
+from ddeutil.core import str2list
+from pydantic import BaseModel, Field, ValidationError
+from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
+from . import StageCancelError, StageRetryError
 from .__types import DictData, DictStr, StrOrInt, StrOrNone, TupleStr
 from .conf import dynamic, pass_env
-from .exceptions import StageException, to_dict
-from .result import CANCEL, FAILED, SUCCESS, WAIT, Result, Status
-from .reusables import TagFunc, extract_call, not_in_template, param2template
+from .errors import StageError, StageSkipError, to_dict
+from .result import (
+    CANCEL,
+    FAILED,
+    SKIP,
+    SUCCESS,
+    WAIT,
+    Result,
+    Status,
+    get_status_from_error,
+    validate_statuses,
+)
+from .reusables import (
+    TagFunc,
+    create_model_from_caller,
+    extract_call,
+    not_in_template,
+    param2template,
+)
 from .utils import (
     delay,
     dump_all,
     filter_func,
     gen_id,
     make_exec,
+    to_train,
 )
 
 T = TypeVar("T")
@@ -100,6 +121,12 @@ class BaseStage(BaseModel, ABC):
     name: str = Field(
         description="A stage name that want to logging when start execution.",
     )
+    desc: StrOrNone = Field(
+        default=None,
+        description=(
+            "A stage description that use to logging when start execution."
+        ),
+    )
     condition: StrOrNone = Field(
         default=None,
         description=(
@@ -118,6 +145,14 @@ class BaseStage(BaseModel, ABC):
         """
         return self.id or self.name
 
+    @field_validator("desc", mode="after")
+    def ___prepare_desc__(cls, value: str) -> str:
+        """Prepare description string that was created on a template.
+
+        :rtype: str
+        """
+        return dedent(value.lstrip("\n"))
+
     @model_validator(mode="after")
     def __prepare_running_id(self) -> Self:
         """Prepare stage running ID that use default value of field and this
@@ -129,14 +164,12 @@ class BaseStage(BaseModel, ABC):
 
         :rtype: Self
         """
-
         # VALIDATE: Validate stage id and name should not dynamic with params
         #   template. (allow only matrix)
         if not_in_template(self.id) or not_in_template(self.name):
             raise ValueError(
                 "Stage name and ID should only template with 'matrix.'"
             )
-
         return self
 
     @abstractmethod
@@ -169,47 +202,41 @@ class BaseStage(BaseModel, ABC):
         parent_run_id: StrOrNone = None,
         result: Optional[Result] = None,
         event: Optional[Event] = None,
-        raise_error: Optional[bool] = None,
     ) -> Union[Result, DictData]:
         """Handler stage execution result from the stage `execute` method.
 
-            This stage exception handler still use ok-error concept, but it
-        allows you force catching an output result with error message by
-        specific environment variable,`WORKFLOW_CORE_STAGE_RAISE_ERROR` or set
-        `raise_error` parameter to True.
+            This handler strategy will catch and mapping message to the result
+        context data before returning. All possible status that will return from
+        this method be:
 
-            Execution   --> Ok      --> Result
+            Handler     --> Ok      --> Result
                                         |-status: SUCCESS
                                         ╰-context:
                                             ╰-outputs: ...
 
                         --> Ok      --> Result
-                                        |-status: CANCEL
-                                        ╰-errors:
-                                            |-name: ...
-                                            ╰-message: ...
+                                        ╰-status: CANCEL
 
-                        --> Ok      --> Result (if `raise_error` was set)
+                        --> Ok      --> Result
+                                        ╰-status: SKIP
+
+                        --> Ok      --> Result
                                         |-status: FAILED
                                         ╰-errors:
                                             |-name: ...
                                             ╰-message: ...
 
-                        --> Error   --> Raise StageException(...)
-
             On the last step, it will set the running ID on a return result
         object from the current stage ID before release the final result.
 
         :param params: (DictData) A parameter data.
-        :param run_id: (str) A running stage ID.
-        :param parent_run_id: (str) A parent running ID.
+        :param run_id: (str) A running stage ID. (Default is None)
+        :param parent_run_id: (str) A parent running ID. (Default is None)
         :param result: (Result) A result object for keeping context and status
             data before execution.
+            (Default is None)
         :param event: (Event) An event manager that pass to the stage execution.
-        :param raise_error: (bool) A flag that all this method raise error
-
-        :raise StageException: If the raise_error was set and the execution
-            raise any error.
+            (Default is None)
 
         :rtype: Result
         """
@@ -221,21 +248,71 @@ class BaseStage(BaseModel, ABC):
             extras=self.extras,
         )
         try:
-            return self.execute(params, result=result, event=event)
+            result.trace.info(
+                f"[STAGE]: Handler {to_train(self.__class__.__name__)}: "
+                f"{self.name!r}."
+            )
+            if self.desc:
+                result.trace.debug(f"[STAGE]: Description:||{self.desc}||")
+
+            if self.is_skipped(params):
+                raise StageSkipError(
+                    f"Skip because condition {self.condition} was valid."
+                )
+            # NOTE: Start call wrapped execution method that will use custom
+            #   execution before the real execution from inherit stage model.
+            result_caught: Result = self.__execute(
+                params, result=result, event=event
+            )
+            if result_caught.status == WAIT:
+                raise StageError(
+                    "Status from execution should not return waiting status."
+                )
+            return result_caught
+
+        # NOTE: Catch this error in this line because the execution can raise
+        #   this exception class at other location.
+        except (
+            StageSkipError,
+            StageCancelError,
+            StageError,
+        ) as e:  # pragma: no cov
+            result.trace.info(
+                f"[STAGE]: Handler:||{e.__class__.__name__}: {e}||"
+                f"{traceback.format_exc()}"
+            )
+            return result.catch(
+                status=get_status_from_error(e),
+                context=(
+                    None
+                    if isinstance(e, StageSkipError)
+                    else {"errors": e.to_dict()}
+                ),
+            )
         except Exception as e:
-            e_name: str = e.__class__.__name__
             result.trace.error(
-                f"[STAGE]: Error Handler:||{e_name}:||{e}||"
+                f"[STAGE]: Error Handler:||{e.__class__.__name__}: {e}||"
                 f"{traceback.format_exc()}"
             )
-            if dynamic("stage_raise_error", f=raise_error, extras=self.extras):
-                if isinstance(e, StageException):
-                    raise
-                raise StageException(
-                    f"{self.__class__.__name__}: {e_name}: {e}"
-                ) from e
             return result.catch(status=FAILED, context={"errors": to_dict(e)})
 
+    def __execute(
+        self, params: DictData, result: Result, event: Optional[Event]
+    ) -> Result:
+        """Wrapped the execute method before returning to handler execution.
+
+        :param params: (DictData) A parameter data that want to use in this
+            execution.
+        :param result: (Result) A result object for keeping context and status
+            data.
+        :param event: (Event) An event manager that use to track parent execute
+            was not force stopped.
+
+        :rtype: Result
+        """
+        result.catch(status=WAIT)
+        return self.execute(params, result=result, event=event)
+
     def set_outputs(self, output: DictData, to: DictData) -> DictData:
         """Set an outputs from execution result context to the received context
         with a `to` input parameter. The result context from stage execution
@@ -283,20 +360,15 @@ class BaseStage(BaseModel, ABC):
         ):
             return to
 
-        output: DictData = output.copy()
+        _id: str = self.gen_id(params=to)
+        output: DictData = copy.deepcopy(output)
         errors: DictData = (
-            {"errors": output.pop("errors", {})} if "errors" in output else {}
+            {"errors": output.pop("errors")} if "errors" in output else {}
         )
-        skipping: dict[str, bool] = (
-            {"skipped": output.pop("skipped", False)}
-            if "skipped" in output
-            else {}
+        status: dict[str, Status] = (
+            {"status": output.pop("status")} if "status" in output else {}
         )
-        to["stages"][self.gen_id(params=to)] = {
-            "outputs": copy.deepcopy(output),
-            **skipping,
-            **errors,
-        }
+        to["stages"][_id] = {"outputs": output} | errors | status
         return to
 
     def get_outputs(self, output: DictData) -> DictData:
@@ -325,14 +397,15 @@ class BaseStage(BaseModel, ABC):
         :param params: (DictData) A parameters that want to pass to condition
             template.
 
-        :raise StageException: When it has any error raise from the eval
+        :raise StageError: When it has any error raise from the eval
             condition statement.
-        :raise StageException: When return type of the eval condition statement
+        :raise StageError: When return type of the eval condition statement
             does not return with boolean type.
 
         :rtype: bool
         """
-        if self.condition is None:
+        # NOTE: Support for condition value is empty string.
+        if not self.condition:
             return False
 
         try:
@@ -348,13 +421,13 @@ class BaseStage(BaseModel, ABC):
                 raise TypeError("Return type of condition does not be boolean")
             return not rs
         except Exception as e:
-            raise StageException(f"{e.__class__.__name__}: {e}") from e
+            raise StageError(f"{e.__class__.__name__}: {e}") from e
 
     def gen_id(self, params: DictData) -> str:
         """Generate stage ID that dynamic use stage's name if it ID does not
         set.
 
-        :param params: A parameter data.
+        :param params: (DictData) A parameter or context data.
 
         :rtype: str
         """
@@ -366,8 +439,16 @@ class BaseStage(BaseModel, ABC):
             )
         )
 
+    @property
+    def is_nested(self) -> bool:
+        """Return true if this stage is nested stage.
+
+        :rtype: bool
+        """
+        return False
 
-class BaseAsyncStage(BaseStage):
+
+class BaseAsyncStage(BaseStage, ABC):
     """Base Async Stage model to make any stage model allow async execution for
     optimize CPU and Memory on the current node. If you want to implement any
     custom async stage, you can inherit this class and implement
@@ -377,18 +458,6 @@ class BaseAsyncStage(BaseStage):
     model.
     """
 
-    @abstractmethod
-    def execute(
-        self,
-        params: DictData,
-        *,
-        result: Optional[Result] = None,
-        event: Optional[Event] = None,
-    ) -> Result:
-        raise NotImplementedError(
-            "Async Stage should implement `execute` method."
-        )
-
     @abstractmethod
     async def axecute(
         self,
@@ -421,7 +490,6 @@ class BaseAsyncStage(BaseStage):
         parent_run_id: StrOrNone = None,
         result: Optional[Result] = None,
         event: Optional[Event] = None,
-        raise_error: Optional[bool] = None,
     ) -> Result:
         """Async Handler stage execution result from the stage `execute` method.
 
@@ -431,7 +499,6 @@ class BaseAsyncStage(BaseStage):
         :param result: (Result) A Result instance for return context and status.
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
-        :param raise_error: (bool) A flag that all this method raise error
 
         :rtype: Result
         """
@@ -442,22 +509,142 @@ class BaseAsyncStage(BaseStage):
             id_logic=self.iden,
             extras=self.extras,
         )
-
         try:
-            rs: Result = await self.axecute(params, result=result, event=event)
-            return rs
-        except Exception as e:
-            e_name: str = e.__class__.__name__
-            await result.trace.aerror(f"[STAGE]: Handler {e_name}: {e}")
-            if dynamic("stage_raise_error", f=raise_error, extras=self.extras):
-                if isinstance(e, StageException):
-                    raise
-                raise StageException(
-                    f"{self.__class__.__name__}: {e_name}: {e}"
-                ) from None
+            await result.trace.ainfo(
+                f"[STAGE]: Handler {to_train(self.__class__.__name__)}: "
+                f"{self.name!r}."
+            )
+            if self.desc:
+                await result.trace.adebug(
+                    f"[STAGE]: Description:||{self.desc}||"
+                )
 
+            if self.is_skipped(params=params):
+                raise StageSkipError(
+                    f"Skip because condition {self.condition} was valid."
+                )
+
+            # NOTE: Start call wrapped execution method that will use custom
+            #   execution before the real execution from inherit stage model.
+            result_caught: Result = await self.__axecute(
+                params, result=result, event=event
+            )
+            if result_caught.status == WAIT:
+                raise StageError(
+                    "Status from execution should not return waiting status."
+                )
+            return result_caught
+
+        # NOTE: Catch this error in this line because the execution can raise
+        #   this exception class at other location.
+        except (
+            StageSkipError,
+            StageCancelError,
+            StageError,
+        ) as e:  # pragma: no cov
+            await result.trace.ainfo(
+                f"[STAGE]: Skip Handler:||{e.__class__.__name__}: {e}||"
+                f"{traceback.format_exc()}"
+            )
+            return result.catch(
+                status=get_status_from_error(e),
+                context=(
+                    {"errors": e.to_dict()}
+                    if isinstance(e, StageError)
+                    else None
+                ),
+            )
+        except Exception as e:
+            await result.trace.aerror(
+                f"[STAGE]: Error Handler:||{e.__class__.__name__}: {e}||"
+                f"{traceback.format_exc()}"
+            )
             return result.catch(status=FAILED, context={"errors": to_dict(e)})
 
+    async def __axecute(
+        self, params: DictData, result: Result, event: Optional[Event]
+    ) -> Result:
+        """Wrapped the axecute method before returning to handler axecute.
+
+        :param params: (DictData) A parameter data that want to use in this
+            execution.
+        :param result: (Result) A result object for keeping context and status
+            data.
+        :param event: (Event) An event manager that use to track parent execute
+            was not force stopped.
+
+        :rtype: Result
+        """
+        result.catch(status=WAIT)
+        return await self.axecute(params, result=result, event=event)
+
+
+class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
+    """Base Retry Stage model that will execute again when it raises with the
+    `StageRetryError`.
+    """
+
+    retry: int = Field(
+        default=0,
+        ge=0,
+        lt=20,
+        description="Retry number if stage execution get the error.",
+    )
+
+    def __execute(
+        self,
+        params: DictData,
+        result: Result,
+        event: Optional[Event],
+    ) -> Result:
+        """Wrapped the execute method with retry strategy before returning to
+        handler execute.
+
+        :param params: (DictData) A parameter data that want to use in this
+            execution.
+        :param result: (Result) A result object for keeping context and status
+            data.
+        :param event: (Event) An event manager that use to track parent execute
+            was not force stopped.
+
+        :rtype: Result
+        """
+        current_retry: int = 0
+        with current_retry < (self.retry + 1):
+            try:
+                result.catch(status=WAIT, context={"retry": current_retry})
+                return self.execute(params, result=result, event=event)
+            except StageRetryError:
+                current_retry += 1
+        raise StageError(f"Reach the maximum of retry number: {self.retry}.")
+
+    async def __axecute(
+        self,
+        params: DictData,
+        result: Result,
+        event: Optional[Event],
+    ) -> Result:
+        """Wrapped the axecute method with retry strategy before returning to
+        handler axecute.
+
+        :param params: (DictData) A parameter data that want to use in this
+            execution.
+        :param result: (Result) A result object for keeping context and status
+            data.
+        :param event: (Event) An event manager that use to track parent execute
+            was not force stopped.
+
+        :rtype: Result
+        """
+        current_retry: int = 0
+        with current_retry < (self.retry + 1):
+            try:
+                result.catch(status=WAIT, context={"retry": current_retry})
+                return await self.axecute(params, result=result, event=event)
+            except StageRetryError:
+                current_retry += 1
+        raise StageError(f"Reach the maximum of retry number: {self.retry}.")
+
 
 class EmptyStage(BaseAsyncStage):
     """Empty stage executor that do nothing and log the `message` field to
@@ -521,12 +708,15 @@ class EmptyStage(BaseAsyncStage):
             else "..."
         )
 
-        result.trace.info(
-            f"[STAGE]: Execute Empty-Stage: {self.name!r}: ( {message} )"
-        )
+        if event and event.is_set():
+            raise StageCancelError(
+                "Execution was canceled from the event before start parallel."
+            )
+
+        result.trace.info(f"[STAGE]: Message: ( {message} )")
         if self.sleep > 0:
             if self.sleep > 5:
-                result.trace.info(f"[STAGE]: ... sleep ({self.sleep} sec)")
+                result.trace.info(f"[STAGE]: Sleep ... ({self.sleep} sec)")
             time.sleep(self.sleep)
         return result.catch(status=SUCCESS)
 
@@ -560,11 +750,16 @@ class EmptyStage(BaseAsyncStage):
             else "..."
         )
 
-        result.trace.info(f"[STAGE]: Empty-Stage: {self.name!r}: ( {message} )")
+        if event and event.is_set():
+            raise StageCancelError(
+                "Execution was canceled from the event before start parallel."
+            )
+
+        result.trace.info(f"[STAGE]: Message: ( {message} )")
         if self.sleep > 0:
             if self.sleep > 5:
                 await result.trace.ainfo(
-                    f"[STAGE]: ... sleep ({self.sleep} sec)"
+                    f"[STAGE]: Sleep ... ({self.sleep} sec)"
                 )
             await asyncio.sleep(self.sleep)
         return result.catch(status=SUCCESS)
@@ -697,19 +892,15 @@ class BashStage(BaseAsyncStage):
             run_id=gen_id(self.name + (self.id or ""), unique=True),
             extras=self.extras,
         )
-
-        result.trace.info(f"[STAGE]: Execute Shell-Stage: {self.name}")
-
         bash: str = param2template(
             dedent(self.bash.strip("\n")), params, extras=self.extras
         )
-
         with self.create_sh_file(
             bash=bash,
             env=param2template(self.env, params, extras=self.extras),
             run_id=result.run_id,
         ) as sh:
-            result.trace.debug(f"[STAGE]: ... Create `{sh[1]}` file.")
+            result.trace.debug(f"[STAGE]: Create `{sh[1]}` file.")
             rs: CompletedProcess = subprocess.run(
                 sh,
                 shell=False,
@@ -720,7 +911,7 @@ class BashStage(BaseAsyncStage):
             )
         if rs.returncode > 0:
             e: str = rs.stderr.removesuffix("\n")
-            raise StageException(
+            raise StageError(
                 f"Subprocess: {e}\n---( statement )---\n```bash\n{bash}\n```"
             )
         return result.catch(
@@ -753,17 +944,15 @@ class BashStage(BaseAsyncStage):
             run_id=gen_id(self.name + (self.id or ""), unique=True),
             extras=self.extras,
         )
-        await result.trace.ainfo(f"[STAGE]: Execute Shell-Stage: {self.name}")
         bash: str = param2template(
             dedent(self.bash.strip("\n")), params, extras=self.extras
         )
-
         async with self.async_create_sh_file(
             bash=bash,
             env=param2template(self.env, params, extras=self.extras),
             run_id=result.run_id,
         ) as sh:
-            await result.trace.adebug(f"[STAGE]: ... Create `{sh[1]}` file.")
+            await result.trace.adebug(f"[STAGE]: Create `{sh[1]}` file.")
             rs: CompletedProcess = subprocess.run(
                 sh,
                 shell=False,
@@ -775,7 +964,7 @@ class BashStage(BaseAsyncStage):
 
         if rs.returncode > 0:
             e: str = rs.stderr.removesuffix("\n")
-            raise StageException(
+            raise StageError(
                 f"Subprocess: {e}\n---( statement )---\n```bash\n{bash}\n```"
             )
         return result.catch(
@@ -882,7 +1071,6 @@ class PyStage(BaseAsyncStage):
             run_id=gen_id(self.name + (self.id or ""), unique=True),
             extras=self.extras,
         )
-
         lc: DictData = {}
         gb: DictData = (
             globals()
@@ -890,8 +1078,6 @@ class PyStage(BaseAsyncStage):
             | {"result": result}
         )
 
-        result.trace.info(f"[STAGE]: Execute Py-Stage: {self.name}")
-
         # WARNING: The exec build-in function is very dangerous. So, it
         #   should use the re module to validate exec-string before running.
         exec(
@@ -915,6 +1101,7 @@ class PyStage(BaseAsyncStage):
                         and not ismodule(gb[k])
                         and not isclass(gb[k])
                         and not isfunction(gb[k])
+                        and k in params
                     )
                 },
             },
@@ -950,8 +1137,6 @@ class PyStage(BaseAsyncStage):
             | param2template(self.vars, params, extras=self.extras)
             | {"result": result}
         )
-        await result.trace.ainfo(f"[STAGE]: Execute Py-Stage: {self.name}")
-
         # WARNING: The exec build-in function is very dangerous. So, it
         #   should use the re module to validate exec-string before running.
         exec(
@@ -972,6 +1157,7 @@ class PyStage(BaseAsyncStage):
                         and not ismodule(gb[k])
                         and not isclass(gb[k])
                         and not isfunction(gb[k])
+                        and k in params
                     )
                 },
             },
@@ -1054,7 +1240,7 @@ class CallStage(BaseAsyncStage):
         )()
 
         result.trace.info(
-            f"[STAGE]: Execute Call-Stage: {call_func.name}@{call_func.tag}"
+            f"[STAGE]: Caller Func: '{call_func.name}@{call_func.tag}'"
         )
 
         # VALIDATE: check input task caller parameters that exists before
@@ -1088,8 +1274,12 @@ class CallStage(BaseAsyncStage):
         if "result" not in sig.parameters and not has_keyword:
             args.pop("result")
 
-        args = self.parse_model_args(call_func, args, result)
+        if event and event.is_set():
+            raise StageCancelError(
+                "Execution was canceled from the event before start parallel."
+            )
 
+        args = self.validate_model_args(call_func, args, result)
         if inspect.iscoroutinefunction(call_func):
             loop = asyncio.get_event_loop()
             rs: DictData = loop.run_until_complete(
@@ -1143,7 +1333,7 @@ class CallStage(BaseAsyncStage):
         )()
 
         await result.trace.ainfo(
-            f"[STAGE]: Execute Call-Stage: {call_func.name}@{call_func.tag}"
+            f"[STAGE]: Caller Func: '{call_func.name}@{call_func.tag}'"
         )
 
         # VALIDATE: check input task caller parameters that exists before
@@ -1177,7 +1367,7 @@ class CallStage(BaseAsyncStage):
         if "result" not in sig.parameters and not has_keyword:
             args.pop("result")
 
-        args = self.parse_model_args(call_func, args, result)
+        args: DictData = self.validate_model_args(call_func, args, result)
         if inspect.iscoroutinefunction(call_func):
             rs: DictOrModel = await call_func(
                 **param2template(args, params, extras=self.extras)
@@ -1200,23 +1390,41 @@ class CallStage(BaseAsyncStage):
         return result.catch(status=SUCCESS, context=dump_all(rs, by_alias=True))
 
     @staticmethod
-    def parse_model_args(
+    def validate_model_args(
         func: TagFunc,
         args: DictData,
         result: Result,
     ) -> DictData:
-        """Parse Pydantic model from any dict data before parsing to target
-        caller function.
+        """Validate an input arguments before passing to the caller function.
 
-        :param func: A tag function that want to get typing.
-        :param args: An arguments before passing to this tag function.
+        :param func: (TagFunc) A tag function that want to get typing.
+        :param args: (DictData) An arguments before passing to this tag func.
         :param result: (Result) A result object for keeping context and status
             data.
 
         :rtype: DictData
         """
         try:
+            model_instance: BaseModel = create_model_from_caller(
+                func
+            ).model_validate(args)
+            override: DictData = dict(model_instance)
+            args.update(override)
             type_hints: dict[str, Any] = get_type_hints(func)
+            for arg in type_hints:
+
+                if arg == "return":
+                    continue
+
+                if arg.removeprefix("_") in args:
+                    args[arg] = args.pop(arg.removeprefix("_"))
+                    continue
+
+            return args
+        except ValidationError as e:
+            raise StageError(
+                "Validate argument from the caller function raise invalid type."
+            ) from e
         except TypeError as e:
             result.trace.warning(
                 f"[STAGE]: Get type hint raise TypeError: {e}, so, it skip "
@@ -1224,28 +1432,43 @@ class CallStage(BaseAsyncStage):
             )
             return args
 
-        for arg in type_hints:
 
-            if arg == "return":
-                continue
+class BaseNestedStage(BaseStage, ABC):
+    """Base Nested Stage model. This model is use for checking the child stage
+    is the nested stage or not.
+    """
 
-            if arg.removeprefix("_") in args:
-                args[arg] = args.pop(arg.removeprefix("_"))
+    def set_outputs(self, output: DictData, to: DictData) -> DictData:
+        """Override the set outputs method that support for nested-stage."""
+        return super().set_outputs(output, to=to)
 
-            t: Any = type_hints[arg]
+    def get_outputs(self, output: DictData) -> DictData:
+        """Override the get outputs method that support for nested-stage"""
+        return super().get_outputs(output)
 
-            # NOTE: Check Result argument was passed to this caller function.
-            #
-            # if is_dataclass(t) and t.__name__ == "Result" and arg not in args:
-            #     args[arg] = result
+    @property
+    def is_nested(self) -> bool:
+        """Check if this stage is a nested stage or not.
 
-            if issubclass(t, BaseModel) and arg in args:
-                args[arg] = t.model_validate(obj=args[arg])
+        :rtype: bool
+        """
+        return True
 
-        return args
+    @staticmethod
+    def mark_errors(context: DictData, error: StageError) -> None:
+        """Make the errors context result with the refs value depends on the nested
+        execute func.
 
+        :param context: (DictData) A context data.
+        :param error: (StageError) A stage exception object.
+        """
+        if "errors" in context:
+            context["errors"][error.refs] = error.to_dict()
+        else:
+            context["errors"] = error.to_dict(with_refs=True)
 
-class TriggerStage(BaseStage):
+
+class TriggerStage(BaseNestedStage):
     """Trigger workflow executor stage that run an input trigger Workflow
     execute method. This is the stage that allow you to create the reusable
     Workflow template with dynamic parameters.
@@ -1277,13 +1500,14 @@ class TriggerStage(BaseStage):
         event: Optional[Event] = None,
     ) -> Result:
         """Trigger another workflow execution. It will wait the trigger
-        workflow running complete before catching its result.
+        workflow running complete before catching its result and raise error
+        when the result status does not be SUCCESS.
 
         :param params: (DictData) A parameter data.
         :param result: (Result) A result object for keeping context and status
-            data.
+            data. (Default is None)
         :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
+            was not force stopped. (Default is None)
 
         :rtype: Result
         """
@@ -1295,57 +1519,28 @@ class TriggerStage(BaseStage):
         )
 
         _trigger: str = param2template(self.trigger, params, extras=self.extras)
-        result.trace.info(f"[STAGE]: Execute Trigger-Stage: {_trigger!r}")
-        rs: Result = Workflow.from_conf(
+        result: Result = Workflow.from_conf(
             name=pass_env(_trigger),
-            extras=self.extras | {"stage_raise_error": True},
+            extras=self.extras,
         ).execute(
+            # NOTE: Should not use the `pass_env` function on this params parameter.
             params=param2template(self.params, params, extras=self.extras),
             run_id=None,
             parent_run_id=result.parent_run_id,
             event=event,
         )
-        if rs.status == FAILED:
+        if result.status == FAILED:
             err_msg: StrOrNone = (
                 f" with:\n{msg}"
-                if (msg := rs.context.get("errors", {}).get("message"))
+                if (msg := result.context.get("errors", {}).get("message"))
                 else "."
             )
-            raise StageException(
-                f"Trigger workflow return `FAILED` status{err_msg}"
-            )
-        return rs
-
-
-class BaseNestedStage(BaseStage):
-    """Base Nested Stage model. This model is use for checking the child stage
-    is the nested stage or not.
-    """
-
-    @abstractmethod
-    def execute(
-        self,
-        params: DictData,
-        *,
-        result: Optional[Result] = None,
-        event: Optional[Event] = None,
-    ) -> Result:
-        """Execute abstraction method that action something by sub-model class.
-        This is important method that make this class is able to be the nested
-        stage.
-
-        :param params: (DictData) A parameter data that want to use in this
-            execution.
-        :param result: (Result) A result object for keeping context and status
-            data.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
-
-        :rtype: Result
-        """
-        raise NotImplementedError(
-            "Nested-Stage should implement `execute` method."
-        )
+            raise StageError(f"Trigger workflow was failed{err_msg}")
+        elif result.status == CANCEL:
+            raise StageCancelError("Trigger workflow was cancel.")
+        elif result.status == SKIP:
+            raise StageSkipError("Trigger workflow was skipped.")
+        return result
 
 
 class ParallelStage(BaseNestedStage):
@@ -1366,10 +1561,14 @@ class ParallelStage(BaseNestedStage):
         ...                 "echo": "Start run with branch 1",
         ...                 "sleep": 3,
         ...             },
+        ...             {
+        ...                 "name": "Echo second stage",
+        ...                 "echo": "Start run with branch 1",
+        ...             },
         ...         ],
         ...         "branch02": [
         ...             {
-        ...                 "name": "Echo second stage",
+        ...                 "name": "Echo first stage",
         ...                 "echo": "Start run with branch 2",
         ...                 "sleep": 1,
         ...             },
@@ -1399,94 +1598,116 @@ class ParallelStage(BaseNestedStage):
         result: Result,
         *,
         event: Optional[Event] = None,
-    ) -> Result:
-        """Execute all stage with specific branch ID.
+    ) -> tuple[Status, Result]:
+        """Execute branch that will execute all nested-stage that was set in
+        this stage with specific branch ID.
 
         :param branch: (str) A branch ID.
         :param params: (DictData) A parameter data.
         :param result: (Result) A Result instance for return context and status.
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
+            (Default is None)
 
-        :rtype: Result
+        :raise StageCancelError: If event was set.
+
+        :rtype: tuple[Status, Result]
         """
         result.trace.debug(f"[STAGE]: Execute Branch: {branch!r}")
+
+        # NOTE: Create nested-context
         context: DictData = copy.deepcopy(params)
         context.update({"branch": branch})
-        output: DictData = {"branch": branch, "stages": {}}
-        for stage in self.parallel[branch]:
+        nestet_context: DictData = {"branch": branch, "stages": {}}
+
+        total_stage: int = len(self.parallel[branch])
+        skips: list[bool] = [False] * total_stage
+        for i, stage in enumerate(self.parallel[branch], start=0):
 
             if self.extras:
                 stage.extras = self.extras
 
-            if stage.is_skipped(params=context):
-                result.trace.info(f"[STAGE]: Skip stage: {stage.iden!r}")
-                stage.set_outputs(output={"skipped": True}, to=output)
-                continue
-
             if event and event.is_set():
                 error_msg: str = (
-                    "Branch-Stage was canceled from event that had set before "
-                    "stage branch execution."
+                    "Branch execution was canceled from the event before "
+                    "start branch execution."
                 )
                 result.catch(
                     status=CANCEL,
                     parallel={
                         branch: {
+                            "status": CANCEL,
                             "branch": branch,
-                            "stages": filter_func(output.pop("stages", {})),
-                            "errors": StageException(error_msg).to_dict(),
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageCancelError(error_msg).to_dict(),
                         }
                     },
                 )
-                raise StageException(error_msg, refs=branch)
+                raise StageCancelError(error_msg, refs=branch)
 
-            try:
-                rs: Result = stage.handler_execute(
-                    params=context,
-                    run_id=result.run_id,
-                    parent_run_id=result.parent_run_id,
-                    raise_error=True,
-                    event=event,
+            rs: Result = stage.handler_execute(
+                params=context,
+                run_id=result.run_id,
+                parent_run_id=result.parent_run_id,
+                event=event,
+            )
+            stage.set_outputs(rs.context, to=nestet_context)
+            stage.set_outputs(stage.get_outputs(nestet_context), to=context)
+
+            if rs.status == SKIP:
+                skips[i] = True
+                continue
+
+            elif rs.status == FAILED:  # pragma: no cov
+                error_msg: str = (
+                    f"Branch execution was break because its nested-stage, "
+                    f"{stage.iden!r}, failed."
                 )
-                stage.set_outputs(rs.context, to=output)
-                stage.set_outputs(stage.get_outputs(output), to=context)
-            except StageException as e:
                 result.catch(
                     status=FAILED,
                     parallel={
                         branch: {
+                            "status": FAILED,
                             "branch": branch,
-                            "stages": filter_func(output.pop("stages", {})),
-                            "errors": e.to_dict(),
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageError(error_msg).to_dict(),
                         },
                     },
                 )
-                raise StageException(str(e), refs=branch) from e
+                raise StageError(error_msg, refs=branch)
 
-            if rs.status == FAILED:
+            elif rs.status == CANCEL:
                 error_msg: str = (
-                    f"Branch-Stage was break because it has a sub stage, "
-                    f"{stage.iden}, failed without raise error."
+                    "Branch execution was canceled from the event after "
+                    "end branch execution."
                 )
                 result.catch(
-                    status=FAILED,
+                    status=CANCEL,
                     parallel={
                         branch: {
+                            "status": CANCEL,
                             "branch": branch,
-                            "stages": filter_func(output.pop("stages", {})),
-                            "errors": StageException(error_msg).to_dict(),
-                        },
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageCancelError(error_msg).to_dict(),
+                        }
                     },
                 )
-                raise StageException(error_msg, refs=branch)
+                raise StageCancelError(error_msg, refs=branch)
 
-        return result.catch(
-            status=SUCCESS,
+        status: Status = SKIP if sum(skips) == total_stage else SUCCESS
+        return status, result.catch(
+            status=status,
             parallel={
                 branch: {
+                    "status": status,
                     "branch": branch,
-                    "stages": filter_func(output.pop("stages", {})),
+                    "stages": filter_func(nestet_context.pop("stages", {})),
                 },
             },
         )
@@ -1504,6 +1725,7 @@ class ParallelStage(BaseNestedStage):
         :param result: (Result) A Result instance for return context and status.
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
+            (Default is None)
 
         :rtype: Result
         """
@@ -1512,28 +1734,18 @@ class ParallelStage(BaseNestedStage):
             extras=self.extras,
         )
         event: Event = event or Event()
-        result.trace.info(
-            f"[STAGE]: Execute Parallel-Stage: {self.max_workers} workers."
+        result.trace.info(f"[STAGE]: Parallel with {self.max_workers} workers.")
+        result.catch(
+            status=WAIT,
+            context={"workers": self.max_workers, "parallel": {}},
         )
-        result.catch(status=WAIT, context={"parallel": {}})
+        len_parallel: int = len(self.parallel)
         if event and event.is_set():
-            return result.catch(
-                status=CANCEL,
-                context={
-                    "errors": StageException(
-                        "Stage was canceled from event that had set "
-                        "before stage parallel execution."
-                    ).to_dict()
-                },
+            raise StageCancelError(
+                "Execution was canceled from the event before start parallel."
             )
 
-        with ThreadPoolExecutor(
-            max_workers=self.max_workers, thread_name_prefix="stage_parallel_"
-        ) as executor:
-
-            context: DictData = {}
-            status: Status = SUCCESS
-
+        with ThreadPoolExecutor(self.max_workers, "stp") as executor:
             futures: list[Future] = [
                 executor.submit(
                     self.execute_branch,
@@ -1544,17 +1756,18 @@ class ParallelStage(BaseNestedStage):
                 )
                 for branch in self.parallel
             ]
-
-            for future in as_completed(futures):
+            context: DictData = {}
+            statuses: list[Status] = [WAIT] * len_parallel
+            for i, future in enumerate(as_completed(futures), start=0):
                 try:
-                    future.result()
-                except StageException as e:
-                    status = FAILED
-                    if "errors" in context:
-                        context["errors"][e.refs] = e.to_dict()
-                    else:
-                        context["errors"] = e.to_dict(with_refs=True)
-        return result.catch(status=status, context=context)
+                    statuses[i], _ = future.result()
+                except StageError as e:
+                    statuses[i] = get_status_from_error(e)
+                    self.mark_errors(context, e)
+        return result.catch(
+            status=validate_statuses(statuses),
+            context=context,
+        )
 
 
 class ForEachStage(BaseNestedStage):
@@ -1614,9 +1827,12 @@ class ForEachStage(BaseNestedStage):
         result: Result,
         *,
         event: Optional[Event] = None,
-    ) -> Result:
-        """Execute all nested stage that set on this stage with specific foreach
-        item parameter.
+    ) -> tuple[Status, Result]:
+        """Execute item that will execute all nested-stage that was set in this
+        stage with specific foreach item.
+
+            This method will create the nested-context from an input context
+        data and use it instead the context data.
 
         :param index: (int) An index value of foreach loop.
         :param item: (str | int) An item that want to execution.
@@ -1624,91 +1840,112 @@ class ForEachStage(BaseNestedStage):
         :param result: (Result) A Result instance for return context and status.
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
+            (Default is None)
 
-        :raise StageException: If event was set.
-        :raise StageException: If the stage execution raise any Exception error.
-        :raise StageException: If the result from execution has `FAILED` status.
+            This method should raise error when it wants to stop the foreach
+        loop such as cancel event or getting the failed status.
 
-        :rtype: Result
+        :raise StageCancelError: If event was set.
+        :raise StageError: If the stage execution raise any Exception error.
+        :raise StageError: If the result from execution has `FAILED` status.
+
+        :rtype: tuple[Status, Result]
         """
         result.trace.debug(f"[STAGE]: Execute Item: {item!r}")
         key: StrOrInt = index if self.use_index_as_key else item
+
         context: DictData = copy.deepcopy(params)
         context.update({"item": item, "loop": index})
-        output: DictData = {"item": item, "stages": {}}
-        for stage in self.stages:
+        nestet_context: DictData = {"item": item, "stages": {}}
+        total_stage: int = len(self.stages)
+        skips: list[bool] = [False] * total_stage
+        for i, stage in enumerate(self.stages, start=0):
 
             if self.extras:
                 stage.extras = self.extras
 
-            if stage.is_skipped(params=context):
-                result.trace.info(f"[STAGE]: Skip stage: {stage.iden!r}")
-                stage.set_outputs(output={"skipped": True}, to=output)
-                continue
-
             if event and event.is_set():
                 error_msg: str = (
-                    "Item-Stage was canceled because event was set."
+                    "Item execution was canceled from the event before start "
+                    "item execution."
                 )
                 result.catch(
                     status=CANCEL,
                     foreach={
                         key: {
+                            "status": CANCEL,
                             "item": item,
-                            "stages": filter_func(output.pop("stages", {})),
-                            "errors": StageException(error_msg).to_dict(),
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageCancelError(error_msg).to_dict(),
                         }
                     },
                 )
-                raise StageException(error_msg, refs=key)
+                raise StageCancelError(error_msg, refs=key)
 
-            try:
-                rs: Result = stage.handler_execute(
-                    params=context,
-                    run_id=result.run_id,
-                    parent_run_id=result.parent_run_id,
-                    raise_error=True,
-                    event=event,
+            rs: Result = stage.handler_execute(
+                params=context,
+                run_id=result.run_id,
+                parent_run_id=result.parent_run_id,
+                event=event,
+            )
+            stage.set_outputs(rs.context, to=nestet_context)
+            stage.set_outputs(stage.get_outputs(nestet_context), to=context)
+
+            if rs.status == SKIP:
+                skips[i] = True
+                continue
+
+            elif rs.status == FAILED:  # pragma: no cov
+                error_msg: str = (
+                    f"Item execution was break because its nested-stage, "
+                    f"{stage.iden!r}, failed."
                 )
-                stage.set_outputs(rs.context, to=output)
-                stage.set_outputs(stage.get_outputs(output), to=context)
-            except StageException as e:
+                result.trace.warning(f"[STAGE]: {error_msg}")
                 result.catch(
                     status=FAILED,
                     foreach={
                         key: {
+                            "status": FAILED,
                             "item": item,
-                            "stages": filter_func(output.pop("stages", {})),
-                            "errors": e.to_dict(),
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageError(error_msg).to_dict(),
                         },
                     },
                 )
-                raise StageException(str(e), refs=key) from e
+                raise StageError(error_msg, refs=key)
 
-            if rs.status == FAILED:
+            elif rs.status == CANCEL:
                 error_msg: str = (
-                    f"Item-Stage was break because it has a sub stage, "
-                    f"{stage.iden}, failed without raise error."
+                    "Item execution was canceled from the event after "
+                    "end item execution."
                 )
-                result.trace.warning(f"[STAGE]: {error_msg}")
                 result.catch(
-                    status=FAILED,
+                    status=CANCEL,
                     foreach={
                         key: {
+                            "status": CANCEL,
                             "item": item,
-                            "stages": filter_func(output.pop("stages", {})),
-                            "errors": StageException(error_msg).to_dict(),
-                        },
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageCancelError(error_msg).to_dict(),
+                        }
                     },
                 )
-                raise StageException(error_msg, refs=key)
+                raise StageCancelError(error_msg, refs=key)
 
-        return result.catch(
-            status=SUCCESS,
+        status: Status = SKIP if sum(skips) == total_stage else SUCCESS
+        return status, result.catch(
+            status=status,
             foreach={
                 key: {
+                    "status": status,
                     "item": item,
-                    "stages": filter_func(output.pop("stages", {})),
+                    "stages": filter_func(nestet_context.pop("stages", {})),
                 },
             },
         )
@@ -1736,38 +1973,42 @@ class ForEachStage(BaseNestedStage):
             extras=self.extras,
         )
         event: Event = event or Event()
-        foreach: Union[list[str], list[int]] = (
+        foreach: Union[list[str], list[int]] = pass_env(
             param2template(self.foreach, params, extras=self.extras)
-            if isinstance(self.foreach, str)
-            else self.foreach
         )
 
+        # [NOTE]: Force convert str to list.
+        if isinstance(foreach, str):
+            try:
+                foreach: list[Any] = str2list(foreach)
+            except ValueError as e:
+                raise TypeError(
+                    f"Does not support string foreach: {foreach!r} that can "
+                    f"not convert to list."
+                ) from e
+
         # [VALIDATE]: Type of the foreach should be `list` type.
-        if not isinstance(foreach, list):
-            raise TypeError(f"Does not support foreach: {foreach!r}")
+        elif not isinstance(foreach, list):
+            raise TypeError(
+                f"Does not support foreach: {foreach!r} ({type(foreach)})"
+            )
+        # [Validate]: Value in the foreach item should not be duplicate when the
+        #   `use_index_as_key` field did not set.
         elif len(set(foreach)) != len(foreach) and not self.use_index_as_key:
             raise ValueError(
                 "Foreach item should not duplicate. If this stage must to pass "
                 "duplicate item, it should set `use_index_as_key: true`."
             )
 
-        result.trace.info(f"[STAGE]: Execute Foreach-Stage: {foreach!r}.")
+        result.trace.info(f"[STAGE]: Foreach: {foreach!r}.")
         result.catch(status=WAIT, context={"items": foreach, "foreach": {}})
+        len_foreach: int = len(foreach)
         if event and event.is_set():
-            return result.catch(
-                status=CANCEL,
-                context={
-                    "errors": StageException(
-                        "Stage was canceled from event that had set "
-                        "before stage foreach execution."
-                    ).to_dict()
-                },
+            raise StageCancelError(
+                "Execution was canceled from the event before start foreach."
             )
 
-        with ThreadPoolExecutor(
-            max_workers=self.concurrent, thread_name_prefix="stage_foreach_"
-        ) as executor:
-
+        with ThreadPoolExecutor(self.concurrent, "stf") as executor:
             futures: list[Future] = [
                 executor.submit(
                     self.execute_item,
@@ -1779,19 +2020,21 @@ class ForEachStage(BaseNestedStage):
                 )
                 for i, item in enumerate(foreach, start=0)
             ]
+
             context: DictData = {}
-            status: Status = SUCCESS
+            statuses: list[Status] = [WAIT] * len_foreach
+            fail_fast: bool = False
 
             done, not_done = wait(futures, return_when=FIRST_EXCEPTION)
             if len(list(done)) != len(futures):
                 result.trace.warning(
-                    "[STAGE]: Set event for stop pending for-each stage."
+                    "[STAGE]: Set the event for stop pending for-each stage."
                 )
                 event.set()
                 for future in not_done:
                     future.cancel()
-                time.sleep(0.075)
 
+                time.sleep(0.025)
                 nd: str = (
                     (
                         f", {len(not_done)} item"
@@ -1804,18 +2047,24 @@ class ForEachStage(BaseNestedStage):
                     f"[STAGE]: ... Foreach-Stage set failed event{nd}"
                 )
                 done: Iterator[Future] = as_completed(futures)
+                fail_fast = True
 
-            for future in done:
+            for i, future in enumerate(done, start=0):
                 try:
-                    future.result()
-                except StageException as e:
-                    status = FAILED
-                    if "errors" in context:
-                        context["errors"][e.refs] = e.to_dict()
-                    else:
-                        context["errors"] = e.to_dict(with_refs=True)
+                    statuses[i], _ = future.result()
+                except StageError as e:
+                    statuses[i] = get_status_from_error(e)
+                    self.mark_errors(context, e)
                 except CancelledError:
                     pass
+
+        status: Status = validate_statuses(statuses)
+
+        # NOTE: Prepare status because it does not cancel from parent event but
+        #   cancel from failed item execution.
+        if fail_fast and status == CANCEL:
+            status = FAILED
+
         return result.catch(status=status, context=context)
 
 
@@ -1874,8 +2123,9 @@ class UntilStage(BaseNestedStage):
         params: DictData,
         result: Result,
         event: Optional[Event] = None,
-    ) -> tuple[Result, T]:
-        """Execute all stage with specific loop and item.
+    ) -> tuple[Status, Result, T]:
+        """Execute loop that will execute all nested-stage that was set in this
+        stage with specific loop and item.
 
         :param item: (T) An item that want to execution.
         :param loop: (int) A number of loop.
@@ -1884,98 +2134,115 @@ class UntilStage(BaseNestedStage):
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
 
-        :rtype: tuple[Result, T]
+        :rtype: tuple[Status, Result, T]
         :return: Return a pair of Result and changed item.
         """
-        result.trace.debug(f"[STAGE]: ... Execute until item: {item!r}")
+        result.trace.debug(f"[STAGE]: Execute Loop: {loop} (Item {item!r})")
+
+        # NOTE: Create nested-context
         context: DictData = copy.deepcopy(params)
-        context.update({"item": item})
-        output: DictData = {"loop": loop, "item": item, "stages": {}}
-        next_item: T = None
-        for stage in self.stages:
+        context.update({"item": item, "loop": loop})
+        nestet_context: DictData = {"loop": loop, "item": item, "stages": {}}
+
+        next_item: Optional[T] = None
+        total_stage: int = len(self.stages)
+        skips: list[bool] = [False] * total_stage
+        for i, stage in enumerate(self.stages, start=0):
 
             if self.extras:
                 stage.extras = self.extras
 
-            if stage.is_skipped(params=context):
-                result.trace.info(f"[STAGE]: Skip stage: {stage.iden!r}")
-                stage.set_outputs(output={"skipped": True}, to=output)
-                continue
-
             if event and event.is_set():
                 error_msg: str = (
-                    "Loop-Stage was canceled from event that had set before "
-                    "stage loop execution."
+                    "Loop execution was canceled from the event before start "
+                    "loop execution."
                 )
-                return (
-                    result.catch(
-                        status=CANCEL,
-                        until={
-                            loop: {
-                                "loop": loop,
-                                "item": item,
-                                "stages": filter_func(output.pop("stages", {})),
-                                "errors": StageException(error_msg).to_dict(),
-                            }
-                        },
-                    ),
-                    next_item,
+                result.catch(
+                    status=CANCEL,
+                    until={
+                        loop: {
+                            "status": CANCEL,
+                            "loop": loop,
+                            "item": item,
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageCancelError(error_msg).to_dict(),
+                        }
+                    },
                 )
+                raise StageCancelError(error_msg, refs=loop)
 
-            try:
-                rs: Result = stage.handler_execute(
-                    params=context,
-                    run_id=result.run_id,
-                    parent_run_id=result.parent_run_id,
-                    raise_error=True,
-                    event=event,
-                )
-                stage.set_outputs(rs.context, to=output)
+            rs: Result = stage.handler_execute(
+                params=context,
+                run_id=result.run_id,
+                parent_run_id=result.parent_run_id,
+                event=event,
+            )
+            stage.set_outputs(rs.context, to=nestet_context)
+
+            if "item" in (_output := stage.get_outputs(nestet_context)):
+                next_item = _output["item"]
 
-                if "item" in (_output := stage.get_outputs(output)):
-                    next_item = _output["item"]
+            stage.set_outputs(_output, to=context)
+
+            if rs.status == SKIP:
+                skips[i] = True
+                continue
 
-                stage.set_outputs(_output, to=context)
-            except StageException as e:
+            elif rs.status == FAILED:
+                error_msg: str = (
+                    f"Loop execution was break because its nested-stage, "
+                    f"{stage.iden!r}, failed."
+                )
                 result.catch(
                     status=FAILED,
                     until={
                         loop: {
+                            "status": FAILED,
                             "loop": loop,
                             "item": item,
-                            "stages": filter_func(output.pop("stages", {})),
-                            "errors": e.to_dict(),
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageError(error_msg).to_dict(),
                         }
                     },
                 )
-                raise
+                raise StageError(error_msg, refs=loop)
 
-            if rs.status == FAILED:
+            elif rs.status == CANCEL:
                 error_msg: str = (
-                    f"Loop-Stage was break because it has a sub stage, "
-                    f"{stage.iden}, failed without raise error."
+                    "Loop execution was canceled from the event after "
+                    "end loop execution."
                 )
                 result.catch(
-                    status=FAILED,
+                    status=CANCEL,
                     until={
                         loop: {
+                            "status": CANCEL,
                             "loop": loop,
                             "item": item,
-                            "stages": filter_func(output.pop("stages", {})),
-                            "errors": StageException(error_msg).to_dict(),
+                            "stages": filter_func(
+                                nestet_context.pop("stages", {})
+                            ),
+                            "errors": StageCancelError(error_msg).to_dict(),
                         }
                     },
                 )
-                raise StageException(error_msg)
+                raise StageCancelError(error_msg, refs=loop)
 
+        status: Status = SKIP if sum(skips) == total_stage else SUCCESS
         return (
+            status,
             result.catch(
-                status=SUCCESS,
+                status=status,
                 until={
                     loop: {
+                        "status": status,
                         "loop": loop,
                         "item": item,
-                        "stages": filter_func(output.pop("stages", {})),
+                        "stages": filter_func(nestet_context.pop("stages", {})),
                     }
                 },
             ),
@@ -1989,12 +2256,14 @@ class UntilStage(BaseNestedStage):
         result: Optional[Result] = None,
         event: Optional[Event] = None,
     ) -> Result:
-        """Execute until loop with checking until condition.
+        """Execute until loop with checking the until condition before release
+        the next loop.
 
         :param params: (DictData) A parameter data.
         :param result: (Result) A Result instance for return context and status.
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
+            (Default is None)
 
         :rtype: Result
         """
@@ -2002,29 +2271,24 @@ class UntilStage(BaseNestedStage):
             run_id=gen_id(self.name + (self.id or ""), unique=True),
             extras=self.extras,
         )
-
-        result.trace.info(f"[STAGE]: Execute Until-Stage: {self.until}")
-        item: Union[str, int, bool] = param2template(
-            self.item, params, extras=self.extras
+        event: Event = event or Event()
+        result.trace.info(f"[STAGE]: Until: {self.until!r}")
+        item: Union[str, int, bool] = pass_env(
+            param2template(self.item, params, extras=self.extras)
         )
         loop: int = 1
-        track: bool = True
+        until_rs: bool = True
         exceed_loop: bool = False
         result.catch(status=WAIT, context={"until": {}})
-        while track and not (exceed_loop := loop >= self.max_loop):
+        statuses: list[Status] = []
+        while until_rs and not (exceed_loop := (loop > self.max_loop)):
 
             if event and event.is_set():
-                return result.catch(
-                    status=CANCEL,
-                    context={
-                        "errors": StageException(
-                            "Stage was canceled from event that had set "
-                            "before stage loop execution."
-                        ).to_dict()
-                    },
+                raise StageCancelError(
+                    "Execution was canceled from the event before start loop."
                 )
 
-            result, item = self.execute_loop(
+            status, result, item = self.execute_loop(
                 item=item,
                 loop=loop,
                 params=params,
@@ -2034,34 +2298,39 @@ class UntilStage(BaseNestedStage):
 
             loop += 1
             if item is None:
+                item: int = loop
                 result.trace.warning(
-                    f"[STAGE]: ... Loop-Execute not set item. It use loop: {loop} by "
-                    f"default."
+                    f"[STAGE]: Return loop not set the item. It uses loop: "
+                    f"{loop} by default."
                 )
-                item: int = loop
 
             next_track: bool = eval(
-                param2template(
-                    self.until,
-                    params | {"item": item, "loop": loop},
-                    extras=self.extras,
+                pass_env(
+                    param2template(
+                        self.until,
+                        params | {"item": item, "loop": loop},
+                        extras=self.extras,
+                    ),
                 ),
                 globals() | params | {"item": item},
                 {},
             )
             if not isinstance(next_track, bool):
-                raise StageException(
+                raise TypeError(
                     "Return type of until condition not be `boolean`, getting"
                     f": {next_track!r}"
                 )
-            track: bool = not next_track
-            delay(0.025)
+            until_rs: bool = not next_track
+            statuses.append(status)
+            delay(0.005)
 
         if exceed_loop:
-            raise StageException(
-                f"The until loop was exceed {self.max_loop} loops"
+            error_msg: str = (
+                f"Loop was exceed the maximum {self.max_loop} "
+                f"loop{'s' if self.max_loop > 1 else ''}."
             )
-        return result.catch(status=SUCCESS)
+            raise StageError(error_msg)
+        return result.catch(status=validate_statuses(statuses))
 
 
 class Match(BaseModel):
@@ -2145,11 +2414,6 @@ class CaseStage(BaseNestedStage):
             if self.extras:
                 stage.extras = self.extras
 
-            if stage.is_skipped(params=context):
-                result.trace.info(f"[STAGE]: ... Skip stage: {stage.iden!r}")
-                stage.set_outputs(output={"skipped": True}, to=output)
-                continue
-
             if event and event.is_set():
                 error_msg: str = (
                     "Case-Stage was canceled from event that had set before "
@@ -2160,29 +2424,18 @@ class CaseStage(BaseNestedStage):
                     context={
                         "case": case,
                         "stages": filter_func(output.pop("stages", {})),
-                        "errors": StageException(error_msg).to_dict(),
+                        "errors": StageError(error_msg).to_dict(),
                     },
                 )
 
-            try:
-                rs: Result = stage.handler_execute(
-                    params=context,
-                    run_id=result.run_id,
-                    parent_run_id=result.parent_run_id,
-                    raise_error=True,
-                    event=event,
-                )
-                stage.set_outputs(rs.context, to=output)
-                stage.set_outputs(stage.get_outputs(output), to=context)
-            except StageException as e:
-                return result.catch(
-                    status=FAILED,
-                    context={
-                        "case": case,
-                        "stages": filter_func(output.pop("stages", {})),
-                        "errors": e.to_dict(),
-                    },
-                )
+            rs: Result = stage.handler_execute(
+                params=context,
+                run_id=result.run_id,
+                parent_run_id=result.parent_run_id,
+                event=event,
+            )
+            stage.set_outputs(rs.context, to=output)
+            stage.set_outputs(stage.get_outputs(output), to=context)
 
             if rs.status == FAILED:
                 error_msg: str = (
@@ -2194,7 +2447,7 @@ class CaseStage(BaseNestedStage):
                     context={
                         "case": case,
                         "stages": filter_func(output.pop("stages", {})),
-                        "errors": StageException(error_msg).to_dict(),
+                        "errors": StageError(error_msg).to_dict(),
                     },
                 )
         return result.catch(
@@ -2228,7 +2481,7 @@ class CaseStage(BaseNestedStage):
 
         _case: StrOrNone = param2template(self.case, params, extras=self.extras)
 
-        result.trace.info(f"[STAGE]: Execute Case-Stage: {_case!r}.")
+        result.trace.info(f"[STAGE]: Case: {_case!r}.")
         _else: Optional[Match] = None
         stages: Optional[list[Stage]] = None
         for match in self.match:
@@ -2237,39 +2490,28 @@ class CaseStage(BaseNestedStage):
                 continue
 
             _condition: str = param2template(c, params, extras=self.extras)
-            if stages is None and _case == _condition:
+            if stages is None and pass_env(_case) == pass_env(_condition):
                 stages: list[Stage] = match.stages
 
         if stages is None:
             if _else is None:
                 if not self.skip_not_match:
-                    raise StageException(
+                    raise StageError(
                         "This stage does not set else for support not match "
                         "any case."
                     )
-                result.trace.info(
-                    "[STAGE]: ... Skip this stage because it does not match."
-                )
-                error_msg: str = (
-                    "Case-Stage was canceled because it does not match any "
-                    "case and else condition does not set too."
-                )
-                return result.catch(
-                    status=CANCEL,
-                    context={"errors": StageException(error_msg).to_dict()},
+                raise StageSkipError(
+                    "Execution was skipped because it does not match any "
+                    "case and the else condition does not set too."
                 )
+
             _case: str = "_"
             stages: list[Stage] = _else.stages
 
         if event and event.is_set():
-            return result.catch(
-                status=CANCEL,
-                context={
-                    "errors": StageException(
-                        "Stage was canceled from event that had set before "
-                        "case-stage execution."
-                    ).to_dict()
-                },
+            raise StageCancelError(
+                "Execution was canceled from the event before start "
+                "case execution."
             )
 
         return self.execute_case(
@@ -2278,7 +2520,7 @@ class CaseStage(BaseNestedStage):
 
 
 class RaiseStage(BaseAsyncStage):
-    """Raise error stage executor that raise `StageException` that use a message
+    """Raise error stage executor that raise `StageError` that use a message
     field for making error message before raise.
 
     Data Validate:
@@ -2291,7 +2533,7 @@ class RaiseStage(BaseAsyncStage):
 
     message: str = Field(
         description=(
-            "An error message that want to raise with `StageException` class"
+            "An error message that want to raise with `StageError` class"
         ),
         alias="raise",
     )
@@ -2303,7 +2545,7 @@ class RaiseStage(BaseAsyncStage):
         result: Optional[Result] = None,
         event: Optional[Event] = None,
     ) -> Result:
-        """Raise the StageException object with the message field execution.
+        """Raise the StageError object with the message field execution.
 
         :param params: (DictData) A parameter data.
         :param result: (Result) A Result instance for return context and status.
@@ -2315,8 +2557,8 @@ class RaiseStage(BaseAsyncStage):
             extras=self.extras,
         )
         message: str = param2template(self.message, params, extras=self.extras)
-        result.trace.info(f"[STAGE]: Execute Raise-Stage: ( {message} )")
-        raise StageException(message)
+        result.trace.info(f"[STAGE]: Message: ( {message} )")
+        raise StageError(message)
 
     async def axecute(
         self,
@@ -2343,7 +2585,7 @@ class RaiseStage(BaseAsyncStage):
         )
         message: str = param2template(self.message, params, extras=self.extras)
         await result.trace.ainfo(f"[STAGE]: Execute Raise-Stage: ( {message} )")
-        raise StageException(message)
+        raise StageError(message)
 
 
 class DockerStage(BaseStage):  # pragma: no cov
@@ -2437,7 +2679,7 @@ class DockerStage(BaseStage):  # pragma: no cov
             )
             return result.catch(
                 status=CANCEL,
-                context={"errors": StageException(error_msg).to_dict()},
+                context={"errors": StageError(error_msg).to_dict()},
             )
 
         unique_image_name: str = f"{self.image}_{datetime.now():%Y%m%d%H%M%S%f}"
@@ -2507,9 +2749,7 @@ class DockerStage(BaseStage):  # pragma: no cov
             extras=self.extras,
         )
 
-        result.trace.info(
-            f"[STAGE]: Execute Docker-Stage: {self.image}:{self.tag}"
-        )
+        result.trace.info(f"[STAGE]: Docker: {self.image}:{self.tag}")
         raise NotImplementedError("Docker Stage does not implement yet.")
 
 
@@ -2608,8 +2848,6 @@ class VirtualPyStage(PyStage):  # pragma: no cov
             run_id=gen_id(self.name + (self.id or ""), unique=True),
             extras=self.extras,
         )
-
-        result.trace.info(f"[STAGE]: Execute VirtualPy-Stage: {self.name}")
         run: str = param2template(dedent(self.run), params, extras=self.extras)
         with self.create_py_file(
             py=run,
@@ -2617,19 +2855,9 @@ class VirtualPyStage(PyStage):  # pragma: no cov
             deps=param2template(self.deps, params, extras=self.extras),
             run_id=result.run_id,
         ) as py:
-            result.trace.debug(f"[STAGE]: ... Create `{py}` file.")
-            try:
-                import uv
-
-                _ = uv
-            except ImportError:
-                raise ImportError(
-                    "The VirtualPyStage need you to install `uv` before"
-                    "execution."
-                ) from None
-
+            result.trace.debug(f"[STAGE]: Create `{py}` file.")
             rs: CompletedProcess = subprocess.run(
-                ["uv", "run", py, "--no-cache"],
+                ["python", "-m", "uv", "run", py, "--no-cache"],
                 # ["uv", "run", "--python", "3.9", py],
                 shell=False,
                 capture_output=True,
@@ -2643,7 +2871,7 @@ class VirtualPyStage(PyStage):  # pragma: no cov
                 if "\\x00" in rs.stderr
                 else rs.stderr
             ).removesuffix("\n")
-            raise StageException(
+            raise StageError(
                 f"Subprocess: {e}\nRunning Statement:\n---\n"
                 f"```python\n{run}\n```"
             )