ddeutil-workflow 0.0.14__py3-none-any.whl → 0.0.16__py3-none-any.whl

ddeutil/workflow/utils.py

@@ -7,7 +7,6 @@ from __future__ import annotations
 
 import inspect
 import logging
-import os
 import stat
 import time
 from abc import ABC, abstractmethod
@@ -15,7 +14,7 @@ from ast import Call, Constant, Expr, Module, Name, parse
 from collections.abc import Iterator
 from dataclasses import field
 from datetime import date, datetime
-from functools import cached_property, wraps
+from functools import wraps
 from hashlib import md5
 from importlib import import_module
 from inspect import isfunction
@@ -30,17 +29,15 @@ try:
 except ImportError:
     from typing_extensions import ParamSpec
 
-from ddeutil.core import getdot, hasdot, hash_str, import_string, lazy, str2bool
-from ddeutil.io import PathData, PathSearch, YamlFlResolve, search_env_replace
-from ddeutil.io.models.lineage import dt_now
-from pydantic import BaseModel, ConfigDict, Field
+from ddeutil.core import getdot, hasdot, hash_str, import_string, lazy
+from ddeutil.io import search_env_replace
+from pydantic import BaseModel, Field
 from pydantic.dataclasses import dataclass
-from pydantic.functional_serializers import field_serializer
 from pydantic.functional_validators import model_validator
 from typing_extensions import Self
 
 from .__types import DictData, Matrix, Re
-from .conf import config
+from .conf import config, load_config
 from .exceptions import ParamValueException, UtilException
 
 P = ParamSpec("P")
@@ -50,16 +47,30 @@ AnyModelType = type[AnyModel]
 logger = logging.getLogger("ddeutil.workflow")
 
 
-def get_diff_sec(dt: datetime, tz: ZoneInfo | None = None) -> int:
+def get_dt_now(tz: ZoneInfo | None = None) -> datetime:  # pragma: no cov
+    """Return the current datetime object.
+
+    :param tz:
+    :return: The current datetime object that use an input timezone or UTC.
+    """
+    return datetime.now(tz=(tz or ZoneInfo("UTC")))
+
+
+def get_diff_sec(
+    dt: datetime, tz: ZoneInfo | None = None
+) -> int:  # pragma: no cov
     """Return second value that come from diff of an input datetime and the
     current datetime with specific timezone.
+
+    :param dt:
+    :param tz:
     """
     return round(
         (dt - datetime.now(tz=(tz or ZoneInfo("UTC")))).total_seconds()
     )
 
 
-def delay(second: float = 0) -> None:
+def delay(second: float = 0) -> None:  # pragma: no cov
     """Delay time that use time.sleep with random second value between
     0.00 - 0.99 seconds.
 
@@ -68,197 +79,6 @@ def delay(second: float = 0) -> None:
     time.sleep(second + randrange(0, 99, step=10) / 100)
 
 
-class Engine(BaseModel):
-    """Engine Model"""
-
-    paths: PathData = Field(default_factory=PathData)
-    registry: list[str] = Field(
-        default_factory=lambda: ["ddeutil.workflow"],  # pragma: no cover
-    )
-    registry_filter: list[str] = Field(
-        default_factory=lambda: ["ddeutil.workflow.utils"],  # pragma: no cover
-    )
-
-    @model_validator(mode="before")
-    def __prepare_registry(cls, values: DictData) -> DictData:
-        """Prepare registry value that passing with string type. It convert the
-        string type to list of string.
-        """
-        if (_regis := values.get("registry")) and isinstance(_regis, str):
-            values["registry"] = [_regis]
-        if (_regis_filter := values.get("registry_filter")) and isinstance(
-            _regis, str
-        ):
-            values["registry_filter"] = [_regis_filter]
-        return values
-
-
-class CoreConf(BaseModel):
-    """Core Config Model"""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    tz: ZoneInfo = Field(default_factory=lambda: ZoneInfo("UTC"))
-
-
-class ConfParams(BaseModel):
-    """Params Model"""
-
-    engine: Engine = Field(
-        default_factory=Engine,
-        description="A engine mapping values.",
-    )
-    core: CoreConf = Field(
-        default_factory=CoreConf,
-        description="A core config value",
-    )
-
-
-def load_config() -> ConfParams:
-    """Load Config data from ``workflows-conf.yaml`` file.
-
-    Configuration Docs:
-    ---
-    :var engine.registry:
-    :var engine.registry_filter:
-    :var paths.root:
-    :var paths.conf:
-    """
-    root_path: str = os.getenv("WORKFLOW_ROOT_PATH", ".")
-
-    regis: list[str] = ["ddeutil.workflow"]
-    if regis_env := os.getenv("WORKFLOW_CORE_REGISTRY"):
-        regis = [r.strip() for r in regis_env.split(",")]
-
-    regis_filter: list[str] = ["ddeutil.workflow.utils"]
-    if regis_filter_env := os.getenv("WORKFLOW_CORE_REGISTRY_FILTER"):
-        regis_filter = [r.strip() for r in regis_filter_env.split(",")]
-
-    conf_path: str = (
-        f"{root_path}/{conf_env}"
-        if (conf_env := os.getenv("WORKFLOW_CORE_PATH_CONF"))
-        else None
-    )
-    return ConfParams.model_validate(
-        obj={
-            "engine": {
-                "registry": regis,
-                "registry_filter": regis_filter,
-                "paths": {
-                    "root": root_path,
-                    "conf": conf_path,
-                },
-            },
-        }
-    )
-
-
-class SimLoad:
-    """Simple Load Object that will search config data by given some identity
-    value like name of workflow or on.
-
-    :param name: A name of config data that will read by Yaml Loader object.
-    :param params: A Params model object.
-    :param externals: An external parameters
-
-    Noted:
-
-        The config data should have ``type`` key for modeling validation that
-    make this loader know what is config should to do pass to.
-
-        ... <identity-key>:
-        ...     type: <importable-object>
-        ...     <key-data>: <value-data>
-        ...     ...
-
-    """
-
-    def __init__(
-        self,
-        name: str,
-        params: ConfParams,
-        externals: DictData | None = None,
-    ) -> None:
-        self.data: DictData = {}
-        for file in PathSearch(params.engine.paths.conf).files:
-            if any(file.suffix.endswith(s) for s in (".yml", ".yaml")) and (
-                data := YamlFlResolve(file).read().get(name, {})
-            ):
-                self.data = data
-
-        # VALIDATE: check the data that reading should not empty.
-        if not self.data:
-            raise ValueError(f"Config {name!r} does not found on conf path")
-
-        self.conf_params: ConfParams = params
-        self.externals: DictData = externals or {}
-        self.data.update(self.externals)
-
-    @classmethod
-    def finds(
-        cls,
-        obj: object,
-        params: ConfParams,
-        *,
-        include: list[str] | None = None,
-        exclude: list[str] | None = None,
-    ) -> Iterator[tuple[str, DictData]]:
-        """Find all data that match with object type in config path. This class
-        method can use include and exclude list of identity name for filter and
-        adds-on.
-        """
-        exclude: list[str] = exclude or []
-        for file in PathSearch(params.engine.paths.conf).files:
-            if any(file.suffix.endswith(s) for s in (".yml", ".yaml")) and (
-                values := YamlFlResolve(file).read()
-            ):
-                for key, data in values.items():
-                    if key in exclude:
-                        continue
-                    if issubclass(get_type(data["type"], params), obj) and (
-                        include is None or all(i in data for i in include)
-                    ):
-                        yield key, data
-
-    @cached_property
-    def type(self) -> AnyModelType:
-        """Return object of string type which implement on any registry. The
-        object type.
-
-        :rtype: AnyModelType
-        """
-        if not (_typ := self.data.get("type")):
-            raise ValueError(
-                f"the 'type' value: {_typ} does not exists in config data."
-            )
-        return get_type(_typ, self.conf_params)
-
-
-class Loader(SimLoad):
-    """Loader Object that get the config `yaml` file from current path.
-
-    :param name: A name of config data that will read by Yaml Loader object.
-    :param externals: An external parameters
-    """
-
-    @classmethod
-    def finds(
-        cls,
-        obj: object,
-        *,
-        include: list[str] | None = None,
-        exclude: list[str] | None = None,
-        **kwargs,
-    ) -> DictData:
-        """Override the find class method from the Simple Loader object."""
-        return super().finds(
-            obj=obj, params=load_config(), include=include, exclude=exclude
-        )
-
-    def __init__(self, name: str, externals: DictData) -> None:
-        super().__init__(name, load_config(), externals)
-
-
 def gen_id(
     value: Any,
     *,
@@ -266,9 +86,9 @@ def gen_id(
     unique: bool = False,
 ) -> str:
     """Generate running ID for able to tracking. This generate process use `md5`
-    algorithm function if ``WORKFLOW_CORE_PIPELINE_ID_SIMPLE`` set to false.
-    But it will cut this hashing value length to 10 it the setting value set to
-    true.
+    algorithm function if ``WORKFLOW_CORE_WORKFLOW_ID_SIMPLE_MODE`` set to
+    false. But it will cut this hashing value length to 10 it the setting value
+    set to true.
 
     :param value: A value that want to add to prefix before hashing with md5.
     :param sensitive: A flag that convert the value to lower case before hashing
@@ -279,7 +99,7 @@ def gen_id(
     if not isinstance(value, str):
         value: str = str(value)
 
-    if str2bool(os.getenv("WORKFLOW_CORE_PIPELINE_ID_SIMPLE", "true")):
+    if config.workflow_id_simple_mode:
         return hash_str(f"{(value if sensitive else value.lower())}", n=10) + (
             f"{datetime.now(tz=config.tz):%Y%m%d%H%M%S%f}" if unique else ""
         )
@@ -291,36 +111,22 @@ def gen_id(
     ).hexdigest()
 
 
-def get_type(t: str, params: ConfParams) -> AnyModelType:
-    """Return import type from string importable value in the type key.
-
-    :param t: A importable type string.
-    :param params: A config parameters that use registry to search this
-        type.
-    :rtype: AnyModelType
-    """
-    try:
-        # NOTE: Auto adding module prefix if it does not set
-        return import_string(f"ddeutil.workflow.{t}")
-    except ModuleNotFoundError:
-        for registry in params.engine.registry:
-            try:
-                return import_string(f"{registry}.{t}")
-            except ModuleNotFoundError:
-                continue
-        return import_string(f"{t}")
-
-
 class TagFunc(Protocol):
     """Tag Function Protocol"""
 
     name: str
     tag: str
 
-    def __call__(self, *args, **kwargs): ...
+    def __call__(self, *args, **kwargs): ...  # pragma: no cov
 
 
-def tag(name: str, alias: str | None = None) -> Callable[P, TagFunc]:
+ReturnTagFunc = Callable[P, TagFunc]
+DecoratorTagFunc = Callable[[Callable[[...], Any]], ReturnTagFunc]
+
+
+def tag(
+    name: str, alias: str | None = None
+) -> DecoratorTagFunc:  # pragma: no cov
     """Tag decorator function that set function attributes, ``tag`` and ``name``
     for making registries variable.
 
@@ -330,7 +136,7 @@ def tag(name: str, alias: str | None = None) -> Callable[P, TagFunc]:
     :rtype: Callable[P, TagFunc]
     """
 
-    def func_internal(func: Callable[[...], Any]) -> TagFunc:
+    def func_internal(func: Callable[[...], Any]) -> ReturnTagFunc:
         func.tag = name
         func.name = alias or func.__name__.replace("_", "-")
 
@@ -386,9 +192,14 @@ def make_registry(submodule: str) -> dict[str, Registry]:
 class BaseParam(BaseModel, ABC):
     """Base Parameter that use to make Params Model."""
 
-    desc: Optional[str] = None
-    required: bool = True
-    type: str
+    desc: Optional[str] = Field(
+        default=None, description="A description of parameter providing."
+    )
+    required: bool = Field(
+        default=True,
+        description="A require flag that force to pass this parameter value.",
+    )
+    type: str = Field(description="A type of parameter.")
 
     @abstractmethod
     def receive(self, value: Optional[Any] = None) -> Any:
@@ -396,15 +207,20 @@ class BaseParam(BaseModel, ABC):
             "Receive value and validate typing before return valid value."
         )
 
-    @field_serializer("type")
-    def __serializer_type(self, value: str) -> str:
-        return value
-
 
 class DefaultParam(BaseParam):
-    """Default Parameter that will check default if it required"""
+    """Default Parameter that will check default if it required. This model do
+    not implement the receive method.
+    """
 
-    default: Optional[str] = None
+    required: bool = Field(
+        default=False,
+        description="A require flag for the default-able parameter value.",
+    )
+    default: Optional[str] = Field(
+        default=None,
+        description="A default value if parameter does not pass.",
+    )
 
     @abstractmethod
     def receive(self, value: Optional[Any] = None) -> Any:
@@ -415,9 +231,9 @@ class DefaultParam(BaseParam):
     @model_validator(mode="after")
     def __check_default(self) -> Self:
         """Check default value should pass when it set required."""
-        if not self.required and self.default is None:
+        if self.required and self.default is None:
             raise ParamValueException(
-                "Default should set when this parameter does not required."
+                "Default should be set when this parameter was required."
             )
         return self
 
@@ -426,8 +242,7 @@ class DatetimeParam(DefaultParam):
     """Datetime parameter."""
 
     type: Literal["datetime"] = "datetime"
-    required: bool = False
-    default: datetime = Field(default_factory=dt_now)
+    default: datetime = Field(default_factory=get_dt_now)
 
     def receive(self, value: str | datetime | date | None = None) -> datetime:
         """Receive value that match with datetime. If a input value pass with
@@ -449,7 +264,12 @@ class DatetimeParam(DefaultParam):
                 f"Value that want to convert to datetime does not support for "
                 f"type: {type(value)}"
             )
-        return datetime.fromisoformat(value)
+        try:
+            return datetime.fromisoformat(value)
+        except ValueError:
+            raise ParamValueException(
+                f"Invalid isoformat string: {value!r}"
+            ) from None
 
 
 class StrParam(DefaultParam):
@@ -457,7 +277,7 @@ class StrParam(DefaultParam):
 
     type: Literal["str"] = "str"
 
-    def receive(self, value: Optional[str] = None) -> str | None:
+    def receive(self, value: str | None = None) -> str | None:
         """Receive value that match with str.
 
         :param value: A value that want to validate with string parameter type.
@@ -472,8 +292,12 @@ 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: Optional[int] = None) -> int | None:
+    def receive(self, value: int | None = None) -> int | None:
         """Receive value that match with int.
 
         :param value: A value that want to validate with integer parameter type.
@@ -484,10 +308,9 @@ class IntParam(DefaultParam):
         if not isinstance(value, int):
             try:
                 return int(str(value))
-            except TypeError as err:
+            except ValueError as err:
                 raise ParamValueException(
-                    f"Value that want to convert to integer does not support "
-                    f"for type: {type(value)}"
+                    f"Value can not convert to int, {value}, with base 10"
                 ) from err
         return value
 
@@ -496,15 +319,19 @@ class ChoiceParam(BaseParam):
     """Choice parameter."""
 
     type: Literal["choice"] = "choice"
-    options: list[str]
+    options: list[str] = Field(description="A list of choice parameters.")
+
+    def receive(self, value: str | None = None) -> str:
+        """Receive value that match with options.
 
-    def receive(self, value: Optional[str] = None) -> str:
-        """Receive value that match with options."""
+        :param value: A value that want to select from the options field.
+        :rtype: str
+        """
         # NOTE:
         #   Return the first value in options if does not pass any input value
         if value is None:
             return self.options[0]
-        if any(value not in self.options):
+        if value not in self.options:
             raise ParamValueException(
                 f"{value!r} does not match any value in choice options."
             )
@@ -531,7 +358,7 @@ class Result:
 
     status: int = field(default=2)
     context: DictData = field(default_factory=dict)
-    start_at: datetime = field(default_factory=dt_now, compare=False)
+    start_at: datetime = field(default_factory=get_dt_now, compare=False)
     end_at: Optional[datetime] = field(default=None, compare=False)
 
     # NOTE: Ignore this field to compare another result model with __eq__.
@@ -563,15 +390,15 @@ class Result:
         :param running_id: A running ID that want to update on this model.
         :rtype: Self
         """
-        self._parent_run_id = running_id
+        self._parent_run_id: str = running_id
         return self
 
     @property
-    def parent_run_id(self):
+    def parent_run_id(self) -> str:
         return self._parent_run_id
 
     @property
-    def run_id(self):
+    def run_id(self) -> str:
         return self._run_id
 
     def catch(self, status: int, context: DictData) -> Self:
@@ -608,8 +435,8 @@ class Result:
         self.__dict__["context"]["jobs"].update(result.context)
 
         # NOTE: Update running ID from an incoming result.
-        self._parent_run_id = result.parent_run_id
-        self._run_id = result.run_id
+        self._parent_run_id: str = result.parent_run_id
+        self._run_id: str = result.run_id
         return self
 
 
@@ -793,8 +620,8 @@ def not_in_template(value: Any, *, not_in: str = "matrix.") -> bool:
     elif not isinstance(value, str):
         return False
     return any(
-        (not found.group("caller").strip().startswith(not_in))
-        for found in Re.RE_CALLER.finditer(value.strip())
+        (not found.caller.strip().startswith(not_in))
+        for found in Re.finditer_caller(value.strip())
     )
 
 
@@ -835,18 +662,16 @@ def str2template(
 
     # NOTE: remove space before and after this string value.
     value: str = value.strip()
-    for found in Re.RE_CALLER.finditer(value):
+    for found in Re.finditer_caller(value):
         # NOTE:
         #   Get caller and filter values that setting inside;
         #
         #   ... ``${{ <caller-value> [ | <filter-value>] ... }}``
         #
-        caller: str = found.group("caller")
+        caller: str = found.caller
         pfilter: list[str] = [
             i.strip()
-            for i in (
-                found.group("post_filters").strip().removeprefix("|").split("|")
-            )
+            for i in (found.post_filters.strip().removeprefix("|").split("|"))
             if i != ""
         ]
         if not hasdot(caller, params):
@@ -859,7 +684,7 @@ def str2template(
         #   If type of getter caller is not string type and it does not use to
         #   concat other string value, it will return origin value from the
         #   ``getdot`` function.
-        if value.replace(found.group(0), "", 1) == "":
+        if value.replace(found.full, "", 1) == "":
             return map_post_filter(getter, pfilter, filters=filters)
 
         # NOTE: map post-filter function.
@@ -867,7 +692,7 @@ def str2template(
         if not isinstance(getter, str):
             getter: str = str(getter)
 
-        value: str = value.replace(found.group(0), getter, 1)
+        value: str = value.replace(found.full, getter, 1)
 
     return search_env_replace(value)
 

{ddeutil_workflow-0.0.14.dist-info → ddeutil_workflow-0.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddeutil-workflow
-Version: 0.0.14
+Version: 0.0.16
 Summary: Lightweight workflow orchestration with less dependencies
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -22,8 +22,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: ddeutil >=0.4.0
-Requires-Dist: ddeutil-io >=0.1.13
+Requires-Dist: ddeutil >=0.4.3
+Requires-Dist: ddeutil-io[yaml] >=0.2.3
 Requires-Dist: python-dotenv ==1.0.1
 Requires-Dist: typer <1.0.0,==0.12.5
 Requires-Dist: schedule <2.0.0,==1.2.2
@@ -179,29 +179,31 @@ The main configuration that use to dynamic changing with your propose of this
 application. If any configuration values do not set yet, it will use default value
 and do not raise any error to you.
 
-| Environment                         | Component | Default                          | Description                                                                |
-|-------------------------------------|-----------|----------------------------------|----------------------------------------------------------------------------|
-| `WORKFLOW_ROOT_PATH`                | Core      | .                                | The root path of the workflow application                                  |
-| `WORKFLOW_CORE_REGISTRY`            | Core      | src.ddeutil.workflow,tests.utils | List of importable string for the hook stage                               |
-| `WORKFLOW_CORE_REGISTRY_FILTER`     | Core      | ddeutil.workflow.utils           | List of importable string for the filter template                          |
-| `WORKFLOW_CORE_PATH_CONF`           | Core      | conf                             | The config path that keep all template `.yaml` files                       |
-| `WORKFLOW_CORE_TIMEZONE`            | Core      | Asia/Bangkok                     | A Timezone string value that will pass to `ZoneInfo` object                |
-| `WORKFLOW_CORE_STAGE_DEFAULT_ID`    | Core      | true                             | A flag that enable default stage ID that use for catch an execution output |
-| `WORKFLOW_CORE_STAGE_RAISE_ERROR`   | Core      | true                             | A flag that all stage raise StageException from stage execution            |
-| `WORKFLOW_CORE_MAX_NUM_POKING`      | Core      | 4                                |                                                                            |
-| `WORKFLOW_CORE_MAX_JOB_PARALLEL`    | Core      | 2                                | The maximum job number that able to run parallel in workflow executor      |
-| `WORKFLOW_LOG_DEBUG_MODE`           | Log       | true                             | A flag that enable logging with debug level mode                           |
-| `WORKFLOW_LOG_ENABLE_WRITE`         | Log       | true                             | A flag that enable logging object saving log to its destination            |
-| `WORKFLOW_APP_PROCESS_WORKER`       | Schedule  | 2                                | The maximum process worker number that run in scheduler app module         |
-| `WORKFLOW_APP_SCHEDULE_PER_PROCESS` | Schedule  | 100                              | A schedule per process that run parallel                                   |
-| `WORKFLOW_APP_STOP_BOUNDARY_DELTA`  | Schedule  | '{"minutes": 5, "seconds": 20}'  | A time delta value that use to stop scheduler app in json string format    |
+| Environment                             | Component | Default                          | Description                                                                                                        | Remark |
+|:----------------------------------------|-----------|----------------------------------|--------------------------------------------------------------------------------------------------------------------|--------|
+| `WORKFLOW_ROOT_PATH`                    | Core      | .                                | The root path of the workflow application                                                                          |        |
+| `WORKFLOW_CORE_REGISTRY`                | Core      | src.ddeutil.workflow,tests.utils | List of importable string for the hook stage                                                                       |        |
+| `WORKFLOW_CORE_REGISTRY_FILTER`         | Core      | ddeutil.workflow.utils           | List of importable string for the filter template                                                                  |        |
+| `WORKFLOW_CORE_PATH_CONF`               | Core      | conf                             | The config path that keep all template `.yaml` files                                                               |        |
+| `WORKFLOW_CORE_TIMEZONE`                | Core      | Asia/Bangkok                     | A Timezone string value that will pass to `ZoneInfo` object                                                        |        |
+| `WORKFLOW_CORE_STAGE_DEFAULT_ID`        | Core      | true                             | A flag that enable default stage ID that use for catch an execution output                                         |        |
+| `WORKFLOW_CORE_STAGE_RAISE_ERROR`       | Core      | false                            | A flag that all stage raise StageException from stage execution                                                    |        |
+| `WORKFLOW_CORE_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. |        |
+| `WORKFLOW_CORE_MAX_NUM_POKING`          | Core      | 4                                |                                                                                                                    |        |
+| `WORKFLOW_CORE_MAX_JOB_PARALLEL`        | Core      | 2                                | The maximum job number that able to run parallel in workflow executor                                              |        |
+| `WORKFLOW_CORE_WORKFLOW_ID_SIMPLE_MODE` | Core      | true                             |                                                                                                                    |        |
+| `WORKFLOW_LOG_DEBUG_MODE`               | Log       | true                             | A flag that enable logging with debug level mode                                                                   |        |
+| `WORKFLOW_LOG_ENABLE_WRITE`             | Log       | true                             | A flag that enable logging object saving log to its destination                                                    |        |
+| `WORKFLOW_APP_MAX_PROCESS`              | Schedule  | 2                                | The maximum process worker number that run in scheduler app module                                                 |        |
+| `WORKFLOW_APP_MAX_SCHEDULE_PER_PROCESS` | Schedule  | 100                              | A schedule per process that run parallel                                                                           |        |
+| `WORKFLOW_APP_STOP_BOUNDARY_DELTA`      | Schedule  | '{"minutes": 5, "seconds": 20}'  | A time delta value that use to stop scheduler app in json string format                                            |        |
 
 **API Application**:
 
-| Environment                          | Component | Default | Description                                                                       |
-|--------------------------------------|-----------|---------|-----------------------------------------------------------------------------------|
-| `WORKFLOW_API_ENABLE_ROUTE_WORKFLOW` | API       | true    | A flag that enable workflow route to manage execute manually and workflow logging |
-| `WORKFLOW_API_ENABLE_ROUTE_SCHEDULE` | API       | true    | A flag that enable run scheduler                                                  |
+| Environment                           | Component | Default | Description                                                                       | Remark |
+|:--------------------------------------|-----------|---------|-----------------------------------------------------------------------------------|--------|
+| `WORKFLOW_API_ENABLE_ROUTE_WORKFLOW`  | API       | true    | A flag that enable workflow route to manage execute manually and workflow logging |        |
+| `WORKFLOW_API_ENABLE_ROUTE_SCHEDULE`  | API       | true    | A flag that enable run scheduler                                                  |        |
 
 ## :rocket: Deployment
 
@@ -224,3 +226,17 @@ like crontab job but via Python API.
 > [!NOTE]
 > If this package already deploy, it able to use
 > `uvicorn ddeutil.workflow.api:app --host 127.0.0.1 --port 80 --workers 4`
+
+### Docker Container
+
+Create Docker image;
+
+```shell
+$ docker build -t ddeutil-workflow:latest -f .container/Dockerfile .
+```
+
+Run the above Docker image;
+
+```shell
+$ docker run -i ddeutil-workflow:latest
+```