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

ddeutil/workflow/scheduler.py

@@ -6,708 +6,615 @@
 from __future__ import annotations
 
 import copy
+import json
+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 typing import Optional
+from zoneinfo import ZoneInfo
+
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field
+from pydantic.functional_validators import model_validator
+from typing_extensions import Self
+
+try:
+    from schedule import CancelJob, Scheduler
+except ImportError:
+    raise ImportError(
+        "Should install schedule package before use this module."
+    ) from None
+
+from .__types import DictData
+from .cron import CronRunner
+from .exceptions import WorkflowException
+from .log import FileLog, Log, get_logger
+from .on import On
+from .pipeline import Pipeline
+from .utils import (
+    Loader,
+    Result,
+    batch,
+    delay,
+    get_diff_sec,
+    param2template,
 )
-from ddeutil.core.dtutils import (
-    next_date,
-    replace_date,
+
+load_dotenv()
+logger = get_logger("ddeutil.workflow")
+logging.getLogger("schedule").setLevel(logging.INFO)
+
+
+__all__ = (
+    "PipelineSchedule",
+    "Schedule",
+    "workflow",
 )
 
-WEEKDAYS: dict[str, int] = {
-    "Sun": 0,
-    "Mon": 1,
-    "Tue": 2,
-    "Wed": 3,
-    "Thu": 4,
-    "Fri": 5,
-    "Sat": 6,
-}
 
+class PipelineSchedule(BaseModel):
+    """Pipeline schedule Pydantic Model."""
 
-@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 ''})"
-        )
+    name: str = Field(description="A pipeline name.")
+    on: list[On] = Field(
+        default_factory=list,
+        description="An override On instance value.",
+    )
+    params: DictData = Field(
+        default_factory=dict,
+        description="A parameters that want to use to pipeline execution.",
+    )
 
+    @model_validator(mode="before")
+    def __prepare__values(cls, values: DictData) -> DictData:
+        """Prepare incoming values before validating with model fields."""
 
-@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",
-        ],
-    ),
-)
+        values["name"] = values["name"].replace(" ", "_")
 
-CRON_UNITS_YEAR: tuple[Unit, ...] = CRON_UNITS + (
-    Unit(
-        name="year",
-        range=partial(range, 1990, 2101),
-        min=1990,
-        max=2100,
-    ),
-)
+        cls.__bypass_on(values)
+        return values
+
+    @classmethod
+    def __bypass_on(cls, data: DictData, externals: DictData | None = None):
+        """Bypass the on data to loaded config data."""
+        if on := data.pop("on", []):
+
+            if isinstance(on, str):
+                on = [on]
 
+            if any(not isinstance(n, (dict, str)) for n in on):
+                raise TypeError("The ``on`` key should be list of str or dict")
 
-@total_ordering
-class CronPart:
-    """Part of Cron object that represent a collection of positive integers."""
+            # NOTE: Pass on value to Loader and keep on model object to on field
+            data["on"] = [
+                (
+                    Loader(n, externals=(externals or {})).data
+                    if isinstance(n, str)
+                    else n
+                )
+                for n in on
+            ]
+        return data
 
-    __slots__: tuple[str, ...] = (
-        "unit",
-        "options",
-        "values",
+
+class Schedule(BaseModel):
+    """Schedule Pydantic Model that use to run with scheduler package. It does
+    not equal the on value in Pipeline model but it use same logic to running
+    release date with crontab interval.
+    """
+
+    desc: Optional[str] = Field(
+        default=None,
+        description=(
+            "A schedule description that can be string of markdown content."
+        ),
+    )
+    pipelines: list[PipelineSchedule] = Field(
+        default_factory=list,
+        description="A list of PipelineSchedule models.",
     )
 
-    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))
-        )
+    @classmethod
+    def from_loader(
+        cls,
+        name: str,
+        externals: DictData | None = None,
+    ) -> Self:
+        loader: Loader = Loader(name, externals=(externals or {}))
 
-    def __str__(self) -> str:
-        """Generate String value from part of cronjob."""
-        _hash: str = "H" if self.options.output_hashes else "*"
+        # NOTE: Validate the config type match with current connection model
+        if loader.type != cls:
+            raise ValueError(f"Type {loader.type} does not match with {cls}")
 
-        if self.is_full:
-            return _hash
+        loader_data: DictData = copy.deepcopy(loader.data)
 
-        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)}"
-            )
-            return f"{_hash}/{self.step}"
+        # NOTE: Add name to loader data
+        loader_data["name"] = name.replace(" ", "_")
 
-        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})"
-        )
+        return cls.model_validate(obj=loader_data)
 
-    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.
+    def tasks(
+        self,
+        start_date: datetime,
+        queue: dict[str, list[datetime]],
+        running: dict[str, list[datetime]],
+        externals: DictData | None = None,
+    ) -> list[PipelineTask]:
+        """Generate Task from the current datetime.
+
+        :param start_date: A start date that get from the workflow schedule.
+        :param queue:
+        :param running:
+        :param externals: An external parameters that pass to the Loader object.
+        :rtype: list[PipelineTask]
         """
-        if (
-            len(self.values) > 2
-            and (step := self.values[1] - self.values[0]) > 1
-        ):
-            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)
+        # NOTE: Create pair of pipeline and on.
+        pipeline_tasks: list[PipelineTask] = []
+        externals: DictData = externals or {}
 
-    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.
+        for pipe in self.pipelines:
+            pipeline: Pipeline = Pipeline.from_loader(
+                pipe.name, externals=externals
+            )
 
-        :param value: A string value that want to parse
-        :type value: str
+            # NOTE: Create default list of release datetime.
+            queue[pipe.name]: list[datetime] = []
+            running[pipe.name]: list[datetime] = []
+
+            for on in pipeline.on:
+                on_gen = on.generate(start_date)
+                next_running_date = on_gen.next
+                while next_running_date in queue[pipe.name]:
+                    next_running_date = on_gen.next
+
+                heappush(queue[pipe.name], next_running_date)
+
+                pipeline_tasks.append(
+                    PipelineTask(
+                        pipeline=pipeline,
+                        on=on,
+                        params=pipe.params,
+                        queue=queue,
+                        running=running,
+                    ),
+                )
 
-        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.
+        return pipeline_tasks
 
-        Noted:
-            -   0 10 * * ? *
-                Run at 10:00 am (UTC) every day
 
-            -   15 12 * * ? *
-                Run at 12:15 pm (UTC) every day
+def catch_exceptions(cancel_on_failure=False):
+    """Catch exception error from scheduler job."""
 
-            -   0 18 ? * MON-FRI *
-                Run at 6:00 pm (UTC) every Monday through Friday
+    def catch_exceptions_decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as err:
+                logger.exception(err)
+                if cancel_on_failure:
+                    return CancelJob
 
-            -   0 8 1 * ? *
-                Run at 8:00 am (UTC) every 1st day of the month
+        return wrapper
 
-            -   0/15 * * * ? *
-                Run every 15 minutes
+    return catch_exceptions_decorator
 
-            -   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)
+def catch_exceptions_method(cancel_on_failure=False):
+    """Catch exception error from scheduler job."""
 
-            -   5,35 14 * * ? *
-                Run every day, at 5 and 35 minutes past 2:00 pm (UTC)
+    def catch_exceptions_decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except Exception as err:
+                logger.exception(err)
+                if cancel_on_failure:
+                    return CancelJob
 
-            -   15 10 ? * 6L 2002-2005
-                Run at 10:15am UTC on the last Friday of each month during the
-                years 2002 to 2005
+        return wrapper
 
-        :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}"
-                )
+    return catch_exceptions_decorator
 
-            value_range, value_step = must_split(_value, "/", maxsplit=1)
-            value_range_list: list[int] = self.out_of_range(
-                self._parse_range(value_range)
-            )
-
-            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)
+@dataclass(frozen=True)
+class PipelineTask:
+    """Pipeline task dataclass that use to keep mapping data and objects for
+    passing in multithreading task.
+    """
 
-    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
+    pipeline: Pipeline
+    on: On
+    params: DictData
+    queue: list[datetime]
+    running: list[datetime]
 
-    def replace_weekday(self, values: list[int] | Iterator[int]) -> list[int]:
-        """Replaces all 7 with 0 as Sunday can be represented by both.
+    @catch_exceptions_method(cancel_on_failure=True)
+    def release(self, log: Log | None = None) -> None:
+        """Pipeline release, it will use with the same logic of
+        `pipeline.release` method.
 
-        :param values: list or iter of int that want to mode by 7
-        :rtype: list[int]
+        :param log: A log object.
         """
-        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)
+        tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
+        log: Log = log or FileLog
+        pipeline: Pipeline = self.pipeline
+        on: On = self.on
 
-    def out_of_range(self, values: list[int]) -> list[int]:
-        """Return an integer is a value out of range was found, otherwise None.
+        gen: CronRunner = on.generate(
+            datetime.now(tz=tz).replace(second=0, microsecond=0)
+        )
+        cron_tz: ZoneInfo = gen.tz
 
-        :param values: A list of int value
-        :type values: list[int]
+        # NOTE: get next schedule time that generate from now.
+        next_time: datetime = gen.next
 
-        :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
+        # NOTE: get next utils it does not running.
+        while log.is_pointed(
+            pipeline.name, next_time, queue=self.running[pipeline.name]
+        ):
+            next_time: datetime = gen.next
 
-    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}"
-            )
-        min_value: int = values[0]
-        return [
-            value
-            for value in values
-            if (value % _step == min_value % _step) or (value == min_value)
-        ]
+        logger.debug(
+            f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+            f"{next_time:%Y-%m-%d %H:%M:%S}"
+        )
+        heappush(self.running[pipeline.name], next_time)
 
-    @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)
-                )
+        if get_diff_sec(next_time, tz=cron_tz) > 55:
+            logger.debug(
+                f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} "
+                f": Does not closely >> {next_time:%Y-%m-%d %H:%M:%S}"
             )
-        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: Add this next running datetime that not in period to queue
+            #   and remove it to running.
+            self.running[pipeline.name].remove(next_time)
+            heappush(self.queue[pipeline.name], next_time)
 
-        :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
+            time.sleep(0.2)
+            return
+
+        logger.debug(
+            f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+            f"Closely to run >> {next_time:%Y-%m-%d %H:%M:%S}"
         )
 
+        # NOTE: Release when the time is nearly to schedule time.
+        while (duration := get_diff_sec(next_time, tz=tz)) > (15 + 5):
+            logger.debug(
+                f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} "
+                f": Sleep until: {duration}"
+            )
+            time.sleep(15)
 
-@total_ordering
-class CronJob:
-    """The Cron Job Converter object that generate datetime dimension of cron
-    job schedule format,
+        time.sleep(0.5)
 
-            ... * * * * * <command to execute>
+        # NOTE: Release parameter that use to change if params has
+        #   templating.
+        release_params: DictData = {
+            "release": {
+                "logical_date": next_time,
+            },
+        }
 
-        (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)
+        # 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(
+            params=param2template(self.params, release_params),
+        )
+        logger.debug(
+            f"({runner.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+            f"End release - {next_time:%Y-%m-%d %H:%M:%S}"
+        )
 
-        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).
+        del runner
+
+        # 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_time,
+                "context": rs.context,
+                "parent_run_id": rs.run_id,
+                "run_id": rs.run_id,
+            }
+        )
+        rs_log.save(excluded=None)
 
-    References:
-        - https://github.com/Sonic0/cron-converter
-        - https://pypi.org/project/python-crontab/
-    """
+        # NOTE: remove this release date from running
+        self.running[pipeline.name].remove(next_time)
 
-    cron_length: int = 5
-    cron_units: tuple[Unit, ...] = CRON_UNITS
+        # 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 self.running[pipeline.name]
+            or future_running_time in self.queue[pipeline.name]
+            or future_running_time < finish_time
+        ):
+            future_running_time: datetime = gen.next
 
-    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)}."
-            )
+        heappush(self.queue[pipeline.name], future_running_time)
+        logger.debug(f"[CORE]: {'-' * 100}")
 
-        # 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 queue2str(queue: list[datetime]) -> Iterator[str]:
+    return (f"{q:%Y-%m-%d %H:%M:%S}" for q in queue)
 
-        # 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"
-            )
 
-    def __str__(self) -> str:
-        """Return joining with space of each value in parts."""
-        return " ".join(str(part) for part in self.parts)
+@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.
 
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}(value={self.__str__()!r}, "
-            f"option={self.options.__dict__})"
-        )
+        This workflow task will start every minute at :02 second.
 
-    def __lt__(self, other) -> bool:
-        return any(
-            part < other_part
-            for part, other_part in zip(self.parts_order, other.parts_order)
+    :param pipeline_tasks:
+    :param stop:
+    :param threads:
+    :rtype: CancelJob | None
+    """
+    tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
+    start_date: datetime = datetime.now(tz=tz)
+    start_date_minute: datetime = start_date.replace(second=0, microsecond=0)
+
+    if start_date > stop:
+        logger.info("[WORKFLOW]: Stop this schedule with datetime stopper.")
+        while len(threads) > 0:
+            logger.warning(
+                "[WORKFLOW]: Waiting pipeline release thread that still "
+                "running in background."
+            )
+            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.
+        logger.debug(
+            f"[WORKFLOW]: Current queue: {task.pipeline.name!r} : "
+            f"{list(queue2str(task.queue[task.pipeline.name]))}"
         )
 
-    def __eq__(self, other) -> bool:
-        return all(
-            part == other_part
-            for part, other_part in zip(self.parts, other.parts)
+        # 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(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]
+        ):
+            logger.debug(
+                f"[WORKFLOW]: Skip schedule "
+                f"{current_running_time:%Y-%m-%d %H:%M:%S} "
+                f"for : {task.pipeline.name!r} : {task.on.cronjob}"
+            )
+            continue
+        elif len(task.queue[task.pipeline.name]) == 0:
+            logger.warning(
+                f"[WORKFLOW]: Queue is empty for : {task.pipeline.name!r} : "
+                f"{task.on.cronjob}"
+            )
+            continue
 
-    @property
-    def parts_order(self) -> Iterator[CronPart]:
-        return reversed(self.parts[:3] + [self.parts[4], self.parts[3]])
+        # NOTE: Remove this datetime from queue.
+        task.queue[task.pipeline.name].pop(0)
 
-    @property
-    def minute(self) -> CronPart:
-        """Return part of minute."""
-        return self.parts[0]
+        # NOTE: Create thread name that able to tracking with observe schedule
+        #   job.
+        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=task.release,
+            name=thread_name,
+            daemon=True,
+        )
 
-    @property
-    def hour(self) -> CronPart:
-        """Return part of hour."""
-        return self.parts[1]
+        threads[thread_name] = pipe_thread
 
-    @property
-    def day(self) -> CronPart:
-        """Return part of day."""
-        return self.parts[2]
+        pipe_thread.start()
 
-    @property
-    def month(self) -> CronPart:
-        """Return part of month."""
-        return self.parts[3]
+        delay()
 
-    @property
-    def dow(self) -> CronPart:
-        """Return part of day of month."""
-        return self.parts[4]
+    logger.debug(f"[WORKFLOW]: {'=' * 100}")
 
-    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)
+def workflow_long_running_task(threads: dict[str, Thread]) -> None:
+    """Workflow schedule for monitoring long running thread from the schedule
+    control.
 
+    :param threads: A mapping of Thread object and its name.
+    :rtype: None
+    """
+    logger.debug(
+        "[MONITOR]: Start checking long running pipeline release task."
+    )
+    snapshot_threads = list(threads.keys())
+    for t_name in snapshot_threads:
 
-class CronJobYear(CronJob):
-    cron_length = 6
-    cron_units = CRON_UNITS_YEAR
+        # NOTE: remove the thread that running success.
+        if not threads[t_name].is_alive():
+            threads.pop(t_name)
 
-    @property
-    def year(self) -> CronPart:
-        """Return part of year."""
-        return self.parts[5]
 
+def workflow_control(
+    schedules: list[str],
+    stop: datetime | None = None,
+    externals: DictData | None = None,
+) -> list[str]:
+    """Workflow scheduler control.
 
-class CronRunner:
-    """Create an instance of Date Runner object for datetime generate with
-    cron schedule object value.
+    :param schedules: A list of pipeline names that want to schedule running.
+    :param stop: An datetime value that use to stop running schedule.
+    :param externals: An external parameters that pass to Loader.
+    :rtype: list[str]
     """
-
-    __slots__: tuple[str, ...] = (
-        "__start_date",
-        "cron",
-        "date",
-        "reset_flag",
-        "tz",
+    tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
+    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 __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))
+    # NOTE: Create pair of pipeline and on from schedule model.
+    pipeline_tasks: list[PipelineTask] = []
+    for name in schedules:
+        sch: Schedule = Schedule.from_loader(name, externals=externals)
+        pipeline_tasks.extend(
+            sch.tasks(start_date_waiting, wf_queue, wf_running, externals)
         )
-        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`.
+    # 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=stop
+        or (
+            start_date
+            + timedelta(
+                **json.loads(
+                    os.getenv("WORKFLOW_APP_STOP_BOUNDARY_DELTA")
+                    or '{"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
+    logger.info(f"[WORKFLOW]: Start schedule: {schedules}")
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
+        if not schedule.get_jobs("control"):
+            schedule.clear("monitor")
+            logger.warning(
+                f"[WORKFLOW]: Pipeline release thread: {thread_releases}"
+            )
+            logger.warning("[WORKFLOW]: Does not have any schedule jobs !!!")
+            break
 
-        :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
+    logger.warning(
+        f"Queue: {[list(queue2str(wf_queue[wf])) for wf in wf_queue]}"
+    )
+    logger.warning(
+        f"Running: {[list(queue2str(wf_running[wf])) for wf in wf_running]}"
+    )
+    return schedules
+
+
+def workflow(
+    stop: datetime | None = None,
+    externals: DictData | None = None,
+    excluded: list[str] | None = None,
+) -> list[str]:
+    """Workflow application that running multiprocessing schedule with chunk of
+    pipelines that exists in config path.
+
+    :param stop:
+    :param excluded:
+    :param externals:
+    :rtype: list[str]
+
+        This function will get all pipelines that include on value that was
+    created in config path and chuck it with WORKFLOW_APP_SCHEDULE_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[str] = excluded or []
+
+    with ProcessPoolExecutor(
+        max_workers=int(os.getenv("WORKFLOW_APP_PROCESS_WORKER") or "2"),
+    ) as executor:
+        futures: list[Future] = [
+            executor.submit(
+                workflow_control,
+                schedules=[load[0] for load in loader],
+                stop=stop,
+                externals=(externals or {}),
             )
-            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
+            for loader in batch(
+                Loader.finds(Schedule, excluded=excluded),
+                n=int(os.getenv("WORKFLOW_APP_SCHEDULE_PER_PROCESS") or "100"),
+            )
+        ]
 
+        results: list[str] = []
+        for future in as_completed(futures):
+            if err := future.exception():
+                logger.error(str(err))
+                raise WorkflowException(str(err)) from err
+            results.extend(future.result(timeout=1))
+        return results
 
-__all__ = (
-    "CronJob",
-    "CronJobYear",
-    "CronRunner",
-    "WEEKDAYS",
-)
+
+if __name__ == "__main__":
+    workflow_rs: list[str] = workflow()
+    logger.info(f"Application run success: {workflow_rs}")