ddeutil-workflow 0.0.69__py3-none-any.whl → 0.0.70__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.69"
+__version__: str = "0.0.70"

ddeutil/workflow/cli.py

@@ -1,17 +1,21 @@
 import json
 from pathlib import Path
 from platform import python_version
-from typing import Annotated, Any, Optional
+from typing import Annotated, Any, Literal, Optional, Union
 
 import typer
 import uvicorn
+from pydantic import Field, TypeAdapter
 
 from .__about__ import __version__
 from .__types import DictData
 from .api import app as fastapp
 from .errors import JobError
+from .event import Crontab
 from .job import Job
+from .params import Param
 from .result import Result
+from .workflow import Workflow
 
 app = typer.Typer(
     pretty_exceptions_enable=True,
@@ -129,5 +133,51 @@ def workflow_execute():
     """"""
 
 
+WORKFLOW_TYPE = Literal["Workflow"]
+
+
+class WorkflowSchema(Workflow):
+    """Override workflow model fields for generate JSON schema file."""
+
+    type: WORKFLOW_TYPE = Field(description="A type of workflow template.")
+    name: Optional[str] = Field(default=None, description="A workflow name.")
+    params: dict[str, Union[Param, str]] = Field(
+        default_factory=dict,
+        description="A parameters that need to use on this workflow.",
+    )
+    on: Union[list[Union[Crontab, str]], str] = Field(
+        default_factory=list,
+        description="A list of Crontab instance for this workflow schedule.",
+    )
+
+
+CRONTAB_TYPE = Literal["Crontab"]
+
+
+class CrontabSchema(Crontab):
+    """Override crontab model fields for generate JSON schema file."""
+
+    type: CRONTAB_TYPE = Field(description="A type of crontab template.")
+
+
+@workflow_app.command(name="json-schema")
+def workflow_json_schema(
+    output: Annotated[
+        Path,
+        typer.Option(help="An output file to export the JSON schema."),
+    ] = Path("./json-schema.json"),
+) -> None:
+    """Generate JSON schema file from the Workflow model."""
+    template = dict[str, Union[WorkflowSchema, CrontabSchema]]
+    json_schema = TypeAdapter(template).json_schema(by_alias=True)
+    template_schema: dict[str, str] = {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "title": "Workflow Configuration Schema",
+        "version": "1.0.0",
+    }
+    with open(output, mode="w", encoding="utf-8") as f:
+        json.dump(template_schema | json_schema, f, indent=2)
+
+
 if __name__ == "__main__":
     app()

ddeutil/workflow/conf.py

@@ -327,13 +327,13 @@ class YamlParser:
         *,
         ignore_filename: Optional[str] = None,
     ) -> bool:
-        """Check this file was ignored.
+        """Check this file was ignored from the `.confignore` format.
 
         :param file: (Path) A file path that want to check.
         :param path: (Path) A config path that want to read the config
             ignore file.
         :param ignore_filename: (str) An ignore filename. Default is
-            `.confignore` filename.
+            ``.confignore`` filename.
 
         :rtype: bool
         """

ddeutil/workflow/errors.py

@@ -38,8 +38,14 @@ def to_dict(exception: Exception, **kwargs) -> ErrorData:  # pragma: no cov
 
 
 class BaseError(Exception):
-    """Base Workflow exception class will implement the `refs` argument for
+    """Base Workflow exception class will implement the ``refs`` argument for
     making an error context to the result context.
+
+    Attributes:
+        refs: (:obj:str, optional)
+        context: (:obj:DictData)
+        params: (:obj:DictData)
+
     """
 
     def __init__(

ddeutil/workflow/job.py

@@ -402,13 +402,19 @@ class Job(BaseModel):
         """
         # VALIDATE: Validate stage id should not duplicate.
         rs: list[str] = []
+        rs_raise: list[str] = []
         for stage in value:
             name: str = stage.iden
             if name in rs:
-                raise ValueError(
-                    f"Stage name, {name!r}, should not be duplicate."
-                )
+                rs_raise.append(name)
+                continue
             rs.append(name)
+
+        if rs_raise:
+            raise ValueError(
+                f"Stage name, {', '.join(repr(s) for s in rs_raise)}, should "
+                f"not be duplicate."
+            )
         return value
 
     @model_validator(mode="after")

ddeutil/workflow/reusables.py

@@ -44,7 +44,7 @@ from .errors import UtilError
 T = TypeVar("T")
 P = ParamSpec("P")
 
-# NOTE: Adjust logging level of the `asyncio` to INFO level.
+# NOTE: Adjust logging level of the ``asyncio`` to INFO level.
 logging.getLogger("asyncio").setLevel(logging.INFO)
 
 

ddeutil/workflow/traces.py

@@ -333,6 +333,124 @@ class BaseTrace(BaseModel, ABC):  # pragma: no cov
             "Adjust make message method for this trace object before using."
         )
 
+    @abstractmethod
+    def _logging(
+        self,
+        message: str,
+        mode: str,
+        *,
+        is_err: bool = False,
+    ):
+        """Write trace log with append mode and logging this message with any
+        logging level.
+
+        :param message: (str) A message that want to log.
+        :param mode: (str)
+        :param is_err: (bool)
+        """
+        raise NotImplementedError(
+            "Logging action should be implement for making trace log."
+        )
+
+    def debug(self, message: str):
+        """Write trace log with append mode and logging this message with the
+        DEBUG level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="debug")
+
+    def info(self, message: str) -> None:
+        """Write trace log with append mode and logging this message with the
+        INFO level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="info")
+
+    def warning(self, message: str) -> None:
+        """Write trace log with append mode and logging this message with the
+        WARNING level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="warning")
+
+    def error(self, message: str) -> None:
+        """Write trace log with append mode and logging this message with the
+        ERROR level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="error", is_err=True)
+
+    def exception(self, message: str) -> None:
+        """Write trace log with append mode and logging this message with the
+        EXCEPTION level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="exception", is_err=True)
+
+    @abstractmethod
+    async def _alogging(
+        self,
+        message: str,
+        mode: str,
+        *,
+        is_err: bool = False,
+    ) -> None:
+        """Async write trace log with append mode and logging this message with
+        any logging level.
+
+        :param message: (str) A message that want to log.
+        :param mode: (str)
+        :param is_err: (bool)
+        """
+        raise NotImplementedError(
+            "Async Logging action should be implement for making trace log."
+        )
+
+    async def adebug(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the DEBUG level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="debug")
+
+    async def ainfo(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the INFO level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="info")
+
+    async def awarning(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the WARNING level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="warning")
+
+    async def aerror(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the ERROR level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="error", is_err=True)
+
+    async def aexception(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the EXCEPTION level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="exception", is_err=True)
+
 
 class ConsoleTrace(BaseTrace):  # pragma: no cov
     """Console Trace log model."""
@@ -416,7 +534,7 @@ class ConsoleTrace(BaseTrace):  # pragma: no cov
             f"{PrefixMsg.from_str(message).prepare(self.extras)}"
         )
 
-    def __logging(
+    def _logging(
         self, message: str, mode: str, *, is_err: bool = False
     ) -> None:
         """Write trace log with append mode and logging this message with any
@@ -433,47 +551,7 @@ class ConsoleTrace(BaseTrace):  # pragma: no cov
 
         getattr(logger, mode)(msg, stacklevel=3, extra={"cut_id": self.cut_id})
 
-    def debug(self, message: str):
-        """Write trace log with append mode and logging this message with the
-        DEBUG level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="debug")
-
-    def info(self, message: str) -> None:
-        """Write trace log with append mode and logging this message with the
-        INFO level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="info")
-
-    def warning(self, message: str) -> None:
-        """Write trace log with append mode and logging this message with the
-        WARNING level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="warning")
-
-    def error(self, message: str) -> None:
-        """Write trace log with append mode and logging this message with the
-        ERROR level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="error", is_err=True)
-
-    def exception(self, message: str) -> None:
-        """Write trace log with append mode and logging this message with the
-        EXCEPTION level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="exception", is_err=True)
-
-    async def __alogging(
+    async def _alogging(
         self, message: str, mode: str, *, is_err: bool = False
     ) -> None:
         """Write trace log with append mode and logging this message with any
@@ -490,46 +568,6 @@ class ConsoleTrace(BaseTrace):  # pragma: no cov
 
         getattr(logger, mode)(msg, stacklevel=3, extra={"cut_id": self.cut_id})
 
-    async def adebug(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the DEBUG level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="debug")
-
-    async def ainfo(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the INFO level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="info")
-
-    async def awarning(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the WARNING level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="warning")
-
-    async def aerror(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the ERROR level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="error", is_err=True)
-
-    async def aexception(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the EXCEPTION level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="exception", is_err=True)
-
 
 class FileTrace(ConsoleTrace):  # pragma: no cov
     """File Trace dataclass that write file to the local storage."""

ddeutil/workflow/utils.py

@@ -163,21 +163,23 @@ def gen_id(
     extras: DictData | None = None,
 ) -> str:
     """Generate running ID for able to tracking. This generates process use
-    `md5` algorithm function if `WORKFLOW_CORE_WORKFLOW_ID_SIMPLE_MODE` set
+    ``md5`` algorithm function if ``WORKFLOW_CORE_WORKFLOW_ID_SIMPLE_MODE`` set
     to false. But it will cut this hashing value length to 10 it the setting
     value set to true.
 
     Simple Mode:
 
-        ... 0000 00    00  00   00     00     000000        T   0000000000
-        ... year month day hour minute second microsecond   sep simple-id
+        ... 0000 00    00  00   00     00     000000       T    0000000000
+        ... year month day hour minute second microsecond  sep  simple-id
 
     :param value: A value that want to add to prefix before hashing with md5.
-    :param sensitive: A flag that convert the value to lower case before hashing
-    :param unique: A flag that add timestamp at microsecond level to value
-        before hashing.
-    :param simple_mode: A flag for generate ID by simple mode.
-    :param extras: An extra parameter that use for override config value.
+    :param sensitive: (bool) A flag that enable to convert the value to lower
+        case before hashing that value before generate ID.
+    :param unique: (bool) A flag that add timestamp at microsecond level to
+        value before hashing.
+    :param simple_mode: (bool | None) A flag for generate ID by simple mode.
+    :param extras: (DictData) An extra parameter that use for override config
+        value.
 
     :rtype: str
     """
@@ -212,7 +214,8 @@ def default_gen_id() -> str:
 def make_exec(path: Union[Path, str]) -> None:
     """Change mode of file to be executable file.
 
-    :param path: A file path that want to make executable permission.
+    :param path: (Path | str) A file path that want to make executable
+        permission.
     """
     f: Path = Path(path) if isinstance(path, str) else path
     f.chmod(f.stat().st_mode | stat.S_IEXEC)
@@ -285,9 +288,14 @@ def dump_all(value: T, by_alias: bool = False) -> T: ...  # pragma: no cov
 
 
 def dump_all(
-    value: Union[T, BaseModel], by_alias: bool = False
+    value: Union[T, BaseModel],
+    by_alias: bool = False,
 ) -> Union[T, DictData]:
-    """Dump all BaseModel object to dict."""
+    """Dump all nested BaseModel object to dict object.
+
+    :param value: (T | BaseModel)
+    :param by_alias: (bool)
+    """
     if isinstance(value, dict):
         return {k: dump_all(value[k], by_alias=by_alias) for k in value}
     elif isinstance(value, (list, tuple, set)):

ddeutil/workflow/workflow.py

@@ -257,8 +257,10 @@ class Workflow(BaseModel):
                     f"{self.name!r}."
                 )
 
-            # NOTE: Set job ID to the job model.
-            self.jobs[job].id = job
+            # NOTE: Copy the job model and set job ID to the job model.
+            job_model = self.jobs[job].model_copy()
+            job_model.id = job
+            self.jobs[job] = job_model
 
         # VALIDATE: Validate workflow name should not dynamic with params
         #   template.
@@ -771,3 +773,217 @@ class Workflow(BaseModel):
                 ).to_dict(),
             },
         )
+
+    def rerun(
+        self,
+        context: DictData,
+        *,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
+        timeout: float = 3600,
+        max_job_parallel: int = 2,
+    ) -> Result:
+        """Re-Execute workflow with passing the error context data.
+
+        :param context: A context result that get the failed status.
+        :param parent_run_id: (Optional[str]) A parent workflow running ID.
+        :param event: (Event) An Event manager instance that use to cancel this
+            execution if it forces stopped by parent execution.
+        :param timeout: (float) A workflow execution time out in second unit
+            that use for limit time of execution and waiting job dependency.
+            This value does not force stop the task that still running more than
+            this limit time. (Default: 60 * 60 seconds)
+        :param max_job_parallel: (int) The maximum workers that use for job
+            execution in `ThreadPoolExecutor` object. (Default: 2 workers)
+
+        :rtype: Result
+        """
+        ts: float = time.monotonic()
+
+        result: Result = Result.construct_with_rs_or_id(
+            parent_run_id=parent_run_id,
+            id_logic=self.name,
+            extras=self.extras,
+        )
+        if context["status"] == SUCCESS:
+            result.trace.info(
+                "[WORKFLOW]: Does not rerun because it already executed with "
+                "success status."
+            )
+            return result.catch(status=SUCCESS, context=context)
+
+        err = context["errors"]
+        result.trace.info(f"[WORKFLOW]: Previous error: {err}")
+
+        event: Event = event or Event()
+        max_job_parallel: int = dynamic(
+            "max_job_parallel", f=max_job_parallel, extras=self.extras
+        )
+        result.trace.info(
+            f"[WORKFLOW]: Execute: {self.name!r} ("
+            f"{'parallel' if max_job_parallel > 1 else 'sequential'} jobs)"
+        )
+        if not self.jobs:
+            result.trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
+            return result.catch(status=SUCCESS, context=context)
+
+        # NOTE: Prepare the new context for rerun process.
+        jobs: DictData = context.get("jobs")
+        new_context: DictData = {
+            "params": context["params"].copy(),
+            "jobs": {j: jobs[j] for j in jobs if jobs[j]["status"] == SUCCESS},
+        }
+
+        total_job: int = 0
+        job_queue: Queue = Queue()
+        for job_id in self.jobs:
+
+            if job_id in new_context["jobs"]:
+                continue
+
+            job_queue.put(job_id)
+            total_job += 1
+
+        if total_job == 0:
+            result.trace.warning("[WORKFLOW]: It does not have job to rerun.")
+            return result.catch(status=SUCCESS, context=context)
+
+        not_timeout_flag: bool = True
+        statuses: list[Status] = [WAIT] * total_job
+        skip_count: int = 0
+        sequence_statuses: list[Status] = []
+        timeout: float = dynamic(
+            "max_job_exec_timeout", f=timeout, extras=self.extras
+        )
+
+        result.catch(status=WAIT, context=new_context)
+        if event and event.is_set():
+            return result.catch(
+                status=CANCEL,
+                context={
+                    "errors": WorkflowCancelError(
+                        "Execution was canceled from the event was set before "
+                        "workflow execution."
+                    ).to_dict(),
+                },
+            )
+
+        with ThreadPoolExecutor(max_job_parallel, "wf") as executor:
+            futures: list[Future] = []
+
+            while not job_queue.empty() and (
+                not_timeout_flag := ((time.monotonic() - ts) < timeout)
+            ):
+                job_id: str = job_queue.get()
+                job: Job = self.job(name=job_id)
+                if (check := job.check_needs(new_context["jobs"])) == WAIT:
+                    job_queue.task_done()
+                    job_queue.put(job_id)
+                    time.sleep(0.15)
+                    continue
+                elif check == FAILED:  # pragma: no cov
+                    return result.catch(
+                        status=FAILED,
+                        context={
+                            "status": FAILED,
+                            "errors": WorkflowError(
+                                f"Validate job trigger rule was failed with "
+                                f"{job.trigger_rule.value!r}."
+                            ).to_dict(),
+                        },
+                    )
+                elif check == SKIP:  # pragma: no cov
+                    result.trace.info(
+                        f"[JOB]: Skip job: {job_id!r} from trigger rule."
+                    )
+                    job.set_outputs(output={"status": SKIP}, to=new_context)
+                    job_queue.task_done()
+                    skip_count += 1
+                    continue
+
+                if max_job_parallel > 1:
+                    futures.append(
+                        executor.submit(
+                            self.execute_job,
+                            job=job,
+                            params=new_context,
+                            result=result,
+                            event=event,
+                        ),
+                    )
+                    job_queue.task_done()
+                    continue
+
+                if len(futures) < 1:
+                    futures.append(
+                        executor.submit(
+                            self.execute_job,
+                            job=job,
+                            params=new_context,
+                            result=result,
+                            event=event,
+                        )
+                    )
+                elif (future := futures.pop(0)).done():
+                    if e := future.exception():
+                        sequence_statuses.append(get_status_from_error(e))
+                    else:
+                        st, _ = future.result()
+                        sequence_statuses.append(st)
+                    job_queue.put(job_id)
+                elif future.cancelled():
+                    sequence_statuses.append(CANCEL)
+                    job_queue.put(job_id)
+                elif future.running() or "state=pending" in str(future):
+                    futures.insert(0, future)
+                    job_queue.put(job_id)
+                else:  # pragma: no cov
+                    job_queue.put(job_id)
+                    futures.insert(0, future)
+                    result.trace.warning(
+                        f"[WORKFLOW]: ... Execution non-threading not "
+                        f"handle: {future}."
+                    )
+
+                job_queue.task_done()
+
+            if not_timeout_flag:
+                job_queue.join()
+                for total, future in enumerate(as_completed(futures), start=0):
+                    try:
+                        statuses[total], _ = future.result()
+                    except WorkflowError as e:
+                        statuses[total] = get_status_from_error(e)
+
+                # NOTE: Update skipped status from the job trigger.
+                for i in range(skip_count):
+                    statuses[total + 1 + i] = SKIP
+
+                # NOTE: Update status from none-parallel job execution.
+                for i, s in enumerate(sequence_statuses, start=0):
+                    statuses[total + 1 + skip_count + i] = s
+
+                return result.catch(
+                    status=validate_statuses(statuses), context=new_context
+                )
+
+            event.set()
+            for future in futures:
+                future.cancel()
+
+            result.trace.error(
+                f"[WORKFLOW]: {self.name!r} was timeout because it use exec "
+                f"time more than {timeout} seconds."
+            )
+
+            time.sleep(0.0025)
+
+        return result.catch(
+            status=FAILED,
+            context={
+                "errors": WorkflowTimeoutError(
+                    f"{self.name!r} was timeout because it use exec time more "
+                    f"than {timeout} seconds."
+                ).to_dict(),
+            },
+        )

{ddeutil_workflow-0.0.69.dist-info → ddeutil_workflow-0.0.70.dist-info}/METADATA

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

{ddeutil_workflow-0.0.69.dist-info → ddeutil_workflow-0.0.70.dist-info}/RECORD

@@ -1,30 +1,30 @@
-ddeutil/workflow/__about__.py,sha256=wwXPhnyUKhGfDURjazLxeC2yPB5gr3G3n0ZD73ZnhYY,28
+ddeutil/workflow/__about__.py,sha256=hpI1C5z35dcwfGMtSFmLCLv6edKv0tP9m0z-1ytAu0Y,28
 ddeutil/workflow/__cron.py,sha256=BOKQcreiex0SAigrK1gnLxpvOeF3aca_rQwyz9Kfve4,28751
 ddeutil/workflow/__init__.py,sha256=HUy9XkBe7ttpUupJS4JDuj3aGp2QmJZfz8m2kHAIwdw,927
 ddeutil/workflow/__main__.py,sha256=Qd-f8z2Q2vpiEP2x6PBFsJrpACWDVxFKQk820MhFmHo,59
 ddeutil/workflow/__types.py,sha256=uNfoRbVmNK5O37UUMVnqcmoghD9oMS1q9fXC0APnjSI,4584
 ddeutil/workflow/audits.py,sha256=1pg4a5wdZCAKOqMr1Z_ofzRAFsDarN1BIJenWwn9xkg,11435
-ddeutil/workflow/cli.py,sha256=ems4Ewc2UGmjUwPjbobVsP3igfBZcz6Crf3PQM15w4E,3449
-ddeutil/workflow/conf.py,sha256=ct7CtebGhWfXk6509CZsKh45hkWMzTD5cVghmINa0Hk,13577
-ddeutil/workflow/errors.py,sha256=4DaKnyUm8RrUyQA5qakgW0ycSQLO7j-owyoh79LWQ5c,2893
+ddeutil/workflow/cli.py,sha256=pFmSmkdQUIpmCbFcoyoBub2LAj3rtlFM3oToJq0C0Ac,5149
+ddeutil/workflow/conf.py,sha256=KcvOlU0zzS53iK44X_T64qHSX9nr4EHGjGX31dsRiUE,13609
+ddeutil/workflow/errors.py,sha256=O5rq80Sqj0QMeIsWXpRUhiFLTq0o8bwm5BQ4kuq6xmI,3013
 ddeutil/workflow/event.py,sha256=e3xcECfMvH6K8Tff9cjCXIItVJjOmlonAQ0l253l6T0,11110
-ddeutil/workflow/job.py,sha256=qcbKSOa39256nfJHL0vKJsHrelcRujX5KET2IEGS8dw,38995
+ddeutil/workflow/job.py,sha256=kviOQeSUsx0Z7CL0foblTulg2m_l6a3M3SMRxg9RWeg,39151
 ddeutil/workflow/params.py,sha256=Pco3DyjptC5Jkx53dhLL9xlIQdJvNAZs4FLzMUfXpbQ,12402
 ddeutil/workflow/result.py,sha256=ctxNSaY9tZPHEAUgvDkjWWu2APeTmlZCf1Hb0XVbbFo,8173
-ddeutil/workflow/reusables.py,sha256=jPrOCbxagqRvRFGXJzIyDa1wKV5AZ4crZyJ10cldQP0,21620
+ddeutil/workflow/reusables.py,sha256=LSn0XTkzGHf4ulOmWub29F0JZHt0NEyzrFd4ZFx_g_k,21622
 ddeutil/workflow/stages.py,sha256=kzMEMRTEuG52EOw51zyVO6LE-oiiqTIRUCk_OMcWZTM,106506
-ddeutil/workflow/traces.py,sha256=GranGEgizx-R6wDJjVjkoCNVHlgOc6-wHi9zD5DH3D8,24059
-ddeutil/workflow/utils.py,sha256=oKrhB-HOogeaO9RGXbe2vAs30A3rMMQxUd2B5pOw8zg,9131
-ddeutil/workflow/workflow.py,sha256=jcSwOTaigVgiHElmlM1iK3g6rDMDd5PGni0ZcIxgH2U,27859
+ddeutil/workflow/traces.py,sha256=DrKzxgp9FJUJd_oWYHiMtR1z8R7HeweAL4_Y8q0_pz8,25048
+ddeutil/workflow/utils.py,sha256=65aMH2JKeeG7GLLoD0D5_0Cv55XV5EUd1Gn-Zz21hwo,9339
+ddeutil/workflow/workflow.py,sha256=nPjNbn0UUKlUwkh7lHFRb5BSLARBOTZ0iv0TU_SMOKc,36205
 ddeutil/workflow/api/__init__.py,sha256=W3fe6_NLHSUzr4Tsu79w3pmvrYjpLeP3zBk4mtpPyqg,2843
 ddeutil/workflow/api/log_conf.py,sha256=WfS3udDLSyrP-C80lWOvxxmhd_XWKvQPkwDqKblcH3E,1834
 ddeutil/workflow/api/routes/__init__.py,sha256=JRaJZB0D6mgR17MbZo8yLtdYDtD62AA8MdKlFqhG84M,420
 ddeutil/workflow/api/routes/job.py,sha256=x809G5gCbJS257txj9eLLTbCbFK8ercXWzPDLuv5gEM,2953
 ddeutil/workflow/api/routes/logs.py,sha256=HiXw93PeIiaK_xJjM8lbD2ED1Il-W1iM51085nc7qmg,5286
 ddeutil/workflow/api/routes/workflows.py,sha256=D76cdLb2_9Dkfe2_8xt06CvPhAyJMqxyYkUgAs8Qlnw,4402
-ddeutil_workflow-0.0.69.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.69.dist-info/METADATA,sha256=wXzNozF5KKoYdTX_JuFz3qOla_YCKjrXCTd7wFd-kb4,15207
-ddeutil_workflow-0.0.69.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ddeutil_workflow-0.0.69.dist-info/entry_points.txt,sha256=qDTpPSauL0ciO6T4iSVt8bJeYrVEkkoEEw_RlGx6Kgk,63
-ddeutil_workflow-0.0.69.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.69.dist-info/RECORD,,
+ddeutil_workflow-0.0.70.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.70.dist-info/METADATA,sha256=EddcIOkUz36vyIOG4GEOnBt2Zy_K8qI7_Gld5KTbeLs,15207
+ddeutil_workflow-0.0.70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ddeutil_workflow-0.0.70.dist-info/entry_points.txt,sha256=qDTpPSauL0ciO6T4iSVt8bJeYrVEkkoEEw_RlGx6Kgk,63
+ddeutil_workflow-0.0.70.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.70.dist-info/RECORD,,