ddeutil-workflow 0.0.23__py3-none-any.whl → 0.0.25__py3-none-any.whl

ddeutil/workflow/workflow.py

@@ -43,19 +43,18 @@ from typing_extensions import Self
 from .__cron import CronJob, CronRunner
 from .__types import DictData, TupleStr
 from .conf import FileLog, Loader, Log, config, get_logger
+from .cron import On
 from .exceptions import JobException, WorkflowException
 from .job import Job
-from .on import On
 from .params import Param
 from .result import Result
 from .utils import (
     cut_id,
-    delay,
     gen_id,
-    get_diff_sec,
     get_dt_now,
     has_template,
     param2template,
+    wait_a_minute,
 )
 
 logger = get_logger("ddeutil.workflow")
@@ -64,7 +63,7 @@ __all__: TupleStr = (
     "Workflow",
     "WorkflowRelease",
     "WorkflowQueue",
-    "WorkflowTaskData",
+    "WorkflowTask",
 )
 
 
@@ -168,7 +167,23 @@ class WorkflowQueue:
         """
         return len(self.queue) > 0
 
-    def check_queue(self, value: WorkflowRelease) -> bool:
+    @property
+    def first_queue(self) -> WorkflowRelease:
+        """Check an input WorkflowRelease object is the first value of the
+        waiting queue.
+
+        :rtype: bool
+        """
+        # NOTE: Old logic to peeking the first release from waiting queue.
+        #
+        # first_value: WorkflowRelease = heappop(self.queue)
+        # heappush(self.queue, first_value)
+        #
+        # return first_value
+        #
+        return self.queue[0]
+
+    def check_queue(self, value: WorkflowRelease | datetime) -> bool:
         """Check a WorkflowRelease value already exists in list of tracking
         queues.
 
@@ -177,27 +192,37 @@ class WorkflowQueue:
 
         :rtype: bool
         """
+        if isinstance(value, datetime):
+            value = WorkflowRelease.from_dt(value)
+
         return (
             (value in self.queue)
             or (value in self.running)
             or (value in self.complete)
         )
 
-    def push_queue(self, value: WorkflowRelease) -> Self:
-        """Push data to the queue."""
-        heappush(self.queue, value)
-        return self
-
-    def push_running(self, value: WorkflowRelease) -> Self:
-        """Push data to the running."""
-        heappush(self.running, value)
-        return self
-
     def remove_running(self, value: WorkflowRelease) -> Self:
-        """Remove data on the running if it exists."""
+        """Remove WorkflowRelease in the running queue if it exists."""
         if value in self.running:
             self.running.remove(value)
 
+    def mark_complete(self, value: WorkflowRelease) -> Self:
+        """Push WorkflowRelease to the complete queue."""
+        heappush(self.complete, value)
+
+        # NOTE: Remove complete queue on workflow that keep more than the
+        #   maximum config.
+        num_complete_delete: int = (
+            len(self.complete) - config.max_queue_complete_hist
+        )
+
+        if num_complete_delete > 0:
+            print(num_complete_delete)
+            for _ in range(num_complete_delete):
+                heappop(self.complete)
+
+        return self
+
 
 class Workflow(BaseModel):
     """Workflow Pydantic model.
@@ -249,7 +274,7 @@ class Workflow(BaseModel):
         loader: Loader = Loader(name, externals=(externals or {}))
 
         # NOTE: Validate the config type match with current connection model
-        if loader.type != cls:
+        if loader.type != cls.__name__:
             raise ValueError(f"Type {loader.type} does not match with {cls}")
 
         loader_data: DictData = copy.deepcopy(loader.data)
@@ -448,6 +473,7 @@ class Workflow(BaseModel):
         queue: (
             WorkflowQueue | list[datetime] | list[WorkflowRelease] | None
         ) = None,
+        override_log_name: str | None = None,
     ) -> Result:
         """Release the workflow execution with overriding parameter with the
         release templating that include logical date (release date), execution
@@ -456,18 +482,30 @@ class Workflow(BaseModel):
             This method allow workflow use log object to save the execution
         result to log destination like file log to the local `/logs` directory.
 
+        :Steps:
+            - Initialize WorkflowQueue and WorkflowRelease if they do not pass.
+            - Create release data for pass to parameter templating function.
+            - Execute this workflow with mapping release data to its parameters.
+            - Writing log
+            - Remove this release on the running queue
+            - Push this release to complete queue
+
         :param release: A release datetime or WorkflowRelease object.
         :param params: A workflow parameter that pass to execute method.
         :param queue: A list of release time that already queue.
         :param run_id: A workflow running ID for this release.
         :param log: A log class that want to save the execution result.
         :param queue: A WorkflowQueue object.
+        :param override_log_name: An override logging name that use instead
+            the workflow name.
 
         :rtype: Result
         """
         log: type[Log] = log or FileLog
-        run_id: str = run_id or gen_id(self.name, unique=True)
+        name: str = override_log_name or self.name
+        run_id: str = run_id or gen_id(name, unique=True)
         rs_release: Result = Result(run_id=run_id)
+        rs_release_type: str = "release"
 
         # VALIDATE: Change queue value to WorkflowQueue object.
         if queue is None or isinstance(queue, list):
@@ -475,10 +513,11 @@ class Workflow(BaseModel):
 
         # VALIDATE: Change release value to WorkflowRelease object.
         if isinstance(release, datetime):
+            rs_release_type: str = "datetime"
             release: WorkflowRelease = WorkflowRelease.from_dt(release)
 
         logger.debug(
-            f"({cut_id(run_id)}) [RELEASE]: {self.name!r} : Start release - "
+            f"({cut_id(run_id)}) [RELEASE]: Start release - {name!r} : "
             f"{release.date:%Y-%m-%d %H:%M:%S}"
         )
 
@@ -499,14 +538,14 @@ class Workflow(BaseModel):
             run_id=run_id,
         )
         logger.debug(
-            f"({cut_id(run_id)}) [RELEASE]: {self.name!r} : End release - "
+            f"({cut_id(run_id)}) [RELEASE]: End release - {name!r} : "
             f"{release.date:%Y-%m-%d %H:%M:%S}"
         )
 
         rs.set_parent_run_id(run_id)
         rs_log: Log = log.model_validate(
             {
-                "name": self.name,
+                "name": name,
                 "release": release.date,
                 "type": release.type,
                 "context": rs.context,
@@ -516,12 +555,14 @@ class Workflow(BaseModel):
         )
 
         # NOTE: Saving execution result to destination of the input log object.
+        logger.debug(f"({cut_id(run_id)}) [LOG]: Writing log: {name!r}.")
         rs_log.save(excluded=None)
 
         # NOTE: Remove this release from running.
         queue.remove_running(release)
-        heappush(queue.complete, release)
+        queue.mark_complete(release)
 
+        # NOTE: Remove the params key from the result context for deduplicate.
         context: dict[str, Any] = rs.context
         context.pop("params")
 
@@ -529,12 +570,17 @@ class Workflow(BaseModel):
             status=0,
             context={
                 "params": params,
-                "release": {"status": "success", "logical_date": release.date},
+                "release": {
+                    "status": "success",
+                    "type": rs_release_type,
+                    "logical_date": release.date,
+                    "release": release,
+                },
                 "outputs": context,
             },
         )
 
-    def queue_poking(
+    def queue(
         self,
         offset: float,
         end_date: datetime,
@@ -589,7 +635,7 @@ class Workflow(BaseModel):
                 continue
 
             # NOTE: Push the WorkflowRelease object to queue.
-            queue.push_queue(workflow_release)
+            heappush(queue.queue, workflow_release)
 
         return queue
 
@@ -667,7 +713,7 @@ class Workflow(BaseModel):
         wf_queue: WorkflowQueue = WorkflowQueue()
 
         # NOTE: Make queue to the workflow queue object.
-        self.queue_poking(
+        self.queue(
             offset,
             end_date=end_date,
             queue=wf_queue,
@@ -703,11 +749,11 @@ class Workflow(BaseModel):
                         f"release has diff time more than 60 seconds ..."
                     )
                     heappush(wf_queue.queue, release)
-                    delay(60)
+                    wait_a_minute(get_dt_now(tz=config.tz, offset=offset))
 
                     # WARNING: I already call queue poking again because issue
                     #   about the every minute crontab.
-                    self.queue_poking(
+                    self.queue(
                         offset,
                         end_date,
                         queue=wf_queue,
@@ -717,7 +763,7 @@ class Workflow(BaseModel):
                     continue
 
                 # NOTE: Push the latest WorkflowRelease to the running queue.
-                wf_queue.push_running(release)
+                heappush(wf_queue.running, release)
 
                 futures.append(
                     executor.submit(
@@ -729,7 +775,7 @@ class Workflow(BaseModel):
                     )
                 )
 
-                self.queue_poking(
+                self.queue(
                     offset,
                     end_date,
                     queue=wf_queue,
@@ -1074,7 +1120,7 @@ class Workflow(BaseModel):
 
 
 @dataclass(config=ConfigDict(arbitrary_types_allowed=True))
-class WorkflowTaskData:
+class WorkflowTask:
     """Workflow task Pydantic dataclass object that use to keep mapping data and
     workflow model for passing to the multithreading task.
 
@@ -1085,151 +1131,105 @@ class WorkflowTaskData:
     alias: str
     workflow: Workflow
     runner: CronRunner
-    params: DictData = field(default_factory=dict)
+    values: DictData = field(default_factory=dict)
 
     def release(
         self,
-        queue: dict[str, list[datetime]],
-        log: Log | None = None,
+        release: datetime | WorkflowRelease | None = None,
         run_id: str | None = None,
-        *,
-        waiting_sec: int = 60,
-        sleep_interval: int = 15,
-    ) -> Result:  # pragma: no cov
-        """Release the workflow task data that use the same logic of
-        `workflow.release` method but use different the queue object for
-        tracking release datetime to run.
-
-        :param queue: A mapping of alias name and list of release datetime.
-        :param log: A log object for saving result logging from workflow
-            execution process.
+        log: type[Log] = None,
+        queue: (
+            WorkflowQueue | list[datetime] | list[WorkflowRelease] | None
+        ) = None,
+    ) -> Result:
+        """Release the workflow task data.
+
+        :param release: A release datetime or WorkflowRelease object.
         :param run_id: A workflow running ID for this release.
-        :param waiting_sec: A second period value that allow workflow execute.
-        :param sleep_interval: A second value that want to waiting until time
-            to execute.
+        :param log: A log class that want to save the execution result.
+        :param queue: A WorkflowQueue object.
 
         :rtype: Result
         """
         log: type[Log] = log or FileLog
-        run_id: str = run_id or gen_id(self.alias, unique=True)
-        rs_release: Result = Result(run_id=run_id)
-        runner: CronRunner = self.runner
 
-        # NOTE: get next schedule time that generate from now.
-        next_time: datetime = runner.date
+        if release is None:
+            if queue.check_queue(self.runner.date):
+                release = self.runner.next
 
-        # NOTE: get next utils it does not running.
-        while log.is_pointed(self.workflow.name, next_time) or (
-            next_time in queue[self.alias]
-        ):
-            next_time: datetime = runner.next
+                while queue.check_queue(release):
+                    release = self.runner.next
+            else:
+                release = self.runner.date
 
-        logger.debug(
-            f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
-            f"{runner.cron} : {next_time:%Y-%m-%d %H:%M:%S}"
+        return self.workflow.release(
+            release=release,
+            params=self.values,
+            run_id=run_id,
+            log=log,
+            queue=queue,
+            override_log_name=self.alias,
         )
-        heappush(queue[self.alias], next_time)
-        start_sec: float = time.monotonic()
-
-        if get_diff_sec(next_time, tz=runner.tz) > waiting_sec:
-            logger.debug(
-                f"({cut_id(run_id)}) [WORKFLOW]: {self.workflow.name!r} : "
-                f"{runner.cron} "
-                f": Does not closely >> {next_time:%Y-%m-%d %H:%M:%S}"
-            )
 
-            # NOTE: Add this next running datetime that not in period to queue
-            #   and remove it to running.
-            queue[self.alias].remove(next_time)
+    def queue(
+        self,
+        end_date: datetime,
+        queue: WorkflowQueue,
+        log: type[Log],
+        *,
+        force_run: bool = False,
+    ):
+        """Generate WorkflowRelease to WorkflowQueue object.
+
+        :param end_date: An end datetime object.
+        :param queue: A workflow queue object.
+        :param log: A log class that want to making log object.
+        :param force_run: A flag that allow to release workflow if the log with
+            that release was pointed.
 
-            time.sleep(0.2)
-            return rs_release.catch(status=0, context={})
+        :rtype: WorkflowQueue
+        """
+        if self.runner.date > end_date:
+            return queue
 
-        logger.debug(
-            f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
-            f"{runner.cron} : Closely to run >> {next_time:%Y-%m-%d %H:%M:%S}"
+        workflow_release = WorkflowRelease(
+            date=self.runner.date,
+            offset=0,
+            end_date=end_date,
+            runner=self.runner,
+            type="task",
         )
 
-        # NOTE: Release when the time is nearly to schedule time.
-        while (duration := get_diff_sec(next_time, tz=config.tz)) > (
-            sleep_interval + 5
+        while queue.check_queue(workflow_release) or (
+            log.is_pointed(name=self.alias, release=workflow_release.date)
+            and not force_run
         ):
-            logger.debug(
-                f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
-                f"{runner.cron} : Sleep until: {duration}"
+            workflow_release = WorkflowRelease(
+                date=self.runner.next,
+                offset=0,
+                end_date=end_date,
+                runner=self.runner,
+                type="task",
             )
-            time.sleep(15)
 
-        time.sleep(0.5)
+        if self.runner.date > end_date:
+            return queue
 
-        # NOTE: Release parameter that use to change if params has
-        #   templating.
-        release_params: DictData = {
-            "release": {
-                "logical_date": next_time,
-                "execute_date": datetime.now(tz=config.tz),
-                "run_id": run_id,
-                "timezone": runner.tz,
-            },
-        }
-
-        # WARNING: Re-create workflow object that use new running workflow ID.
-        rs: Result = self.workflow.execute(
-            params=param2template(self.params, release_params),
-        )
-        logger.debug(
-            f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
-            f"{runner.cron} : End release - {next_time:%Y-%m-%d %H:%M:%S}"
-        )
-
-        # NOTE: Set parent ID on this result.
-        rs.set_parent_run_id(run_id)
+        # NOTE: Push the WorkflowRelease object to queue.
+        heappush(queue.queue, workflow_release)
 
-        # NOTE: Save result to log object saving.
-        rs_log: Log = log.model_validate(
-            {
-                "name": self.workflow.name,
-                "type": "schedule",
-                "release": next_time,
-                "context": rs.context,
-                "parent_run_id": rs.run_id,
-                "run_id": rs.run_id,
-            }
-        )
-        rs_log.save(excluded=None)
-
-        # NOTE: Remove the current release date from the running.
-        queue[self.alias].remove(next_time)
-        total_sec: float = time.monotonic() - start_sec
-
-        # IMPORTANT:
-        #   Add the next running datetime to workflow task queue.
-        future_running_time: datetime = runner.next
-
-        while (
-            future_running_time in queue[self.alias]
-            or (future_running_time - next_time).total_seconds() < total_sec
-        ):  # pragma: no cov
-            future_running_time: datetime = runner.next
-
-        # NOTE: Queue next release date.
-        logger.debug(f"[CORE]: {'-' * 100}")
-
-        context: dict[str, Any] = rs.context
-        context.pop("params")
+        return queue
 
-        return rs_release.catch(
-            status=0,
-            context={
-                "params": self.params,
-                "release": {"status": "success", "logical_date": next_time},
-                "outputs": context,
-            },
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(alias={self.alias!r}, "
+            f"workflow={self.workflow.name!r}, runner={self.runner!r}, "
+            f"values={self.values})"
         )
 
-    def __eq__(self, other: WorkflowTaskData) -> bool:
+    def __eq__(self, other: WorkflowTask) -> bool:
         """Override equal property that will compare only the same type."""
-        if isinstance(other, WorkflowTaskData):
+        if isinstance(other, WorkflowTask):
             return (
                 self.workflow.name == other.workflow.name
                 and self.runner.cron == other.runner.cron

{ddeutil_workflow-0.0.23.dist-info → ddeutil_workflow-0.0.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddeutil-workflow
-Version: 0.0.23
+Version: 0.0.25
 Summary: Lightweight workflow orchestration with less dependencies
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -24,7 +24,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ddeutil>=0.4.3
 Requires-Dist: ddeutil-io[toml,yaml]>=0.2.3
-Requires-Dist: pydantic==2.10.2
+Requires-Dist: pydantic==2.10.4
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: typer==0.15.1
 Requires-Dist: schedule<2.0.0,==1.2.2
@@ -68,8 +68,8 @@ configuration. It called **Metadata Driven Data Workflow**.
 > with `.yml` files and all of config file from several data orchestration framework
 > tools from my experience on Data Engineer. :grimacing:
 >
-> Other workflow that I interest on them and pick some interested feature to this
-> package:
+> Other workflow tools that I interest on them and pick some interested feature
+> implement to this package:
 >
 > - [Google **Workflows**](https://cloud.google.com/workflows)
 > - [AWS **Step Functions**](https://aws.amazon.com/step-functions/)
@@ -85,9 +85,6 @@ If you want to install this package with application add-ons, you should add
 | Python & CLI      | `pip install ddeutil-workflow`           | :heavy_check_mark: |
 | FastAPI Server    | `pip install ddeutil-workflow[api]`      | :heavy_check_mark: |
 
-
-> I added this feature to the main milestone.
->
 > :egg: **Docker Images** supported:
 >
 > | Docker Image                | Python Version | Support |
@@ -113,7 +110,7 @@ use-case.
 run-py-local:
 
    # Validate model that use to parsing exists for template file
-   type: ddeutil.workflow.Workflow
+   type: ddeutil.workflow.workflow.Workflow
    on:
       # If workflow deploy to schedule, it will running every 5 minutes
       # with Asia/Bangkok timezone.
@@ -182,34 +179,35 @@ 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                                                                                                        | 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_JOB_RAISE_ERROR`         | Core      | true                             | A flag that all job raise JobException from job strategy 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_CORE_MAX_JOB_EXEC_TIMEOUT`    | Core      | 600                              |                                                                                                                    |        |
-| `WORKFLOW_CORE_MAX_ON_PER_WORKFLOW`     | Core      | 5                                |                                                                                                                    |        |
-| `WORKFLOW_CORE_GENERATE_ID_SIMPLE_MODE` | Core      | true                             | A flog that enable generating ID with `md5` algorithm.                                                             |        |
-| `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.                                           |        |
+| Environment                             | Component  | Default                                            | Description                                                                                                        | Remark |
+|:----------------------------------------|:----------:|:---------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------|--------|
+| `WORKFLOW_ROOT_PATH`                    |    Core    | .                                                  | The root path of the workflow application.                                                                         |        |
+| `WORKFLOW_CORE_REGISTRY`                |    Core    | src,src.ddeutil.workflow,tests,tests.utils         | List of importable string for the hook stage.                                                                      |        |
+| `WORKFLOW_CORE_REGISTRY_FILTER`         |    Core    | src.ddeutil.workflow.utils,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_JOB_RAISE_ERROR`         |    Core    | true                                               | A flag that all job raise JobException from job strategy 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_CORE_MAX_JOB_EXEC_TIMEOUT`    |    Core    | 600                                                |                                                                                                                    |        |
+| `WORKFLOW_CORE_MAX_CRON_PER_WORKFLOW`   |    Core    | 5                                                  |                                                                                                                    |        |
+| `WORKFLOW_CORE_MAX_QUEUE_COMPLETE_HIST` |    Core    | 16                                                 |                                                                                                                    |        |
+| `WORKFLOW_CORE_GENERATE_ID_SIMPLE_MODE` |    Core    | true                                               | A flog that enable generating ID with `md5` algorithm.                                                             |        |
+| `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                                                                        | 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.                                                  |        |
+| 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
 
@@ -217,7 +215,7 @@ This package able to run as a application service for receive manual trigger
 from the master node via RestAPI or use to be Scheduler background service
 like crontab job but via Python API.
 
-### Schedule App
+### CLI
 
 ```shell
 (venv) $ ddeutil-workflow schedule
@@ -230,7 +228,7 @@ like crontab job but via Python API.
 ```
 
 > [!NOTE]
-> If this package already deploy, it able to use
+> If this package already deploy, it able to use multiprocess;
 > `uvicorn ddeutil.workflow.api:app --host 127.0.0.1 --port 80 --workers 4`
 
 ### Docker Container

ddeutil_workflow-0.0.25.dist-info/RECORD

@@ -0,0 +1,25 @@
+ddeutil/workflow/__about__.py,sha256=t4IIhCiioD7q4m2ksb5i3WtaGFGCRBYpETJrirYC7s8,28
+ddeutil/workflow/__cron.py,sha256=uA8XcbY_GwA9rJSHaHUaXaJyGDObJN0ZeYlJSinL8y8,26880
+ddeutil/workflow/__init__.py,sha256=49eGrCuchPVZKMybRouAviNhbulK_F6VwCmLm76hIss,1478
+ddeutil/workflow/__types.py,sha256=Ia7f38kvL3NibwmRKi0wQ1ud_45Z-SojYGhNJwIqcu8,3713
+ddeutil/workflow/cli.py,sha256=Ik14rFFxE9u20uOgCa4Vx7fNuKXVsWJg7gZb15sGans,2878
+ddeutil/workflow/conf.py,sha256=YY2zZ_qv9JkTDs_73bkyrF1n1cqBINuxzMxbBjzYw-8,15361
+ddeutil/workflow/cron.py,sha256=75A0hqevvouziKoLALncLJspVAeki9qCH3zniAJaxzY,7513
+ddeutil/workflow/exceptions.py,sha256=P56K7VD3etGm9y-k_GXrzEyqsTCaz9EJazTIshZDf9g,943
+ddeutil/workflow/job.py,sha256=cvSLMdc1sMl1MeU7so7Oe2SdRYxQwt6hm55mLV1iP-Y,24219
+ddeutil/workflow/params.py,sha256=uPGkZx18E-iZ8BteqQ2ONgg0frhF3ZmP5cOyfK2j59U,5280
+ddeutil/workflow/result.py,sha256=WIC8MsnfLiWNpZomT6jS4YCdYhlbIVVBjtGGe2dkoKk,3404
+ddeutil/workflow/scheduler.py,sha256=_V812UlqcwfVF2Sl_45nIatMklioBXcXfGZSFoAAjwo,20452
+ddeutil/workflow/stage.py,sha256=a2sngzs9DkP6GU2pgAD3QvGoijyBQTR_pOhyJUIuWAo,26692
+ddeutil/workflow/utils.py,sha256=pucRnCi9aLJDptXhzzReHZd5d-S0o5oZif5tr6H4iy8,18736
+ddeutil/workflow/workflow.py,sha256=AD0rs1tRT2EpvUyNVAEr2bBPgF6-KOzGmLedR3o4y0Q,42177
+ddeutil/workflow/api/__init__.py,sha256=F53NMBWtb9IKaDWkPU5KvybGGfKAcbehgn6TLBwHuuM,21
+ddeutil/workflow/api/api.py,sha256=Md1cz3Edc7_uz63s_L_i-R3IE4mkO3aTADrX8GOGU-Y,5644
+ddeutil/workflow/api/repeat.py,sha256=zyvsrXKk-3-_N8ZRZSki0Mueshugum2jtqctEOp9QSc,4927
+ddeutil/workflow/api/route.py,sha256=MQXtkF5uM_ZL1SGDuXFzgkNkbT5cpAXVNRp6mvewupM,7447
+ddeutil_workflow-0.0.25.dist-info/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.25.dist-info/METADATA,sha256=Rt11UMGcXyYWwXcxb-p0LgelfUFi7DaM_lQwFVX1Mtw,14641
+ddeutil_workflow-0.0.25.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+ddeutil_workflow-0.0.25.dist-info/entry_points.txt,sha256=0BVOgO3LdUdXVZ-CiHHDKxzEk2c8J30jEwHeKn2YCWI,62
+ddeutil_workflow-0.0.25.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.25.dist-info/RECORD,,