ddeutil-workflow 0.0.42__py3-none-any.whl → 0.0.43__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.42"
+__version__: str = "0.0.43"

ddeutil/workflow/__init__.py

@@ -4,7 +4,7 @@
 # license information.
 # ------------------------------------------------------------------------------
 from .__cron import CronJob, CronRunner
-from .__types import Re
+from .__types import DictData, DictStr, Matrix, Re, TupleStr
 from .conf import (
     Config,
     Loader,
@@ -47,6 +47,10 @@ from .params import (
     StrParam,
 )
 from .result import (
+    FAILED,
+    SKIP,
+    SUCCESS,
+    WAIT,
     Result,
     Status,
 )

ddeutil/workflow/exceptions.py

@@ -9,10 +9,20 @@ annotate for handle error only.
 """
 from __future__ import annotations
 
-from typing import Any
+from typing import TypedDict
 
+ErrorData = TypedDict(
+    "ErrorData",
+    {
+        "class": Exception,
+        "name": str,
+        "message": str,
+    },
+)
 
-def to_dict(exception: Exception) -> dict[str, Any]:  # pragma: no cov
+
+def to_dict(exception: Exception) -> ErrorData:  # pragma: no cov
+    """Create dict data from exception instance."""
     return {
         "class": exception,
         "name": exception.__class__.__name__,
@@ -22,7 +32,7 @@ def to_dict(exception: Exception) -> dict[str, Any]:  # pragma: no cov
 
 class BaseWorkflowException(Exception):
 
-    def to_dict(self) -> dict[str, Any]:
+    def to_dict(self) -> ErrorData:
         return to_dict(self)
 
 

ddeutil/workflow/job.py

@@ -39,7 +39,7 @@ from .exceptions import (
     StageException,
     UtilException,
 )
-from .result import Result, Status
+from .result import FAILED, SKIP, SUCCESS, WAIT, Result, Status
 from .reusables import has_template, param2template
 from .stages import Stage
 from .utils import cross_product, filter_func, gen_id
@@ -51,7 +51,6 @@ __all__: TupleStr = (
     "Strategy",
     "Job",
     "TriggerRules",
-    "TriggerState",
     "RunsOn",
     "RunsOnLocal",
     "RunsOnSelfHosted",
@@ -206,16 +205,6 @@ class TriggerRules(str, Enum):
     none_skipped: str = "none_skipped"
 
 
-class TriggerState(str, Enum):
-    waiting: str = "waiting"
-    passed: str = "passed"
-    skipped: str = "skipped"
-    failed: str = "failed"
-
-    def is_waiting(self):
-        return self.value == "waiting"
-
-
 class RunsOnType(str, Enum):
     """Runs-On enum object."""
 
@@ -407,30 +396,31 @@ class Job(BaseModel):
     def check_needs(
         self,
         jobs: dict[str, Any],
-    ) -> TriggerState:  # pragma: no cov
-        """Return True if job's need exists in an input list of job's ID.
+    ) -> Status:  # pragma: no cov
+        """Return Status enum for checking job's need trigger logic in an
+        input list of job's ID.
 
         :param jobs: A mapping of job ID and result context.
 
         :raise NotImplementedError: If the job trigger rule out of scope.
 
-        :rtype: TriggerState
+        :rtype: Status
         """
         if not self.needs:
-            return TriggerState.passed
+            return SUCCESS
 
-        def make_return(result: bool) -> TriggerState:
-            return TriggerState.passed if result else TriggerState.failed
+        def make_return(result: bool) -> Status:
+            return SUCCESS if result else FAILED
 
         need_exist: dict[str, Any] = {
             need: jobs[need] for need in self.needs if need in jobs
         }
         if len(need_exist) != len(self.needs):
-            return TriggerState.waiting
+            return WAIT
         elif all("skipped" in need_exist[job] for job in need_exist):
-            return TriggerState.skipped
+            return SKIP
         elif self.trigger_rule == TriggerRules.all_done:
-            return TriggerState.passed
+            return SUCCESS
         elif self.trigger_rule == TriggerRules.all_success:
             rs = all(
                 k not in need_exist[job]
@@ -674,7 +664,7 @@ def local_execute_strategy(
                 "strategy execution."
             )
             return result.catch(
-                status=Status.FAILED,
+                status=FAILED,
                 context={
                     strategy_id: {
                         "matrix": strategy,
@@ -724,7 +714,7 @@ def local_execute_strategy(
                 ) from None
 
             return result.catch(
-                status=Status.FAILED,
+                status=FAILED,
                 context={
                     strategy_id: {
                         "matrix": strategy,
@@ -735,7 +725,7 @@ def local_execute_strategy(
             )
 
     return result.catch(
-        status=Status.SUCCESS,
+        status=SUCCESS,
         context={
             strategy_id: {
                 "matrix": strategy,
@@ -790,7 +780,7 @@ def local_execute(
 
             if event and event.is_set():  # pragma: no cov
                 return result.catch(
-                    status=Status.FAILED,
+                    status=FAILED,
                     context={
                         "errors": JobException(
                             "Job strategy was canceled from event that had set "
@@ -808,7 +798,7 @@ def local_execute(
                 raise_error=raise_error,
             )
 
-        return result.catch(status=Status.SUCCESS)
+        return result.catch(status=SUCCESS)
 
     fail_fast_flag: bool = job.strategy.fail_fast
     ls: str = "Fail-Fast" if fail_fast_flag else "All-Completed"
@@ -819,7 +809,7 @@ def local_execute(
 
     if event and event.is_set():  # pragma: no cov
         return result.catch(
-            status=Status.FAILED,
+            status=FAILED,
             context={
                 "errors": JobException(
                     "Job strategy was canceled from event that had set "
@@ -849,7 +839,7 @@ def local_execute(
         ]
 
         context: DictData = {}
-        status: Status = Status.SUCCESS
+        status: Status = SUCCESS
 
         if not fail_fast_flag:
             done = as_completed(futures, timeout=1800)
@@ -875,7 +865,7 @@ def local_execute(
             try:
                 future.result()
             except JobException as err:
-                status = Status.FAILED
+                status = FAILED
                 result.trace.error(
                     f"[JOB]: {ls} Catch:\n\t{err.__class__.__name__}:"
                     f"\n\t{err}"
@@ -903,7 +893,7 @@ def self_hosted_execute(
     )
 
     if event and event.is_set():
-        return result.catch(status=Status.FAILED)
+        return result.catch(status=FAILED)
 
     import requests
 
@@ -922,5 +912,5 @@ def self_hosted_execute(
                 f"{job.runs_on.args.host!r}"
             )
 
-        return result.catch(status=Status.FAILED)
-    return result.catch(status=Status.SUCCESS)
+        return result.catch(status=FAILED)
+    return result.catch(status=SUCCESS)

ddeutil/workflow/params.py

@@ -3,7 +3,6 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-# [ ] Use config
 """This module include all Param Pydantic Models that use for parsing an
 incoming parameters that was passed to the Workflow and Schedule objects before
 execution or release methods.
@@ -18,6 +17,7 @@ from abc import ABC, abstractmethod
 from datetime import date, datetime
 from typing import Annotated, Any, Literal, Optional, TypeVar, Union
 
+from ddeutil.core import str2dict, str2list
 from pydantic import BaseModel, Field
 
 from .__types import TupleStr
@@ -31,6 +31,8 @@ __all__: TupleStr = (
     "IntParam",
     "Param",
     "StrParam",
+    "ArrayParam",
+    "MapParam",
 )
 
 T = TypeVar("T")
@@ -42,7 +44,10 @@ class BaseParam(BaseModel, ABC):
     """
 
     desc: Optional[str] = Field(
-        default=None, description="A description of parameter providing."
+        default=None,
+        description=(
+            "A description of this parameter provide to the workflow model."
+        ),
     )
     required: bool = Field(
         default=True,
@@ -52,6 +57,7 @@ class BaseParam(BaseModel, ABC):
 
     @abstractmethod
     def receive(self, value: Optional[T] = None) -> T:
+        """Abstract method receive value to this parameter model."""
         raise NotImplementedError(
             "Receive value and validate typing before return valid value."
         )
@@ -66,13 +72,14 @@ class DefaultParam(BaseParam):
         default=False,
         description="A require flag for the default-able parameter value.",
     )
-    default: Optional[str] = Field(
+    default: Optional[Any] = Field(
         default=None,
         description="A default value if parameter does not pass.",
     )
 
     @abstractmethod
     def receive(self, value: Optional[Any] = None) -> Any:
+        """Abstract method receive value to this parameter model."""
         raise NotImplementedError(
             "Receive value and validate typing before return valid value."
         )
@@ -82,7 +89,10 @@ class DateParam(DefaultParam):  # pragma: no cov
     """Date parameter model."""
 
     type: Literal["date"] = "date"
-    default: date = Field(default_factory=get_d_now)
+    default: date = Field(
+        default_factory=get_d_now,
+        description="A default date that make from the current date func.",
+    )
 
     def receive(self, value: Optional[str | datetime | date] = None) -> date:
         """Receive value that match with date. If an input value pass with
@@ -116,7 +126,12 @@ class DatetimeParam(DefaultParam):
     """Datetime parameter model."""
 
     type: Literal["datetime"] = "datetime"
-    default: datetime = Field(default_factory=get_dt_now)
+    default: datetime = Field(
+        default_factory=get_dt_now,
+        description=(
+            "A default datetime that make from the current datetime func."
+        ),
+    )
 
     def receive(self, value: str | datetime | date | None = None) -> datetime:
         """Receive value that match with datetime. If an input value pass with
@@ -167,10 +182,6 @@ class IntParam(DefaultParam):
     """Integer parameter."""
 
     type: Literal["int"] = "int"
-    default: Optional[int] = Field(
-        default=None,
-        description="A default value if parameter does not pass.",
-    )
 
     def receive(self, value: int | None = None) -> int | None:
         """Receive value that match with int.
@@ -222,36 +233,84 @@ class ChoiceParam(BaseParam):
         return value
 
 
-# TODO: Not implement this parameter yet
 class MapParam(DefaultParam):  # pragma: no cov
+    """Map parameter."""
 
     type: Literal["map"] = "map"
-    default: dict[Any, Any] = Field(default_factory=dict)
+    default: dict[Any, Any] = Field(
+        default_factory=dict,
+        description="A default dict that make from the dict built-in func.",
+    )
+
+    def receive(
+        self,
+        value: Optional[Union[dict[Any, Any], str]] = None,
+    ) -> dict[Any, Any]:
+        """Receive value that match with map type.
 
-    def receive(self, value: Optional[dict[Any, Any]] = None) -> dict[Any, Any]:
+        :param value: A value that want to validate with map parameter type.
+        :rtype: dict[Any, Any]
+        """
         if value is None:
             return self.default
 
+        if isinstance(value, str):
+            try:
+                value: dict[Any, Any] = str2dict(value)
+            except ValueError as e:
+                raise ParamValueException(
+                    f"Value that want to convert to map does not support for "
+                    f"type: {type(value)}"
+                ) from e
+        elif not isinstance(value, dict):
+            raise ParamValueException(
+                f"Value of map param support only string-dict or dict type, "
+                f"not {type(value)}"
+            )
+        return value
+
 
-# TODO: Not implement this parameter yet
 class ArrayParam(DefaultParam):  # pragma: no cov
+    """Array parameter."""
 
     type: Literal["array"] = "array"
-    default: list[Any] = Field(default_factory=list)
+    default: list[Any] = Field(
+        default_factory=list,
+        description="A default list that make from the list built-in func.",
+    )
 
-    def receive(self, value: Optional[list[T]] = None) -> list[T]:
+    def receive(
+        self, value: Optional[Union[list[T], tuple[T, ...], str]] = None
+    ) -> list[T]:
+        """Receive value that match with array type.
+
+        :param value: A value that want to validate with array parameter type.
+        :rtype: list[Any]
+        """
         if value is None:
             return self.default
-        if not isinstance(value, list):
+        if isinstance(value, str):
+            try:
+                value: list[T] = str2list(value)
+            except ValueError as e:
+                raise ParamValueException(
+                    f"Value that want to convert to array does not support for "
+                    f"type: {type(value)}"
+                ) from e
+        elif isinstance(value, (tuple, set)):
+            return list(value)
+        elif not isinstance(value, list):
             raise ParamValueException(
-                f"Value that want to convert to array does not support for "
-                f"type: {type(value)}"
+                f"Value of map param support only string-list or list type, "
+                f"not {type(value)}"
             )
         return value
 
 
 Param = Annotated[
     Union[
+        MapParam,
+        ArrayParam,
         ChoiceParam,
         DatetimeParam,
         DateParam,

ddeutil/workflow/result.py

@@ -3,8 +3,8 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-"""This is the Result module. It is the data context transfer objects that use
-by all object in this package. This module provide Result dataclass.
+"""Result module. It is the data context transfer objects that use by all object
+in this package. This module provide Status enum object and Result dataclass.
 """
 from __future__ import annotations
 
@@ -23,13 +23,19 @@ from .logs import TraceLog, get_dt_tznow, get_trace
 from .utils import default_gen_id, gen_id
 
 __all__: TupleStr = (
+    "SUCCESS",
+    "FAILED",
+    "WAIT",
+    "SKIP",
     "Result",
     "Status",
 )
 
 
 class Status(IntEnum):
-    """Status Int Enum object."""
+    """Status Int Enum object that use for tracking execution status to the
+    Result dataclass object.
+    """
 
     SUCCESS: int = 0
     FAILED: int = 1
@@ -37,8 +43,17 @@ class Status(IntEnum):
     SKIP: int = 3
 
 
+SUCCESS = Status.SUCCESS
+FAILED = Status.FAILED
+WAIT = Status.WAIT
+SKIP = Status.SKIP
+
+
 @dataclass(
-    config=ConfigDict(arbitrary_types_allowed=True, use_enum_values=True)
+    config=ConfigDict(
+        arbitrary_types_allowed=True,
+        use_enum_values=True,
+    ),
 )
 class Result:
     """Result Pydantic Model for passing and receiving data context from any
@@ -49,8 +64,9 @@ class Result:
     and ``_run_id`` fields to comparing with other result instance.
     """
 
-    status: Status = field(default=Status.WAIT)
+    status: Status = field(default=WAIT)
     context: DictData = field(default_factory=dict)
+    errors: DictData = field(default_factory=dict)
     run_id: Optional[str] = field(default_factory=default_gen_id)
     parent_run_id: Optional[str] = field(default=None, compare=False)
     ts: datetime = field(default_factory=get_dt_tznow, compare=False)
@@ -64,9 +80,16 @@ class Result:
         run_id: str | None = None,
         parent_run_id: str | None = None,
         id_logic: str | None = None,
-    ) -> Self:  # pragma: no cov
+    ) -> Self:
         """Create the Result object or set parent running id if passing Result
         object.
+
+        :param result:
+        :param run_id:
+        :param parent_run_id:
+        :param id_logic:
+
+        :rtype: Self
         """
         if result is None:
             result: Result = cls(
@@ -101,18 +124,23 @@ class Result:
         self,
         status: int | Status,
         context: DictData | None = None,
+        error: DictData | None = None,
     ) -> Self:
         """Catch the status and context to this Result object. This method will
         use between a child execution return a result, and it wants to pass
         status and context to this object.
 
-        :param status:
-        :param context:
+        :param status: A status enum object.
+        :param context: A context data that will update to the current context.
+        :param error: An error data that will update to the current errors.
+
+        :rtype: Self
         """
         self.__dict__["status"] = (
             Status(status) if isinstance(status, int) else status
         )
         self.__dict__["context"].update(context or {})
+        self.__dict__["errors"].update(error or {})
         return self
 
     def alive_time(self) -> float:  # pragma: no cov

ddeutil/workflow/scheduler.py

@@ -56,14 +56,13 @@ from .conf import Loader, SimLoad, config, get_logger
 from .cron import On
 from .exceptions import ScheduleException, WorkflowException
 from .logs import Audit, get_audit
-from .result import Result, Status
+from .result import SUCCESS, Result
 from .utils import batch, delay
 from .workflow import Release, ReleaseQueue, Workflow, WorkflowTask
 
 P = ParamSpec("P")
-logger = get_logger("ddeutil.workflow")
 
-# NOTE: Adjust logging level on the `schedule` package.
+logger = get_logger("ddeutil.workflow")
 logging.getLogger("schedule").setLevel(logging.INFO)
 
 
@@ -393,7 +392,7 @@ class Schedule(BaseModel):
             audit=audit,
         )
 
-        return result.catch(status=Status.SUCCESS)
+        return result.catch(status=SUCCESS)
 
 
 ResultOrCancel = Union[type[CancelJob], Result]
@@ -572,9 +571,7 @@ def schedule_task(
         f"[SCHEDULE]: End schedule task that run since "
         f"{current_date:%Y-%m-%d %H:%M:%S} {'=' * 30}"
     )
-    return result.catch(
-        status=Status.SUCCESS, context={"task_date": current_date}
-    )
+    return result.catch(status=SUCCESS, context={"task_date": current_date})
 
 
 def monitor(
@@ -690,7 +687,7 @@ def scheduler_pending(
         f"[SCHEDULE]: Queue: {[list(queue[wf].queue) for wf in queue]}"
     )
     return result.catch(
-        status=Status.SUCCESS,
+        status=SUCCESS,
         context={
             "threads": [
                 {
@@ -759,7 +756,7 @@ def schedule_control(
         audit=audit,
     )
 
-    return result.catch(status=Status.SUCCESS, context={"schedules": schedules})
+    return result.catch(status=SUCCESS, context={"schedules": schedules})
 
 
 def schedule_runner(

ddeutil/workflow/stages.py

@@ -4,18 +4,18 @@
 # license information.
 # ------------------------------------------------------------------------------
 # [x] Use dynamic config
-"""Stage Model that use for getting stage data template from the Job Model.
-The stage handle the minimize task that run in some thread (same thread at
-its job owner) that mean it is the lowest executor of a workflow that can
-tracking logs.
+"""Stage model. It stores all stage model that use for getting stage data template
+from the Job Model. The stage handle the minimize task that run in some thread
+(same thread at its job owner) that mean it is the lowest executor of a workflow
+that can tracking logs.
 
     The output of stage execution only return 0 status because I do not want to
 handle stage error on this stage model. I think stage model should have a lot of
 use-case, and it does not worry when I want to create a new one.
 
-    Execution   --> Ok      --> Result with 0
+    Execution   --> Ok      --> Result with SUCCESS
 
-                --> Error   ┬-> Result with 1 (if env var was set)
+                --> Error   ┬-> Result with FAILED (if env var was set)
                             ╰-> Raise StageException(...)
 
     On the context I/O that pass to a stage object at execute process. The
@@ -52,7 +52,7 @@ from typing_extensions import Self
 from .__types import DictData, DictStr, TupleStr
 from .conf import dynamic
 from .exceptions import StageException, to_dict
-from .result import Result, Status
+from .result import FAILED, SUCCESS, Result, Status
 from .reusables import TagFunc, extract_call, not_in_template, param2template
 from .utils import (
     gen_id,
@@ -80,6 +80,10 @@ class BaseStage(BaseModel, ABC):
         This class is the abstraction class for any stage class.
     """
 
+    extras: DictData = Field(
+        default_factory=dict,
+        description="An extra override config values.",
+    )
     id: Optional[str] = Field(
         default=None,
         description=(
@@ -95,10 +99,6 @@ class BaseStage(BaseModel, ABC):
         description="A stage condition statement to allow stage executable.",
         alias="if",
     )
-    extras: DictData = Field(
-        default_factory=dict,
-        description="An extra override config values.",
-    )
 
     @property
     def iden(self) -> str:
@@ -170,12 +170,12 @@ class BaseStage(BaseModel, ABC):
         specific environment variable,`WORKFLOW_CORE_STAGE_RAISE_ERROR`.
 
             Execution   --> Ok      --> Result
-                                        |-status: Status.SUCCESS
+                                        |-status: SUCCESS
                                         ╰-context:
                                             ╰-outputs: ...
 
                         --> Error   --> Result (if env var was set)
-                                        |-status: Status.FAILED
+                                        |-status: FAILED
                                         ╰-errors:
                                             |-class: ...
                                             |-name: ...
@@ -209,26 +209,24 @@ class BaseStage(BaseModel, ABC):
 
         try:
             rs: Result = self.execute(params, result=result, event=event)
-            if to is not None:
-                return self.set_outputs(rs.context, to=to)
-            return rs
-        except Exception as err:
-            result.trace.error(f"[STAGE]: {err.__class__.__name__}: {err}")
+            return self.set_outputs(rs.context, to=to) if to is not None else rs
+        except Exception as e:
+            result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
 
             if dynamic("stage_raise_error", f=raise_error, extras=self.extras):
-                if isinstance(err, StageException):
+                if isinstance(e, StageException):
                     raise
 
                 raise StageException(
                     f"{self.__class__.__name__}: \n\t"
-                    f"{err.__class__.__name__}: {err}"
-                ) from None
+                    f"{e.__class__.__name__}: {e}"
+                ) from e
 
-            errors: DictData = {"errors": to_dict(err)}
+            errors: DictData = {"errors": to_dict(e)}
             if to is not None:
                 return self.set_outputs(errors, to=to)
 
-            return result.catch(status=Status.FAILED, context=errors)
+            return result.catch(status=FAILED, context=errors)
 
     def set_outputs(self, output: DictData, to: DictData) -> DictData:
         """Set an outputs from execution process to the received context. The
@@ -315,8 +313,8 @@ class BaseStage(BaseModel, ABC):
             if not isinstance(rs, bool):
                 raise TypeError("Return type of condition does not be boolean")
             return not rs
-        except Exception as err:
-            raise StageException(f"{err.__class__.__name__}: {err}") from err
+        except Exception as e:
+            raise StageException(f"{e.__class__.__name__}: {e}") from e
 
 
 class BaseAsyncStage(BaseStage):
@@ -393,25 +391,23 @@ class BaseAsyncStage(BaseStage):
             if to is not None:
                 return self.set_outputs(rs.context, to=to)
             return rs
-        except Exception as err:
-            await result.trace.aerror(
-                f"[STAGE]: {err.__class__.__name__}: {err}"
-            )
+        except Exception as e:
+            await result.trace.aerror(f"[STAGE]: {e.__class__.__name__}: {e}")
 
             if dynamic("stage_raise_error", f=raise_error, extras=self.extras):
-                if isinstance(err, StageException):
+                if isinstance(e, StageException):
                     raise
 
                 raise StageException(
                     f"{self.__class__.__name__}: \n\t"
-                    f"{err.__class__.__name__}: {err}"
+                    f"{e.__class__.__name__}: {e}"
                 ) from None
 
-            errors: DictData = {"errors": to_dict(err)}
+            errors: DictData = {"errors": to_dict(e)}
             if to is not None:
                 return self.set_outputs(errors, to=to)
 
-            return result.catch(status=Status.FAILED, context=errors)
+            return result.catch(status=FAILED, context=errors)
 
 
 class EmptyStage(BaseAsyncStage):
@@ -472,7 +468,7 @@ class EmptyStage(BaseAsyncStage):
                 result.trace.info(f"[STAGE]: ... sleep ({self.sleep} seconds)")
             time.sleep(self.sleep)
 
-        return result.catch(status=Status.SUCCESS)
+        return result.catch(status=SUCCESS)
 
     async def axecute(
         self,
@@ -510,7 +506,7 @@ class EmptyStage(BaseAsyncStage):
                 )
             await asyncio.sleep(self.sleep)
 
-        return result.catch(status=Status.SUCCESS)
+        return result.catch(status=SUCCESS)
 
 
 class BashStage(BaseStage):
@@ -619,17 +615,17 @@ class BashStage(BaseStage):
 
         if rs.returncode > 0:
             # NOTE: Prepare stderr message that returning from subprocess.
-            err: str = (
+            e: str = (
                 rs.stderr.encode("utf-8").decode("utf-16")
                 if "\\x00" in rs.stderr
                 else rs.stderr
             ).removesuffix("\n")
             raise StageException(
-                f"Subprocess: {err}\nRunning Statement:\n---\n"
+                f"Subprocess: {e}\nRunning Statement:\n---\n"
                 f"```bash\n{bash}\n```"
             )
         return result.catch(
-            status=Status.SUCCESS,
+            status=SUCCESS,
             context={
                 "return_code": rs.returncode,
                 "stdout": None if (out := rs.stdout.strip("\n")) == "" else out,
@@ -749,7 +745,7 @@ class PyStage(BaseStage):
         )
 
         return result.catch(
-            status=Status.SUCCESS, context={"locals": lc, "globals": gb}
+            status=SUCCESS, context={"locals": lc, "globals": gb}
         )
 
 
@@ -871,7 +867,7 @@ class CallStage(BaseStage):
                 f"Return type: '{t_func.name}@{t_func.tag}' does not serialize "
                 f"to result model, you change return type to `dict`."
             )
-        return result.catch(status=Status.SUCCESS, context=rs)
+        return result.catch(status=SUCCESS, context=rs)
 
 
 class TriggerStage(BaseStage):
@@ -999,19 +995,11 @@ class ParallelStage(BaseStage):  # pragma: no cov
                     ).context,
                     to=context,
                 )
-            except StageException as err:  # pragma: no cov
+            except StageException as e:  # pragma: no cov
                 result.trace.error(
-                    f"[STAGE]: Catch:\n\t{err.__class__.__name__}:" f"\n\t{err}"
-                )
-                context.update(
-                    {
-                        "errors": {
-                            "class": err,
-                            "name": err.__class__.__name__,
-                            "message": f"{err.__class__.__name__}: {err}",
-                        },
-                    },
+                    f"[STAGE]: Catch:\n\t{e.__class__.__name__}:" f"\n\t{e}"
                 )
+                context.update({"errors": e.to_dict()})
         return context
 
     def execute(
@@ -1041,7 +1029,7 @@ class ParallelStage(BaseStage):  # pragma: no cov
             f"[STAGE]: Parallel-Execute with {self.max_parallel_core} cores."
         )
         rs: DictData = {"parallel": {}}
-        status = Status.SUCCESS
+        status = SUCCESS
         with ThreadPoolExecutor(
             max_workers=self.max_parallel_core,
             thread_name_prefix="parallel_stage_exec_",
@@ -1065,7 +1053,7 @@ class ParallelStage(BaseStage):  # pragma: no cov
                 rs["parallel"][context.pop("branch")] = context
 
                 if "errors" in context:
-                    status = Status.FAILED
+                    status = FAILED
 
         return result.catch(status=status, context=rs)
 
@@ -1144,7 +1132,7 @@ class ForEachStage(BaseStage):
 
         result.trace.info(f"[STAGE]: Foreach-Execute: {foreach!r}.")
         rs: DictData = {"items": foreach, "foreach": {}}
-        status = Status.SUCCESS
+        status: Status = SUCCESS
         # TODO: Implement concurrent more than 1.
         for item in foreach:
             result.trace.debug(f"[STAGE]: Execute foreach item: {item!r}")
@@ -1161,21 +1149,12 @@ class ForEachStage(BaseStage):
                         ).context,
                         to=context,
                     )
-                except StageException as err:  # pragma: no cov
-                    status = Status.FAILED
+                except StageException as e:  # pragma: no cov
+                    status = FAILED
                     result.trace.error(
-                        f"[STAGE]: Catch:\n\t{err.__class__.__name__}:"
-                        f"\n\t{err}"
-                    )
-                    context.update(
-                        {
-                            "errors": {
-                                "class": err,
-                                "name": err.__class__.__name__,
-                                "message": f"{err.__class__.__name__}: {err}",
-                            },
-                        },
+                        f"[STAGE]: Catch:\n\t{e.__class__.__name__}:" f"\n\t{e}"
                     )
+                    context.update({"errors": e.to_dict()})
 
             rs["foreach"][item] = context
 
@@ -1288,7 +1267,7 @@ class CaseStage(BaseStage):  # pragma: no cov
             result: Result = Result(
                 run_id=gen_id(self.name + (self.id or ""), unique=True)
             )
-        status = Status.SUCCESS
+        status = SUCCESS
         _case = param2template(self.case, params, extras=self.extras)
         _else = None
         context = {}
@@ -1310,21 +1289,12 @@ class CaseStage(BaseStage):  # pragma: no cov
                         ).context,
                         to=context,
                     )
-                except StageException as err:  # pragma: no cov
-                    status = Status.FAILED
+                except StageException as e:  # pragma: no cov
+                    status = FAILED
                     result.trace.error(
-                        f"[STAGE]: Catch:\n\t{err.__class__.__name__}:"
-                        f"\n\t{err}"
-                    )
-                    context.update(
-                        {
-                            "errors": {
-                                "class": err,
-                                "name": err.__class__.__name__,
-                                "message": f"{err.__class__.__name__}: {err}",
-                            },
-                        },
+                        f"[STAGE]: Catch:\n\t{e.__class__.__name__}:" f"\n\t{e}"
                     )
+                    context.update({"errors": e.to_dict()})
 
         return result.catch(status=status, context=context)
 

ddeutil/workflow/workflow.py

@@ -35,10 +35,10 @@ from .__types import DictData, TupleStr
 from .conf import Loader, SimLoad, dynamic, get_logger
 from .cron import On
 from .exceptions import JobException, WorkflowException
-from .job import Job, TriggerState
+from .job import Job
 from .logs import Audit, get_audit
 from .params import Param
-from .result import Result, Status
+from .result import FAILED, SKIP, SUCCESS, WAIT, Result, Status
 from .reusables import has_template, param2template
 from .utils import (
     gen_id,
@@ -673,7 +673,7 @@ class Workflow(BaseModel):
         )
 
         return result.catch(
-            status=Status.SUCCESS,
+            status=SUCCESS,
             context={
                 "params": params,
                 "release": {
@@ -804,7 +804,7 @@ class Workflow(BaseModel):
             result.trace.info(
                 f"[POKING]: {self.name!r} does not have any schedule to run."
             )
-            return result.catch(status=Status.SUCCESS, context={"outputs": []})
+            return result.catch(status=SUCCESS, context={"outputs": []})
 
         # NOTE: Create the current date that change microsecond to 0
         current_date: datetime = datetime.now(
@@ -850,7 +850,7 @@ class Workflow(BaseModel):
             result.trace.info(
                 f"[POKING]: {self.name!r} does not have any queue."
             )
-            return result.catch(status=Status.SUCCESS, context={"outputs": []})
+            return result.catch(status=SUCCESS, context={"outputs": []})
 
         # NOTE: Start create the thread pool executor for running this poke
         #   process.
@@ -912,7 +912,7 @@ class Workflow(BaseModel):
                 context.append(future.result())
 
         return result.catch(
-            status=Status.SUCCESS,
+            status=SUCCESS,
             context={"outputs": context},
         )
 
@@ -991,7 +991,7 @@ class Workflow(BaseModel):
                 "Handle error from the job execution does not support yet."
             ) from None
 
-        return result.catch(status=Status.SUCCESS, context=params)
+        return result.catch(status=SUCCESS, context=params)
 
     def execute(
         self,
@@ -1048,7 +1048,7 @@ class Workflow(BaseModel):
             result.trace.warning(
                 f"[WORKFLOW]: {self.name!r} does not have any jobs"
             )
-            return result.catch(status=Status.SUCCESS, context=params)
+            return result.catch(status=SUCCESS, context=params)
 
         # NOTE: Create a job queue that keep the job that want to run after
         #   its dependency condition.
@@ -1065,7 +1065,7 @@ class Workflow(BaseModel):
         #   }
         #
         context: DictData = self.parameterize(params)
-        status: Status = Status.SUCCESS
+        status: Status = SUCCESS
         try:
             if (
                 dynamic(
@@ -1091,7 +1091,7 @@ class Workflow(BaseModel):
                     event=event,
                 )
         except WorkflowException as err:
-            status = Status.FAILED
+            status = FAILED
             context.update({"errors": err.to_dict()})
 
         return result.catch(status=status, context=context)
@@ -1142,16 +1142,16 @@ class Workflow(BaseModel):
                 job_id: str = job_queue.get()
                 job: Job = self.jobs[job_id]
 
-                if (check := job.check_needs(context["jobs"])).is_waiting():
+                if (check := job.check_needs(context["jobs"])) == WAIT:
                     job_queue.task_done()
                     job_queue.put(job_id)
                     time.sleep(0.15)
                     continue
-                elif check == TriggerState.failed:  # pragma: no cov
+                elif check == FAILED:  # pragma: no cov
                     raise WorkflowException(
                         "Check job trigger rule was failed."
                     )
-                elif check == TriggerState.skipped:  # pragma: no cov
+                elif check == SKIP:  # pragma: no cov
                     result.trace.info(f"[JOB]: Skip job: {job_id!r}")
                     job.set_outputs({"SKIP": {"skipped": True}}, to=context)
                     job_queue.task_done()
@@ -1249,14 +1249,14 @@ class Workflow(BaseModel):
             job_id: str = job_queue.get()
             job: Job = self.jobs[job_id]
 
-            if (check := job.check_needs(context["jobs"])).is_waiting():
+            if (check := job.check_needs(context["jobs"])) == WAIT:
                 job_queue.task_done()
                 job_queue.put(job_id)
                 time.sleep(0.075)
                 continue
-            elif check == TriggerState.failed:  # pragma: no cov
+            elif check == FAILED:  # pragma: no cov
                 raise WorkflowException("Check job trigger rule was failed.")
-            elif check == TriggerState.skipped:  # pragma: no cov
+            elif check == SKIP:  # pragma: no cov
                 result.trace.info(f"[JOB]: Skip job: {job_id!r}")
                 job.set_outputs({"SKIP": {"skipped": True}}, to=context)
                 job_queue.task_done()

{ddeutil_workflow-0.0.42.dist-info → ddeutil_workflow-0.0.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.42
+Version: 0.0.43
 Summary: Lightweight workflow orchestration
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: ddeutil>=0.4.6
+Requires-Dist: ddeutil[checksum]>=0.4.6
 Requires-Dist: ddeutil-io[toml,yaml]>=0.2.10
 Requires-Dist: pydantic==2.11.1
 Requires-Dist: python-dotenv==1.1.0
@@ -212,7 +212,7 @@ execution time such as `run-date` should change base on that workflow running da
 ```python
 from ddeutil.workflow import Workflow, Result
 
-workflow: Workflow = Workflow.from_loader('run-py-local')
+workflow: Workflow = Workflow.from_conf('run-py-local')
 result: Result = workflow.execute(
    params={"source-extract": "USD-THB", "asat-dt": "2024-01-01"}
 )
@@ -246,7 +246,7 @@ from ddeutil.workflow import Schedule
 
 (
    Schedule
-   .from_loader("schedule-run-local-wf")
+   .from_conf("schedule-run-local-wf")
    .pending(stop=None)
 )
 ```
@@ -261,31 +261,31 @@ it will use default value and do not raise any error to you.
 > The config value that you will set on the environment should combine with
 > prefix, component, and name which is `WORKFLOW_{component}_{name}` (Upper case).
 
-| Name                         | Component | Default                                                                                                                         | Description                                                                                                        |
-|:-----------------------------|:---------:|:--------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------|
-| **ROOT_PATH**                |   Core    | `.`                                                                                                                             | The root path of the workflow application.                                                                         |
-| **REGISTRY_CALLER**          |   Core    | `.`                                                                                                                             | List of importable string for the call stage.                                                                      |
-| **REGISTRY_FILTER**          |   Core    | `ddeutil.workflow.templates`                                                                                                    | List of importable string for the filter template.                                                                 |
-| **CONF_PATH**                |   Core    | `conf`                                                                                                                          | The config path that keep all template `.yaml` files.                                                              |
-| **TIMEZONE**                 |   Core    | `Asia/Bangkok`                                                                                                                  | A Timezone string value that will pass to `ZoneInfo` object.                                                       |
-| **STAGE_DEFAULT_ID**         |   Core    | `true`                                                                                                                          | A flag that enable default stage ID that use for catch an execution output.                                        |
-| **STAGE_RAISE_ERROR**        |   Core    | `false`                                                                                                                         | A flag that all stage raise StageException from stage execution.                                                   |
-| **JOB_DEFAULT_ID**           |   Core    | `false`                                                                                                                         | A flag that enable default job ID that use for catch an execution output. The ID that use will be sequence number. |
-| **JOB_RAISE_ERROR**          |   Core    | `true`                                                                                                                          | A flag that all job raise JobException from job strategy execution.                                                |
-| **MAX_CRON_PER_WORKFLOW**    |   Core    | `5`                                                                                                                             |                                                                                                                    |
-| **MAX_QUEUE_COMPLETE_HIST**  |   Core    | `16`                                                                                                                            |                                                                                                                    |
-| **GENERATE_ID_SIMPLE_MODE**  |   Core    | `true`                                                                                                                          | A flog that enable generating ID with `md5` algorithm.                                                             |
-| **TRACE_PATH**               |    Log    | `./logs`                                                                                                                        | The log path of the workflow saving log.                                                                           |
-| **DEBUG_MODE**               |    Log    | `true`                                                                                                                          | A flag that enable logging with debug level mode.                                                                  |
-| **FORMAT**                   |    Log    | `%(asctime)s.%(msecs)03d (%(name)-10s, %(process)-5d,%(thread)-5d) [%(levelname)-7s] %(message)-120s (%(filename)s:%(lineno)s)` |                                                                                                                    |
-| **FORMAT_FILE**              |    Log    | `{datetime} ({process:5d}, {thread:5d}) {message:120s} ({filename}:{lineno})`                                                   |                                                                                                                    |
-| **DATETIME_FORMAT**          |    Log    | `%Y-%m-%d %H:%M:%S`                                                                                                             |                                                                                                                    |
-| **TRACE_ENABLE_WRITE**       |    Log    | `false`                                                                                                                         |                                                                                                                    |
-| **AUDIT_PATH**               |    Log    | `./audits`                                                                                                                      |                                                                                                                    |
-| **AUDIT_ENABLE_WRITE**       |    Log    | `true`                                                                                                                          | A flag that enable logging object saving log to its destination.                                                   |
-| **MAX_PROCESS**              |    App    | `2`                                                                                                                             | The maximum process worker number that run in scheduler app module.                                                |
-| **MAX_SCHEDULE_PER_PROCESS** |    App    | `100`                                                                                                                           | A schedule per process that run parallel.                                                                          |
-| **STOP_BOUNDARY_DELTA**      |    App    | `'{"minutes": 5, "seconds": 20}'`                                                                                               | A time delta value that use to stop scheduler app in json string format.                                           |
+| Name                         | Component | Default                                                                                                                         | Override | Description                                                                                                        |
+|:-----------------------------|:---------:|:--------------------------------------------------------------------------------------------------------------------------------|:--------:|:-------------------------------------------------------------------------------------------------------------------|
+| **ROOT_PATH**                |   Core    | `.`                                                                                                                             |    No    | The root path of the workflow application.                                                                         |
+| **REGISTRY_CALLER**          |   Core    | `.`                                                                                                                             |   Yes    | List of importable string for the call stage.                                                                      |
+| **REGISTRY_FILTER**          |   Core    | `ddeutil.workflow.templates`                                                                                                    |   Yes    | List of importable string for the filter template.                                                                 |
+| **CONF_PATH**                |   Core    | `conf`                                                                                                                          |    No    | The config path that keep all template `.yaml` files.                                                              |
+| **TIMEZONE**                 |   Core    | `Asia/Bangkok`                                                                                                                  |    No    | A Timezone string value that will pass to `ZoneInfo` object.                                                       |
+| **STAGE_DEFAULT_ID**         |   Core    | `true`                                                                                                                          |    No    | A flag that enable default stage ID that use for catch an execution output.                                        |
+| **STAGE_RAISE_ERROR**        |   Core    | `false`                                                                                                                         |   Yes    | A flag that all stage raise StageException from stage execution.                                                   |
+| **JOB_DEFAULT_ID**           |   Core    | `false`                                                                                                                         |    No    | A flag that enable default job ID that use for catch an execution output. The ID that use will be sequence number. |
+| **JOB_RAISE_ERROR**          |   Core    | `true`                                                                                                                          |   Yes    | A flag that all job raise JobException from job strategy execution.                                                |
+| **MAX_CRON_PER_WORKFLOW**    |   Core    | `5`                                                                                                                             |    No    |                                                                                                                    |
+| **MAX_QUEUE_COMPLETE_HIST**  |   Core    | `16`                                                                                                                            |    No    |                                                                                                                    |
+| **GENERATE_ID_SIMPLE_MODE**  |   Core    | `true`                                                                                                                          |    No    | A flog that enable generating ID with `md5` algorithm.                                                             |
+| **DEBUG_MODE**               |    Log    | `true`                                                                                                                          |    No    | A flag that enable logging with debug level mode.                                                                  |
+| **FORMAT**                   |    Log    | `%(asctime)s.%(msecs)03d (%(name)-10s, %(process)-5d,%(thread)-5d) [%(levelname)-7s] %(message)-120s (%(filename)s:%(lineno)s)` |    No    |                                                                                                                    |
+| **FORMAT_FILE**              |    Log    | `{datetime} ({process:5d}, {thread:5d}) {message:120s} ({filename}:{lineno})`                                                   |    No    |                                                                                                                    |
+| **DATETIME_FORMAT**          |    Log    | `%Y-%m-%d %H:%M:%S`                                                                                                             |    No    |                                                                                                                    |
+| **TRACE_PATH**               |    Log    | `./logs`                                                                                                                        |    No    | The log path of the workflow saving log.                                                                           |
+| **TRACE_ENABLE_WRITE**       |    Log    | `false`                                                                                                                         |    No    |                                                                                                                    |
+| **AUDIT_PATH**               |    Log    | `./audits`                                                                                                                      |    No    |                                                                                                                    |
+| **AUDIT_ENABLE_WRITE**       |    Log    | `true`                                                                                                                          |    No    | A flag that enable logging object saving log to its destination.                                                   |
+| **MAX_PROCESS**              |    App    | `2`                                                                                                                             |    No    | The maximum process worker number that run in scheduler app module.                                                |
+| **MAX_SCHEDULE_PER_PROCESS** |    App    | `100`                                                                                                                           |    No    | A schedule per process that run parallel.                                                                          |
+| **STOP_BOUNDARY_DELTA**      |    App    | `'{"minutes": 5, "seconds": 20}'`                                                                                               |    No    | A time delta value that use to stop scheduler app in json string format.                                           |
 
 **API Application**:
 

{ddeutil_workflow-0.0.42.dist-info → ddeutil_workflow-0.0.43.dist-info}/RECORD

@@ -1,19 +1,19 @@
-ddeutil/workflow/__about__.py,sha256=B3KiwXw9ATZmMG1vER6qdPImMLkQPPjYkRvYepuIhF4,28
+ddeutil/workflow/__about__.py,sha256=feByUkEJfWx0d1Lb9oGvd2f3clHHuGXDT7T7Ki5zoEA,28
 ddeutil/workflow/__cron.py,sha256=h8rLeIUAAEB2SdZ4Jhch7LU1Yl3bbJ-iNNJ3tQ0eYVM,28095
-ddeutil/workflow/__init__.py,sha256=cYWwG2utpsYvdwqvkFSRWi_Q6gylDgNQBcIWcF5NFs4,1861
+ddeutil/workflow/__init__.py,sha256=m7ZTCuUOarcTKJuXOyuaXd5WTIO7NTkqCeCrNX3d5i8,1943
 ddeutil/workflow/__types.py,sha256=8jBdbfb3aZSetjz0mvNrpGHwwxJff7mK8_4v41cLqlc,4316
 ddeutil/workflow/conf.py,sha256=lDzWiVSNlNAhTzxbNIhIbQAIF1ggbmetAp0yn2fgnsc,12385
 ddeutil/workflow/cron.py,sha256=80SijzMdDOBxTWRsiF-Fmuz7Ym7leY0XT2lzRAPGdXc,8781
-ddeutil/workflow/exceptions.py,sha256=fO37f9p7lOjIJgVOpKE_1X44yJTwBepyukZV9a7NNm4,1241
-ddeutil/workflow/job.py,sha256=vsayKMzwKDpjchgYQnbshZHnp-vuM9CobpFWhUJETRU,30315
+ddeutil/workflow/exceptions.py,sha256=uLNxzav3HRcr4vaZnvbUIF_eTR6UXXZNaxroMWFOUL4,1418
+ddeutil/workflow/job.py,sha256=6CqLb1F_z3mHU_rOVRY7Z2V2B1tY3p7FZIJgb8DM1YE,29969
 ddeutil/workflow/logs.py,sha256=RkM5o_JPoWhFY7NrbYAARZQWjLC62YB_FYzTTcyDp8U,19816
-ddeutil/workflow/params.py,sha256=Mv-D2DY5inm1ug0lsgCPDkO5wT_AUhc5XEF5jxgDx6U,8036
-ddeutil/workflow/result.py,sha256=ynZB0g_vEEXn24034J-hatjNWDBmRAj38S8SqGRM-8I,4029
+ddeutil/workflow/params.py,sha256=xCtFEh0-G-G-f8y_SXxyf31bU6Ox5p5Z-WbBFXrjy8M,9960
+ddeutil/workflow/result.py,sha256=iwkUzOubxhLCuO-ngWEWL6t-CpYBpINIIO_ubg4kz14,4701
 ddeutil/workflow/reusables.py,sha256=AtZO83HDFu1uK_azUinv5d8jsA36f2i3n_tqMrolbvc,17529
-ddeutil/workflow/scheduler.py,sha256=wFEgcnxtgF-8y5otv8RqT1MuBttZl7mu-bBu5ffwV_Y,27534
-ddeutil/workflow/stages.py,sha256=prw1-za1zwYehbrjeAnoJ79GxpfTqdKLsI2PY0OuSlY,48417
+ddeutil/workflow/scheduler.py,sha256=_MDsEHbBVOeF-381U8DfIMDyca_nG3XNXmgX4229_EU,27437
+ddeutil/workflow/stages.py,sha256=RMyOU9KqPhS-49kQduT6-iysGJZFwX0Cbgo9o8kzIAY,47304
 ddeutil/workflow/utils.py,sha256=sblje9qOtejCHVt8EVrbC0KY98vKqvxccaR5HIkRiTA,7363
-ddeutil/workflow/workflow.py,sha256=Y1D5arh2KSobkIZGJ1fWSTe15heURi9OhhdfIr0jHyo,50591
+ddeutil/workflow/workflow.py,sha256=LPZzGNf55Tca0XXQZytTiyWbocC1T47cB_XsWpiXdyc,50482
 ddeutil/workflow/api/__init__.py,sha256=F53NMBWtb9IKaDWkPU5KvybGGfKAcbehgn6TLBwHuuM,21
 ddeutil/workflow/api/api.py,sha256=b-bMg0aRsEqt8Qb2hNUtamEt2Fq2CgNotF2oXSAdDu8,5226
 ddeutil/workflow/api/log.py,sha256=NMTnOnsBrDB5129329xF2myLdrb-z9k1MQrmrP7qXJw,1818
@@ -23,8 +23,8 @@ ddeutil/workflow/api/routes/job.py,sha256=YVta083i8vU8-o4WdKFwDpfdC9vN1dZ6goZSmN
 ddeutil/workflow/api/routes/logs.py,sha256=TeRDrEelbKS2Hu_EovgLh0bOdmSv9mfnrIZsrE7uPD4,5353
 ddeutil/workflow/api/routes/schedules.py,sha256=rUWBm5RgLS1PNBHSWwWXJ0l-c5mYWfl9os0BA9_OTEw,4810
 ddeutil/workflow/api/routes/workflows.py,sha256=ctgQGxXfpIV6bHFDM9IQ1_qaQHT6n5-HjJ1-D4GKWpc,4527
-ddeutil_workflow-0.0.42.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.42.dist-info/METADATA,sha256=TJp1M40eLXYOInkTpl_XhFOWGHLd0hIHktXQXiFsmEw,18853
-ddeutil_workflow-0.0.42.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ddeutil_workflow-0.0.42.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.42.dist-info/RECORD,,
+ddeutil_workflow-0.0.43.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.43.dist-info/METADATA,sha256=eOwkhUh-w_bSW0LOlOCielBQTg0mvf2gEkkNMlbwIU4,19134
+ddeutil_workflow-0.0.43.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ddeutil_workflow-0.0.43.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.43.dist-info/RECORD,,