ddeutil-workflow 0.0.73__py3-none-any.whl → 0.0.75__py3-none-any.whl

ddeutil/workflow/job.py

@@ -3,17 +3,33 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-"""Job model that use for store Stage models and node parameter that use for
-running these stages. The job model handle the lineage of stages and location of
-execution that mean you can define `runs-on` field with the Self-Hosted mode
-for execute on target machine instead of the current local machine.
-
-    This module include Strategy model that use on the job `strategy` field for
-making matrix values before execution parallelism stage execution.
-
-    The Job model does not implement `handler_execute` same as Stage model
-because the job should raise only `JobError` class from the execution
-method.
+"""Job Execution Module.
+
+This module contains the Job model and related components for managing stage
+execution, execution strategies, and job orchestration within workflows.
+
+The Job model serves as a container for Stage models and handles the execution
+lifecycle, dependency management, and output coordination. It supports various
+execution environments through the runs-on configuration.
+
+Key Features:
+    - Stage execution orchestration
+    - Matrix strategy for parameterized execution
+    - Multi-environment support (local, self-hosted, Docker, Azure Batch)
+    - Dependency management via job needs
+    - Conditional execution support
+    - Parallel execution capabilities
+
+Classes:
+    Job: Main job execution container
+    Strategy: Matrix strategy for parameterized execution
+    Rule: Trigger rules for job execution
+    RunsOn: Execution environment enumeration
+    BaseRunsOn: Base class for execution environments
+
+Note:
+    Jobs raise JobError on execution failures, providing consistent error
+    handling across the workflow system.
 """
 from __future__ import annotations
 
@@ -49,11 +65,13 @@ from .result import (
     WAIT,
     Result,
     Status,
+    catch,
     get_status_from_error,
     validate_statuses,
 )
 from .reusables import has_template, param2template
 from .stages import Stage
+from .traces import Trace, get_trace
 from .utils import cross_product, filter_func, gen_id
 
 MatrixFilter = list[dict[str, Union[str, int]]]
@@ -123,27 +141,41 @@ def make(
 
 
 class Strategy(BaseModel):
-    """Strategy model that will combine a matrix together for running the
-    special job with combination of matrix data.
-
-        This model does not be the part of job only because you can use it to
-    any model object. The objective of this model is generating metrix result
-    that comming from combination logic with any matrix values for running it
-    with parallelism.
-
-        [1, 2, 3] x [a, b] --> [1a], [1b], [2a], [2b], [3a], [3b]
-
-    Data Validate:
-        >>> strategy = {
-        ...     'max-parallel': 1,
-        ...     'fail-fast': False,
-        ...     'matrix': {
-        ...         'first': [1, 2, 3],
-        ...         'second': ['foo', 'bar'],
-        ...     },
-        ...     'include': [{'first': 4, 'second': 'foo'}],
-        ...     'exclude': [{'first': 1, 'second': 'bar'}],
-        ... }
+    """Matrix strategy model for parameterized job execution.
+
+    The Strategy model generates combinations of matrix values to enable
+    parallel execution of jobs with different parameter sets. It supports
+    cross-product generation, inclusion of specific combinations, and
+    exclusion of unwanted combinations.
+
+    This model can be used independently or as part of job configuration
+    to create multiple execution contexts from a single job definition.
+
+    Matrix Combination Logic:
+        [1, 2, 3] × [a, b] → [1a], [1b], [2a], [2b], [3a], [3b]
+
+    Attributes:
+        fail_fast (bool): Cancel remaining executions on first failure
+        max_parallel (int): Maximum concurrent executions (1-9)
+        matrix (dict): Base matrix values for cross-product generation
+        include (list): Additional specific combinations to include
+        exclude (list): Specific combinations to exclude from results
+
+    Example:
+        ```python
+        strategy = Strategy(
+            max_parallel=2,
+            fail_fast=True,
+            matrix={
+                'python_version': ['3.9', '3.10', '3.11'],
+                'os': ['ubuntu', 'windows']
+            },
+            include=[{'python_version': '3.12', 'os': 'ubuntu'}],
+            exclude=[{'python_version': '3.9', 'os': 'windows'}]
+        )
+
+        combinations = strategy.make()  # Returns list of parameter dicts
+        ```
     """
 
     fail_fast: bool = Field(
@@ -182,7 +214,8 @@ class Strategy(BaseModel):
     def is_set(self) -> bool:
         """Return True if this strategy was set from yaml template.
 
-        :rtype: bool
+        Returns:
+            bool: True if matrix has been configured, False otherwise.
         """
         return len(self.matrix) > 0
 
@@ -190,7 +223,8 @@ class Strategy(BaseModel):
         """Return List of product of matrix values that already filter with
         exclude and add include.
 
-        :rtype: list[DictStr]
+        Returns:
+            list[DictStr]: List of parameter combinations from matrix strategy.
         """
         return make(self.matrix, self.include, self.exclude)
 
@@ -213,9 +247,17 @@ class RunsOn(str, Enum):
     LOCAL = "local"
     SELF_HOSTED = "self_hosted"
     AZ_BATCH = "azure_batch"
+    AWS_BATCH = "aws_batch"
+    CLOUD_BATCH = "cloud_batch"
     DOCKER = "docker"
 
 
+LOCAL = RunsOn.LOCAL
+SELF_HOSTED = RunsOn.SELF_HOSTED
+AZ_BATCH = RunsOn.AZ_BATCH
+DOCKER = RunsOn.DOCKER
+
+
 class BaseRunsOn(BaseModel):  # pragma: no cov
     """Base Runs-On Model for generate runs-on types via inherit this model
     object and override execute method.
@@ -297,7 +339,7 @@ class OnDocker(BaseRunsOn):  # pragma: no cov
 
 def get_discriminator_runs_on(model: dict[str, Any]) -> RunsOn:
     """Get discriminator of the RunsOn models."""
-    t = model.get("type")
+    t: str = model.get("type")
     return RunsOn(t) if t else RunsOn.LOCAL
 
 
@@ -312,30 +354,48 @@ RunsOnModel = Annotated[
 
 
 class Job(BaseModel):
-    """Job Pydantic model object (short descripte: a group of stages).
-
-        This job model allow you to use for-loop that call matrix strategy. If
-    you pass matrix mapping, and it is able to generate, you will see it running
-    with loop of matrix values.
-
-    Data Validate:
-        >>> job = {
-        ...     "runs-on": {"type": "local"},
-        ...     "strategy": {
-        ...         "max-parallel": 1,
-        ...         "matrix": {
-        ...             "first": [1, 2, 3],
-        ...             "second": ['foo', 'bar'],
-        ...         },
-        ...     },
-        ...     "needs": [],
-        ...     "stages": [
-        ...         {
-        ...             "name": "Some stage",
-        ...             "run": "print('Hello World')",
-        ...         },
-        ...     ],
-        ... }
+    """Job execution container for stage orchestration.
+
+    The Job model represents a logical unit of work containing multiple stages
+    that execute sequentially. Jobs support matrix strategies for parameterized
+    execution, dependency management, conditional execution, and multienvironment
+    deployment.
+
+    Jobs are the primary execution units within workflows, providing:
+    - Stage lifecycle management
+    - Execution environment abstraction
+    - Matrix strategy support for parallel execution
+    - Dependency resolution via job needs
+    - Output coordination between stages
+
+    Attributes:
+        id (str, optional): Unique job identifier within workflow
+        desc (str, optional): Job description in Markdown format
+        runs_on (RunsOnModel): Execution environment configuration
+        condition (str, optional): Conditional execution expression
+        stages (list[Stage]): Ordered list of stages to execute
+        trigger_rule (Rule): Rule for handling job dependencies
+        needs (list[str]): List of prerequisite job IDs
+        strategy (Strategy): Matrix strategy for parameterized execution
+        extras (dict): Additional configuration parameters
+
+    Example:
+        ```python
+        job = Job(
+            id="data-processing",
+            desc="Process daily data files",
+            runs_on=OnLocal(),
+            stages=[
+                EmptyStage(name="Start", echo="Processing started"),
+                PyStage(name="Process", run="process_data()"),
+                EmptyStage(name="Complete", echo="Processing finished")
+            ],
+            strategy=Strategy(
+                matrix={'env': ['dev', 'prod']},
+                max_parallel=2
+            )
+        )
+        ```
     """
 
     id: StrOrNone = Field(
@@ -694,7 +754,6 @@ class Job(BaseModel):
         params: DictData,
         *,
         run_id: StrOrNone = None,
-        parent_run_id: StrOrNone = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Job execution with passing dynamic parameters from the workflow
@@ -704,58 +763,65 @@ class Job(BaseModel):
             This method be execution routing for call dynamic execution function
         with specific target `runs-on` value.
 
-        :param params: (DictData) A parameter data.
-        :param run_id: (str) A job running ID.
-        :param parent_run_id: (str) A parent running ID.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
+        Args
+            params: (DictData) A parameter context that also pass from the
+                workflow execute method.
+            run_id: (str) An execution running ID.
+            event: (Event) An Event manager instance that use to cancel this
+                execution if it forces stopped by parent execution.
 
-        :rtype: Result
+        Returns
+            Result: Return Result object that create from execution context.
         """
-        result: Result = Result.construct_with_rs_or_id(
-            run_id=run_id,
-            parent_run_id=parent_run_id,
-            id_logic=(self.id or "EMPTY"),
-            extras=self.extras,
+        ts: float = time.monotonic()
+        parent_run_id: str = run_id
+        run_id: str = gen_id((self.id or "EMPTY"), unique=True)
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
-
-        result.trace.info(
+        trace.info(
             f"[JOB]: Routing for "
             f"{''.join(self.runs_on.type.value.split('_')).title()}: "
             f"{self.id!r}"
         )
 
-        if self.runs_on.type == RunsOn.LOCAL:
+        if self.runs_on.type == LOCAL:
             return local_execute(
                 self,
                 params,
-                run_id=run_id,
-                parent_run_id=parent_run_id,
+                run_id=parent_run_id,
                 event=event,
-            )
-        elif self.runs_on.type == RunsOn.SELF_HOSTED:  # pragma: no cov
+            ).make_info({"execution_time": time.monotonic() - ts})
+        elif self.runs_on.type == SELF_HOSTED:  # pragma: no cov
+            pass
+        elif self.runs_on.type == AZ_BATCH:  # pragma: no cov
             pass
-        elif self.runs_on.type == RunsOn.DOCKER:  # pragma: no cov
-            docker_execution(
+        elif self.runs_on.type == DOCKER:  # pragma: no cov
+            return docker_execution(
                 self,
                 params,
                 run_id=run_id,
                 parent_run_id=parent_run_id,
                 event=event,
-            )
+            ).make_info({"execution_time": time.monotonic() - ts})
 
-        result.trace.error(
+        trace.error(
             f"[JOB]: Execution not support runs-on: {self.runs_on.type.value!r} "
             f"yet."
         )
-        return result.catch(
+        return Result(
             status=FAILED,
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             context={
+                "status": FAILED,
                 "errors": JobError(
                     f"Execute runs-on type: {self.runs_on.type.value!r} does "
                     f"not support yet."
                 ).to_dict(),
             },
+            info={"execution_time": time.monotonic() - ts},
+            extras=self.extras,
         )
 
 
@@ -772,14 +838,20 @@ def mark_errors(context: DictData, error: JobError) -> None:
         context["errors"] = error.to_dict(with_refs=True)
 
 
+def pop_stages(context: DictData) -> DictData:
+    return filter_func(context.pop("stages", {}))
+
+
 def local_execute_strategy(
     job: Job,
     strategy: DictData,
     params: DictData,
+    run_id: str,
+    context: DictData,
     *,
-    result: Optional[Result] = None,
+    parent_run_id: Optional[str] = None,
     event: Optional[Event] = None,
-) -> tuple[Status, Result]:
+) -> tuple[Status, DictData]:
     """Local strategy execution with passing dynamic parameters from the
     job execution and strategy matrix.
 
@@ -796,7 +868,9 @@ def local_execute_strategy(
     :param strategy: (DictData) A strategy metrix value. This value will pass
         to the `matrix` key for templating in context data.
     :param params: (DictData) A parameter data.
-    :param result: (Result) A Result instance for return context and status.
+    :param run_id: (str)
+        :param context: (DictData)
+        :param parent_run_id: (str | None)
     :param event: (Event) An Event manager instance that use to cancel this
         execution if it forces stopped by parent execution.
 
@@ -804,21 +878,20 @@ def local_execute_strategy(
     :raise JobError: If stage execution raise any error as `StageError`.
     :raise JobError: If the result from execution has `FAILED` status.
 
-    :rtype: tuple[Status, Result]
+    :rtype: tuple[Status, DictData]
     """
-    result: Result = result or Result(
-        run_id=gen_id(job.id or "EMPTY", unique=True),
-        extras=job.extras,
+    trace: Trace = get_trace(
+        run_id, parent_run_id=parent_run_id, extras=job.extras
     )
     if strategy:
         strategy_id: str = gen_id(strategy)
-        result.trace.info(f"[JOB]: Execute Strategy: {strategy_id!r}")
-        result.trace.info(f"[JOB]: ... matrix: {strategy!r}")
+        trace.info(f"[JOB]: Execute Strategy: {strategy_id!r}")
+        trace.info(f"[JOB]: ... matrix: {strategy!r}")
     else:
         strategy_id: str = "EMPTY"
 
-    context: DictData = copy.deepcopy(params)
-    context.update({"matrix": strategy, "stages": {}})
+    current_context: DictData = copy.deepcopy(params)
+    current_context.update({"matrix": strategy, "stages": {}})
     total_stage: int = len(job.stages)
     skips: list[bool] = [False] * total_stage
     for i, stage in enumerate(job.stages, start=0):
@@ -831,27 +904,27 @@ def local_execute_strategy(
                 "Strategy execution was canceled from the event before "
                 "start stage execution."
             )
-            result.catch(
+            catch(
+                context=context,
                 status=CANCEL,
-                context={
+                updated={
                     strategy_id: {
                         "status": CANCEL,
                         "matrix": strategy,
-                        "stages": filter_func(context.pop("stages", {})),
+                        "stages": pop_stages(current_context),
                         "errors": JobCancelError(error_msg).to_dict(),
                     },
                 },
             )
             raise JobCancelError(error_msg, refs=strategy_id)
 
-        result.trace.info(f"[JOB]: Execute Stage: {stage.iden!r}")
-        rs: Result = stage.handler_execute(
-            params=context,
-            run_id=result.run_id,
-            parent_run_id=result.parent_run_id,
+        trace.info(f"[JOB]: Execute Stage: {stage.iden!r}")
+        rs: Result = stage.execute(
+            params=current_context,
+            run_id=parent_run_id,
             event=event,
         )
-        stage.set_outputs(rs.context, to=context)
+        stage.set_outputs(rs.context, to=current_context)
 
         if rs.status == SKIP:
             skips[i] = True
@@ -862,13 +935,14 @@ def local_execute_strategy(
                 f"Strategy execution was break because its nested-stage, "
                 f"{stage.iden!r}, failed."
             )
-            result.catch(
+            catch(
+                context=context,
                 status=FAILED,
-                context={
+                updated={
                     strategy_id: {
                         "status": FAILED,
                         "matrix": strategy,
-                        "stages": filter_func(context.pop("stages", {})),
+                        "stages": pop_stages(current_context),
                         "errors": JobError(error_msg).to_dict(),
                     },
                 },
@@ -880,13 +954,14 @@ def local_execute_strategy(
                 "Strategy execution was canceled from the event after "
                 "end stage execution."
             )
-            result.catch(
+            catch(
+                context=context,
                 status=CANCEL,
-                context={
+                updated={
                     strategy_id: {
                         "status": CANCEL,
                         "matrix": strategy,
-                        "stages": filter_func(context.pop("stages", {})),
+                        "stages": pop_stages(current_context),
                         "errors": JobCancelError(error_msg).to_dict(),
                     },
                 },
@@ -894,17 +969,18 @@ def local_execute_strategy(
             raise JobCancelError(error_msg, refs=strategy_id)
 
     status: Status = SKIP if sum(skips) == total_stage else SUCCESS
-    result.catch(
+    catch(
+        context=context,
         status=status,
-        context={
+        updated={
             strategy_id: {
                 "status": status,
                 "matrix": strategy,
-                "stages": filter_func(context.pop("stages", {})),
+                "stages": pop_stages(current_context),
             },
         },
     )
-    return status, result
+    return status, context
 
 
 def local_execute(
@@ -912,7 +988,6 @@ def local_execute(
     params: DictData,
     *,
     run_id: StrOrNone = None,
-    parent_run_id: StrOrNone = None,
     event: Optional[Event] = None,
 ) -> Result:
     """Local job execution with passing dynamic parameters from the workflow
@@ -933,47 +1008,61 @@ def local_execute(
     :param job: (Job) A job model.
     :param params: (DictData) A parameter data.
     :param run_id: (str) A job running ID.
-    :param parent_run_id: (str) A parent workflow running ID.
     :param event: (Event) An Event manager instance that use to cancel this
         execution if it forces stopped by parent execution.
 
     :rtype: Result
     """
-    result: Result = Result.construct_with_rs_or_id(
-        run_id=run_id,
-        parent_run_id=parent_run_id,
-        id_logic=(job.id or "EMPTY"),
-        extras=job.extras,
+    ts: float = time.monotonic()
+    parent_run_id: StrOrNone = run_id
+    run_id: str = gen_id((job.id or "EMPTY"), unique=True)
+    trace: Trace = get_trace(
+        run_id, parent_run_id=parent_run_id, extras=job.extras
     )
-
-    result.trace.info("[JOB]: Start Local executor.")
+    context: DictData = {"status": WAIT}
+    trace.info("[JOB]: Start Local executor.")
 
     if job.desc:
-        result.trace.debug(f"[JOB]: Description:||{job.desc}||")
+        trace.debug(f"[JOB]: Description:||{job.desc}||")
 
     if job.is_skipped(params=params):
-        result.trace.info("[JOB]: Skip because job condition was valid.")
-        return result.catch(status=SKIP)
+        trace.info("[JOB]: Skip because job condition was valid.")
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=SKIP,
+            context=catch(context, status=SKIP),
+            info={"execution_time": time.monotonic() - ts},
+            extras=job.extras,
+        )
 
     event: Event = event or Event()
     ls: str = "Fail-Fast" if job.strategy.fail_fast else "All-Completed"
     workers: int = job.strategy.max_parallel
     strategies: list[DictStr] = job.strategy.make()
     len_strategy: int = len(strategies)
-    result.trace.info(
+    trace.info(
         f"[JOB]: ... Mode {ls}: {job.id!r} with {workers} "
         f"worker{'s' if workers > 1 else ''}."
     )
 
     if event and event.is_set():
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=CANCEL,
-            context={
-                "errors": JobCancelError(
-                    "Execution was canceled from the event before start "
-                    "local job execution."
-                ).to_dict()
-            },
+            context=catch(
+                context,
+                status=CANCEL,
+                updated={
+                    "errors": JobCancelError(
+                        "Execution was canceled from the event before start "
+                        "local job execution."
+                    ).to_dict()
+                },
+            ),
+            info={"execution_time": time.monotonic() - ts},
+            extras=job.extras,
         )
 
     with ThreadPoolExecutor(workers, "jb_stg") as executor:
@@ -983,13 +1072,15 @@ def local_execute(
                 job=job,
                 strategy=strategy,
                 params=params,
-                result=result,
+                run_id=run_id,
+                context=context,
+                parent_run_id=parent_run_id,
                 event=event,
             )
             for strategy in strategies
         ]
 
-        context: DictData = {}
+        errors: DictData = {}
         statuses: list[Status] = [WAIT] * len_strategy
         fail_fast: bool = False
 
@@ -998,14 +1089,14 @@ def local_execute(
         else:
             done, not_done = wait(futures, return_when=FIRST_EXCEPTION)
             if len(list(done)) != len(futures):
-                result.trace.warning(
+                trace.warning(
                     "[JOB]: Set the event for stop pending job-execution."
                 )
                 event.set()
                 for future in not_done:
                     future.cancel()
 
-                time.sleep(0.025)
+                time.sleep(0.01)
                 nd: str = (
                     (
                         f", {len(not_done)} strateg"
@@ -1014,7 +1105,7 @@ def local_execute(
                     if not_done
                     else ""
                 )
-                result.trace.debug(f"[JOB]: ... Job was set Fail-Fast{nd}")
+                trace.debug(f"[JOB]: ... Job was set Fail-Fast{nd}")
                 done: Iterator[Future] = as_completed(futures)
                 fail_fast: bool = True
 
@@ -1023,10 +1114,10 @@ def local_execute(
                 statuses[i], _ = future.result()
             except JobError as e:
                 statuses[i] = get_status_from_error(e)
-                result.trace.error(
+                trace.error(
                     f"[JOB]: {ls} Handler:||{e.__class__.__name__}: {e}"
                 )
-                mark_errors(context, e)
+                mark_errors(errors, e)
             except CancelledError:
                 pass
 
@@ -1037,7 +1128,14 @@ def local_execute(
     if fail_fast and status == CANCEL:
         status = FAILED
 
-    return result.catch(status=status, context=context)
+    return Result(
+        run_id=run_id,
+        parent_run_id=parent_run_id,
+        status=status,
+        context=catch(context, status=status, updated=errors),
+        info={"execution_time": time.monotonic() - ts},
+        extras=job.extras,
+    )
 
 
 def self_hosted_execute(
@@ -1045,7 +1143,6 @@ def self_hosted_execute(
     params: DictData,
     *,
     run_id: StrOrNone = None,
-    parent_run_id: StrOrNone = None,
     event: Optional[Event] = None,
 ) -> Result:  # pragma: no cov
     """Self-Hosted job execution with passing dynamic parameters from the
@@ -1055,30 +1152,35 @@ def self_hosted_execute(
     :param job: (Job) A job model that want to execute.
     :param params: (DictData) A parameter data.
     :param run_id: (str) A job running ID.
-    :param parent_run_id: (str) A parent workflow running ID.
     :param event: (Event) An Event manager instance that use to cancel this
         execution if it forces stopped by parent execution.
 
     :rtype: Result
     """
-    result: Result = Result.construct_with_rs_or_id(
-        run_id=run_id,
-        parent_run_id=parent_run_id,
-        id_logic=(job.id or "EMPTY"),
-        extras=job.extras,
+    parent_run_id: StrOrNone = run_id
+    run_id: str = gen_id((job.id or "EMPTY"), unique=True)
+    trace: Trace = get_trace(
+        run_id, parent_run_id=parent_run_id, extras=job.extras
     )
-
-    result.trace.info("[JOB]: Start self-hosted executor.")
+    context: DictData = {"status": WAIT}
+    trace.info("[JOB]: Start self-hosted executor.")
 
     if event and event.is_set():
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=CANCEL,
-            context={
-                "errors": JobCancelError(
-                    "Execution was canceled from the event before start "
-                    "self-hosted execution."
-                ).to_dict()
-            },
+            context=catch(
+                context,
+                status=CANCEL,
+                updated={
+                    "errors": JobCancelError(
+                        "Execution was canceled from the event before start "
+                        "self-hosted execution."
+                    ).to_dict()
+                },
+            ),
+            extras=job.extras,
         )
 
     import requests
@@ -1090,11 +1192,20 @@ def self_hosted_execute(
             data={
                 "job": job.model_dump(),
                 "params": params,
-                "result": result.__dict__,
+                "run_id": parent_run_id,
+                "extras": job.extras,
             },
         )
     except requests.exceptions.RequestException as e:
-        return result.catch(status=FAILED, context={"errors": to_dict(e)})
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=FAILED,
+            context=catch(
+                context, status=FAILED, updated={"errors": to_dict(e)}
+            ),
+            extras=job.extras,
+        )
 
     if resp.status_code != 200:
         raise JobError(
@@ -1102,7 +1213,13 @@ def self_hosted_execute(
             f"{job.runs_on.args.host!r}"
         )
 
-    return result.catch(status=SUCCESS)
+    return Result(
+        run_id=run_id,
+        parent_run_id=parent_run_id,
+        status=SUCCESS,
+        context=catch(context, status=SUCCESS),
+        extras=job.extras,
+    )
 
 
 def azure_batch_execute(
@@ -1110,7 +1227,6 @@ def azure_batch_execute(
     params: DictData,
     *,
     run_id: StrOrNone = None,
-    parent_run_id: StrOrNone = None,
     event: Optional[Event] = None,
 ) -> Result:  # pragma: no cov
     """Azure Batch job execution that will run all job's stages on the Azure
@@ -1134,32 +1250,43 @@ def azure_batch_execute(
     :param job:
     :param params:
     :param run_id:
-    :param parent_run_id:
     :param event:
 
     :rtype: Result
     """
-    result: Result = Result.construct_with_rs_or_id(
-        run_id=run_id,
-        parent_run_id=parent_run_id,
-        id_logic=(job.id or "EMPTY"),
-        extras=job.extras,
+    parent_run_id: StrOrNone = run_id
+    run_id: str = gen_id((job.id or "EMPTY"), unique=True)
+    trace: Trace = get_trace(
+        run_id, parent_run_id=parent_run_id, extras=job.extras
     )
-
-    result.trace.info("[JOB]: Start Azure Batch executor.")
+    context: DictData = {"status": WAIT}
+    trace.info("[JOB]: Start Azure Batch executor.")
 
     if event and event.is_set():
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=CANCEL,
-            context={
-                "errors": JobCancelError(
-                    "Execution was canceled from the event before start "
-                    "azure-batch execution."
-                ).to_dict()
-            },
+            context=catch(
+                context,
+                status=CANCEL,
+                updated={
+                    "errors": JobCancelError(
+                        "Execution was canceled from the event before start "
+                        "self-hosted execution."
+                    ).to_dict()
+                },
+            ),
+            extras=job.extras,
         )
     print(params)
-    return result.catch(status=SUCCESS)
+    return Result(
+        run_id=run_id,
+        parent_run_id=parent_run_id,
+        status=SUCCESS,
+        context=catch(context, status=SUCCESS),
+        extras=job.extras,
+    )
 
 
 def docker_execution(
@@ -1177,24 +1304,36 @@ def docker_execution(
         - Install this workflow package
         - Start push job to run to target Docker container.
     """
-    result: Result = Result.construct_with_rs_or_id(
-        run_id=run_id,
-        parent_run_id=parent_run_id,
-        id_logic=(job.id or "EMPTY"),
-        extras=job.extras,
+    parent_run_id: StrOrNone = run_id
+    run_id: str = gen_id((job.id or "EMPTY"), unique=True)
+    trace: Trace = get_trace(
+        run_id, parent_run_id=parent_run_id, extras=job.extras
     )
-
-    result.trace.info("[JOB]: Start Docker executor.")
+    context: DictData = {"status": WAIT}
+    trace.info("[JOB]: Start Docker executor.")
 
     if event and event.is_set():
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=CANCEL,
-            context={
-                "errors": JobCancelError(
-                    "Execution was canceled from the event before start "
-                    "start docker execution."
-                ).to_dict()
-            },
+            context=catch(
+                context,
+                status=CANCEL,
+                updated={
+                    "errors": JobCancelError(
+                        "Execution was canceled from the event before start "
+                        "self-hosted execution."
+                    ).to_dict()
+                },
+            ),
+            extras=job.extras,
         )
     print(params)
-    return result.catch(status=SUCCESS)
+    return Result(
+        run_id=run_id,
+        parent_run_id=parent_run_id,
+        status=SUCCESS,
+        context=catch(context, status=SUCCESS),
+        extras=job.extras,
+    )