ddeutil-workflow 0.0.85__py3-none-any.whl → 0.0.86__py3-none-any.whl

ddeutil/workflow/workflow.py

@@ -19,11 +19,12 @@ Classes:
 Constants:
     NORMAL: Normal release execution
     RERUN: Re-execution of failed workflows
-    EVENT: Event-triggered execution
+    DRYRUN: Dryrun execution for testing workflow loop.
     FORCE: Force execution regardless of conditions
 """
 import copy
 import time
+import traceback
 from concurrent.futures import (
     Future,
     ThreadPoolExecutor,
@@ -43,9 +44,15 @@ from typing_extensions import Self
 
 from . import DRYRUN
 from .__types import DictData
-from .audits import NORMAL, RERUN, Audit, ReleaseType, get_audit
+from .audits import NORMAL, RERUN, Audit, AuditData, ReleaseType, get_audit
 from .conf import YamlParser, dynamic
-from .errors import WorkflowCancelError, WorkflowError, WorkflowTimeoutError
+from .errors import (
+    WorkflowCancelError,
+    WorkflowError,
+    WorkflowSkipError,
+    WorkflowTimeoutError,
+    to_dict,
+)
 from .event import Event
 from .job import Job
 from .params import Param
@@ -65,7 +72,6 @@ from .reusables import has_template, param2template
 from .traces import Trace, get_trace
 from .utils import (
     extract_id,
-    gen_id,
     get_dt_now,
     pop_sys_extras,
 )
@@ -167,10 +173,10 @@ class Workflow(BaseModel):
             FileNotFoundError: If workflow configuration file not found
 
         Example:
-            >>> # NOTE: Load from default config path
+            Case: Load from default config path
             >>> workflow = Workflow.from_conf('data-pipeline')
 
-            >>> # NOTE: Load with custom path and extras
+            Case: Load with custom path and extras
             >>> workflow = Workflow.from_conf(
             ...     'data-pipeline',
             ...     path=Path('./custom-configs'),
@@ -374,7 +380,6 @@ class Workflow(BaseModel):
                     if k in self.params
                 }
             ),
-            "jobs": {},
         }
 
     def release(
@@ -439,7 +444,10 @@ class Workflow(BaseModel):
             "extras": self.extras,
         }
         trace: Trace = get_trace(
-            run_id, parent_run_id=parent_run_id, extras=self.extras
+            run_id,
+            parent_run_id=parent_run_id,
+            extras=self.extras,
+            pre_process=True,
         )
         release: datetime = self.on.validate_dt(dt=release)
         trace.info(f"[RELEASE]: Start {name!r} : {release:%Y-%m-%d %H:%M:%S}")
@@ -457,13 +465,21 @@ class Workflow(BaseModel):
         )
 
         if release_type == RERUN:
-            # TODO: It will load previous audit and use this data to run with
-            #   the `rerun` method.
-            raise NotImplementedError(
-                "Release does not support for rerun type yet. Please use the "
-                "`rerun` method instead."
-            )
+            try:
+                previous: AuditData = audit.find_audit_with_release(
+                    name, release=release
+                )
+                values: DictData = previous.context
+            except FileNotFoundError:
+                trace.warning(
+                    (
+                        f"Does not find previous audit log with release: "
+                        f"{release:%Y%m%d%H%M%S}"
+                    ),
+                    module="release",
+                )
         elif release_type == DRYRUN:
+            # IMPORTANT: Set system extra parameter for allow dryrun mode,
             self.extras.update({"__sys_release_dryrun_mode": True})
             trace.debug("[RELEASE]: Mark dryrun mode to the extra params.")
         elif release_type == NORMAL and audit.is_pointed(data=audit_data):
@@ -492,7 +508,7 @@ class Workflow(BaseModel):
                         "context": context,
                         "runs_metadata": (
                             (runs_metadata or {})
-                            | rs.info
+                            | context.get("info", {})
                             | {
                                 "timeout": timeout,
                                 "original_name": self.name,
@@ -523,7 +539,7 @@ class Workflow(BaseModel):
             ),
         )
 
-    def execute_job(
+    def process_job(
         self,
         job: Job,
         run_id: str,
@@ -532,7 +548,7 @@ class Workflow(BaseModel):
         parent_run_id: Optional[str] = None,
         event: Optional[ThreadEvent] = None,
     ) -> tuple[Status, DictData]:
-        """Job execution with passing dynamic parameters from the main workflow
+        """Job process job 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
@@ -602,132 +618,48 @@ class Workflow(BaseModel):
 
         return result.status, catch(context, status=result.status)
 
-    def execute(
+    def process(
         self,
-        params: DictData,
+        job_queue: Queue[str],
+        run_id: str,
+        context: DictData,
         *,
-        run_id: Optional[str] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[ThreadEvent] = None,
         timeout: float = 3600,
         max_job_parallel: int = 2,
+        total_job: Optional[int] = None,
     ) -> Result:
-        """Execute workflow with passing a dynamic parameters to all jobs that
-        included in this workflow model with `jobs` field.
-
-            The result of execution process for each job and stages on this
-        workflow will keep in dict which able to catch out with all jobs and
-        stages by dot annotation.
-
-            For example with non-strategy job, when I want to use the output
-        from previous stage, I can access it with syntax:
+        """Job process method.
 
-        ... ${job-id}.stages.${stage-id}.outputs.${key}
-        ... ${job-id}.stages.${stage-id}.errors.${key}
-
-            But example for strategy job:
-
-        ... ${job-id}.strategies.${strategy-id}.stages.${stage-id}.outputs.${key}
-        ... ${job-id}.strategies.${strategy-id}.stages.${stage-id}.errors.${key}
-
-            This method already handle all exception class that can raise from
-        the job execution. It will warp that error and keep it in the key `errors`
-        at the result context.
-
-
-            Execution   --> Ok      --> Result
-                                        |-status: CANCEL
-                                        ╰-context:
-                                            ╰-errors:
-                                                |-name: ...
-                                                ╰-message: ...
-
-                        --> Ok      --> Result
-                                        |-status: FAILED
-                                        ╰-context:
-                                            ╰-errors:
-                                                |-name: ...
-                                                ╰-message: ...
-
-                        --> Ok      --> Result
-                                        ╰-status: SKIP
-
-                        --> Ok      --> Result
-                                        ╰-status: SUCCESS
-
-        :param params: A parameter data that will parameterize before execution.
-        :param run_id: (Optional[str]) A workflow running ID.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-        :param timeout: (float) A workflow execution time out in second unit
-            that use for limit time of execution and waiting job dependency.
-            This value does not force stop the task that still running more than
-            this limit time. (Default: 60 * 60 seconds)
-        :param max_job_parallel: (int) The maximum workers that use for job
-            execution in `ThreadPoolExecutor` object. (Default: 2 workers)
-
-        :rtype: Result
+        Args:
+            job_queue:
+            run_id (str):
+            context (DictData):
+            parent_run_id (str, default None):
+            event (Event, default None):
+            timeout:
+            max_job_parallel:
+            total_job:
         """
         ts: float = time.monotonic()
-        parent_run_id, run_id = extract_id(
-            self.name, run_id=run_id, extras=self.extras
-        )
         trace: Trace = get_trace(
             run_id, parent_run_id=parent_run_id, extras=self.extras
         )
-        context: DictData = self.parameterize(params)
-        event: ThreadEvent = event or ThreadEvent()
-        max_job_parallel: int = dynamic(
-            "max_job_parallel", f=max_job_parallel, extras=self.extras
-        )
-        trace.info(
-            f"[WORKFLOW]: Execute: {self.name!r} ("
-            f"{'parallel' if max_job_parallel > 1 else 'sequential'} jobs)"
-        )
-        if not self.jobs:
-            trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
-            return Result(
-                run_id=run_id,
-                parent_run_id=parent_run_id,
-                status=SUCCESS,
-                context=catch(context, status=SUCCESS),
-                info={"execution_time": time.monotonic() - ts},
-                extras=self.extras,
-            )
-
-        job_queue: Queue = Queue()
-        for job_id in self.jobs:
-            job_queue.put(job_id)
-
         not_timeout_flag: bool = True
-        total_job: int = len(self.jobs)
+        total_job: int = total_job or len(self.jobs)
         statuses: list[Status] = [WAIT] * total_job
         skip_count: int = 0
         sequence_statuses: list[Status] = []
-        timeout: float = dynamic(
-            "max_job_exec_timeout", f=timeout, extras=self.extras
-        )
-        catch(context, status=WAIT)
         if event and event.is_set():
-            err_msg: str = (
+            raise WorkflowCancelError(
                 "Execution was canceled from the event was set "
                 "before workflow execution."
             )
-            trace.error(f"[WORKFLOW]: {err_msg}")
-            return Result(
-                run_id=run_id,
-                parent_run_id=parent_run_id,
-                status=CANCEL,
-                context=catch(
-                    context,
-                    status=CANCEL,
-                    updated={"errors": WorkflowCancelError(err_msg).to_dict()},
-                ),
-                info={"execution_time": time.monotonic() - ts},
-                extras=self.extras,
-            )
 
         # NOTE: Force update internal extras for handler circle execution.
         self.extras.update({"__sys_exec_break_circle": self.name})
+
         with ThreadPoolExecutor(max_job_parallel, "wf") as executor:
             futures: list[Future] = []
 
@@ -757,23 +689,9 @@ class Workflow(BaseModel):
 
                 if check == FAILED:  # pragma: no cov
                     pop_sys_extras(self.extras)
-                    return Result(
-                        run_id=run_id,
-                        parent_run_id=parent_run_id,
-                        status=FAILED,
-                        context=catch(
-                            context,
-                            status=FAILED,
-                            updated={
-                                "status": FAILED,
-                                "errors": WorkflowError(
-                                    f"Validate job trigger rule was failed "
-                                    f"with {job.trigger_rule.value!r}."
-                                ).to_dict(),
-                            },
-                        ),
-                        info={"execution_time": time.monotonic() - ts},
-                        extras=self.extras,
+                    raise WorkflowError(
+                        f"Validate job trigger rule was failed with "
+                        f"{job.trigger_rule.value!r}."
                     )
                 elif check == SKIP:  # pragma: no cov
                     trace.info(
@@ -788,7 +706,7 @@ class Workflow(BaseModel):
                 if max_job_parallel > 1:
                     futures.append(
                         executor.submit(
-                            self.execute_job,
+                            self.process_job,
                             job=job,
                             run_id=run_id,
                             context=context,
@@ -802,7 +720,7 @@ class Workflow(BaseModel):
                 if len(futures) < 1:
                     futures.append(
                         executor.submit(
-                            self.execute_job,
+                            self.process_job,
                             job=job,
                             run_id=run_id,
                             context=context,
@@ -853,13 +771,8 @@ class Workflow(BaseModel):
 
                 pop_sys_extras(self.extras)
                 st: Status = validate_statuses(statuses)
-                return Result(
-                    run_id=run_id,
-                    parent_run_id=parent_run_id,
-                    status=st,
-                    context=catch(context, status=st),
-                    info={"execution_time": time.monotonic() - ts},
-                    extras=self.extras,
+                return Result.from_trace(trace).catch(
+                    status=st, context=catch(context, status=st)
                 )
 
             event.set()
@@ -867,85 +780,86 @@ class Workflow(BaseModel):
                 future.cancel()
 
             trace.error(
-                f"[WORKFLOW]: {self.name!r} was timeout because it use exec "
-                f"time more than {timeout} seconds."
+                (
+                    f"{self.name!r} was timeout because it use exec time more "
+                    f"than {timeout} seconds."
+                ),
+                module="workflow",
             )
 
             time.sleep(0.0025)
 
         pop_sys_extras(self.extras)
-        return Result(
-            run_id=run_id,
-            parent_run_id=parent_run_id,
-            status=FAILED,
-            context=catch(
-                context,
-                status=FAILED,
-                updated={
-                    "errors": WorkflowTimeoutError(
-                        f"{self.name!r} was timeout because it use exec time "
-                        f"more than {timeout} seconds."
-                    ).to_dict(),
-                },
-            ),
-            info={"execution_time": time.monotonic() - ts},
-            extras=self.extras,
+        raise WorkflowTimeoutError(
+            f"{self.name!r} was timeout because it use exec time more than "
+            f"{timeout} seconds."
         )
 
-    def rerun(
+    def _execute(
         self,
+        params: DictData,
+        trace: Trace,
         context: DictData,
         *,
-        run_id: Optional[str] = None,
         event: Optional[ThreadEvent] = None,
         timeout: float = 3600,
         max_job_parallel: int = 2,
-    ) -> Result:  # pragma: no cov
-        """Re-Execute workflow with passing the error context data.
-
-        Warnings:
-            This rerun method allow to rerun job execution level only. That mean
-        it does not support rerun only stage.
+        total_job: Optional[int] = None,
+    ) -> Result:
+        """Wrapped Execute method."""
+        context.update(
+            {"jobs": {}, "info": {"exec_start": get_dt_now()}}
+            | self.parameterize(params)
+        )
+        trace.info(
+            f"[WORKFLOW]: Execute: {self.name!r} ("
+            f"{'parallel' if max_job_parallel > 1 else 'sequential'} jobs)"
+        )
+        if not self.jobs:
+            trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
+            return Result.from_trace(trace).catch(
+                status=SUCCESS, context=catch(context, status=SUCCESS)
+            )
 
-        Args:
-            context: A context result that get the failed status.
-            run_id: (Optional[str]) A workflow running ID.
-            event: (Event) An Event manager instance that use to cancel this
-                execution if it forces stopped by parent execution.
-            timeout: (float) A workflow execution time out in second unit
-                that use for limit time of execution and waiting job dependency.
-                This value does not force stop the task that still running more
-                than this limit time. (Default: 60 * 60 seconds)
-            max_job_parallel: (int) The maximum workers that use for job
-                execution in `ThreadPoolExecutor` object. (Default: 2 workers)
+        job_queue: Queue[str] = Queue()
+        for job_id in self.jobs:
+            job_queue.put(job_id)
 
-        Returns
-            Result: Return Result object that create from execution context with
-                return mode.
-        """
-        ts: float = time.monotonic()
-        parent_run_id: str = run_id
-        run_id: str = gen_id(self.name, extras=self.extras)
-        trace: Trace = get_trace(
-            run_id, parent_run_id=parent_run_id, extras=self.extras
+        catch(context, status=WAIT)
+        return self.process(
+            job_queue,
+            run_id=trace.run_id,
+            context=context,
+            parent_run_id=trace.parent_run_id,
+            event=event,
+            timeout=timeout,
+            max_job_parallel=max_job_parallel,
+            total_job=total_job,
         )
-        if context["status"] == SUCCESS:
+
+    def _rerun(
+        self,
+        params: DictData,
+        trace: Trace,
+        context: DictData,
+        *,
+        event: Optional[ThreadEvent] = None,
+        timeout: float = 3600,
+        max_job_parallel: int = 2,
+    ) -> Result:
+        """Wrapped Rerun method."""
+        if params["status"] == SUCCESS:
             trace.info(
                 "[WORKFLOW]: Does not rerun because it already executed with "
                 "success status."
             )
             return Result.from_trace(trace).catch(
                 status=SUCCESS,
-                context=catch(context=context, status=SUCCESS),
+                context=catch(context=params, status=SUCCESS),
             )
 
-        err: dict[str, str] = context.get("errors", {})
+        err: dict[str, str] = params.get("errors", {})
         trace.info(f"[WORKFLOW]: Previous error: {err}")
-
-        event: ThreadEvent = event or ThreadEvent()
-        max_job_parallel: int = dynamic(
-            "max_job_parallel", f=max_job_parallel, extras=self.extras
-        )
         trace.info(
             f"[WORKFLOW]: Execute: {self.name!r} ("
             f"{'parallel' if max_job_parallel > 1 else 'sequential'} jobs)"
@@ -953,19 +867,24 @@ class Workflow(BaseModel):
         if not self.jobs:
             trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
             return Result.from_trace(trace).catch(
-                status=SUCCESS,
-                context=catch(context=context, status=SUCCESS),
+                status=SUCCESS, context=catch(context=params, status=SUCCESS)
             )
 
         # NOTE: Prepare the new context variable for rerun process.
-        jobs: DictData = context.get("jobs")
-        context: DictData = {
-            "params": context["params"].copy(),
-            "jobs": {j: jobs[j] for j in jobs if jobs[j]["status"] == SUCCESS},
-        }
+        jobs: DictData = params.get("jobs")
+        context.update(
+            {
+                "params": params["params"].copy(),
+                "jobs": {
+                    j: jobs[j]
+                    for j in jobs
+                    if jobs[j].get("status", FAILED) == SUCCESS
+                },
+            }
+        )
 
         total_job: int = 0
-        job_queue: Queue = Queue()
+        job_queue: Queue[str] = Queue()
         for job_id in self.jobs:
 
             if job_id in context["jobs"]:
@@ -975,178 +894,199 @@ class Workflow(BaseModel):
             total_job += 1
 
         if total_job == 0:
-            trace.warning(
-                "[WORKFLOW]: It does not have job to rerun. it will change "
+            raise WorkflowSkipError(
+                "It does not have job to rerun. it will change "
                 "status to skip."
             )
-            return Result.from_trace(trace).catch(
-                status=SKIP,
-                context=catch(context=context, status=SKIP),
-            )
-
-        not_timeout_flag: bool = True
-        statuses: list[Status] = [WAIT] * total_job
-        skip_count: int = 0
-        sequence_statuses: list[Status] = []
-        timeout: float = dynamic(
-            "max_job_exec_timeout", f=timeout, extras=self.extras
-        )
 
         catch(context, status=WAIT)
-        if event and event.is_set():
-            return Result.from_trace(trace).catch(
-                status=CANCEL,
-                context=catch(
-                    context,
-                    status=CANCEL,
-                    updated={
-                        "errors": WorkflowCancelError(
-                            "Execution was canceled from the event was set "
-                            "before workflow execution."
-                        ).to_dict(),
-                    },
-                ),
-            )
+        return self.process(
+            job_queue,
+            run_id=trace.run_id,
+            context=context,
+            parent_run_id=trace.parent_run_id,
+            event=event,
+            timeout=timeout,
+            max_job_parallel=max_job_parallel,
+            total_job=total_job,
+        )
 
-        with ThreadPoolExecutor(max_job_parallel, "wf") as executor:
-            futures: list[Future] = []
-            backoff_sleep = 0.01
-            consecutive_waits = 0
+    def execute(
+        self,
+        params: DictData,
+        *,
+        run_id: Optional[str] = None,
+        event: Optional[ThreadEvent] = None,
+        timeout: float = 3600,
+        max_job_parallel: int = 2,
+        rerun_mode: bool = False,
+    ) -> Result:
+        """Execute workflow with passing a dynamic parameters to all jobs that
+        included in this workflow model with `jobs` field.
 
-            while not job_queue.empty() and (
-                not_timeout_flag := ((time.monotonic() - ts) < timeout)
-            ):
-                job_id: str = job_queue.get()
-                job: Job = self.job(name=job_id)
-                if (check := job.check_needs(context["jobs"])) == WAIT:
-                    job_queue.task_done()
-                    job_queue.put(job_id)
-                    consecutive_waits += 1
+            The result of execution process for each job and stages on this
+        workflow will keep in dict which able to catch out with all jobs and
+        stages by dot annotation.
 
-                    # NOTE: Exponential backoff up to 0.15s max.
-                    backoff_sleep = min(backoff_sleep * 1.5, 0.15)
-                    time.sleep(backoff_sleep)
-                    continue
+            For example with non-strategy job, when I want to use the output
+        from previous stage, I can access it with syntax:
 
-                # NOTE: Reset backoff when we can proceed
-                consecutive_waits = 0
-                backoff_sleep = 0.01
+        ... ${job-id}.stages.${stage-id}.outputs.${key}
+        ... ${job-id}.stages.${stage-id}.errors.${key}
 
-                if check == FAILED:  # pragma: no cov
-                    return Result.from_trace(trace).catch(
-                        status=FAILED,
-                        context=catch(
-                            context,
-                            status=FAILED,
-                            updated={
-                                "status": FAILED,
-                                "errors": WorkflowError(
-                                    f"Validate job trigger rule was failed "
-                                    f"with {job.trigger_rule.value!r}."
-                                ).to_dict(),
-                            },
-                        ),
-                    )
-                elif check == SKIP:  # pragma: no cov
-                    trace.info(
-                        f"[JOB]: Skip job: {job_id!r} from trigger rule."
-                    )
-                    job.set_outputs(output={"status": SKIP}, to=context)
-                    job_queue.task_done()
-                    skip_count += 1
-                    continue
+            But example for strategy job:
 
-                if max_job_parallel > 1:
-                    futures.append(
-                        executor.submit(
-                            self.execute_job,
-                            job=job,
-                            run_id=run_id,
-                            context=context,
-                            parent_run_id=parent_run_id,
-                            event=event,
-                        ),
-                    )
-                    job_queue.task_done()
-                    continue
+        ... ${job-id}.strategies.${strategy-id}.stages.${stage-id}.outputs.${key}
+        ... ${job-id}.strategies.${strategy-id}.stages.${stage-id}.errors.${key}
 
-                if len(futures) < 1:
-                    futures.append(
-                        executor.submit(
-                            self.execute_job,
-                            job=job,
-                            run_id=run_id,
-                            context=context,
-                            parent_run_id=parent_run_id,
-                            event=event,
-                        )
-                    )
-                elif (future := futures.pop(0)).done():
-                    if e := future.exception():
-                        sequence_statuses.append(get_status_from_error(e))
-                    else:
-                        st, _ = future.result()
-                        sequence_statuses.append(st)
-                    job_queue.put(job_id)
-                elif future.cancelled():
-                    sequence_statuses.append(CANCEL)
-                    job_queue.put(job_id)
-                elif future.running() or "state=pending" in str(future):
-                    futures.insert(0, future)
-                    job_queue.put(job_id)
-                else:  # pragma: no cov
-                    job_queue.put(job_id)
-                    futures.insert(0, future)
-                    trace.warning(
-                        f"[WORKFLOW]: ... Execution non-threading not "
-                        f"handle: {future}."
-                    )
+            This method already handle all exception class that can raise from
+        the job execution. It will warp that error and keep it in the key `errors`
+        at the result context.
 
-                job_queue.task_done()
 
-            if not_timeout_flag:
-                job_queue.join()
-                for total, future in enumerate(as_completed(futures), start=0):
-                    try:
-                        statuses[total], _ = future.result()
-                    except WorkflowError as e:
-                        statuses[total] = get_status_from_error(e)
+            Execution   --> Ok      --> Result
+                                        |-status: CANCEL
+                                        ╰-context:
+                                            ╰-errors:
+                                                |-name: ...
+                                                ╰-message: ...
 
-                # NOTE: Update skipped status from the job trigger.
-                for i in range(skip_count):
-                    statuses[total + 1 + i] = SKIP
+                        --> Ok      --> Result
+                                        |-status: FAILED
+                                        ╰-context:
+                                            ╰-errors:
+                                                |-name: ...
+                                                ╰-message: ...
 
-                # NOTE: Update status from none-parallel job execution.
-                for i, s in enumerate(sequence_statuses, start=0):
-                    statuses[total + 1 + skip_count + i] = s
+                        --> Ok      --> Result
+                                        ╰-status: SKIP
 
-                st: Status = validate_statuses(statuses)
-                return Result.from_trace(trace).catch(
-                    status=st,
-                    context=catch(context, status=st),
-                )
+                        --> Ok      --> Result
+                                        ╰-status: SUCCESS
 
-            event.set()
-            for future in futures:
-                future.cancel()
+        Args:
+            params (DictData): A parameter data that will parameterize before
+                execution.
+            run_id (str, default None): A workflow running ID.
+            event (Event, default None): An Event manager instance that use to
+                cancel this execution if it forces stopped by parent execution.
+            timeout (float, default 3600): A workflow execution time out in
+                second unit that use for limit time of execution and waiting job
+                dependency. This value does not force stop the task that still
+                running more than this limit time. (Default: 60 * 60 seconds)
+            max_job_parallel (int, default 2) The maximum workers that use for
+                job execution in `ThreadPoolExecutor` object.
+            rerun_mode (bool, default False): A rerun mode flag that will use
+                `_rerun` method if it set be True.
 
+        Returns
+            Result: Return Result object that create from execution context with
+                return mode.
+        """
+        ts: float = time.monotonic()
+        parent_run_id, run_id = extract_id(
+            self.name, run_id=run_id, extras=self.extras
+        )
+        trace: Trace = get_trace(
+            run_id,
+            parent_run_id=parent_run_id,
+            extras=self.extras,
+            pre_process=True,
+        )
+        context: DictData = {
+            "jobs": {},
+            "status": WAIT,
+            "info": {"exec_start": get_dt_now()},
+        }
+        event: ThreadEvent = event or ThreadEvent()
+        max_job_parallel: int = dynamic(
+            "max_job_parallel", f=max_job_parallel, extras=self.extras
+        )
+        try:
+            if rerun_mode:
+                return self._rerun(
+                    params,
+                    trace,
+                    context,
+                    event=event,
+                    timeout=timeout,
+                    max_job_parallel=max_job_parallel,
+                )
+            return self._execute(
+                params,
+                trace,
+                context,
+                event=event,
+                timeout=timeout,
+                max_job_parallel=max_job_parallel,
+            )
+        except WorkflowError as e:
+            updated = {"errors": e.to_dict()}
+            if isinstance(e, WorkflowSkipError):
+                trace.error(f"⏭️ Skip: {e}", module="workflow")
+                updated = None
+            else:
+                trace.error(f"📢 Workflow Failed:||{e}", module="workflow")
+
+            st: Status = get_status_from_error(e)
+            return Result.from_trace(trace).catch(
+                status=st, context=catch(context, status=st, updated=updated)
+            )
+        except Exception as e:
             trace.error(
-                f"[WORKFLOW]: {self.name!r} was timeout because it use exec "
-                f"time more than {timeout} seconds."
+                f"💥 Error Failed:||🚨 {traceback.format_exc()}||",
+                module="workflow",
+            )
+            return Result.from_trace(trace).catch(
+                status=FAILED,
+                context=catch(
+                    context, status=FAILED, updated={"errors": to_dict(e)}
+                ),
+            )
+        finally:
+            context["info"].update(
+                {
+                    "exec_end": get_dt_now(),
+                    "exec_latency": round(time.monotonic() - ts, 6),
+                }
             )
 
-            time.sleep(0.0025)
+    def rerun(
+        self,
+        context: DictData,
+        *,
+        run_id: Optional[str] = None,
+        event: Optional[ThreadEvent] = None,
+        timeout: float = 3600,
+        max_job_parallel: int = 2,
+    ) -> Result:  # pragma: no cov
+        """Re-Execute workflow with passing the error context data.
 
-        return Result.from_trace(trace).catch(
-            status=FAILED,
-            context=catch(
-                context,
-                status=FAILED,
-                updated={
-                    "errors": WorkflowTimeoutError(
-                        f"{self.name!r} was timeout because it use exec time "
-                        f"more than {timeout} seconds."
-                    ).to_dict(),
-                },
-            ),
+        Warnings:
+            This rerun method allow to rerun job execution level only. That mean
+        it does not support rerun only stage.
+
+        Args:
+            context (DictData): A context result that get the failed status.
+            run_id (str, default None): A workflow running ID.
+            event (Event, default None): An Event manager instance that use to
+                cancel this execution if it forces stopped by parent execution.
+            timeout (float, default 3600): A workflow execution time out in
+                second unit that use for limit time of execution and waiting job
+                dependency. This value does not force stop the task that still
+                running more than this limit time. (Default: 60 * 60 seconds)
+            max_job_parallel (int, default 2) The maximum workers that use for
+                job execution in `ThreadPoolExecutor` object.
+
+        Returns
+            Result: Return Result object that create from execution context with
+                return mode.
+        """
+        return self.execute(
+            context,
+            run_id=run_id,
+            event=event,
+            timeout=timeout,
+            max_job_parallel=max_job_parallel,
+            rerun_mode=True,
         )