ddeutil-workflow 0.0.60__py3-none-any.whl → 0.0.62__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.60"
+__version__: str = "0.0.62"

ddeutil/workflow/__cron.py

@@ -18,7 +18,7 @@ from ddeutil.core import (
     isinstance_check,
     must_split,
 )
-from ddeutil.core.dtutils import next_date, replace_date
+from ddeutil.core.dtutils import DatetimeMode, next_date, replace_date
 
 WEEKDAYS: dict[str, int] = {
     "Sun": 0,
@@ -31,7 +31,8 @@ WEEKDAYS: dict[str, int] = {
 }
 
 
-class CronYearLimit(Exception): ...
+class YearReachLimit(Exception):
+    """"""
 
 
 def str2cron(value: str) -> str:  # pragma: no cov
@@ -178,7 +179,7 @@ class CronPart:
     def __init__(
         self,
         unit: Unit,
-        values: str | list[int],
+        values: Union[str, list[int]],
         options: Options,
     ) -> None:
         self.unit: Unit = unit
@@ -229,19 +230,21 @@ class CronPart:
             f"(unit={self.unit}, values={self.__str__()!r})"
         )
 
-    def __lt__(self, other) -> bool:
+    def __lt__(self, other: Union[CronPart, list]) -> bool:
         """Override __lt__ method."""
         if isinstance(other, CronPart):
             return self.values < other.values
         elif isinstance(other, list):
             return self.values < other
+        return NotImplemented
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: Union[CronPart, list]) -> bool:
         """Override __eq__ method."""
         if isinstance(other, CronPart):
             return self.values == other.values
         elif isinstance(other, list):
             return self.values == other
+        return NotImplemented
 
     @property
     def min(self) -> int:
@@ -271,6 +274,7 @@ class CronPart:
             and (step := self.values[1] - self.values[0]) > 1
         ):
             return step
+        return None
 
     @property
     def is_full(self) -> bool:
@@ -355,6 +359,8 @@ class CronPart:
                     f"Invalid interval step value {value_step!r} for "
                     f"{self.unit.name!r}"
                 )
+            elif value_step:
+                value_step: int = int(value_step)
 
             # NOTE: Generate interval that has step
             interval_list.append(self._interval(value_range_list, value_step))
@@ -375,7 +381,9 @@ class CronPart:
                 value: str = value.replace(alt, str(self.unit.min + i))
         return value
 
-    def replace_weekday(self, values: list[int] | Iterator[int]) -> list[int]:
+    def replace_weekday(
+        self, values: Union[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
@@ -433,12 +441,12 @@ class CronPart:
     def _interval(
         self,
         values: list[int],
-        step: int | None = None,
+        step: Optional[int] = None,
     ) -> list[int]:
         """Applies an interval step to a collection of values.
 
         :param values:
-        :param step:
+        :param step: (int) A step
 
         :rtype: list[int]
         """
@@ -515,7 +523,7 @@ class CronPart:
                 start_number: Optional[int] = value
         return multi_dim_values
 
-    def filler(self, value: int) -> int | str:
+    def filler(self, value: int) -> Union[int, str]:
         """Formats weekday and month names as string when the relevant options
         are set.
 
@@ -765,12 +773,12 @@ class CronRunner:
 
     def __init__(
         self,
-        cron: CronJob | CronJobYear,
+        cron: Union[CronJob, CronJobYear],
         date: Optional[datetime] = None,
         *,
-        tz: str | ZoneInfo | None = None,
+        tz: Optional[Union[str, ZoneInfo]] = None,
     ) -> None:
-        self.tz: ZoneInfo | None = None
+        self.tz: Optional[ZoneInfo] = None
         if tz:
             if isinstance(tz, ZoneInfo):
                 self.tz = tz
@@ -810,7 +818,7 @@ class CronRunner:
             )
 
         self.__start_date: datetime = self.date
-        self.cron: CronJob | CronJobYear = cron
+        self.cron: Union[CronJob, CronJobYear] = cron
         self.is_year: bool = isinstance(cron, CronJobYear)
         self.reset_flag: bool = True
 
@@ -863,7 +871,7 @@ class CronRunner:
 
         raise RecursionError("Unable to find execution time for schedule")
 
-    def __shift_date(self, mode: str, reverse: bool = False) -> bool:
+    def __shift_date(self, mode: DatetimeMode, reverse: bool = False) -> bool:
         """Increments the mode of date value ("month", "day", "hour", "minute")
         until matches with the schedule.
 
@@ -897,8 +905,8 @@ class CronRunner:
                 getattr(self.date, mode)
                 > (max_year := max(self.cron.year.values))
             ):
-                raise CronYearLimit(
-                    f"The year is out of limit with this crontab value: "
+                raise YearReachLimit(
+                    f"The year is reach the limit with this crontab setting: "
                     f"{max_year}."
                 )
 
@@ -917,12 +925,3 @@ class CronRunner:
 
         # NOTE: Return False if the date that match with condition.
         return False
-
-
-__all__ = (
-    "CronJob",
-    "CronJobYear",
-    "CronRunner",
-    "Options",
-    "WEEKDAYS",
-)

ddeutil/workflow/event.py

@@ -314,3 +314,26 @@ class CrontabYear(Crontab):
             if isinstance(value, str)
             else value
         )
+
+
+class ReleaseEvent(BaseModel):  # pragma: no cov
+    """Release trigger event."""
+
+    release: list[str] = Field(
+        description=(
+            "A list of workflow name that want to receive event from release"
+            "trigger."
+        )
+    )
+
+
+Event = Annotated[
+    Union[
+        CronJobYear,
+        CronJob,
+    ],
+    Field(
+        union_mode="smart",
+        description="An event models.",
+    ),
+]  # pragma: no cov

ddeutil/workflow/logs.py

@@ -23,7 +23,7 @@ from inspect import Traceback, currentframe, getframeinfo
 from pathlib import Path
 from threading import get_ident
 from types import FrameType
-from typing import ClassVar, Literal, Optional, TypeVar, Union
+from typing import ClassVar, Final, Literal, Optional, TypeVar, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 from pydantic.functional_validators import model_validator
@@ -74,7 +74,7 @@ def get_dt_tznow() -> datetime:  # pragma: no cov
     return get_dt_now(tz=config.tz)
 
 
-PREFIX_LOGS: dict[str, dict] = {
+PREFIX_LOGS: Final[dict[str, dict]] = {
     "CALLER": {
         "emoji": "📍",
         "desc": "logs from any usage from custom caller function.",
@@ -85,7 +85,7 @@ PREFIX_LOGS: dict[str, dict] = {
     "RELEASE": {"emoji": "📅", "desc": "logs from release workflow method."},
     "POKING": {"emoji": "⏰", "desc": "logs from poke workflow method."},
 }  # pragma: no cov
-PREFIX_DEFAULT: str = "CALLER"
+PREFIX_DEFAULT: Final[str] = "CALLER"
 PREFIX_LOGS_REGEX: re.Pattern[str] = re.compile(
     rf"(^\[(?P<name>{'|'.join(PREFIX_LOGS)})]:\s?)?(?P<message>.*)",
     re.MULTILINE | re.DOTALL | re.ASCII | re.VERBOSE,
@@ -103,6 +103,9 @@ class PrefixMsg(BaseModel):
     def prepare(self, extras: Optional[DictData] = None) -> str:
         """Prepare message with force add prefix before writing trace log.
 
+        :param extras: (DictData) An extra parameter that want to get the
+            `log_add_emoji` flag.
+
         :rtype: str
         """
         name: str = self.name or PREFIX_DEFAULT
@@ -332,9 +335,7 @@ class BaseTrace(BaseModel, ABC):  # pragma: no cov
 
         :param message: (str) A message that want to log.
         """
-        msg: str = prepare_newline(
-            self.make_message(extract_msg_prefix(message).prepare(self.extras))
-        )
+        msg: str = self.make_message(message)
 
         if mode != "debug" or (
             mode == "debug" and dynamic("debug", extras=self.extras)
@@ -391,9 +392,7 @@ class BaseTrace(BaseModel, ABC):  # pragma: no cov
 
         :param message: (str) A message that want to log.
         """
-        msg: str = prepare_newline(
-            self.make_message(extract_msg_prefix(message).prepare(self.extras))
-        )
+        msg: str = self.make_message(message)
 
         if mode != "debug" or (
             mode == "debug" and dynamic("debug", extras=self.extras)
@@ -514,13 +513,15 @@ class FileTrace(BaseTrace):  # pragma: no cov
         return f"{cut_parent_run_id} -> {cut_run_id}"
 
     def make_message(self, message: str) -> str:
-        """Prepare and Make a message before write and log processes.
+        """Prepare and Make a message before write and log steps.
 
         :param message: (str) A message that want to prepare and make before.
 
         :rtype: str
         """
-        return f"({self.cut_id}) {message}"
+        return prepare_newline(
+            f"({self.cut_id}) {extract_msg_prefix(message).prepare(self.extras)}"
+        )
 
     def writer(self, message: str, level: str, is_err: bool = False) -> None:
         """Write a trace message after making to target file and write metadata

ddeutil/workflow/params.py

@@ -20,6 +20,7 @@ from typing import Annotated, Any, Literal, Optional, TypeVar, Union
 from ddeutil.core import str2dict, str2list
 from pydantic import BaseModel, Field
 
+from .__types import StrOrInt
 from .exceptions import ParamValueException
 from .utils import get_d_now, get_dt_now
 
@@ -159,10 +160,11 @@ class StrParam(DefaultParam):
 
     type: Literal["str"] = "str"
 
-    def receive(self, value: Optional[str] = None) -> Optional[str]:
+    def receive(self, value: Optional[Any] = None) -> Optional[str]:
         """Receive value that match with str.
 
-        :param value: A value that want to validate with string parameter type.
+        :param value: (Any) A value that want to validate with string parameter
+            type.
         :rtype: Optional[str]
         """
         if value is None:
@@ -175,7 +177,7 @@ class IntParam(DefaultParam):
 
     type: Literal["int"] = "int"
 
-    def receive(self, value: Optional[int] = None) -> Optional[int]:
+    def receive(self, value: Optional[StrOrInt] = None) -> Optional[int]:
         """Receive value that match with int.
 
         :param value: A value that want to validate with integer parameter type.
@@ -200,13 +202,24 @@ class FloatParam(DefaultParam):  # pragma: no cov
     precision: int = 6
 
     def rounding(self, value: float) -> float:
-        """Rounding float value with the specific precision field."""
+        """Rounding float value with the specific precision field.
+
+        :param value: A float value that want to round with the precision value.
+
+        :rtype: float
+        """
         round_str: str = f"{{0:.{self.precision}f}}"
         return float(round_str.format(round(value, self.precision)))
 
-    def receive(self, value: Optional[Union[float, int, str]] = None) -> float:
+    def receive(
+        self, value: Optional[Union[float, int, str]] = None
+    ) -> Optional[float]:
+        """Receive value that match with float.
 
-        if value in None:
+        :param value: A value that want to validate with float parameter type.
+        :rtype: float | None
+        """
+        if value is None:
             return self.default
 
         if isinstance(value, float):
@@ -217,11 +230,7 @@ class FloatParam(DefaultParam):  # pragma: no cov
             raise TypeError(
                 "Received value type does not math with str, float, or int."
             )
-
-        try:
-            return self.rounding(float(value))
-        except Exception:
-            raise
+        return self.rounding(float(value))
 
 
 class DecimalParam(DefaultParam):  # pragma: no cov
@@ -231,12 +240,28 @@ class DecimalParam(DefaultParam):  # pragma: no cov
     precision: int = 6
 
     def rounding(self, value: Decimal) -> Decimal:
-        """Rounding float value with the specific precision field."""
+        """Rounding float value with the specific precision field.
+
+        :param value: (Decimal) A Decimal value that want to round with the
+            precision value.
+
+        :rtype: Decimal
+        """
         return value.quantize(Decimal(10) ** -self.precision)
 
-    def receive(self, value: float | Decimal | None = None) -> Decimal:
+    def receive(
+        self, value: Optional[Union[float, int, str, Decimal]] = None
+    ) -> Decimal:
+        """Receive value that match with decimal.
 
-        if isinstance(value, float):
+        :param value: (float | Decimal) A value that want to validate with
+            decimal parameter type.
+        :rtype: Decimal | None
+        """
+        if value is None:
+            return self.default
+
+        if isinstance(value, (float, int)):
             return self.rounding(Decimal(value))
         elif isinstance(value, Decimal):
             return self.rounding(value)
@@ -261,11 +286,12 @@ class ChoiceParam(BaseParam):
         description="A list of choice parameters that able be str or int.",
     )
 
-    def receive(self, value: Union[str, int] | None = None) -> Union[str, int]:
+    def receive(self, value: Optional[StrOrInt] = None) -> StrOrInt:
         """Receive value that match with options.
 
-        :param value: A value that want to select from the options field.
-        :rtype: str
+        :param value: (str | int) A value that want to select from the options
+            field.
+        :rtype: str | int
         """
         # NOTE:
         #   Return the first value in options if it does not pass any input
@@ -279,7 +305,7 @@ class ChoiceParam(BaseParam):
         return value
 
 
-class MapParam(DefaultParam):  # pragma: no cov
+class MapParam(DefaultParam):
     """Map parameter."""
 
     type: Literal["map"] = "map"
@@ -295,6 +321,7 @@ class MapParam(DefaultParam):  # pragma: no cov
         """Receive value that match with map type.
 
         :param value: A value that want to validate with map parameter type.
+
         :rtype: dict[Any, Any]
         """
         if value is None:
@@ -316,7 +343,7 @@ class MapParam(DefaultParam):  # pragma: no cov
         return value
 
 
-class ArrayParam(DefaultParam):  # pragma: no cov
+class ArrayParam(DefaultParam):
     """Array parameter."""
 
     type: Literal["array"] = "array"
@@ -326,7 +353,7 @@ class ArrayParam(DefaultParam):  # pragma: no cov
     )
 
     def receive(
-        self, value: Optional[Union[list[T], tuple[T, ...], str]] = None
+        self, value: Optional[Union[list[T], tuple[T, ...], set[T], str]] = None
     ) -> list[T]:
         """Receive value that match with array type.
 
@@ -365,5 +392,11 @@ Param = Annotated[
         IntParam,
         StrParam,
     ],
-    Field(discriminator="type"),
+    Field(
+        discriminator="type",
+        description=(
+            "A parameter models that use for validate and receive on the "
+            "workflow execution."
+        ),
+    ),
 ]

ddeutil/workflow/reusables.py

@@ -4,7 +4,7 @@
 # license information.
 # ------------------------------------------------------------------------------
 # [x] Use dynamic config
-"""Reusables module that keep any templating functions."""
+"""Reusables module that keep any template and template filter functions."""
 from __future__ import annotations
 
 import copy
@@ -14,7 +14,7 @@ from ast import Call, Constant, Expr, Module, Name, parse
 from datetime import datetime
 from functools import wraps
 from importlib import import_module
-from typing import Any, Callable, Optional, Protocol, TypeVar, Union
+from typing import Any, Callable, Literal, Optional, Protocol, TypeVar, Union
 
 try:
     from typing import ParamSpec
@@ -32,7 +32,7 @@ from .exceptions import UtilException
 T = TypeVar("T")
 P = ParamSpec("P")
 
-logger = logging.getLogger("ddeutil.workflow")
+# NOTE: Adjust logging level of the `asyncio` to INFO level.
 logging.getLogger("asyncio").setLevel(logging.INFO)
 
 
@@ -40,10 +40,14 @@ FILTERS: dict[str, Callable] = {  # pragma: no cov
     "abs": abs,
     "str": str,
     "int": int,
+    "list": list,
+    "dict": dict,
     "title": lambda x: x.title(),
     "upper": lambda x: x.upper(),
     "lower": lambda x: x.lower(),
     "rstr": [str, repr],
+    "keys": lambda x: x.keys(),
+    "values": lambda x: x.values(),
 }
 
 
@@ -53,6 +57,7 @@ class FilterFunc(Protocol):
     """
 
     filter: str
+    mark: Literal["filter"] = "filter"
 
     def __call__(self, *args, **kwargs): ...  # pragma: no cov
 
@@ -71,6 +76,7 @@ def custom_filter(name: str) -> Callable[P, FilterFunc]:
 
     def func_internal(func: Callable[[...], Any]) -> FilterFunc:
         func.filter = name
+        func.mark = "filter"
 
         @wraps(func)
         def wrapped(*args, **kwargs):
@@ -102,7 +108,10 @@ def make_filter_registry(
         for fstr, func in inspect.getmembers(importer, inspect.isfunction):
             # NOTE: check function attribute that already set tag by
             #   ``utils.tag`` decorator.
-            if not hasattr(func, "filter"):
+            if not (
+                hasattr(func, "filter")
+                and str(getattr(func, "mark", "NOT SET")) == "filter"
+            ):
                 continue
 
             func: FilterFunc
@@ -207,11 +216,9 @@ def map_post_filter(
                     value: T = func(value)
             else:
                 value: T = f_func(value, *args, **kwargs)
-        except UtilException as err:
-            logger.warning(str(err))
+        except UtilException:
             raise
-        except Exception as err:
-            logger.warning(str(err))
+        except Exception:
             raise UtilException(
                 f"The post-filter: {func_name!r} does not fit with {value!r} "
                 f"(type: {type(value).__name__})."
@@ -301,7 +308,7 @@ def str2template(
             getter: Any = getdot(caller, params)
         except ValueError as err:
             raise UtilException(
-                f"Params does not set caller: {caller!r}."
+                f"Parameters does not get dot with caller: {caller!r}."
             ) from err
 
         # NOTE:
@@ -330,7 +337,7 @@ def param2template(
     filters: Optional[dict[str, FilterRegistry]] = None,
     *,
     extras: Optional[DictData] = None,
-) -> T:
+) -> Any:
     """Pass param to template string that can search by ``RE_CALLER`` regular
     expression.
 
@@ -340,7 +347,7 @@ def param2template(
     :param filters: A filter mapping for mapping with `map_post_filter` func.
     :param extras: (Optional[list[str]]) An Override extras.
 
-    :rtype: T
+    :rtype: Any
     :returns: An any getter value from the params input.
     """
     registers: Optional[list[str]] = (
@@ -367,6 +374,11 @@ def param2template(
 def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
     """Format datetime object to string with the format.
 
+    Examples:
+
+        > ${{ start-date | fmt('%Y%m%d') }}
+        > ${{ start-date | fmt }}
+
     :param value: (datetime) A datetime value that want to format to string
         value.
     :param fmt: (str) A format string pattern that passing to the `dt.strftime`
@@ -383,15 +395,54 @@ def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
 
 @custom_filter("coalesce")  # pragma: no cov
 def coalesce(value: Optional[T], default: Any) -> T:
-    """Coalesce with default value if the main value is None."""
+    """Coalesce with default value if the main value is None.
+
+    Examples:
+
+        > ${{ value | coalesce("foo") }}
+
+    :param value: A value that want to check nullable.
+    :param default: A default value that use to returned value if an input
+        value was null.
+    """
     return default if value is None else value
 
 
+@custom_filter("getitem")  # pragma: no cov
+def get_item(
+    value: DictData, key: Union[str, int], default: Optional[Any] = None
+) -> Any:
+    """Get a value with an input specific key."""
+    if not isinstance(value, dict):
+        raise UtilException(
+            f"The value that pass to `getitem` filter should be `dict` not "
+            f"`{type(value)}`."
+        )
+    return value.get(key, default)
+
+
+@custom_filter("getindex")  # pragma: no cov
+def get_index(value: list[Any], index: int):
+    if not isinstance(value, list):
+        raise UtilException(
+            f"The value that pass to `getindex` filter should be `list` not "
+            f"`{type(value)}`."
+        )
+    try:
+        return value[index]
+    except IndexError as e:
+        raise UtilException(
+            f"Index: {index} is out of range of value (The maximum range is "
+            f"{len(value)})."
+        ) from e
+
+
 class TagFunc(Protocol):
     """Tag Function Protocol"""
 
     name: str
     tag: str
+    mark: Literal["tag"] = "tag"
 
     def __call__(self, *args, **kwargs): ...  # pragma: no cov
 
@@ -419,6 +470,7 @@ def tag(
     def func_internal(func: Callable[[...], Any]) -> ReturnTagFunc:
         func.tag = name or "latest"
         func.name = alias or func.__name__.replace("_", "-")
+        func.mark = "tag"
 
         @wraps(func)
         def wrapped(*args: P.args, **kwargs: P.kwargs) -> TagFunc:
@@ -466,7 +518,9 @@ def make_registry(
             # NOTE: check function attribute that already set tag by
             #   ``utils.tag`` decorator.
             if not (
-                hasattr(func, "tag") and hasattr(func, "name")
+                hasattr(func, "tag")
+                and hasattr(func, "name")
+                and str(getattr(func, "mark", "NOT SET")) == "tag"
             ):  # pragma: no cov
                 continue
 

ddeutil/workflow/stages.py

@@ -35,6 +35,7 @@ import json
 import subprocess
 import sys
 import time
+import traceback
 import uuid
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Iterator
@@ -65,12 +66,14 @@ from .result import CANCEL, FAILED, SUCCESS, WAIT, Result, Status
 from .reusables import TagFunc, extract_call, not_in_template, param2template
 from .utils import (
     delay,
+    dump_all,
     filter_func,
     gen_id,
     make_exec,
 )
 
 T = TypeVar("T")
+DictOrModel = Union[DictData, BaseModel]
 
 
 class BaseStage(BaseModel, ABC):
@@ -221,7 +224,10 @@ class BaseStage(BaseModel, ABC):
             return self.execute(params, result=result, event=event)
         except Exception as e:
             e_name: str = e.__class__.__name__
-            result.trace.error(f"[STAGE]: Error Handler:||{e_name}:||{e}")
+            result.trace.error(
+                f"[STAGE]: Error Handler:||{e_name}:||{e}||"
+                f"{traceback.format_exc()}"
+            )
             if dynamic("stage_raise_error", f=raise_error, extras=self.extras):
                 if isinstance(e, StageException):
                     raise
@@ -1170,13 +1176,12 @@ class CallStage(BaseAsyncStage):
             args.pop("result")
 
         args = self.parse_model_args(call_func, args, result)
-
         if inspect.iscoroutinefunction(call_func):
-            rs: DictData = await call_func(
+            rs: DictOrModel = await call_func(
                 **param2template(args, params, extras=self.extras)
             )
         else:
-            rs: DictData = call_func(
+            rs: DictOrModel = call_func(
                 **param2template(args, params, extras=self.extras)
             )
 
@@ -1190,7 +1195,7 @@ class CallStage(BaseAsyncStage):
                 f"serialize, you must set return be `dict` or Pydantic "
                 f"model."
             )
-        return result.catch(status=SUCCESS, context=rs)
+        return result.catch(status=SUCCESS, context=dump_all(rs, by_alias=True))
 
     @staticmethod
     def parse_model_args(
@@ -2528,7 +2533,11 @@ class VirtualPyStage(PyStage):  # pragma: no cov
         deps: list[str],
         run_id: StrOrNone = None,
     ) -> Iterator[str]:
-        """Create the .py file with an input Python string statement.
+        """Create the `.py` file and write an input Python statement and its
+        Python dependency on the header of this file.
+
+            The format of Python dependency was followed by the `uv`
+        recommended.
 
         :param py: A Python string statement.
         :param values: A variable that want to set before running this
@@ -2544,7 +2553,7 @@ class VirtualPyStage(PyStage):  # pragma: no cov
                 f"{var} = {value!r}" for var, value in values.items()
             )
 
-            # NOTE: uv supports PEP 723 — inline TOML metadata.
+            # NOTE: `uv` supports PEP 723 — inline TOML metadata.
             f.write(
                 dedent(
                     f"""
@@ -2603,6 +2612,16 @@ class VirtualPyStage(PyStage):  # pragma: no cov
             run_id=result.run_id,
         ) as py:
             result.trace.debug(f"[STAGE]: ... Create `{py}` file.")
+            try:
+                import uv
+
+                _ = uv
+            except ImportError:
+                raise ImportError(
+                    "The VirtualPyStage need you to install `uv` before"
+                    "execution."
+                ) from None
+
             rs: CompletedProcess = subprocess.run(
                 ["uv", "run", py, "--no-cache"],
                 # ["uv", "run", "--python", "3.9", py],

ddeutil/workflow/utils.py

@@ -15,10 +15,11 @@ from inspect import isfunction
 from itertools import chain, islice, product
 from pathlib import Path
 from random import randrange
-from typing import Any, Final, Optional, TypeVar, Union
+from typing import Any, Final, Optional, TypeVar, Union, overload
 from zoneinfo import ZoneInfo
 
 from ddeutil.core import hash_str
+from pydantic import BaseModel
 
 from .__types import DictData, Matrix
 
@@ -289,3 +290,24 @@ def cut_id(run_id: str, *, num: int = 6) -> str:
         dt, simple = run_id.split("T", maxsplit=1)
         return dt[:12] + simple[-num:]
     return run_id[:12] + run_id[-num:]
+
+
+@overload
+def dump_all(value: BaseModel, by_alias: bool = False) -> DictData: ...
+
+
+@overload
+def dump_all(value: T, by_alias: bool = False) -> T: ...
+
+
+def dump_all(
+    value: Union[T, BaseModel], by_alias: bool = False
+) -> Union[T, DictData]:
+    """Dump all BaseModel object to dict."""
+    if isinstance(value, dict):
+        return {k: dump_all(value[k], by_alias=by_alias) for k in value}
+    elif isinstance(value, (list, tuple, set)):
+        return type(value)([dump_all(i, by_alias=by_alias) for i in value])
+    elif isinstance(value, BaseModel):
+        return value.model_dump(by_alias=by_alias)
+    return value

ddeutil/workflow/workflow.py

@@ -39,7 +39,7 @@ from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
 from .__cron import CronRunner
-from .__types import DictData, TupleStr
+from .__types import DictData
 from .conf import FileLoad, Loader, dynamic
 from .event import Crontab
 from .exceptions import WorkflowException
@@ -57,14 +57,6 @@ from .utils import (
     wait_until_next_minute,
 )
 
-__all__: TupleStr = (
-    "Release",
-    "ReleaseQueue",
-    "ReleaseType",
-    "Workflow",
-    "WorkflowTask",
-)
-
 
 class ReleaseType(str, Enum):
     """Release Type Enum support the type field on the Release dataclass."""
@@ -711,198 +703,6 @@ class Workflow(BaseModel):
             },
         )
 
-    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
-
-    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()
-
-        # 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!!!"
-            )
-            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())
-
-        return result.catch(
-            status=SUCCESS,
-            context={"outputs": context},
-        )
-
     def execute_job(
         self,
         job: Job,
@@ -974,7 +774,7 @@ class Workflow(BaseModel):
         parent_run_id: Optional[str] = None,
         result: Optional[Result] = None,
         event: Optional[Event] = None,
-        timeout: int = 3600,
+        timeout: float = 3600,
         max_job_parallel: int = 2,
     ) -> Result:
         """Execute workflow with passing a dynamic parameters to all jobs that
@@ -1005,10 +805,10 @@ class Workflow(BaseModel):
         :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: (int) A workflow execution time out in second unit that
-            use for limit time of execution and waiting job dependency. This
-            value does not force stop the task that still running more than this
-            limit time. (Default: 60 * 60 seconds)
+        :param timeout: (float) A workflow execution time out in second unit
+            that use for limit time of execution and waiting job dependency.
+            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)
 
@@ -1040,7 +840,7 @@ class Workflow(BaseModel):
             job_queue.put(job_id)
 
         not_timeout_flag: bool = True
-        timeout: int = dynamic(
+        timeout: float = dynamic(
             "max_job_exec_timeout", f=timeout, extras=self.extras
         )
 
@@ -1140,6 +940,202 @@ class Workflow(BaseModel):
         )
 
 
+class WorkflowPoke(Workflow):
+    """Workflow Poke model that was implemented the poke method."""
+
+    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
+
+    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()
+
+        # 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!!!"
+            )
+            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())
+
+        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

{ddeutil_workflow-0.0.60.dist-info → ddeutil_workflow-0.0.62.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.60
+Version: 0.0.62
 Summary: Lightweight workflow orchestration
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT

{ddeutil_workflow-0.0.60.dist-info → ddeutil_workflow-0.0.62.dist-info}/RECORD

@@ -1,20 +1,20 @@
-ddeutil/workflow/__about__.py,sha256=sQSmxiDbXlnTI1qDQGcyxr1EGvwITzIX0PKi2dOg4LU,28
-ddeutil/workflow/__cron.py,sha256=5DHQKejG-76L_oREW78RcwMzeyKddJxSMmBzYyMAeeY,28536
+ddeutil/workflow/__about__.py,sha256=yjnDqQt_XdXe6-ocPUq4R7qNZAPra-nc1AMmD7lPaN4,28
+ddeutil/workflow/__cron.py,sha256=BOKQcreiex0SAigrK1gnLxpvOeF3aca_rQwyz9Kfve4,28751
 ddeutil/workflow/__init__.py,sha256=NXEhjzKFdIGa-jtIq9HXChLCjSXNPd8VJ8ltggxbBO8,1371
 ddeutil/workflow/__main__.py,sha256=x-sYedl4T8p6054aySk-EQX6vhytvPR0HvaBNYxMzp0,364
 ddeutil/workflow/__types.py,sha256=uNfoRbVmNK5O37UUMVnqcmoghD9oMS1q9fXC0APnjSI,4584
 ddeutil/workflow/conf.py,sha256=NLvjZ8bpDsn4e0MG3m1vgMdAwtmii5hP1D0STKQyZeo,14907
-ddeutil/workflow/event.py,sha256=iAvd7TfAJaMndDhxbi1xNLzl4wNlgLqe1nIseaIm5-Y,10533
+ddeutil/workflow/event.py,sha256=oY5C9E5CM5wRPs0Fb1OhduvNPMT-hY6p4iO8tICpWAc,10972
 ddeutil/workflow/exceptions.py,sha256=TKHBIlfquz3yEb8_kg6UXpxVLKxstt3QA9a1XYsLPJk,2455
 ddeutil/workflow/job.py,sha256=Php1b3n6c-jddel8PTSa61kAW22QBTetzoLVR4XXM4E,35240
-ddeutil/workflow/logs.py,sha256=81wl83dbYDcMctGmWiptmFaoZoXFO2TS0E4sxOILOQk,31321
-ddeutil/workflow/params.py,sha256=tBjKe1_e0TlUrSrlMahDuAdNNBlGBAKMmMMQ9eV-YSs,11616
+ddeutil/workflow/logs.py,sha256=iVtyl8i69y7t07tAuWkihc54WlkHCcBy_Ur0WtzJ_lM,31367
+ddeutil/workflow/params.py,sha256=1u8gXs1ZyMq-2eD9H8L7Yjfu5t7b_OzjA0fJvhxdYWY,12505
 ddeutil/workflow/result.py,sha256=4M9VCcveI8Yz6ZrnI-67SZlry-Z8G7e0hziy1k-pklk,5906
-ddeutil/workflow/reusables.py,sha256=mw_Fi763B5am0EmntcjLBF7MDEhKqud2BYHcYyno5Ec,17663
+ddeutil/workflow/reusables.py,sha256=ogE7SwcVacSH_J6vK25fRxvmT4g0GE-jjcteis23Tss,19268
 ddeutil/workflow/scheduler.py,sha256=OsEyj2zscQ-3bDMk2z7UtKlCWLlgoGjaRFt17o1B1ew,27263
-ddeutil/workflow/stages.py,sha256=N_DkEUGiwpglovtXx-Wg3zX_03eGBT650zRsZV7knKk,92640
-ddeutil/workflow/utils.py,sha256=ADJTt3kiF44qntsRnOUdCFihlB2WWbRE-Tojp5EOYbk,8898
-ddeutil/workflow/workflow.py,sha256=BFnaB_7mrYZ3KV07AV16xR9khsoSt9i3QLyEtrLNAqs,44877
+ddeutil/workflow/stages.py,sha256=xH_f7IRohFCnUrtyD-QW86BlJ72p64JmpRTRrLPoF6A,93241
+ddeutil/workflow/utils.py,sha256=rcaDwXaEs4SCdcBKWx4ZCEtpnNfPI8du7Er6b_rg8t4,9569
+ddeutil/workflow/workflow.py,sha256=8Z_h8OtNHkaGf8MJixTHNeXsyA4mBlYtHDqj0oEVFBs,44858
 ddeutil/workflow/api/__init__.py,sha256=kY30dL8HPY8tY_GBmm7y_3OdoXzB1-EA2a96PLU0AQw,5278
 ddeutil/workflow/api/logs.py,sha256=NMTnOnsBrDB5129329xF2myLdrb-z9k1MQrmrP7qXJw,1818
 ddeutil/workflow/api/utils.py,sha256=uTtUFVLpiYYahXvCVx8sueRQ03K2Xw1id_gW3IMmX1U,5295
@@ -23,9 +23,9 @@ ddeutil/workflow/api/routes/job.py,sha256=8X5VLDJH6PumyNIY6JGRNBsf2gWN0eG9DzxRPS
 ddeutil/workflow/api/routes/logs.py,sha256=U6vOni3wd-ZTOwd3yVdSOpgyRmNdcgfngU5KlLM3Cww,5383
 ddeutil/workflow/api/routes/schedules.py,sha256=14RnaJKEGMSJtncI1H_QQVZNBe_jDS40PPRO6qFc3i0,4805
 ddeutil/workflow/api/routes/workflows.py,sha256=GJu5PiXEylswrXylEImpncySjeU9chrvrtjhiMCw2RQ,4529
-ddeutil_workflow-0.0.60.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.60.dist-info/METADATA,sha256=VixljHKK-7rmiv5UC_65sp2DAgb3kHjms1H7vvF0DyY,19427
-ddeutil_workflow-0.0.60.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-ddeutil_workflow-0.0.60.dist-info/entry_points.txt,sha256=qDTpPSauL0ciO6T4iSVt8bJeYrVEkkoEEw_RlGx6Kgk,63
-ddeutil_workflow-0.0.60.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.60.dist-info/RECORD,,
+ddeutil_workflow-0.0.62.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.62.dist-info/METADATA,sha256=wo8CyK5cEyeEYiQkcaDtWwxd8b6BWMv_GKXhGCRWi6k,19427
+ddeutil_workflow-0.0.62.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+ddeutil_workflow-0.0.62.dist-info/entry_points.txt,sha256=qDTpPSauL0ciO6T4iSVt8bJeYrVEkkoEEw_RlGx6Kgk,63
+ddeutil_workflow-0.0.62.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.62.dist-info/RECORD,,

{ddeutil_workflow-0.0.60.dist-info → ddeutil_workflow-0.0.62.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any