ddeutil-workflow 0.0.26.post1__py3-none-any.whl → 0.0.27__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.26.post1"
+__version__: str = "0.0.27"

ddeutil/workflow/__init__.py

@@ -8,6 +8,7 @@ from .conf import (
     Config,
     Loader,
     Log,
+    config,
     env,
     get_log,
     get_logger,
@@ -24,6 +25,13 @@ from .exceptions import (
     UtilException,
     WorkflowException,
 )
+from .hook import (
+    ReturnTagFunc,
+    TagFunc,
+    extract_hook,
+    make_registry,
+    tag,
+)
 from .job import (
     Job,
     Strategy,
@@ -48,33 +56,30 @@ from .stage import (
     PyStage,
     Stage,
     TriggerStage,
-    extract_hook,
 )
-from .utils import (
+from .templates import (
     FILTERS,
     FilterFunc,
     FilterRegistry,
-    ReturnTagFunc,
-    TagFunc,
+    custom_filter,
+    get_args_const,
+    has_template,
+    make_filter_registry,
+    map_post_filter,
+    not_in_template,
+    param2template,
+    str2template,
+)
+from .utils import (
     batch,
     cross_product,
-    custom_filter,
     dash2underscore,
     delay,
     filter_func,
     gen_id,
-    get_args_const,
     get_diff_sec,
     get_dt_now,
-    has_template,
     make_exec,
-    make_filter_registry,
-    make_registry,
-    map_post_filter,
-    not_in_template,
-    param2template,
-    str2template,
-    tag,
 )
 from .workflow import (
     Workflow,

ddeutil/workflow/conf.py

@@ -108,15 +108,13 @@ class Config:  # pragma: no cov
     # NOTE: Register
     @property
     def regis_hook(self) -> list[str]:
-        regis_hook_str: str = env(
-            "CORE_REGISTRY", "src,src.ddeutil.workflow,tests,tests.utils"
-        )
+        regis_hook_str: str = env("CORE_REGISTRY", "src")
         return [r.strip() for r in regis_hook_str.split(",")]
 
     @property
     def regis_filter(self) -> list[str]:
         regis_filter_str: str = env(
-            "CORE_REGISTRY_FILTER", "ddeutil.workflow.utils"
+            "CORE_REGISTRY_FILTER", "ddeutil.workflow.templates"
         )
         return [r.strip() for r in regis_filter_str.split(",")]
 
@@ -312,6 +310,10 @@ class SimLoad:
         )
 
 
+config = Config()
+logger = get_logger("ddeutil.workflow")
+
+
 class Loader(SimLoad):
     """Loader Object that get the config `yaml` file from current path.
 
@@ -337,15 +339,11 @@ class Loader(SimLoad):
         :rtype: Iterator[tuple[str, DictData]]
         """
         return super().finds(
-            obj=obj, conf=Config(), included=included, excluded=excluded
+            obj=obj, conf=config, included=included, excluded=excluded
         )
 
     def __init__(self, name: str, externals: DictData) -> None:
-        super().__init__(name, conf=Config(), externals=externals)
-
-
-config = Config()
-logger = get_logger("ddeutil.workflow")
+        super().__init__(name, conf=config, externals=externals)
 
 
 class BaseLog(BaseModel, ABC):
@@ -427,8 +425,8 @@ class FileLog(BaseLog):
         workflow name and release values. If a release does not pass to an input
         argument, it will return the latest release from the current log path.
 
-        :param name:
-        :param release:
+        :param name: A workflow name that want to search log.
+        :param release: A release datetime that want to search log.
 
         :raise FileNotFoundError:
         :raise NotImplementedError:
@@ -492,8 +490,14 @@ class FileLog(BaseLog):
 
         :rtype: Self
         """
+        from .utils import cut_id
+
         # NOTE: Check environ variable was set for real writing.
         if not config.enable_write_log:
+            logger.debug(
+                f"({cut_id(self.run_id)}) [LOG]: Skip writing log cause "
+                f"config was set"
+            )
             return self
 
         log_file: Path = self.pointer() / f"{self.run_id}.log"
@@ -523,6 +527,19 @@ class SQLiteLog(BaseLog):  # pragma: no cov
         """
 
     def save(self, excluded: list[str] | None) -> None:
+        """Save logging data that receive a context data from a workflow
+        execution result.
+        """
+        from .utils import cut_id
+
+        # NOTE: Check environ variable was set for real writing.
+        if not config.enable_write_log:
+            logger.debug(
+                f"({cut_id(self.run_id)}) [LOG]: Skip writing log cause "
+                f"config was set"
+            )
+            return self
+
         raise NotImplementedError("SQLiteLog does not implement yet.")
 
 

ddeutil/workflow/exceptions.py

@@ -29,6 +29,3 @@ class WorkflowFailException(WorkflowException): ...
 
 
 class ParamValueException(WorkflowException): ...
-
-
-class CliException(BaseWorkflowException): ...

ddeutil/workflow/hook.py

@@ -0,0 +1,153 @@
+# ------------------------------------------------------------------------------
+# Copyright (c) 2022 Korawich Anuttra. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root for
+# license information.
+# ------------------------------------------------------------------------------
+from __future__ import annotations
+
+import inspect
+import logging
+from dataclasses import dataclass
+from functools import wraps
+from importlib import import_module
+from typing import Any, Callable, Protocol, TypeVar
+
+try:
+    from typing import ParamSpec
+except ImportError:
+    from typing_extensions import ParamSpec
+
+from ddeutil.core import lazy
+
+from .__types import Re
+from .conf import config
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+logger = logging.getLogger("ddeutil.workflow")
+
+
+class TagFunc(Protocol):
+    """Tag Function Protocol"""
+
+    name: str
+    tag: str
+
+    def __call__(self, *args, **kwargs): ...  # pragma: no cov
+
+
+ReturnTagFunc = Callable[P, TagFunc]
+DecoratorTagFunc = Callable[[Callable[[...], Any]], ReturnTagFunc]
+
+
+def tag(
+    name: str, alias: str | None = None
+) -> DecoratorTagFunc:  # pragma: no cov
+    """Tag decorator function that set function attributes, ``tag`` and ``name``
+    for making registries variable.
+
+    :param: name: A tag name for make different use-case of a function.
+    :param: alias: A alias function name that keeping in registries. If this
+        value does not supply, it will use original function name from __name__.
+    :rtype: Callable[P, TagFunc]
+    """
+
+    def func_internal(func: Callable[[...], Any]) -> ReturnTagFunc:
+        func.tag = name
+        func.name = alias or func.__name__.replace("_", "-")
+
+        @wraps(func)
+        def wrapped(*args, **kwargs):
+            # NOTE: Able to do anything before calling hook function.
+            return func(*args, **kwargs)
+
+        return wrapped
+
+    return func_internal
+
+
+Registry = dict[str, Callable[[], TagFunc]]
+
+
+def make_registry(submodule: str) -> dict[str, Registry]:
+    """Return registries of all functions that able to called with task.
+
+    :param submodule: A module prefix that want to import registry.
+    :rtype: dict[str, Registry]
+    """
+    rs: dict[str, Registry] = {}
+    for module in config.regis_hook:
+        # NOTE: try to sequential import task functions
+        try:
+            importer = import_module(f"{module}.{submodule}")
+        except ModuleNotFoundError:
+            continue
+
+        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, "tag"):
+                continue
+
+            # NOTE: Create new register name if it not exists
+            if func.name not in rs:
+                rs[func.name] = {func.tag: lazy(f"{module}.{submodule}.{fstr}")}
+                continue
+
+            if func.tag in rs[func.name]:
+                raise ValueError(
+                    f"The tag {func.tag!r} already exists on "
+                    f"{module}.{submodule}, you should change this tag name or "
+                    f"change it func name."
+                )
+            rs[func.name][func.tag] = lazy(f"{module}.{submodule}.{fstr}")
+
+    return rs
+
+
+@dataclass(frozen=True)
+class HookSearchData:
+    """Hook Search dataclass that use for receive regular expression grouping
+    dict from searching hook string value.
+    """
+
+    path: str
+    func: str
+    tag: str
+
+
+def extract_hook(hook: str) -> Callable[[], TagFunc]:
+    """Extract Hook function from string value to hook partial function that
+    does run it at runtime.
+
+    :raise NotImplementedError: When the searching hook's function result does
+        not exist in the registry.
+    :raise NotImplementedError: When the searching hook's tag result does not
+        exists in the registry with its function key.
+
+    :param hook: A hook value that able to match with Task regex.
+    :rtype: Callable[[], TagFunc]
+    """
+    if not (found := Re.RE_TASK_FMT.search(hook)):
+        raise ValueError(
+            f"Hook {hook!r} does not match with hook format regex."
+        )
+
+    # NOTE: Pass the searching hook string to `path`, `func`, and `tag`.
+    hook: HookSearchData = HookSearchData(**found.groupdict())
+
+    # NOTE: Registry object should implement on this package only.
+    rgt: dict[str, Registry] = make_registry(f"{hook.path}")
+    if hook.func not in rgt:
+        raise NotImplementedError(
+            f"``REGISTER-MODULES.{hook.path}.registries`` does not "
+            f"implement registry: {hook.func!r}."
+        )
+
+    if hook.tag not in rgt[hook.func]:
+        raise NotImplementedError(
+            f"tag: {hook.tag!r} does not found on registry func: "
+            f"``REGISTER-MODULES.{hook.path}.registries.{hook.func}``"
+        )
+    return rgt[hook.func][hook.tag]

ddeutil/workflow/job.py

@@ -38,13 +38,13 @@ from .exceptions import (
 )
 from .result import Result
 from .stage import Stage
+from .templates import has_template
 from .utils import (
     cross_product,
     cut_id,
     dash2underscore,
     filter_func,
     gen_id,
-    has_template,
 )
 
 logger = get_logger("ddeutil.workflow")

ddeutil/workflow/stage.py

@@ -31,7 +31,6 @@ import time
 import uuid
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
-from dataclasses import dataclass
 from functools import wraps
 from inspect import Parameter
 from pathlib import Path
@@ -48,19 +47,16 @@ from pydantic import BaseModel, Field
 from pydantic.functional_validators import model_validator
 from typing_extensions import Self
 
-from .__types import DictData, DictStr, Re, TupleStr
+from .__types import DictData, DictStr, TupleStr
 from .conf import config, get_logger
 from .exceptions import StageException
+from .hook import TagFunc, extract_hook
 from .result import Result
+from .templates import not_in_template, param2template
 from .utils import (
-    Registry,
-    TagFunc,
     cut_id,
     gen_id,
     make_exec,
-    make_registry,
-    not_in_template,
-    param2template,
 )
 
 P = ParamSpec("P")
@@ -76,7 +72,6 @@ __all__: TupleStr = (
     "HookStage",
     "TriggerStage",
     "Stage",
-    "extract_hook",
 )
 
 
@@ -558,53 +553,6 @@ class PyStage(BaseStage):
         )
 
 
-@dataclass(frozen=True)
-class HookSearchData:
-    """Hook Search dataclass that use for receive regular expression grouping
-    dict from searching hook string value.
-    """
-
-    path: str
-    func: str
-    tag: str
-
-
-def extract_hook(hook: str) -> Callable[[], TagFunc]:
-    """Extract Hook function from string value to hook partial function that
-    does run it at runtime.
-
-    :raise NotImplementedError: When the searching hook's function result does
-        not exist in the registry.
-    :raise NotImplementedError: When the searching hook's tag result does not
-        exists in the registry with its function key.
-
-    :param hook: A hook value that able to match with Task regex.
-    :rtype: Callable[[], TagFunc]
-    """
-    if not (found := Re.RE_TASK_FMT.search(hook)):
-        raise ValueError(
-            f"Hook {hook!r} does not match with hook format regex."
-        )
-
-    # NOTE: Pass the searching hook string to `path`, `func`, and `tag`.
-    hook: HookSearchData = HookSearchData(**found.groupdict())
-
-    # NOTE: Registry object should implement on this package only.
-    rgt: dict[str, Registry] = make_registry(f"{hook.path}")
-    if hook.func not in rgt:
-        raise NotImplementedError(
-            f"``REGISTER-MODULES.{hook.path}.registries`` does not "
-            f"implement registry: {hook.func!r}."
-        )
-
-    if hook.tag not in rgt[hook.func]:
-        raise NotImplementedError(
-            f"tag: {hook.tag!r} does not found on registry func: "
-            f"``REGISTER-MODULES.{hook.path}.registries.{hook.func}``"
-        )
-    return rgt[hook.func][hook.tag]
-
-
 class HookStage(BaseStage):
     """Hook executor that hook the Python function from registry with tag
     decorator function in ``utils`` module and run it with input arguments.

ddeutil/workflow/templates.py

@@ -0,0 +1,334 @@
+# ------------------------------------------------------------------------------
+# Copyright (c) 2022 Korawich Anuttra. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root for
+# license information.
+# ------------------------------------------------------------------------------
+from __future__ import annotations
+
+import inspect
+import logging
+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, Protocol, TypeVar, Union
+
+try:
+    from typing import ParamSpec
+except ImportError:
+    from typing_extensions import ParamSpec
+
+from ddeutil.core import getdot, hasdot, import_string
+from ddeutil.io import search_env_replace
+
+from .__types import DictData, Re
+from .conf import config
+from .exceptions import UtilException
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+logger = logging.getLogger("ddeutil.workflow")
+
+
+FILTERS: dict[str, callable] = {  # pragma: no cov
+    "abs": abs,
+    "str": str,
+    "int": int,
+    "title": lambda x: x.title(),
+    "upper": lambda x: x.upper(),
+    "lower": lambda x: x.lower(),
+    "rstr": [str, repr],
+}
+
+
+class FilterFunc(Protocol):
+    """Tag Function Protocol. This protocol that use to represent any callable
+    object that able to access the name attribute.
+    """
+
+    name: str
+
+    def __call__(self, *args, **kwargs): ...  # pragma: no cov
+
+
+FilterRegistry = Union[FilterFunc, Callable[[...], Any]]
+
+
+def custom_filter(name: str) -> Callable[P, FilterFunc]:
+    """Custom filter decorator function that set function attributes, ``filter``
+    for making filter registries variable.
+
+    :param: name: A filter name for make different use-case of a function.
+    :rtype: Callable[P, FilterFunc]
+    """
+
+    def func_internal(func: Callable[[...], Any]) -> FilterFunc:
+        func.filter = name
+
+        @wraps(func)
+        def wrapped(*args, **kwargs):
+            # NOTE: Able to do anything before calling custom filter function.
+            return func(*args, **kwargs)
+
+        return wrapped
+
+    return func_internal
+
+
+def make_filter_registry() -> dict[str, FilterRegistry]:
+    """Return registries of all functions that able to called with task.
+
+    :rtype: dict[str, Registry]
+    """
+    rs: dict[str, FilterRegistry] = {}
+    for module in config.regis_filter:
+        # NOTE: try to sequential import task functions
+        try:
+            importer = import_module(module)
+        except ModuleNotFoundError:
+            continue
+
+        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"):
+                continue
+
+            rs[func.filter] = import_string(f"{module}.{fstr}")
+
+    rs.update(FILTERS)
+    return rs
+
+
+def get_args_const(
+    expr: str,
+) -> tuple[str, list[Constant], dict[str, Constant]]:
+    """Get arguments and keyword-arguments from function calling string.
+
+    :rtype: tuple[str, list[Constant], dict[str, Constant]]
+    """
+    try:
+        mod: Module = parse(expr)
+    except SyntaxError:
+        raise UtilException(
+            f"Post-filter: {expr} does not valid because it raise syntax error."
+        ) from None
+
+    body: list[Expr] = mod.body
+    if len(body) > 1:
+        raise UtilException(
+            "Post-filter function should be only one calling per workflow."
+        )
+
+    caller: Union[Name, Call]
+    if isinstance((caller := body[0].value), Name):
+        return caller.id, [], {}
+    elif not isinstance(caller, Call):
+        raise UtilException(
+            f"Get arguments does not support for caller type: {type(caller)}"
+        )
+
+    name: Name = caller.func
+    args: list[Constant] = caller.args
+    keywords: dict[str, Constant] = {k.arg: k.value for k in caller.keywords}
+
+    if any(not isinstance(i, Constant) for i in args):
+        raise UtilException(f"Argument of {expr} should be constant.")
+
+    if any(not isinstance(i, Constant) for i in keywords.values()):
+        raise UtilException(f"Keyword argument of {expr} should be constant.")
+
+    return name.id, args, keywords
+
+
+def get_args_from_filter(
+    ft: str,
+    filters: dict[str, FilterRegistry],
+) -> tuple[str, FilterRegistry, list[Any], dict[Any, Any]]:  # pragma: no cov
+    """Get arguments and keyword-arguments from filter function calling string.
+    and validate it with the filter functions mapping dict.
+    """
+    func_name, _args, _kwargs = get_args_const(ft)
+    args: list[Any] = [arg.value for arg in _args]
+    kwargs: dict[Any, Any] = {k: v.value for k, v in _kwargs.items()}
+
+    if func_name not in filters:
+        raise UtilException(
+            f"The post-filter: {func_name!r} does not support yet."
+        )
+
+    if isinstance((f_func := filters[func_name]), list) and (args or kwargs):
+        raise UtilException(
+            "Chain filter function does not support for passing arguments."
+        )
+
+    return func_name, f_func, args, kwargs
+
+
+def map_post_filter(
+    value: T,
+    post_filter: list[str],
+    filters: dict[str, FilterRegistry],
+) -> T:
+    """Mapping post-filter to value with sequence list of filter function name
+    that will get from the filter registry.
+
+    :param value: A string value that want to mapped with filter function.
+    :param post_filter: A list of post-filter function name.
+    :param filters: A filter registry.
+
+    :rtype: T
+    """
+    for ft in post_filter:
+        func_name, f_func, args, kwargs = get_args_from_filter(ft, filters)
+        try:
+            if isinstance(f_func, list):
+                for func in f_func:
+                    value: T = func(value)
+            else:
+                value: T = f_func(value, *args, **kwargs)
+        except UtilException as err:
+            logger.warning(str(err))
+            raise
+        except Exception as err:
+            logger.warning(str(err))
+            raise UtilException(
+                f"The post-filter function: {func_name} does not fit with "
+                f"{value} (type: {type(value).__name__})."
+            ) from None
+    return value
+
+
+def not_in_template(value: Any, *, not_in: str = "matrix.") -> bool:
+    """Check value should not pass template with not_in value prefix.
+
+    :param value: A value that want to find parameter template prefix.
+    :param not_in: The not in string that use in the `.startswith` function.
+
+    :rtype: bool
+    """
+    if isinstance(value, dict):
+        return any(not_in_template(value[k], not_in=not_in) for k in value)
+    elif isinstance(value, (list, tuple, set)):
+        return any(not_in_template(i, not_in=not_in) for i in value)
+    elif not isinstance(value, str):
+        return False
+    return any(
+        (not found.caller.strip().startswith(not_in))
+        for found in Re.finditer_caller(value.strip())
+    )
+
+
+def has_template(value: Any) -> bool:
+    """Check value include templating string.
+
+    :param value: A value that want to find parameter template.
+
+    :rtype: bool
+    """
+    if isinstance(value, dict):
+        return any(has_template(value[k]) for k in value)
+    elif isinstance(value, (list, tuple, set)):
+        return any(has_template(i) for i in value)
+    elif not isinstance(value, str):
+        return False
+    return bool(Re.RE_CALLER.findall(value.strip()))
+
+
+def str2template(
+    value: str,
+    params: DictData,
+    *,
+    filters: dict[str, FilterRegistry] | None = None,
+) -> Any:
+    """(Sub-function) Pass param to template string that can search by
+    ``RE_CALLER`` regular expression.
+
+        The getter value that map a template should have typing support align
+    with the workflow parameter types that is `str`, `int`, `datetime`, and
+    `list`.
+
+    :param value: A string value that want to mapped with an params
+    :param params: A parameter value that getting with matched regular
+        expression.
+    :param filters:
+    """
+    filters: dict[str, FilterRegistry] = filters or make_filter_registry()
+
+    # NOTE: remove space before and after this string value.
+    value: str = value.strip()
+    for found in Re.finditer_caller(value):
+        # NOTE:
+        #   Get caller and filter values that setting inside;
+        #
+        #   ... ``${{ <caller-value> [ | <filter-value>] ... }}``
+        #
+        caller: str = found.caller
+        pfilter: list[str] = [
+            i.strip()
+            for i in (found.post_filters.strip().removeprefix("|").split("|"))
+            if i != ""
+        ]
+        if not hasdot(caller, params):
+            raise UtilException(f"The params does not set caller: {caller!r}.")
+
+        # NOTE: from validate step, it guarantee that caller exists in params.
+        getter: Any = getdot(caller, params)
+
+        # NOTE:
+        #   If type of getter caller is not string type and it does not use to
+        #   concat other string value, it will return origin value from the
+        #   ``getdot`` function.
+        if value.replace(found.full, "", 1) == "":
+            return map_post_filter(getter, pfilter, filters=filters)
+
+        # NOTE: map post-filter function.
+        getter: Any = map_post_filter(getter, pfilter, filters=filters)
+        if not isinstance(getter, str):
+            getter: str = str(getter)
+
+        value: str = value.replace(found.full, getter, 1)
+
+    return search_env_replace(value)
+
+
+def param2template(
+    value: Any,
+    params: DictData,
+) -> Any:
+    """Pass param to template string that can search by ``RE_CALLER`` regular
+    expression.
+
+    :param value: A value that want to mapped with an params
+    :param params: A parameter value that getting with matched regular
+        expression.
+
+    :rtype: Any
+    :returns: An any getter value from the params input.
+    """
+    filters: dict[str, FilterRegistry] = make_filter_registry()
+    if isinstance(value, dict):
+        return {k: param2template(value[k], params) for k in value}
+    elif isinstance(value, (list, tuple, set)):
+        return type(value)([param2template(i, params) for i in value])
+    elif not isinstance(value, str):
+        return value
+    return str2template(value, params, filters=filters)
+
+
+@custom_filter("fmt")  # pragma: no cov
+def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
+    """Format datetime object to string with the format.
+
+    :param value: A datetime value that want to format to string value.
+    :param fmt: A format string pattern that passing to the `dt.strftime`
+        method.
+
+    :rtype: str
+    """
+    if isinstance(value, datetime):
+        return value.strftime(fmt)
+    raise UtilException(
+        "This custom function should pass input value with datetime type."
+    )

ddeutil/workflow/utils.py

@@ -5,21 +5,17 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-import inspect
 import logging
 import stat
 import time
-from ast import Call, Constant, Expr, Module, Name, parse
 from collections.abc import Iterator
 from datetime import datetime, timedelta
-from functools import wraps
 from hashlib import md5
-from importlib import import_module
 from inspect import isfunction
 from itertools import chain, islice, product
 from pathlib import Path
 from random import randrange
-from typing import Any, Callable, Protocol, TypeVar, Union
+from typing import Any, TypeVar
 from zoneinfo import ZoneInfo
 
 try:
@@ -27,18 +23,13 @@ try:
 except ImportError:
     from typing_extensions import ParamSpec
 
-from ddeutil.core import getdot, hasdot, hash_str, import_string, lazy
-from ddeutil.io import search_env_replace
-from pydantic import BaseModel
+from ddeutil.core import hash_str
 
-from .__types import DictData, Matrix, Re
+from .__types import DictData, Matrix
 from .conf import config
-from .exceptions import UtilException
 
 T = TypeVar("T")
 P = ParamSpec("P")
-AnyModel = TypeVar("AnyModel", bound=BaseModel)
-AnyModelType = type[AnyModel]
 
 logger = logging.getLogger("ddeutil.workflow")
 
@@ -121,84 +112,6 @@ def gen_id(
     ).hexdigest()
 
 
-class TagFunc(Protocol):
-    """Tag Function Protocol"""
-
-    name: str
-    tag: str
-
-    def __call__(self, *args, **kwargs): ...  # pragma: no cov
-
-
-ReturnTagFunc = Callable[P, TagFunc]
-DecoratorTagFunc = Callable[[Callable[[...], Any]], ReturnTagFunc]
-
-
-def tag(
-    name: str, alias: str | None = None
-) -> DecoratorTagFunc:  # pragma: no cov
-    """Tag decorator function that set function attributes, ``tag`` and ``name``
-    for making registries variable.
-
-    :param: name: A tag name for make different use-case of a function.
-    :param: alias: A alias function name that keeping in registries. If this
-        value does not supply, it will use original function name from __name__.
-    :rtype: Callable[P, TagFunc]
-    """
-
-    def func_internal(func: Callable[[...], Any]) -> ReturnTagFunc:
-        func.tag = name
-        func.name = alias or func.__name__.replace("_", "-")
-
-        @wraps(func)
-        def wrapped(*args, **kwargs):
-            # NOTE: Able to do anything before calling hook function.
-            return func(*args, **kwargs)
-
-        return wrapped
-
-    return func_internal
-
-
-Registry = dict[str, Callable[[], TagFunc]]
-
-
-def make_registry(submodule: str) -> dict[str, Registry]:
-    """Return registries of all functions that able to called with task.
-
-    :param submodule: A module prefix that want to import registry.
-    :rtype: dict[str, Registry]
-    """
-    rs: dict[str, Registry] = {}
-    for module in config.regis_hook:
-        # NOTE: try to sequential import task functions
-        try:
-            importer = import_module(f"{module}.{submodule}")
-        except ModuleNotFoundError:
-            continue
-
-        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, "tag"):
-                continue
-
-            # NOTE: Create new register name if it not exists
-            if func.name not in rs:
-                rs[func.name] = {func.tag: lazy(f"{module}.{submodule}.{fstr}")}
-                continue
-
-            if func.tag in rs[func.name]:
-                raise ValueError(
-                    f"The tag {func.tag!r} already exists on "
-                    f"{module}.{submodule}, you should change this tag name or "
-                    f"change it func name."
-                )
-            rs[func.name][func.tag] = lazy(f"{module}.{submodule}.{fstr}")
-
-    return rs
-
-
 def make_exec(path: str | Path) -> None:
     """Change mode of file to be executable file.
 
@@ -208,307 +121,6 @@ def make_exec(path: str | Path) -> None:
     f.chmod(f.stat().st_mode | stat.S_IEXEC)
 
 
-FILTERS: dict[str, callable] = {  # pragma: no cov
-    "abs": abs,
-    "str": str,
-    "int": int,
-    "title": lambda x: x.title(),
-    "upper": lambda x: x.upper(),
-    "lower": lambda x: x.lower(),
-    "rstr": [str, repr],
-}
-
-
-class FilterFunc(Protocol):
-    """Tag Function Protocol. This protocol that use to represent any callable
-    object that able to access the name attribute.
-    """
-
-    name: str
-
-    def __call__(self, *args, **kwargs): ...  # pragma: no cov
-
-
-def custom_filter(name: str) -> Callable[P, FilterFunc]:
-    """Custom filter decorator function that set function attributes, ``filter``
-    for making filter registries variable.
-
-    :param: name: A filter name for make different use-case of a function.
-    :rtype: Callable[P, FilterFunc]
-    """
-
-    def func_internal(func: Callable[[...], Any]) -> FilterFunc:
-        func.filter = name
-
-        @wraps(func)
-        def wrapped(*args, **kwargs):
-            # NOTE: Able to do anything before calling custom filter function.
-            return func(*args, **kwargs)
-
-        return wrapped
-
-    return func_internal
-
-
-FilterRegistry = Union[FilterFunc, Callable[[...], Any]]
-
-
-def make_filter_registry() -> dict[str, FilterRegistry]:
-    """Return registries of all functions that able to called with task.
-
-    :rtype: dict[str, Registry]
-    """
-    rs: dict[str, Registry] = {}
-    for module in config.regis_filter:
-        # NOTE: try to sequential import task functions
-        try:
-            importer = import_module(module)
-        except ModuleNotFoundError:
-            continue
-
-        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"):
-                continue
-
-            rs[func.filter] = import_string(f"{module}.{fstr}")
-
-    rs.update(FILTERS)
-    return rs
-
-
-def get_args_const(
-    expr: str,
-) -> tuple[str, list[Constant], dict[str, Constant]]:
-    """Get arguments and keyword-arguments from function calling string.
-
-    :rtype: tuple[str, list[Constant], dict[str, Constant]]
-    """
-    try:
-        mod: Module = parse(expr)
-    except SyntaxError:
-        raise UtilException(
-            f"Post-filter: {expr} does not valid because it raise syntax error."
-        ) from None
-
-    body: list[Expr] = mod.body
-    if len(body) > 1:
-        raise UtilException(
-            "Post-filter function should be only one calling per workflow."
-        )
-
-    caller: Union[Name, Call]
-    if isinstance((caller := body[0].value), Name):
-        return caller.id, [], {}
-    elif not isinstance(caller, Call):
-        raise UtilException(
-            f"Get arguments does not support for caller type: {type(caller)}"
-        )
-
-    name: Name = caller.func
-    args: list[Constant] = caller.args
-    keywords: dict[str, Constant] = {k.arg: k.value for k in caller.keywords}
-
-    if any(not isinstance(i, Constant) for i in args):
-        raise UtilException(f"Argument of {expr} should be constant.")
-
-    if any(not isinstance(i, Constant) for i in keywords.values()):
-        raise UtilException(f"Keyword argument of {expr} should be constant.")
-
-    return name.id, args, keywords
-
-
-def get_args_from_filter(
-    ft: str,
-    filters: dict[str, FilterRegistry],
-) -> tuple[str, FilterRegistry, list[Any], dict[Any, Any]]:  # pragma: no cov
-    """Get arguments and keyword-arguments from filter function calling string.
-    and validate it with the filter functions mapping dict.
-    """
-    func_name, _args, _kwargs = get_args_const(ft)
-    args: list[Any] = [arg.value for arg in _args]
-    kwargs: dict[Any, Any] = {k: v.value for k, v in _kwargs.items()}
-
-    if func_name not in filters:
-        raise UtilException(
-            f"The post-filter: {func_name!r} does not support yet."
-        )
-
-    if isinstance((f_func := filters[func_name]), list) and (args or kwargs):
-        raise UtilException(
-            "Chain filter function does not support for passing arguments."
-        )
-
-    return func_name, f_func, args, kwargs
-
-
-@custom_filter("fmt")  # pragma: no cov
-def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
-    """Format datetime object to string with the format.
-
-    :param value: A datetime value that want to format to string value.
-    :param fmt: A format string pattern that passing to the `dt.strftime`
-        method.
-
-    :rtype: str
-    """
-    if isinstance(value, datetime):
-        return value.strftime(fmt)
-    raise UtilException(
-        "This custom function should pass input value with datetime type."
-    )
-
-
-def map_post_filter(
-    value: T,
-    post_filter: list[str],
-    filters: dict[str, FilterRegistry],
-) -> T:
-    """Mapping post-filter to value with sequence list of filter function name
-    that will get from the filter registry.
-
-    :param value: A string value that want to mapped with filter function.
-    :param post_filter: A list of post-filter function name.
-    :param filters: A filter registry.
-
-    :rtype: T
-    """
-    for ft in post_filter:
-        func_name, f_func, args, kwargs = get_args_from_filter(ft, filters)
-        try:
-            if isinstance(f_func, list):
-                for func in f_func:
-                    value: T = func(value)
-            else:
-                value: T = f_func(value, *args, **kwargs)
-        except UtilException as err:
-            logger.warning(str(err))
-            raise
-        except Exception as err:
-            logger.warning(str(err))
-            raise UtilException(
-                f"The post-filter function: {func_name} does not fit with "
-                f"{value} (type: {type(value).__name__})."
-            ) from None
-    return value
-
-
-def not_in_template(value: Any, *, not_in: str = "matrix.") -> bool:
-    """Check value should not pass template with not_in value prefix.
-
-    :param value: A value that want to find parameter template prefix.
-    :param not_in: The not in string that use in the `.startswith` function.
-    :rtype: bool
-    """
-    if isinstance(value, dict):
-        return any(not_in_template(value[k], not_in=not_in) for k in value)
-    elif isinstance(value, (list, tuple, set)):
-        return any(not_in_template(i, not_in=not_in) for i in value)
-    elif not isinstance(value, str):
-        return False
-    return any(
-        (not found.caller.strip().startswith(not_in))
-        for found in Re.finditer_caller(value.strip())
-    )
-
-
-def has_template(value: Any) -> bool:
-    """Check value include templating string.
-
-    :param value: A value that want to find parameter template.
-    :rtype: bool
-    """
-    if isinstance(value, dict):
-        return any(has_template(value[k]) for k in value)
-    elif isinstance(value, (list, tuple, set)):
-        return any(has_template(i) for i in value)
-    elif not isinstance(value, str):
-        return False
-    return bool(Re.RE_CALLER.findall(value.strip()))
-
-
-def str2template(
-    value: str,
-    params: DictData,
-    *,
-    filters: dict[str, FilterRegistry] | None = None,
-) -> Any:
-    """(Sub-function) Pass param to template string that can search by
-    ``RE_CALLER`` regular expression.
-
-        The getter value that map a template should have typing support align
-    with the workflow parameter types that is `str`, `int`, `datetime`, and
-    `list`.
-
-    :param value: A string value that want to mapped with an params
-    :param params: A parameter value that getting with matched regular
-        expression.
-    :param filters:
-    """
-    filters: dict[str, FilterRegistry] = filters or make_filter_registry()
-
-    # NOTE: remove space before and after this string value.
-    value: str = value.strip()
-    for found in Re.finditer_caller(value):
-        # NOTE:
-        #   Get caller and filter values that setting inside;
-        #
-        #   ... ``${{ <caller-value> [ | <filter-value>] ... }}``
-        #
-        caller: str = found.caller
-        pfilter: list[str] = [
-            i.strip()
-            for i in (found.post_filters.strip().removeprefix("|").split("|"))
-            if i != ""
-        ]
-        if not hasdot(caller, params):
-            raise UtilException(f"The params does not set caller: {caller!r}.")
-
-        # NOTE: from validate step, it guarantee that caller exists in params.
-        getter: Any = getdot(caller, params)
-
-        # NOTE:
-        #   If type of getter caller is not string type and it does not use to
-        #   concat other string value, it will return origin value from the
-        #   ``getdot`` function.
-        if value.replace(found.full, "", 1) == "":
-            return map_post_filter(getter, pfilter, filters=filters)
-
-        # NOTE: map post-filter function.
-        getter: Any = map_post_filter(getter, pfilter, filters=filters)
-        if not isinstance(getter, str):
-            getter: str = str(getter)
-
-        value: str = value.replace(found.full, getter, 1)
-
-    return search_env_replace(value)
-
-
-def param2template(
-    value: Any,
-    params: DictData,
-) -> Any:
-    """Pass param to template string that can search by ``RE_CALLER`` regular
-    expression.
-
-    :param value: A value that want to mapped with an params
-    :param params: A parameter value that getting with matched regular
-        expression.
-
-    :rtype: Any
-    :returns: An any getter value from the params input.
-    """
-    filters: dict[str, FilterRegistry] = make_filter_registry()
-    if isinstance(value, dict):
-        return {k: param2template(value[k], params) for k in value}
-    elif isinstance(value, (list, tuple, set)):
-        return type(value)([param2template(i, params) for i in value])
-    elif not isinstance(value, str):
-        return value
-    return str2template(value, params, filters=filters)
-
-
 def filter_func(value: Any) -> Any:
     """Filter out an own created function of any value of mapping context by
     replacing it to its function name. If it is built-in function, it does not

ddeutil/workflow/workflow.py

@@ -48,12 +48,11 @@ from .exceptions import JobException, WorkflowException
 from .job import Job
 from .params import Param
 from .result import Result
+from .templates import has_template, param2template
 from .utils import (
     cut_id,
     gen_id,
     get_dt_now,
-    has_template,
-    param2template,
     wait_a_minute,
 )
 
@@ -486,7 +485,7 @@ class Workflow(BaseModel):
             - Initialize WorkflowQueue and WorkflowRelease if they do not pass.
             - Create release data for pass to parameter templating function.
             - Execute this workflow with mapping release data to its parameters.
-            - Writing log
+            - Writing result log
             - Remove this release on the running queue
             - Push this release to complete queue
 

{ddeutil_workflow-0.0.26.post1.dist-info → ddeutil_workflow-0.0.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddeutil-workflow
-Version: 0.0.26.post1
+Version: 0.0.27
 Summary: Lightweight workflow orchestration with less dependencies
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -168,29 +168,29 @@ The main configuration that use to dynamic changing with your propose of this
 application. If any configuration values do not set yet, it will use default value
 and do not raise any error to you.
 
-| Environment                                | Component | Default                                              | Description                                                                                                        | Remark |
-|:-------------------------------------------|:---------:|:-----------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------|--------|
-| **WORKFLOW_ROOT_PATH**                     |   Core    | `.`                                                  | The root path of the workflow application.                                                                         |        |
-| **WORKFLOW_CORE_REGISTRY**                 |   Core    | `src,src.ddeutil.workflow,tests,tests.utils`         | List of importable string for the hook stage.                                                                      |        |
-| **WORKFLOW_CORE_REGISTRY_FILTER**          |   Core    | `src.ddeutil.workflow.utils,ddeutil.workflow.utils`  | List of importable string for the filter template.                                                                 |        |
-| **WORKFLOW_CORE_PATH_CONF**                |   Core    | `conf`                                               | The config path that keep all template `.yaml` files.                                                              |        |
-| **WORKFLOW_CORE_TIMEZONE**                 |   Core    | `Asia/Bangkok`                                       | A Timezone string value that will pass to `ZoneInfo` object.                                                       |        |
-| **WORKFLOW_CORE_STAGE_DEFAULT_ID**         |   Core    | `true`                                               | A flag that enable default stage ID that use for catch an execution output.                                        |        |
-| **WORKFLOW_CORE_STAGE_RAISE_ERROR**        |   Core    | `false`                                              | A flag that all stage raise StageException from stage execution.                                                   |        |
-| **WORKFLOW_CORE_JOB_DEFAULT_ID**           |   Core    | `false`                                              | A flag that enable default job ID that use for catch an execution output. The ID that use will be sequence number. |        |
-| **WORKFLOW_CORE_JOB_RAISE_ERROR**          |   Core    | `true`                                               | A flag that all job raise JobException from job strategy execution.                                                |        |
-| **WORKFLOW_CORE_MAX_NUM_POKING**           |   Core    | `4`                                                  | .                                                                                                                  |        |
-| **WORKFLOW_CORE_MAX_JOB_PARALLEL**         |   Core    | `2`                                                  | The maximum job number that able to run parallel in workflow executor.                                             |        |
-| **WORKFLOW_CORE_MAX_JOB_EXEC_TIMEOUT**     |   Core    | `600`                                                |                                                                                                                    |        |
-| **WORKFLOW_CORE_MAX_CRON_PER_WORKFLOW**    |   Core    | `5`                                                  |                                                                                                                    |        |
-| **WORKFLOW_CORE_MAX_QUEUE_COMPLETE_HIST**  |   Core    | `16`                                                 |                                                                                                                    |        |
-| **WORKFLOW_CORE_GENERATE_ID_SIMPLE_MODE**  |   Core    | `true`                                               | A flog that enable generating ID with `md5` algorithm.                                                             |        |
-| **WORKFLOW_LOG_PATH**                      |    Log    | `./logs`                                             | The log path of the workflow saving log.                                                                           |        |
-| **WORKFLOW_LOG_DEBUG_MODE**                |    Log    | `true`                                               | A flag that enable logging with debug level mode.                                                                  |        |
-| **WORKFLOW_LOG_ENABLE_WRITE**              |    Log    | `true`                                               | A flag that enable logging object saving log to its destination.                                                   |        |
-| **WORKFLOW_APP_MAX_PROCESS**               | Schedule  | `2`                                                  | The maximum process worker number that run in scheduler app module.                                                |        |
-| **WORKFLOW_APP_MAX_SCHEDULE_PER_PROCESS**  | Schedule  | `100`                                                | A schedule per process that run parallel.                                                                          |        |
-| **WORKFLOW_APP_STOP_BOUNDARY_DELTA**       | Schedule  | `'{"minutes": 5, "seconds": 20}'`                    | A time delta value that use to stop scheduler app in json string format.                                           |        |
+| Environment                                | Component | Default                           | Description                                                                                                        | Remark |
+|:-------------------------------------------|:---------:|:----------------------------------|:-------------------------------------------------------------------------------------------------------------------|--------|
+| **WORKFLOW_ROOT_PATH**                     |   Core    | `.`                               | The root path of the workflow application.                                                                         |        |
+| **WORKFLOW_CORE_REGISTRY**                 |   Core    | `src`                             | List of importable string for the hook stage.                                                                      |        |
+| **WORKFLOW_CORE_REGISTRY_FILTER**          |   Core    | `ddeutil.workflow.utils`          | List of importable string for the filter template.                                                                 |        |
+| **WORKFLOW_CORE_PATH_CONF**                |   Core    | `conf`                            | The config path that keep all template `.yaml` files.                                                              |        |
+| **WORKFLOW_CORE_TIMEZONE**                 |   Core    | `Asia/Bangkok`                    | A Timezone string value that will pass to `ZoneInfo` object.                                                       |        |
+| **WORKFLOW_CORE_STAGE_DEFAULT_ID**         |   Core    | `true`                            | A flag that enable default stage ID that use for catch an execution output.                                        |        |
+| **WORKFLOW_CORE_STAGE_RAISE_ERROR**        |   Core    | `false`                           | A flag that all stage raise StageException from stage execution.                                                   |        |
+| **WORKFLOW_CORE_JOB_DEFAULT_ID**           |   Core    | `false`                           | A flag that enable default job ID that use for catch an execution output. The ID that use will be sequence number. |        |
+| **WORKFLOW_CORE_JOB_RAISE_ERROR**          |   Core    | `true`                            | A flag that all job raise JobException from job strategy execution.                                                |        |
+| **WORKFLOW_CORE_MAX_NUM_POKING**           |   Core    | `4`                               | .                                                                                                                  |        |
+| **WORKFLOW_CORE_MAX_JOB_PARALLEL**         |   Core    | `2`                               | The maximum job number that able to run parallel in workflow executor.                                             |        |
+| **WORKFLOW_CORE_MAX_JOB_EXEC_TIMEOUT**     |   Core    | `600`                             |                                                                                                                    |        |
+| **WORKFLOW_CORE_MAX_CRON_PER_WORKFLOW**    |   Core    | `5`                               |                                                                                                                    |        |
+| **WORKFLOW_CORE_MAX_QUEUE_COMPLETE_HIST**  |   Core    | `16`                              |                                                                                                                    |        |
+| **WORKFLOW_CORE_GENERATE_ID_SIMPLE_MODE**  |   Core    | `true`                            | A flog that enable generating ID with `md5` algorithm.                                                             |        |
+| **WORKFLOW_LOG_PATH**                      |    Log    | `./logs`                          | The log path of the workflow saving log.                                                                           |        |
+| **WORKFLOW_LOG_DEBUG_MODE**                |    Log    | `true`                            | A flag that enable logging with debug level mode.                                                                  |        |
+| **WORKFLOW_LOG_ENABLE_WRITE**              |    Log    | `true`                            | A flag that enable logging object saving log to its destination.                                                   |        |
+| **WORKFLOW_APP_MAX_PROCESS**               | Schedule  | `2`                               | The maximum process worker number that run in scheduler app module.                                                |        |
+| **WORKFLOW_APP_MAX_SCHEDULE_PER_PROCESS**  | Schedule  | `100`                             | A schedule per process that run parallel.                                                                          |        |
+| **WORKFLOW_APP_STOP_BOUNDARY_DELTA**       | Schedule  | `'{"minutes": 5, "seconds": 20}'` | A time delta value that use to stop scheduler app in json string format.                                           |        |
 
 **API Application**:
 

ddeutil_workflow-0.0.27.dist-info/RECORD

@@ -0,0 +1,25 @@
+ddeutil/workflow/__about__.py,sha256=Tb1KYKrlWsfQNnf5zwGCHzEkcwD78iHOrO3PQIyUgTY,28
+ddeutil/workflow/__cron.py,sha256=uA8XcbY_GwA9rJSHaHUaXaJyGDObJN0ZeYlJSinL8y8,26880
+ddeutil/workflow/__init__.py,sha256=ATYXzGtLyq4LWCtJ-Odz36QSrLL7dKymVs8ziThOVOk,1582
+ddeutil/workflow/__types.py,sha256=Ia7f38kvL3NibwmRKi0wQ1ud_45Z-SojYGhNJwIqcu8,3713
+ddeutil/workflow/conf.py,sha256=jr7KPnt3vd7icuXTLGcJt_kT9tlmN1Cu5QBDMHUrm94,16819
+ddeutil/workflow/cron.py,sha256=75A0hqevvouziKoLALncLJspVAeki9qCH3zniAJaxzY,7513
+ddeutil/workflow/exceptions.py,sha256=NqnQJP52S59XIYMeXbTDbr4xH2UZ5EA3ejpU5Z4g6cQ,894
+ddeutil/workflow/hook.py,sha256=yXhpr9E6ZzPb9_9ed79rWiRWDLnwkbRRg3TPmLvqoEI,4899
+ddeutil/workflow/job.py,sha256=JJ4vSpuhQnY7LOMf9xq6N8pBZQ1oAxqYQFbKHn_HjdQ,24237
+ddeutil/workflow/params.py,sha256=uPGkZx18E-iZ8BteqQ2ONgg0frhF3ZmP5cOyfK2j59U,5280
+ddeutil/workflow/result.py,sha256=WIC8MsnfLiWNpZomT6jS4YCdYhlbIVVBjtGGe2dkoKk,3404
+ddeutil/workflow/scheduler.py,sha256=BbY_3Y3QOdNwDfdvnRa7grGC2_a0Hn1KJbZKAscchk8,20454
+ddeutil/workflow/stage.py,sha256=JJDuObNzpw803-bECmDzeGuaxQW2DnR0Ps8Tl0uJZnw,25033
+ddeutil/workflow/templates.py,sha256=X-s5IZjwYpSD7UY3jaQiqbQBBG_Z3cWJDkzEIpicldg,10797
+ddeutil/workflow/utils.py,sha256=jg0ZsbglrrF3bAakQ3rSna9KTMq2Qf_NPLnlORHf3J0,6039
+ddeutil/workflow/workflow.py,sha256=QoSljQakGcumrx8l-W9yWuQZUTCrhArwAYktsj_L_9s,42204
+ddeutil/workflow/api/__init__.py,sha256=F53NMBWtb9IKaDWkPU5KvybGGfKAcbehgn6TLBwHuuM,21
+ddeutil/workflow/api/api.py,sha256=Md1cz3Edc7_uz63s_L_i-R3IE4mkO3aTADrX8GOGU-Y,5644
+ddeutil/workflow/api/repeat.py,sha256=zyvsrXKk-3-_N8ZRZSki0Mueshugum2jtqctEOp9QSc,4927
+ddeutil/workflow/api/route.py,sha256=v96jNbgjM1cJ2MpVSRWs2kgRqF8DQElEBdRZrVFEpEw,8578
+ddeutil_workflow-0.0.27.dist-info/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.27.dist-info/METADATA,sha256=SC2dWZTZ0eruriXwbnhuCHhOg-0Z6wT1t026hJvsLnw,13921
+ddeutil_workflow-0.0.27.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+ddeutil_workflow-0.0.27.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.27.dist-info/RECORD,,

ddeutil_workflow-0.0.26.post1.dist-info/RECORD

@@ -1,23 +0,0 @@
-ddeutil/workflow/__about__.py,sha256=jU_KFZf1uiZIWhuownbhRsjIL3oHGR_URL-jKTEnMKo,34
-ddeutil/workflow/__cron.py,sha256=uA8XcbY_GwA9rJSHaHUaXaJyGDObJN0ZeYlJSinL8y8,26880
-ddeutil/workflow/__init__.py,sha256=ozadVrqfqFRuukjv_zXUcgLANdiSrC6wrKkyVjdGg3w,1521
-ddeutil/workflow/__types.py,sha256=Ia7f38kvL3NibwmRKi0wQ1ud_45Z-SojYGhNJwIqcu8,3713
-ddeutil/workflow/conf.py,sha256=AU3GKTaxFFGDN-Sg8BGb08xj7vRBCTTjwk0FaORLJIk,16188
-ddeutil/workflow/cron.py,sha256=75A0hqevvouziKoLALncLJspVAeki9qCH3zniAJaxzY,7513
-ddeutil/workflow/exceptions.py,sha256=P56K7VD3etGm9y-k_GXrzEyqsTCaz9EJazTIshZDf9g,943
-ddeutil/workflow/job.py,sha256=cvSLMdc1sMl1MeU7so7Oe2SdRYxQwt6hm55mLV1iP-Y,24219
-ddeutil/workflow/params.py,sha256=uPGkZx18E-iZ8BteqQ2ONgg0frhF3ZmP5cOyfK2j59U,5280
-ddeutil/workflow/result.py,sha256=WIC8MsnfLiWNpZomT6jS4YCdYhlbIVVBjtGGe2dkoKk,3404
-ddeutil/workflow/scheduler.py,sha256=BbY_3Y3QOdNwDfdvnRa7grGC2_a0Hn1KJbZKAscchk8,20454
-ddeutil/workflow/stage.py,sha256=a2sngzs9DkP6GU2pgAD3QvGoijyBQTR_pOhyJUIuWAo,26692
-ddeutil/workflow/utils.py,sha256=pucRnCi9aLJDptXhzzReHZd5d-S0o5oZif5tr6H4iy8,18736
-ddeutil/workflow/workflow.py,sha256=s6E-mKzSVQPTSV0biIAu5lFjslo6blKA-WTAjeOfLuw,42183
-ddeutil/workflow/api/__init__.py,sha256=F53NMBWtb9IKaDWkPU5KvybGGfKAcbehgn6TLBwHuuM,21
-ddeutil/workflow/api/api.py,sha256=Md1cz3Edc7_uz63s_L_i-R3IE4mkO3aTADrX8GOGU-Y,5644
-ddeutil/workflow/api/repeat.py,sha256=zyvsrXKk-3-_N8ZRZSki0Mueshugum2jtqctEOp9QSc,4927
-ddeutil/workflow/api/route.py,sha256=v96jNbgjM1cJ2MpVSRWs2kgRqF8DQElEBdRZrVFEpEw,8578
-ddeutil_workflow-0.0.26.post1.dist-info/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.26.post1.dist-info/METADATA,sha256=B95z9M1Z9DWiKXQr1VoRvtlYcB6eX11RGktlAwn4MvI,14364
-ddeutil_workflow-0.0.26.post1.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-ddeutil_workflow-0.0.26.post1.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.26.post1.dist-info/RECORD,,