ddeutil-workflow 0.0.83__tar.gz → 0.0.84__tar.gz

{ddeutil_workflow-0.0.83 → ddeutil_workflow-0.0.84}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.83
+Version: 0.0.84
 Summary: Lightweight workflow orchestration with YAML template
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT

{ddeutil_workflow-0.0.83 → ddeutil_workflow-0.0.84}/src/ddeutil/workflow/__about__.py

@@ -1,2 +1,2 @@
-__version__: str = "0.0.83"
+__version__: str = "0.0.84"
 __python_version__: str = "3.9"

{ddeutil_workflow-0.0.83 → ddeutil_workflow-0.0.84}/src/ddeutil/workflow/stages.py

@@ -206,13 +206,13 @@ class BaseStage(BaseModel, ABC):
         return self.id or self.name
 
     @field_validator("desc", mode="after")
-    def ___prepare_desc__(cls, value: str) -> str:
+    def ___prepare_desc__(cls, value: Optional[str]) -> Optional[str]:
         """Prepare description string that was created on a template.
 
         Returns:
             str: A dedent and left strip newline of description string.
         """
-        return dedent(value.lstrip("\n"))
+        return value if value is None else dedent(value.lstrip("\n"))
 
     @model_validator(mode="after")
     def __prepare_running_id(self) -> Self:
@@ -552,7 +552,7 @@ class BaseStage(BaseModel, ABC):
             #   should use the `re` module to validate eval-string before
             #   running.
             rs: bool = eval(
-                param2template(self.condition, params, extras=self.extras),
+                self.pass_template(self.condition, params),
                 globals() | params,
                 {},
             )
@@ -583,7 +583,8 @@ class BaseStage(BaseModel, ABC):
     def is_nested(self) -> bool:
         """Return true if this stage is nested stage.
 
-        :rtype: bool
+        Returns:
+            bool: True if this stage is nested stage.
         """
         return False
 
@@ -593,14 +594,46 @@ class BaseStage(BaseModel, ABC):
         Returns:
             DictData: A dict that was dumped from this model with alias mode.
         """
-        return self.model_dump(by_alias=True)
+        return self.model_dump(
+            by_alias=True,
+            exclude_defaults=True,
+            exclude={"extras", "id", "name", "desc"},
+        )
 
-    def md(self) -> str:  # pragma: no cov
+    def md(self, level: int = 1) -> str:  # pragma: no cov
         """Return generated document that will be the interface of this stage.
 
-        :rtype: str
+        Args:
+            level (int, default 0): A header level that want to generate
+                markdown content.
+
+        Returns:
+            str
         """
-        return self.desc
+        assert level >= 1, "Header level should gather than 0"
+
+        def align_newline(value: Optional[str]) -> str:
+            space: str = " " * 16
+            if value is None:
+                return ""
+            return value.rstrip("\n").replace("\n", f"\n{space}")
+
+        header: str = "#" * level
+        return dedent(
+            f"""
+                {header} Stage: {self.iden}\n
+                {align_newline(self.desc)}\n
+                #{header} Parameters\n
+                | name | type | default | description |
+                | --- | --- | --- | : --- : |\n\n
+                #{header} Details\n
+                ```json
+                {self.detail()}
+                ```
+                """.lstrip(
+                "\n"
+            )
+        )
 
     def dryrun(
         self,
@@ -610,26 +643,73 @@ class BaseStage(BaseModel, ABC):
         *,
         parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
-    ) -> Optional[Result]:  # pragma: no cov
+    ) -> Optional[Result]:
         """Pre-process method that will use to run with dry-run mode, and it
-        should be used before process method.
+        should be used replace of process method when workflow release set with
+        DRYRUN mode.
+
+            By default, this method will set logic to convert this stage model
+        to am EmptyStage if it is action stage before use process method
+        instead process itself.
+
+        Args:
+            params (DictData): A parameter data that want to use in this
+                execution.
+            run_id (str): A running stage ID.
+            context (DictData): A context data.
+            parent_run_id (str, default None): A parent running ID.
+            event (Event, default None): An event manager that use to track
+                parent process was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
+        trace.debug("[STAGE]: Start Dryrun ...")
+        if self.action_stage:
+            return self.to_empty().process(
+                params,
+                run_id,
+                context,
+                parent_run_id=parent_run_id,
+                event=event,
+            )
+        return self.process(
+            params, run_id, context, parent_run_id=parent_run_id, event=event
+        )
 
-    def to_empty(self, sleep: int = 0.35) -> EmptyStage:  # pragma: no cov
+    def to_empty(
+        self,
+        sleep: int = 0.35,
+        *,
+        message: Optional[str] = None,
+    ) -> EmptyStage:
         """Convert the current Stage model to the EmptyStage model for dry-run
         mode if the `action_stage` class attribute has set.
 
+        Args:
+            sleep (int, default 0.35): An adjustment sleep time.
+            message (str, default None): A message that want to override default
+                message on EmptyStage model.
+
         Returns:
             EmptyStage: An EmptyStage model that passing itself model data to
                 message.
         """
+        if isinstance(self, EmptyStage):
+            return self.model_copy(update={"sleep": sleep})
         return EmptyStage.model_validate(
             {
                 "name": self.name,
                 "id": self.id,
                 "desc": self.desc,
                 "if": self.condition,
-                "echo": f"Convert from {self.__class__.__name__}",
+                "echo": (
+                    message
+                    or f"Convert from {self.__class__.__name__} to EmptyStage"
+                ),
                 "sleep": sleep,
             }
         )
@@ -794,12 +874,14 @@ class BaseAsyncStage(BaseStage, ABC):
     ) -> Result:
         """Wrapped the axecute method before returning to handler axecute.
 
-        :param params: (DictData) A parameter data that want to use in this
-            execution.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
+        Args:
+            params: (DictData) A parameter data that want to use in this
+                execution.
+            event: (Event) An event manager that use to track parent execute
+                was not force stopped.
 
-        :rtype: Result
+        Returns:
+            Result: A Result object.
         """
         catch(context, status=WAIT)
         return await self.async_process(
@@ -820,7 +902,10 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         default=0,
         ge=0,
         lt=20,
-        description="A retry number if stage execution get the error.",
+        description=(
+            "A retry number if stage process got the error exclude skip and "
+            "cancel exception class."
+        ),
     )
 
     def _execute(
@@ -834,12 +919,14 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         """Wrapped the execute method with retry strategy before returning to
         handler execute.
 
-        :param params: (DictData) A parameter data that want to use in this
-            execution.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
+        Args:
+            params: (DictData) A parameter data that want to use in this
+                execution.
+            event: (Event) An event manager that use to track parent execute
+                was not force stopped.
 
-        :rtype: Result
+        Returns:
+            Result: A Result object.
         """
         current_retry: int = 0
         exception: Exception
@@ -847,9 +934,19 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         trace: Trace = get_trace(
             run_id, parent_run_id=parent_run_id, extras=self.extras
         )
-
         # NOTE: First execution for not pass to retry step if it passes.
         try:
+            if (
+                self.extras.get("__sys_release_dryrun_mode", False)
+                and self.action_stage
+            ):
+                return self.dryrun(
+                    params | {"retry": current_retry},
+                    run_id=run_id,
+                    context=context,
+                    parent_run_id=parent_run_id,
+                    event=event,
+                )
             return self.process(
                 params | {"retry": current_retry},
                 run_id=run_id,
@@ -876,6 +973,17 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
                     status=WAIT,
                     updated={"retry": current_retry},
                 )
+                if (
+                    self.extras.get("__sys_release_dryrun_mode", False)
+                    and self.action_stage
+                ):
+                    return self.dryrun(
+                        params | {"retry": current_retry},
+                        run_id=run_id,
+                        context=context,
+                        parent_run_id=parent_run_id,
+                        event=event,
+                    )
                 return self.process(
                     params | {"retry": current_retry},
                     run_id=run_id,
@@ -884,10 +992,10 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
                     event=event,
                 )
             except (
-                StageSkipError,
                 StageNestedSkipError,
-                StageCancelError,
                 StageNestedCancelError,
+                StageSkipError,
+                StageCancelError,
             ):
                 trace.debug("[STAGE]: process raise skip or cancel error.")
                 raise
@@ -916,12 +1024,14 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         """Wrapped the axecute method with retry strategy before returning to
         handler axecute.
 
-        :param params: (DictData) A parameter data that want to use in this
-            execution.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
+        Args:
+            params: (DictData) A parameter data that want to use in this
+                execution.
+            event: (Event) An event manager that use to track parent execute
+                was not force stopped.
 
-        :rtype: Result
+        Returns:
+            Result: A Result object.
         """
         current_retry: int = 0
         exception: Exception
@@ -932,6 +1042,17 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
 
         # NOTE: First execution for not pass to retry step if it passes.
         try:
+            if (
+                self.extras.get("__sys_release_dryrun_mode", False)
+                and self.action_stage
+            ):
+                return self.dryrun(
+                    params | {"retry": current_retry},
+                    run_id=run_id,
+                    context=context,
+                    parent_run_id=parent_run_id,
+                    event=event,
+                )
             return await self.async_process(
                 params | {"retry": current_retry},
                 run_id=run_id,
@@ -958,6 +1079,17 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
                     status=WAIT,
                     updated={"retry": current_retry},
                 )
+                if (
+                    self.extras.get("__sys_release_dryrun_mode", False)
+                    and self.action_stage
+                ):
+                    return self.dryrun(
+                        params | {"retry": current_retry},
+                        run_id=run_id,
+                        context=context,
+                        parent_run_id=parent_run_id,
+                        event=event,
+                    )
                 return await self.async_process(
                     params | {"retry": current_retry},
                     run_id=run_id,
@@ -966,10 +1098,10 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
                     event=event,
                 )
             except (
-                StageSkipError,
                 StageNestedSkipError,
-                StageCancelError,
                 StageNestedCancelError,
+                StageSkipError,
+                StageCancelError,
             ):
                 await trace.adebug(
                     "[STAGE]: process raise skip or cancel error."
@@ -1165,6 +1297,7 @@ class BashStage(BaseRetryStage):
         ... }
     """
 
+    action_stage: ClassVar[bool] = True
     bash: str = Field(
         description=(
             "A bash statement that want to execute via Python subprocess."
@@ -1409,6 +1542,7 @@ class PyStage(BaseRetryStage):
         ... }
     """
 
+    action_stage: ClassVar[bool] = True
     run: str = Field(
         description="A Python string statement that want to run with `exec`.",
     )
@@ -1647,6 +1781,7 @@ class CallStage(BaseRetryStage):
         ... }
     """
 
+    action_stage: ClassVar[bool] = True
     uses: str = Field(
         description=(
             "A caller function with registry importer syntax that use to load "
@@ -1728,7 +1863,7 @@ class CallStage(BaseRetryStage):
                 extras=self.extras,
             ),
             "extras": self.extras,
-        } | param2template(self.args, params, extras=self.extras)
+        } | self.pass_template(self.args, params)
         sig = inspect.signature(call_func)
         necessary_params: list[str] = []
         has_keyword: bool = False
@@ -1743,6 +1878,7 @@ class CallStage(BaseRetryStage):
             elif v.kind == Parameter.VAR_KEYWORD:
                 has_keyword = True
 
+        # NOTE: Validate private parameter should exist in the args field.
         if any(
             (k.removeprefix("_") not in args and k not in args)
             for k in necessary_params
@@ -1760,11 +1896,12 @@ class CallStage(BaseRetryStage):
                 f"does not set to args. It already set {list(args.keys())}."
             )
 
-        if "result" not in sig.parameters and not has_keyword:
-            args.pop("result")
+        if not has_keyword:
+            if "result" not in sig.parameters:
+                args.pop("result")
 
-        if "extras" not in sig.parameters and not has_keyword:
-            args.pop("extras")
+            if "extras" not in sig.parameters:  # pragma: no cov
+                args.pop("extras")
 
         if event and event.is_set():
             raise StageCancelError("Cancel before start call process.")
@@ -1847,7 +1984,7 @@ class CallStage(BaseRetryStage):
                 extras=self.extras,
             ),
             "extras": self.extras,
-        } | param2template(self.args, params, extras=self.extras)
+        } | self.pass_template(self.args, params)
         sig = inspect.signature(call_func)
         necessary_params: list[str] = []
         has_keyword: bool = False
@@ -1878,11 +2015,13 @@ class CallStage(BaseRetryStage):
                 f"Necessary params, ({', '.join(necessary_params)}, ), "
                 f"does not set to args. It already set {list(args.keys())}."
             )
-        if "result" not in sig.parameters and not has_keyword:
-            args.pop("result")
 
-        if "extras" not in sig.parameters and not has_keyword:
-            args.pop("extras")
+        if not has_keyword:
+            if "result" not in sig.parameters:
+                args.pop("result")
+
+            if "extras" not in sig.parameters:  # pragma: no cov
+                args.pop("extras")
 
         if event and event.is_set():
             raise StageCancelError("Cancel before start call process.")
@@ -1932,11 +2071,14 @@ class CallStage(BaseRetryStage):
         """Validate an input arguments before passing to the caller function.
 
         Args:
-            func: (TagFunc) A tag function that want to get typing.
-            args: (DictData) An arguments before passing to this tag func.
-            run_id: A running stage ID.
+            func (TagFunc): A tag function object that want to get typing.
+            args (DictData): An arguments before passing to this tag func.
+            run_id (str): A running ID.
+            parent_run_id (str, default None): A parent running ID.
+            extras (DictData, default None): An extra parameters.
 
-        :rtype: DictData
+        Returns:
+            DictData: A prepared args paramter that validate with model args.
         """
         try:
             override: DictData = dict(
@@ -1969,8 +2111,87 @@ class CallStage(BaseRetryStage):
             )
             return args
 
+    def dryrun(
+        self,
+        params: DictData,
+        run_id: str,
+        context: DictData,
+        *,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
+    ) -> Optional[Result]:  # pragma: no cov
+        """Override the dryrun method for this CallStage.
 
-class BaseNestedStage(BaseRetryStage, ABC):
+        Steps:
+            - Pre-hook caller function that exist.
+            - Show function parameters
+        """
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
+        call_func: TagFunc = self.get_caller(params=params)()
+        trace.info(f"[STAGE]: Caller Func: '{call_func.name}@{call_func.tag}'")
+
+        args: DictData = {
+            "result": Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=WAIT,
+                context=context,
+                extras=self.extras,
+            ),
+            "extras": self.extras,
+        } | self.pass_template(self.args, params)
+        sig = inspect.signature(call_func)
+        trace.debug(f"[STAGE]: {sig.parameters}")
+        necessary_params: list[str] = []
+        has_keyword: bool = False
+        for k in sig.parameters:
+            if (
+                v := sig.parameters[k]
+            ).default == Parameter.empty and v.kind not in (
+                Parameter.VAR_KEYWORD,
+                Parameter.VAR_POSITIONAL,
+            ):
+                necessary_params.append(k)
+            elif v.kind == Parameter.VAR_KEYWORD:
+                has_keyword = True
+
+        func_typed: dict[str, Any] = get_type_hints(call_func)
+        map_type: str = "||".join(
+            f"\t{p}: {func_typed[p]}"
+            for p in necessary_params
+            if p in func_typed
+        )
+        map_type_args: str = "||".join(f"\t{a}: {type(a)}" for a in args)
+        if not has_keyword:
+            if "result" not in sig.parameters:
+                args.pop("result")
+
+            if "extras" not in sig.parameters:
+                args.pop("extras")
+
+        trace.debug(
+            f"[STAGE]: Details"
+            f"||Necessary Params:"
+            f"||{map_type}"
+            f"||Return Type: {func_typed['return']}"
+            f"||Argument Params:"
+            f"||{map_type_args}"
+            f"||"
+        )
+        if has_keyword:
+            trace.debug("[STAGE]: This caller function support keyword param.")
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=SUCCESS,
+            context=catch(context=context, status=SUCCESS),
+            extras=self.extras,
+        )
+
+
+class BaseNestedStage(BaseAsyncStage, ABC):
     """Base Nested Stage model. This model is use for checking the child stage
     is the nested stage or not.
     """
@@ -2035,7 +2256,7 @@ class BaseNestedStage(BaseRetryStage, ABC):
         )
 
 
-class TriggerStage(BaseNestedStage):
+class TriggerStage(BaseRetryStage):
     """Trigger workflow executor stage that run an input trigger Workflow
     execute method. This is the stage that allow you to create the reusable
     Workflow template with dynamic parameters.
@@ -2093,7 +2314,7 @@ class TriggerStage(BaseNestedStage):
             run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         _trigger: str = param2template(self.trigger, params, extras=self.extras)
-        if _trigger == self.extras.get("__sys_break_circle_exec", "NOTSET"):
+        if _trigger == self.extras.get("__sys_exec_break_circle", "NOTSET"):
             raise StageError("Circle execute via trigger itself workflow name.")
         trace.info(f"[NESTED]: Load Workflow Config: {_trigger!r}")
         result: Result = Workflow.from_conf(
@@ -2142,6 +2363,33 @@ class TriggerStage(BaseNestedStage):
             )
         return result
 
+    async def async_process(
+        self,
+        params: DictData,
+        run_id: str,
+        context: DictData,
+        *,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
+    ) -> Result:  # pragma: no cov
+        """Async process for nested-stage do not implement yet.
+
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
+        """
+        raise NotImplementedError(
+            "The Trigger stage does not implement the `axecute` method yet."
+        )
+
 
 class ParallelContext(TypedDict):
     branch: str
@@ -2776,7 +3024,7 @@ class UntilStage(BaseNestedStage):
         ),
     )
     until: str = Field(description="A until condition for stop the while loop.")
-    stages: list[NestedStage] = Field(
+    stages: list[SubStage] = Field(
         default_factory=list,
         description=(
             "A list of stage that will run with each item in until loop."
@@ -3414,7 +3662,7 @@ class RaiseStage(BaseAsyncStage):
         raise StageError(message)
 
 
-class DockerStage(BaseStage):  # pragma: no cov
+class DockerStage(BaseRetryStage):  # pragma: no cov
     """Docker container stage execution that will pull the specific Docker image
     with custom authentication and run this image by passing environment
     variables and mounting local volume to this Docker container.
@@ -3437,6 +3685,7 @@ class DockerStage(BaseStage):  # pragma: no cov
         ... }
     """
 
+    action_stage: ClassVar[bool] = True
     image: str = Field(
         description="A Docker image url with tag that want to run.",
     )
@@ -3593,6 +3842,33 @@ class DockerStage(BaseStage):  # pragma: no cov
         trace.info(f"[STAGE]: Docker: {self.image}:{self.tag}")
         raise NotImplementedError("Docker Stage does not implement yet.")
 
+    async def async_process(
+        self,
+        params: DictData,
+        run_id: str,
+        context: DictData,
+        *,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
+    ) -> Result:  # pragma: no cov
+        """Async process for nested-stage do not implement yet.
+
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
+        """
+        raise NotImplementedError(
+            "The Docker stage does not implement the `axecute` method yet."
+        )
+
 
 class VirtualPyStage(PyStage):  # pragma: no cov
     """Virtual Python stage executor that run Python statement on the dependent
@@ -3629,7 +3905,7 @@ class VirtualPyStage(PyStage):  # pragma: no cov
 
         Args:
             py: A Python string statement.
-            values: A variable that want to set before running this
+            values: A variable that want to set before running these
             deps: An additional Python dependencies that want install before
                 run this python stage.
             run_id: (StrOrNone) A running ID of this stage execution.
@@ -3761,7 +4037,7 @@ class VirtualPyStage(PyStage):  # pragma: no cov
         )
 
 
-NestedStage = Annotated[
+SubStage = Annotated[
     Union[
         BashStage,
         CallStage,
@@ -3777,7 +4053,10 @@ NestedStage = Annotated[
     ],
     Field(
         union_mode="smart",
-        description="A nested-stage allow list",
+        description=(
+            "A nested-stage allow list that able to use on the NestedStage "
+            "model."
+        ),
     ),
 ]  # pragma: no cov
 
@@ -3790,6 +4069,7 @@ ActionStage = Annotated[
         PyStage,
         RaiseStage,
         DockerStage,
+        TriggerStage,
         EmptyStage,
     ],
     Field(

{ddeutil_workflow-0.0.83 → ddeutil_workflow-0.0.84}/src/ddeutil/workflow/utils.py

@@ -405,6 +405,17 @@ def obj_name(obj: Optional[Union[str, object]] = None) -> Optional[str]:
     return obj_type
 
 
-def remove_sys_extras(extras: DictData) -> DictData:
-    """Remove key that starts with `__sys_` from the extra dict parameter."""
-    return {k: extras[k] for k in extras if not k.startswith("__sys_")}
+def pop_sys_extras(extras: DictData, scope: str = "exec") -> DictData:
+    """Remove key that starts with `__sys_` from the extra dict parameter.
+
+    Args:
+        extras:
+        scope (str):
+
+    Returns:
+        DictData:
+    """
+    keys: list[str] = [k for k in extras if not k.startswith(f"__sys_{scope}")]
+    for k in keys:
+        extras.pop(k)
+    return extras

{ddeutil_workflow-0.0.83 → ddeutil_workflow-0.0.84}/src/ddeutil/workflow/workflow.py

@@ -41,6 +41,7 @@ from pydantic.functional_serializers import field_serializer
 from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
+from . import DRYRUN
 from .__types import DictData
 from .audits import NORMAL, RERUN, Audit, ReleaseType, get_audit
 from .conf import YamlParser, dynamic
@@ -66,7 +67,7 @@ from .utils import (
     extract_id,
     gen_id,
     get_dt_now,
-    remove_sys_extras,
+    pop_sys_extras,
 )
 
 
@@ -244,14 +245,12 @@ class Workflow(BaseModel):
                 f"{self.name!r}."
             )
 
-        # NOTE: Force update internal extras for handler circle execution.
-        self.extras.update({"__sys_break_circle_exec": self.name})
-
         return self
 
     @field_serializer("extras")
     def __serialize_extras(self, extras: DictData) -> DictData:
-        return remove_sys_extras(extras)
+        """Serialize extra parameter."""
+        return {k: extras[k] for k in extras if not k.startswith("__sys_")}
 
     def detail(self) -> DictData:  # pragma: no cov
         """Return the detail of this workflow for generate markdown."""
@@ -264,8 +263,10 @@ class Workflow(BaseModel):
             author (str | None, default None): An author name.
         """
 
-        def align_newline(value: str) -> str:
+        def align_newline(value: Optional[str]) -> str:
             space: str = " " * 16
+            if value is None:
+                return ""
             return value.rstrip("\n").replace("\n", f"\n{space}")
 
         info: str = (
@@ -452,7 +453,17 @@ class Workflow(BaseModel):
             extras=self.extras,
         )
 
-        if release_type == NORMAL and audit.is_pointed(data=audit_data):
+        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."
+            )
+        elif release_type == DRYRUN:
+            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):
             trace.info("[RELEASE]: Skip this release because it already audit.")
             return Result(
                 run_id=run_id,
@@ -462,14 +473,6 @@ class Workflow(BaseModel):
                 extras=self.extras,
             )
 
-        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."
-            )
-
         rs: Result = self.execute(
             params=values,
             run_id=parent_run_id,
@@ -478,27 +481,29 @@ class Workflow(BaseModel):
         catch(context, status=rs.status, updated=rs.context)
         trace.info(f"[RELEASE]: End {name!r} : {release:%Y-%m-%d %H:%M:%S}")
         trace.debug(f"[RELEASE]: Writing audit: {name!r}.")
-        (
-            audit.save(
-                data=audit_data
-                | {
-                    "context": context,
-                    "runs_metadata": (
-                        (runs_metadata or {})
-                        | rs.info
-                        | {
-                            "timeout": timeout,
-                            "original_name": self.name,
-                            "audit_excluded": audit_excluded,
-                        }
-                    ),
-                },
-                excluded=audit_excluded,
+        if release_type != DRYRUN:
+            (
+                audit.save(
+                    data=audit_data
+                    | {
+                        "context": context,
+                        "runs_metadata": (
+                            (runs_metadata or {})
+                            | rs.info
+                            | {
+                                "timeout": timeout,
+                                "original_name": self.name,
+                                "audit_excluded": audit_excluded,
+                            }
+                        ),
+                    },
+                    excluded=audit_excluded,
+                )
             )
-        )
-        return Result(
-            run_id=run_id,
-            parent_run_id=parent_run_id,
+
+        # NOTE: Pop system extra parameters.
+        pop_sys_extras(self.extras, scope="release")
+        return Result.from_trace(trace).catch(
             status=rs.status,
             context=catch(
                 context,
@@ -513,7 +518,6 @@ class Workflow(BaseModel):
                     **(context["errors"] if "errors" in context else {}),
                 },
             ),
-            extras=remove_sys_extras(self.extras),
         )
 
     def execute_job(
@@ -719,6 +723,8 @@ class Workflow(BaseModel):
                 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] = []
 
@@ -747,6 +753,7 @@ class Workflow(BaseModel):
                 backoff_sleep = 0.01
 
                 if check == FAILED:  # pragma: no cov
+                    pop_sys_extras(self.extras)
                     return Result(
                         run_id=run_id,
                         parent_run_id=parent_run_id,
@@ -841,6 +848,7 @@ class Workflow(BaseModel):
                 for i, s in enumerate(sequence_statuses, start=0):
                     statuses[total + 1 + skip_count + i] = s
 
+                pop_sys_extras(self.extras)
                 st: Status = validate_statuses(statuses)
                 return Result(
                     run_id=run_id,
@@ -862,6 +870,7 @@ class Workflow(BaseModel):
 
             time.sleep(0.0025)
 
+        pop_sys_extras(self.extras)
         return Result(
             run_id=run_id,
             parent_run_id=parent_run_id,

{ddeutil_workflow-0.0.83 → ddeutil_workflow-0.0.84}/src/ddeutil_workflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.83
+Version: 0.0.84
 Summary: Lightweight workflow orchestration with YAML template
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT

{ddeutil_workflow-0.0.83 → ddeutil_workflow-0.0.84}/tests/test_workflow.py

@@ -47,7 +47,6 @@ def test_workflow():
 
     set_job_id = job.model_copy()
     set_job_id.id = "demo-run"
-    set_job_id.extras.update({"__sys_break_circle_exec": "manual-workflow"})
     assert workflow.job("demo-run") == set_job_id
 
     # NOTE: Raise ValueError when get a job with ID that does not exist.
@@ -101,21 +100,14 @@ def test_workflow_bypass_extras():
     assert workflow.jobs["first-job"].extras == {}
 
     # NOTE: Bypass extras to job model.
-    assert workflow.job("first-job").extras == {
-        "registries": ["foo", "bar"],
-        "__sys_break_circle_exec": "manual-workflow",
-    }
-    assert workflow.job("second-job").extras == {
-        "registries": ["foo", "bar"],
-        "__sys_break_circle_exec": "manual-workflow",
-    }
+    assert workflow.job("first-job").extras == {"registries": ["foo", "bar"]}
+    assert workflow.job("second-job").extras == {"registries": ["foo", "bar"]}
 
     assert workflow.job("first-job").stages[0].extras == {}
 
     # NOTE: Bypass extras to stage model.
     assert workflow.job("first-job").stage("echo").extras == {
-        "registries": ["foo", "bar"],
-        "__sys_break_circle_exec": "manual-workflow",
+        "registries": ["foo", "bar"]
     }
 
 
@@ -237,10 +229,7 @@ def test_workflow_from_conf_override(test_path):
             name="tmp-wf-override-conf-trigger", extras={"conf_path": conf_path}
         )
         stage = workflow.job(name="trigger-job").stage("trigger-stage")
-        assert stage.extras == {
-            "conf_path": conf_path,
-            "__sys_break_circle_exec": "tmp-wf-override-conf-trigger",
-        }
+        assert stage.extras == {"conf_path": conf_path}
 
         rs: Result = workflow.execute(params={"name": "bar"})
         assert rs.status == SUCCESS

{ddeutil_workflow-0.0.83 → ddeutil_workflow-0.0.84}/tests/test_workflow_release.py

@@ -4,6 +4,7 @@ from zoneinfo import ZoneInfo
 
 import pytest
 from ddeutil.workflow import (
+    DRYRUN,
     FORCE,
     NORMAL,
     RERUN,
@@ -238,3 +239,43 @@ def test_workflow_release_rerun():
     )
     with pytest.raises(NotImplementedError):
         workflow.release(release=datetime.now(), params={}, release_type=RERUN)
+
+
+def test_workflow_release_dryrun():
+    workflow: Workflow = Workflow.model_validate(
+        obj={
+            "name": "wf-scheduling-common",
+            "jobs": {
+                "first-job": {
+                    "stages": [
+                        {"name": "First Stage", "run": "print('test')"},
+                        {"name": "Second Stage", "id": "second-stage"},
+                    ]
+                }
+            },
+            "extra": {"enable_write_audit": True},
+        }
+    )
+    rs: Result = workflow.release(
+        release=datetime(2024, 10, 1),
+        params={},
+        release_type=DRYRUN,
+    )
+    assert rs.status == SUCCESS
+    assert rs.context == {
+        "status": "SUCCESS",
+        "params": {},
+        "release": {
+            "type": DRYRUN,
+            "logical_date": datetime(2024, 10, 1, tzinfo=ZoneInfo(key="UTC")),
+        },
+        "jobs": {
+            "first-job": {
+                "status": SUCCESS,
+                "stages": {
+                    "7782830343": {"outputs": {}, "status": SUCCESS},
+                    "second-stage": {"outputs": {}, "status": SUCCESS},
+                },
+            },
+        },
+    }