ddeutil-workflow 0.0.61__tar.gz → 0.0.63__tar.gz

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.61
+Version: 0.0.63
 Summary: Lightweight workflow orchestration
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -25,6 +25,7 @@ License-File: LICENSE
 Requires-Dist: ddeutil[checksum]>=0.4.8
 Requires-Dist: ddeutil-io[toml,yaml]>=0.2.13
 Requires-Dist: pydantic==2.11.4
+Requires-Dist: pydantic-extra-types==2.10.4
 Requires-Dist: python-dotenv==1.1.0
 Requires-Dist: schedule<2.0.0,==1.2.2
 Provides-Extra: all
@@ -215,19 +216,23 @@ registry-caller/
 This function will store as module that will import from `WORKFLOW_CORE_REGISTRY_CALLER`
 value (This config can override by extra parameters with `registry_caller` key).
 
+> [!NOTE]
+> You can use Pydantic Model as argument of your caller function. The core workflow
+> engine will auto use the `model_validate` method before run your caller function.
+
 ```python
-from ddeutil.workflow import Result, tag
+from ddeutil.workflow import Result, WorkflowSecret, tag
 from ddeutil.workflow.exceptions import StageException
-from pydantic import BaseModel, SecretStr
+from pydantic import BaseModel
 
 class AwsCredential(BaseModel):
     path: str
     access_client_id: str
-    access_client_secret: SecretStr
+    access_client_secret: WorkflowSecret
 
 class RestAuth(BaseModel):
     type: str
-    keys: SecretStr
+    keys: WorkflowSecret
 
 @tag("requests", alias="get-api-with-oauth-to-s3")
 def get_api_with_oauth_to_s3(
@@ -243,6 +248,7 @@ def get_api_with_oauth_to_s3(
     result.trace.info(f"... {method}: {url}")
     if method != "post":
        raise StageException(f"RestAPI does not support for {method} action.")
+    # NOTE: If you want to use secret, you can use `auth.keys.get_secret_value()`.
     return {"records": 1000}
 ```
 

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.63}/README.md

@@ -165,19 +165,23 @@ registry-caller/
 This function will store as module that will import from `WORKFLOW_CORE_REGISTRY_CALLER`
 value (This config can override by extra parameters with `registry_caller` key).
 
+> [!NOTE]
+> You can use Pydantic Model as argument of your caller function. The core workflow
+> engine will auto use the `model_validate` method before run your caller function.
+
 ```python
-from ddeutil.workflow import Result, tag
+from ddeutil.workflow import Result, WorkflowSecret, tag
 from ddeutil.workflow.exceptions import StageException
-from pydantic import BaseModel, SecretStr
+from pydantic import BaseModel
 
 class AwsCredential(BaseModel):
     path: str
     access_client_id: str
-    access_client_secret: SecretStr
+    access_client_secret: WorkflowSecret
 
 class RestAuth(BaseModel):
     type: str
-    keys: SecretStr
+    keys: WorkflowSecret
 
 @tag("requests", alias="get-api-with-oauth-to-s3")
 def get_api_with_oauth_to_s3(
@@ -193,6 +197,7 @@ def get_api_with_oauth_to_s3(
     result.trace.info(f"... {method}: {url}")
     if method != "post":
        raise StageException(f"RestAPI does not support for {method} action.")
+    # NOTE: If you want to use secret, you can use `auth.keys.get_secret_value()`.
     return {"records": 1000}
 ```
 

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.63}/pyproject.toml

@@ -28,6 +28,7 @@ dependencies = [
     "ddeutil[checksum]>=0.4.8",
     "ddeutil-io[yaml,toml]>=0.2.13",
     "pydantic==2.11.4",
+    "pydantic-extra-types==2.10.4",
     "python-dotenv==1.1.0",
     "schedule==1.2.2,<2.0.0",
 ]

ddeutil_workflow-0.0.63/src/ddeutil/workflow/__about__.py

@@ -0,0 +1 @@
+__version__: str = "0.0.63"

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.63}/src/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-0.0.61 → ddeutil_workflow-0.0.63}/src/ddeutil/workflow/__init__.py

@@ -5,12 +5,7 @@
 # ------------------------------------------------------------------------------
 from .__cron import CronJob, CronRunner
 from .__types import DictData, DictStr, Matrix, Re, TupleStr
-from .conf import (
-    Config,
-    FileLoad,
-    config,
-    env,
-)
+from .conf import *
 from .event import *
 from .exceptions import *
 from .job import *
@@ -37,24 +32,7 @@ from .result import (
     Result,
     Status,
 )
-from .reusables import (
-    FILTERS,
-    FilterFunc,
-    FilterRegistry,
-    ReturnTagFunc,
-    TagFunc,
-    custom_filter,
-    extract_call,
-    get_args_const,
-    has_template,
-    make_filter_registry,
-    make_registry,
-    map_post_filter,
-    not_in_template,
-    param2template,
-    str2template,
-    tag,
-)
+from .reusables import *
 from .scheduler import (
     Schedule,
     ScheduleWorkflow,

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.63}/src/ddeutil/workflow/conf.py

@@ -18,8 +18,9 @@ from typing import Final, Optional, Protocol, TypeVar, Union
 from zoneinfo import ZoneInfo
 
 from ddeutil.core import str2bool
-from ddeutil.io import YamlFlResolve
+from ddeutil.io import YamlFlResolve, search_env_replace
 from ddeutil.io.paths import glob_files, is_ignored, read_ignore
+from pydantic import SecretStr
 
 from .__types import DictData
 
@@ -321,15 +322,16 @@ class FileLoad(BaseLoad):
         *,
         path: Optional[Path] = None,
         paths: Optional[list[Path]] = None,
-        excluded: list[str] | None = None,
+        excluded: Optional[list[str]] = None,
         extras: Optional[DictData] = None,
     ) -> Iterator[tuple[str, DictData]]:
         """Find all data that match with object type in config path. This class
         method can use include and exclude list of identity name for filter and
         adds-on.
 
-        :param obj: An object that want to validate matching before return.
-        :param path: A config path object.
+        :param obj: (object) An object that want to validate matching before
+            return.
+        :param path: (Path) A config path object.
         :param paths: (list[Path]) A list of config path object.
         :param excluded: An included list of data key that want to filter from
             data.
@@ -474,3 +476,33 @@ class Loader(Protocol):  # pragma: no cov
     def finds(
         cls, obj: object, *args, **kwargs
     ) -> Iterator[tuple[str, DictData]]: ...
+
+
+def pass_env(value: T) -> T:  # pragma: no cov
+    """Passing environment variable to an input value.
+
+    :param value: (Any) A value that want to pass env var searching.
+
+    :rtype: Any
+    """
+    if isinstance(value, dict):
+        return {k: pass_env(value[k]) for k in value}
+    elif isinstance(value, (list, tuple, set)):
+        return type(value)([pass_env(i) for i in value])
+    if not isinstance(value, str):
+        return value
+
+    rs: str = search_env_replace(value)
+    return None if rs == "null" else rs
+
+
+class WorkflowSecret(SecretStr):  # pragma: no cov
+    """Workflow Secret String model."""
+
+    def get_secret_value(self) -> str:
+        """Override get_secret_value by adding pass_env before return the
+        real-value.
+
+        :rtype: str
+        """
+        return pass_env(super().get_secret_value())

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.63}/src/ddeutil/workflow/event.py

@@ -17,6 +17,7 @@ from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 from pydantic import BaseModel, ConfigDict, Field, ValidationInfo
 from pydantic.functional_serializers import field_serializer
 from pydantic.functional_validators import field_validator, model_validator
+from pydantic_extra_types.timezone_name import TimeZoneName
 from typing_extensions import Self
 
 from .__cron import WEEKDAYS, CronJob, CronJobYear, CronRunner, Options
@@ -92,7 +93,7 @@ class Crontab(BaseModel):
         ),
     ]
     tz: Annotated[
-        str,
+        TimeZoneName,
         Field(
             description="A timezone string value",
             alias="timezone",
@@ -316,6 +317,17 @@ class CrontabYear(Crontab):
         )
 
 
+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,

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.63}/src/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,16 @@ 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,
+    get_type_hints,
+)
 
 try:
     from typing import ParamSpec
@@ -23,6 +32,7 @@ except ImportError:
 
 from ddeutil.core import getdot, import_string, lazy
 from ddeutil.io import search_env_replace
+from pydantic import BaseModel, create_model
 from pydantic.dataclasses import dataclass
 
 from .__types import DictData, Re
@@ -32,7 +42,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,12 +50,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: list(x.keys()),
-    "values": lambda x: list(x.values()),
+    "keys": lambda x: x.keys(),
+    "values": lambda x: x.values(),
 }
 
 
@@ -55,6 +67,7 @@ class FilterFunc(Protocol):
     """
 
     filter: str
+    mark: Literal["filter"] = "filter"
 
     def __call__(self, *args, **kwargs): ...  # pragma: no cov
 
@@ -73,6 +86,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):
@@ -104,7 +118,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
@@ -209,11 +226,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__})."
@@ -226,6 +241,7 @@ def not_in_template(value: Any, *, not_in: str = "matrix.") -> bool:
 
     :param value: A value that want to find parameter template prefix.
     :param not_in: The not-in string that use in the `.startswith` function.
+        (Default is `matrix.`)
 
     :rtype: bool
     """
@@ -274,7 +290,7 @@ def str2template(
     :param value: (str) A string value that want to map with params.
     :param params: (DictData) A parameter value that getting with matched
         regular expression.
-    :param filters: A mapping of filter registry.
+    :param filters: (dict[str, FilterRegistry]) A mapping of filter registry.
     :param registers: (Optional[list[str]]) Override list of register.
 
     :rtype: str
@@ -299,12 +315,14 @@ def str2template(
         ]
 
         # NOTE: from validate step, it guarantees that caller exists in params.
+        #   I recommend to avoid logging params context on this case because it
+        #   can include secret value.
         try:
             getter: Any = getdot(caller, params)
-        except ValueError as err:
+        except ValueError:
             raise UtilException(
-                f"Params does not set caller: {caller!r}."
-            ) from err
+                f"Parameters does not get dot with caller: {caller!r}."
+            ) from None
 
         # NOTE:
         #   If type of getter caller is not string type, and it does not use to
@@ -332,17 +350,18 @@ 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.
 
-    :param value: A value that want to map with params
-    :param params: A parameter value that getting with matched regular
-        expression.
-    :param filters: A filter mapping for mapping with `map_post_filter` func.
+    :param value: (Any) A value that want to map with params.
+    :param params: (DictData) A parameter value that getting with matched
+        regular expression.
+    :param filters: (dict[str, FilterRegistry]) 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]] = (
@@ -369,6 +388,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`
@@ -385,15 +409,68 @@ 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.
+
+    Examples:
+
+        >>> "${{ value | getitem('key') }}"
+        >>> "${{ value | getitem('key', 'default') }}"
+
+    """
+    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) -> Any:
+    """Get a value with an input specific index.
+
+    Examples:
+
+        >>> "${{ value | getindex(1) }}"
+
+    """
+    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
 
@@ -421,6 +498,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:
@@ -468,7 +546,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
 
@@ -553,3 +633,32 @@ def extract_call(
             f"`REGISTER.{call.path}.registries.{call.func}`"
         )
     return rgt[call.func][call.tag]
+
+
+def create_model_from_caller(func: Callable) -> BaseModel:  # pragma: no cov
+    """Create model from the caller function. This function will use for
+    validate the caller function argument typed-hint that valid with the args
+    field.
+
+    :param func: A caller function.
+
+    :rtype: BaseModel
+    """
+    sig: inspect.Signature = inspect.signature(func)
+    type_hints: dict[str, Any] = get_type_hints(func)
+    fields: dict[str, Any] = {}
+    for name in sig.parameters:
+        param: inspect.Parameter = sig.parameters[name]
+        if param.kind in (
+            inspect.Parameter.VAR_KEYWORD,
+            inspect.Parameter.VAR_POSITIONAL,
+        ):
+            continue
+        if param.default != inspect.Parameter.empty:
+            fields[name] = (type_hints[name], param.default)
+        else:
+            fields[name] = (type_hints[name], ...)
+
+    return create_model(
+        "".join(i.title() for i in func.__name__.split("_")), **fields
+    )