ddeutil-workflow 0.0.53__py3-none-any.whl → 0.0.54__py3-none-any.whl

ddeutil/workflow/utils.py

@@ -24,6 +24,7 @@ from .__types import DictData, Matrix
 
 T = TypeVar("T")
 UTC: Final[ZoneInfo] = ZoneInfo("UTC")
+NEWLINE: Final[str] = "\n\t| ...\t"
 
 
 def replace_sec(dt: datetime) -> datetime:
@@ -200,7 +201,7 @@ def filter_func(value: T) -> T:
 def cross_product(matrix: Matrix) -> Iterator[DictData]:
     """Iterator of products value from matrix.
 
-    :param matrix:
+    :param matrix: (Matrix)
 
     :rtype: Iterator[DictData]
     """
@@ -223,7 +224,7 @@ def batch(iterable: Iterator[Any] | range, n: int) -> Iterator[Any]:
         ['G']
 
     :param iterable:
-    :param n:
+    :param n: (int) A number of returning batch size.
 
     :rtype: Iterator[Any]
     """
@@ -247,8 +248,8 @@ def cut_id(run_id: str, *, num: int = 6) -> str:
         >>> cut_id(run_id='20240101081330000000T1354680202')
         '202401010813680202'
 
-    :param run_id: A running ID That want to cut
-    :param num:
+    :param run_id: (str) A running ID That want to cut.
+    :param num: (int) A number of cutting length.
 
     :rtype: str
     """

ddeutil/workflow/workflow.py

@@ -4,11 +4,11 @@
 # license information.
 # ------------------------------------------------------------------------------
 # [x] Use dynamic config
-"""A Workflow module that is the core module of this package. It keeps Release
-and Workflow Pydantic models.
+"""Workflow module is the core module of this Workflow package. It keeps
+Release, ReleaseQueue, and Workflow Pydantic models.
 
-    I will implement timeout on the workflow execution layer only because the
-main propose of this package in Workflow model.
+    This package implement timeout strategy on the workflow execution layer only
+because the main propose of this package is using Workflow to be orchestrator.
 """
 from __future__ import annotations
 
@@ -43,9 +43,10 @@ from .exceptions import JobException, UtilException, WorkflowException
 from .job import Job
 from .logs import Audit, get_audit
 from .params import Param
-from .result import FAILED, SKIP, SUCCESS, WAIT, Result, Status
+from .result import FAILED, SKIP, SUCCESS, WAIT, Result
 from .reusables import has_template, param2template
 from .utils import (
+    NEWLINE,
     gen_id,
     get_dt_now,
     reach_next_minute,
@@ -462,7 +463,7 @@ class Workflow(BaseModel):
             if isinstance(on, str):
                 on: list[str] = [on]
             if any(not isinstance(i, (dict, str)) for i in on):
-                raise TypeError("The ``on`` key should be list of str or dict")
+                raise TypeError("The `on` key should be list of str or dict")
 
             # NOTE: Pass on value to SimLoad and keep on model object to the on
             #   field.
@@ -602,8 +603,8 @@ class Workflow(BaseModel):
             ...     "jobs": {}
             ... }
 
-        :param params: A parameter mapping that receive from workflow execution.
-        :type params: DictData
+        :param params: (DictData) A parameter data that receive from workflow
+            execute method.
 
         :raise WorkflowException: If parameter value that want to validate does
             not include the necessary parameter that had required flag.
@@ -623,7 +624,7 @@ class Workflow(BaseModel):
                 f"{', '.join(check_key)}."
             )
 
-        # NOTE: Mapping type of param before adding it to the ``params`` key.
+        # NOTE: Mapping type of param before adding it to the `params` key.
         return {
             "params": (
                 params
@@ -969,22 +970,19 @@ class Workflow(BaseModel):
         execution to the target job object via job's ID.
 
             This execution is the minimum level of execution of this workflow
-        model. It different with ``self.execute`` because this method run only
+        model. It different with `self.execute` because this method run only
         one job and return with context of this job data.
 
         :raise WorkflowException: If execute with not exist job's ID.
         :raise WorkflowException: If the job execution raise JobException.
 
-        :param job_id: A job ID that want to execute.
-        :param params: A params that was parameterized from workflow execution.
-        :param result: (Result) A result object for keeping context and status
-            data.
-        :param event: (Event) An event manager that pass to the
-            PoolThreadExecutor.
+        :param job_id: A job ID.
+        :param params: (DictData) A parameter data.
+        :param result: (Result) A Result instance for return context and status.
+        :param event: (Event) An Event manager instance that use to cancel this
+            execution if it forces stopped by parent execution.
 
         :rtype: Result
-        :return: Return the result object that receive the job execution result
-            context.
         """
         if result is None:  # pragma: no cov
             result: Result = Result(run_id=gen_id(self.name, unique=True))
@@ -1020,13 +1018,12 @@ class Workflow(BaseModel):
         except (JobException, UtilException) as e:
             result.trace.error(f"[WORKFLOW]: {e.__class__.__name__}: {e}")
             raise WorkflowException(
-                f"Get job execution error {job_id}: JobException: {e}"
+                f"Job {job_id!r} raise {e.__class__.__name__}: {e}"
             ) from None
 
         if rs.status == FAILED:
-            error_msg: str = (
-                f"Workflow job, {job.id}, failed without raise error."
-            )
+            error_msg: str = f"Workflow job, {job.id!r}, return FAILED status."
+            result.trace.warning(f"[WORKFLOW]: {error_msg}")
             return result.catch(
                 status=FAILED,
                 context={
@@ -1042,37 +1039,42 @@ class Workflow(BaseModel):
         *,
         run_id: str | None = None,
         parent_run_id: str | None = None,
-        timeout: int = 600,
         result: Result | None = None,
-        max_job_parallel: int = 2,
         event: Event | None = None,
+        timeout: int = 3600,
+        max_job_parallel: int = 2,
     ) -> Result:
         """Execute workflow with passing a dynamic parameters to all jobs that
-        included in this workflow model with ``jobs`` field.
+        included in this workflow model with `jobs` field.
 
             The result of execution process for each job and stages on this
         workflow will keep in dict which able to catch out with all jobs and
         stages by dot annotation.
 
-            For example, when I want to use the output from previous stage, I
-        can access it with syntax:
+            For example with non-strategy job, when I want to use the output
+        from previous stage, I can access it with syntax:
+
+            ... ${job-id}.stages.${stage-id}.outputs.${key}
+            ... ${job-id}.stages.${stage-id}.errors.${key}
 
-            ... ${job-name}.stages.${stage-id}.outputs.${key}
-            ... ${job-name}.stages.${stage-id}.errors.${key}
+            But example for strategy job:
+
+            ... ${job-id}.strategies.${strategy-id}.stages.${stage-id}.outputs.${key}
+            ... ${job-id}.strategies.${strategy-id}.stages.${stage-id}.errors.${key}
 
         :param params: An input parameters that use on workflow execution that
-            will parameterize before using it. Default is None.
-        :param run_id: A workflow running ID for this job execution.
-        :param parent_run_id: A parent workflow running ID for this release.
+            will parameterize before using it.
+        :param run_id: (str | None) A workflow running ID.
+        :param parent_run_id: (str | None) A parent workflow running ID.
+        :param result: (Result) A Result instance for return context and status.
+        :param event: (Event) An Event manager instance that use to cancel this
+            execution if it forces stopped by parent execution.
         :param timeout: (int) A workflow execution time out in second unit that
             use for limit time of execution and waiting job dependency. This
             value does not force stop the task that still running more than this
-            limit time. (default: 0)
-        :param result: (Result) A result object for keeping context and status
-            data.
-        :param max_job_parallel: (int) The maximum threads of job execution.
-        :param event: (Event) An event manager that pass to the
-            PoolThreadExecutor.
+            limit time. (Default: 60 * 60 seconds)
+        :param max_job_parallel: (int) The maximum workers that use for job
+            execution in `PoolThreadExecutor` object. (Default: 2 workers)
 
         :rtype: Result
         """
@@ -1084,95 +1086,28 @@ class Workflow(BaseModel):
             id_logic=self.name,
             extras=self.extras,
         )
-
+        context: DictData = self.parameterize(params)
         result.trace.info(f"[WORKFLOW]: Execute: {self.name!r} ...")
         if not self.jobs:
-            result.trace.warning(
-                f"[WORKFLOW]: {self.name!r} does not have any jobs"
-            )
-            return result.catch(status=SUCCESS, context=params)
+            result.trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
+            return result.catch(status=SUCCESS, context=context)
 
-        jq: Queue = Queue()
+        job_queue: Queue = Queue()
         for job_id in self.jobs:
-            jq.put(job_id)
-
-        # NOTE: Create data context that will pass to any job executions
-        #   on this workflow.
-        #
-        #   {
-        #       'params': <input-params>,
-        #       'jobs': {},
-        #   }
-        #
-        context: DictData = self.parameterize(params)
-        status: Status = SUCCESS
-        try:
-            if (
-                dynamic(
-                    "max_job_parallel", f=max_job_parallel, extras=self.extras
-                )
-                == 1
-            ):
-                self.__exec_non_threading(
-                    result=result,
-                    context=context,
-                    ts=ts,
-                    job_queue=jq,
-                    timeout=timeout,
-                    event=event,
-                )
-            else:
-                self.__exec_threading(
-                    result=result,
-                    context=context,
-                    ts=ts,
-                    job_queue=jq,
-                    timeout=timeout,
-                    event=event,
-                )
-        except (WorkflowException, JobException) as e:
-            status: Status = FAILED
-            context.update({"errors": e.to_dict()})
-
-        return result.catch(status=status, context=context)
-
-    def __exec_threading(
-        self,
-        result: Result,
-        context: DictData,
-        ts: float,
-        job_queue: Queue,
-        *,
-        timeout: int = 600,
-        thread_timeout: int = 1800,
-        event: Event | None = None,
-    ) -> DictData:
-        """Workflow execution by threading strategy that use multithreading.
-
-            If a job need dependency, it will check dependency job ID from
-        context data before allow it run.
-
-        :param result: (Result) A result model.
-        :param context: A context workflow data that want to downstream passing.
-        :param ts: A start timestamp that use for checking execute time should
-            time out.
-        :param job_queue: (Queue) A job queue object.
-        :param timeout: (int) A second value unit that bounding running time.
-        :param thread_timeout: A timeout to waiting all futures complete.
-        :param event: (Event) An event manager that pass to the
-            PoolThreadExecutor.
+            job_queue.put(job_id)
 
-        :rtype: DictData
-        """
         not_timeout_flag: bool = True
         timeout: int = dynamic(
             "max_job_exec_timeout", f=timeout, extras=self.extras
         )
         event: Event = event or Event()
-        result.trace.debug(f"... Run {self.name!r} with threading.")
+        result.trace.debug(f"... Run {self.name!r} with non-threading.")
+        max_job_parallel: int = dynamic(
+            "max_job_parallel", f=max_job_parallel, extras=self.extras
+        )
         with ThreadPoolExecutor(
-            max_workers=dynamic("max_job_parallel", extras=self.extras),
-            thread_name_prefix="wf_exec_threading_",
+            max_workers=max_job_parallel,
+            thread_name_prefix="wf_exec_non_threading_",
         ) as executor:
             futures: list[Future] = []
 
@@ -1188,9 +1123,14 @@ class Workflow(BaseModel):
                     time.sleep(0.15)
                     continue
                 elif check == FAILED:  # pragma: no cov
-                    raise WorkflowException(
-                        f"Validate job trigger rule was failed with "
-                        f"{job.trigger_rule.value!r}."
+                    return result.catch(
+                        status=FAILED,
+                        context={
+                            "errors": WorkflowException(
+                                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}")
@@ -1198,119 +1138,42 @@ class Workflow(BaseModel):
                     job_queue.task_done()
                     continue
 
-                futures.append(
-                    executor.submit(
-                        self.execute_job,
-                        job_id=job_id,
-                        params=context,
-                        result=result,
-                        event=event,
-                    ),
-                )
-
-                job_queue.task_done()
-
-            if not_timeout_flag:
-                job_queue.join()
-                for future in as_completed(futures, timeout=thread_timeout):
-                    if e := future.exception():
-                        result.trace.error(f"[WORKFLOW]: {e}")
-                        raise WorkflowException(str(e))
-
-                    future.result()
-
-                return context
-
-            result.trace.error(
-                f"[WORKFLOW]: Execution: {self.name!r} was timeout."
-            )
-            event.set()
-            for future in futures:
-                future.cancel()
-
-        raise WorkflowException(f"Execution: {self.name!r} was timeout.")
-
-    def __exec_non_threading(
-        self,
-        result: Result,
-        context: DictData,
-        ts: float,
-        job_queue: Queue,
-        *,
-        timeout: int = 600,
-        event: Event | None = None,
-    ) -> DictData:
-        """Workflow execution with non-threading strategy that use sequential
-        job running and waiting previous job was run successful.
-
-            If a job need dependency, it will check dependency job ID from
-        context data before allow it run.
-
-        :param result: (Result) A result model.
-        :param context: A context workflow data that want to downstream passing.
-        :param ts: (float) A start timestamp that use for checking execute time
-            should time out.
-        :param timeout: (int) A second value unit that bounding running time.
-        :param event: (Event) An event manager that pass to the
-            PoolThreadExecutor.
-
-        :rtype: DictData
-        """
-        not_timeout_flag: bool = True
-        timeout: int = dynamic(
-            "max_job_exec_timeout", f=timeout, extras=self.extras
-        )
-        event: Event = event or Event()
-        result.trace.debug(f"... Run {self.name!r} with non-threading.")
-        with ThreadPoolExecutor(
-            max_workers=1,
-            thread_name_prefix="wf_exec_non_threading_",
-        ) as executor:
-            future: Optional[Future] = None
-
-            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(context["jobs"])) == WAIT:
-                    job_queue.task_done()
-                    job_queue.put(job_id)
-                    time.sleep(0.075)
-                    continue
-                elif check == FAILED:
-                    raise WorkflowException(
-                        f"Validate job trigger rule was failed with "
-                        f"{job.trigger_rule.value!r}."
+                if max_job_parallel > 1:
+                    futures.append(
+                        executor.submit(
+                            self.execute_job,
+                            job_id=job_id,
+                            params=context,
+                            result=result,
+                            event=event,
+                        ),
                     )
-                elif check == SKIP:  # pragma: no cov
-                    result.trace.info(f"[JOB]: Skip job: {job_id!r}")
-                    job.set_outputs(output={"skipped": True}, to=context)
                     job_queue.task_done()
                     continue
 
-                if future is None:
-                    future: Future = executor.submit(
-                        self.execute_job,
-                        job_id=job_id,
-                        params=context,
-                        result=result,
-                        event=event,
+                if len(futures) < 1:
+                    futures.append(
+                        executor.submit(
+                            self.execute_job,
+                            job_id=job_id,
+                            params=context,
+                            result=result,
+                            event=event,
+                        )
                     )
                     time.sleep(0.025)
-                elif future.done() or future.cancelled():
+                elif (future := futures.pop(0)).done() or future.cancelled():
                     if e := future.exception():
                         result.trace.error(f"[WORKFLOW]: {e}")
                         raise WorkflowException(str(e))
-
-                    future = None
                     job_queue.put(job_id)
                 elif future.running() or "state=pending" in str(future):
                     time.sleep(0.075)
+                    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"... Execution non-threading not handle: {future}."
                     )
@@ -1319,23 +1182,35 @@ class Workflow(BaseModel):
 
             if not_timeout_flag:
                 job_queue.join()
-                if future:  # pragma: no cov
-                    if e := future.exception():
-                        result.trace.error(f"[WORKFLOW]: {e}")
-                        raise WorkflowException(str(e))
-
-                    future.result()
-
-                return context
+                for future in as_completed(futures):
+                    try:
+                        future.result()
+                    except WorkflowException as e:
+                        result.trace.error(f"[WORKFLOW]: Handler:{NEWLINE}{e}")
+                        return result.catch(
+                            status=FAILED,
+                            context={
+                                "errors": WorkflowException(str(e)).to_dict()
+                            },
+                        )
+                return result.catch(
+                    status=FAILED if "errors" in result.context else SUCCESS,
+                    context=context,
+                )
 
-            result.trace.error(
-                f"[WORKFLOW]: Execution: {self.name!r} was timeout."
-            )
+            result.trace.error(f"[WORKFLOW]: {self.name!r} was timeout.")
             event.set()
-            if future:
+            for future in futures:
                 future.cancel()
 
-        raise WorkflowException(f"Execution: {self.name!r} was timeout.")
+        return result.catch(
+            status=FAILED,
+            context={
+                "errors": WorkflowException(
+                    f"{self.name!r} was timeout."
+                ).to_dict()
+            },
+        )
 
 
 @dataclass(config=ConfigDict(arbitrary_types_allowed=True))

{ddeutil_workflow-0.0.53.dist-info → ddeutil_workflow-0.0.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.53
+Version: 0.0.54
 Summary: Lightweight workflow orchestration
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -62,12 +62,6 @@ by a `.yaml` template.
 > use the workflow stage to process any large volume data which use a lot of compute
 > resource :cold_sweat:.
 
-In my opinion, I think it should not create duplicate workflow codes if I can
-write with dynamic input parameters on the one template workflow that just change
-the input parameters per use-case instead.
-This way I can handle a lot of logical workflows in our orgs with only metadata
-configuration. It called **Metadata Driven Data Workflow**.
-
 ---
 
 **:pushpin: <u>Rules of This Workflow engine</u>**:

{ddeutil_workflow-0.0.53.dist-info → ddeutil_workflow-0.0.54.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ddeutil/workflow/__about__.py,sha256=fOQi-49Q8-qLVO7us5t2StkrubZvI2LQkyYSQi-3P88,28
+ddeutil/workflow/__about__.py,sha256=KTbXC0Wvt30Z6UCFcSzVAD697wqCc-kgyHEuDu_xEtY,28
 ddeutil/workflow/__cron.py,sha256=h8rLeIUAAEB2SdZ4Jhch7LU1Yl3bbJ-iNNJ3tQ0eYVM,28095
 ddeutil/workflow/__init__.py,sha256=noE8LNRcgq32m9OnIFcQqh0P7PXWdp-SGmvBCYIXgf4,1338
 ddeutil/workflow/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -6,26 +6,26 @@ ddeutil/workflow/__types.py,sha256=8jBdbfb3aZSetjz0mvNrpGHwwxJff7mK8_4v41cLqlc,4
 ddeutil/workflow/conf.py,sha256=80rgmJKFU7BlH5xTLnghGzGhE8C6LFAQykd9mjHSjo8,12528
 ddeutil/workflow/cron.py,sha256=WS2MInn0Sp5DKlZDZH5VFZ5AA0Q3_AnBnYEU4lZSv4I,9779
 ddeutil/workflow/exceptions.py,sha256=r4Jrf9qtVPALU4wh4bnb_OYqC-StqSQJEmFC-_QK934,1408
-ddeutil/workflow/job.py,sha256=Z1XP_9pj-RY64z3G4LYX-MppS99zQns9wtZy7zHuWbE,35262
+ddeutil/workflow/job.py,sha256=uoj6grIq1f0iV5RFtQaysyel6z9keYr-urkkhFzyhcI,33831
 ddeutil/workflow/logs.py,sha256=rsoBrUGQrooou18fg2yvPsB8NOaXnUA5ThQpBr_WVMg,26598
 ddeutil/workflow/params.py,sha256=FKY4Oo1Ze4QZKRfAk7rqKsi44YaJQAbqAtXM6vlO2hI,11392
 ddeutil/workflow/result.py,sha256=27nPQq9CETLCVczv4vvFEF9w2TllHZ_ROfyDoLFxRWM,5647
 ddeutil/workflow/reusables.py,sha256=iXcS7Gg-71qVX4ln0ILTDx03cTtUnj_rNoXHTVdVrxc,17636
 ddeutil/workflow/scheduler.py,sha256=4G5AogkmnsTKe7jKYSfU35qjubR82WQ8CLtEe9kqPTE,28304
-ddeutil/workflow/stages.py,sha256=ZsGh8Wd-NqdAZC5cyJ6wXuF-UHqoCcFFedXvyHssSqc,72473
-ddeutil/workflow/utils.py,sha256=zbVttaMFMRLuuBJdSJf7D9qtz8bOnQIBq-rHI3Eqy4M,7821
-ddeutil/workflow/workflow.py,sha256=2ZBNW3-vcP8bpKrK184wSCukq3wpT6G0z25Su5bapR0,50832
+ddeutil/workflow/stages.py,sha256=131pGqE5RhhDo9aLy6KTXGrvVLFT3UIwr9fS3tVqoZQ,80466
+ddeutil/workflow/utils.py,sha256=NZPvPPP_5g4cigFcD7tHjIKLtKMeYAcb3oUhNyhTpJ0,7947
+ddeutil/workflow/workflow.py,sha256=-7M3HdxOpuPpXeRF8oWhDh_S8anX3ivSoKlOsKnsh6c,46942
 ddeutil/workflow/api/__init__.py,sha256=F53NMBWtb9IKaDWkPU5KvybGGfKAcbehgn6TLBwHuuM,21
-ddeutil/workflow/api/api.py,sha256=CWtPLgOv2Jus9E7nzG5mG2Z32ZEkUK3JWQ2htZyMRpA,5244
-ddeutil/workflow/api/log.py,sha256=NMTnOnsBrDB5129329xF2myLdrb-z9k1MQrmrP7qXJw,1818
-ddeutil/workflow/api/repeat.py,sha256=uTtUFVLpiYYahXvCVx8sueRQ03K2Xw1id_gW3IMmX1U,5295
+ddeutil/workflow/api/api.py,sha256=xLrQ8yD7iOn-MkzaSxG-BADbdkqLikDna630oW3YEmc,5243
+ddeutil/workflow/api/logs.py,sha256=NMTnOnsBrDB5129329xF2myLdrb-z9k1MQrmrP7qXJw,1818
+ddeutil/workflow/api/utils.py,sha256=uTtUFVLpiYYahXvCVx8sueRQ03K2Xw1id_gW3IMmX1U,5295
 ddeutil/workflow/api/routes/__init__.py,sha256=qoGtOMyVgQ5nTUc8J8wH27A8isaxl3IFCX8qoyibeCY,484
-ddeutil/workflow/api/routes/job.py,sha256=oPwBVP0Mxwxv-bGPlfmxQQ9PcVl0ev9HoPzndpYDCCQ,1954
+ddeutil/workflow/api/routes/job.py,sha256=GbDFmToksKsvPHn9KPXhoOCznzEPRTe79jUn7ew0snE,1953
 ddeutil/workflow/api/routes/logs.py,sha256=U6vOni3wd-ZTOwd3yVdSOpgyRmNdcgfngU5KlLM3Cww,5383
 ddeutil/workflow/api/routes/schedules.py,sha256=EgUjyRGhsm6UNaMj5luh6TcY6l571sCHcla-BL1iOfY,4829
 ddeutil/workflow/api/routes/workflows.py,sha256=JcDOrn1deK8ztFRcMTNATQejG6KMA7JxZLVc4QeBsP4,4527
-ddeutil_workflow-0.0.53.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.53.dist-info/METADATA,sha256=xNgYIlFQvS9VsF0agSPsYbJWin_s9c_llkRFnEUxyC0,19425
-ddeutil_workflow-0.0.53.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ddeutil_workflow-0.0.53.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.53.dist-info/RECORD,,
+ddeutil_workflow-0.0.54.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.54.dist-info/METADATA,sha256=uVgjeBlD6MEq6XVs4pPNEfhiTuf44TrUzpESmy_8ADw,19081
+ddeutil_workflow-0.0.54.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ddeutil_workflow-0.0.54.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.54.dist-info/RECORD,,