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

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

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

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

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

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.62}/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.62}/src/ddeutil/workflow/event.py

@@ -316,6 +316,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.62}/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,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,12 +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: list(x.keys()),
-    "values": lambda x: list(x.values()),
+    "keys": lambda x: x.keys(),
+    "values": lambda x: x.values(),
 }
 
 
@@ -55,6 +57,7 @@ class FilterFunc(Protocol):
     """
 
     filter: str
+    mark: Literal["filter"] = "filter"
 
     def __call__(self, *args, **kwargs): ...  # pragma: no cov
 
@@ -73,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):
@@ -104,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
@@ -209,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__})."
@@ -303,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:
@@ -332,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.
 
@@ -342,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]] = (
@@ -369,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`
@@ -385,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
 
@@ -421,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:
@@ -468,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-0.0.61 → ddeutil_workflow-0.0.62}/src/ddeutil/workflow/workflow.py

@@ -774,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
@@ -805,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)
 
@@ -840,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
         )
 

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.62}/src/ddeutil_workflow.egg-info/PKG-INFO

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

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.62}/tests/test__cron.py

@@ -2,15 +2,23 @@ from datetime import datetime
 from functools import partial
 from zoneinfo import ZoneInfo
 
-import ddeutil.workflow.__cron as cron
 import pytest
+from ddeutil.workflow.__cron import (
+    CRON_UNITS,
+    CronJob,
+    CronJobYear,
+    CronPart,
+    Options,
+    Unit,
+    YearReachLimit,
+)
 
 from tests.utils import str2dt
 
 
 def test_cron_cron_part():
-    cron_part = cron.CronPart(
-        unit=cron.Unit(
+    cron_part = CronPart(
+        unit=Unit(
             name="month",
             range=partial(range, 1, 13),
             min=1,
@@ -31,7 +39,7 @@ def test_cron_cron_part():
             ],
         ),
         values="3,5-8",
-        options=cron.Options(),
+        options=Options(),
     )
     assert [3, 5, 6, 7, 8] == cron_part.values
     assert repr(cron_part) == (
@@ -41,45 +49,45 @@ def test_cron_cron_part():
         "'OCT', 'NOV', 'DEC']), values='3,5-8')"
     )
 
-    cron_part = cron.CronPart(cron.CRON_UNITS[1], [1, 12], cron.Options())
+    cron_part = CronPart(CRON_UNITS[1], [1, 12], Options())
     assert [1, 12] == cron_part.values
     assert cron_part > [1]
     assert cron_part == [1, 12]
 
     with pytest.raises(ValueError):
-        cron.CronPart(cron.CRON_UNITS[1], [45], cron.Options())
+        CronPart(CRON_UNITS[1], [45], Options())
 
     with pytest.raises(TypeError):
-        cron.CronPart(cron.CRON_UNITS[1], 45, cron.Options())
+        CronPart(CRON_UNITS[1], 45, Options())
 
 
 def test_cron_cronjob():
-    cr1 = cron.CronJob("*/5 * * * *")
-    cr2 = cron.CronJob("*/5,3,6 9-17/2 * 1-3 1-5")
+    cr1 = CronJob("*/5 * * * *")
+    cr2 = CronJob("*/5,3,6 9-17/2 * 1-3 1-5")
 
     assert str(cr1) == "*/5 * * * *"
     assert str(cr2) == "0,3,5-6,10,15,20,25,30,35,40,45,50,55 9-17/2 * 1-3 1-5"
     assert cr1 != cr2
     assert cr1 < cr2
 
-    cr = cron.CronJob("0 */12 1 ? 0")
+    cr = CronJob("0 */12 1 ? 0")
     assert str(cr) == "0 0,12 1 ? 0"
 
-    cr = cron.CronJob("*/4 0 1 * 1")
+    cr = CronJob("*/4 0 1 * 1")
     assert str(cr) == "*/4 0 1 * 1"
 
-    cr = cron.CronJob("*/4 */3 1 * 1")
+    cr = CronJob("*/4 */3 1 * 1")
     assert str(cr) == "*/4 */3 1 * 1"
 
     with pytest.raises(ValueError):
-        cron.CronJob("*/4 */3 1 *")
+        CronJob("*/4 */3 1 *")
 
 
 def test_cron_cronjob_to_list():
-    cr = cron.CronJob("0 */12 1 1 0")
+    cr = CronJob("0 */12 1 1 0")
     assert cr.to_list() == [[0], [0, 12], [1], [1], [0]]
 
-    cr = cron.CronJob("*/4 */3 1 * 1")
+    cr = CronJob("*/4 */3 1 * 1")
     assert cr.to_list() == [
         [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56],
         [0, 3, 6, 9, 12, 15, 18, 21],
@@ -88,7 +96,7 @@ def test_cron_cronjob_to_list():
         [1],
     ]
 
-    cr = cron.CronJob("*/30 */12 23 */3 *")
+    cr = CronJob("*/30 */12 23 */3 *")
     assert cr.to_list() == [
         [0, 30],
         [0, 12],
@@ -99,7 +107,7 @@ def test_cron_cronjob_to_list():
 
 
 def test_cron_option():
-    cr = cron.CronJob(
+    cr = CronJob(
         "*/5,3,6 9-17/2 * 1-3 1-5",
         option={
             "output_hashes": True,
@@ -108,7 +116,7 @@ def test_cron_option():
     assert (
         str(cr) == "0,3,5-6,10,15,20,25,30,35,40,45,50,55 H(9-17)/2 H 1-3 1-5"
     )
-    cr = cron.CronJob(
+    cr = CronJob(
         "*/5 9-17/2 * 1-3,5 1-5",
         option={
             "output_weekday_names": True,
@@ -119,7 +127,7 @@ def test_cron_option():
 
 
 def test_cron_runner_next_previous():
-    sch = cron.CronJob("*/30 */12 23 */3 *").schedule(
+    sch = CronJob("*/30 */12 23 */3 *").schedule(
         date=datetime(2024, 1, 1, 12, tzinfo=ZoneInfo("Asia/Bangkok")),
     )
     t = sch.next
@@ -149,12 +157,12 @@ def test_cron_runner_next_previous():
 
 def test_cron_runner_tz():
     with pytest.raises(TypeError):
-        cron.CronJob("*/5 * * * *").schedule(tz=1)
+        CronJob("*/5 * * * *").schedule(tz=1)
 
     with pytest.raises(ValueError):
-        cron.CronJob("*/5 * * * *").schedule(tz="UUID")
+        CronJob("*/5 * * * *").schedule(tz="UUID")
 
-    sch = cron.CronJob("*/5 * * * *").schedule(
+    sch = CronJob("*/5 * * * *").schedule(
         date=datetime(2024, 1, 1, 12, tzinfo=ZoneInfo("Asia/Bangkok")),
         tz="UTC",
     )
@@ -167,14 +175,14 @@ def test_cron_runner_tz():
     assert sch.prev == str2dt("2024-01-01 11:55:00", "UTC")
     assert sch.prev == str2dt("2024-01-01 11:50:00", "UTC")
 
-    sch = cron.CronJob("*/5 * * * *").schedule(date=datetime(2024, 1, 1, 12))
+    sch = CronJob("*/5 * * * *").schedule(date=datetime(2024, 1, 1, 12))
     assert sch.date == datetime(2024, 1, 1, 12)
     assert sch.next == datetime(2024, 1, 1, 12)
     assert sch.next == datetime(2024, 1, 1, 12, 5)
 
 
 def test_cron_cronjob_year():
-    cr = cron.CronJobYear("*/5 * * * * */8,1999")
+    cr = CronJobYear("*/5 * * * * */8,1999")
     assert str(cr) == (
         "*/5 * * * * 1990,1998-1999,2006,2014,2022,2030,2038,2046,2054,2062,"
         "2070,2078,2086,2094"
@@ -182,7 +190,7 @@ def test_cron_cronjob_year():
 
 
 def test_cron_next_year():
-    sch = cron.CronJob("0 0 1 * *").schedule(
+    sch = CronJob("0 0 1 * *").schedule(
         date=datetime(2024, 10, 1, 12, tzinfo=ZoneInfo("Asia/Bangkok")),
     )
     assert sch.next == str2dt("2024-11-01 00:00:00")
@@ -191,7 +199,7 @@ def test_cron_next_year():
 
 
 def test_cron_year_next_year():
-    sch = cron.CronJobYear("0 0 1 * * *").schedule(
+    sch = CronJobYear("0 0 1 * * *").schedule(
         date=datetime(2024, 10, 1, 12, tzinfo=ZoneInfo("Asia/Bangkok")),
     )
     assert sch.next == str2dt("2024-11-01 00:00:00")
@@ -200,8 +208,8 @@ def test_cron_year_next_year():
 
 
 def test_cron_year_next_year_raise():
-    sch = cron.CronJobYear("0 0 1 * * 2023").schedule(
+    sch = CronJobYear("0 0 1 * * 2023").schedule(
         date=datetime(2024, 10, 1, 12, tzinfo=ZoneInfo("Asia/Bangkok")),
     )
-    with pytest.raises(cron.CronYearLimit):
+    with pytest.raises(YearReachLimit):
         _ = sch.next

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.62}/tests/test_reusables_call_tag.py

@@ -121,8 +121,9 @@ def test_make_registry_raise(call_function_dup):
         make_registry("new_tasks_dup")
 
 
-def test_extract_call():
+def test_extract_caller():
     func = extract_call("tasks/el-csv-to-parquet@polars-dir")
     call_func = func()
     assert call_func.name == "el-csv-to-parquet"
     assert call_func.tag == "polars-dir"
+    assert call_func.mark == "tag"

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.62}/tests/test_reusables_template.py

@@ -76,6 +76,70 @@ def test_param2template_with_filter():
     )
     assert 5 == value
 
+    assert (
+        param2template(
+            value="${{ params.start-dt | fmt('%Y%m%d') }}",
+            params={"params": {"start-dt": datetime(2024, 6, 12)}},
+        )
+        == "20240612"
+    )
+
+    assert (
+        param2template(
+            value="${{ params.start-dt | fmt }}",
+            params={"params": {"start-dt": datetime(2024, 6, 12)}},
+        )
+        == "2024-06-12 00:00:00"
+    )
+
+    assert (
+        param2template(
+            value="${{ params.value | coalesce('foo') }}",
+            params={"params": {"value": None}},
+        )
+        == "foo"
+    )
+
+    assert (
+        param2template(
+            value="${{ params.value | coalesce('foo') }}",
+            params={"params": {"value": "bar"}},
+        )
+        == "bar"
+    )
+
+    assert (
+        param2template(
+            value="${{ params.data | getitem('key') }}",
+            params={"params": {"data": {"key": "value"}}},
+        )
+        == "value"
+    )
+
+    assert (
+        param2template(
+            value="${{ params.data | getitem('foo', 'bar') }}",
+            params={"params": {"data": {"key": "value"}}},
+        )
+        == "bar"
+    )
+
+    assert (
+        param2template(
+            value="${{ params.data | getitem(1, 'bar') }}",
+            params={"params": {"data": {1: "value"}}},
+        )
+        == "value"
+    )
+
+    assert (
+        param2template(
+            value="${{ params.range | getindex(0) }}",
+            params={"params": {"range": [1, 2, 3]}},
+        )
+        == 1
+    )
+
     with pytest.raises(UtilException):
         param2template(
             value="${{ params.value | abs12 }}",
@@ -96,6 +160,18 @@ def test_param2template_with_filter():
             },
         )
 
+    with pytest.raises(UtilException):
+        param2template(
+            value="${{ params.data | getitem(1, 'bar') }}",
+            params={"params": {"data": 1}},
+        )
+
+    with pytest.raises(UtilException):
+        param2template(
+            value="${{ params.range | getindex(4) }}",
+            params={"params": {"range": [1, 2, 3]}},
+        )
+
 
 def test_not_in_template():
     assert not not_in_template(

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.62}/tests/test_reusables_template_filter.py

@@ -40,6 +40,10 @@ def test_make_registry_raise():
     assert isfunction(make_filter_registry()["foo"])
     assert "bar" == make_filter_registry()["foo"]("")
 
+    filter_func = make_filter_registry()["foo"]
+    assert filter_func.filter == "foo"
+    assert filter_func.mark == "filter"
+
 
 def test_get_args_const():
     name, args, kwargs = get_args_const('fmt(fmt="str")')
@@ -80,9 +84,11 @@ def test_map_post_filter():
     assert "'bar'" == map_post_filter("bar", ["rstr"], registry)
     assert 1 == map_post_filter("1", ["int"], registry)
     assert ["foo", "bar"] == map_post_filter(
-        {"foo": 1, "bar": 2}, ["keys"], registry
+        {"foo": 1, "bar": 2}, ["keys", "list"], registry
+    )
+    assert [1, 2] == map_post_filter(
+        {"foo": 1, "bar": 2}, ["values", "list"], registry
     )
-    assert [1, 2] == map_post_filter({"foo": 1, "bar": 2}, ["values"], registry)
 
     with pytest.raises(UtilException):
         map_post_filter("demo", ['rstr(fmt="foo")'], registry)

{ddeutil_workflow-0.0.61 → ddeutil_workflow-0.0.62}/tests/test_workflow_exec.py

@@ -859,7 +859,8 @@ def test_workflow_exec_raise_param(test_path):
                             "errors": {
                                 "name": "UtilException",
                                 "message": (
-                                    "Params does not set caller: 'params.name'."
+                                    "Parameters does not get dot with caller: "
+                                    "'params.name'."
                                 ),
                             },
                         }
@@ -921,7 +922,8 @@ def test_workflow_exec_raise_job_trigger(test_path):
                             "errors": {
                                 "name": "UtilException",
                                 "message": (
-                                    "Params does not set caller: 'params.name'."
+                                    "Parameters does not get dot with caller: "
+                                    "'params.name'."
                                 ),
                             },
                         },

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

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