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

ddeutil/workflow/workflow.py

@@ -8,9 +8,6 @@ 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
 
@@ -21,288 +18,57 @@ from concurrent.futures import (
     ThreadPoolExecutor,
     as_completed,
 )
-from dataclasses import field
-from datetime import datetime, timedelta
+from datetime import datetime
 from enum import Enum
-from functools import partial, total_ordering
-from heapq import heappop, heappush
 from pathlib import Path
 from queue import Queue
 from textwrap import dedent
-from threading import Event, Lock
-from typing import Any, Optional, Union
+from threading import Event
+from typing import Any, Optional
 from zoneinfo import ZoneInfo
 
-from pydantic import BaseModel, ConfigDict, Field, ValidationInfo
-from pydantic.dataclasses import dataclass
+from pydantic import BaseModel, Field, ValidationInfo
 from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
-from .__cron import CronRunner
+from . import get_status_from_error
 from .__types import DictData
 from .conf import FileLoad, Loader, dynamic
+from .errors import WorkflowCancelError, WorkflowError, WorkflowTimeoutError
 from .event import Crontab
-from .exceptions import WorkflowException
 from .job import Job
 from .logs import Audit, get_audit
 from .params import Param
-from .result import CANCEL, FAILED, SKIP, SUCCESS, WAIT, Result
+from .result import (
+    CANCEL,
+    FAILED,
+    SKIP,
+    SUCCESS,
+    WAIT,
+    Result,
+    Status,
+    validate_statuses,
+)
 from .reusables import has_template, param2template
 from .utils import (
-    clear_tz,
     gen_id,
-    get_dt_now,
-    reach_next_minute,
     replace_sec,
-    wait_until_next_minute,
 )
 
 
 class ReleaseType(str, Enum):
-    """Release Type Enum support the type field on the Release dataclass."""
+    """Release Type Enum."""
 
-    DEFAULT = "manual"
-    SCHEDULE = "schedule"
-    POKING = "poking"
+    NORMAL = "normal"
+    RERUN = "rerun"
+    EVENT = "event"
     FORCE = "force"
 
 
-@total_ordering
-@dataclass(config=ConfigDict(use_enum_values=True))
-class Release:
-    """Release object that use for represent the release datetime."""
-
-    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:
-        """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.
-
-        :rtype: str
-        """
-        return f"{self.date:%Y-%m-%d %H:%M:%S}"
-
-    @classmethod
-    def from_dt(cls, dt: Union[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: (Union[datetime, str]) A datetime object or string that want to
-            construct to the Release object.
-
-        :raise TypeError: If the type of the dt argument does not valid with
-            datetime or str object.
-
-        :rtype: Release
-        """
-        if isinstance(dt, str):
-            dt: datetime = datetime.fromisoformat(dt)
-        elif not isinstance(dt, datetime):
-            raise TypeError(
-                f"The `from_dt` need the `dt` parameter type be `str` or "
-                f"`datetime` only, not {type(dt)}."
-            )
-        return cls(date=replace_sec(dt.replace(tzinfo=None)))
-
-    def __eq__(self, other: Union[Release, datetime]) -> bool:
-        """Override equal property that will compare only the same type or
-        datetime.
-
-        :rtype: bool
-        """
-        if isinstance(other, self.__class__):
-            return self.date == other.date
-        elif isinstance(other, datetime):
-            return self.date == other
-        return NotImplemented
-
-    def __lt__(self, other: Union[Release, datetime]) -> bool:
-        """Override less-than property that will compare only the same type or
-        datetime.
-
-        :rtype: bool
-        """
-        if isinstance(other, self.__class__):
-            return self.date < other.date
-        elif isinstance(other, datetime):
-            return self.date < other
-        return NotImplemented
-
-
-class ReleaseQueue:
-    """ReleaseQueue object that is storage management of Release objects on
-    the memory with list object.
-    """
-
-    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: 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: A queue object for create ReleaseQueue instance.
-
-        :raise TypeError: If the type of input queue does not valid.
-
-        :rtype: ReleaseQueue
-        """
-        if queue is None:
-            return cls()
-
-        if isinstance(queue, list):
-            if all(isinstance(q, datetime) 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)
-
-        raise TypeError(
-            "Type of the queue does not valid with ReleaseQueue "
-            "or list of datetime or list of Release."
-        )
-
-    @property
-    def is_queued(self) -> bool:
-        """Return True if it has workflow release object in the queue.
-
-        :rtype: bool
-        """
-        return len(self.queue) > 0
-
-    def check_queue(self, value: Union[Release, datetime]) -> bool:
-        """Check a Release value already exists in list of tracking
-        queues.
-
-        :param value: A Release object that want to check it already in
-            queues.
-
-        :rtype: bool
-        """
-        if isinstance(value, datetime):
-            value = Release.from_dt(value)
-
-        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. 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
-        """
-        with self.lock:
-            if value in self.running:
-                self.running.remove(value)
-
-            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)
-
-        return self
-
-    def gen(
-        self,
-        end_date: datetime,
-        audit: type[Audit],
-        runner: CronRunner,
-        name: str,
-        *,
-        force_run: bool = False,
-        extras: Optional[DictData] = None,
-    ) -> Self:
-        """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
-              date.
-            - Check this release do not store on the release queue object.
-              Generate the next date if it exists.
-            - Push this release to the release queue
-
-        :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 name: (str) A target name that want to check at pointer of audit.
-        :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 clear_tz(runner.date) > clear_tz(end_date):
-            return self
-
-        release = Release(
-            date=clear_tz(runner.date),
-            type=(ReleaseType.FORCE if force_run else ReleaseType.POKING),
-        )
-
-        while self.check_queue(release) or (
-            audit.is_pointed(name=name, release=release.date, extras=extras)
-            and not force_run
-        ):
-            release = Release(
-                date=clear_tz(runner.next),
-                type=(ReleaseType.FORCE if force_run else ReleaseType.POKING),
-            )
-
-        if clear_tz(runner.date) > clear_tz(end_date):
-            return self
-
-        with self.lock:
-            heappush(self.queue, release)
-
-        return self
+NORMAL = ReleaseType.NORMAL
+RERUN = ReleaseType.RERUN
+EVENT = ReleaseType.EVENT
+FORCE = ReleaseType.FORCE
 
 
 class Workflow(BaseModel):
@@ -484,8 +250,9 @@ class Workflow(BaseModel):
     def __validate_jobs_need__(self) -> Self:
         """Validate each need job in any jobs should exist.
 
-        :raise WorkflowException: If it has not exists need value in this
+        :raise WorkflowError: If it has not exists need value in this
             workflow job.
+        :raise ValueError: If the workflow name has template value.
 
         :rtype: Self
         """
@@ -493,11 +260,12 @@ class Workflow(BaseModel):
             if not_exist := [
                 need for need in self.jobs[job].needs if need not in self.jobs
             ]:
-                raise WorkflowException(
+                raise WorkflowError(
                     f"The needed jobs: {not_exist} do not found in "
                     f"{self.name!r}."
                 )
 
+            # NOTE: Set job ID to the job model.
             self.jobs[job].id = job
 
         # VALIDATE: Validate workflow name should not dynamic with params
@@ -547,7 +315,7 @@ class Workflow(BaseModel):
         :param params: (DictData) A parameter data that receive from workflow
             execute method.
 
-        :raise WorkflowException: If parameter value that want to validate does
+        :raise WorkflowError: If parameter value that want to validate does
             not include the necessary parameter that had required flag.
 
         :rtype: DictData
@@ -561,7 +329,7 @@ class Workflow(BaseModel):
             if (k not in params and self.params[k].required)
         ]
         if check_key:
-            raise WorkflowException(
+            raise WorkflowError(
                 f"Required Param on this workflow setting does not set: "
                 f"{', '.join(check_key)}."
             )
@@ -579,15 +347,35 @@ class Workflow(BaseModel):
             "jobs": {},
         }
 
+    def validate_release(self, dt: datetime) -> datetime:
+        """Validate the release datetime that should was replaced second and
+        millisecond to 0 and replaced timezone to None before checking it match
+        with the set `on` field.
+
+        :param dt: (datetime) A datetime object that want to validate.
+
+        :rtype: datetime
+        """
+        release: datetime = replace_sec(dt.replace(tzinfo=None))
+        if not self.on:
+            return release
+
+        for on in self.on:
+            if release == on.cronjob.schedule(release).next:
+                return release
+        raise WorkflowError(
+            "Release datetime does not support for this workflow"
+        )
+
     def release(
         self,
-        release: Union[Release, datetime],
+        release: datetime,
         params: DictData,
         *,
+        release_type: ReleaseType = NORMAL,
         run_id: Optional[str] = None,
         parent_run_id: Optional[str] = None,
         audit: type[Audit] = None,
-        queue: Optional[ReleaseQueue] = None,
         override_log_name: Optional[str] = None,
         result: Optional[Result] = None,
         timeout: int = 600,
@@ -605,24 +393,19 @@ class Workflow(BaseModel):
             - Create release data for pass to parameter templating function.
             - Execute this workflow with mapping release data to its parameters.
             - Writing result audit
-            - Remove this release on the running queue
-            - Push this release to complete queue
 
-        :param release: A release datetime or Release object.
+        :param release: (datetime) A release datetime.
         :param params: A workflow parameter that pass to execute method.
+        :param release_type:
         :param run_id: (str) A workflow running ID.
         :param parent_run_id: (str) A parent workflow running ID.
         :param audit: An audit class that want to save the execution result.
-        :param queue: (ReleaseQueue) A ReleaseQueue object.
         :param override_log_name: (str) An override logging name that use
             instead the workflow name.
         :param result: (Result) A result object for keeping context and status
             data.
         :param timeout: (int) A workflow execution time out in second unit.
 
-        :raise TypeError: If a queue parameter does not match with ReleaseQueue
-            type.
-
         :rtype: Result
         """
         audit: type[Audit] = audit or get_audit(extras=self.extras)
@@ -634,26 +417,16 @@ class Workflow(BaseModel):
             id_logic=name,
             extras=self.extras,
         )
-
-        # VALIDATE: check type of queue that valid with 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)
-
+        release: datetime = self.validate_release(dt=release)
         result.trace.info(
-            f"[RELEASE]: Start {name!r} : {release.date:%Y-%m-%d %H:%M:%S}"
+            f"[RELEASE]: Start {name!r} : {release:%Y-%m-%d %H:%M:%S}"
         )
         tz: ZoneInfo = dynamic("tz", extras=self.extras)
         values: DictData = param2template(
             params,
             params={
                 "release": {
-                    "logical_date": release.date,
+                    "logical_date": release,
                     "execute_date": datetime.now(tz=tz),
                     "run_id": result.run_id,
                 }
@@ -662,19 +435,19 @@ class Workflow(BaseModel):
         )
         rs: Result = self.execute(
             params=values,
-            result=result,
             parent_run_id=result.run_id,
             timeout=timeout,
         )
+        result.catch(status=rs.status, context=rs.context)
         result.trace.info(
-            f"[RELEASE]: End {name!r} : {release.date:%Y-%m-%d %H:%M:%S}"
+            f"[RELEASE]: End {name!r} : {release:%Y-%m-%d %H:%M:%S}"
         )
         result.trace.debug(f"[RELEASE]: Writing audit: {name!r}.")
         (
             audit(
                 name=name,
-                release=release.date,
-                type=release.type,
+                release=release,
+                type=release_type,
                 context=result.context,
                 parent_run_id=result.parent_run_id,
                 run_id=result.run_id,
@@ -682,17 +455,13 @@ class Workflow(BaseModel):
                 extras=self.extras,
             ).save(excluded=None)
         )
-
-        if queue:
-            queue.mark_complete(release)
-
         return result.catch(
             status=rs.status,
             context={
                 "params": params,
                 "release": {
-                    "type": release.type,
-                    "logical_date": release.date,
+                    "type": release_type,
+                    "logical_date": release,
                 },
                 **{"jobs": result.context.pop("jobs", {})},
                 **(
@@ -710,7 +479,7 @@ class Workflow(BaseModel):
         *,
         result: Optional[Result] = None,
         event: Optional[Event] = None,
-    ) -> Result:
+    ) -> tuple[Status, Result]:
         """Job execution with passing dynamic parameters from the main workflow
         execution to the target job object via job's ID.
 
@@ -718,7 +487,8 @@ 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 the job execution raise JobException.
+            This method do not raise any error, and it will handle all exception
+        from the job execution.
 
         :param job: (Job) A job model that want to execute.
         :param params: (DictData) A parameter data.
@@ -726,22 +496,19 @@ class Workflow(BaseModel):
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
 
-        :rtype: Result
+        :rtype: tuple[Status, Result]
         """
         result: Result = result or Result(run_id=gen_id(self.name, unique=True))
 
-        if job.is_skipped(params=params):
-            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():
-            return result.catch(
+            error_msg: str = (
+                "Job execution was canceled because the event was set "
+                "before start job execution."
+            )
+            return CANCEL, result.catch(
                 status=CANCEL,
                 context={
-                    "errors": WorkflowException(
-                        "Workflow job was canceled because event was set."
-                    ).to_dict(),
+                    "errors": WorkflowCancelError(error_msg).to_dict(),
                 },
             )
 
@@ -753,18 +520,31 @@ class Workflow(BaseModel):
             event=event,
         )
         job.set_outputs(rs.context, to=params)
-        if rs.status in (FAILED, CANCEL):
+
+        if rs.status == FAILED:
+            error_msg: str = f"Job execution, {job.id!r}, was failed."
+            return FAILED, result.catch(
+                status=FAILED,
+                context={
+                    "errors": WorkflowError(error_msg).to_dict(),
+                    **params,
+                },
+            )
+
+        elif rs.status == CANCEL:
             error_msg: str = (
-                f"Job, {job.id!r}, return `{rs.status.name}` status."
+                f"Job execution, {job.id!r}, was canceled from the event after "
+                f"end job execution."
             )
-            return result.catch(
-                status=rs.status,
+            return CANCEL, result.catch(
+                status=CANCEL,
                 context={
-                    "errors": WorkflowException(error_msg).to_dict(),
+                    "errors": WorkflowCancelError(error_msg).to_dict(),
                     **params,
                 },
             )
-        return result.catch(status=SUCCESS, context=params)
+
+        return rs.status, result.catch(status=rs.status, context=params)
 
     def execute(
         self,
@@ -772,7 +552,6 @@ class Workflow(BaseModel):
         *,
         run_id: Optional[str] = None,
         parent_run_id: Optional[str] = None,
-        result: Optional[Result] = None,
         event: Optional[Event] = None,
         timeout: float = 3600,
         max_job_parallel: int = 2,
@@ -799,10 +578,17 @@ class Workflow(BaseModel):
         the job execution. It will warp that error and keep it in the key `errors`
         at the result context.
 
+
+            Execution   --> Ok      --> Result
+                                        |-status: CANCEL
+                                        ╰-context:
+                                            ╰-errors:
+                                                |-name: ...
+                                                ╰-message: ...
+
         :param params: A parameter data that will parameterize before execution.
         :param run_id: (Optional[str]) A workflow running ID.
         :param parent_run_id: (Optional[str]) A parent workflow 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 timeout: (float) A workflow execution time out in second unit
@@ -810,13 +596,12 @@ class Workflow(BaseModel):
             This value does not force stop the task that still running more than
             this limit time. (Default: 60 * 60 seconds)
         :param max_job_parallel: (int) The maximum workers that use for job
-            execution in `PoolThreadExecutor` object. (Default: 2 workers)
+            execution in `ThreadPoolExecutor` object. (Default: 2 workers)
 
         :rtype: Result
         """
         ts: float = time.monotonic()
         result: Result = Result.construct_with_rs_or_id(
-            result,
             run_id=run_id,
             parent_run_id=parent_run_id,
             id_logic=self.name,
@@ -840,13 +625,26 @@ class Workflow(BaseModel):
             job_queue.put(job_id)
 
         not_timeout_flag: bool = True
+        total_job: int = len(self.jobs)
+        statuses: list[Status] = [WAIT] * total_job
+        skip_count: int = 0
+        sequence_statuses: list[Status] = []
         timeout: float = dynamic(
             "max_job_exec_timeout", f=timeout, extras=self.extras
         )
+        result.catch(status=WAIT, context=context)
+        if event and event.is_set():
+            return result.catch(
+                status=CANCEL,
+                context={
+                    "errors": WorkflowCancelError(
+                        "Execution was canceled from the event was set before "
+                        "workflow execution."
+                    ).to_dict(),
+                },
+            )
 
-        with ThreadPoolExecutor(
-            max_workers=max_job_parallel, thread_name_prefix="wf_exec_"
-        ) as executor:
+        with ThreadPoolExecutor(max_job_parallel, "wf") as executor:
             futures: list[Future] = []
 
             while not job_queue.empty() and (
@@ -863,16 +661,20 @@ class Workflow(BaseModel):
                     return result.catch(
                         status=FAILED,
                         context={
-                            "errors": WorkflowException(
+                            "status": FAILED,
+                            "errors": WorkflowError(
                                 f"Validate job trigger rule was failed with "
                                 f"{job.trigger_rule.value!r}."
-                            ).to_dict()
+                            ).to_dict(),
                         },
                     )
                 elif check == SKIP:  # pragma: no cov
-                    result.trace.info(f"[JOB]: Skip job: {job_id!r}")
-                    job.set_outputs(output={"skipped": True}, to=context)
+                    result.trace.info(
+                        f"[JOB]: Skip job: {job_id!r} from trigger rule."
+                    )
+                    job.set_outputs(output={"status": SKIP}, to=context)
                     job_queue.task_done()
+                    skip_count += 1
                     continue
 
                 if max_job_parallel > 1:
@@ -898,17 +700,22 @@ class Workflow(BaseModel):
                             event=event,
                         )
                     )
-                    time.sleep(0.025)
-                elif (future := futures.pop(0)).done() or future.cancelled():
+                elif (future := futures.pop(0)).done():
+                    if e := future.exception():
+                        sequence_statuses.append(get_status_from_error(e))
+                    else:
+                        st, _ = future.result()
+                        sequence_statuses.append(st)
+                    job_queue.put(job_id)
+                elif future.cancelled():
+                    sequence_statuses.append(CANCEL)
                     job_queue.put(job_id)
                 elif future.running() or "state=pending" in str(future):
-                    time.sleep(0.075)
                     futures.insert(0, future)
                     job_queue.put(job_id)
                 else:  # pragma: no cov
                     job_queue.put(job_id)
                     futures.insert(0, future)
-                    time.sleep(0.025)
                     result.trace.warning(
                         f"[WORKFLOW]: ... Execution non-threading not "
                         f"handle: {future}."
@@ -918,351 +725,43 @@ class Workflow(BaseModel):
 
             if not_timeout_flag:
                 job_queue.join()
-                for future in as_completed(futures):
-                    future.result()
-                return result.catch(
-                    status=FAILED if "errors" in result.context else SUCCESS,
-                    context=context,
-                )
-
-            result.trace.error(f"[WORKFLOW]: {self.name!r} was timeout.")
-            event.set()
-            for future in futures:
-                future.cancel()
+                total_future: int = 0
+                for i, future in enumerate(as_completed(futures), start=0):
+                    try:
+                        statuses[i], _ = future.result()
+                    except WorkflowError as e:
+                        statuses[i] = get_status_from_error(e)
+                    total_future += 1
 
-        return result.catch(
-            status=FAILED,
-            context={
-                "errors": WorkflowException(
-                    f"{self.name!r} was timeout."
-                ).to_dict()
-            },
-        )
+                # NOTE: Update skipped status from the job trigger.
+                for i in range(skip_count):
+                    statuses[total_future + i] = SKIP
 
+                # NOTE: Update status from none-parallel job execution.
+                for i, s in enumerate(sequence_statuses, start=0):
+                    statuses[total_future + skip_count + i] = s
 
-class WorkflowPoke(Workflow):
-    """Workflow Poke model that was implemented the poke method."""
+                status: Status = validate_statuses(statuses)
 
-    def queue(
-        self,
-        offset: float,
-        end_date: datetime,
-        queue: ReleaseQueue,
-        audit: type[Audit],
-        *,
-        force_run: bool = False,
-    ) -> ReleaseQueue:
-        """Generate Release from all on values from the on field and store them
-        to the ReleaseQueue object.
-
-        :param offset: An offset in second unit for time travel.
-        :param end_date: An end datetime object.
-        :param queue: A workflow queue object.
-        :param audit: An audit class that want to make audit object.
-        :param force_run: A flag that allow to release workflow if the audit
-            with that release was pointed.
-
-        :rtype: ReleaseQueue
-        """
-        for on in self.on:
-
-            queue.gen(
-                end_date,
-                audit,
-                on.next(get_dt_now(offset=offset).replace(microsecond=0)),
-                self.name,
-                force_run=force_run,
-            )
-
-        return queue
+                return result.catch(status=status, context=context)
 
-    def poke(
-        self,
-        params: Optional[DictData] = None,
-        start_date: Optional[datetime] = None,
-        *,
-        run_id: Optional[str] = None,
-        periods: int = 1,
-        audit: Optional[Audit] = None,
-        force_run: bool = False,
-        timeout: int = 1800,
-        max_poking_pool_worker: int = 2,
-    ) -> Result:
-        """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 `on` field that nearing to run with the
-        `self.release()` method.
-
-            The limitation of this method is not allow run a date that gather
-        than the current date.
-
-        :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.
-        """
-        audit: type[Audit] = audit or get_audit(extras=self.extras)
-        result: Result = Result(
-            run_id=(run_id or gen_id(self.name, unique=True))
-        )
-
-        # 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."
-            )
-
-        if len(self.on) == 0:
-            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().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. 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]: 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] = []
-        q: ReleaseQueue = ReleaseQueue()
+            event.set()
+            for future in futures:
+                future.cancel()
 
-        # NOTE: Create reusable partial function and add Release to the release
-        #   queue object.
-        partial_queue = partial(
-            self.queue, offset, end_date, audit=audit, force_run=force_run
-        )
-        partial_queue(q)
-        if not q.is_queued:
-            result.trace.warning(
-                f"[POKING]: Skip {self.name!r}, not have any queue!!!"
+            result.trace.error(
+                f"[WORKFLOW]: {self.name!r} was timeout because it use exec "
+                f"time more than {timeout} seconds."
             )
-            return result.catch(status=SUCCESS, context={"outputs": []})
-
-        with ThreadPoolExecutor(
-            max_workers=dynamic(
-                "max_poking_pool_worker",
-                f=max_poking_pool_worker,
-                extras=self.extras,
-            ),
-            thread_name_prefix="wf_poking_",
-        ) as executor:
-
-            futures: list[Future] = []
-
-            while q.is_queued:
-
-                # NOTE: Pop the latest Release object from the release queue.
-                release: Release = heappop(q.queue)
-
-                if reach_next_minute(release.date, offset=offset):
-                    result.trace.debug(
-                        f"[POKING]: Skip Release: "
-                        f"{release.date:%Y-%m-%d %H:%M:%S}"
-                    )
-                    heappush(q.queue, release)
-                    wait_until_next_minute(get_dt_now(offset=offset))
 
-                    # WARNING: I already call queue poking again because issue
-                    #   about the every minute crontab.
-                    partial_queue(q)
-                    continue
-
-                heappush(q.running, release)
-                futures.append(
-                    executor.submit(
-                        self.release,
-                        release=release,
-                        params=params,
-                        audit=audit,
-                        queue=q,
-                        parent_run_id=result.run_id,
-                    )
-                )
-
-                partial_queue(q)
-
-            # WARNING: This poking method does not allow to use fail-fast
-            #   logic to catching parallel execution result.
-            for future in as_completed(futures, timeout=timeout):
-                context.append(future.result())
+            time.sleep(0.0025)
 
         return result.catch(
-            status=SUCCESS,
-            context={"outputs": context},
-        )
-
-
-@dataclass(config=ConfigDict(arbitrary_types_allowed=True))
-class WorkflowTask:
-    """Workflow task Pydantic dataclass object that use to keep mapping data and
-    workflow model for passing to the multithreading task.
-
-        This dataclass object is mapping 1-to-1 with workflow and cron runner
-    objects.
-
-        This dataclass has the release method for itself that prepare necessary
-    arguments before passing to the parent release method.
-
-    :param alias: (str) An alias name of Workflow model.
-    :param workflow: (Workflow) A Workflow model instance.
-    :param runner: (CronRunner)
-    :param values: A value data that want to parameterize.
-    :param extras: An extra parameter that use to override core config values.
-    """
-
-    alias: str
-    workflow: Workflow
-    runner: CronRunner
-    values: DictData = field(default_factory=dict)
-    extras: DictData = field(default_factory=dict)
-
-    def release(
-        self,
-        release: Optional[Union[Release, datetime]] = None,
-        run_id: Optional[str] = None,
-        audit: type[Audit] = None,
-        queue: Optional[ReleaseQueue] = None,
-    ) -> Result:
-        """Release the workflow task that passing an override parameter to
-        the parent release method with the `values` field.
-
-            This method can handler not passing release value by default
-        generate step. It uses the `runner` field for generate release object.
-
-        :param release: A release datetime or Release object.
-        :param run_id: A workflow running ID for this release.
-        :param audit: An audit class that want to save the execution result.
-        :param queue: A ReleaseQueue object that use to mark complete.
-
-        :raise ValueError: If a queue parameter does not pass while release
-            is None.
-        :raise TypeError: If a queue parameter does not match with ReleaseQueue
-            type.
-
-        :rtype: Result
-        """
-        audit: type[Audit] = audit or get_audit(extras=self.extras)
-
-        if release is None:
-
-            if queue is None:
-                raise ValueError(
-                    "If pass None release value, you should to pass the queue"
-                    "for generate this release."
-                )
-            elif not isinstance(queue, ReleaseQueue):
-                raise TypeError(
-                    "The queue argument should be ReleaseQueue object only."
-                )
-
-            if queue.check_queue(self.runner.date):
-                release = self.runner.next
-
-                while queue.check_queue(release):
-                    release = self.runner.next
-            else:
-                release = self.runner.date
-
-        return self.workflow.release(
-            release=release,
-            params=self.values,
-            run_id=run_id,
-            audit=audit,
-            queue=queue,
-            override_log_name=self.alias,
-        )
-
-    def queue(
-        self,
-        end_date: datetime,
-        queue: ReleaseQueue,
-        audit: type[Audit],
-        *,
-        force_run: bool = False,
-    ) -> ReleaseQueue:
-        """Generate Release from the runner field and store it to the
-        ReleaseQueue object.
-
-        :param end_date: An end datetime object.
-        :param queue: A workflow queue object.
-        :param audit: An audit class that want to make audit object.
-        :param force_run: (bool) A flag that allow to release workflow if the
-            audit with that release was pointed.
-
-        :rtype: ReleaseQueue
-        """
-        return queue.gen(
-            end_date,
-            audit,
-            self.runner,
-            self.alias,
-            force_run=force_run,
-            extras=self.extras,
-        )
-
-    def __repr__(self) -> str:
-        """Override the `__repr__` method.
-
-        :rtype: str
-        """
-        return (
-            f"{self.__class__.__name__}(alias={self.alias!r}, "
-            f"workflow={self.workflow.name!r}, runner={self.runner!r}, "
-            f"values={self.values})"
+            status=FAILED,
+            context={
+                "errors": WorkflowTimeoutError(
+                    f"{self.name!r} was timeout because it use exec time more "
+                    f"than {timeout} seconds."
+                ).to_dict(),
+            },
         )
-
-    def __eq__(self, other: WorkflowTask) -> bool:
-        """Override the equal property that will compare only the same type.
-
-        :rtype: bool
-        """
-        if isinstance(other, WorkflowTask):
-            return (
-                self.workflow.name == other.workflow.name
-                and self.runner.cron == other.runner.cron
-            )
-        return NotImplemented