ddeutil-workflow 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

ddeutil/workflow/utils.py

@@ -9,29 +9,42 @@ import inspect
 import logging
 import os
 import stat
+import time
 from abc import ABC, abstractmethod
 from ast import Call, Constant, Expr, Module, Name, parse
 from collections.abc import Iterator
 from datetime import date, datetime
-from functools import wraps
+from functools import cached_property, wraps
 from hashlib import md5
 from importlib import import_module
 from inspect import isfunction
-from itertools import product
+from itertools import chain, islice, product
 from pathlib import Path
-from typing import Any, Callable, Literal, Optional, Protocol, Union
+from random import randrange
+from typing import Any, Callable, Literal, Optional, Protocol, TypeVar, Union
 from zoneinfo import ZoneInfo
 
+try:
+    from typing import ParamSpec
+except ImportError:
+    from typing_extensions import ParamSpec
+
 from ddeutil.core import getdot, hasdot, hash_str, import_string, lazy, str2bool
-from ddeutil.io import PathData, search_env_replace
+from ddeutil.io import PathData, PathSearch, YamlFlResolve, search_env_replace
 from ddeutil.io.models.lineage import dt_now
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
+from pydantic.functional_serializers import field_serializer
 from pydantic.functional_validators import model_validator
 from typing_extensions import Self
 
 from .__types import DictData, Matrix, Re
 from .exceptions import ParamValueException, UtilException
 
+logger = logging.getLogger("ddeutil.workflow")
+P = ParamSpec("P")
+AnyModel = TypeVar("AnyModel", bound=BaseModel)
+AnyModelType = type[AnyModel]
+
 
 def get_diff_sec(dt: datetime, tz: ZoneInfo | None = None) -> int:
     """Return second value that come from diff of an input datetime and the
@@ -42,6 +55,15 @@ def get_diff_sec(dt: datetime, tz: ZoneInfo | None = None) -> int:
     )
 
 
+def delay(second: float = 0) -> None:
+    """Delay time that use time.sleep with random second value between
+    0.00 - 0.99 seconds.
+
+    :param second: A second number that want to adds-on random value.
+    """
+    time.sleep(second + randrange(0, 99, step=10) / 100)
+
+
 class Engine(BaseModel):
     """Engine Model"""
 
@@ -127,6 +149,112 @@ def config() -> ConfParams:
     )
 
 
+class SimLoad:
+    """Simple Load Object that will search config data by given some identity
+    value like name of pipeline or on.
+
+    :param name: A name of config data that will read by Yaml Loader object.
+    :param params: A Params model object.
+    :param externals: An external parameters
+
+    Noted:
+    ---
+        The config data should have ``type`` key for modeling validation that
+    make this loader know what is config should to do pass to.
+
+        ... <identity-key>:
+        ...     type: <importable-object>
+        ...     <key-data>: <value-data>
+        ...     ...
+
+    """
+
+    def __init__(
+        self,
+        name: str,
+        params: ConfParams,
+        externals: DictData | None = None,
+    ) -> None:
+        self.data: DictData = {}
+        for file in PathSearch(params.engine.paths.conf).files:
+            if any(file.suffix.endswith(s) for s in (".yml", ".yaml")) and (
+                data := YamlFlResolve(file).read().get(name, {})
+            ):
+                self.data = data
+
+        # VALIDATE: check the data that reading should not empty.
+        if not self.data:
+            raise ValueError(f"Config {name!r} does not found on conf path")
+
+        self.conf_params: ConfParams = params
+        self.externals: DictData = externals or {}
+        self.data.update(self.externals)
+
+    @classmethod
+    def finds(
+        cls,
+        obj: object,
+        params: ConfParams,
+        *,
+        include: list[str] | None = None,
+        exclude: list[str] | None = None,
+    ) -> Iterator[tuple[str, DictData]]:
+        """Find all data that match with object type in config path. This class
+        method can use include and exclude list of identity name for filter and
+        adds-on.
+        """
+        exclude: list[str] = exclude or []
+        for file in PathSearch(params.engine.paths.conf).files:
+            if any(file.suffix.endswith(s) for s in (".yml", ".yaml")) and (
+                values := YamlFlResolve(file).read()
+            ):
+                for key, data in values.items():
+                    if key in exclude:
+                        continue
+                    if issubclass(get_type(data["type"], params), obj) and (
+                        include is None or all(i in data for i in include)
+                    ):
+                        yield key, data
+
+    @cached_property
+    def type(self) -> AnyModelType:
+        """Return object of string type which implement on any registry. The
+        object type.
+
+        :rtype: AnyModelType
+        """
+        if not (_typ := self.data.get("type")):
+            raise ValueError(
+                f"the 'type' value: {_typ} does not exists in config data."
+            )
+        return get_type(_typ, self.conf_params)
+
+
+class Loader(SimLoad):
+    """Loader Object that get the config `yaml` file from current path.
+
+    :param name: A name of config data that will read by Yaml Loader object.
+    :param externals: An external parameters
+    """
+
+    @classmethod
+    def finds(
+        cls,
+        obj: object,
+        *,
+        include: list[str] | None = None,
+        exclude: list[str] | None = None,
+        **kwargs,
+    ) -> DictData:
+        """Override the find class method from the Simple Loader object."""
+        return super().finds(
+            obj=obj, params=config(), include=include, exclude=exclude
+        )
+
+    def __init__(self, name: str, externals: DictData) -> None:
+        super().__init__(name, config(), externals)
+
+
 def gen_id(
     value: Any,
     *,
@@ -160,6 +288,26 @@ def gen_id(
     ).hexdigest()
 
 
+def get_type(t: str, params: ConfParams) -> AnyModelType:
+    """Return import type from string importable value in the type key.
+
+    :param t: A importable type string.
+    :param params: A config parameters that use registry to search this
+        type.
+    :rtype: AnyModelType
+    """
+    try:
+        # NOTE: Auto adding module prefix if it does not set
+        return import_string(f"ddeutil.workflow.{t}")
+    except ModuleNotFoundError:
+        for registry in params.engine.registry:
+            try:
+                return import_string(f"{registry}.{t}")
+            except ModuleNotFoundError:
+                continue
+        return import_string(f"{t}")
+
+
 class TagFunc(Protocol):
     """Tag Function Protocol"""
 
@@ -244,6 +392,10 @@ class BaseParam(BaseModel, ABC):
             "Receive value and validate typing before return valid value."
         )
 
+    @field_serializer("type")
+    def __serializer_type(self, value: str) -> str:
+        return value
+
 
 class DefaultParam(BaseParam):
     """Default Parameter that will check default if it required"""
@@ -257,7 +409,8 @@ class DefaultParam(BaseParam):
         )
 
     @model_validator(mode="after")
-    def check_default(self) -> Self:
+    def __check_default(self) -> Self:
+        """Check default value should pass when it set required."""
         if not self.required and self.default is None:
             raise ParamValueException(
                 "Default should set when this parameter does not required."
@@ -273,7 +426,13 @@ 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."""
+        """Receive value that match with datetime. If a input value pass with
+        None, it will use default value instead.
+
+        :param value: A value that want to validate with datetime parameter
+            type.
+        :rtype: datetime
+        """
         if value is None:
             return self.default
 
@@ -295,7 +454,11 @@ class StrParam(DefaultParam):
     type: Literal["str"] = "str"
 
     def receive(self, value: Optional[str] = None) -> str | None:
-        """Receive value that match with str."""
+        """Receive value that match with str.
+
+        :param value: A value that want to validate with string parameter type.
+        :rtype: str | None
+        """
         if value is None:
             return self.default
         return str(value)
@@ -307,7 +470,11 @@ class IntParam(DefaultParam):
     type: Literal["int"] = "int"
 
     def receive(self, value: Optional[int] = None) -> int | None:
-        """Receive value that match with int."""
+        """Receive value that match with int.
+
+        :param value: A value that want to validate with integer parameter type.
+        :rtype: int | None
+        """
         if value is None:
             return self.default
         if not isinstance(value, int):
@@ -348,57 +515,57 @@ Param = Union[
 ]
 
 
-class Context(BaseModel):
-    """Context Pydantic Model"""
-
-    params: dict = Field(default_factory=dict)
-    jobs: dict = Field(default_factory=dict)
-    error: dict = Field(default_factory=dict)
-
-
 class Result(BaseModel):
     """Result Pydantic Model for passing parameter and receiving output from
     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)
 
+    # NOTE: Ignore this field to compare another result model with __eq__.
+    _parent_run_id: Optional[str] = PrivateAttr(default=None)
+    _run_id: Optional[str] = PrivateAttr(default=None)
+
+    @model_validator(mode="after")
+    def __prepare_run_id(self):
+        if self._run_id is None:
+            self._run_id = gen_id("manual", unique=True)
+        return self
+
+    def set_run_id(self, running_id: str) -> Self:
+        self._run_id = running_id
+        return self
+
+    def set_parent_run_id(self, running_id: str) -> Self:
+        self._parent_run_id = running_id
+        return self
+
+    @property
+    def parent_run_id(self):
+        return self._parent_run_id
+
+    @property
+    def run_id(self):
+        return self._run_id
+
     def receive(self, result: Result) -> Result:
         self.__dict__["status"] = result.status
         self.__dict__["context"].update(result.context)
+        self._parent_run_id = result.parent_run_id
+        self._run_id = result.run_id
         return self
 
     def receive_jobs(self, result: Result) -> Result:
         self.__dict__["status"] = result.status
+
+        # NOTE: Check the context has jobs key.
         if "jobs" not in self.__dict__["context"]:
             self.__dict__["context"]["jobs"] = {}
-        self.__dict__["context"]["jobs"].update(result.context)
-        return self
-
 
-class ReResult(BaseModel):
-    """Result Pydantic Model for passing parameter and receiving output from
-    the pipeline execution.
-    """
-
-    # TODO: Add running ID to this result dataclass.
-    # ---
-    # parent_run_id: str
-    # run_id: str
-    #
-    status: int = Field(default=2)
-    context: Context = Field(default_factory=Context)
-
-    def receive(self, result: ReResult) -> ReResult:
-        self.__dict__["status"] = result.status
-        self.__dict__["context"].__dict__["jobs"].update(result.context.jobs)
-        self.__dict__["context"].__dict__["error"].update(result.context.error)
+        self.__dict__["context"]["jobs"].update(result.context)
+        self._parent_run_id = result.parent_run_id
+        self._run_id = result.run_id
         return self
 
 
@@ -426,7 +593,7 @@ class FilterFunc(Protocol):
     def __call__(self, *args, **kwargs): ...
 
 
-def custom_filter(name: str):
+def custom_filter(name: str) -> Callable[P, TagFunc]:
     """Custom filter decorator function that set function attributes, ``filter``
     for making filter registries variable.
 
@@ -511,7 +678,11 @@ def get_args_const(
 
 @custom_filter("fmt")
 def datetime_format(value: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
-    return value.strftime(fmt)
+    if isinstance(value, datetime):
+        return value.strftime(fmt)
+    raise UtilException(
+        "This custom function should pass input value with datetime type."
+    )
 
 
 def map_post_filter(
@@ -548,7 +719,7 @@ def map_post_filter(
             else:
                 value: Any = f_func(value, *args, **kwargs)
         except Exception as err:
-            logging.warning(str(err))
+            logger.warning(str(err))
             raise UtilException(
                 f"The post-filter function: {func_name} does not fit with "
                 f"{value} (type: {type(value).__name__})."
@@ -556,6 +727,40 @@ def map_post_filter(
     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:
+    :param not_in:
+    :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.group("caller").strip().startswith(not_in))
+        for found in Re.RE_CALLER.finditer(value.strip())
+    )
+
+
+def has_template(value: Any) -> bool:
+    """Check value include templating string.
+
+    :param value:
+    :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,
@@ -639,7 +844,7 @@ def param2template(
     return str2template(value, params, filters=filters)
 
 
-def filter_func(value: Any):
+def filter_func(value: Any) -> Any:
     """Filter own created function out of any value with replace it to its
     function name. If it is built-in function, it does not have any changing.
     """
@@ -678,3 +883,25 @@ def cross_product(matrix: Matrix) -> Iterator[DictData]:
             *[[{k: v} for v in vs] for k, vs in matrix.items()]
         )
     )
+
+
+def batch(iterable: Iterator[Any], n: int) -> Iterator[Any]:
+    """Batch data into iterators of length n. The last batch may be shorter.
+
+    Example:
+        >>> for b in batch('ABCDEFG', 3):
+        ...     print(list(b))
+        ['A', 'B', 'C']
+        ['D', 'E', 'F']
+        ['G']
+    """
+    if n < 1:
+        raise ValueError("n must be at least one")
+    it = iter(iterable)
+    while True:
+        chunk_it = islice(it, n)
+        try:
+            first_el = next(chunk_it)
+        except StopIteration:
+            return
+        yield chain((first_el,), chunk_it)

ddeutil_workflow-0.0.10.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.1
+Name: ddeutil-workflow
+Version: 0.0.10
+Summary: Lightweight workflow orchestration with less dependencies
+Author-email: ddeutils <korawich.anu@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ddeutils/ddeutil-workflow/
+Project-URL: Source Code, https://github.com/ddeutils/ddeutil-workflow/
+Keywords: orchestration,workflow
+Classifier: Topic :: Utilities
+Classifier: Natural Language :: English
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ddeutil-io
+Requires-Dist: python-dotenv ==1.0.1
+Requires-Dist: typer <1.0.0,==0.12.5
+Provides-Extra: api
+Requires-Dist: fastapi[standard] <1.0.0,==0.112.2 ; extra == 'api'
+Provides-Extra: schedule
+Requires-Dist: schedule <2.0.0,==1.2.2 ; extra == 'schedule'
+
+# Workflow
+
+[![test](https://github.com/ddeutils/ddeutil-workflow/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/ddeutils/ddeutil-workflow/actions/workflows/tests.yml)
+[![python support version](https://img.shields.io/pypi/pyversions/ddeutil-workflow)](https://pypi.org/project/ddeutil-workflow/)
+[![size](https://img.shields.io/github/languages/code-size/ddeutils/ddeutil-workflow)](https://github.com/ddeutils/ddeutil-workflow)
+[![gh license](https://img.shields.io/github/license/ddeutils/ddeutil-workflow)](https://github.com/ddeutils/ddeutil-workflow/blob/main/LICENSE)
+[![code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+The **Lightweight workflow orchestration** with less dependencies the was created
+for easy to make a simple metadata driven for data pipeline orchestration.
+It can to use for data operator by a `.yaml` template.
+
+> [!WARNING]
+> This package provide only orchestration workload. That mean you should not use
+> workflow stage to process any large data which use lot of compute usecase.
+
+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
+pipeline.
+
+> [!NOTE]
+> _Disclaimer_: I inspire the dynamic statement from the GitHub Action `.yml` files
+> and all of config file from several data orchestration framework tools from my
+> experience on Data Engineer.
+
+**Rules of This Workflow engine**:
+
+1. Minimum unit of scheduling is 1 minute
+2. Cannot re-run only failed stage and its pending downstream
+3. All parallel tasks inside workflow engine use Threading
+   (Because Python 3.13 unlock GIL)
+
+## Installation
+
+This project need `ddeutil-io` extension namespace packages. If you want to install
+this package with application add-ons, you should add `app` in installation;
+
+| Usecase           | Install Optional                         | Support            |
+|-------------------|------------------------------------------|--------------------|
+| Python & CLI      | `pip install ddeutil-workflow`           | :heavy_check_mark: |
+| Scheduler Service | `pip install ddeutil-workflow[schedule]` | :x:                |
+| FastAPI Server    | `pip install ddeutil-workflow[api]`      | :x:                |
+
+
+> I added this feature to the main milestone.
+>
+> **Docker Images** supported:
+>
+> | Docker Image                | Python Version | Support |
+> |-----------------------------|----------------|---------|
+> | ddeutil-workflow:latest     | `3.9`          | :x:     |
+> | ddeutil-workflow:python3.10 | `3.10`         | :x:     |
+> | ddeutil-workflow:python3.11 | `3.11`         | :x:     |
+> | ddeutil-workflow:python3.12 | `3.12`         | :x:     |
+
+## Usage
+
+This is examples that use workflow file for running common Data Engineering
+use-case.
+
+> [!IMPORTANT]
+> I recommend you to use the `hook` stage for all actions that you want to do
+> with pipeline activity that you want to orchestrate. Because it able to dynamic
+> an input argument with the same hook function that make you use less time to
+> maintenance your data pipelines.
+
+```yaml
+run_py_local:
+  type: pipeline.Pipeline
+  on:
+    - cronjob: '*/5 * * * *'
+      timezone: "Asia/Bangkok"
+  params:
+    author-run: str
+    run-date: datetime
+  jobs:
+    getting-api-data:
+      stages:
+        - name: "Retrieve API Data"
+          id: retrieve-api
+          uses: tasks/get-api-with-oauth-to-s3@requests
+          with:
+            url: https://open-data/
+            auth: ${API_ACCESS_REFRESH_TOKEN}
+            aws_s3_path: my-data/open-data/
+
+            # This Authentication code should implement with your custom hook function.
+            # The template allow you to use environment variable.
+            aws_access_client_id: ${AWS_ACCESS_CLIENT_ID}
+            aws_access_client_secret: ${AWS_ACCESS_CLIENT_SECRET}
+```
+
+## Configuration
+
+| Environment                         | Component | Default                      | Description                                                                |
+|-------------------------------------|-----------|------------------------------|----------------------------------------------------------------------------|
+| `WORKFLOW_ROOT_PATH`                | Core      | .                            | The root path of the workflow application                                  |
+| `WORKFLOW_CORE_REGISTRY`            | Core      | ddeutil.workflow,tests.utils | 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      | true                         | A flag that all stage raise StageException from stage execution            |
+| `WORKFLOW_CORE_MAX_PIPELINE_POKING` | Core      | 4                            |                                                                            |
+| `WORKFLOW_CORE_MAX_JOB_PARALLEL`    | Core      | 2                            | The maximum job number that able to run parallel in pipeline executor      |
+| `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            |
+
+
+**Application**:
+
+| Environment                         | Default                          | Description                                                             |
+|-------------------------------------|----------------------------------|-------------------------------------------------------------------------|
+| `WORKFLOW_APP_PROCESS_WORKER`       | 2                                | The maximum process worker number that run in scheduler app module      |
+| `WORKFLOW_APP_SCHEDULE_PER_PROCESS` | 100                              | A schedule per process that run parallel                                |
+| `WORKFLOW_APP_STOP_BOUNDARY_DELTA`  | '{"minutes": 5, "seconds": 20}'  | A time delta value that use to stop scheduler app in json string format |
+
+**API server**:
+
+| Environment                          | Default | Description                                                                       |
+|--------------------------------------|---------|-----------------------------------------------------------------------------------|
+| `WORKFLOW_API_ENABLE_ROUTE_WORKFLOW` | true    | A flag that enable workflow route to manage execute manually and workflow logging |
+| `WORKFLOW_API_ENABLE_ROUTE_SCHEDULE` | true    | A flag that enable run scheduler                                                  |
+
+## Deployment
+
+This package able to run as a application service for receive manual trigger
+from the master node via RestAPI or use to be Scheduler background service
+like crontab job but via Python API.
+
+### Schedule Service
+
+```shell
+(venv) $ python src.ddeutil.workflow.app
+```
+
+### API Server
+
+```shell
+(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 --workers 4`

ddeutil_workflow-0.0.10.dist-info/RECORD

@@ -0,0 +1,21 @@
+ddeutil/workflow/__about__.py,sha256=KJfEGSDA5LiPvdupul6ulxozLD2x2GhgUvq8t60EXsI,28
+ddeutil/workflow/__init__.py,sha256=oGvg_BpKKb_FG76DlMvXTKD7BsYhqF9wB1r4x5Q_lQI,647
+ddeutil/workflow/__types.py,sha256=SYMoxbENQX8uPsiCZkjtpHAqqHOh8rUrarAFicAJd0E,1773
+ddeutil/workflow/api.py,sha256=WHgmjvnnkM4djwHt4bsAqsQjjcjAITRSrNrYYO6bgn8,2582
+ddeutil/workflow/cli.py,sha256=snJCM-LAqvWwhkSB-3KRWwcgbHAkHn4cZ_DtmfOL5gs,3360
+ddeutil/workflow/cron.py,sha256=uhp3E5pl_tX_H88bsDujcwdhZmOE53csyV-ouPpPdK8,25321
+ddeutil/workflow/exceptions.py,sha256=UHojJQmnG9OVuRhXBAzDW6KZn-uKxvxV034QhUBUzUI,686
+ddeutil/workflow/log.py,sha256=a5L5KWEGS5oiY_y6jugeAoRyAcnAhlt1HfeTU77YeI4,6036
+ddeutil/workflow/on.py,sha256=Sxwnu0vPbIrMR_WWvH3_rOvD0tbiJntcB5378WoV19M,7163
+ddeutil/workflow/pipeline.py,sha256=lPw9R3gOnBcU2eogClG8b4e4rTvpn5EbACLNZDuuR38,40825
+ddeutil/workflow/repeat.py,sha256=0O8voTRB8lNMWsk1AbOYcio_b2_CW98yrfiEzNBb6gA,4954
+ddeutil/workflow/route.py,sha256=pcn_oDzc2nl6txFhu_TWAnntLggEOFV9A3EVdnazcHI,2597
+ddeutil/workflow/scheduler.py,sha256=Vu9FZbiHDnshQ2O1SnkVX686eSfaZzip-1oQohfuH_Y,20140
+ddeutil/workflow/stage.py,sha256=XZEPImipk83kNX9UHrwu7wWUBigXZpEkWqagOG0oS70,20656
+ddeutil/workflow/utils.py,sha256=ehIcT_fIQL8N0wU16VJDKAFN9q4h1FyMxyT5uTeMIA0,28561
+ddeutil_workflow-0.0.10.dist-info/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.10.dist-info/METADATA,sha256=7jdDYS2WtaZFpwUCo4ur8NAFWyi-omELh8YLB3EL9ok,9433
+ddeutil_workflow-0.0.10.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+ddeutil_workflow-0.0.10.dist-info/entry_points.txt,sha256=0BVOgO3LdUdXVZ-CiHHDKxzEk2c8J30jEwHeKn2YCWI,62
+ddeutil_workflow-0.0.10.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.10.dist-info/RECORD,,

{ddeutil_workflow-0.0.8.dist-info → ddeutil_workflow-0.0.10.dist-info}/WHEEL

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

ddeutil_workflow-0.0.10.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ddeutil-workflow = ddeutil.workflow.cli:cli