ddeutil-workflow 0.0.9__py3-none-any.whl → 0.0.10__py3-none-any.whl

ddeutil/workflow/pipeline.py

@@ -6,7 +6,6 @@
 from __future__ import annotations
 
 import copy
-import logging
 import os
 import time
 from concurrent.futures import (
@@ -44,11 +43,11 @@ from .exceptions import (
     StageException,
     UtilException,
 )
-from .loader import Loader
-from .log import FileLog, Log
+from .log import FileLog, Log, get_logger
 from .on import On
 from .stage import Stage
 from .utils import (
+    Loader,
     Param,
     Result,
     cross_product,
@@ -61,6 +60,9 @@ from .utils import (
     param2template,
 )
 
+logger = get_logger("ddeutil.workflow")
+
+
 __all__: TupleStr = (
     "Strategy",
     "Job",
@@ -85,9 +87,25 @@ class Strategy(BaseModel):
         ... }
     """
 
-    fail_fast: bool = Field(default=False)
-    max_parallel: int = Field(default=1, gt=0)
-    matrix: Matrix = Field(default_factory=dict)
+    fail_fast: bool = Field(
+        default=False,
+        serialization_alias="fail-fast",
+    )
+    max_parallel: int = Field(
+        default=1,
+        gt=0,
+        description=(
+            "The maximum number of executor thread pool that want to run "
+            "parallel"
+        ),
+        serialization_alias="max-parallel",
+    )
+    matrix: Matrix = Field(
+        default_factory=dict,
+        description=(
+            "A matrix values that want to cross product to possible strategies."
+        ),
+    )
     include: MatrixInclude = Field(
         default_factory=list,
         description="A list of additional matrix that want to adds-in.",
@@ -184,7 +202,13 @@ class Job(BaseModel):
         ... }
     """
 
-    id: Optional[str] = Field(default=None, description="A job ID.")
+    id: Optional[str] = Field(
+        default=None,
+        description=(
+            "A job ID, this value will add from pipeline after validation "
+            "process."
+        ),
+    )
     desc: Optional[str] = Field(
         default=None,
         description="A job description that can be string of markdown content.",
@@ -192,6 +216,7 @@ class Job(BaseModel):
     runs_on: Optional[str] = Field(
         default=None,
         description="A target executor node for this job use to execution.",
+        serialization_alias="runs-on",
     )
     stages: list[Stage] = Field(
         default_factory=list,
@@ -209,6 +234,7 @@ class Job(BaseModel):
         default=None,
         description="A running job ID.",
         repr=False,
+        exclude=True,
     )
 
     @model_validator(mode="before")
@@ -252,11 +278,12 @@ class Job(BaseModel):
         raise ValueError(f"Stage ID {stage_id} does not exists")
 
     def set_outputs(self, output: DictData) -> DictData:
+        """Setting output of job execution"""
         if len(output) > 1 and self.strategy.is_set():
             return {"strategies": output}
         return output[next(iter(output))]
 
-    def strategy_execute(
+    def execute_strategy(
         self,
         strategy: DictData,
         params: DictData,
@@ -276,6 +303,7 @@ class Job(BaseModel):
         :raise JobException: If it has any error from StageException or
             UtilException.
         """
+        # NOTE: Force stop this execution if event was set from main execution.
         if event and event.is_set():
             return Result(
                 status=1,
@@ -283,7 +311,7 @@ class Job(BaseModel):
                     gen_id(strategy): {
                         "matrix": strategy,
                         "stages": {},
-                        "error": {
+                        "error_message": {
                             "message": "Process Event stopped before execution"
                         },
                     },
@@ -311,18 +339,18 @@ class Job(BaseModel):
             _st_name: str = stage.id or stage.name
 
             if stage.is_skipped(params=context):
-                logging.info(
+                logger.info(
                     f"({self.run_id}) [JOB]: Skip the stage: {_st_name!r}"
                 )
                 continue
 
-            logging.info(
+            logger.info(
                 f"({self.run_id}) [JOB]: Start execute the stage: {_st_name!r}"
             )
 
             # NOTE: Logging a matrix that pass on this stage execution.
             if strategy:
-                logging.info(f"({self.run_id}) [JOB]: Matrix: {strategy}")
+                logger.info(f"({self.run_id}) [JOB]: Matrix: {strategy}")
 
             # NOTE:
             #       I do not use below syntax because `params` dict be the
@@ -352,7 +380,7 @@ class Job(BaseModel):
                             # ---
                             # "stages": filter_func(context.pop("stages", {})),
                             "stages": context.pop("stages", {}),
-                            "error": {
+                            "error_message": {
                                 "message": (
                                     "Process Event stopped before execution"
                                 ),
@@ -364,7 +392,7 @@ class Job(BaseModel):
                 rs: Result = stage.execute(params=context)
                 stage.set_outputs(rs.context, to=context)
             except (StageException, UtilException) as err:
-                logging.error(
+                logger.error(
                     f"({self.run_id}) [JOB]: {err.__class__.__name__}: {err}"
                 )
                 raise JobException(
@@ -398,18 +426,18 @@ class Job(BaseModel):
         :param params: An input parameters that use on job execution.
         :rtype: Result
         """
-        strategy_context: DictData = {}
+        context: DictData = {}
 
         # NOTE: Normal Job execution.
         if (not self.strategy.is_set()) or self.strategy.max_parallel == 1:
             for strategy in self.strategy.make():
-                rs: Result = self.strategy_execute(
+                rs: Result = self.execute_strategy(
                     strategy, params=copy.deepcopy(params)
                 )
-                strategy_context.update(rs.context)
+                context.update(rs.context)
             return Result(
                 status=0,
-                context=strategy_context,
+                context=context,
             )
 
         # # WARNING: (WF001) I got error that raise when use
@@ -430,7 +458,7 @@ class Job(BaseModel):
         #     ) as executor:
         #         futures: list[Future] = [
         #             executor.submit(
-        #                 self.strategy_execute,
+        #                 self.execute_strategy,
         #                 strategy,
         #                 params=copy.deepcopy(params),
         #                 event=event,
@@ -450,13 +478,15 @@ class Job(BaseModel):
         ) as executor:
             futures: list[Future] = [
                 executor.submit(
-                    self.strategy_execute,
+                    self.execute_strategy,
                     strategy,
                     params=copy.deepcopy(params),
                     event=event,
                 )
                 for strategy in self.strategy.make()
             ]
+
+            # NOTE: Dynamic catching futures object with fail-fast flag.
             if self.strategy.fail_fast:
                 rs: Result = self.__catch_fail_fast(event, futures)
             else:
@@ -475,7 +505,7 @@ class Job(BaseModel):
         :param futures: A list of futures.
         :rtype: Result
         """
-        strategy_context: DictData = {}
+        context: DictData = {}
         # NOTE: Get results from a collection of tasks with a
         #   timeout that has the first exception.
         done, not_done = wait(
@@ -484,20 +514,22 @@ class Job(BaseModel):
         nd: str = (
             f", the strategies do not run is {not_done}" if not_done else ""
         )
-        logging.debug(f"[JOB]: Strategy is set Fail Fast{nd}")
+        logger.debug(f"({self.run_id}) [JOB]: Strategy is set Fail Fast{nd}")
 
-        # NOTE: Stop all running tasks
-        event.set()
+        if len(done) != len(futures):
 
-        # NOTE: Cancel any scheduled tasks
-        for future in futures:
-            future.cancel()
+            # NOTE: Stop all running tasks
+            event.set()
+
+            # NOTE: Cancel any scheduled tasks
+            for future in futures:
+                future.cancel()
 
         status: int = 0
         for future in done:
             if future.exception():
                 status = 1
-                logging.error(
+                logger.error(
                     f"({self.run_id}) [JOB]: One stage failed with: "
                     f"{future.exception()}, shutting down this future."
                 )
@@ -505,11 +537,8 @@ class Job(BaseModel):
                 continue
             else:
                 rs: Result = future.result(timeout=60)
-                strategy_context.update(rs.context)
-        return Result(
-            status=status,
-            context=strategy_context,
-        )
+                context.update(rs.context)
+        return Result(status=status, context=context)
 
     def __catch_all_completed(self, futures: list[Future]) -> Result:
         """Job parallel pool futures catching with all-completed mode.
@@ -517,12 +546,12 @@ class Job(BaseModel):
         :param futures: A list of futures.
         :rtype: Result
         """
-        strategy_context: DictData = {}
+        context: DictData = {}
         status: int = 0
         for future in as_completed(futures):
             try:
                 rs: Result = future.result(timeout=60)
-                strategy_context.update(rs.context)
+                context.update(rs.context)
             except PickleError as err:
                 # NOTE: (WF001) I do not want to fix this issue because
                 #   it does not make sense and over-engineering with
@@ -533,26 +562,35 @@ class Job(BaseModel):
                 ) from None
             except TimeoutError:
                 status = 1
-                logging.warning("Task is hanging. Attempting to kill.")
+                logger.warning(
+                    f"({self.run_id}) [JOB]: Task is hanging. Attempting to "
+                    f"kill."
+                )
                 future.cancel()
+                time.sleep(0.1)
                 if not future.cancelled():
-                    logging.warning("Failed to cancel the task.")
+                    logger.warning(
+                        f"({self.run_id}) [JOB]: Failed to cancel the task."
+                    )
                 else:
-                    logging.warning("Task canceled successfully.")
+                    logger.warning(
+                        f"({self.run_id}) [JOB]: Task canceled successfully."
+                    )
             except JobException as err:
                 status = 1
-                logging.error(
+                logger.error(
                     f"({self.run_id}) [JOB]: Get stage exception with "
                     f"fail-fast does not set;\n{err.__class__.__name__}:\n\t"
                     f"{err}"
                 )
-        return Result(status=status, context=strategy_context)
+        return Result(status=status, context=context)
 
 
 class Pipeline(BaseModel):
     """Pipeline Model this is the main future of this project because it use to
-    be workflow data for running everywhere that you want. It use lightweight
-    coding line to execute it.
+    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 pipeline name.")
@@ -578,6 +616,7 @@ class Pipeline(BaseModel):
         default=None,
         description="A running pipeline ID.",
         repr=False,
+        exclude=True,
     )
 
     @property
@@ -601,17 +640,19 @@ class Pipeline(BaseModel):
         :rtype: Self
         """
         loader: Loader = Loader(name, externals=(externals or {}))
+
+        # NOTE: Validate the config type match with current connection model
+        if loader.type != cls:
+            raise ValueError(f"Type {loader.type} does not match with {cls}")
+
         loader_data: DictData = copy.deepcopy(loader.data)
 
         # NOTE: Add name to loader data
         loader_data["name"] = name.replace(" ", "_")
 
-        if "jobs" not in loader_data:
-            raise ValueError("Config does not set ``jobs`` value")
-
         # NOTE: Prepare `on` data
         cls.__bypass_on(loader_data)
-        return cls.model_validate(loader_data)
+        return cls.model_validate(obj=loader_data)
 
     @classmethod
     def __bypass_on(cls, data: DictData, externals: DictData | None = None):
@@ -742,120 +783,128 @@ class Pipeline(BaseModel):
         self,
         on: On,
         params: DictData,
+        queue: list[datetime],
         *,
-        waiting_sec: int = 55,
+        waiting_sec: int = 60,
         sleep_interval: int = 15,
         log: Log = None,
-        lq: list[datetime] = None,
     ) -> Result:
         """Start running pipeline with the on schedule in period of 30 minutes.
         That mean it will still running at background 30 minutes until the
         schedule matching with its time.
 
             This method allow pipeline 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 local `/logs` directory.
+
+        :param on: An on schedule value.
+        :param params: A pipeline parameter that pass to execute method.
+        :param queue: A list of release time that already running.
+        :param waiting_sec: A second period value that allow pipeline execute.
+        :param sleep_interval: A second value that want to waiting until time
+            to execute.
+        :param log: A log object that want to save execution result.
         :rtype: Result
         """
-        delay()
         log: Log = log or FileLog
-        current_running_time = datetime.now()
-        if not (
-            latest_running_time := log.latest_point(name=self.name, queue=lq)
-        ) or (
-            latest_running_time.replace(tzinfo=ZoneInfo(on.tz))
-            < current_running_time.replace(tzinfo=ZoneInfo(on.tz))
-        ):
-            latest_running_time: datetime = current_running_time.replace(
-                tzinfo=ZoneInfo(on.tz)
-            )
-        else:
-            latest_running_time: datetime = latest_running_time.replace(
-                tzinfo=ZoneInfo(on.tz)
-            )
-
+        tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
         gen: CronRunner = on.generate(
-            latest_running_time + timedelta(seconds=1)
+            datetime.now(tz=tz).replace(second=0, microsecond=0)
+            + timedelta(seconds=1)
         )
-        tz: ZoneInfo = gen.tz
+        cron_tz: ZoneInfo = gen.tz
 
         # NOTE: get next schedule time that generate from now.
-        next_running_time: datetime = gen.next
+        next_time: datetime = gen.next
 
-        # NOTE: get next utils it does not logging.
-        # while log.is_pointed(self.name, next_running_time, queue=lq):
-        #     next_running_time: datetime = gen.next
-        while log.is_pointed(self.name, next_running_time, queue=lq):
-            next_running_time: datetime = gen.next
+        # NOTE: get next utils it does not logger.
+        while log.is_pointed(self.name, next_time, queue=queue):
+            next_time: datetime = gen.next
 
-        heappush(lq, next_running_time)
+        # NOTE: push this next running time to log queue
+        heappush(queue, next_time)
 
         # VALIDATE: Check the different time between the next schedule time and
         #   now that less than waiting period (second unit).
-        if get_diff_sec(next_running_time, tz=tz) <= waiting_sec:
-            logging.debug(
+        if get_diff_sec(next_time, tz=cron_tz) > waiting_sec:
+            logger.debug(
                 f"({self.run_id}) [CORE]: {self.name!r} : {on.cronjob} : "
-                f"Closely to run >> {next_running_time:%Y-%m-%d %H:%M:%S}"
+                f"Does not closely >> {next_time:%Y-%m-%d %H:%M:%S}"
             )
 
-            # NOTE: Release when the time is nearly to schedule time.
-            while (duration := get_diff_sec(next_running_time, tz=tz)) > (
-                sleep_interval + 5
-            ):
-                logging.debug(
-                    f"({self.run_id}) [CORE]: {self.name!r} : {on.cronjob} : "
-                    f"Sleep until: {duration}"
-                )
-                time.sleep(sleep_interval)
-
-            time.sleep(0.5)
+            # NOTE: Remove next datetime from queue.
+            queue.remove(next_time)
 
-            # NOTE: Release parameter that use to change if params has
-            #   templating.
-            release_params: DictData = {
-                "release": {
-                    "logical_date": next_running_time,
+            time.sleep(0.15)
+            return Result(
+                status=0,
+                context={
+                    "params": params,
+                    "poking": {"skipped": [str(on.cronjob)], "run": []},
                 },
-            }
-
-            # WARNING: Re-create pipeline object that use new running pipeline
-            #   ID.
-            pipeline: Self = self.get_running_id(run_id=self.new_run_id)
-            rs: Result = pipeline.execute(
-                params=param2template(params, release_params),
-            )
-            logging.debug(
-                f"({pipeline.run_id}) [CORE]: {self.name!r} : {on.cronjob} : "
-                f"End release"
             )
 
-            del pipeline
-
-            rs.set_parent_run_id(self.run_id)
-            rs_log: Log = log.model_validate(
-                {
-                    "name": self.name,
-                    "on": str(on.cronjob),
-                    "release": next_running_time,
-                    "context": rs.context,
-                    "parent_run_id": rs.run_id,
-                    "run_id": rs.run_id,
-                }
-            )
-            rs_log.save()
-        else:
-            logging.debug(
+        logger.debug(
+            f"({self.run_id}) [CORE]: {self.name!r} : {on.cronjob} : "
+            f"Closely to run >> {next_time:%Y-%m-%d %H:%M:%S}"
+        )
+
+        # NOTE: Release when the time is nearly to schedule time.
+        while (duration := get_diff_sec(next_time, tz=cron_tz)) > (
+            sleep_interval + 5
+        ):
+            logger.debug(
                 f"({self.run_id}) [CORE]: {self.name!r} : {on.cronjob} : "
-                f"Does not closely >> {next_running_time:%Y-%m-%d %H:%M:%S}"
+                f"Sleep until: {duration}"
             )
-            rs = Result(status=0, context={"params": params})
+            time.sleep(sleep_interval)
+
+        time.sleep(0.5)
 
-        if lq is None:
-            return rs
+        # NOTE: Release parameter that use to change if params has
+        #   templating.
+        release_params: DictData = {
+            "release": {
+                "logical_date": next_time,
+            },
+        }
 
-        lq.remove(next_running_time)
-        time.sleep(0.25)
-        return rs
+        # WARNING: Re-create pipeline object that use new running pipeline
+        #   ID.
+        runner: Self = self.get_running_id(run_id=self.new_run_id)
+        rs: Result = runner.execute(
+            params=param2template(params, release_params),
+        )
+        logger.debug(
+            f"({runner.run_id}) [CORE]: {self.name!r} : {on.cronjob} : "
+            f"End release {next_time:%Y-%m-%d %H:%M:%S}"
+        )
+
+        # NOTE: Delete a copied pipeline instance for saving memory.
+        del runner
+
+        rs.set_parent_run_id(self.run_id)
+        rs_log: Log = log.model_validate(
+            {
+                "name": self.name,
+                "on": str(on.cronjob),
+                "release": next_time,
+                "context": rs.context,
+                "parent_run_id": rs.run_id,
+                "run_id": rs.run_id,
+            }
+        )
+        # NOTE: Saving execution result to destination of the input log object.
+        rs_log.save(excluded=None)
+
+        queue.remove(next_time)
+        time.sleep(0.05)
+        return Result(
+            status=0,
+            context={
+                "params": params,
+                "poking": {"skipped": [], "run": [str(on.cronjob)]},
+            },
+        )
 
     def poke(
         self,
@@ -871,45 +920,49 @@ class Pipeline(BaseModel):
         :param log: A log object that want to use on this poking process.
         :rtype: list[Result]
         """
-        params: DictData = params or {}
-        logging.info(f"({self.run_id}) [CORE]: Start Poking: {self.name!r} ...")
-        results: list[Result] = []
-        log_queue: list[datetime] = []
+        logger.info(
+            f"({self.run_id}) [POKING]: Start Poking: {self.name!r} ..."
+        )
 
-        # NOTE: If this pipeline does not set schedule, it will return empty
-        #   result.
+        # NOTE: If this pipeline does not set the on schedule, it will return
+        #   empty result.
         if len(self.on) == 0:
-            return results
+            return []
 
-        with ThreadPoolExecutor(
-            max_workers=int(
-                os.getenv("WORKFLOW_CORE_MAX_PIPELINE_POKING", "4")
-            ),
-        ) as executor:
-            futures: list[Future] = [
-                executor.submit(
-                    self.release,
-                    on,
-                    params=params,
-                    log=log,
-                    lq=log_queue,
+        params: DictData = params or {}
+        queue: list[datetime] = []
+        results: list[Result] = []
+
+        wk: int = int(os.getenv("WORKFLOW_CORE_MAX_PIPELINE_POKING") or "4")
+        with ThreadPoolExecutor(max_workers=wk) as executor:
+            # TODO: If I want to run infinite loop.
+            futures: list[Future] = []
+            for on in self.on:
+                futures.append(
+                    executor.submit(
+                        self.release,
+                        on,
+                        params=params,
+                        log=log,
+                        queue=queue,
+                    )
                 )
-                for on in self.on
-            ]
+                delay()
+
+            # 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()
-                logging.info(rs.context.get("params", {}))
-                results.append(rs)
-
-        if len(log_queue) > 0:
-            logging.error(
-                f"({self.run_id}) [CORE]: Log Queue does empty when poke "
-                f"is finishing."
+                results.append(future.result(timeout=60))
+
+        if len(queue) > 0:
+            logger.error(
+                f"({self.run_id}) [POKING]: Log Queue does empty when poking "
+                f"process was finishing."
             )
 
         return results
 
-    def job_execute(
+    def execute_job(
         self,
         job: str,
         params: DictData,
@@ -918,6 +971,7 @@ class Pipeline(BaseModel):
 
         :param job: A job ID that want to execute.
         :param params: A params that was parameterized from pipeline execution.
+        :rtype: Result
         """
         # VALIDATE: check a job ID that exists in this pipeline or not.
         if job not in self.jobs:
@@ -925,7 +979,7 @@ class Pipeline(BaseModel):
                 f"The job ID: {job} does not exists on {self.name!r} pipeline."
             )
         try:
-            logging.info(f"({self.run_id}) [PIPELINE]: Start execute: {job!r}")
+            logger.info(f"({self.run_id}) [PIPELINE]: Start execute: {job!r}")
 
             # IMPORTANT:
             #   Change any job running IDs to this pipeline running ID.
@@ -933,10 +987,8 @@ class Pipeline(BaseModel):
             j_rs: Result = job_obj.execute(params=params)
 
         except JobException as err:
-            raise PipelineException(
-                f"The job ID: {job} get error: {err.__class__.__name__}:"
-                f"\n{err}"
-            ) from None
+            raise PipelineException(f"{job}: JobException: {err}") from None
+
         return Result(
             status=j_rs.status,
             context={job: job_obj.set_outputs(j_rs.context)},
@@ -970,12 +1022,16 @@ class Pipeline(BaseModel):
             ... ${job-name}.stages.${stage-id}.outputs.${key}
 
         """
-        logging.info(f"({self.run_id}) [CORE]: Start Execute: {self.name} ...")
+        logger.info(f"({self.run_id}) [CORE]: Start Execute: {self.name!r} ...")
         params: DictData = params or {}
+        ts: float = time.monotonic()
 
         # NOTE: It should not do anything if it does not have job.
         if not self.jobs:
-            logging.warning("[PIPELINE]: This pipeline does not have any jobs")
+            logger.warning(
+                f"({self.run_id}) [PIPELINE]: This pipeline: {self.name!r} "
+                f"does not have any jobs"
+            )
             return Result(status=0, context=params)
 
         # NOTE: Create a job queue that keep the job that want to running after
@@ -984,79 +1040,70 @@ class Pipeline(BaseModel):
         for job_id in self.jobs:
             jq.put(job_id)
 
-        # NOTE: Create start timestamp
-        ts: float = time.monotonic()
-
         # NOTE: Create result context that will pass this context to any
         #   execution dependency.
-        rs: Result = Result(context=self.parameterize(params))
+        context: DictData = self.parameterize(params)
         try:
-            rs.receive(
-                self.__exec_non_threading(rs, ts, timeout=timeout)
-                if (
-                    worker := int(
-                        os.getenv("WORKFLOW_CORE_MAX_JOB_PARALLEL", "2")
-                    )
-                )
-                == 1
+            worker: int = int(os.getenv("WORKFLOW_CORE_MAX_JOB_PARALLEL", "2"))
+            (
+                self.__exec_non_threading(context, ts, jq, timeout=timeout)
+                if worker == 1
                 else self.__exec_threading(
-                    rs, ts, worker=worker, timeout=timeout
+                    context, ts, jq, worker=worker, timeout=timeout
                 )
             )
-            return rs
+            return Result(status=0, context=context)
         except PipelineException as err:
-            rs.context.update({"error": {"message": str(err)}})
-            rs.status = 1
-            return rs
+            context.update(
+                {"error_message": f"{err.__class__.__name__}: {err}"}
+            )
+            return Result(status=1, context=context)
 
     def __exec_threading(
         self,
-        rs: Result,
+        context: DictData,
         ts: float,
+        job_queue: Queue,
         *,
         worker: int = 2,
         timeout: int = 600,
-    ) -> Result:
+    ) -> DictData:
         """Pipeline threading execution.
 
-        :param rs:
-        :param ts:
+        :param context: A context pipeline data that want to downstream passing.
+        :param ts: A start timestamp that use for checking execute time should
+            timeout.
         :param timeout: A second value unit that bounding running time.
         :param worker: A number of threading executor pool size.
-        :rtype: Result
+        :rtype: DictData
         """
         not_time_out_flag: bool = True
-        logging.debug(
+        logger.debug(
             f"({self.run_id}): [CORE]: Run {self.name} with threading job "
             f"executor"
         )
 
-        # NOTE: Create a job queue that keep the job that want to running after
-        #   it dependency condition.
-        job_queue: Queue = Queue()
-        for job_id in self.jobs:
-            job_queue.put(job_id)
-
         # IMPORTANT: The job execution can run parallel and waiting by
         #   needed.
         with ThreadPoolExecutor(max_workers=worker) as executor:
             futures: list[Future] = []
+
             while not job_queue.empty() and (
                 not_time_out_flag := ((time.monotonic() - ts) < timeout)
             ):
                 job_id: str = job_queue.get()
                 job: Job = self.jobs[job_id]
 
-                if any(need not in rs.context["jobs"] for need in job.needs):
+                if any(need not in context["jobs"] for need in job.needs):
                     job_queue.put(job_id)
-                    time.sleep(0.5)
+                    time.sleep(0.25)
                     continue
 
                 futures.append(
                     executor.submit(
-                        self.job_execute,
+                        self.execute_job,
                         job_id,
-                        params=copy.deepcopy(rs.context),
+                        params=copy.deepcopy(context),
                     ),
                 )
                 job_queue.task_done()
@@ -1066,19 +1113,19 @@ class Pipeline(BaseModel):
 
             for future in as_completed(futures):
                 if err := future.exception():
-                    logging.error(f"{err}")
+                    logger.error(f"{err}")
                     raise PipelineException(f"{err}")
 
                 # NOTE: Update job result to pipeline result.
-                rs.receive_jobs(future.result(timeout=20))
+                context["jobs"].update(future.result(timeout=20).conext)
 
         if not_time_out_flag:
-            rs.status = 0
-            return rs
+            return context
 
         # NOTE: Raise timeout error.
-        logging.warning(
-            f"({self.run_id}) [PIPELINE]: Execution of pipeline was timeout"
+        logger.warning(
+            f"({self.run_id}) [PIPELINE]: Execution of pipeline, {self.name!r} "
+            f", was timeout"
         )
         raise PipelineException(
             f"Execution of pipeline: {self.name} was timeout"
@@ -1086,28 +1133,26 @@ class Pipeline(BaseModel):
 
     def __exec_non_threading(
         self,
-        rs: Result,
+        context: DictData,
         ts: float,
+        job_queue: Queue,
         *,
         timeout: int = 600,
-    ) -> Result:
-        """Pipeline non-threading execution.
+    ) -> DictData:
+        """Pipeline non-threading execution that use sequential job running
+        and waiting previous run successful.
 
-        :param rs:
-        :param ts:
+        :param context: A context pipeline data that want to downstream passing.
+        :param ts: A start timestamp that use for checking execute time should
+            timeout.
         :param timeout: A second value unit that bounding running time.
-        :rtype: Result
+        :rtype: DictData
         """
         not_time_out_flag: bool = True
-        logging.debug(
+        logger.debug(
             f"({self.run_id}) [CORE]: Run {self.name} with non-threading job "
             f"executor"
         )
-        # NOTE: Create a job queue that keep the job that want to running after
-        #   it dependency condition.
-        job_queue: Queue = Queue()
-        for job_id in self.jobs:
-            job_queue.put(job_id)
 
         while not job_queue.empty() and (
             not_time_out_flag := ((time.monotonic() - ts) < timeout)
@@ -1116,25 +1161,24 @@ class Pipeline(BaseModel):
             job: Job = self.jobs[job_id]
 
             # NOTE:
-            if any(need not in rs.context["jobs"] for need in job.needs):
+            if any(need not in context["jobs"] for need in job.needs):
                 job_queue.put(job_id)
-                time.sleep(0.5)
+                time.sleep(0.25)
                 continue
 
             # NOTE: Start job execution.
-            job_rs = self.job_execute(job_id, params=copy.deepcopy(rs.context))
-            rs.context["jobs"].update(job_rs.context)
+            job_rs = self.execute_job(job_id, params=copy.deepcopy(context))
+            context["jobs"].update(job_rs.context)
             job_queue.task_done()
 
         # NOTE: Wait for all items to finish processing
         job_queue.join()
 
         if not_time_out_flag:
-            rs.status = 0
-            return rs
+            return context
 
         # NOTE: Raise timeout error.
-        logging.warning(
+        logger.warning(
             f"({self.run_id}) [PIPELINE]: Execution of pipeline was timeout"
         )
         raise PipelineException(