ddeutil-workflow 0.0.53__py3-none-any.whl → 0.0.55__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,
@@ -165,6 +166,7 @@ class ReleaseQueue:
     extras: DictData = Field(
         default_factory=dict,
         description="An extra parameters that want to override config values.",
+        repr=False,
     )
 
     @classmethod
@@ -212,15 +214,6 @@ class ReleaseQueue:
         """
         return len(self.queue) > 0
 
-    @property
-    def first_queue(self) -> Release:
-        """Check an input Release object is the first value of the
-        waiting queue.
-
-        :rtype: Release
-        """
-        return self.queue[0]
-
     def check_queue(self, value: Release | datetime) -> bool:
         """Check a Release value already exists in list of tracking
         queues.
@@ -239,16 +232,6 @@ class ReleaseQueue:
             or (value in self.complete)
         )
 
-    def remove_running(self, value: Release) -> Self:
-        """Remove Release in the running queue if it exists.
-
-        :rtype: Self
-        """
-        if value in self.running:
-            self.running.remove(value)
-
-        return self
-
     def mark_complete(self, value: Release) -> Self:
         """Push Release to the complete queue.
 
@@ -462,7 +445,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 +585,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 +606,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
@@ -701,10 +684,10 @@ class Workflow(BaseModel):
         if isinstance(release, datetime):
             release: Release = Release.from_dt(release, extras=self.extras)
 
-        result.trace.debug(
+        result.trace.info(
             f"[RELEASE]: Start {name!r} : {release.date:%Y-%m-%d %H:%M:%S}"
         )
-        self.execute(
+        rs: Result = self.execute(
             params=param2template(
                 params,
                 params={
@@ -723,7 +706,7 @@ class Workflow(BaseModel):
             parent_run_id=result.parent_run_id,
             timeout=timeout,
         )
-        result.trace.debug(
+        result.trace.info(
             f"[RELEASE]: End {name!r} : {release.date:%Y-%m-%d %H:%M:%S}"
         )
 
@@ -744,11 +727,12 @@ class Workflow(BaseModel):
         )
 
         if queue:
-            queue.remove_running(release)
+            if release in queue.running:
+                queue.running.remove(release)
             queue.mark_complete(release)
 
         return result.catch(
-            status=SUCCESS,
+            status=rs.status,
             context={
                 "params": params,
                 "release": {
@@ -969,22 +953,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 +1001,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 +1022,45 @@ 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-name}.stages.${stage-id}.outputs.${key}
-            ... ${job-name}.stages.${stage-id}.errors.${key}
+        ... ${job-id}.stages.${stage-id}.outputs.${key}
+        ... ${job-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.
+            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}
+
+            This method already handle all exception class that can raise from
+        the job execution. It will warp that error and keep it in the key `errors`
+        at the result context.
+
+        :param params: A parameter data that will parameterize before execution.
+        :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 +1072,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.
+            job_queue.put(job_id)
 
-        :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.
-
-        :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] = []
 
@@ -1181,16 +1102,20 @@ class Workflow(BaseModel):
             ):
                 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.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 +1123,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 +1167,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))
@@ -1352,8 +1212,8 @@ class WorkflowTask:
     :param alias: (str) An alias name of Workflow model.
     :param workflow: (Workflow) A Workflow model instance.
     :param runner: (CronRunner)
-    :param values:
-    :param extras:
+    :param values: A value data that want to parameterize.
+    :param extras: An extra parameter that use to override core config values.
     """
 
     alias: str

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.53
+Version: 0.0.55
 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>**:
@@ -127,12 +121,10 @@ flowchart LR
 
 > [!WARNING]
 > _**Disclaimer**_: I inspire the dynamic YAML statement from the [**GitHub Action**](https://github.com/features/actions),
-> and all configs pattern from several data orchestration framework tools from
-> my data engineering experience. :grimacing:
-
-> [!NOTE]
-> Other workflow orchestration tools that I interest and pick them to be inspiration
-> some for this package:
+> and my experience of data framework configs pattern. :grimacing:
+>
+> Other workflow orchestration services that I interest and pick them to be
+> this project inspiration:
 >
 > - [Google **Workflows**](https://cloud.google.com/workflows)
 > - [AWS **Step Functions**](https://aws.amazon.com/step-functions/)

ddeutil_workflow-0.0.55.dist-info/RECORD

@@ -0,0 +1,30 @@
+ddeutil/workflow/__about__.py,sha256=kfTS6Gqr5xkMNDVKm-NTS4vmeIl2Zj4oMBQGmq19LHA,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
+ddeutil/workflow/__types.py,sha256=8jBdbfb3aZSetjz0mvNrpGHwwxJff7mK8_4v41cLqlc,4316
+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=aVRWLMLv5vYFbckT6AKYrMu29FzXYESOEzDHhFIpUyo,34159
+ddeutil/workflow/logs.py,sha256=rsoBrUGQrooou18fg2yvPsB8NOaXnUA5ThQpBr_WVMg,26598
+ddeutil/workflow/params.py,sha256=FKY4Oo1Ze4QZKRfAk7rqKsi44YaJQAbqAtXM6vlO2hI,11392
+ddeutil/workflow/result.py,sha256=rI0S8-HanFDk1l6_BsYRRamzSfzKUy7bkKJUae1w_aQ,5708
+ddeutil/workflow/reusables.py,sha256=iXcS7Gg-71qVX4ln0ILTDx03cTtUnj_rNoXHTVdVrxc,17636
+ddeutil/workflow/scheduler.py,sha256=hk3-9R63DZH9J0PWbtBzaD8rqHyiOf03vTvAJDgsxTA,28279
+ddeutil/workflow/stages.py,sha256=E5XoMVijjcvm_YK8AbiA8xGAQUphCPTtGazW-oLAdeI,82543
+ddeutil/workflow/utils.py,sha256=NZPvPPP_5g4cigFcD7tHjIKLtKMeYAcb3oUhNyhTpJ0,7947
+ddeutil/workflow/workflow.py,sha256=F3I_c0LHMoJFZIFt1a92sxFMlQVkE-cH--TLyX2rwuo,46799
+ddeutil/workflow/api/__init__.py,sha256=kY30dL8HPY8tY_GBmm7y_3OdoXzB1-EA2a96PLU0AQw,5278
+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=8X5VLDJH6PumyNIY6JGRNBsf2gWN0eG9DzxRPSh6n4I,2190
+ddeutil/workflow/api/routes/logs.py,sha256=U6vOni3wd-ZTOwd3yVdSOpgyRmNdcgfngU5KlLM3Cww,5383
+ddeutil/workflow/api/routes/schedules.py,sha256=14RnaJKEGMSJtncI1H_QQVZNBe_jDS40PPRO6qFc3i0,4805
+ddeutil/workflow/api/routes/workflows.py,sha256=GJu5PiXEylswrXylEImpncySjeU9chrvrtjhiMCw2RQ,4529
+ddeutil_workflow-0.0.55.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.55.dist-info/METADATA,sha256=sTjAMsv4yIgw-CKKHyr-sg_yrgnnDT_0UMF3E2TP-Js,19008
+ddeutil_workflow-0.0.55.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ddeutil_workflow-0.0.55.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.55.dist-info/RECORD,,