ddeutil-workflow 0.0.49__py3-none-any.whl → 0.0.51__py3-none-any.whl

ddeutil/workflow/job.py

@@ -3,7 +3,6 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-# [x] Use dynamic config
 """Job Model that use for keeping stages and node that running its stages.
 The job handle the lineage of stages and location of execution of stages that
 mean the job model able to define `runs-on` key that allow you to run this
@@ -28,19 +27,18 @@ from threading import Event
 from typing import Annotated, Any, Literal, Optional, Union
 
 from ddeutil.core import freeze_args
-from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag
+from pydantic import BaseModel, ConfigDict, Discriminator, Field, SecretStr, Tag
 from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
-from .__types import DictData, DictStr, Matrix, TupleStr
-from .conf import dynamic
+from .__types import DictData, DictStr, Matrix
 from .exceptions import (
     JobException,
     StageException,
     UtilException,
     to_dict,
 )
-from .result import FAILED, SKIP, SUCCESS, WAIT, Result, Status
+from .result import CANCEL, FAILED, SKIP, SUCCESS, WAIT, Result, Status
 from .reusables import has_template, param2template
 from .stages import Stage
 from .utils import cross_product, filter_func, gen_id
@@ -48,20 +46,6 @@ from .utils import cross_product, filter_func, gen_id
 MatrixFilter = list[dict[str, Union[str, int]]]
 
 
-__all__: TupleStr = (
-    "Strategy",
-    "Job",
-    "TriggerRules",
-    "RunsOn",
-    "RunsOnLocal",
-    "RunsOnSelfHosted",
-    "RunsOnK8s",
-    "make",
-    "local_execute_strategy",
-    "local_execute",
-)
-
-
 @freeze_args
 @lru_cache
 def make(
@@ -121,7 +105,6 @@ def make(
 
         add.append(inc)
 
-    # NOTE: Merge all matrix together.
     final.extend(add)
     return final
 
@@ -194,24 +177,25 @@ class Strategy(BaseModel):
         return make(self.matrix, self.include, self.exclude)
 
 
-class TriggerRules(str, Enum):
+class Rule(str, Enum):
     """Trigger rules enum object."""
 
-    all_success: str = "all_success"
-    all_failed: str = "all_failed"
-    all_done: str = "all_done"
-    one_failed: str = "one_failed"
-    one_success: str = "one_success"
-    none_failed: str = "none_failed"
-    none_skipped: str = "none_skipped"
+    ALL_SUCCESS: str = "all_success"
+    ALL_FAILED: str = "all_failed"
+    ALL_DONE: str = "all_done"
+    ONE_FAILED: str = "one_failed"
+    ONE_SUCCESS: str = "one_success"
+    NONE_FAILED: str = "none_failed"
+    NONE_SKIPPED: str = "none_skipped"
 
 
-class RunsOnType(str, Enum):
+class RunsOn(str, Enum):
     """Runs-On enum object."""
 
     LOCAL: str = "local"
     SELF_HOSTED: str = "self_hosted"
-    K8S: str = "k8s"
+    AZ_BATCH: str = "azure_batch"
+    DOCKER: str = "docker"
 
 
 class BaseRunsOn(BaseModel):  # pragma: no cov
@@ -221,47 +205,79 @@ class BaseRunsOn(BaseModel):  # pragma: no cov
 
     model_config = ConfigDict(use_enum_values=True)
 
-    type: Literal[RunsOnType.LOCAL]
+    type: RunsOn = Field(description="A runs-on type.")
     args: DictData = Field(
         default_factory=dict,
         alias="with",
+        description=(
+            "An argument that pass to the runs-on execution function. This "
+            "args will override by this child-model with specific args model."
+        ),
     )
 
 
-class RunsOnLocal(BaseRunsOn):  # pragma: no cov
+class OnLocal(BaseRunsOn):  # pragma: no cov
     """Runs-on local."""
 
-    type: Literal[RunsOnType.LOCAL] = Field(default=RunsOnType.LOCAL)
+    type: Literal[RunsOn.LOCAL] = Field(default=RunsOn.LOCAL)
 
 
 class SelfHostedArgs(BaseModel):
-    host: str
+    """Self-Hosted arguments."""
+
+    host: str = Field(description="A host URL of the target self-hosted.")
 
 
-class RunsOnSelfHosted(BaseRunsOn):  # pragma: no cov
+class OnSelfHosted(BaseRunsOn):  # pragma: no cov
     """Runs-on self-hosted."""
 
-    type: Literal[RunsOnType.SELF_HOSTED] = Field(
-        default=RunsOnType.SELF_HOSTED
-    )
+    type: Literal[RunsOn.SELF_HOSTED] = Field(default=RunsOn.SELF_HOSTED)
     args: SelfHostedArgs = Field(alias="with")
 
 
-class RunsOnK8s(BaseRunsOn):  # pragma: no cov
-    """Runs-on Kubernetes."""
+class AzBatchArgs(BaseModel):
+    batch_account_name: str
+    batch_account_key: SecretStr
+    batch_account_url: str
+    storage_account_name: str
+    storage_account_key: SecretStr
+
+
+class OnAzBatch(BaseRunsOn):  # pragma: no cov
+
+    type: Literal[RunsOn.AZ_BATCH] = Field(default=RunsOn.AZ_BATCH)
+    args: AzBatchArgs = Field(alias="with")
+
+
+class DockerArgs(BaseModel):
+    image: str = Field(
+        default="ubuntu-latest",
+        description=(
+            "An image that want to run like `ubuntu-22.04`, `windows-latest`, "
+            ", `ubuntu-24.04-arm`, or `macos-14`"
+        ),
+    )
+    env: DictData = Field(default_factory=dict)
+    volume: DictData = Field(default_factory=dict)
+
 
-    type: Literal[RunsOnType.K8S] = Field(default=RunsOnType.K8S)
+class OnDocker(BaseRunsOn):  # pragma: no cov
+    """Runs-on Docker container."""
+
+    type: Literal[RunsOn.DOCKER] = Field(default=RunsOn.DOCKER)
+    args: DockerArgs = Field(alias="with", default_factory=DockerArgs)
 
 
 def get_discriminator_runs_on(model: dict[str, Any]) -> str:
+    """Get discriminator of the RunsOn models."""
     return model.get("type", "local")
 
 
-RunsOn = Annotated[
+RunsOnModel = Annotated[
     Union[
-        Annotated[RunsOnK8s, Tag(RunsOnType.K8S)],
-        Annotated[RunsOnSelfHosted, Tag(RunsOnType.SELF_HOSTED)],
-        Annotated[RunsOnLocal, Tag(RunsOnType.LOCAL)],
+        Annotated[OnSelfHosted, Tag(RunsOn.SELF_HOSTED)],
+        Annotated[OnDocker, Tag(RunsOn.DOCKER)],
+        Annotated[OnLocal, Tag(RunsOn.LOCAL)],
     ],
     Discriminator(get_discriminator_runs_on),
 ]
@@ -290,7 +306,6 @@ class Job(BaseModel):
         ...             "name": "Some stage",
         ...             "run": "print('Hello World')",
         ...         },
-        ...         ...
         ...     ],
         ... }
     """
@@ -305,8 +320,8 @@ class Job(BaseModel):
         default=None,
         description="A job description that can be string of markdown content.",
     )
-    runs_on: RunsOn = Field(
-        default_factory=RunsOnLocal,
+    runs_on: RunsOnModel = Field(
+        default_factory=OnLocal,
         description="A target node for this job to use for execution.",
         alias="runs-on",
     )
@@ -319,8 +334,8 @@ class Job(BaseModel):
         default_factory=list,
         description="A list of Stage of this job.",
     )
-    trigger_rule: TriggerRules = Field(
-        default=TriggerRules.all_success,
+    trigger_rule: Rule = Field(
+        default=Rule.ALL_SUCCESS,
         description=(
             "A trigger rule of tracking needed jobs if feature will use when "
             "the `raise_error` did not set from job and stage executions."
@@ -329,7 +344,7 @@ class Job(BaseModel):
     )
     needs: list[str] = Field(
         default_factory=list,
-        description="A list of the job ID that want to run before this job.",
+        description="A list of the job that want to run before this job model.",
     )
     strategy: Strategy = Field(
         default_factory=Strategy,
@@ -361,7 +376,7 @@ class Job(BaseModel):
             name: str = stage.iden
             if name in rs:
                 raise ValueError(
-                    "Stage name in jobs object should not be duplicate."
+                    f"Stage name, {name!r}, should not be duplicate."
                 )
             rs.append(name)
         return value
@@ -374,7 +389,9 @@ class Job(BaseModel):
         """
         # VALIDATE: Validate job id should not dynamic with params template.
         if has_template(self.id):
-            raise ValueError("Job ID should not has any template.")
+            raise ValueError(
+                f"Job ID, {self.id!r}, should not has any template."
+            )
 
         return self
 
@@ -392,7 +409,7 @@ class Job(BaseModel):
                 if self.extras:
                     stage.extras = self.extras
                 return stage
-        raise ValueError(f"Stage ID {stage_id} does not exists")
+        raise ValueError(f"Stage {stage_id!r} does not exists in this job.")
 
     def check_needs(
         self,
@@ -421,27 +438,27 @@ class Job(BaseModel):
             return WAIT
         elif all("skipped" in need_exist[job] for job in need_exist):
             return SKIP
-        elif self.trigger_rule == TriggerRules.all_done:
+        elif self.trigger_rule == Rule.ALL_DONE:
             return SUCCESS
-        elif self.trigger_rule == TriggerRules.all_success:
+        elif self.trigger_rule == Rule.ALL_SUCCESS:
             rs = all(
                 k not in need_exist[job]
                 for k in ("errors", "skipped")
                 for job in need_exist
             )
-        elif self.trigger_rule == TriggerRules.all_failed:
+        elif self.trigger_rule == Rule.ALL_FAILED:
             rs = all("errors" in need_exist[job] for job in need_exist)
-        elif self.trigger_rule == TriggerRules.one_success:
+        elif self.trigger_rule == Rule.ONE_SUCCESS:
             rs = sum(
                 k not in need_exist[job]
                 for k in ("errors", "skipped")
                 for job in need_exist
             ) + 1 == len(self.needs)
-        elif self.trigger_rule == TriggerRules.one_failed:
+        elif self.trigger_rule == Rule.ONE_FAILED:
             rs = sum("errors" in need_exist[job] for job in need_exist) == 1
-        elif self.trigger_rule == TriggerRules.none_skipped:
+        elif self.trigger_rule == Rule.NONE_SKIPPED:
             rs = all("skipped" not in need_exist[job] for job in need_exist)
-        elif self.trigger_rule == TriggerRules.none_failed:
+        elif self.trigger_rule == Rule.NONE_FAILED:
             rs = all("errors" not in need_exist[job] for job in need_exist)
         else:  # pragma: no cov
             raise NotImplementedError(
@@ -480,8 +497,8 @@ class Job(BaseModel):
             if not isinstance(rs, bool):
                 raise TypeError("Return type of condition does not be boolean")
             return not rs
-        except Exception as err:
-            raise JobException(f"{err.__class__.__name__}: {err}") from err
+        except Exception as e:
+            raise JobException(f"{e.__class__.__name__}: {e}") from e
 
     def set_outputs(
         self,
@@ -499,14 +516,14 @@ class Job(BaseModel):
             ... (i)   output: {'strategy-01': bar, 'strategy-02': bar}
             ... (ii)  to: {'jobs': {}}
 
-        The result of the `to` variable will be;
+        The result of the `to` argument will be;
 
             ... (iii) to: {
                         'jobs': {
                             '<job-id>': {
                                 'strategies': {
                                     'strategy-01': bar,
-                                    'strategy-02': bar
+                                    'strategy-02': bar,
                                 }
                             }
                         }
@@ -529,22 +546,27 @@ class Job(BaseModel):
                 "This job do not set the ID before setting execution output."
             )
 
-        # NOTE: If the job ID did not set, it will use index of jobs key
-        #   instead.
         _id: str = self.id or job_id
-
         errors: DictData = (
             {"errors": output.pop("errors", {})} if "errors" in output else {}
         )
+        skipping: dict[str, bool] = (
+            {"skipped": output.pop("skipped", False)}
+            if "skipped" in output
+            else {}
+        )
 
-        if "SKIP" in output:  # pragma: no cov
-            to["jobs"][_id] = output["SKIP"]
-        elif self.strategy.is_set():
-            to["jobs"][_id] = {"strategies": output, **errors}
+        if self.strategy.is_set():
+            to["jobs"][_id] = {"strategies": output, **skipping, **errors}
+        elif len(k := output.keys()) > 1:  # pragma: no cov
+            raise JobException(
+                "Strategy output from execution return more than one ID while "
+                "this job does not set strategy."
+            )
         else:
-            _output = output.get(next(iter(output), "FIRST"), {})
+            _output: DictData = {} if len(k) == 0 else output[list(k)[0]]
             _output.pop("matrix", {})
-            to["jobs"][_id] = {**_output, **errors}
+            to["jobs"][_id] = {**_output, **skipping, **errors}
         return to
 
     def execute(
@@ -555,11 +577,15 @@ class Job(BaseModel):
         parent_run_id: str | None = None,
         result: Result | None = None,
         event: Event | None = None,
+        raise_error: bool = True,
     ) -> Result:
         """Job execution with passing dynamic parameters from the workflow
         execution. It will generate matrix values at the first step and run
         multithread on this metrics to the `stages` field of this job.
 
+            This method be execution routing for call dynamic execution function
+        with specific target `runs-on` value.
+
         :param params: An input parameters that use on job execution.
         :param run_id: (str) A job running ID.
         :param parent_run_id: (str) A parent workflow running ID.
@@ -567,6 +593,10 @@ class Job(BaseModel):
             data.
         :param event: (Event) An event manager that pass to the
             PoolThreadExecutor.
+        :param raise_error: (bool) A flag that all this method raise error to
+            the strategy execution. Default is `True`.
+
+        :raise NotImplementedError: If the `runs-on` value does not implement.
 
         :rtype: Result
         """
@@ -578,26 +608,36 @@ class Job(BaseModel):
             extras=self.extras,
         )
 
-        if self.runs_on.type == RunsOnType.LOCAL:
+        result.trace.info(
+            f"[JOB]: Execute: {self.id!r} on {self.runs_on.type!r}"
+        )
+        if self.runs_on.type == RunsOn.LOCAL:
             return local_execute(
-                job=self,
-                params=params,
-                result=result,
+                self,
+                params,
+                run_id=run_id,
+                parent_run_id=parent_run_id,
                 event=event,
+                raise_error=raise_error,
             )
-        elif self.runs_on.type == RunsOnType.SELF_HOSTED:  # pragma: no cov
-            pass
-        elif self.runs_on.type == RunsOnType.K8S:  # pragma: no cov
+        elif self.runs_on.type == RunsOn.SELF_HOSTED:  # pragma: no cov
             pass
+        elif self.runs_on.type == RunsOn.DOCKER:  # pragma: no cov
+            docker_execution(
+                self,
+                params,
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                event=event,
+                raise_error=raise_error,
+            )
 
         # pragma: no cov
         result.trace.error(
-            f"[JOB]: Job executor does not support for runs-on type: "
-            f"{self.runs_on.type} yet"
+            f"[JOB]: Execution not support runs-on: {self.runs_on.type!r} yet."
         )
         raise NotImplementedError(
-            f"The job runs-on other type: {self.runs_on.type} does not "
-            f"support yet."
+            f"Execution runs-on type: {self.runs_on.type} does not support yet."
         )
 
 
@@ -608,7 +648,7 @@ def local_execute_strategy(
     *,
     result: Result | None = None,
     event: Event | None = None,
-    raise_error: bool | None = None,
+    raise_error: bool = True,
 ) -> Result:
     """Local job strategy execution with passing dynamic parameters from the
     workflow execution to strategy matrix.
@@ -619,6 +659,8 @@ def local_execute_strategy(
 
         The result of this execution will return result with strategy ID
     that generated from the `gen_id` function with an input strategy value.
+    For each stage that execution with this strategy metrix, it will use the
+    `set_outputs` method for reconstruct result context data.
 
     :raise JobException: If it has any error from `StageException` or
         `UtilException`.
@@ -642,8 +684,10 @@ def local_execute_strategy(
     context.update({"matrix": strategy, "stages": {}})
 
     if strategy:
-        result.trace.info(f"[JOB]: Execute Strategy ID: {strategy_id}")
-        result.trace.info(f"[JOB]: ... Matrix: {strategy_id}")
+        result.trace.info(f"[JOB]: Execute Strategy: {strategy_id!r}")
+        result.trace.info(f"[JOB]: ... matrix: {strategy!r}")
+    else:
+        result.trace.info("[JOB]: Execute Empty-Strategy")
 
     for stage in job.stages:
 
@@ -651,7 +695,7 @@ def local_execute_strategy(
             stage.extras = job.extras
 
         if stage.is_skipped(params=context):
-            result.trace.info(f"[STAGE]: Skip stage: {stage.iden!r}")
+            result.trace.info(f"[JOB]: Skip Stage: {stage.iden!r}")
             stage.set_outputs(output={"skipped": True}, to=context)
             continue
 
@@ -661,17 +705,18 @@ def local_execute_strategy(
                 "strategy execution."
             )
             return result.catch(
-                status=FAILED,
+                status=CANCEL,
                 context={
                     strategy_id: {
                         "matrix": strategy,
-                        "stages": context.pop("stages", {}),
+                        "stages": filter_func(context.pop("stages", {})),
                         "errors": JobException(error_msg).to_dict(),
                     },
                 },
             )
 
         try:
+            result.trace.info(f"[JOB]: Execute Stage: {stage.iden!r}")
             rs: Result = stage.handler_execute(
                 params=context,
                 run_id=result.run_id,
@@ -679,31 +724,11 @@ def local_execute_strategy(
                 event=event,
             )
             stage.set_outputs(rs.context, to=context)
-            if rs.status == FAILED:
-                error_msg: str = (
-                    f"Job strategy was break because it has a stage, "
-                    f"{stage.iden}, failed without raise error."
-                )
-                return result.catch(
-                    status=FAILED,
-                    context={
-                        strategy_id: {
-                            "matrix": strategy,
-                            "stages": context.pop("stages", {}),
-                            "errors": JobException(error_msg).to_dict(),
-                        },
-                    },
-                )
-
-        except (StageException, UtilException) as err:
-            result.trace.error(f"[JOB]: {err.__class__.__name__}: {err}")
-            do_raise: bool = dynamic(
-                "job_raise_error", f=raise_error, extras=job.extras
-            )
-            if do_raise:
+        except (StageException, UtilException) as e:
+            result.trace.error(f"[JOB]: {e.__class__.__name__}: {e}")
+            if raise_error:
                 raise JobException(
-                    f"Stage execution error: {err.__class__.__name__}: "
-                    f"{err}"
+                    f"Stage execution error: {e.__class__.__name__}: {e}"
                 ) from None
 
             return result.catch(
@@ -711,8 +736,24 @@ def local_execute_strategy(
                 context={
                     strategy_id: {
                         "matrix": strategy,
-                        "stages": context.pop("stages", {}),
-                        "errors": err.to_dict(),
+                        "stages": filter_func(context.pop("stages", {})),
+                        "errors": e.to_dict(),
+                    },
+                },
+            )
+
+        if rs.status == FAILED:
+            error_msg: str = (
+                f"Job strategy was break because stage, {stage.iden}, "
+                f"failed without raise error."
+            )
+            return result.catch(
+                status=FAILED,
+                context={
+                    strategy_id: {
+                        "matrix": strategy,
+                        "stages": filter_func(context.pop("stages", {})),
+                        "errors": JobException(error_msg).to_dict(),
                     },
                 },
             )
@@ -734,9 +775,8 @@ def local_execute(
     *,
     run_id: str | None = None,
     parent_run_id: str | None = None,
-    result: Result | None = None,
     event: Event | None = None,
-    raise_error: bool | None = None,
+    raise_error: bool = True,
 ) -> Result:
     """Local job execution with passing dynamic parameters from the workflow
     execution or itself execution. It will generate matrix values at the first
@@ -749,21 +789,19 @@ def local_execute(
     :param params: (DictData) An input parameters that use on job execution.
     :param run_id: (str) A job running ID for this execution.
     :param parent_run_id: (str) A parent workflow running ID for this release.
-    :param result: (Result) A result object for keeping context and status
-        data.
     :param event: (Event) An event manager that pass to the PoolThreadExecutor.
     :param raise_error: (bool) A flag that all this method raise error to the
-        strategy execution.
+        strategy execution. Default is `True`.
 
     :rtype: Result
     """
     result: Result = Result.construct_with_rs_or_id(
-        result,
         run_id=run_id,
         parent_run_id=parent_run_id,
         id_logic=(job.id or "not-set"),
         extras=job.extras,
     )
+
     event: Event = Event() if event is None else event
 
     # NOTE: Normal Job execution without parallel strategy matrix. It uses
@@ -774,7 +812,7 @@ def local_execute(
 
             if event and event.is_set():  # pragma: no cov
                 return result.catch(
-                    status=FAILED,
+                    status=CANCEL,
                     context={
                         "errors": JobException(
                             "Job strategy was canceled from event that had set "
@@ -784,15 +822,15 @@ def local_execute(
                 )
 
             local_execute_strategy(
-                job=job,
-                strategy=strategy,
-                params=params,
+                job,
+                strategy,
+                params,
                 result=result,
                 event=event,
                 raise_error=raise_error,
             )
 
-        return result.catch(status=result.status)
+        return result
 
     fail_fast_flag: bool = job.strategy.fail_fast
     ls: str = "Fail-Fast" if fail_fast_flag else "All-Completed"
@@ -803,7 +841,7 @@ def local_execute(
 
     if event and event.is_set():  # pragma: no cov
         return result.catch(
-            status=FAILED,
+            status=CANCEL,
             context={
                 "errors": JobException(
                     "Job strategy was canceled from event that had set "
@@ -842,7 +880,7 @@ def local_execute(
 
             if len(done) != len(futures):
                 result.trace.warning(
-                    "[JOB]: Set the event for stop running stage."
+                    "[JOB]: Set event for stop pending stage future."
                 )
                 event.set()
                 for future in not_done:
@@ -851,18 +889,17 @@ def local_execute(
             nd: str = (
                 f", the strategies do not run is {not_done}" if not_done else ""
             )
-            result.trace.debug(f"[JOB]: Strategy is set Fail Fast{nd}")
+            result.trace.debug(f"[JOB]: Strategy set Fail-Fast{nd}")
 
         for future in done:
             try:
                 future.result()
-            except JobException as err:
+            except JobException as e:
                 status = FAILED
                 result.trace.error(
-                    f"[JOB]: {ls} Catch:\n\t{err.__class__.__name__}:"
-                    f"\n\t{err}"
+                    f"[JOB]: {ls} Catch:\n\t{e.__class__.__name__}:\n\t{e}"
                 )
-                context.update({"errors": err.to_dict()})
+                context.update({"errors": e.to_dict()})
 
     return result.catch(status=status, context=context)
 
@@ -873,9 +910,8 @@ def self_hosted_execute(
     *,
     run_id: str | None = None,
     parent_run_id: str | None = None,
-    result: Result | None = None,
     event: Event | None = None,
-    raise_error: bool | None = None,
+    raise_error: bool = True,
 ) -> Result:  # pragma: no cov
     """Self-Hosted job execution with passing dynamic parameters from the
     workflow execution or itself execution. It will make request to the
@@ -885,8 +921,6 @@ def self_hosted_execute(
     :param params: (DictData) An input parameters that use on job execution.
     :param run_id: (str) A job running ID for this execution.
     :param parent_run_id: (str) A parent workflow running ID for this release.
-    :param result: (Result) A result object for keeping context and status
-        data.
     :param event: (Event) An event manager that pass to the PoolThreadExecutor.
     :param raise_error: (bool) A flag that all this method raise error to the
         strategy execution.
@@ -894,7 +928,6 @@ def self_hosted_execute(
     :rtype: Result
     """
     result: Result = Result.construct_with_rs_or_id(
-        result,
         run_id=run_id,
         parent_run_id=parent_run_id,
         id_logic=(job.id or "not-set"),
@@ -903,7 +936,7 @@ def self_hosted_execute(
 
     if event and event.is_set():
         return result.catch(
-            status=FAILED,
+            status=CANCEL,
             context={
                 "errors": JobException(
                     "Job self-hosted execution was canceled from event that "
@@ -929,10 +962,7 @@ def self_hosted_execute(
         return result.catch(status=FAILED, context={"errors": to_dict(e)})
 
     if resp.status_code != 200:
-        do_raise: bool = dynamic(
-            "job_raise_error", f=raise_error, extras=job.extras
-        )
-        if do_raise:
+        if raise_error:
             raise JobException(
                 f"Job execution error from request to self-hosted: "
                 f"{job.runs_on.args.host!r}"
@@ -940,3 +970,97 @@ def self_hosted_execute(
 
         return result.catch(status=FAILED)
     return result.catch(status=SUCCESS)
+
+
+def azure_batch_execute(
+    job: Job,
+    params: DictData,
+    *,
+    run_id: str | None = None,
+    parent_run_id: str | None = None,
+    event: Event | None = None,
+    raise_error: bool | None = None,
+) -> Result:  # pragma no cov
+    """Azure Batch job execution that will run all job's stages on the Azure
+    Batch Node and extract the result file to be returning context result.
+
+    Steps:
+        - Create a Batch account and a Batch pool.
+        - Create a Batch job and add tasks to the job. Each task represents a
+          command to run on a compute node.
+        - Specify the command to run the Python script in the task. You can use
+          the cmd /c command to run the script with the Python interpreter.
+        - Upload the Python script and any required input files to Azure Storage
+          Account.
+        - Configure the task to download the input files from Azure Storage to
+          the compute node before running the script.
+        - Monitor the job and retrieve the output files from Azure Storage.
+
+    References:
+        - https://docs.azure.cn/en-us/batch/tutorial-parallel-python
+
+    :param job:
+    :param params:
+    :param run_id:
+    :param parent_run_id:
+    :param event:
+    :param raise_error:
+
+    :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 "not-set"),
+        extras=job.extras,
+    )
+    if event and event.is_set():
+        return result.catch(
+            status=CANCEL,
+            context={
+                "errors": JobException(
+                    "Job azure-batch execution was canceled from event that "
+                    "had set before start execution."
+                ).to_dict()
+            },
+        )
+    print(params)
+    print(raise_error)
+    return result.catch(status=SUCCESS)
+
+
+def docker_execution(
+    job: Job,
+    params: DictData,
+    *,
+    run_id: str | None = None,
+    parent_run_id: str | None = None,
+    event: Event | None = None,
+    raise_error: bool | None = None,
+):
+    """Docker job execution.
+
+    Steps:
+        - Pull the image
+        - 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 "not-set"),
+        extras=job.extras,
+    )
+    if event and event.is_set():
+        return result.catch(
+            status=CANCEL,
+            context={
+                "errors": JobException(
+                    "Job Docker execution was canceled from event that "
+                    "had set before start execution."
+                ).to_dict()
+            },
+        )
+    print(params)
+    print(raise_error)
+    return result.catch(status=SUCCESS)