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

ddeutil/workflow/workflow.py

@@ -3,12 +3,14 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-# [x] Use dynamic config
-"""Workflow module is the core module of this Workflow package. It keeps
-Release, ReleaseQueue, and Workflow Pydantic models.
+"""Workflow module is the core module of this package. It keeps Release,
+ReleaseQueue, and Workflow models.
 
     This package implement timeout strategy on the workflow execution layer only
 because the main propose of this package is using Workflow to be orchestrator.
+
+    ReleaseQueue is the memory storage of Release for tracking this release
+already run or pending in the current session.
 """
 from __future__ import annotations
 
@@ -27,30 +29,32 @@ from heapq import heappop, heappush
 from pathlib import Path
 from queue import Queue
 from textwrap import dedent
-from threading import Event
-from typing import Optional
+from threading import Event, Lock
+from typing import Any, Optional, Union
+from zoneinfo import ZoneInfo
 
 from pydantic import BaseModel, ConfigDict, Field, ValidationInfo
 from pydantic.dataclasses import dataclass
 from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
-from .__cron import CronJob, CronRunner
+from .__cron import CronRunner
 from .__types import DictData, TupleStr
-from .conf import Loader, SimLoad, dynamic
-from .cron import On
-from .exceptions import JobException, UtilException, WorkflowException
+from .conf import FileLoad, Loader, dynamic
+from .event import On
+from .exceptions import WorkflowException
 from .job import Job
 from .logs import Audit, get_audit
 from .params import Param
-from .result import FAILED, SKIP, SUCCESS, WAIT, Result
+from .result import CANCEL, FAILED, SKIP, SUCCESS, WAIT, Result
 from .reusables import has_template, param2template
 from .utils import (
-    NEWLINE,
+    clear_tz,
     gen_id,
     get_dt_now,
     reach_next_minute,
-    wait_to_next_minute,
+    replace_sec,
+    wait_until_next_minute,
 )
 
 __all__: TupleStr = (
@@ -66,46 +70,50 @@ class ReleaseType(str, Enum):
     """Release Type Enum support the type field on the Release dataclass."""
 
     DEFAULT: str = "manual"
-    TASK: str = "task"
-    POKE: str = "poking"
+    SCHEDULE: str = "schedule"
+    POKING: str = "poking"
+    FORCE: str = "force"
 
 
 @total_ordering
-@dataclass(
-    config=ConfigDict(arbitrary_types_allowed=True, use_enum_values=True)
-)
+@dataclass(config=ConfigDict(use_enum_values=True))
 class Release:
-    """Release Pydantic dataclass object that use for represent the release data
-    that use with the `workflow.release` method.
-    """
+    """Release object that use for represent the release datetime."""
 
-    date: datetime
-    offset: float
-    end_date: datetime
-    runner: CronRunner
-    type: ReleaseType = field(default=ReleaseType.DEFAULT)
+    date: datetime = Field(
+        description=(
+            "A release date that should has second and millisecond equal 0."
+        )
+    )
+    type: ReleaseType = Field(
+        default=ReleaseType.DEFAULT,
+        description="A type of release that create before start execution.",
+    )
 
     def __repr__(self) -> str:
-        """Represent string"""
+        """Override __repr__ method for represent value of `date` field.
+
+        :rtype: str
+        """
         return repr(f"{self.date:%Y-%m-%d %H:%M:%S}")
 
     def __str__(self) -> str:
-        """Override string value of this release object with the date field.
+        """Override string value of this release object with the `date` field.
 
         :rtype: str
         """
         return f"{self.date:%Y-%m-%d %H:%M:%S}"
 
     @classmethod
-    def from_dt(
-        cls, dt: datetime | str, *, extras: Optional[DictData] = None
-    ) -> Self:
-        """Construct Release via datetime object only.
+    def from_dt(cls, dt: datetime | str) -> Self:
+        """Construct Release object from `datetime` or `str` objects.
+
+            This method will replace second and millisecond value to 0 and
+        replace timezone to the `tz` config setting or extras overriding before
+        create Release object.
 
         :param dt: (datetime | str) A datetime object or string that want to
             construct to the Release object.
-        :param extras: (DictData) An extra parameters that want to pass to
-            override config values.
 
         :raise TypeError: If the type of the dt argument does not valid with
             datetime or str object.
@@ -116,20 +124,10 @@ class Release:
             dt: datetime = datetime.fromisoformat(dt)
         elif not isinstance(dt, datetime):
             raise TypeError(
-                "The `from_dt` need the `dt` argument type be str or datetime "
-                "only."
+                f"The `from_dt` need the `dt` parameter type be `str` or "
+                f"`datetime` only, not {type(dt)}."
             )
-
-        return cls(
-            date=dt,
-            offset=0,
-            end_date=dt + timedelta(days=1),
-            runner=(
-                CronJob("* * * * *").schedule(
-                    dt.replace(tzinfo=dynamic("tz", extras=extras))
-                )
-            ),
-        )
+        return cls(date=replace_sec(dt.replace(tzinfo=None)))
 
     def __eq__(self, other: Release | datetime) -> bool:
         """Override equal property that will compare only the same type or
@@ -144,7 +142,7 @@ class Release:
         return NotImplemented
 
     def __lt__(self, other: Release | datetime) -> bool:
-        """Override equal property that will compare only the same type or
+        """Override less-than property that will compare only the same type or
         datetime.
 
         :rtype: bool
@@ -156,31 +154,33 @@ class Release:
         return NotImplemented
 
 
-@dataclass
 class ReleaseQueue:
-    """Workflow Queue object that is management of Release objects."""
+    """ReleaseQueue object that is storage management of Release objects on
+    the memory with list object.
+    """
 
-    queue: list[Release] = field(default_factory=list)
-    running: list[Release] = field(default_factory=list)
-    complete: list[Release] = field(default_factory=list)
-    extras: DictData = Field(
-        default_factory=dict,
-        description="An extra parameters that want to override config values.",
-        repr=False,
-    )
+    def __init__(
+        self,
+        queue: Optional[list[Release]] = None,
+        running: Optional[list[Release]] = None,
+        complete: Optional[list[Release]] = None,
+        extras: Optional[DictData] = None,
+    ):
+        self.queue: list[Release] = queue or []
+        self.running: list[Release] = running or []
+        self.complete: list[Release] = complete or []
+        self.extras: DictData = extras or {}
+        self.lock: Lock = Lock()
 
     @classmethod
     def from_list(
         cls,
-        queue: list[datetime] | list[Release] | None = None,
-        extras: Optional[DictData] = None,
+        queue: Optional[Union[list[datetime], list[Release]]] = None,
     ) -> Self:
         """Construct ReleaseQueue object from an input queue value that passing
         with list of datetime or list of Release.
 
-        :param queue:
-        :param extras: An extra parameter that want to override core config
-            values.
+        :param queue: A queue object for create ReleaseQueue instance.
 
         :raise TypeError: If the type of input queue does not valid.
 
@@ -190,13 +190,8 @@ class ReleaseQueue:
             return cls()
 
         if isinstance(queue, list):
-
             if all(isinstance(q, datetime) for q in queue):
-                return cls(
-                    queue=[
-                        Release.from_dt(q, extras=(extras or {})) for q in queue
-                    ]
-                )
+                return cls(queue=[Release.from_dt(q) for q in queue])
 
             if all(isinstance(q, Release) for q in queue):
                 return cls(queue=queue)
@@ -224,30 +219,39 @@ class ReleaseQueue:
         :rtype: bool
         """
         if isinstance(value, datetime):
-            value = Release.from_dt(value, extras=self.extras)
+            value = Release.from_dt(value)
 
-        return (
-            (value in self.queue)
-            or (value in self.running)
-            or (value in self.complete)
-        )
+        with self.lock:
+            return (
+                (value in self.queue)
+                or (value in self.running)
+                or (value in self.complete)
+            )
 
     def mark_complete(self, value: Release) -> Self:
-        """Push Release to the complete queue.
+        """Push Release to the complete queue. After push the release, it will
+        delete old release base on the `CORE_MAX_QUEUE_COMPLETE_HIST` value.
+
+        :param value: (Release) A Release value that want to push to the
+            complete field.
 
         :rtype: Self
         """
-        heappush(self.complete, value)
+        with self.lock:
+            if value in self.running:
+                self.running.remove(value)
 
-        # NOTE: Remove complete queue on workflow that keep more than the
-        #   maximum config value.
-        num_complete_delete: int = len(self.complete) - dynamic(
-            "max_queue_complete_hist", extras=self.extras
-        )
+            heappush(self.complete, value)
+
+            # NOTE: Remove complete queue on workflow that keep more than the
+            #   maximum config value.
+            num_complete_delete: int = len(self.complete) - dynamic(
+                "max_queue_complete_hist", extras=self.extras
+            )
 
-        if num_complete_delete > 0:
-            for _ in range(num_complete_delete):
-                heappop(self.complete)
+            if num_complete_delete > 0:
+                for _ in range(num_complete_delete):
+                    heappop(self.complete)
 
         return self
 
@@ -258,11 +262,10 @@ class ReleaseQueue:
         runner: CronRunner,
         name: str,
         *,
-        offset: float = 0,
         force_run: bool = False,
         extras: Optional[DictData] = None,
     ) -> Self:
-        """Generate Release model to queue.
+        """Generate a Release model to the queue field with an input CronRunner.
 
         Steps:
             - Create Release object from the current date that not reach the end
@@ -274,50 +277,44 @@ class ReleaseQueue:
         :param end_date: (datetime) An end datetime object.
         :param audit: (type[Audit]) An audit class that want to make audit
             instance.
-        :param runner: (CronRunner) A CronRunner object.
+        :param runner: (CronRunner) A `CronRunner` object.
         :param name: (str) A target name that want to check at pointer of audit.
-        :param offset: (float) An offset in second unit for time travel.
-        :param force_run: A flag that allow to release workflow if the audit
-            with that release was pointed.
-        :param extras: An extra parameter that want to override core config.
+        :param force_run: (bool) A flag that allow to release workflow if the
+            audit with that release was pointed. (Default is False).
+        :param extras: (DictDatA) An extra parameter that want to override core
+            config values.
 
         :rtype: ReleaseQueue
 
         """
-        if runner.date > end_date:
+        if clear_tz(runner.date) > clear_tz(end_date):
             return self
 
-        workflow_release = Release(
-            date=runner.date,
-            offset=offset,
-            end_date=end_date,
-            runner=runner,
-            type=ReleaseType.POKE,
+        release = Release(
+            date=clear_tz(runner.date),
+            type=(ReleaseType.FORCE if force_run else ReleaseType.POKING),
         )
 
-        while self.check_queue(workflow_release) or (
-            audit.is_pointed(
-                name=name, release=workflow_release.date, extras=extras
-            )
+        while self.check_queue(release) or (
+            audit.is_pointed(name=name, release=release.date, extras=extras)
             and not force_run
         ):
-            workflow_release = Release(
-                date=runner.next,
-                offset=offset,
-                end_date=end_date,
-                runner=runner,
-                type=ReleaseType.POKE,
+            release = Release(
+                date=clear_tz(runner.next),
+                type=(ReleaseType.FORCE if force_run else ReleaseType.POKING),
             )
 
-        if runner.date > end_date:
+        if clear_tz(runner.date) > clear_tz(end_date):
             return self
 
-        heappush(self.queue, workflow_release)
+        with self.lock:
+            heappush(self.queue, release)
+
         return self
 
 
 class Workflow(BaseModel):
-    """Workflow Pydantic model.
+    """Workflow model that use to keep the `Job` and `On` models.
 
         This is the main future of this project because it uses to be workflow
     data for running everywhere that you want or using it to scheduler task in
@@ -355,6 +352,7 @@ class Workflow(BaseModel):
         cls,
         name: str,
         *,
+        path: Optional[Path] = None,
         extras: DictData | None = None,
         loader: type[Loader] = None,
     ) -> Self:
@@ -362,45 +360,8 @@ class Workflow(BaseModel):
         an input workflow name. The loader object will use this workflow name to
         searching configuration data of this workflow model in conf path.
 
-        :param name: A workflow name that want to pass to Loader object.
-        :param extras: An extra parameters that want to pass to Loader
-            object.
-        :param loader: A loader class for override default loader object.
-
-        :raise ValueError: If the type does not match with current object.
-
-        :rtype: Self
-        """
-        loader: Loader = (loader or Loader)(name, externals=(extras or {}))
-
-        # NOTE: Validate the config type match with current connection model
-        if loader.type != cls.__name__:
-            raise ValueError(f"Type {loader.type} does not match with {cls}")
-
-        loader_data: DictData = copy.deepcopy(loader.data)
-        loader_data["name"] = name.replace(" ", "_")
-
-        if extras:
-            loader_data["extras"] = extras
-
-        cls.__bypass_on__(loader_data, path=loader.conf_path, extras=extras)
-        return cls.model_validate(obj=loader_data)
-
-    @classmethod
-    def from_path(
-        cls,
-        name: str,
-        path: Path,
-        *,
-        extras: DictData | None = None,
-        loader: type[Loader] = None,
-    ) -> Self:
-        """Create Workflow instance from the specific path. The loader object
-        will use this workflow name and path to searching configuration data of
-        this workflow model.
-
         :param name: (str) A workflow name that want to pass to Loader object.
-        :param path: (Path) A config path that want to search.
+        :param path: (Path) An override config path.
         :param extras: (DictData) An extra parameters that want to override core
             config values.
         :param loader: A loader class for override default loader object.
@@ -409,21 +370,21 @@ class Workflow(BaseModel):
 
         :rtype: Self
         """
-        loader: SimLoad = (loader or SimLoad)(
-            name, conf_path=path, externals=(extras or {})
-        )
+        loader: type[Loader] = loader or FileLoad
+        load: Loader = loader(name, path=path, extras=extras)
+
         # NOTE: Validate the config type match with current connection model
-        if loader.type != cls.__name__:
-            raise ValueError(f"Type {loader.type} does not match with {cls}")
+        if load.type != cls.__name__:
+            raise ValueError(f"Type {load.type} does not match with {cls}")
 
-        loader_data: DictData = copy.deepcopy(loader.data)
-        loader_data["name"] = name.replace(" ", "_")
+        data: DictData = copy.deepcopy(load.data)
+        data["name"] = name
 
         if extras:
-            loader_data["extras"] = extras
+            data["extras"] = extras
 
-        cls.__bypass_on__(loader_data, path=path, extras=extras)
-        return cls.model_validate(obj=loader_data)
+        cls.__bypass_on__(data, path=load.path, extras=extras, loader=loader)
+        return cls.model_validate(obj=data)
 
     @classmethod
     def __bypass_on__(
@@ -431,6 +392,7 @@ class Workflow(BaseModel):
         data: DictData,
         path: Path,
         extras: DictData | None = None,
+        loader: type[Loader] = None,
     ) -> DictData:
         """Bypass the on data to loaded config data.
 
@@ -451,7 +413,7 @@ class Workflow(BaseModel):
             #   field.
             data["on"] = [
                 (
-                    SimLoad(n, conf_path=path, externals=(extras or {})).data
+                    (loader or FileLoad)(n, path=path, extras=extras).data
                     if isinstance(n, str)
                     else n
                 )
@@ -460,11 +422,10 @@ class Workflow(BaseModel):
         return data
 
     @model_validator(mode="before")
-    def __prepare_model_before__(cls, values: DictData) -> DictData:
+    def __prepare_model_before__(cls, data: Any) -> Any:
         """Prepare the params key in the data model before validating."""
-        # NOTE: Prepare params type if it is passing with only type value.
-        if params := values.pop("params", {}):
-            values["params"] = {
+        if isinstance(data, dict) and (params := data.pop("params", {})):
+            data["params"] = {
                 p: (
                     {"type": params[p]}
                     if isinstance(params[p], str)
@@ -472,7 +433,7 @@ class Workflow(BaseModel):
                 )
                 for p in params
             }
-        return values
+        return data
 
     @field_validator("desc", mode="after")
     def __dedent_desc__(cls, value: str) -> str:
@@ -481,7 +442,7 @@ class Workflow(BaseModel):
         :param value: A description string value that want to dedent.
         :rtype: str
         """
-        return dedent(value)
+        return dedent(value.lstrip("\n"))
 
     @field_validator("on", mode="after")
     def __on_no_dup_and_reach_limit__(
@@ -511,6 +472,12 @@ class Workflow(BaseModel):
         #         "If it has every minute cronjob on value, it should have "
         #         "only one value in the on field."
         #     )
+        set_tz: set[str] = {on.tz for on in value}
+        if len(set_tz) > 1:
+            raise ValueError(
+                f"The on fields should not contain multiple timezone, "
+                f"{list[set_tz]}."
+            )
 
         extras: Optional[DictData] = info.data.get("extras")
         if len(set_ons) > (
@@ -632,9 +599,10 @@ class Workflow(BaseModel):
         result: Optional[Result] = None,
         timeout: int = 600,
     ) -> Result:
-        """Release the workflow execution with overriding parameter with the
-        release templating that include logical date (release date), execution
-        date, or running id to the params.
+        """Release the workflow which is executes workflow with writing audit
+        log tracking. The method is overriding parameter with the release
+        templating that include logical date (release date), execution date,
+        or running id to the params.
 
             This method allow workflow use audit object to save the execution
         result to audit destination like file audit to the local `./logs` path.
@@ -675,33 +643,32 @@ class Workflow(BaseModel):
         )
 
         # VALIDATE: check type of queue that valid with ReleaseQueue.
-        if queue and not isinstance(queue, ReleaseQueue):
+        if queue is not None and not isinstance(queue, ReleaseQueue):
             raise TypeError(
                 "The queue argument should be ReleaseQueue object only."
             )
 
         # VALIDATE: Change release value to Release object.
         if isinstance(release, datetime):
-            release: Release = Release.from_dt(release, extras=self.extras)
+            release: Release = Release.from_dt(release)
 
         result.trace.info(
             f"[RELEASE]: Start {name!r} : {release.date:%Y-%m-%d %H:%M:%S}"
         )
+        tz: ZoneInfo = dynamic("tz", extras=self.extras)
+        values: DictData = param2template(
+            params,
+            params={
+                "release": {
+                    "logical_date": release.date,
+                    "execute_date": datetime.now(tz=tz),
+                    "run_id": result.run_id,
+                }
+            },
+            extras=self.extras,
+        )
         rs: Result = self.execute(
-            params=param2template(
-                params,
-                params={
-                    "release": {
-                        "logical_date": release.date,
-                        "execute_date": datetime.now(
-                            tz=dynamic("tz", extras=self.extras)
-                        ),
-                        "run_id": result.run_id,
-                        "timezone": dynamic("tz", extras=self.extras),
-                    }
-                },
-                extras=self.extras,
-            ),
+            params=values,
             result=result,
             parent_run_id=result.parent_run_id,
             timeout=timeout,
@@ -709,10 +676,7 @@ class Workflow(BaseModel):
         result.trace.info(
             f"[RELEASE]: End {name!r} : {release.date:%Y-%m-%d %H:%M:%S}"
         )
-
-        # NOTE: Saving execution result to destination of the input audit
-        #   object.
-        result.trace.debug(f"[LOG]: Writing audit: {name!r}.")
+        result.trace.debug(f"[RELEASE]: Writing audit: {name!r}.")
         (
             audit(
                 name=name,
@@ -727,8 +691,6 @@ class Workflow(BaseModel):
         )
 
         if queue:
-            if release in queue.running:
-                queue.running.remove(release)
             queue.mark_complete(release)
 
         return result.catch(
@@ -738,9 +700,13 @@ class Workflow(BaseModel):
                 "release": {
                     "type": release.type,
                     "logical_date": release.date,
-                    "release": release,
                 },
-                "outputs": {"jobs": result.context.pop("jobs", {})},
+                **{"jobs": result.context.pop("jobs", {})},
+                **(
+                    result.context["errors"]
+                    if "errors" in result.context
+                    else {}
+                ),
             },
         )
 
@@ -770,13 +736,8 @@ class Workflow(BaseModel):
             queue.gen(
                 end_date,
                 audit,
-                on.next(
-                    get_dt_now(
-                        tz=dynamic("tz", extras=self.extras), offset=offset
-                    ).replace(microsecond=0)
-                ),
+                on.next(get_dt_now(offset=offset).replace(microsecond=0)),
                 self.name,
-                offset=offset,
                 force_run=force_run,
             )
 
@@ -784,36 +745,41 @@ class Workflow(BaseModel):
 
     def poke(
         self,
-        start_date: datetime | None = None,
         params: DictData | None = None,
+        start_date: datetime | None = None,
         *,
         run_id: str | None = None,
         periods: int = 1,
         audit: Audit | None = None,
         force_run: bool = False,
         timeout: int = 1800,
-        max_poking_pool_worker: int = 4,
+        max_poking_pool_worker: int = 2,
     ) -> Result:
-        """Poke function with a start datetime value that will pass to its
+        """Poke workflow with a start datetime value that will pass to its
         `on` field on the threading executor pool for execute the `release`
         method (It run all schedules that was set on the `on` values).
 
-            This method will observe its schedule that nearing to run with the
+            This method will observe its `on` field that nearing to run with the
         `self.release()` method.
 
-            The limitation of this method is not allow run a date that less
+            The limitation of this method is not allow run a date that gather
         than the current date.
 
-        :param start_date: A start datetime object.
-        :param params: A parameters that want to pass to the release method.
-        :param run_id: A workflow running ID for this poke.
-        :param periods: A periods in minutes value that use to run this poking.
-        :param audit: An audit object that want to use on this poking process.
-        :param force_run: A flag that allow to release workflow if the audit with
-            that release was pointed.
-        :param timeout: A second value for timeout while waiting all futures
-            run completely.
-        :param max_poking_pool_worker: The maximum poking pool worker.
+        :param params: (DictData) A parameter data.
+        :param start_date: (datetime) A start datetime object.
+        :param run_id: (str) A workflow running ID for this poke.
+        :param periods: (int) A periods in minutes value that use to run this
+            poking. (Default is 1)
+        :param audit: (Audit) An audit object that want to use on this poking
+            process.
+        :param force_run: (bool) A flag that allow to release workflow if the
+            audit with that release was pointed. (Default is False)
+        :param timeout: (int) A second value for timeout while waiting all
+            futures run completely.
+        :param max_poking_pool_worker: (int) The maximum poking pool worker.
+            (Default is 2 workers)
+
+        :raise WorkflowException: If the periods parameter less or equal than 0.
 
         :rtype: Result
         :return: A list of all results that return from `self.release` method.
@@ -826,45 +792,49 @@ class Workflow(BaseModel):
         # VALIDATE: Check the periods value should gather than 0.
         if periods <= 0:
             raise WorkflowException(
-                "The period of poking should be int and grater or equal than 1."
+                "The period of poking should be `int` and grater or equal "
+                "than 1."
             )
 
         if len(self.on) == 0:
-            result.trace.info(
-                f"[POKING]: {self.name!r} does not have any schedule to run."
+            result.trace.warning(
+                f"[POKING]: {self.name!r} not have any schedule!!!"
             )
             return result.catch(status=SUCCESS, context={"outputs": []})
 
         # NOTE: Create the current date that change microsecond to 0
-        current_date: datetime = datetime.now(
-            tz=dynamic("tz", extras=self.extras)
-        ).replace(microsecond=0)
-
-        # NOTE: Create start_date and offset variables.
-        if start_date and start_date <= current_date:
-            start_date = start_date.replace(
-                tzinfo=dynamic("tz", extras=self.extras)
-            ).replace(microsecond=0)
-            offset: float = (current_date - start_date).total_seconds()
-        else:
+        current_date: datetime = datetime.now().replace(microsecond=0)
+
+        if start_date is None:
             # NOTE: Force change start date if it gathers than the current date,
             #   or it does not pass to this method.
             start_date: datetime = current_date
             offset: float = 0
+        elif start_date <= current_date:
+            start_date = start_date.replace(microsecond=0)
+            offset: float = (current_date - start_date).total_seconds()
+        else:
+            raise WorkflowException(
+                f"The start datetime should less than or equal the current "
+                f"datetime, {current_date:%Y-%m-%d %H:%M:%S}."
+            )
 
         # NOTE: The end date is using to stop generate queue with an input
-        #   periods value.
-        end_date: datetime = start_date + timedelta(minutes=periods)
+        #   periods value. It will change to MM:59.
+        #   For example:
+        #       (input)  start_date = 12:04:12, offset = 2
+        #       (output) end_date = 12:06:59
+        end_date: datetime = start_date.replace(second=0) + timedelta(
+            minutes=periods + 1, seconds=-1
+        )
 
         result.trace.info(
-            f"[POKING]: Start Poking: {self.name!r} from "
-            f"{start_date:%Y-%m-%d %H:%M:%S} to {end_date:%Y-%m-%d %H:%M:%S}"
+            f"[POKING]: Execute Poking: {self.name!r} ("
+            f"{start_date:%Y-%m-%d %H:%M:%S} ==> {end_date:%Y-%m-%d %H:%M:%S})"
         )
 
         params: DictData = {} if params is None else params
         context: list[Result] = []
-
-        # NOTE: Create empty ReleaseQueue object.
         q: ReleaseQueue = ReleaseQueue()
 
         # NOTE: Create reusable partial function and add Release to the release
@@ -873,16 +843,12 @@ class Workflow(BaseModel):
             self.queue, offset, end_date, audit=audit, force_run=force_run
         )
         partial_queue(q)
-
-        # NOTE: Return the empty result if it does not have any Release.
         if not q.is_queued:
-            result.trace.info(
-                f"[POKING]: {self.name!r} does not have any queue."
+            result.trace.warning(
+                f"[POKING]: Skip {self.name!r}, not have any queue!!!"
             )
             return result.catch(status=SUCCESS, context={"outputs": []})
 
-        # NOTE: Start create the thread pool executor for running this poke
-        #   process.
         with ThreadPoolExecutor(
             max_workers=dynamic(
                 "max_poking_pool_worker",
@@ -901,16 +867,11 @@ class Workflow(BaseModel):
 
                 if reach_next_minute(release.date, offset=offset):
                     result.trace.debug(
-                        f"[POKING]: Latest Release, "
-                        f"{release.date:%Y-%m-%d %H:%M:%S}, can not run on "
-                        f"this time"
+                        f"[POKING]: Skip Release: "
+                        f"{release.date:%Y-%m-%d %H:%M:%S}"
                     )
                     heappush(q.queue, release)
-                    wait_to_next_minute(
-                        get_dt_now(
-                            tz=dynamic("tz", extras=self.extras), offset=offset
-                        )
-                    )
+                    wait_until_next_minute(get_dt_now(offset=offset))
 
                     # WARNING: I already call queue poking again because issue
                     #   about the every minute crontab.
@@ -943,7 +904,7 @@ class Workflow(BaseModel):
 
     def execute_job(
         self,
-        job_id: str,
+        job: Job,
         params: DictData,
         *,
         result: Result | None = None,
@@ -956,10 +917,9 @@ class Workflow(BaseModel):
         model. It different with `self.execute` because this method run only
         one job and return with context of this job data.
 
-        :raise WorkflowException: If execute with not exist job's ID.
         :raise WorkflowException: If the job execution raise JobException.
 
-        :param job_id: A job ID.
+        :param job: (Job) A job model that want to execute.
         :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
@@ -967,48 +927,37 @@ class Workflow(BaseModel):
 
         :rtype: Result
         """
-        if result is None:  # pragma: no cov
-            result: Result = Result(run_id=gen_id(self.name, unique=True))
+        result: Result = result or Result(run_id=gen_id(self.name, unique=True))
 
-        # VALIDATE: check a job ID that exists in this workflow or not.
-        if job_id not in self.jobs:
-            raise WorkflowException(
-                f"The job: {job_id!r} does not exists in {self.name!r} "
-                f"workflow."
-            )
-
-        job: Job = self.job(name=job_id)
         if job.is_skipped(params=params):
-            result.trace.info(f"[WORKFLOW]: Skip job: {job_id!r}")
+            result.trace.info(f"[WORKFLOW]: Skip Job: {job.id!r}")
             job.set_outputs(output={"skipped": True}, to=params)
             return result.catch(status=SKIP, context=params)
 
-        if event and event.is_set():  # pragma: no cov
-            raise WorkflowException(
-                "Workflow job was canceled from event that had set before "
-                "job execution."
+        if event and event.is_set():
+            return result.catch(
+                status=CANCEL,
+                context={
+                    "errors": WorkflowException(
+                        "Workflow job was canceled because event was set."
+                    ).to_dict(),
+                },
             )
 
-        try:
-            result.trace.info(f"[WORKFLOW]: Execute Job: {job_id!r}")
-            rs: Result = job.execute(
-                params=params,
-                run_id=result.run_id,
-                parent_run_id=result.parent_run_id,
-                event=event,
+        result.trace.info(f"[WORKFLOW]: Execute Job: {job.id!r}")
+        rs: Result = job.execute(
+            params=params,
+            run_id=result.run_id,
+            parent_run_id=result.parent_run_id,
+            event=event,
+        )
+        job.set_outputs(rs.context, to=params)
+        if rs.status in (FAILED, CANCEL):
+            error_msg: str = (
+                f"Job, {job.id!r}, return `{rs.status.name}` status."
             )
-            job.set_outputs(rs.context, to=params)
-        except (JobException, UtilException) as e:
-            result.trace.error(f"[WORKFLOW]: {e.__class__.__name__}: {e}")
-            raise WorkflowException(
-                f"Job {job_id!r} raise {e.__class__.__name__}: {e}"
-            ) from None
-
-        if rs.status == FAILED:
-            error_msg: str = f"Workflow job, {job.id!r}, return FAILED status."
-            result.trace.warning(f"[WORKFLOW]: {error_msg}")
             return result.catch(
-                status=FAILED,
+                status=rs.status,
                 context={
                     "errors": WorkflowException(error_msg).to_dict(),
                     **params,
@@ -1073,7 +1022,7 @@ class Workflow(BaseModel):
             extras=self.extras,
         )
         context: DictData = self.parameterize(params)
-        result.trace.info(f"[WORKFLOW]: Execute: {self.name!r} ...")
+        result.trace.info(f"[WORKFLOW]: Execute: {self.name!r}")
         if not self.jobs:
             result.trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
             return result.catch(status=SUCCESS, context=context)
@@ -1087,7 +1036,9 @@ class Workflow(BaseModel):
             "max_job_exec_timeout", f=timeout, extras=self.extras
         )
         event: Event = event or Event()
-        result.trace.debug(f"... Run {self.name!r} with non-threading.")
+        result.trace.debug(
+            f"[WORKFLOW]: ... Run {self.name!r} with non-threading."
+        )
         max_job_parallel: int = dynamic(
             "max_job_parallel", f=max_job_parallel, extras=self.extras
         )
@@ -1127,7 +1078,7 @@ class Workflow(BaseModel):
                     futures.append(
                         executor.submit(
                             self.execute_job,
-                            job_id=job_id,
+                            job=job,
                             params=context,
                             result=result,
                             event=event,
@@ -1140,7 +1091,7 @@ class Workflow(BaseModel):
                     futures.append(
                         executor.submit(
                             self.execute_job,
-                            job_id=job_id,
+                            job=job,
                             params=context,
                             result=result,
                             event=event,
@@ -1148,9 +1099,6 @@ class Workflow(BaseModel):
                     )
                     time.sleep(0.025)
                 elif (future := futures.pop(0)).done() or future.cancelled():
-                    if e := future.exception():
-                        result.trace.error(f"[WORKFLOW]: {e}")
-                        raise WorkflowException(str(e))
                     job_queue.put(job_id)
                 elif future.running() or "state=pending" in str(future):
                     time.sleep(0.075)
@@ -1159,8 +1107,10 @@ class Workflow(BaseModel):
                 else:  # pragma: no cov
                     job_queue.put(job_id)
                     futures.insert(0, future)
+                    time.sleep(0.025)
                     result.trace.warning(
-                        f"... Execution non-threading not handle: {future}."
+                        f"[WORKFLOW]: ... Execution non-threading not "
+                        f"handle: {future}."
                     )
 
                 job_queue.task_done()
@@ -1168,16 +1118,7 @@ class Workflow(BaseModel):
             if not_timeout_flag:
                 job_queue.join()
                 for future in as_completed(futures):
-                    try:
-                        future.result()
-                    except WorkflowException as e:
-                        result.trace.error(f"[WORKFLOW]: Handler:{NEWLINE}{e}")
-                        return result.catch(
-                            status=FAILED,
-                            context={
-                                "errors": WorkflowException(str(e)).to_dict()
-                            },
-                        )
+                    future.result()
                 return result.catch(
                     status=FAILED if "errors" in result.context else SUCCESS,
                     context=context,