ddeutil-workflow 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

ddeutil/workflow/scheduler.py

@@ -5,709 +5,448 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-import copy
+import logging
+import os
+import time
 from collections.abc import Iterator
-from dataclasses import dataclass, field
+from concurrent.futures import Future, ProcessPoolExecutor, as_completed
+from dataclasses import dataclass
 from datetime import datetime, timedelta
-from functools import partial, total_ordering
-from typing import Callable, Optional, Union
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
-
-from ddeutil.core import (
-    is_int,
-    isinstance_check,
-    must_split,
+from functools import wraps
+from heapq import heappush
+from threading import Thread
+from zoneinfo import ZoneInfo
+
+from ddeutil.workflow.__types import DictData
+from ddeutil.workflow.cron import CronRunner
+from ddeutil.workflow.exceptions import WorkflowException
+from ddeutil.workflow.log import FileLog, Log
+from ddeutil.workflow.on import On
+from ddeutil.workflow.pipeline import Pipeline
+from ddeutil.workflow.utils import (
+    Result,
+    batch,
+    delay,
+    get_diff_sec,
+    param2template,
 )
-from ddeutil.core.dtutils import (
-    next_date,
-    replace_date,
+from dotenv import load_dotenv
+from schedule import CancelJob, Scheduler
+
+load_dotenv("../../../.env")
+logging.basicConfig(
+    level=logging.DEBUG,
+    format=(
+        "%(asctime)s.%(msecs)03d (%(name)-10s, %(process)-5d, %(thread)-5d) "
+        "[%(levelname)-7s] %(message)-120s (%(filename)s:%(lineno)s)"
+    ),
+    handlers=[logging.StreamHandler()],
+    datefmt="%Y-%m-%d %H:%M:%S",
 )
+logging.getLogger("schedule").setLevel(logging.INFO)
+
+tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
 
-WEEKDAYS: dict[str, int] = {
-    "Sun": 0,
-    "Mon": 1,
-    "Tue": 2,
-    "Wed": 3,
-    "Thu": 4,
-    "Fri": 5,
-    "Sat": 6,
-}
-
-
-@dataclass(frozen=True)
-class Unit:
-    name: str
-    range: partial
-    min: int
-    max: int
-    alt: list[str] = field(default_factory=list)
-
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__}(name={self.name!r}, range={self.range},"
-            f"min={self.min}, max={self.max}"
-            f"{f', alt={self.alt}' if self.alt else ''})"
-        )
+
+def catch_exceptions(cancel_on_failure=False):
+    """Catch exception error from scheduler job."""
+
+    def catch_exceptions_decorator(job_func):
+        @wraps(job_func)
+        def wrapper(*args, **kwargs):
+            try:
+                return job_func(*args, **kwargs)
+            except Exception as err:
+                logging.exception(err)
+                if cancel_on_failure:
+                    return CancelJob
+
+        return wrapper
+
+    return catch_exceptions_decorator
 
 
 @dataclass
-class Options:
-    output_weekday_names: bool = False
-    output_month_names: bool = False
-    output_hashes: bool = False
-
-
-CRON_UNITS: tuple[Unit, ...] = (
-    Unit(
-        name="minute",
-        range=partial(range, 0, 60),
-        min=0,
-        max=59,
-    ),
-    Unit(
-        name="hour",
-        range=partial(range, 0, 24),
-        min=0,
-        max=23,
-    ),
-    Unit(
-        name="day",
-        range=partial(range, 1, 32),
-        min=1,
-        max=31,
-    ),
-    Unit(
-        name="month",
-        range=partial(range, 1, 13),
-        min=1,
-        max=12,
-        alt=[
-            "JAN",
-            "FEB",
-            "MAR",
-            "APR",
-            "MAY",
-            "JUN",
-            "JUL",
-            "AUG",
-            "SEP",
-            "OCT",
-            "NOV",
-            "DEC",
-        ],
-    ),
-    Unit(
-        name="weekday",
-        range=partial(range, 0, 7),
-        min=0,
-        max=6,
-        alt=[
-            "SUN",
-            "MON",
-            "TUE",
-            "WED",
-            "THU",
-            "FRI",
-            "SAT",
-        ],
-    ),
-)
+class PipelineTask:
+    pipeline: Pipeline
+    on: On
+    queue: list[datetime]
+    running: list[datetime]
+
+
+def queue2str(queue: list[datetime]) -> Iterator[str]:
+    return (f"{q:%Y-%m-%d %H:%M:%S}" for q in queue)
 
-CRON_UNITS_YEAR: tuple[Unit, ...] = CRON_UNITS + (
-    Unit(
-        name="year",
-        range=partial(range, 1990, 2101),
-        min=1990,
-        max=2100,
-    ),
-)
 
+def pipeline_release(
+    task: PipelineTask,
+    *,
+    log: Log | None = None,
+) -> None:
+    """Pipeline release, it will use with the same logic of `pipeline.release`
+    method.
 
-@total_ordering
-class CronPart:
-    """Part of Cron object that represent a collection of positive integers."""
+    :param task: A PipelineTask dataclass.
+    :param log: A log object.
+    """
+    log: Log = log or FileLog
+    pipeline: Pipeline = task.pipeline
+    on: On = task.on
+
+    gen: CronRunner = on.generate(
+        datetime.now(tz=tz).replace(second=0, microsecond=0)
+    )
+    cron_tz: ZoneInfo = gen.tz
+
+    next_running_time: datetime = gen.next
+    while next_running_time in task.running[pipeline.name]:
+        next_running_time: datetime = gen.next
+
+    logging.debug(
+        f"[CORE]: {pipeline.name!r} : {on.cronjob} : "
+        f"{next_running_time:%Y-%m-%d %H:%M:%S}"
+    )
+    heappush(task.running[pipeline.name], next_running_time)
+
+    # TODO: event should set on this step for release next pipeline task?
+
+    if get_diff_sec(next_running_time, tz=cron_tz) > 55:
+        logging.debug(
+            f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+            f"Does not closely >> {next_running_time:%Y-%m-%d %H:%M:%S}"
+        )
 
-    __slots__: tuple[str, ...] = (
-        "unit",
-        "options",
-        "values",
+        # NOTE: Add this next running datetime to queue
+        heappush(task.queue[pipeline.name], next_running_time)
+        task.running[pipeline.name].remove(next_running_time)
+        time.sleep(0.5)
+        return
+
+    logging.debug(
+        f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+        f"Closely to run >> {next_running_time:%Y-%m-%d %H:%M:%S}"
     )
 
-    def __init__(
-        self,
-        unit: Unit,
-        values: str | list[int],
-        options: Options,
-    ) -> None:
-        self.unit: Unit = unit
-        self.options: Options = options
-
-        if isinstance(values, str):
-            values: list[int] = self.from_str(values) if values != "?" else []
-        elif isinstance_check(values, list[int]):
-            values: list[int] = self.replace_weekday(values)
-        else:
-            raise TypeError(f"Invalid type of value in cron part: {values}.")
-
-        self.values: list[int] = self.out_of_range(
-            sorted(dict.fromkeys(values))
+    # NOTE: Release when the time is nearly to schedule time.
+    while (duration := get_diff_sec(next_running_time, tz=tz)) > (15 + 5):
+        logging.debug(
+            f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+            f"Sleep until: {duration}"
         )
+        time.sleep(15)
+
+    time.sleep(0.5)
+
+    # NOTE: Release parameter that use to change if params has
+    #   templating.
+    release_params: DictData = {
+        "release": {
+            "logical_date": next_running_time,
+        },
+    }
+
+    # WARNING: Re-create pipeline object that use new running pipeline
+    #   ID.
+    runner: Pipeline = pipeline.get_running_id(run_id=pipeline.new_run_id)
+    rs: Result = runner.execute(
+        # FIXME: replace fix parameters on this execution process.
+        params=param2template(
+            {"asat-dt": "${{ release.logical_date }}"}, release_params
+        ),
+    )
+    logging.debug(
+        f"({runner.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+        f"End release"
+    )
+
+    del runner
+
+    # NOTE: remove this release date from running
+    task.running[pipeline.name].remove(next_running_time)
+
+    # IMPORTANT:
+    #   Add the next running datetime to pipeline queue
+    finish_time: datetime = datetime.now(tz=cron_tz).replace(
+        second=0, microsecond=0
+    )
+    future_running_time: datetime = gen.next
+    while (
+        future_running_time in task.running[pipeline.name]
+        or future_running_time in task.queue[pipeline.name]
+        or future_running_time < finish_time
+    ):
+        future_running_time: datetime = gen.next
+
+    heappush(task.queue[pipeline.name], future_running_time)
+
+    # NOTE: Set parent ID on this result.
+    rs.set_parent_run_id(pipeline.run_id)
+
+    # NOTE: Save result to log object saving.
+    rs_log: Log = log.model_validate(
+        {
+            "name": pipeline.name,
+            "on": str(on.cronjob),
+            "release": next_running_time,
+            "context": rs.context,
+            "parent_run_id": rs.run_id,
+            "run_id": rs.run_id,
+        }
+    )
+    rs_log.save()
 
-    def __str__(self) -> str:
-        """Generate String value from part of cronjob."""
-        _hash: str = "H" if self.options.output_hashes else "*"
+    logging.debug(f"[CORE]: {rs}")
 
-        if self.is_full:
-            return _hash
 
-        if self.is_interval:
-            if self.is_full_interval:
-                return f"{_hash}/{self.step}"
-            _hash: str = (
-                f"H({self.filler(self.min)}-{self.filler(self.max)})"
-                if _hash == "H"
-                else f"{self.filler(self.min)}-{self.filler(self.max)}"
+@catch_exceptions(cancel_on_failure=True)
+def workflow_task(
+    pipeline_tasks: list[PipelineTask],
+    stop: datetime,
+    threads: dict[str, Thread],
+) -> CancelJob | None:
+    """Workflow task generator that create release pair of pipeline and on to
+    the threading in background.
+
+        This workflow task will start every minute at :02 second.
+    """
+    start_date: datetime = datetime.now(tz=tz)
+    start_date_minute = start_date.replace(second=0, microsecond=0)
+
+    if start_date > stop:
+        logging.info("[WORKFLOW]: Stop this schedule with datetime stopper.")
+        while len(threads) > 0:
+            logging.warning(
+                "[WORKFLOW]: Waiting pipeline release thread that still "
+                "running in background."
             )
-            return f"{_hash}/{self.step}"
-
-        cron_range_strings: list[str] = []
-        for cron_range in self.ranges():
-            if isinstance(cron_range, list):
-                cron_range_strings.append(
-                    f"{self.filler(cron_range[0])}-{self.filler(cron_range[1])}"
-                )
-            else:
-                cron_range_strings.append(f"{self.filler(cron_range)}")
-        return ",".join(cron_range_strings) if cron_range_strings else "?"
-
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}"
-            f"(unit={self.unit}, values={self.__str__()!r})"
+            time.sleep(15)
+            workflow_long_running_task(threads)
+        return CancelJob
+
+    # IMPORTANT:
+    #       Filter pipeline & on that should to run with `pipeline_release`
+    #   function. It will deplicate running with different schedule value
+    #   because I use current time in this condition.
+    #
+    #       For example, if a pipeline A queue has '00:02:00' time that
+    #   should to run and its schedule has '*/2 * * * *' and '*/35 * * * *'.
+    #   This condition will release with 2 threading job.
+    #
+    #   '00:02:00'  --> '*/2 * * * *'   --> running
+    #               --> '*/35 * * * *'  --> skip
+    #
+    for task in pipeline_tasks:
+
+        # NOTE: Get incoming datetime queue.
+        logging.debug(
+            f"[WORKFLOW]: Current queue: {task.pipeline.name!r} : "
+            f"{list(queue2str(task.queue[task.pipeline.name]))}"
         )
 
-    def __lt__(self, other) -> bool:
-        if isinstance(other, CronPart):
-            return self.values < other.values
-        elif isinstance(other, list):
-            return self.values < other
-
-    def __eq__(self, other) -> bool:
-        if isinstance(other, CronPart):
-            return self.values == other.values
-        elif isinstance(other, list):
-            return self.values == other
-
-    @property
-    def min(self) -> int:
-        """Returns the smallest value in the range."""
-        return self.values[0]
-
-    @property
-    def max(self) -> int:
-        """Returns the largest value in the range."""
-        return self.values[-1]
-
-    @property
-    def step(self) -> Optional[int]:
-        """Returns the difference between first and second elements in the
-        range.
-        """
+        # NOTE: Create minute unit value for any scheduler datetime that
+        #   checking a pipeline task should run in this datetime.
+        current_running_time: datetime = start_date_minute.astimezone(
+            tz=ZoneInfo(task.on.tz)
+        )
         if (
-            len(self.values) > 2
-            and (step := self.values[1] - self.values[0]) > 1
+            len(task.queue[task.pipeline.name]) > 0
+            and current_running_time != task.queue[task.pipeline.name][0]
+        ) or (
+            task.on.next(current_running_time)
+            != task.queue[task.pipeline.name][0]
         ):
-            return step
-
-    @property
-    def is_full(self) -> bool:
-        """Returns true if range has all the values of the unit."""
-        return len(self.values) == (self.unit.max - self.unit.min + 1)
-
-    def from_str(self, value: str) -> tuple[int, ...]:
-        """Parses a string as a range of positive integers. The string should
-        include only `-` and `,` special strings.
-
-        :param value: A string value that want to parse
-        :type value: str
-
-        TODO: support for `L`, `W`, and `#`
-        TODO: if you didn't care what day of the week the 7th was, you
-            could enter ? in the Day-of-week field.
-        TODO: L : the Day-of-month or Day-of-week fields specifies the last day
-            of the month or week.
-            DEV: use -1 for represent with L
-        TODO: W : In the Day-of-month field, 3W specifies the weekday closest
-            to the third day of the month.
-        TODO: # : 3#2 would be the second Tuesday of the month,
-            the 3 refers to Tuesday because it is the third day of each week.
-
-        Noted:
-            -   0 10 * * ? *
-                Run at 10:00 am (UTC) every day
-
-            -   15 12 * * ? *
-                Run at 12:15 pm (UTC) every day
-
-            -   0 18 ? * MON-FRI *
-                Run at 6:00 pm (UTC) every Monday through Friday
-
-            -   0 8 1 * ? *
-                Run at 8:00 am (UTC) every 1st day of the month
-
-            -   0/15 * * * ? *
-                Run every 15 minutes
-
-            -   0/10 * ? * MON-FRI *
-                Run every 10 minutes Monday through Friday
-
-            -   0/5 8-17 ? * MON-FRI *
-                Run every 5 minutes Monday through Friday between 8:00 am and
-                5:55 pm (UTC)
-
-            -   5,35 14 * * ? *
-                Run every day, at 5 and 35 minutes past 2:00 pm (UTC)
-
-            -   15 10 ? * 6L 2002-2005
-                Run at 10:15am UTC on the last Friday of each month during the
-                years 2002 to 2005
-
-        :rtype: tuple[int, ...]
-        """
-        interval_list: list[list[int]] = []
-        for _value in self.replace_alternative(value.upper()).split(","):
-            if _value == "?":
-                continue
-            elif _value.count("/") > 1:
-                raise ValueError(
-                    f"Invalid value {_value!r} in cron part {value!r}"
-                )
-
-            value_range, value_step = must_split(_value, "/", maxsplit=1)
-            value_range_list: list[int] = self.out_of_range(
-                self._parse_range(value_range)
+            logging.debug(
+                f"[WORKFLOW]: Skip schedule "
+                f"{current_running_time:%Y-%m-%d %H:%M:%S} "
+                f"for : {task.pipeline.name!r} : {task.on.cronjob}"
             )
-
-            if (value_step and not is_int(value_step)) or value_step == "":
-                raise ValueError(
-                    f"Invalid interval step value {value_step!r} for "
-                    f"{self.unit.name!r}"
-                )
-
-            interval_list.append(self._interval(value_range_list, value_step))
-        return tuple(item for sublist in interval_list for item in sublist)
-
-    def replace_alternative(self, value: str) -> str:
-        """Replaces the alternative representations of numbers in a string."""
-        for i, alt in enumerate(self.unit.alt):
-            if alt in value:
-                value: str = value.replace(alt, str(self.unit.min + i))
-        return value
-
-    def replace_weekday(self, values: list[int] | Iterator[int]) -> list[int]:
-        """Replaces all 7 with 0 as Sunday can be represented by both.
-
-        :param values: list or iter of int that want to mode by 7
-        :rtype: list[int]
-        """
-        if self.unit.name == "weekday":
-            # NOTE: change weekday value in range 0-6 (div-mod by 7).
-            return [value % 7 for value in values]
-        return list(values)
-
-    def out_of_range(self, values: list[int]) -> list[int]:
-        """Return an integer is a value out of range was found, otherwise None.
-
-        :param values: A list of int value
-        :type values: list[int]
-
-        :rtype: list[int]
-        """
-        if values:
-            if (first := values[0]) < self.unit.min:
-                raise ValueError(
-                    f"Value {first!r} out of range for {self.unit.name!r}"
-                )
-            elif (last := values[-1]) > self.unit.max:
-                raise ValueError(
-                    f"Value {last!r} out of range for {self.unit.name!r}"
-                )
-        return values
-
-    def _parse_range(self, value: str) -> list[int]:
-        """Parses a range string."""
-        if value == "*":
-            return list(self.unit.range())
-        elif value.count("-") > 1:
-            raise ValueError(f"Invalid value {value}")
-        try:
-            sub_parts: list[int] = list(map(int, value.split("-")))
-        except ValueError as exc:
-            raise ValueError(f"Invalid value {value!r} --> {exc}") from exc
-
-        if len(sub_parts) == 2:
-            min_value, max_value = sub_parts
-            if max_value < min_value:
-                raise ValueError(f"Max range is less than min range in {value}")
-            sub_parts: list[int] = list(range(min_value, max_value + 1))
-        return self.replace_weekday(sub_parts)
-
-    def _interval(
-        self,
-        values: list[int],
-        step: int | None = None,
-    ) -> list[int]:
-        """Applies an interval step to a collection of values."""
-        if not step:
-            return values
-        elif (_step := int(step)) < 1:
-            raise ValueError(
-                f"Invalid interval step value {_step!r} for "
-                f"{self.unit.name!r}"
+            continue
+        elif len(task.queue[task.pipeline.name]) == 0:
+            # TODO: Should auto add new queue?
+            logging.warning(
+                f"[WORKFLOW]: Queue is empty for : {task.pipeline.name!r} : "
+                f"{task.on.cronjob}"
             )
-        min_value: int = values[0]
-        return [
-            value
-            for value in values
-            if (value % _step == min_value % _step) or (value == min_value)
-        ]
+            continue
 
-    @property
-    def is_interval(self) -> bool:
-        """Returns true if the range can be represented as an interval."""
-        if not (step := self.step):
-            return False
-        for idx, value in enumerate(self.values):
-            if idx == 0:
-                continue
-            elif (value - self.values[idx - 1]) != step:
-                return False
-        return True
-
-    @property
-    def is_full_interval(self) -> bool:
-        """Returns true if the range contains all the interval values."""
-        if step := self.step:
-            return (
-                self.min == self.unit.min
-                and (self.max + step) > self.unit.max
-                and (
-                    len(self.values)
-                    == (round((self.max - self.min) / step) + 1)
-                )
-            )
-        return False
-
-    def ranges(self) -> list[Union[int, list[int]]]:
-        """Returns the range as an array of ranges defined as arrays of
-        positive integers.
+        # NOTE: Remove this datetime from queue.
+        task.queue[task.pipeline.name].pop(0)
 
-        :rtype: list[Union[int, list[int]]]
-        """
-        multi_dim_values: list[Union[int, list[int]]] = []
-        start_number: Optional[int] = None
-        for idx, value in enumerate(self.values):
-            try:
-                next_value: int = self.values[idx + 1]
-            except IndexError:
-                next_value: int = -1
-            if value != (next_value - 1):
-                # NOTE: ``next_value`` is not the subsequent number
-                if start_number is None:
-                    # NOTE:
-                    #   The last number of the list ``self.values`` is not in a
-                    #   range.
-                    multi_dim_values.append(value)
-                else:
-                    multi_dim_values.append([start_number, value])
-                    start_number: Optional[int] = None
-            elif start_number is None:
-                start_number: Optional[int] = value
-        return multi_dim_values
-
-    def filler(self, value: int) -> int | str:
-        """Formats weekday and month names as string when the relevant options
-        are set.
-
-        :param value: a int value
-        :type value: int
-
-        :rtype: int | str
-        """
-        return (
-            self.unit.alt[value - self.unit.min]
-            if (
-                (
-                    self.options.output_weekday_names
-                    and self.unit.name == "weekday"
-                )
-                or (
-                    self.options.output_month_names
-                    and self.unit.name == "month"
-                )
-            )
-            else value
+        thread_name: str = (
+            f"{task.pipeline.name}|{str(task.on.cronjob)}|"
+            f"{current_running_time:%Y%m%d%H%M}"
         )
+        pipe_thread: Thread = Thread(
+            target=pipeline_release,
+            args=(task,),
+            name=thread_name,
+            daemon=True,
+        )
+
+        threads[thread_name] = pipe_thread
 
+        pipe_thread.start()
 
-@total_ordering
-class CronJob:
-    """The Cron Job Converter object that generate datetime dimension of cron
-    job schedule format,
+        delay()
 
-            ... * * * * * <command to execute>
+    logging.debug(f"[WORKFLOW]: {'=' * 100}")
 
-        (i)     minute (0 - 59)
-        (ii)    hour (0 - 23)
-        (iii)   day of the month (1 - 31)
-        (iv)    month (1 - 12)
-        (v)     day of the week (0 - 6) (Sunday to Saturday; 7 is also Sunday
-                on some systems)
 
-        This object implement necessary methods and properties for using cron
-    job value with other object like Schedule.
-        Support special value with `/`, `*`, `-`, `,`, and `?` (in day of month
-    and day of week value).
+def workflow_long_running_task(threads: dict[str, Thread]) -> None:
+    """Workflow schedule for monitoring long running thread from the schedule
+    control.
 
-    References:
-        - https://github.com/Sonic0/cron-converter
-        - https://pypi.org/project/python-crontab/
+    :param threads: A mapping of Thread object and its name.
     """
+    logging.debug("[MONITOR]: Start checking long running pipeline release.")
+    snapshot_threads = list(threads.keys())
+    for t_name in snapshot_threads:
 
-    cron_length: int = 5
-    cron_units: tuple[Unit, ...] = CRON_UNITS
-
-    def __init__(
-        self,
-        value: Union[list[list[int]], str],
-        *,
-        option: Optional[dict[str, bool]] = None,
-    ) -> None:
-        if isinstance(value, str):
-            value: list[str] = value.strip().split()
-        elif not isinstance_check(value, list[list[int]]):
-            raise TypeError(
-                f"{self.__class__.__name__} cron value does not support "
-                f"type: {type(value)}."
-            )
+        # NOTE: remove the thread that running success.
+        if not threads[t_name].is_alive():
+            threads.pop(t_name)
 
-        # NOTE: Validate length of crontab of this class.
-        if len(value) != self.cron_length:
-            raise ValueError(
-                f"Invalid cron value does not have length equal "
-                f"{self.cron_length}: {value}."
-            )
-        self.options: Options = Options(**(option or {}))
 
-        # NOTE: Start initial crontab for each part
-        self.parts: list[CronPart] = [
-            CronPart(unit, values=item, options=self.options)
-            for item, unit in zip(value, self.cron_units)
-        ]
+def workflow_control(
+    pipelines: list[str],
+    until: datetime | None = None,
+    externals: DictData | None = None,
+) -> list[str]:
+    """Workflow scheduler control.
 
-        # NOTE: Validate values of `day` and `dow` from parts.
-        if self.day == self.dow == []:
-            raise ValueError(
-                "Invalid cron value when set the `?` on day of month and "
-                "day of week together"
-            )
+    :param pipelines: A list of pipeline names that want to schedule running.
+    :param until:
+    :param externals: An external parameters that pass to Loader.
+    """
+    schedule: Scheduler = Scheduler()
+    start_date: datetime = datetime.now(tz=tz)
+
+    # NOTE: Design workflow queue caching.
+    #   ---
+    #   {"pipeline-name": [<release-datetime>, <release-datetime>, ...]}
+    #
+    wf_queue: dict[str, list[datetime]] = {}
+    wf_running: dict[str, list[datetime]] = {}
+    thread_releases: dict[str, Thread] = {}
+
+    start_date_waiting: datetime = (start_date + timedelta(minutes=1)).replace(
+        second=0, microsecond=0
+    )
 
-    def __str__(self) -> str:
-        """Return joining with space of each value in parts."""
-        return " ".join(str(part) for part in self.parts)
+    # NOTE: Create pair of pipeline and on.
+    pipeline_tasks: list[PipelineTask] = []
 
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}(value={self.__str__()!r}, "
-            f"option={self.options.__dict__})"
-        )
+    for name in pipelines:
+        pipeline: Pipeline = Pipeline.from_loader(name, externals=externals)
 
-    def __lt__(self, other) -> bool:
-        return any(
-            part < other_part
-            for part, other_part in zip(self.parts_order, other.parts_order)
-        )
+        # NOTE: Create default list of release datetime.
+        wf_queue[name]: list[datetime] = []
+        wf_running[name]: list[datetime] = []
 
-    def __eq__(self, other) -> bool:
-        return all(
-            part == other_part
-            for part, other_part in zip(self.parts, other.parts)
-        )
+        for on in pipeline.on:
 
-    @property
-    def parts_order(self) -> Iterator[CronPart]:
-        return reversed(self.parts[:3] + [self.parts[4], self.parts[3]])
-
-    @property
-    def minute(self) -> CronPart:
-        """Return part of minute."""
-        return self.parts[0]
-
-    @property
-    def hour(self) -> CronPart:
-        """Return part of hour."""
-        return self.parts[1]
-
-    @property
-    def day(self) -> CronPart:
-        """Return part of day."""
-        return self.parts[2]
-
-    @property
-    def month(self) -> CronPart:
-        """Return part of month."""
-        return self.parts[3]
-
-    @property
-    def dow(self) -> CronPart:
-        """Return part of day of month."""
-        return self.parts[4]
-
-    def to_list(self) -> list[list[int]]:
-        """Returns the cron schedule as a 2-dimensional list of integers."""
-        return [part.values for part in self.parts]
-
-    def schedule(
-        self,
-        date: datetime | None = None,
-        *,
-        tz: str | None = None,
-    ) -> CronRunner:
-        """Returns the schedule datetime runner with this cronjob. It would run
-        ``next``, ``prev``, or ``reset`` to generate running date that you want.
-
-        :param date: An initial date that want to mark as the start point.
-        :param tz: A string timezone that want to change on runner.
-        :rtype: CronRunner
-        """
-        return CronRunner(self, date, tz=tz)
-
-
-class CronJobYear(CronJob):
-    cron_length = 6
-    cron_units = CRON_UNITS_YEAR
-
-    @property
-    def year(self) -> CronPart:
-        """Return part of year."""
-        return self.parts[5]
-
-
-class CronRunner:
-    """Create an instance of Date Runner object for datetime generate with
-    cron schedule object value.
-    """
+            on_gen = on.generate(start_date_waiting)
+            next_running_date = on_gen.next
+            while next_running_date in wf_queue[name]:
+                next_running_date = on_gen.next
 
-    __slots__: tuple[str, ...] = (
-        "__start_date",
-        "cron",
-        "date",
-        "reset_flag",
-        "tz",
-    )
+            heappush(wf_queue[name], next_running_date)
+            pipeline_tasks.append(
+                PipelineTask(
+                    pipeline=pipeline, on=on, queue=wf_queue, running=wf_running
+                ),
+            )
 
-    def __init__(
-        self,
-        cron: CronJob | CronJobYear,
-        date: datetime | None = None,
-        *,
-        tz: str | None = None,
-    ) -> None:
-        # NOTE: Prepare timezone if this value does not set, it will use UTC.
-        self.tz: ZoneInfo = ZoneInfo("UTC")
-        if tz:
-            try:
-                self.tz = ZoneInfo(tz)
-            except ZoneInfoNotFoundError as err:
-                raise ValueError(f"Invalid timezone: {tz}") from err
-
-        # NOTE: Prepare date
-        if date:
-            if not isinstance(date, datetime):
-                raise ValueError(
-                    "Input schedule start time is not a valid datetime object."
-                )
-            if tz is None:
-                self.tz = date.tzinfo
-            self.date: datetime = date.astimezone(self.tz)
-        else:
-            self.date: datetime = datetime.now(tz=self.tz)
-
-        # NOTE: Add one minute if the second value more than 0.
-        if self.date.second > 0:
-            self.date: datetime = self.date + timedelta(minutes=1)
-
-        self.__start_date: datetime = self.date
-        self.cron: CronJob | CronJobYear = cron
-        self.reset_flag: bool = True
-
-    def reset(self) -> None:
-        """Resets the iterator to start time."""
-        self.date: datetime = self.__start_date
-        self.reset_flag: bool = True
-
-    @property
-    def next(self) -> datetime:
-        """Returns the next time of the schedule."""
-        self.date = (
-            self.date
-            if self.reset_flag
-            else (self.date + timedelta(minutes=+1))
-        )
-        return self.find_date(reverse=False)
-
-    @property
-    def prev(self) -> datetime:
-        """Returns the previous time of the schedule."""
-        self.date: datetime = self.date + timedelta(minutes=-1)
-        return self.find_date(reverse=True)
-
-    def find_date(self, reverse: bool = False) -> datetime:
-        """Returns the time the schedule would run by `next` or `prev`.
-
-        :param reverse: A reverse flag.
-        """
-        # NOTE: Set reset flag to false if start any action.
-        self.reset_flag: bool = False
-        for _ in range(25):
-            if all(
-                not self.__shift_date(mode, reverse)
-                for mode in ("month", "day", "hour", "minute")
-            ):
-                return copy.deepcopy(self.date.replace(second=0, microsecond=0))
-        raise RecursionError("Unable to find execution time for schedule")
-
-    def __shift_date(self, mode: str, reverse: bool = False) -> bool:
-        """Increments the mode value until matches with the schedule."""
-        switch: dict[str, str] = {
-            "month": "year",
-            "day": "month",
-            "hour": "day",
-            "minute": "hour",
-        }
-        current_value: int = getattr(self.date, switch[mode])
-        _addition_condition: Callable[[], bool] = (
-            (
-                lambda: WEEKDAYS.get(self.date.strftime("%a"))
-                not in self.cron.dow.values
+    # NOTE: This schedule job will start every minute at :02 seconds.
+    schedule.every(1).minutes.at(":02").do(
+        workflow_task,
+        pipeline_tasks=pipeline_tasks,
+        stop=until or (start_date + timedelta(minutes=5, seconds=20)),
+        threads=thread_releases,
+    ).tag("control")
+
+    # NOTE: Checking zombie task with schedule job will start every 5 minute.
+    schedule.every(5).minutes.at(":10").do(
+        workflow_long_running_task,
+        threads=thread_releases,
+    ).tag("monitor")
+
+    # NOTE: Start running schedule
+    logging.info(f"[WORKFLOW]: Start schedule: {pipelines}")
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
+        if not schedule.get_jobs("control"):
+            schedule.clear("monitor")
+            logging.warning(
+                f"[WORKFLOW]: Pipeline release thread: {thread_releases}"
             )
-            if mode == "day"
-            else lambda: False
-        )
-        # NOTE: Start while-loop for checking this date include in this cronjob.
-        while (
-            getattr(self.date, mode) not in getattr(self.cron, mode).values
-        ) or _addition_condition():
-            self.date: datetime = next_date(self.date, mode, reverse=reverse)
-            self.date: datetime = replace_date(self.date, mode, reverse=reverse)
-            if current_value != getattr(self.date, switch[mode]):
-                return mode != "month"
-        return False
-
-
-__all__ = (
-    "CronJob",
-    "CronJobYear",
-    "CronRunner",
-    "WEEKDAYS",
-)
+            logging.warning("[WORKFLOW]: Does not have any schedule jobs !!!")
+            break
+
+    logging.warning(f"Queue: {[wf_queue[wf] for wf in wf_queue]}")
+    logging.warning(f"Running: {[wf_running[wf] for wf in wf_running]}")
+    return pipelines
+
+
+def workflow(
+    until: datetime | None = None,
+    externals: DictData | None = None,
+    excluded: list[str] | None = None,
+):
+    """Workflow application that running multiprocessing schedule with chunk of
+    pipelines that exists in config path.
+
+    :param until:
+    :param excluded:
+    :param externals:
+
+        This function will get all pipelines that include on value that was
+    created in config path and chuck it with WORKFLOW_APP_PIPELINE_PER_PROCESS
+    value to multiprocess executor pool.
+
+    The current workflow logic:
+    ---
+        PIPELINES ==> process 01 ==> schedule 1 minute --> thread of release
+                                                           pipeline task 01 01
+                                                       --> thread of release
+                                                           pipeline task 01 02
+                  ==> process 02 ==> schedule 1 minute --> thread of release
+                                                           pipeline task 02 01
+                                                       --> thread of release
+                                                           pipeline task 02 02
+                  ==> ...
+    """
+    excluded: list = excluded or []
+
+    with ProcessPoolExecutor(max_workers=2) as executor:
+        futures: list[Future] = [
+            executor.submit(
+                workflow_control,
+                pipelines=[load[0] for load in loader],
+                until=until,
+                externals=(externals or {}),
+            )
+            for loader in batch(
+                # Loader.find(Pipeline, include=["on"], excluded=excluded),
+                [
+                    ("pipe-scheduling", None),
+                    # ("pipe-scheduling-minute", None),
+                ],
+                n=1,
+            )
+        ]
+
+        results: list[str] = []
+        for future in as_completed(futures):
+            if err := future.exception():
+                logging.error(str(err))
+                raise WorkflowException(str(err)) from err
+            results.extend(future.result(timeout=1))
+        return results
+
+
+if __name__ == "__main__":
+    # TODO: Define input arguments that want to manage this application.
+    workflow_rs: list[str] = workflow()
+    logging.info(f"Application run success: {workflow_rs}")