ddeutil-workflow 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

ddeutil/workflow/utils.py

@@ -6,9 +6,11 @@
 from __future__ import annotations
 
 import inspect
+import logging
 import os
 import stat
 from abc import ABC, abstractmethod
+from ast import Call, Constant, Expr, Module, Name, parse
 from collections.abc import Iterator
 from dataclasses import dataclass, field
 from datetime import date, datetime
@@ -20,14 +22,24 @@ from pathlib import Path
 from typing import Any, Callable, Literal, Optional, Protocol, Union
 from zoneinfo import ZoneInfo
 
-from ddeutil.core import getdot, hasdot, lazy
-from ddeutil.io import PathData
+from ddeutil.core import getdot, hasdot, import_string, lazy
+from ddeutil.io import PathData, search_env_replace
 from ddeutil.io.models.lineage import dt_now
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 from pydantic.functional_validators import model_validator
 from typing_extensions import Self
 
 from .__types import DictData, Matrix, Re
+from .exceptions import ParamValueException, UtilException
+
+
+def get_diff_sec(dt: datetime, tz: ZoneInfo | None = None) -> int:
+    """Return second value that come from diff of an input datetime and the
+    current datetime with specific timezone.
+    """
+    return round(
+        (dt - datetime.now(tz=(tz or ZoneInfo("UTC")))).total_seconds()
+    )
 
 
 class Engine(BaseModel):
@@ -35,9 +47,10 @@ class Engine(BaseModel):
 
     paths: PathData = Field(default_factory=PathData)
     registry: list[str] = Field(
-        default_factory=lambda: [
-            "ddeutil.workflow",
-        ],
+        default_factory=lambda: ["ddeutil.workflow"],
+    )
+    registry_filter: list[str] = Field(
+        default=lambda: ["ddeutil.workflow.utils"]
     )
 
     @model_validator(mode="before")
@@ -47,9 +60,21 @@ class Engine(BaseModel):
         """
         if (_regis := values.get("registry")) and isinstance(_regis, str):
             values["registry"] = [_regis]
+        if (_regis_filter := values.get("registry_filter")) and isinstance(
+            _regis, str
+        ):
+            values["registry_filter"] = [_regis_filter]
         return values
 
 
+class CoreConf(BaseModel):
+    """Core Config Model"""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    tz: ZoneInfo = Field(default_factory=lambda: ZoneInfo("UTC"))
+
+
 class ConfParams(BaseModel):
     """Params Model"""
 
@@ -57,16 +82,24 @@ class ConfParams(BaseModel):
         default_factory=Engine,
         description="A engine mapping values.",
     )
+    core: CoreConf = Field(
+        default_factory=CoreConf,
+        description="A core config value",
+    )
 
 
 def config() -> ConfParams:
     """Load Config data from ``workflows-conf.yaml`` file."""
     root_path: str = os.getenv("WORKFLOW_ROOT_PATH", ".")
 
-    regis: list[str] = []
+    regis: list[str] = ["ddeutil.workflow"]
     if regis_env := os.getenv("WORKFLOW_CORE_REGISTRY"):
         regis = [r.strip() for r in regis_env.split(",")]
 
+    regis_filter: list[str] = ["ddeutil.workflow.utils"]
+    if regis_filter_env := os.getenv("WORKFLOW_CORE_REGISTRY_FILTER"):
+        regis_filter = [r.strip() for r in regis_filter_env.split(",")]
+
     conf_path: str = (
         f"{root_path}/{conf_env}"
         if (conf_env := os.getenv("WORKFLOW_CORE_PATH_CONF"))
@@ -76,6 +109,7 @@ def config() -> ConfParams:
         obj={
             "engine": {
                 "registry": regis,
+                "registry_filter": regis_filter,
                 "paths": {
                     "root": root_path,
                     "conf": conf_path,
@@ -115,24 +149,24 @@ class TagFunc(Protocol):
     def __call__(self, *args, **kwargs): ...
 
 
-def tag(value: str, name: str | None = None):
+def tag(name: str, alias: str | None = None):
     """Tag decorator function that set function attributes, ``tag`` and ``name``
     for making registries variable.
 
-    :param: value: A tag value for make different use-case of a function.
-    :param: name: A name that keeping in registries.
+    :param: name: A tag value 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__.
     """
 
-    def func_internal(func: callable) -> TagFunc:
-        func.tag = value
-        func.name = name or func.__name__.replace("_", "-")
+    def func_internal(func: Callable[[...], Any]) -> TagFunc:
+        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)
 
-        # TODO: pass result from a wrapped to Result model
-        #   >>> return Result.model_validate(obj=wrapped)
         return wrapped
 
     return func_internal
@@ -145,6 +179,7 @@ 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().engine.registry:
@@ -185,7 +220,7 @@ class BaseParam(BaseModel, ABC):
 
     @abstractmethod
     def receive(self, value: Optional[Any] = None) -> Any:
-        raise ValueError(
+        raise NotImplementedError(
             "Receive value and validate typing before return valid value."
         )
 
@@ -197,14 +232,14 @@ class DefaultParam(BaseParam):
 
     @abstractmethod
     def receive(self, value: Optional[Any] = None) -> Any:
-        raise ValueError(
+        raise NotImplementedError(
             "Receive value and validate typing before return valid value."
         )
 
     @model_validator(mode="after")
     def check_default(self) -> Self:
         if not self.required and self.default is None:
-            raise ValueError(
+            raise ParamValueException(
                 "Default should set when this parameter does not required."
             )
         return self
@@ -218,6 +253,7 @@ class DatetimeParam(DefaultParam):
     default: datetime = Field(default_factory=dt_now)
 
     def receive(self, value: str | datetime | date | None = None) -> datetime:
+        """Receive value that match with datetime."""
         if value is None:
             return self.default
 
@@ -226,7 +262,7 @@ class DatetimeParam(DefaultParam):
         elif isinstance(value, date):
             return datetime(value.year, value.month, value.day)
         elif not isinstance(value, str):
-            raise ValueError(
+            raise ParamValueException(
                 f"Value that want to convert to datetime does not support for "
                 f"type: {type(value)}"
             )
@@ -239,6 +275,7 @@ class StrParam(DefaultParam):
     type: Literal["str"] = "str"
 
     def receive(self, value: Optional[str] = None) -> str | None:
+        """Receive value that match with str."""
         if value is None:
             return self.default
         return str(value)
@@ -250,13 +287,14 @@ class IntParam(DefaultParam):
     type: Literal["int"] = "int"
 
     def receive(self, value: Optional[int] = None) -> int | None:
+        """Receive value that match with int."""
         if value is None:
             return self.default
         if not isinstance(value, int):
             try:
                 return int(str(value))
             except TypeError as err:
-                raise ValueError(
+                raise ParamValueException(
                     f"Value that want to convert to integer does not support "
                     f"for type: {type(value)}"
                 ) from err
@@ -264,6 +302,8 @@ class IntParam(DefaultParam):
 
 
 class ChoiceParam(BaseParam):
+    """Choice parameter."""
+
     type: Literal["choice"] = "choice"
     options: list[str]
 
@@ -274,13 +314,16 @@ class ChoiceParam(BaseParam):
         if value is None:
             return self.options[0]
         if any(value not in self.options):
-            raise ValueError(f"{value} does not match any value in options")
+            raise ParamValueException(
+                f"{value!r} does not match any value in choice options."
+            )
         return value
 
 
 Param = Union[
     ChoiceParam,
     DatetimeParam,
+    IntParam,
     StrParam,
 ]
 
@@ -291,6 +334,11 @@ class Result:
     the pipeline execution.
     """
 
+    # TODO: Add running ID to this result dataclass.
+    # ---
+    # parent_run_id: str
+    # run_id: str
+    #
     status: int = field(default=2)
     context: DictData = field(default_factory=dict)
 
@@ -301,11 +349,216 @@ def make_exec(path: str | Path):
     f.chmod(f.stat().st_mode | stat.S_IEXEC)
 
 
-def param2template(
+FILTERS: dict[str, callable] = {
+    "abs": abs,
+    "str": str,
+    "int": int,
+    "upper": lambda x: x.upper(),
+    "lower": lambda x: x.lower(),
+    "rstr": [str, repr],
+}
+
+
+class FilterFunc(Protocol):
+    """Tag Function Protocol"""
+
+    name: str
+
+    def __call__(self, *args, **kwargs): ...
+
+
+def custom_filter(name: str):
+    """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.
+    """
+
+    def func_internal(func: Callable[[...], Any]) -> TagFunc:
+        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().engine.registry_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."""
+    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 pipe"
+        )
+
+    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("Argument should be constant.")
+
+    return name.id, args, keywords
+
+
+@custom_filter("fmt")
+def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
+    return value.strftime(fmt)
+
+
+def map_post_filter(
     value: Any,
-    params: dict[str, Any],
+    post_filter: list[str],
+    filters: dict[str, FilterRegistry],
+) -> Any:
+    """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.
+    """
+    for _filter in post_filter:
+        func_name, _args, _kwargs = get_args_const(_filter)
+        args = [arg.value for arg in _args]
+        kwargs = {k: v.value for k, v in _kwargs.items()}
+
+        if func_name not in filters:
+            raise UtilException(
+                f"The post-filter: {func_name} does not support yet."
+            )
+
+        try:
+            if isinstance((f_func := filters[func_name]), list):
+                if args or kwargs:
+                    raise UtilException(
+                        "Chain filter function does not support for passing "
+                        "arguments."
+                    )
+                for func in f_func:
+                    value: Any = func(value)
+            else:
+                value: Any = f_func(value, *args, **kwargs)
+        except Exception as err:
+            logging.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 str2template(
+    value: str,
+    params: DictData,
     *,
-    repr_flag: bool = False,
+    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 pipeline 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.RE_CALLER.finditer(value):
+        # NOTE:
+        #   Get caller and filter values that setting inside;
+        #
+        #   ... ``${{ <caller-value> [ | <filter-value>] ... }}``
+        #
+        caller: str = found.group("caller")
+        pfilter: list[str] = [
+            i.strip()
+            for i in (
+                found.group("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.group(0), "", 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.group(0), 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.
@@ -313,47 +566,18 @@ def param2template(
     :param value: A value that want to mapped with an params
     :param params: A parameter value that getting with matched regular
         expression.
-    :param repr_flag: A repr flag for using repr instead of str if it set be
-        true.
 
     :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
-
-    if not Re.RE_CALLER.search(value):
-        return value
-
-    for found in Re.RE_CALLER.finditer(value):
-
-        # NOTE: get caller value that setting inside; ``${{ <caller-value> }}``
-        caller: str = found.group("caller")
-        if not hasdot(caller, params):
-            raise ValueError(f"params does not set caller: {caller!r}")
-
-        getter: Any = getdot(caller, params)
-
-        # NOTE: check type of vars
-        if isinstance(getter, (str, int)):
-            value: str = value.replace(
-                found.group(0), (repr(getter) if repr_flag else str(getter)), 1
-            )
-            continue
-
-        # NOTE:
-        #   If type of getter caller does not formatting, it will return origin
-        #   value from the ``getdot`` function.
-        if value.replace(found.group(0), "", 1) != "":
-            raise ValueError(
-                "Callable variable should not pass other outside ${{ ... }}"
-            )
-        return getter
-    return value
+    return str2template(value, params, filters=filters)
 
 
 def dash2underscore(
@@ -368,7 +592,7 @@ def dash2underscore(
     return values
 
 
-def cross_product(matrix: Matrix) -> Iterator:
+def cross_product(matrix: Matrix) -> Iterator[DictData]:
     """Iterator of products value from matrix."""
     yield from (
         {_k: _v for e in mapped for _k, _v in e.items()}

{ddeutil_workflow-0.0.6.dist-info → ddeutil_workflow-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddeutil-workflow
-Version: 0.0.6
+Version: 0.0.7
 Summary: Data Developer & Engineer Workflow Utility Objects
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -24,9 +24,12 @@ License-File: LICENSE
 Requires-Dist: fmtutil
 Requires-Dist: ddeutil-io
 Requires-Dist: python-dotenv ==1.0.1
+Provides-Extra: api
+Requires-Dist: fastapi[standard] ==0.112.0 ; extra == 'api'
+Requires-Dist: apscheduler[sqlalchemy] <4.0.0,==3.10.4 ; extra == 'api'
+Requires-Dist: croniter ==3.0.3 ; extra == 'api'
 Provides-Extra: app
-Requires-Dist: fastapi ==0.112.0 ; extra == 'app'
-Requires-Dist: apscheduler[sqlalchemy] ==3.10.4 ; extra == 'app'
+Requires-Dist: schedule <2.0.0,==1.2.2 ; extra == 'app'
 
 # Workflow
 
@@ -39,7 +42,6 @@ Requires-Dist: apscheduler[sqlalchemy] ==3.10.4 ; extra == 'app'
 
 - [Installation](#installation)
 - [Getting Started](#getting-started)
-- [Core Features](#core-features)
   - [On](#on)
   - [Pipeline](#pipeline)
 - [Usage](#usage)
@@ -50,12 +52,14 @@ Requires-Dist: apscheduler[sqlalchemy] ==3.10.4 ; extra == 'app'
 - [Deployment](#deployment)
 
 This **Workflow** objects was created for easy to make a simple metadata
-driven pipeline that able to **ETL, T, EL, or ELT** by `.yaml` file.
+driven for data pipeline orchestration that able to use for **ETL, T, EL, or
+ELT** by a `.yaml` file template.
 
-I think we should not create the multiple pipeline per use-case if we able to
-write some dynamic pipeline that just change the input parameters per use-case
-instead. This way we can handle a lot of pipelines in our orgs with metadata only.
-It called **Metadata Driven**.
+In my opinion, I think it should not create duplicate pipeline codes if I can
+write with dynamic input parameters on the one template pipeline that just change
+the input parameters per use-case instead.
+This way I can handle a lot of logical pipelines in our orgs with only metadata
+configuration. It called **Metadata Driven Data Pipeline**.
 
 Next, we should get some monitoring tools for manage logging that return from
 pipeline running. Because it not show us what is a use-case that running data
@@ -79,6 +83,10 @@ this package with application add-ons, you should add `app` in installation;
 pip install ddeutil-workflow[app]
 ```
 
+```shell
+pip install ddeutil-workflow[api]
+```
+
 ## Getting Started
 
 The first step, you should start create the connections and datasets for In and
@@ -240,6 +248,18 @@ pipe_el_pg_to_lake:
               endpoint: "/${{ params.name }}"
 ```
 
+Implement hook:
+
+```python
+from ddeutil.workflow.utils import tag
+
+@tag('polars', alias='postgres-to-delta')
+def postgres_to_delta(source, sink):
+    return {
+        "source": source, "sink": sink
+    }
+```
+
 ### Hook (Transform)
 
 ```yaml
@@ -265,12 +285,30 @@ pipeline_hook_mssql_proc:
               target: ${{ params.target_name }}
 ```
 
+Implement hook:
+
+```python
+from ddeutil.workflow.utils import tag
+
+@tag('odbc', alias='mssql-proc')
+def odbc_mssql_procedure(_exec: str, params: dict):
+    return {
+        "exec": _exec, "params": params
+    }
+```
+
 ## Configuration
 
 ```bash
 export WORKFLOW_ROOT_PATH=.
 export WORKFLOW_CORE_REGISTRY=ddeutil.workflow,tests.utils
+export WORKFLOW_CORE_REGISTRY_FILTER=ddeutil.workflow.utils
 export WORKFLOW_CORE_PATH_CONF=conf
+export WORKFLOW_CORE_TIMEZONE=Asia/Bangkok
+export WORKFLOW_CORE_DEFAULT_STAGE_ID=true
+
+export WORKFLOW_CORE_MAX_PIPELINE_POKING=4
+export WORKFLOW_CORE_MAX_JOB_PARALLEL=2
 ```
 
 Application config:
@@ -283,12 +321,21 @@ export WORKFLOW_APP_INTERVAL=10
 ## Deployment
 
 This package able to run as a application service for receive manual trigger
-from the master node via RestAPI.
+from the master node via RestAPI or use to be Scheduler background service
+like crontab job but via Python API.
+
+### Schedule Service
 
-> [!WARNING]
-> This feature do not start yet because I still research and find the best tool
-> to use it provision an app service, like `starlette`, `fastapi`, `apscheduler`.
+```shell
+(venv) $ python src.ddeutil.workflow.app
+```
+
+### API Server
 
 ```shell
-(venv) $ workflow start -p 7070
+(venv) $ uvicorn src.ddeutil.workflow.api:app --host 0.0.0.0 --port 80 --reload
 ```
+
+> [!NOTE]
+> If this package already deploy, it able to use
+> `uvicorn ddeutil.workflow.api:app --host 0.0.0.0 --port 80`

ddeutil_workflow-0.0.7.dist-info/RECORD

@@ -0,0 +1,20 @@
+ddeutil/workflow/__about__.py,sha256=b23XabBwtuoPOLmS_Hj_gSA4LZ0fRfAkACM6c3szVoc,27
+ddeutil/workflow/__init__.py,sha256=4PEL3RdHmUowK0Dz-tK7fO0wvFX4u9CLd0Up7b3lrAQ,760
+ddeutil/workflow/__types.py,sha256=SYMoxbENQX8uPsiCZkjtpHAqqHOh8rUrarAFicAJd0E,1773
+ddeutil/workflow/api.py,sha256=d2Mmv9jTtN3FITIy-2mivyAKdBOGZxtkNWRMPbCLlFI,3341
+ddeutil/workflow/app.py,sha256=GbdwvUkE8lO2Ze4pZ0-J-7p9mcZAaORfjkHwW_oZIP0,1076
+ddeutil/workflow/exceptions.py,sha256=BH7COn_3uz3z7oJBZOQGiuo8osBFgeXL8HYymnjCOPQ,671
+ddeutil/workflow/loader.py,sha256=_ZD-XP5P7VbUeqItrUVPaKIZu6dMUZ2aywbCbReW1hQ,2778
+ddeutil/workflow/log.py,sha256=_GJEdJr7bqpcQDxZjrqHd-hkiW3NKFaVoR6voE6Ty0o,952
+ddeutil/workflow/on.py,sha256=YoEqDbzJUwqOA3JRltbvlYr0rNTtxdmb7cWMxl8U19k,6717
+ddeutil/workflow/pipeline.py,sha256=dKF09TFS_v5TCD-5o8tp1UhB5sGuWIQu4zl_UFtlIC0,25951
+ddeutil/workflow/repeat.py,sha256=sNoRfbOR4cYm_edrSvlVy9N8Dk_osLIq9FC5GMZz32M,4621
+ddeutil/workflow/route.py,sha256=Ck_O1xJwI-vKkMJr37El0-1PGKlwKF8__DDNWVQrf0A,2079
+ddeutil/workflow/scheduler.py,sha256=FqmkvWCqwJ4eRf8aDn5Ce4FcNWqmcvu2aTTfL34lfgs,22184
+ddeutil/workflow/stage.py,sha256=z05bKk2QFQDXjidSnQYCVOdceSpSO13sHXE0B1UH6XA,14978
+ddeutil/workflow/utils.py,sha256=pDM2jaYVP-USH0pLd_XmHOguxVPGVzZ76hOh1AZdINU,18495
+ddeutil_workflow-0.0.7.dist-info/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.7.dist-info/METADATA,sha256=ba2nH57cpHB2P4ldQCRT8ZWDj3r1OPx9a1dgcB0a2Ws,9702
+ddeutil_workflow-0.0.7.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+ddeutil_workflow-0.0.7.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.7.dist-info/RECORD,,

{ddeutil_workflow-0.0.6.dist-info → ddeutil_workflow-0.0.7.dist-info}/WHEEL

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