ddeutil-workflow 0.0.53__py3-none-any.whl → 0.0.55__py3-none-any.whl

ddeutil/workflow/stages.py

@@ -4,23 +4,27 @@
 # license information.
 # ------------------------------------------------------------------------------
 # [x] Use dynamic config
-"""Stage model. It stores all stage model that use for getting stage data template
-from the Job Model. The stage handle the minimize task that run in some thread
-(same thread at its job owner) that mean it is the lowest executor of a workflow
-that can tracking logs.
+"""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
+you can track logs.
 
-    The output of stage execution only return 0 status because I do not want to
-handle stage error on this stage model. I think stage model should have a lot of
-use-case, and it does not worry when I want to create a new one.
+    The output of stage execution only return SUCCESS or CANCEL status because
+I do not want to handle stage error on this stage execution. I think stage model
+have a lot of use-case, and it should does not worry about it error output.
 
-    Execution   --> Ok      --> Result with SUCCESS
+    So, I will create `handler_execute` for any exception class that raise from
+the stage execution method.
 
-                --> Error   ┬-> Result with FAILED (if env var was set)
-                            ╰-> Raise StageException(...)
+    Execution   --> Ok      ---( handler )--> Result with `SUCCESS` or `CANCEL`
+
+                --> Error   ┬--( handler )-> Result with `FAILED` (Set `raise_error` flag)
+                            |
+                            ╰--( handler )-> Raise StageException(...)
 
     On the context I/O that pass to a stage object at execute process. The
-execute method receives a `params={"params": {...}}` value for mapping to
-template searching.
+execute method receives a `params={"params": {...}}` value for passing template
+searching.
 """
 from __future__ import annotations
 
@@ -28,12 +32,13 @@ import asyncio
 import contextlib
 import copy
 import inspect
+import json
 import subprocess
 import sys
 import time
 import uuid
 from abc import ABC, abstractmethod
-from collections.abc import Iterator
+from collections.abc import AsyncIterator, Iterator
 from concurrent.futures import (
     FIRST_EXCEPTION,
     Future,
@@ -59,6 +64,7 @@ from .exceptions import StageException, UtilException, to_dict
 from .result import CANCEL, FAILED, SUCCESS, WAIT, Result, Status
 from .reusables import TagFunc, extract_call, not_in_template, param2template
 from .utils import (
+    NEWLINE,
     delay,
     filter_func,
     gen_id,
@@ -66,20 +72,22 @@ from .utils import (
 )
 
 T = TypeVar("T")
+StrOrInt = Union[str, int]
 
 
 class BaseStage(BaseModel, ABC):
-    """Base Stage Model that keep only id and name fields for the stage
-    metadata. If you want to implement any custom stage, you can use this class
-    to parent and implement ``self.execute()`` method only.
+    """Base Stage Model that keep only necessary fields like `id`, `name` or
+    `condition` for the stage metadata. If you want to implement any custom
+    stage, you can inherit this class and implement `self.execute()` method
+    only.
 
-        This class is the abstraction class for any stage model that want to
-    implement to workflow model.
+        This class is the abstraction class for any inherit stage model that
+    want to implement on this workflow package.
     """
 
     extras: DictData = Field(
         default_factory=dict,
-        description="An extra override config values.",
+        description="An extra parameter that override core config values.",
     )
     id: Optional[str] = Field(
         default=None,
@@ -93,14 +101,17 @@ class BaseStage(BaseModel, ABC):
     )
     condition: Optional[str] = Field(
         default=None,
-        description="A stage condition statement to allow stage executable.",
+        description=(
+            "A stage condition statement to allow stage executable. This field "
+            "alise with `if` field."
+        ),
         alias="if",
     )
 
     @property
     def iden(self) -> str:
-        """Return identity of this stage object that return the id field first.
-        If the id does not set, it will use name field instead.
+        """Return this stage identity that return the `id` field first and if
+        this `id` field does not set, it will use the `name` field instead.
 
         :rtype: str
         """
@@ -156,8 +167,8 @@ class BaseStage(BaseModel, ABC):
         run_id: str | None = None,
         parent_run_id: str | None = None,
         result: Result | None = None,
-        raise_error: bool | None = None,
         event: Event | None = None,
+        raise_error: bool | None = None,
     ) -> Result | DictData:
         """Handler stage execution result from the stage `execute` method.
 
@@ -170,7 +181,7 @@ class BaseStage(BaseModel, ABC):
                                         ╰-context:
                                             ╰-outputs: ...
 
-                        --> Error   --> Result (if env var was set)
+                        --> Error   --> Result (if `raise_error` was set)
                                         |-status: FAILED
                                         ╰-errors:
                                             |-class: ...
@@ -179,18 +190,16 @@ class BaseStage(BaseModel, ABC):
 
                         --> Error   --> Raise StageException(...)
 
-            On the last step, it will set the running ID on a return result object
-        from current stage ID before release the final result.
+            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 parameterize value data that use in this
-            stage execution.
-        :param run_id: (str) A running stage ID for this execution.
-        :param parent_run_id: (str) A parent workflow running ID for this
-            execution.
+        :param params: (DictData) A parameter data.
+        :param run_id: (str) A running stage ID.
+        :param parent_run_id: (str) A parent running ID.
         :param result: (Result) A result object for keeping context and status
             data before execution.
-        :param raise_error: (bool) A flag that all this method raise error
         :param event: (Event) An event manager that pass to the stage execution.
+        :param raise_error: (bool) A flag that all this method raise error
 
         :rtype: Result
         """
@@ -203,51 +212,56 @@ class BaseStage(BaseModel, ABC):
         )
 
         try:
-            rs: Result = self.execute(params, result=result, event=event)
-            return rs
+            return self.execute(params, result=result, event=event)
         except Exception as e:
-            result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
-
+            e_name: str = e.__class__.__name__
+            result.trace.error(f"[STAGE]: Handler:{NEWLINE}{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__}: \n\t"
-                    f"{e.__class__.__name__}: {e}"
+                    f"{self.__class__.__name__}: {NEWLINE}{e_name}: {e}"
                 ) from e
 
-            errors: DictData = {"errors": to_dict(e)}
-            return result.catch(status=FAILED, context=errors)
+            return result.catch(status=FAILED, context={"errors": to_dict(e)})
 
     def set_outputs(self, output: DictData, to: DictData) -> DictData:
-        """Set an outputs from execution process to the received context. The
-        result from execution will pass to value of `outputs` key.
+        """Set an outputs from execution result context to the received context
+        with a `to` input parameter. The result context from stage execution
+        will be set with `outputs` key in this stage ID key.
 
             For example of setting output method, If you receive execute output
         and want to set on the `to` like;
 
-            ... (i)   output: {'foo': bar}
+            ... (i)   output: {'foo': 'bar', 'skipped': True}
             ... (ii)  to: {'stages': {}}
 
-            The result of the `to` argument will be;
+            The received context in the `to` argument will be;
 
             ... (iii) to: {
                         'stages': {
                             '<stage-id>': {
                                 'outputs': {'foo': 'bar'},
-                                'skipped': False,
+                                'skipped': True,
                             }
                         }
                     }
 
+            The keys that will set to the received context is `outputs`,
+        `errors`, and `skipped` keys. The `errors` and `skipped` keys will
+        extract from the result context if it exists. If it does not found, it
+        will not set on the received context.
+
         Important:
+
             This method is use for reconstruct the result context and transfer
-        to the `to` argument.
+        to the `to` argument. The result context was soft copied before set
+        output step.
 
-        :param output: (DictData) An output data that want to extract to an
-            output key.
-        :param to: (DictData) A context data that want to add output result.
+        :param output: (DictData) A result data context that want to extract
+            and transfer to the `outputs` key in receive context.
+        :param to: (DictData) A received context data.
 
         :rtype: DictData
         """
@@ -282,11 +296,12 @@ class BaseStage(BaseModel, ABC):
         }
         return to
 
-    def get_outputs(self, outputs: DictData) -> DictData:
+    def get_outputs(self, output: DictData) -> DictData:
         """Get the outputs from stages data. It will get this stage ID from
         the stage outputs mapping.
 
-        :param outputs: (DictData) A stage outputs that want to get by stage ID.
+        :param output: (DictData) A stage output context that want to get this
+            stage ID `outputs` key.
 
         :rtype: DictData
         """
@@ -296,33 +311,31 @@ class BaseStage(BaseModel, ABC):
             return {}
 
         _id: str = (
-            param2template(self.id, params=outputs, extras=self.extras)
+            param2template(self.id, params=output, extras=self.extras)
             if self.id
             else gen_id(
-                param2template(self.name, params=outputs, extras=self.extras)
+                param2template(self.name, params=output, extras=self.extras)
             )
         )
-        return outputs.get("stages", {}).get(_id, {}).get("outputs", {})
+        return output.get("stages", {}).get(_id, {}).get("outputs", {})
 
-    def is_skipped(self, params: DictData | None = None) -> bool:
+    def is_skipped(self, params: DictData) -> bool:
         """Return true if condition of this stage do not correct. This process
         use build-in eval function to execute the if-condition.
 
+        :param params: (DictData) A parameters that want to pass to condition
+            template.
+
         :raise StageException: When it has any error raise from the eval
             condition statement.
         :raise StageException: 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
         """
         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
@@ -340,7 +353,14 @@ class BaseStage(BaseModel, ABC):
 
 
 class BaseAsyncStage(BaseStage):
-    """Base Async Stage model."""
+    """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
+    `self.axecute()` (async + execute = axecute) method only.
+
+        This class is the abstraction class for any inherit asyncable stage
+    model.
+    """
 
     @abstractmethod
     def execute(
@@ -385,20 +405,18 @@ class BaseAsyncStage(BaseStage):
         run_id: str | None = None,
         parent_run_id: str | None = None,
         result: Result | None = None,
-        raise_error: bool | None = None,
         event: Event | None = None,
+        raise_error: bool | None = None,
     ) -> Result:
         """Async Handler stage execution result from the stage `execute` method.
 
-        :param params: (DictData) A parameterize value data that use in this
-            stage execution.
-        :param run_id: (str) A running stage ID for this execution.
-        :param parent_run_id: (str) A parent workflow running ID for this
-            execution.
-        :param result: (Result) A result object for keeping context and status
-            data before execution.
+        :param params: (DictData) A parameter data.
+        :param run_id: (str) A stage running ID.
+        :param parent_run_id: (str) A parent job running ID.
+        :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
-        :param event: (Event) An event manager that pass to the stage execution.
 
         :rtype: Result
         """
@@ -414,24 +432,26 @@ class BaseAsyncStage(BaseStage):
             rs: Result = await self.axecute(params, result=result, event=event)
             return rs
         except Exception as e:  # pragma: no cov
-            await result.trace.aerror(f"[STAGE]: {e.__class__.__name__}: {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__}: \n\t"
-                    f"{e.__class__.__name__}: {e}"
+                    f"{self.__class__.__name__}: {NEWLINE}{e_name}: {e}"
                 ) from None
 
-            errors: DictData = {"errors": to_dict(e)}
-            return result.catch(status=FAILED, context=errors)
+            return result.catch(status=FAILED, context={"errors": to_dict(e)})
 
 
 class EmptyStage(BaseAsyncStage):
-    """Empty stage that do nothing (context equal empty stage) and logging the
-    name of stage only to stdout.
+    """Empty stage executor that do nothing and log the `message` field to
+    stdout only. It can use for tracking a template parameter on the workflow or
+    debug step.
+
+        You can pass a sleep value in second unit to this stage for waiting
+    after log message.
 
     Data Validate:
         >>> stage = {
@@ -443,11 +463,14 @@ class EmptyStage(BaseAsyncStage):
 
     echo: Optional[str] = Field(
         default=None,
-        description="A string message that want to show on the stdout.",
+        description="A message that want to show on the stdout.",
     )
     sleep: float = Field(
         default=0,
-        description="A second value to sleep before start execution.",
+        description=(
+            "A second value to sleep before start execution. This value should "
+            "gather or equal 0, and less than 1800 seconds."
+        ),
         ge=0,
         lt=1800,
     )
@@ -460,18 +483,15 @@ class EmptyStage(BaseAsyncStage):
         event: Event | None = None,
     ) -> Result:
         """Execution method for the Empty stage that do only logging out to
-        stdout. This method does not use the `handler_result` decorator because
-        it does not get any error from logging function.
+        stdout.
 
             The result context should be empty and do not process anything
         without calling logging function.
 
-        :param params: (DictData) A context data that want to add output result.
-            But this stage does not pass any output.
-        :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.
+        :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.
 
         :rtype: Result
         """
@@ -484,21 +504,18 @@ class EmptyStage(BaseAsyncStage):
             message: str = "..."
         else:
             message: str = param2template(
-                dedent(self.echo), params, extras=self.extras
+                dedent(self.echo.strip("\n")), params, extras=self.extras
             )
-            if "\n" in self.echo:
-                message: str = "\n\t" + message.replace("\n", "\n\t").strip(
-                    "\n"
-                )
+            if "\n" in message:
+                message: str = NEWLINE + message.replace("\n", NEWLINE)
 
         result.trace.info(
             f"[STAGE]: Empty-Execute: {self.name!r}: ( {message} )"
         )
         if self.sleep > 0:
             if self.sleep > 5:
-                result.trace.info(f"[STAGE]: ... sleep ({self.sleep} seconds)")
+                result.trace.info(f"[STAGE]: ... sleep ({self.sleep} sec)")
             time.sleep(self.sleep)
-
         return result.catch(status=SUCCESS)
 
     async def axecute(
@@ -511,44 +528,48 @@ class EmptyStage(BaseAsyncStage):
         """Async execution method for this Empty stage that only logging out to
         stdout.
 
-        :param params: (DictData) A context data that want to add output result.
-            But this stage does not pass any output.
-        :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.
+        :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.
 
         :rtype: Result
         """
-        if result is None:
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
+
+        if not self.echo:
+            message: str = "..."
+        else:
+            message: str = param2template(
+                dedent(self.echo.strip("\n")), params, extras=self.extras
             )
+            if "\n" in message:
+                message: str = NEWLINE + message.replace("\n", NEWLINE)
 
-        await result.trace.ainfo(
-            f"[STAGE]: Empty-Execute: {self.name!r}: "
-            f"( {param2template(self.echo, params, extras=self.extras) or '...'} )"
+        result.trace.info(
+            f"[STAGE]: Empty-Execute: {self.name!r}: ( {message} )"
         )
-
         if self.sleep > 0:
             if self.sleep > 5:
                 await result.trace.ainfo(
-                    f"[STAGE]: ... sleep ({self.sleep} seconds)"
+                    f"[STAGE]: ... sleep ({self.sleep} sec)"
                 )
             await asyncio.sleep(self.sleep)
-
         return result.catch(status=SUCCESS)
 
 
 class BashStage(BaseStage):
-    """Bash execution stage that execute bash script on the current OS.
-    If your current OS is Windows, it will run on the bash in the WSL.
+    """Bash stage executor that execute bash script on the current OS.
+    If your current OS is Windows, it will run on the bash from the current WSL.
+    It will use `bash` for Windows OS and use `sh` for Linux OS.
 
-        I get some limitation when I run shell statement with the built-in
-    subprocess package. It does not good enough to use multiline statement.
-    Thus, I add writing ``.sh`` file before execution process for fix this
-    issue.
+        This stage has some limitation when it runs shell statement with the
+    built-in subprocess package. It does not good enough to use multiline
+    statement. Thus, it will write the `.sh` file before start running bash
+    command for fix this issue.
 
     Data Validate:
         >>> stage = {
@@ -560,15 +581,46 @@ class BashStage(BaseStage):
         ... }
     """
 
-    bash: str = Field(description="A bash statement that want to execute.")
+    bash: str = Field(
+        description=(
+            "A bash statement that want to execute via Python subprocess."
+        )
+    )
     env: DictStr = Field(
         default_factory=dict,
         description=(
-            "An environment variables that set before start execute by adding "
-            "on the header of the `.sh` file."
+            "An environment variables that set before run bash command. It "
+            "will add on the header of the `.sh` file."
         ),
     )
 
+    @contextlib.asynccontextmanager
+    async def acreate_sh_file(
+        self, bash: str, env: DictStr, run_id: str | None = None
+    ) -> AsyncIterator:  # pragma no cov
+        import aiofiles
+
+        f_name: str = f"{run_id or uuid.uuid4()}.sh"
+        f_shebang: str = "bash" if sys.platform.startswith("win") else "sh"
+
+        async with aiofiles.open(f"./{f_name}", mode="w", newline="\n") as f:
+            # NOTE: write header of `.sh` file
+            await f.write(f"#!/bin/{f_shebang}\n\n")
+
+            # NOTE: add setting environment variable before bash skip statement.
+            await f.writelines([f"{k}='{env[k]}';\n" for k in env])
+
+            # NOTE: make sure that shell script file does not have `\r` char.
+            await f.write("\n" + bash.replace("\r\n", "\n"))
+
+        # NOTE: Make this .sh file able to executable.
+        make_exec(f"./{f_name}")
+
+        yield [f_shebang, f_name]
+
+        # Note: Remove .sh file that use to run bash.
+        Path(f"./{f_name}").unlink()
+
     @contextlib.contextmanager
     def create_sh_file(
         self, bash: str, env: DictStr, run_id: str | None = None
@@ -577,16 +629,14 @@ class BashStage(BaseStage):
         step will write the `.sh` file before giving this file name to context.
         After that, it will auto delete this file automatic.
 
-        :param bash: (str) A bash statement that want to execute.
-        :param env: (DictStr) An environment variable that use on this bash
-            statement.
+        :param bash: (str) A bash statement.
+        :param env: (DictStr) An environment variable that set before run bash.
         :param run_id: (str | None) A running stage ID that use for writing sh
             file instead generate by UUID4.
 
         :rtype: Iterator[TupleStr]
         """
-        run_id: str = run_id or uuid.uuid4()
-        f_name: str = f"{run_id}.sh"
+        f_name: str = f"{run_id or uuid.uuid4()}.sh"
         f_shebang: str = "bash" if sys.platform.startswith("win") else "sh"
 
         with open(f"./{f_name}", mode="w", newline="\n") as f:
@@ -614,28 +664,28 @@ class BashStage(BaseStage):
         result: Result | None = None,
         event: Event | None = None,
     ) -> Result:
-        """Execute the Bash statement with the Python build-in ``subprocess``
-        package.
+        """Execute bash statement with the Python build-in `subprocess` package.
+        It will catch result from the `subprocess.run` returning output like
+        `return_code`, `stdout`, and `stderr`.
 
-        :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 event: (Event) An event manager that use to track parent execute
-            was not force stopped.
+        :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.
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
+
+        result.trace.info(f"[STAGE]: Shell-Execute: {self.name}")
 
         bash: str = param2template(
-            dedent(self.bash), params, extras=self.extras
+            dedent(self.bash.strip("\n")), params, extras=self.extras
         )
 
-        result.trace.info(f"[STAGE]: Shell-Execute: {self.name}")
         with self.create_sh_file(
             bash=bash,
             env=param2template(self.env, params, extras=self.extras),
@@ -654,7 +704,7 @@ class BashStage(BaseStage):
                 else rs.stderr
             ).removesuffix("\n")
             raise StageException(
-                f"Subprocess: {e}\nRunning Statement:\n---\n"
+                f"Subprocess: {e}\n---( statement )---\n"
                 f"```bash\n{bash}\n```"
             )
         return result.catch(
@@ -668,18 +718,24 @@ class BashStage(BaseStage):
 
 
 class PyStage(BaseStage):
-    """Python executor stage that running the Python statement with receiving
-    globals and additional variables.
+    """Python stage that running the Python statement with the current globals
+    and passing an input additional variables via `exec` built-in function.
 
         This stage allow you to use any Python object that exists on the globals
     such as import your installed package.
 
+    Warning:
+
+        The exec build-in function is very dangerous. So, it should use the `re`
+    module to validate exec-string before running or exclude the `os` package
+    from the current globals variable.
+
     Data Validate:
         >>> stage = {
         ...     "name": "Python stage execution",
-        ...     "run": 'print("Hello {x}")',
+        ...     "run": 'print(f"Hello {VARIABLE}")',
         ...     "vars": {
-        ...         "x": "BAR",
+        ...         "VARIABLE": "WORLD",
         ...     },
         ... }
     """
@@ -741,9 +797,9 @@ class PyStage(BaseStage):
         event: Event | None = None,
     ) -> Result:
         """Execute the Python statement that pass all globals and input params
-        to globals argument on ``exec`` build-in function.
+        to globals argument on `exec` build-in function.
 
-        :param params: A parameter that want to pass before run any statement.
+        :param params: (DictData) A parameter data.
         :param result: (Result) A result object for keeping context and status
             data.
         :param event: (Event) An event manager that use to track parent execute
@@ -751,11 +807,10 @@ class PyStage(BaseStage):
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
 
         lc: DictData = {}
         gb: DictData = (
@@ -792,20 +847,36 @@ class PyStage(BaseStage):
             },
         )
 
+    async def axecute(
+        self,
+    ):
+        """Async execution method.
+
+        References:
+            - https://stackoverflow.com/questions/44859165/async-exec-in-python
+        """
+
 
 class CallStage(BaseStage):
-    """Call executor that call the Python function from registry with tag
-    decorator function in ``utils`` module and run it with input arguments.
+    """Call stage executor that call the Python function from registry with tag
+    decorator function in `reusables` module and run it with input arguments.
+
+        This stage is different with PyStage because the PyStage is just run
+    a Python statement with the `exec` function and pass the current locals and
+    globals before exec that statement. This stage will import the caller
+    function can call it with an input arguments. So, you can create your
+    function complexly that you can for your objective to invoked by this stage
+    object.
 
-        This stage is different with PyStage because the PyStage is just calling
-    a Python statement with the ``eval`` and pass that locale before eval that
-    statement. So, you can create your function complexly that you can for your
-    objective to invoked by this stage object.
+        This stage is the most powerfull stage of this package for run every
+    use-case by a custom requirement that you want by creating the Python
+    function and adding it to the caller registry value by importer syntax like
+    `module.caller.registry` not path style like `module/caller/registry`.
 
-        This stage is the usefull stage for run every job by a custom requirement
-    that you want by creating the Python function and adding it to the task
-    registry by importer syntax like `module.tasks.registry` not path style like
-    `module/tasks/registry`.
+    Warning:
+
+        The caller registry to get a caller function should importable by the
+    current Python execution pointer.
 
     Data Validate:
         >>> stage = {
@@ -817,12 +888,16 @@ class CallStage(BaseStage):
 
     uses: str = Field(
         description=(
-            "A pointer that want to load function from the call registry."
+            "A caller function with registry importer syntax that use to load "
+            "function before execute step. The caller registry syntax should "
+            "be `<import.part>/<func-name>@<tag-name>`."
         ),
     )
     args: DictData = Field(
         default_factory=dict,
-        description="An arguments that want to pass to the call function.",
+        description=(
+            "An argument parameter that will pass to this caller function."
+        ),
         alias="with",
     )
 
@@ -833,19 +908,12 @@ class CallStage(BaseStage):
         result: Result | None = None,
         event: Event | None = None,
     ) -> Result:
-        """Execute the Call function that already in the call registry.
+        """Execute this caller function with its argument parameter.
 
-        :raise ValueError: When the necessary arguments of call function do not
-            set from the input params argument.
-        :raise TypeError: When the return type of call function does not be
-            dict type.
-
-        :param params: (DictData) A parameter that want to pass before run any
-            statement.
-        :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.
+        :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.
 
         :raise ValueError: If necessary arguments does not pass from the `args`
             field.
@@ -854,18 +922,20 @@ class CallStage(BaseStage):
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
 
-        has_keyword: bool = False
         call_func: TagFunc = extract_call(
             param2template(self.uses, params, extras=self.extras),
             registries=self.extras.get("registry_caller"),
         )()
 
+        result.trace.info(
+            f"[STAGE]: Call-Execute: {call_func.name}@{call_func.tag}"
+        )
+
         # VALIDATE: check input task caller parameters that exists before
         #   calling.
         args: DictData = {"result": result} | param2template(
@@ -873,6 +943,7 @@ class CallStage(BaseStage):
         )
         ips = inspect.signature(call_func)
         necessary_params: list[str] = []
+        has_keyword: bool = False
         for k in ips.parameters:
             if (
                 v := ips.parameters[k]
@@ -896,10 +967,6 @@ class CallStage(BaseStage):
         if "result" not in ips.parameters and not has_keyword:
             args.pop("result")
 
-        result.trace.info(
-            f"[STAGE]: Call-Execute: {call_func.name}@{call_func.tag}"
-        )
-
         args = self.parse_model_args(call_func, args, result)
 
         if inspect.iscoroutinefunction(call_func):
@@ -970,9 +1037,9 @@ class CallStage(BaseStage):
 
 
 class TriggerStage(BaseStage):
-    """Trigger Workflow execution stage that execute another workflow. This
-    the core stage that allow you to create the reusable workflow object or
-    dynamic parameters workflow for common usecase.
+    """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.
 
     Data Validate:
         >>> stage = {
@@ -984,12 +1051,13 @@ class TriggerStage(BaseStage):
 
     trigger: str = Field(
         description=(
-            "A trigger workflow name that should exist on the config path."
+            "A trigger workflow name. This workflow name should exist on the "
+            "config path because it will load by the `load_conf` method."
         ),
     )
     params: DictData = Field(
         default_factory=dict,
-        description="A parameter that want to pass to workflow execution.",
+        description="A parameter that will pass to workflow execution method.",
     )
 
     def execute(
@@ -1002,7 +1070,7 @@ class TriggerStage(BaseStage):
         """Trigger another workflow execution. It will wait the trigger
         workflow running complete before catching its result.
 
-        :param params: A parameter data that want to use in this execution.
+        :param params: (DictData) A parameter data.
         :param result: (Result) A result object for keeping context and status
             data.
         :param event: (Event) An event manager that use to track parent execute
@@ -1013,11 +1081,10 @@ class TriggerStage(BaseStage):
         from .exceptions import WorkflowException
         from .workflow import Workflow
 
-        if result is None:
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
 
         _trigger: str = param2template(self.trigger, params, extras=self.extras)
         result.trace.info(f"[STAGE]: Trigger-Execute: {_trigger!r}")
@@ -1037,16 +1104,20 @@ class TriggerStage(BaseStage):
             err_msg: str | None = (
                 f" with:\n{msg}"
                 if (msg := rs.context.get("errors", {}).get("message"))
-                else ""
+                else "."
+            )
+            raise StageException(
+                f"Trigger workflow return failed status{err_msg}"
             )
-            raise StageException(f"Trigger workflow was failed{err_msg}.")
         return rs
 
 
 class ParallelStage(BaseStage):  # pragma: no cov
-    """Parallel execution stage that execute child stages with parallel.
+    """Parallel stage executor that execute branch stages with multithreading.
+    This stage let you set the fix branches for running child stage inside it on
+    multithread pool.
 
-        This stage is not the low-level stage model because it runs muti-stages
+        This stage is not the low-level stage model because it runs multi-stages
     in this stage execution.
 
     Data Validate:
@@ -1072,58 +1143,55 @@ class ParallelStage(BaseStage):  # pragma: no cov
     """
 
     parallel: dict[str, list[Stage]] = Field(
-        description="A mapping of parallel branch name and stages.",
+        description="A mapping of branch name and its stages.",
     )
     max_workers: int = Field(
         default=2,
         ge=1,
         lt=20,
         description=(
-            "The maximum thread pool worker size for execution parallel."
+            "The maximum multi-thread pool worker size for execution parallel. "
+            "This value should be gather or equal than 1, and less than 20."
         ),
         alias="max-workers",
     )
 
-    def execute_task(
+    def execute_branch(
         self,
         branch: str,
         params: DictData,
         result: Result,
         *,
         event: Event | None = None,
-        extras: DictData | None = None,
-    ) -> DictData:
-        """Task execution method for passing a branch to each thread.
+    ) -> Result:
+        """Execute all stage with specific branch ID.
 
-        :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 event: (Event) An event manager that use to track parent execute
-            was not force stopped.
-        :param extras: (DictData) An extra parameters that want to override
-            config values.
+        :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.
 
-        :rtype: DictData
+        :rtype: Result
         """
-        result.trace.debug(f"... Execute branch: {branch!r}")
+        result.trace.debug(f"[STAGE]: Execute Branch: {branch!r}")
         context: DictData = copy.deepcopy(params)
         context.update({"branch": branch})
         output: DictData = {"branch": branch, "stages": {}}
         for stage in self.parallel[branch]:
 
-            if extras:
-                stage.extras = extras
+            if self.extras:
+                stage.extras = self.extras
 
             if stage.is_skipped(params=context):
-                result.trace.info(f"... Skip stage: {stage.iden!r}")
+                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 item execution."
+                    "stage branch execution."
                 )
                 return result.catch(
                     status=CANCEL,
@@ -1147,17 +1215,29 @@ class ParallelStage(BaseStage):  # pragma: no cov
                 stage.set_outputs(rs.context, to=output)
                 stage.set_outputs(stage.get_outputs(output), to=context)
             except (StageException, UtilException) as e:  # pragma: no cov
-                result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
+                result.trace.error(
+                    f"[STAGE]: {e.__class__.__name__}:{NEWLINE}{e}"
+                )
+                result.catch(
+                    status=FAILED,
+                    parallel={
+                        branch: {
+                            "branch": branch,
+                            "stages": filter_func(output.pop("stages", {})),
+                            "errors": e.to_dict(),
+                        },
+                    },
+                )
                 raise StageException(
-                    f"Sub-Stage execution error: {e.__class__.__name__}: {e}"
+                    f"Sub-Stage raise: {e.__class__.__name__}: {e}"
                 ) from None
 
             if rs.status == FAILED:
                 error_msg: str = (
-                    f"Item-Stage was break because it has a sub stage, "
+                    f"Branch-Stage was break because it has a sub stage, "
                     f"{stage.iden}, failed without raise error."
                 )
-                return result.catch(
+                result.catch(
                     status=FAILED,
                     parallel={
                         branch: {
@@ -1167,6 +1247,7 @@ class ParallelStage(BaseStage):  # pragma: no cov
                         },
                     },
                 )
+                raise StageException(error_msg)
 
         return result.catch(
             status=SUCCESS,
@@ -1185,30 +1266,37 @@ class ParallelStage(BaseStage):  # pragma: no cov
         result: Result | None = None,
         event: Event | None = None,
     ) -> Result:
-        """Execute the stages that parallel each branch via multi-threading mode
-        or async mode by changing `async_mode` flag.
+        """Execute parallel each branch via multi-threading pool.
 
-        :param params: A parameter that want to pass before run any statement.
-        :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.
+        :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.
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
         event: Event = Event() if event is None else event
         result.trace.info(
             f"[STAGE]: Parallel-Execute: {self.max_workers} workers."
         )
         result.catch(status=WAIT, context={"parallel": {}})
+        if event and event.is_set():  # pragma: no cov
+            return result.catch(
+                status=CANCEL,
+                context={
+                    "errors": StageException(
+                        "Stage was canceled from event that had set "
+                        "before stage parallel execution."
+                    ).to_dict()
+                },
+            )
+
         with ThreadPoolExecutor(
-            max_workers=self.max_workers,
-            thread_name_prefix="parallel_stage_exec_",
+            max_workers=self.max_workers, thread_name_prefix="stage_parallel_"
         ) as executor:
 
             context: DictData = {}
@@ -1216,36 +1304,36 @@ class ParallelStage(BaseStage):  # pragma: no cov
 
             futures: list[Future] = (
                 executor.submit(
-                    self.execute_task,
+                    self.execute_branch,
                     branch=branch,
                     params=params,
                     result=result,
                     event=event,
-                    extras=self.extras,
                 )
                 for branch in self.parallel
             )
 
-            done = as_completed(futures, timeout=1800)
-            for future in done:
+            for future in as_completed(futures):
                 try:
                     future.result()
                 except StageException as e:
                     status = FAILED
                     result.trace.error(
-                        f"[STAGE]: {e.__class__.__name__}:\n\t{e}"
+                        f"[STAGE]: {e.__class__.__name__}:{NEWLINE}{e}"
                     )
-                    context.update({"errors": e.to_dict()})
-
+                    if "errors" in context:
+                        context["errors"].append(e.to_dict())
+                    else:
+                        context["errors"] = [e.to_dict()]
         return result.catch(status=status, context=context)
 
 
 class ForEachStage(BaseStage):
-    """For-Each execution stage that execute child stages with an item in list
-    of item values. This stage is not the low-level stage model because it runs
-    muti-stages in this stage execution.
+    """For-Each stage executor that execute all stages with each item in the
+    foreach list.
 
-        The concept of this stage use the same logic of the Job execution.
+        This stage is not the low-level stage model because it runs
+    multi-stages in this stage execution.
 
     Data Validate:
         >>> stage = {
@@ -1254,7 +1342,7 @@ class ForEachStage(BaseStage):
         ...     "stages": [
         ...         {
         ...             "name": "Echo stage",
-        ...             "echo": "Start run with item {{ item }}"
+        ...             "echo": "Start run with item ${{ item }}"
         ...         },
         ...     ],
         ... }
@@ -1262,13 +1350,14 @@ class ForEachStage(BaseStage):
 
     foreach: Union[list[str], list[int], str] = Field(
         description=(
-            "A items for passing to each stages via ${{ item }} template."
+            "A items for passing to stages via ${{ item }} template parameter."
         ),
     )
     stages: list[Stage] = Field(
         default_factory=list,
         description=(
-            "A list of stage that will run with each item in the foreach field."
+            "A list of stage that will run with each item in the `foreach` "
+            "field."
         ),
     )
     concurrent: int = Field(
@@ -1283,27 +1372,25 @@ class ForEachStage(BaseStage):
 
     def execute_item(
         self,
-        item: Union[str, int],
+        item: StrOrInt,
         params: DictData,
         result: Result,
         *,
         event: Event | None = None,
     ) -> Result:
-        """Execute foreach item from list of item.
+        """Execute all stage with specific foreach item.
 
         :param item: (str | int) An item that want to execution.
-        :param params: (DictData) A parameter that want to pass to stage
-            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.
+        :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.
 
         :raise StageException: If the stage execution raise errors.
 
         :rtype: Result
         """
-        result.trace.debug(f"[STAGE]: Execute item: {item!r}")
+        result.trace.debug(f"[STAGE]: Execute Item: {item!r}")
         context: DictData = copy.deepcopy(params)
         context.update({"item": item})
         output: DictData = {"item": item, "stages": {}}
@@ -1313,7 +1400,7 @@ class ForEachStage(BaseStage):
                 stage.extras = self.extras
 
             if stage.is_skipped(params=context):
-                result.trace.info(f"... Skip stage: {stage.iden!r}")
+                result.trace.info(f"[STAGE]: Skip stage: {stage.iden!r}")
                 stage.set_outputs(output={"skipped": True}, to=output)
                 continue
 
@@ -1344,9 +1431,21 @@ class ForEachStage(BaseStage):
                 stage.set_outputs(rs.context, to=output)
                 stage.set_outputs(stage.get_outputs(output), to=context)
             except (StageException, UtilException) as e:
-                result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
+                result.trace.error(
+                    f"[STAGE]: {e.__class__.__name__}:{NEWLINE}{e}"
+                )
+                result.catch(
+                    status=FAILED,
+                    foreach={
+                        item: {
+                            "item": item,
+                            "stages": filter_func(output.pop("stages", {})),
+                            "errors": e.to_dict(),
+                        },
+                    },
+                )
                 raise StageException(
-                    f"Sub-Stage execution error: {e.__class__.__name__}: {e}"
+                    f"Sub-Stage raise: {e.__class__.__name__}: {e}"
                 ) from None
 
             if rs.status == FAILED:
@@ -1354,7 +1453,8 @@ class ForEachStage(BaseStage):
                     f"Item-Stage was break because it has a sub stage, "
                     f"{stage.iden}, failed without raise error."
                 )
-                return result.catch(
+                result.trace.warning(f"[STAGE]: {error_msg}")
+                result.catch(
                     status=FAILED,
                     foreach={
                         item: {
@@ -1364,6 +1464,8 @@ class ForEachStage(BaseStage):
                         },
                     },
                 )
+                raise StageException(error_msg)
+
         return result.catch(
             status=SUCCESS,
             foreach={
@@ -1383,29 +1485,29 @@ class ForEachStage(BaseStage):
     ) -> Result:
         """Execute the stages that pass each item form the foreach field.
 
-        :param params: A parameter that want to pass before run any statement.
-        :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.
+        :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.
+
+        :raise TypeError: If the foreach does not match with type list.
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
         event: Event = Event() if event is None else event
         foreach: Union[list[str], list[int]] = (
             param2template(self.foreach, params, extras=self.extras)
             if isinstance(self.foreach, str)
             else self.foreach
         )
+
+        # [VALIDATE]: Type of the foreach should be `list` type.
         if not isinstance(foreach, list):
-            raise StageException(
-                f"Foreach does not support foreach value: {foreach!r}"
-            )
+            raise TypeError(f"Does not support foreach: {foreach!r}")
 
         result.trace.info(f"[STAGE]: Foreach-Execute: {foreach!r}.")
         result.catch(status=WAIT, context={"items": foreach, "foreach": {}})
@@ -1437,33 +1539,36 @@ class ForEachStage(BaseStage):
             context: DictData = {}
             status: Status = SUCCESS
 
-            done, not_done = wait(
-                futures, timeout=1800, return_when=FIRST_EXCEPTION
-            )
-
+            done, not_done = wait(futures, return_when=FIRST_EXCEPTION)
             if len(done) != len(futures):
                 result.trace.warning(
-                    "[STAGE]: Set the event for stop running stage."
+                    "[STAGE]: Set event for stop pending stage future."
                 )
                 event.set()
                 for future in not_done:
                     future.cancel()
 
+                nd: str = f", item not run: {not_done}" if not_done else ""
+                result.trace.debug(f"... Foreach set Fail-Fast{nd}")
+
             for future in done:
                 try:
                     future.result()
                 except StageException as e:
                     status = FAILED
                     result.trace.error(
-                        f"[STAGE]: {e.__class__.__name__}:\n\t{e}"
+                        f"[STAGE]: {e.__class__.__name__}:{NEWLINE}{e}"
                     )
                     context.update({"errors": e.to_dict()})
-
         return result.catch(status=status, context=context)
 
 
-class UntilStage(BaseStage):  # pragma: no cov
-    """Until execution stage.
+class UntilStage(BaseStage):
+    """Until stage executor that will run stages in each loop until it valid
+    with stop loop condition.
+
+        This stage is not the low-level stage model because it runs
+    multi-stages in this stage execution.
 
     Data Validate:
         >>> stage = {
@@ -1485,23 +1590,25 @@ class UntilStage(BaseStage):  # pragma: no cov
             "An initial value that can be any value in str, int, or bool type."
         ),
     )
-    until: str = Field(description="A until condition.")
+    until: str = Field(description="A until condition for stop the while loop.")
     stages: list[Stage] = Field(
         default_factory=list,
         description=(
-            "A list of stage that will run with each item until condition "
-            "correct."
+            "A list of stage that will run with each item in until loop."
         ),
     )
     max_loop: int = Field(
         default=10,
         ge=1,
         lt=100,
-        description="The maximum value of loop for this until stage.",
+        description=(
+            "The maximum value of loop for this until stage. This value should "
+            "be gather or equal than 1, and less than 100."
+        ),
         alias="max-loop",
     )
 
-    def execute_item(
+    def execute_loop(
         self,
         item: T,
         loop: int,
@@ -1509,19 +1616,17 @@ class UntilStage(BaseStage):  # pragma: no cov
         result: Result,
         event: Event | None = None,
     ) -> tuple[Result, T]:
-        """Execute until item set item by some stage or by default loop
-        variable.
+        """Execute all stage with specific loop and item.
 
         :param item: (T) An item that want to execution.
         :param loop: (int) A number of loop.
-        :param params: (DictData) A parameter that want to pass to stage
-            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.
+        :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.
 
         :rtype: tuple[Result, T]
+        :return: Return a pair of Result and changed item.
         """
         result.trace.debug(f"... Execute until item: {item!r}")
         context: DictData = copy.deepcopy(params)
@@ -1534,14 +1639,14 @@ class UntilStage(BaseStage):  # pragma: no cov
                 stage.extras = self.extras
 
             if stage.is_skipped(params=context):
-                result.trace.info(f"... Skip stage: {stage.iden!r}")
+                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 from event that had set before "
-                    "stage item execution."
+                    "Loop-Stage was canceled from event that had set before "
+                    "stage loop execution."
                 )
                 return (
                     result.catch(
@@ -1573,11 +1678,42 @@ class UntilStage(BaseStage):  # pragma: no cov
 
                 stage.set_outputs(_output, to=context)
             except (StageException, UtilException) as e:
-                result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
+                result.trace.error(
+                    f"[STAGE]: {e.__class__.__name__}:{NEWLINE}{e}"
+                )
+                result.catch(
+                    status=FAILED,
+                    until={
+                        loop: {
+                            "loop": loop,
+                            "item": item,
+                            "stages": filter_func(output.pop("stages", {})),
+                            "errors": e.to_dict(),
+                        }
+                    },
+                )
                 raise StageException(
                     f"Sub-Stage execution error: {e.__class__.__name__}: {e}"
                 ) from None
 
+            if rs.status == FAILED:
+                error_msg: str = (
+                    f"Loop-Stage was break because it has a sub stage, "
+                    f"{stage.iden}, failed without raise error."
+                )
+                result.catch(
+                    status=FAILED,
+                    until={
+                        loop: {
+                            "loop": loop,
+                            "item": item,
+                            "stages": filter_func(output.pop("stages", {})),
+                            "errors": StageException(error_msg).to_dict(),
+                        }
+                    },
+                )
+                raise StageException(error_msg)
+
         return (
             result.catch(
                 status=SUCCESS,
@@ -1599,21 +1735,19 @@ class UntilStage(BaseStage):  # pragma: no cov
         result: Result | None = None,
         event: Event | None = None,
     ) -> Result:
-        """Execute the stages that pass item from until condition field and
-        setter step.
+        """Execute until loop with checking until condition.
 
-        :param params: A parameter that want to pass before run any statement.
-        :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.
+        :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.
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True)
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
 
         result.trace.info(f"[STAGE]: Until-Execution: {self.until}")
         item: Union[str, int, bool] = param2template(
@@ -1631,12 +1765,12 @@ class UntilStage(BaseStage):  # pragma: no cov
                     context={
                         "errors": StageException(
                             "Stage was canceled from event that had set "
-                            "before stage until execution."
+                            "before stage loop execution."
                         ).to_dict()
                     },
                 )
 
-            result, item = self.execute_item(
+            result, item = self.execute_loop(
                 item=item,
                 loop=loop,
                 params=params,
@@ -1647,10 +1781,10 @@ class UntilStage(BaseStage):  # pragma: no cov
             loop += 1
             if item is None:
                 result.trace.warning(
-                    "... Does not have set item stage. It will use loop by "
-                    "default."
+                    f"... Loop-Execute not set item. It use loop: {loop} by "
+                    f"default."
                 )
-                item = loop
+                item: int = loop
 
             next_track: bool = eval(
                 param2template(
@@ -1663,8 +1797,8 @@ class UntilStage(BaseStage):  # pragma: no cov
             )
             if not isinstance(next_track, bool):
                 raise StageException(
-                    "Return type of until condition does not be boolean, it"
-                    f"return: {next_track!r}"
+                    "Return type of until condition not be `boolean`, getting"
+                    f": {next_track!r}"
                 )
             track: bool = not next_track
             delay(0.025)
@@ -1679,14 +1813,14 @@ class UntilStage(BaseStage):  # pragma: no cov
 class Match(BaseModel):
     """Match model for the Case Stage."""
 
-    case: Union[str, int] = Field(description="A match case.")
+    case: StrOrInt = Field(description="A match case.")
     stages: list[Stage] = Field(
         description="A list of stage to execution for this case."
     )
 
 
 class CaseStage(BaseStage):
-    """Case execution stage.
+    """Case stage executor that execute all stages if the condition was matched.
 
     Data Validate:
         >>> stage = {
@@ -1742,19 +1876,16 @@ class CaseStage(BaseStage):
 
         :param case: (str) A case that want to execution.
         :param stages: (list[Stage]) A list of stage.
-        :param params: (DictData) A parameter that want to pass to stage
-            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.
+        :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.
 
         :rtype: Result
         """
         context: DictData = copy.deepcopy(params)
         context.update({"case": case})
         output: DictData = {"case": case, "stages": {}}
-
         for stage in stages:
 
             if self.extras:
@@ -1830,19 +1961,17 @@ class CaseStage(BaseStage):
     ) -> Result:
         """Execute case-match condition that pass to the case field.
 
-        :param params: A parameter that want to pass before run any statement.
-        :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.
+        :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.
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
 
         _case: Optional[str] = param2template(
             self.case, params, extras=self.extras
@@ -1898,7 +2027,7 @@ class CaseStage(BaseStage):
 
 
 class RaiseStage(BaseStage):  # pragma: no cov
-    """Raise error stage execution that raise StageException that use a message
+    """Raise error stage executor that raise `StageException` that use a message
     field for making error message before raise.
 
     Data Validate:
@@ -1911,7 +2040,7 @@ class RaiseStage(BaseStage):  # pragma: no cov
 
     message: str = Field(
         description=(
-            "An error message that want to raise with StageException class"
+            "An error message that want to raise with `StageException` class"
         ),
         alias="raise",
     )
@@ -1925,43 +2054,27 @@ class RaiseStage(BaseStage):  # pragma: no cov
     ) -> Result:
         """Raise the StageException object with the message field execution.
 
-        :param params: A parameter that want to pass before run any statement.
-        :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.
+        :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.
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True),
-                extras=self.extras,
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
         message: str = param2template(self.message, params, extras=self.extras)
         result.trace.info(f"[STAGE]: Raise-Execute: {message!r}.")
         raise StageException(message)
 
 
-# TODO: Not implement this stages yet
-class HookStage(BaseStage):  # pragma: no cov
-    """Hook stage execution."""
-
-    hook: str
-    args: DictData = Field(default_factory=dict)
-    callback: str
-
-    def execute(
-        self,
-        params: DictData,
-        *,
-        result: Result | None = None,
-        event: Event | None = None,
-    ) -> Result:
-        raise NotImplementedError("Hook Stage does not implement yet.")
-
-
-# TODO: Not implement this stages yet
 class DockerStage(BaseStage):  # pragma: no cov
-    """Docker container stage execution.
+    """Docker container stage execution that will pull the specific Docker image
+    with custom authentication and run this image by passing environment
+    variables and mounting local volume to this Docker container.
+
+        The volume path that mount to this Docker container will limit. That is
+    this stage does not allow you to mount any path to this container.
 
     Data Validate:
         >>> stage = {
@@ -1969,10 +2082,7 @@ class DockerStage(BaseStage):  # pragma: no cov
         ...     "image": "image-name.pkg.com",
         ...     "env": {
         ...         "ENV": "dev",
-        ...         "DEBUG": "true",
-        ...     },
-        ...     "volume": {
-        ...         "secrets": "/secrets",
+        ...         "SECRET": "${SPECIFIC_SECRET}",
         ...     },
         ...     "auth": {
         ...         "username": "__json_key",
@@ -1985,8 +2095,16 @@ class DockerStage(BaseStage):  # pragma: no cov
         description="A Docker image url with tag that want to run.",
     )
     tag: str = Field(default="latest", description="An Docker image tag.")
-    env: DictData = Field(default_factory=dict)
-    volume: DictData = Field(default_factory=dict)
+    env: DictData = Field(
+        default_factory=dict,
+        description=(
+            "An environment variable that want pass to Docker container.",
+        ),
+    )
+    volume: DictData = Field(
+        default_factory=dict,
+        description="A mapping of local and target mounting path.",
+    )
     auth: DictData = Field(
         default_factory=dict,
         description=(
@@ -1998,7 +2116,17 @@ class DockerStage(BaseStage):  # pragma: no cov
         self,
         params: DictData,
         result: Result,
-    ):
+        event: Event | None = None,
+    ) -> Result:
+        """Execute Docker container task.
+
+        :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.
+
+        :rtype: Result
+        """
         from docker import DockerClient
         from docker.errors import ContainerError
 
@@ -2016,6 +2144,16 @@ class DockerStage(BaseStage):  # pragma: no cov
         for line in resp:
             result.trace.info(f"... {line}")
 
+        if event and event.is_set():
+            error_msg: str = (
+                "Docker-Stage was canceled from event that had set before "
+                "run the Docker container."
+            )
+            return result.catch(
+                status=CANCEL,
+                context={"errors": StageException(error_msg).to_dict()},
+            )
+
         unique_image_name: str = f"{self.image}_{datetime.now():%Y%m%d%H%M%S%f}"
         container = client.containers.run(
             image=f"{self.image}:{self.tag}",
@@ -2054,6 +2192,13 @@ class DockerStage(BaseStage):  # pragma: no cov
                 f"{self.image}:{self.tag}",
                 out,
             )
+        output_file: Path = Path(f".docker.{result.run_id}.logs/outputs.json")
+        if not output_file.exists():
+            return result.catch(status=SUCCESS)
+
+        with output_file.open(mode="rt") as f:
+            data = json.load(f)
+        return result.catch(status=SUCCESS, context=data)
 
     def execute(
         self,
@@ -2062,13 +2207,34 @@ class DockerStage(BaseStage):  # pragma: no cov
         result: Result | None = None,
         event: Event | None = None,
     ) -> Result:
+        """Execute the Docker image via Python API.
+
+        :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.
+
+        :rtype: Result
+        """
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
+
+        result.trace.info(f"[STAGE]: Docker-Execute: {self.image}:{self.tag}")
+
         raise NotImplementedError("Docker Stage does not implement yet.")
 
 
-# TODO: Not implement this stages yet
 class VirtualPyStage(PyStage):  # pragma: no cov
-    """Python Virtual Environment stage execution."""
+    """Virtual Python stage executor that run Python statement on the dependent
+    Python virtual environment via the `uv` package.
+    """
 
+    version: str = Field(
+        default="3.9",
+        description="A Python version that want to run.",
+    )
     deps: list[str] = Field(
         description=(
             "list of Python dependency that want to install before execution "
@@ -2076,7 +2242,54 @@ class VirtualPyStage(PyStage):  # pragma: no cov
         ),
     )
 
-    def create_py_file(self, py: str, run_id: str | None): ...
+    @contextlib.contextmanager
+    def create_py_file(
+        self,
+        py: str,
+        values: DictData,
+        deps: list[str],
+        run_id: str | None = None,
+    ) -> Iterator[str]:
+        """Create the .py file with an input Python string statement.
+
+        :param py: A Python string statement.
+        :param values: A variable that want to set before running this
+        :param deps: An additional Python dependencies that want install before
+            run this python stage.
+        :param run_id: (str | None) A running ID of this stage execution.
+        """
+        run_id: str = run_id or uuid.uuid4()
+        f_name: str = f"{run_id}.py"
+        with open(f"./{f_name}", mode="w", newline="\n") as f:
+            # NOTE: Create variable mapping that write before running statement.
+            vars_str: str = "\n ".join(
+                f"{var} = {value!r}" for var, value in values.items()
+            )
+
+            # NOTE: uv supports PEP 723 — inline TOML metadata.
+            f.write(
+                dedent(
+                    f"""
+                    # /// script
+                    # dependencies = [{', '.join(f'"{dep}"' for dep in deps)}]
+                    # ///
+                    {vars_str}
+                    """.strip(
+                        "\n"
+                    )
+                )
+            )
+
+            # NOTE: make sure that py script file does not have `\r` char.
+            f.write("\n" + py.replace("\r\n", "\n"))
+
+        # NOTE: Make this .py file able to executable.
+        make_exec(f"./{f_name}")
+
+        yield f_name
+
+        # Note: Remove .py file that use to run Python.
+        Path(f"./{f_name}").unlink()
 
     def execute(
         self,
@@ -2088,31 +2301,61 @@ class VirtualPyStage(PyStage):  # pragma: no cov
         """Execute the Python statement via Python virtual environment.
 
         Steps:
-            - Create python file.
-            - Create `.venv` and install necessary Python deps.
-            - Execution python file with uv and specific `.venv`.
+            - Create python file with the `uv` syntax.
+            - Execution python file with `uv run` via Python subprocess module.
 
-        :param params: A parameter that want to pass before run any statement.
-        :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.
+        :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.
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(
-                run_id=gen_id(self.name + (self.id or ""), unique=True)
-            )
+        result: Result = result or Result(
+            run_id=gen_id(self.name + (self.id or ""), unique=True),
+            extras=self.extras,
+        )
 
         result.trace.info(f"[STAGE]: Py-Virtual-Execute: {self.name}")
-        raise NotImplementedError(
-            "Python Virtual Stage does not implement yet."
+        run: str = param2template(dedent(self.run), params, extras=self.extras)
+        with self.create_py_file(
+            py=run,
+            values=param2template(self.vars, params, extras=self.extras),
+            deps=param2template(self.deps, params, extras=self.extras),
+            run_id=result.run_id,
+        ) as py:
+            result.trace.debug(f"... Create `{py}` file.")
+            rs: CompletedProcess = subprocess.run(
+                ["uv", "run", py, "--no-cache"],
+                # ["uv", "run", "--python", "3.9", py],
+                shell=False,
+                capture_output=True,
+                text=True,
+            )
+
+        if rs.returncode > 0:
+            # NOTE: Prepare stderr message that returning from subprocess.
+            e: str = (
+                rs.stderr.encode("utf-8").decode("utf-16")
+                if "\\x00" in rs.stderr
+                else rs.stderr
+            ).removesuffix("\n")
+            raise StageException(
+                f"Subprocess: {e}\nRunning Statement:\n---\n"
+                f"```python\n{run}\n```"
+            )
+        return result.catch(
+            status=SUCCESS,
+            context={
+                "return_code": rs.returncode,
+                "stdout": None if (out := rs.stdout.strip("\n")) == "" else out,
+                "stderr": None if (out := rs.stderr.strip("\n")) == "" else out,
+            },
         )
 
 
 # NOTE:
-#   An order of parsing stage model on the Job model with ``stages`` field.
+#   An order of parsing stage model on the Job model with `stages` field.
 #   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.
 #
@@ -2121,7 +2364,6 @@ Stage = Annotated[
         DockerStage,
         BashStage,
         CallStage,
-        HookStage,
         TriggerStage,
         ForEachStage,
         UntilStage,