ddeutil-workflow 0.0.20__py3-none-any.whl → 0.0.22__py3-none-any.whl

ddeutil/workflow/workflow.py

@@ -3,8 +3,7 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-"""
-The main schedule running is ``workflow_runner`` function that trigger the
+"""The main schedule running is ``workflow_runner`` function that trigger the
 multiprocess of ``workflow_control`` function for listing schedules on the
 config by ``Loader.finds(Schedule)``.
 
@@ -12,6 +11,7 @@ config by ``Loader.finds(Schedule)``.
 functions; ``workflow_task``, and ``workflow_monitor``.
 
     ``workflow_control`` --- Every minute at :02 --> ``workflow_task``
+
                          --- Every 5 minutes     --> ``workflow_monitor``
 
     The ``workflow_task`` will run ``task.release`` method in threading object
@@ -49,6 +49,7 @@ from .on import On
 from .utils import (
     Param,
     Result,
+    cut_id,
     delay,
     gen_id,
     get_diff_sec,
@@ -70,7 +71,7 @@ __all__: TupleStr = (
 @total_ordering
 @dataclass(config=ConfigDict(arbitrary_types_allowed=True))
 class WorkflowRelease:
-    """Workflow release data dataclass object."""
+    """Workflow release Pydantic dataclass object."""
 
     date: datetime
     offset: float
@@ -86,6 +87,12 @@ class WorkflowRelease:
 
     @classmethod
     def from_dt(cls, dt: datetime) -> Self:
+        """Construct WorkflowRelease via datetime object only.
+
+        :param dt: A datetime object.
+
+        :rtype: Self
+        """
         return cls(
             date=dt,
             offset=0,
@@ -95,6 +102,9 @@ class WorkflowRelease:
         )
 
     def __eq__(self, other: WorkflowRelease | datetime) -> bool:
+        """Override equal property that will compare only the same type or
+        datetime.
+        """
         if isinstance(other, self.__class__):
             return self.date == other.date
         elif isinstance(other, datetime):
@@ -102,6 +112,9 @@ class WorkflowRelease:
         return NotImplemented
 
     def __lt__(self, other: WorkflowRelease | datetime) -> bool:
+        """Override equal property that will compare only the same type or
+        datetime.
+        """
         if isinstance(other, self.__class__):
             return self.date < other.date
         elif isinstance(other, datetime):
@@ -111,47 +124,84 @@ class WorkflowRelease:
 
 @dataclass
 class WorkflowQueue:
-    """Workflow Queue object."""
+    """Workflow Queue object that is management of WorkflowRelease objects."""
 
     queue: list[WorkflowRelease] = field(default_factory=list)
     running: list[WorkflowRelease] = field(default_factory=list)
     complete: list[WorkflowRelease] = field(default_factory=list)
 
+    @classmethod
+    def from_list(
+        cls, queue: list[datetime] | list[WorkflowRelease] | None
+    ) -> Self:
+        """Construct WorkflowQueue object from an input queue value that passing
+        with list of datetime or list of WorkflowRelease.
+
+        :raise TypeError: If the type of an input queue does not valid.
+
+        :rtype: Self
+        """
+        if queue is None:
+            return cls()
+        elif isinstance(queue, list):
+
+            if all(isinstance(q, datetime) for q in queue):
+                return cls(queue=[WorkflowRelease.from_dt(q) for q in queue])
+
+            elif all(isinstance(q, WorkflowRelease) for q in queue):
+                return cls(queue=queue)
+
+        raise TypeError(
+            "Type of the queue does not valid with WorkflowQueue "
+            "or list of datetime or list of WorkflowRelease."
+        )
+
     @property
     def is_queued(self) -> bool:
-        """Return True if it has data in the queue."""
+        """Return True if it has workflow release object in the queue.
+
+        :rtype: bool
+        """
         return len(self.queue) > 0
 
-    def check_queue(self, data: WorkflowRelease) -> bool:
+    def check_queue(self, value: WorkflowRelease) -> bool:
         """Check a WorkflowRelease value already exists in list of tracking
         queues.
 
-        :param data:
+        :param value: A WorkflowRelease object that want to check it already in
+            queues.
+
+        :rtype: bool
         """
         return (
-            (data in self.queue)
-            or (data in self.running)
-            or (data in self.complete)
+            (value in self.queue)
+            or (value in self.running)
+            or (value in self.complete)
         )
 
-    def push_queue(self, data: WorkflowRelease) -> Self:
-        heappush(self.queue, data)
+    def push_queue(self, value: WorkflowRelease) -> Self:
+        """Push data to the queue."""
+        heappush(self.queue, value)
         return self
 
-    def push_running(self, data: WorkflowRelease) -> Self:
-        heappush(self.running, data)
+    def push_running(self, value: WorkflowRelease) -> Self:
+        """Push data to the running."""
+        heappush(self.running, value)
         return self
 
-    def remove_running(self, data: WorkflowRelease) -> Self:
-        if data in self.running:
-            self.running.remove(data)
+    def remove_running(self, value: WorkflowRelease) -> Self:
+        """Remove data on the running if it exists."""
+        if value in self.running:
+            self.running.remove(value)
 
 
 class Workflow(BaseModel):
-    """Workflow Pydantic Model this is the main future of this project because
-    it use to be workflow data for running everywhere that you want or using it
-    to scheduler task in background. It use lightweight coding line from
-    Pydantic Model and enhance execute method on it.
+    """Workflow Pydantic model.
+
+        This is the main future of this project because it use to be workflow
+    data for running everywhere that you want or using it to scheduler task in
+    background. It use lightweight coding line from Pydantic Model and enhance
+    execute method on it.
     """
 
     name: str = Field(description="A workflow name.")
@@ -184,9 +234,12 @@ class Workflow(BaseModel):
         an input workflow name. The loader object will use this workflow name to
         searching configuration data of this workflow model in conf path.
 
+        :raise ValueError: If the type does not match with current object.
+
         :param name: A workflow name that want to pass to Loader object.
         :param externals: An external parameters that want to pass to Loader
             object.
+
         :rtype: Self
         """
         loader: Loader = Loader(name, externals=(externals or {}))
@@ -235,7 +288,7 @@ class Workflow(BaseModel):
 
     @model_validator(mode="before")
     def __prepare_model_before__(cls, values: DictData) -> DictData:
-        """Prepare the params key."""
+        """Prepare the params key in the data model before validating."""
         # NOTE: Prepare params type if it passing with only type value.
         if params := values.pop("params", {}):
             values["params"] = {
@@ -258,9 +311,17 @@ class Workflow(BaseModel):
         return dedent(value)
 
     @field_validator("on", mode="after")
-    def __on_no_dup__(cls, value: list[On]) -> list[On]:
+    def __on_no_dup_and_reach_limit__(cls, value: list[On]) -> list[On]:
         """Validate the on fields should not contain duplicate values and if it
-        contain every minute value, it should has only one on value."""
+        contain the every minute value more than one value, it will remove to
+        only one value.
+
+        :raise ValueError: If it has some duplicate value.
+
+        :param value: A list of on object.
+
+        :rtype: list[On]
+        """
         set_ons: set[str] = {str(on.cronjob) for on in value}
         if len(set_ons) != len(value):
             raise ValueError(
@@ -273,12 +334,21 @@ class Workflow(BaseModel):
         #         "If it has every minute cronjob on value, it should has only "
         #         "one value in the on field."
         #     )
+
+        if len(set_ons) > config.max_on_per_workflow:
+            raise ValueError(
+                f"The number of the on should not more than "
+                f"{config.max_on_per_workflow} crontab."
+            )
         return value
 
     @model_validator(mode="after")
     def __validate_jobs_need__(self) -> Self:
         """Validate each need job in any jobs should exists.
 
+        :raise WorkflowException: If it has not exists need value in this
+            workflow job.
+
         :rtype: Self
         """
         for job in self.jobs:
@@ -368,22 +438,21 @@ class Workflow(BaseModel):
         self,
         release: datetime | WorkflowRelease,
         params: DictData,
-        run_id: str | None = None,
         *,
+        run_id: str | None = None,
         log: type[Log] = None,
-        queue: WorkflowQueue | list[datetime] | None = None,
+        queue: (
+            WorkflowQueue | list[datetime] | list[WorkflowRelease] | None
+        ) = None,
     ) -> Result:
         """Release the workflow execution with overriding parameter with the
         release templating that include logical date (release date), execution
         date, or running id to the params.
 
             This method allow workflow use log object to save the execution
-        result to log destination like file log to local `/logs` directory.
+        result to log destination like file log to the local `/logs` directory.
 
-            I will add sleep with 0.15 seconds on every step that interact with
-        the queue object.
-
-        :param release: A release datetime.
+        :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.
@@ -394,23 +463,23 @@ class Workflow(BaseModel):
         """
         log: type[Log] = log or FileLog
         run_id: str = run_id or gen_id(self.name, unique=True)
+        rs_release: Result = Result(run_id=run_id)
 
         # VALIDATE: Change queue value to WorkflowQueue object.
-        if queue is None:
-            queue: WorkflowQueue = WorkflowQueue()
-        elif isinstance(queue, list):
-            queue: WorkflowQueue = WorkflowQueue(queue=queue)
+        if queue is None or isinstance(queue, list):
+            queue: WorkflowQueue = WorkflowQueue.from_list(queue)
 
         # VALIDATE: Change release value to WorkflowRelease object.
         if isinstance(release, datetime):
             release: WorkflowRelease = WorkflowRelease.from_dt(release)
 
         logger.debug(
-            f"({run_id}) [RELEASE]: {self.name!r} : "
-            f"Closely to run >> {release.date:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [RELEASE]: {self.name!r} : Start release - "
+            f"{release.date:%Y-%m-%d %H:%M:%S}"
         )
 
-        # NOTE: Release parameter that use to change if params has templating.
+        # NOTE: Release parameters that use to templating on the schedule
+        #   config data.
         release_params: DictData = {
             "release": {
                 "logical_date": release.date,
@@ -420,14 +489,14 @@ class Workflow(BaseModel):
             }
         }
 
-        # WARNING: Re-create workflow object that use new running workflow ID.
+        # NOTE: Execute workflow with templating params from release mapping.
         rs: Result = self.execute(
             params=param2template(params, release_params),
             run_id=run_id,
         )
         logger.debug(
-            f"({run_id}) [RELEASE]: {self.name!r} : "
-            f"End release {release.date:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [RELEASE]: {self.name!r} : End release - "
+            f"{release.date:%Y-%m-%d %H:%M:%S}"
         )
 
         rs.set_parent_run_id(run_id)
@@ -449,16 +518,13 @@ class Workflow(BaseModel):
         queue.remove_running(release)
         heappush(queue.complete, release)
 
-        return Result(
+        return rs_release.catch(
             status=0,
             context={
                 "params": params,
-                "release": {
-                    "status": "success",
-                    "logical_date": release.date,
-                },
+                "release": {"status": "success", "logical_date": release.date},
+                "outputs": rs.context,
             },
-            run_id=run_id,
         )
 
     def queue_poking(
@@ -467,14 +533,20 @@ class Workflow(BaseModel):
         end_date: datetime,
         queue: WorkflowQueue,
         log: type[Log],
+        *,
+        force_run: bool = False,
     ) -> WorkflowQueue:
         """Generate queue of datetime from the cron runner that initialize from
         the on field. with offset value.
 
-        :param offset:
-        :param end_date:
-        :param queue:
-        :param log:
+        :param offset: A offset in second unit for time travel.
+        :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.
+
+        :rtype: WorkflowQueue
         """
         for on in self.on:
 
@@ -482,6 +554,7 @@ class Workflow(BaseModel):
                 get_dt_now(tz=config.tz, offset=offset).replace(microsecond=0)
             )
 
+            # NOTE: Skip this runner date if it more than the end date.
             if runner.date > end_date:
                 continue
 
@@ -493,8 +566,9 @@ class Workflow(BaseModel):
                 type="poking",
             )
 
-            while queue.check_queue(data=workflow_release) or (
+            while queue.check_queue(workflow_release) or (
                 log.is_pointed(name=self.name, release=workflow_release.date)
+                and not force_run
             ):
                 workflow_release = WorkflowRelease(
                     date=runner.next,
@@ -507,36 +581,50 @@ class Workflow(BaseModel):
             if runner.date > end_date:
                 continue
 
+            # NOTE: Push the WorkflowRelease object to queue.
             queue.push_queue(workflow_release)
+
         return queue
 
     def poke(
         self,
         start_date: datetime | None = None,
         params: DictData | None = None,
+        *,
         run_id: str | None = None,
         periods: int = 1,
-        *,
         log: Log | None = None,
+        force_run: bool = False,
+        timeout: int = 1800,
     ) -> list[Result]:
-        """Poke workflow with the ``on`` field with threading executor pool for
-        executing with all its schedules that was set on the `on` value.
-        This method will observe its schedule that nearing to run with the
+        """Poke this workflow with start datetime value that passing to its
+        ``on`` field with threading executor pool for executing with all its
+        schedules that was set on the `on` value.
+
+            This method will observe its schedule that nearing to run with the
         ``self.release()`` method.
 
         :param start_date: A start datetime object.
         :param params: A parameters that want to pass to the release method.
         :param run_id: A workflow running ID for this poke.
-        :param periods: A periods of minutes value to running poke.
+        :param periods: A periods in minutes value that use to run this poking.
         :param log: A log object that want to use on this poking process.
+        :param force_run: A flag that allow to release workflow if the log with
+            that release was pointed.
+        :param timeout: A second value for timeout while waiting all futures
+            run completely.
 
         :rtype: list[Result]
+        :return: A list of all results that return from ``self.release`` method.
         """
+        log: type[Log] = log or FileLog
+        run_id: str = run_id or gen_id(self.name, unique=True)
+
         # NOTE: If this workflow does not set the on schedule, it will return
         #   empty result.
         if len(self.on) == 0:
             logger.info(
-                f"({run_id}) [POKING]: {self.name!r} does not have any "
+                f"({cut_id(run_id)}) [POKING]: {self.name!r} does not have any "
                 f"schedule to run."
             )
             return []
@@ -556,82 +644,93 @@ class Workflow(BaseModel):
             start_date: datetime = current_date
             offset: float = 0
 
+        # NOTE: End date is use to stop generate queue with an input periods
+        #   value.
         end_date: datetime = start_date + timedelta(minutes=periods)
 
-        log: type[Log] = log or FileLog
-        run_id: str = run_id or gen_id(self.name, unique=True)
         logger.info(
-            f"({run_id}) [POKING]: Start Poking: {self.name!r} from "
+            f"({cut_id(run_id)}) [POKING]: Start Poking: {self.name!r} from "
             f"{start_date:%Y-%m-%d %H:%M:%S} to {end_date:%Y-%m-%d %H:%M:%S}"
         )
 
-        params: DictData = params or {}
-        workflow_queue: WorkflowQueue = WorkflowQueue()
+        params: DictData = {} if params is None else params
+        wf_queue: WorkflowQueue = WorkflowQueue()
         results: list[Result] = []
         futures: list[Future] = []
 
+        # NOTE: Make queue to the workflow queue object.
         self.queue_poking(
-            offset, end_date=end_date, queue=workflow_queue, log=log
+            offset,
+            end_date=end_date,
+            queue=wf_queue,
+            log=log,
+            force_run=force_run,
         )
-
-        if len(workflow_queue.queue) == 0:
+        if not wf_queue.is_queued:
             logger.info(
-                f"({run_id}) [POKING]: {self.name!r} does not have any "
-                f"queue to run."
+                f"({cut_id(run_id)}) [POKING]: {self.name!r} does not have "
+                f"any queue."
             )
             return []
 
+        # NOTE: Start create the thread pool executor for running this poke
+        #   process.
         with ThreadPoolExecutor(
             max_workers=config.max_poking_pool_worker,
-            thread_name_prefix="workflow_poking_",
+            thread_name_prefix="wf_poking_",
         ) as executor:
 
-            while workflow_queue.is_queued:
+            while wf_queue.is_queued:
+
+                # NOTE: Pop the latest WorkflowRelease object from queue.
+                release: WorkflowRelease = heappop(wf_queue.queue)
 
-                wf_release: WorkflowRelease = heappop(workflow_queue.queue)
                 if (
-                    wf_release.date - get_dt_now(tz=config.tz, offset=offset)
+                    release.date - get_dt_now(tz=config.tz, offset=offset)
                 ).total_seconds() > 60:
                     logger.debug(
-                        f"({run_id}) [POKING]: Waiting because the latest "
-                        f"release has diff time more than 60 seconds "
+                        f"({cut_id(run_id)}) [POKING]: Wait because the latest "
+                        f"release has diff time more than 60 seconds ..."
                     )
-                    heappush(workflow_queue.queue, wf_release)
+                    heappush(wf_queue.queue, release)
                     delay(60)
+
+                    # WARNING: I already call queue poking again because issue
+                    #   about the every minute crontab.
                     self.queue_poking(
-                        offset, end_date, queue=workflow_queue, log=log
+                        offset,
+                        end_date,
+                        queue=wf_queue,
+                        log=log,
+                        force_run=force_run,
                     )
                     continue
 
-                # NOTE: Push the workflow release to running queue
-                workflow_queue.push_running(wf_release)
+                # NOTE: Push the latest WorkflowRelease to the running queue.
+                wf_queue.push_running(release)
 
                 futures.append(
                     executor.submit(
                         self.release,
-                        release=wf_release,
+                        release=release,
                         params=params,
                         log=log,
-                        queue=workflow_queue,
+                        queue=wf_queue,
                     )
                 )
 
                 self.queue_poking(
-                    offset, end_date, queue=workflow_queue, log=log
+                    offset,
+                    end_date,
+                    queue=wf_queue,
+                    log=log,
+                    force_run=force_run,
                 )
 
             # WARNING: This poking method does not allow to use fail-fast
             #   logic to catching parallel execution result.
-            for future in as_completed(futures):
-                rs: Result = future.result(timeout=60)
-                results.append(rs.set_parent_run_id(run_id))
-
-        while len(workflow_queue.running) > 0:  # pragma: no cov
-            logger.warning(
-                f"({run_id}) [POKING]: Running does empty when poking "
-                f"process was finishing."
-            )
-            delay(10)
+            for future in as_completed(futures, timeout=timeout):
+                results.append(future.result().set_parent_run_id(run_id))
 
         return results
 
@@ -639,17 +738,21 @@ class Workflow(BaseModel):
         self,
         job_id: str,
         params: DictData,
-        run_id: str | None = None,
         *,
+        run_id: str | None = None,
         raise_error: bool = True,
     ) -> Result:
-        """Workflow Job execution with passing dynamic parameters from the
-        workflow execution to the target job.
+        """Job execution with passing dynamic parameters from the main workflow
+        execution to the target job object via job's ID.
 
             This execution is the minimum level of execution of this workflow
         model. It different with ``self.execute`` because this method run only
         one job and return with context of this job data.
 
+        :raise WorkflowException: If execute with not exist job's ID.
+        :raise WorkflowException: If the job execution raise JobException.
+        :raise NotImplementedError: If set raise_error argument to False.
+
         :param job_id: A job ID that want to execute.
         :param params: A params that was parameterized from workflow execution.
         :param run_id: A workflow running ID for this job execution.
@@ -657,20 +760,27 @@ class Workflow(BaseModel):
             if it get exception from job execution.
 
         :rtype: Result
+        :return: Return the result object that receive the job execution result
+            context.
         """
         run_id: str = run_id or gen_id(self.name, unique=True)
+        rs: Result = Result(run_id=run_id)
 
         # VALIDATE: check a job ID that exists in this workflow or not.
         if job_id not in self.jobs:
             raise WorkflowException(
-                f"The job ID: {job_id} does not exists in {self.name!r} "
+                f"The job: {job_id!r} does not exists in {self.name!r} "
                 f"workflow."
             )
 
-        logger.info(f"({run_id}) [WORKFLOW]: Start execute: {job_id!r}")
+        logger.info(
+            f"({cut_id(run_id)}) [WORKFLOW]: Start execute job: {job_id!r}"
+        )
 
         # IMPORTANT:
-        #   Change any job running IDs to this workflow running ID.
+        #   This execution change all job running IDs to the current workflow
+        #   execution running ID (with passing run_id to the job execution
+        #   argument).
         #
         try:
             job: Job = self.jobs[job_id]
@@ -680,23 +790,25 @@ class Workflow(BaseModel):
             )
         except JobException as err:
             logger.error(
-                f"({run_id}) [WORKFLOW]: {err.__class__.__name__}: {err}"
+                f"({cut_id(run_id)}) [WORKFLOW]: {err.__class__.__name__}: "
+                f"{err}"
             )
             if raise_error:
                 raise WorkflowException(
                     f"Get job execution error {job_id}: JobException: {err}"
                 ) from None
-            else:
-                raise NotImplementedError() from None
+            raise NotImplementedError(
+                "Handle error from the job execution does not support yet."
+            ) from None
 
-        return Result(status=0, context=params).set_run_id(run_id)
+        return rs.catch(status=0, context=params)
 
     def execute(
         self,
         params: DictData,
-        run_id: str | None = None,
         *,
-        timeout: int = 60,
+        run_id: str | None = None,
+        timeout: int = 0,
     ) -> Result:
         """Execute workflow with passing a dynamic parameters to all jobs that
         included in this workflow model with ``jobs`` field.
@@ -712,18 +824,20 @@ class Workflow(BaseModel):
 
         :param params: An input parameters that use on workflow execution that
             will parameterize before using it. Default is None.
-        :type params: DictData | None
+        :type params: DictData
+
         :param run_id: A workflow running ID for this job execution.
-        :type run_id: str | None
+        :type run_id: str | None (default: None)
         :param timeout: A workflow execution time out in second unit that use
-            for limit time of execution and waiting job dependency. Default is
-            60 seconds.
-        :type timeout: int
+            for limit time of execution and waiting job dependency.
+        :type timeout: int (default: 0)
 
         :rtype: Result
         """
         run_id: str = run_id or gen_id(self.name, unique=True)
-        logger.info(f"({run_id}) [WORKFLOW]: Start Execute: {self.name!r} ...")
+        logger.info(
+            f"({cut_id(run_id)}) [WORKFLOW]: Start Execute: {self.name!r} ..."
+        )
 
         # NOTE: I use this condition because this method allow passing empty
         #   params and I do not want to create new dict object.
@@ -733,7 +847,7 @@ class Workflow(BaseModel):
         # NOTE: It should not do anything if it does not have job.
         if not self.jobs:
             logger.warning(
-                f"({run_id}) [WORKFLOW]: This workflow: {self.name!r} "
+                f"({cut_id(run_id)}) [WORKFLOW]: This workflow: {self.name!r} "
                 f"does not have any jobs"
             )
             return rs.catch(status=0, context=params)
@@ -769,17 +883,16 @@ class Workflow(BaseModel):
                     context=context,
                     ts=ts,
                     job_queue=jq,
-                    worker=config.max_job_parallel,
                     timeout=timeout,
                 )
         except WorkflowException as err:
+            status: int = 1
             context.update(
                 {
                     "error": err,
                     "error_message": f"{err.__class__.__name__}: {err}",
                 },
             )
-            status = 1
         return rs.catch(status=status, context=context)
 
     def __exec_threading(
@@ -789,10 +902,10 @@ class Workflow(BaseModel):
         ts: float,
         job_queue: Queue,
         *,
-        worker: int = 2,
-        timeout: int = 600,
+        timeout: int = 0,
+        thread_timeout: int = 1800,
     ) -> DictData:
-        """Workflow execution by threading strategy.
+        """Workflow execution by threading strategy that use multithreading.
 
             If a job need dependency, it will check dependency job ID from
         context data before allow it run.
@@ -802,27 +915,31 @@ class Workflow(BaseModel):
             timeout.
         :param job_queue: A job queue object.
         :param timeout: A second value unit that bounding running time.
-        :param worker: A number of threading executor pool size.
+        :param thread_timeout: A timeout to waiting all futures complete.
+
         :rtype: DictData
         """
-        not_time_out_flag: bool = True
+        not_timeout_flag: bool = True
+        timeout: int = timeout or config.max_job_exec_timeout
         logger.debug(
-            f"({run_id}): [WORKFLOW]: Run {self.name} with threading job "
-            f"executor"
+            f"({cut_id(run_id)}) [WORKFLOW]: Run {self.name!r} with threading."
         )
 
         # IMPORTANT: The job execution can run parallel and waiting by
         #   needed.
-        with ThreadPoolExecutor(max_workers=worker) as executor:
+        with ThreadPoolExecutor(
+            max_workers=config.max_job_parallel,
+            thread_name_prefix="wf_exec_threading_",
+        ) as executor:
             futures: list[Future] = []
 
             while not job_queue.empty() and (
-                not_time_out_flag := ((time.monotonic() - ts) < timeout)
+                not_timeout_flag := ((time.monotonic() - ts) < timeout)
             ):
                 job_id: str = job_queue.get()
                 job: Job = self.jobs[job_id]
 
-                if any(need not in context["jobs"] for need in job.needs):
+                if not job.check_needs(context["jobs"]):
                     job_queue.task_done()
                     job_queue.put(job_id)
                     time.sleep(0.25)
@@ -831,10 +948,13 @@ class Workflow(BaseModel):
                 # NOTE: Start workflow job execution with deep copy context data
                 #   before release.
                 #
+                #   Context:
+                #   ---
                 #   {
                 #       'params': <input-params>,
-                #       'jobs': {},
+                #       'jobs': { <job's-id>: ... },
                 #   }
+                #
                 futures.append(
                     executor.submit(
                         self.execute_job,
@@ -846,31 +966,31 @@ class Workflow(BaseModel):
                 # NOTE: Mark this job queue done.
                 job_queue.task_done()
 
-            # NOTE: Wait for all items to finish processing
-            job_queue.join()
+            if not_timeout_flag:
 
-            for future in as_completed(futures, timeout=1800):
-                if err := future.exception():
-                    logger.error(f"({run_id}) [WORKFLOW]: {err}")
-                    raise WorkflowException(f"{err}")
-                try:
-                    future.result(timeout=60)
-                except TimeoutError as err:  # pragma: no cove
-                    raise WorkflowException(
-                        "Timeout when getting result from future"
-                    ) from err
-
-        if not_time_out_flag:
-            return context
+                # NOTE: Wait for all items to finish processing by `task_done()`
+                #   method.
+                job_queue.join()
+
+                for future in as_completed(futures, timeout=thread_timeout):
+                    if err := future.exception():
+                        logger.error(f"({cut_id(run_id)}) [WORKFLOW]: {err}")
+                        raise WorkflowException(str(err))
+
+                    # NOTE: This getting result does not do anything.
+                    future.result()
+
+                return context
+
+            for future in futures:
+                future.cancel()
 
         # NOTE: Raise timeout error.
-        logger.warning(  # pragma: no cov
-            f"({run_id}) [WORKFLOW]: Execution of workflow, {self.name!r} "
-            f", was timeout"
-        )
-        raise WorkflowException(  # pragma: no cov
-            f"Execution of workflow: {self.name} was timeout"
+        logger.warning(
+            f"({cut_id(run_id)}) [WORKFLOW]: Execution: {self.name!r} "
+            f"was timeout."
         )
+        raise WorkflowException(f"Execution: {self.name!r} was timeout.")
 
     def __exec_non_threading(
         self,
@@ -879,7 +999,7 @@ class Workflow(BaseModel):
         ts: float,
         job_queue: Queue,
         *,
-        timeout: int = 600,
+        timeout: int = 0,
     ) -> DictData:
         """Workflow execution with non-threading strategy that use sequential
         job running and waiting previous job was run successful.
@@ -891,25 +1011,27 @@ class Workflow(BaseModel):
         :param ts: A start timestamp that use for checking execute time should
             timeout.
         :param timeout: A second value unit that bounding running time.
+
         :rtype: DictData
         """
-        not_time_out_flag: bool = True
+        not_timeout_flag: bool = True
+        timeout: int = timeout or config.max_job_exec_timeout
         logger.debug(
-            f"({run_id}) [WORKFLOW]: Run {self.name} with non-threading job "
-            f"executor"
+            f"({cut_id(run_id)}) [WORKFLOW]: Run {self.name} with "
+            f"non-threading."
         )
 
         while not job_queue.empty() and (
-            not_time_out_flag := ((time.monotonic() - ts) < timeout)
+            not_timeout_flag := ((time.monotonic() - ts) < timeout)
         ):
             job_id: str = job_queue.get()
             job: Job = self.jobs[job_id]
 
             # NOTE: Waiting dependency job run successful before release.
-            if any(need not in context["jobs"] for need in job.needs):
+            if not job.check_needs(context["jobs"]):
                 job_queue.task_done()
                 job_queue.put(job_id)
-                time.sleep(0.05)
+                time.sleep(0.075)
                 continue
 
             # NOTE: Start workflow job execution with deep copy context data
@@ -925,27 +1047,28 @@ class Workflow(BaseModel):
             # NOTE: Mark this job queue done.
             job_queue.task_done()
 
-        # NOTE: Wait for all items to finish processing
-        job_queue.join()
+        if not_timeout_flag:
+
+            # NOTE: Wait for all items to finish processing by `task_done()`
+            #   method.
+            job_queue.join()
 
-        if not_time_out_flag:
             return context
 
         # NOTE: Raise timeout error.
-        logger.warning(  # pragma: no cov
-            f"({run_id}) [WORKFLOW]: Execution of workflow was timeout"
-        )
-        raise WorkflowException(  # pragma: no cov
-            f"Execution of workflow: {self.name} was timeout"
+        logger.warning(
+            f"({cut_id(run_id)}) [WORKFLOW]: Execution: {self.name!r} "
+            f"was timeout."
         )
+        raise WorkflowException(f"Execution: {self.name!r} was timeout.")
 
 
 @dataclass(config=ConfigDict(arbitrary_types_allowed=True))
 class WorkflowTaskData:
-    """Workflow task dataclass that use to keep mapping data and objects for
-    passing in multithreading task.
+    """Workflow task Pydantic dataclass object that use to keep mapping data and
+    workflow model for passing to the multithreading task.
 
-        This dataclass will be 1-1 mapping with workflow and cron runner
+        This dataclass object is mapping 1-to-1 with workflow and cron runner
     objects.
     """
 
@@ -988,15 +1111,15 @@ class WorkflowTaskData:
             next_time: datetime = runner.next
 
         logger.debug(
-            f"({run_id}) [CORE]: {self.workflow.name!r} : {runner.cron} : "
-            f"{next_time:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
+            f"{runner.cron} : {next_time:%Y-%m-%d %H:%M:%S}"
         )
         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"({run_id}) [WORKFLOW]: {self.workflow.name!r} : "
+                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}"
             )
@@ -1009,8 +1132,8 @@ class WorkflowTaskData:
             return
 
         logger.debug(
-            f"({run_id}) [CORE]: {self.workflow.name!r} : {runner.cron} : "
-            f"Closely to run >> {next_time:%Y-%m-%d %H:%M:%S}"
+            f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
+            f"{runner.cron} : Closely to run >> {next_time:%Y-%m-%d %H:%M:%S}"
         )
 
         # NOTE: Release when the time is nearly to schedule time.
@@ -1018,8 +1141,8 @@ class WorkflowTaskData:
             sleep_interval + 5
         ):
             logger.debug(
-                f"({run_id}) [CORE]: {self.workflow.name!r} : {runner.cron} "
-                f": Sleep until: {duration}"
+                f"({cut_id(run_id)}) [CORE]: {self.workflow.name!r} : "
+                f"{runner.cron} : Sleep until: {duration}"
             )
             time.sleep(15)
 
@@ -1038,8 +1161,8 @@ class WorkflowTaskData:
             params=param2template(self.params, release_params),
         )
         logger.debug(
-            f"({run_id}) [CORE]: {self.workflow.name!r} : {runner.cron} : "
-            f"End release - {next_time:%Y-%m-%d %H:%M:%S}"
+            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.
@@ -1075,7 +1198,8 @@ class WorkflowTaskData:
         # NOTE: Queue next release date.
         logger.debug(f"[CORE]: {'-' * 100}")
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: WorkflowTaskData) -> bool:
+        """Override equal property that will compare only the same type."""
         if isinstance(other, WorkflowTaskData):
             return (
                 self.workflow.name == other.workflow.name