ddeutil-workflow 0.0.52__tar.gz → 0.0.53__tar.gz

{ddeutil_workflow-0.0.52/src/ddeutil_workflow.egg-info → ddeutil_workflow-0.0.53}/PKG-INFO

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

ddeutil_workflow-0.0.53/src/ddeutil/workflow/__about__.py

@@ -0,0 +1 @@
+__version__: str = "0.0.53"

{ddeutil_workflow-0.0.52 → ddeutil_workflow-0.0.53}/src/ddeutil/workflow/job.py

@@ -555,6 +555,7 @@ class Job(BaseModel):
             )
 
         _id: str = self.id or job_id
+        output: DictData = copy.deepcopy(output)
         errors: DictData = (
             {"errors": output.pop("errors", {})} if "errors" in output else {}
         )

{ddeutil_workflow-0.0.52 → ddeutil_workflow-0.0.53}/src/ddeutil/workflow/stages.py

@@ -42,7 +42,7 @@ from concurrent.futures import (
     wait,
 )
 from datetime import datetime
-from inspect import Parameter
+from inspect import Parameter, isclass, isfunction, ismodule
 from pathlib import Path
 from subprocess import CompletedProcess
 from textwrap import dedent
@@ -266,7 +266,7 @@ class BaseStage(BaseModel, ABC):
                 param2template(self.name, params=to, extras=self.extras)
             )
         )
-
+        output: DictData = output.copy()
         errors: DictData = (
             {"errors": output.pop("errors", {})} if "errors" in output else {}
         )
@@ -302,7 +302,7 @@ class BaseStage(BaseModel, ABC):
                 param2template(self.name, params=outputs, extras=self.extras)
             )
         )
-        return outputs.get("stages", {}).get(_id, {})
+        return outputs.get("stages", {}).get(_id, {}).get("outputs", {})
 
     def is_skipped(self, params: DictData | None = None) -> bool:
         """Return true if condition of this stage do not correct. This process
@@ -704,12 +704,11 @@ class PyStage(BaseStage):
 
         :rtype: Iterator[str]
         """
-        from inspect import isclass, ismodule
-
         for value in values:
 
             if (
                 value == "__annotations__"
+                or (value.startswith("__") and value.endswith("__"))
                 or ismodule(values[value])
                 or isclass(values[value])
             ):
@@ -727,11 +726,10 @@ class PyStage(BaseStage):
 
         :rtype: DictData
         """
+        output: DictData = output.copy()
         lc: DictData = output.pop("locals", {})
         gb: DictData = output.pop("globals", {})
-        super().set_outputs(
-            {k: lc[k] for k in self.filter_locals(lc)} | output, to=to
-        )
+        super().set_outputs(lc | output, to=to)
         to.update({k: gb[k] for k in to if k in gb})
         return to
 
@@ -762,26 +760,36 @@ class PyStage(BaseStage):
         lc: DictData = {}
         gb: DictData = (
             globals()
-            | params
             | param2template(self.vars, params, extras=self.extras)
             | {"result": result}
         )
 
-        # NOTE: Start exec the run statement.
         result.trace.info(f"[STAGE]: Py-Execute: {self.name}")
-        # result.trace.warning(
-        #     "[STAGE]: This stage allow use `eval` function, so, please "
-        #     "check your statement be safe before execute."
-        # )
-        #
+
         # WARNING: The exec build-in function is very dangerous. So, it
         #   should use the re module to validate exec-string before running.
         exec(
-            param2template(dedent(self.run), params, extras=self.extras), gb, lc
+            param2template(dedent(self.run), params, extras=self.extras),
+            gb,
+            lc,
         )
 
         return result.catch(
-            status=SUCCESS, context={"locals": lc, "globals": gb}
+            status=SUCCESS,
+            context={
+                "locals": {k: lc[k] for k in self.filter_locals(lc)},
+                "globals": {
+                    k: gb[k]
+                    for k in gb
+                    if (
+                        not k.startswith("__")
+                        and k != "annotations"
+                        and not ismodule(gb[k])
+                        and not isclass(gb[k])
+                        and not isfunction(gb[k])
+                    )
+                },
+            },
         )
 
 
@@ -841,8 +849,8 @@ class CallStage(BaseStage):
 
         :raise ValueError: If necessary arguments does not pass from the `args`
             field.
-        :raise TypeError: If the result from the caller function does not by
-            a `dict` type.
+        :raise TypeError: If the result from the caller function does not match
+            with a `dict` type.
 
         :rtype: Result
         """
@@ -1099,17 +1107,17 @@ class ParallelStage(BaseStage):  # pragma: no cov
         :rtype: DictData
         """
         result.trace.debug(f"... Execute branch: {branch!r}")
-        _params: DictData = copy.deepcopy(params)
-        _params.update({"branch": branch})
-        context: DictData = {"branch": branch, "stages": {}}
+        context: DictData = copy.deepcopy(params)
+        context.update({"branch": branch})
+        output: DictData = {"branch": branch, "stages": {}}
         for stage in self.parallel[branch]:
 
             if extras:
                 stage.extras = extras
 
-            if stage.is_skipped(params=_params):
+            if stage.is_skipped(params=context):
                 result.trace.info(f"... Skip stage: {stage.iden!r}")
-                stage.set_outputs(output={"skipped": True}, to=context)
+                stage.set_outputs(output={"skipped": True}, to=output)
                 continue
 
             if event and event.is_set():
@@ -1122,7 +1130,7 @@ class ParallelStage(BaseStage):  # pragma: no cov
                     parallel={
                         branch: {
                             "branch": branch,
-                            "stages": filter_func(context.pop("stages", {})),
+                            "stages": filter_func(output.pop("stages", {})),
                             "errors": StageException(error_msg).to_dict(),
                         }
                     },
@@ -1130,14 +1138,15 @@ class ParallelStage(BaseStage):  # pragma: no cov
 
             try:
                 rs: Result = stage.handler_execute(
-                    params=_params,
+                    params=context,
                     run_id=result.run_id,
                     parent_run_id=result.parent_run_id,
                     raise_error=True,
                     event=event,
                 )
-                stage.set_outputs(rs.context, to=context)
-            except StageException as e:  # pragma: no cov
+                stage.set_outputs(rs.context, to=output)
+                stage.set_outputs(stage.get_outputs(output), to=context)
+            except (StageException, UtilException) as e:  # pragma: no cov
                 result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
                 raise StageException(
                     f"Sub-Stage execution error: {e.__class__.__name__}: {e}"
@@ -1153,7 +1162,7 @@ class ParallelStage(BaseStage):  # pragma: no cov
                     parallel={
                         branch: {
                             "branch": branch,
-                            "stages": filter_func(context.pop("stages", {})),
+                            "stages": filter_func(output.pop("stages", {})),
                             "errors": StageException(error_msg).to_dict(),
                         },
                     },
@@ -1164,7 +1173,7 @@ class ParallelStage(BaseStage):  # pragma: no cov
             parallel={
                 branch: {
                     "branch": branch,
-                    "stages": filter_func(context.pop("stages", {})),
+                    "stages": filter_func(output.pop("stages", {})),
                 },
             },
         )
@@ -1294,18 +1303,18 @@ class ForEachStage(BaseStage):
 
         :rtype: Result
         """
-        result.trace.debug(f"... Execute item: {item!r}")
-        _params: DictData = copy.deepcopy(params)
-        _params.update({"item": item})
-        context: DictData = {"item": item, "stages": {}}
+        result.trace.debug(f"[STAGE]: Execute item: {item!r}")
+        context: DictData = copy.deepcopy(params)
+        context.update({"item": item})
+        output: DictData = {"item": item, "stages": {}}
         for stage in self.stages:
 
             if self.extras:
                 stage.extras = self.extras
 
-            if stage.is_skipped(params=_params):
+            if stage.is_skipped(params=context):
                 result.trace.info(f"... Skip stage: {stage.iden!r}")
-                stage.set_outputs(output={"skipped": True}, to=context)
+                stage.set_outputs(output={"skipped": True}, to=output)
                 continue
 
             if event and event.is_set():  # pragma: no cov
@@ -1318,7 +1327,7 @@ class ForEachStage(BaseStage):
                     foreach={
                         item: {
                             "item": item,
-                            "stages": filter_func(context.pop("stages", {})),
+                            "stages": filter_func(output.pop("stages", {})),
                             "errors": StageException(error_msg).to_dict(),
                         }
                     },
@@ -1326,13 +1335,14 @@ class ForEachStage(BaseStage):
 
             try:
                 rs: Result = stage.handler_execute(
-                    params=_params,
+                    params=context,
                     run_id=result.run_id,
                     parent_run_id=result.parent_run_id,
                     raise_error=True,
                     event=event,
                 )
-                stage.set_outputs(rs.context, to=context)
+                stage.set_outputs(rs.context, to=output)
+                stage.set_outputs(stage.get_outputs(output), to=context)
             except (StageException, UtilException) as e:
                 result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
                 raise StageException(
@@ -1349,18 +1359,17 @@ class ForEachStage(BaseStage):
                     foreach={
                         item: {
                             "item": item,
-                            "stages": filter_func(context.pop("stages", {})),
+                            "stages": filter_func(output.pop("stages", {})),
                             "errors": StageException(error_msg).to_dict(),
                         },
                     },
                 )
-
         return result.catch(
             status=SUCCESS,
             foreach={
                 item: {
                     "item": item,
-                    "stages": filter_func(context.pop("stages", {})),
+                    "stages": filter_func(output.pop("stages", {})),
                 },
             },
         )
@@ -1515,18 +1524,18 @@ class UntilStage(BaseStage):  # pragma: no cov
         :rtype: tuple[Result, T]
         """
         result.trace.debug(f"... Execute until item: {item!r}")
-        _params: DictData = copy.deepcopy(params)
-        _params.update({"item": item})
-        context: DictData = {"loop": loop, "item": item, "stages": {}}
+        context: DictData = copy.deepcopy(params)
+        context.update({"item": item})
+        output: DictData = {"loop": loop, "item": item, "stages": {}}
         next_item: T = None
         for stage in self.stages:
 
             if self.extras:
                 stage.extras = self.extras
 
-            if stage.is_skipped(params=_params):
+            if stage.is_skipped(params=context):
                 result.trace.info(f"... Skip stage: {stage.iden!r}")
-                stage.set_outputs(output={"skipped": True}, to=context)
+                stage.set_outputs(output={"skipped": True}, to=output)
                 continue
 
             if event and event.is_set():
@@ -1541,9 +1550,7 @@ class UntilStage(BaseStage):  # pragma: no cov
                             loop: {
                                 "loop": loop,
                                 "item": item,
-                                "stages": filter_func(
-                                    context.pop("stages", {})
-                                ),
+                                "stages": filter_func(output.pop("stages", {})),
                                 "errors": StageException(error_msg).to_dict(),
                             }
                         },
@@ -1553,17 +1560,18 @@ class UntilStage(BaseStage):  # pragma: no cov
 
             try:
                 rs: Result = stage.handler_execute(
-                    params=_params,
+                    params=context,
                     run_id=result.run_id,
                     parent_run_id=result.parent_run_id,
                     raise_error=True,
                     event=event,
                 )
-                stage.set_outputs(rs.context, to=context)
-                if "item" in (
-                    outputs := stage.get_outputs(context).get("outputs", {})
-                ):
-                    next_item = outputs["item"]
+                stage.set_outputs(rs.context, to=output)
+
+                if "item" in (_output := stage.get_outputs(output)):
+                    next_item = _output["item"]
+
+                stage.set_outputs(_output, to=context)
             except (StageException, UtilException) as e:
                 result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
                 raise StageException(
@@ -1577,7 +1585,7 @@ class UntilStage(BaseStage):  # pragma: no cov
                     loop: {
                         "loop": loop,
                         "item": item,
-                        "stages": filter_func(context.pop("stages", {})),
+                        "stages": filter_func(output.pop("stages", {})),
                     }
                 },
             ),
@@ -1672,7 +1680,9 @@ class Match(BaseModel):
     """Match model for the Case Stage."""
 
     case: Union[str, int] = Field(description="A match case.")
-    stage: Stage = Field(description="A stage to execution for this case.")
+    stages: list[Stage] = Field(
+        description="A list of stage to execution for this case."
+    )
 
 
 class CaseStage(BaseStage):
@@ -1685,24 +1695,21 @@ class CaseStage(BaseStage):
         ...     "match": [
         ...         {
         ...             "case": "1",
-        ...             "stage": {
-        ...                 "name": "Stage case 1",
-        ...                 "eche": "Hello case 1",
-        ...             },
-        ...         },
-        ...         {
-        ...             "case": "2",
-        ...             "stage": {
-        ...                 "name": "Stage case 2",
-        ...                 "eche": "Hello case 2",
-        ...             },
+        ...             "stages": [
+        ...                 {
+        ...                     "name": "Stage case 1",
+        ...                     "eche": "Hello case 1",
+        ...                 },
+        ...             ],
         ...         },
         ...         {
         ...             "case": "_",
-        ...             "stage": {
-        ...                 "name": "Stage else",
-        ...                 "eche": "Hello case else",
-        ...             },
+        ...             "stages": [
+        ...                 {
+        ...                     "name": "Stage else",
+        ...                     "eche": "Hello case else",
+        ...                 },
+        ...             ],
         ...         },
         ...     ],
         ... }
@@ -1722,6 +1729,98 @@ class CaseStage(BaseStage):
         alias="skip-not-match",
     )
 
+    def execute_case(
+        self,
+        case: str,
+        stages: list[Stage],
+        params: DictData,
+        result: Result,
+        *,
+        event: Event | None = None,
+    ) -> Result:
+        """Execute case.
+
+        :param case: (str) A case that want to execution.
+        :param stages: (list[Stage]) A list of stage.
+        :param params: (DictData) A parameter that want to pass to stage
+            execution.
+        :param result: (Result) A result object for keeping context and status
+            data.
+        :param event: (Event) An event manager that use to track parent execute
+            was not force stopped.
+
+        :rtype: Result
+        """
+        context: DictData = copy.deepcopy(params)
+        context.update({"case": case})
+        output: DictData = {"case": case, "stages": {}}
+
+        for stage in stages:
+
+            if self.extras:
+                stage.extras = self.extras
+
+            if stage.is_skipped(params=context):
+                result.trace.info(f"... Skip stage: {stage.iden!r}")
+                stage.set_outputs(output={"skipped": True}, to=output)
+                continue
+
+            if event and event.is_set():  # pragma: no cov
+                error_msg: str = (
+                    "Case-Stage was canceled from event that had set before "
+                    "stage case execution."
+                )
+                return result.catch(
+                    status=CANCEL,
+                    context={
+                        "case": case,
+                        "stages": filter_func(output.pop("stages", {})),
+                        "errors": StageException(error_msg).to_dict(),
+                    },
+                )
+
+            try:
+                rs: Result = stage.handler_execute(
+                    params=context,
+                    run_id=result.run_id,
+                    parent_run_id=result.parent_run_id,
+                    raise_error=True,
+                    event=event,
+                )
+                stage.set_outputs(rs.context, to=output)
+                stage.set_outputs(stage.get_outputs(output), to=context)
+            except (StageException, UtilException) as e:  # pragma: no cov
+                result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
+                return result.catch(
+                    status=FAILED,
+                    context={
+                        "case": case,
+                        "stages": filter_func(output.pop("stages", {})),
+                        "errors": e.to_dict(),
+                    },
+                )
+
+            if rs.status == FAILED:
+                error_msg: str = (
+                    f"Case-Stage was break because it has a sub stage, "
+                    f"{stage.iden}, failed without raise error."
+                )
+                return result.catch(
+                    status=FAILED,
+                    context={
+                        "case": case,
+                        "stages": filter_func(output.pop("stages", {})),
+                        "errors": StageException(error_msg).to_dict(),
+                    },
+                )
+        return result.catch(
+            status=SUCCESS,
+            context={
+                "case": case,
+                "stages": filter_func(output.pop("stages", {})),
+            },
+        )
+
     def execute(
         self,
         params: DictData,
@@ -1751,17 +1850,17 @@ class CaseStage(BaseStage):
 
         result.trace.info(f"[STAGE]: Case-Execute: {_case!r}.")
         _else: Optional[Match] = None
-        stage: Optional[Stage] = None
+        stages: Optional[list[Stage]] = None
         for match in self.match:
             if (c := match.case) == "_":
                 _else: Match = match
                 continue
 
             _condition: str = param2template(c, params, extras=self.extras)
-            if stage is None and _case == _condition:
-                stage: Stage = match.stage
+            if stages is None and _case == _condition:
+                stages: list[Stage] = match.stages
 
-        if stage is None:
+        if stages is None:
             if _else is None:
                 if not self.skip_not_match:
                     raise StageException(
@@ -1779,10 +1878,8 @@ class CaseStage(BaseStage):
                     status=CANCEL,
                     context={"errors": StageException(error_msg).to_dict()},
                 )
-            stage: Stage = _else.stage
-
-        if self.extras:
-            stage.extras = self.extras
+            _case: str = "_"
+            stages: list[Stage] = _else.stages
 
         if event and event.is_set():  # pragma: no cov
             return result.catch(
@@ -1795,19 +1892,9 @@ class CaseStage(BaseStage):
                 },
             )
 
-        try:
-            return result.catch(
-                status=SUCCESS,
-                context=stage.handler_execute(
-                    params=params,
-                    run_id=result.run_id,
-                    parent_run_id=result.parent_run_id,
-                    event=event,
-                ).context,
-            )
-        except StageException as e:  # pragma: no cov
-            result.trace.error(f"[STAGE]: {e.__class__.__name__}:" f"\n\t{e}")
-            return result.catch(status=FAILED, context={"errors": e.to_dict()})
+        return self.execute_case(
+            case=_case, stages=stages, params=params, result=result, event=event
+        )
 
 
 class RaiseStage(BaseStage):  # pragma: no cov

{ddeutil_workflow-0.0.52 → ddeutil_workflow-0.0.53/src/ddeutil_workflow.egg-info}/PKG-INFO

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

{ddeutil_workflow-0.0.52 → ddeutil_workflow-0.0.53}/tests/test_stage.py

@@ -109,9 +109,9 @@ def test_stage_get_outputs():
     assert stage.get_outputs(outputs) == {}
 
     stage.extras = {"stage_default_id": True}
-    assert stage.get_outputs(outputs) == {"outputs": {"foo": "baz"}}
+    assert stage.get_outputs(outputs) == {"foo": "baz"}
 
     stage: Stage = EmptyStage.model_validate(
         {"id": "first-stage", "name": "Empty Stage", "echo": "hello world"}
     )
-    assert stage.get_outputs(outputs) == {"outputs": {"foo": "bar"}}
+    assert stage.get_outputs(outputs) == {"foo": "bar"}

{ddeutil_workflow-0.0.52 → ddeutil_workflow-0.0.53}/tests/test_stage_handler_exec.py

@@ -992,36 +992,36 @@ def test_stage_exec_case_match(test_path):
                   case: ${{ params.name }}
                   match:
                     - case: "bar"
-                      stage:
-                        name: Match name with Bar
-                        echo: Hello ${{ params.name }}
+                      stages:
+                        - name: Match name with Bar
+                          echo: Hello ${{ params.name }}
 
                     - case: "foo"
-                      stage:
-                        name: Match name with For
-                        echo: Hello ${{ params.name }}
+                      stages:
+                        - name: Match name with For
+                          echo: Hello ${{ params.name }}
 
                     - case: "_"
-                      stage:
-                        name: Else stage
-                        echo: Not match any case.
+                      stages:
+                        - name: Else stage
+                          echo: Not match any case.
                 - name: "Stage raise not has else condition"
                   id: raise-else
                   case: ${{ params.name }}
                   match:
                     - case: "bar"
-                      stage:
-                        name: Match name with Bar
-                        echo: Hello ${{ params.name }}
+                      stages:
+                        - name: Match name with Bar
+                          echo: Hello ${{ params.name }}
                 - name: "Stage skip not has else condition"
                   id: not-else
                   case: ${{ params.name }}
                   skip-not-match: true
                   match:
                     - case: "bar"
-                      stage:
-                        name: Match name with Bar
-                        echo: Hello ${{ params.name }}
+                      stages:
+                        - name: Match name with Bar
+                          echo: Hello ${{ params.name }}
         """,
     ):
         workflow = Workflow.from_conf(name="tmp-wf-case-match")
@@ -1029,17 +1029,44 @@ def test_stage_exec_case_match(test_path):
         rs = stage.set_outputs(
             stage.handler_execute({"params": {"name": "bar"}}).context, to={}
         )
-        assert rs == {"stages": {"case-stage": {"outputs": {}}}}
+        assert rs == {
+            "stages": {
+                "case-stage": {
+                    "outputs": {
+                        "case": "bar",
+                        "stages": {"3616274431": {"outputs": {}}},
+                    },
+                },
+            },
+        }
 
         rs = stage.set_outputs(
             stage.handler_execute({"params": {"name": "foo"}}).context, to={}
         )
-        assert rs == {"stages": {"case-stage": {"outputs": {}}}}
+        assert rs == {
+            "stages": {
+                "case-stage": {
+                    "outputs": {
+                        "case": "foo",
+                        "stages": {"4740784512": {"outputs": {}}},
+                    }
+                }
+            }
+        }
 
         rs = stage.set_outputs(
             stage.handler_execute({"params": {"name": "test"}}).context, to={}
         )
-        assert rs == {"stages": {"case-stage": {"outputs": {}}}}
+        assert rs == {
+            "stages": {
+                "case-stage": {
+                    "outputs": {
+                        "case": "_",
+                        "stages": {"5883888894": {"outputs": {}}},
+                    }
+                }
+            }
+        }
 
         # NOTE: Raise because else condition does not set.
         stage: Stage = workflow.job("first-job").stage("raise-else")
@@ -1048,8 +1075,7 @@ def test_stage_exec_case_match(test_path):
 
         stage: Stage = workflow.job("first-job").stage("not-else")
         rs = stage.set_outputs(
-            stage.handler_execute({"params": {"name": "test"}}).context,
-            to={},
+            stage.handler_execute({"params": {"name": "test"}}).context, to={}
         )
         assert rs == {
             "stages": {

{ddeutil_workflow-0.0.52 → ddeutil_workflow-0.0.53}/tests/test_workflow_exec.py

@@ -677,6 +677,104 @@ def test_workflow_exec_foreach(test_path):
         }
 
 
+def test_workflow_exec_foreach_get_inside(test_path):
+    with dump_yaml_context(
+        test_path / "conf/demo/01_99_wf_test_wf_foreach_get_inside.yml",
+        data="""
+        tmp-wf-foreach-inside:
+          type: Workflow
+          jobs:
+            transform:
+              stages:
+                - name: "Get Items before run foreach"
+                  id: get-items
+                  uses: tasks/get-items@demo
+                - name: "Create variable"
+                  id: create-variable
+                  run: |
+                    foo: str = "bar"
+                - name: "For-each item"
+                  id: foreach-stage
+                  foreach: ${{ stages.get-items.outputs.items }}
+                  stages:
+                    - name: "Echo stage"
+                      id: prepare-variable
+                      run: |
+                        foo: str = 'baz${{ item }}'
+                    - name: "Final Echo"
+                      if: ${{ item }} == 4
+                      echo: |
+                        This is the final foo, it be: ${{ stages.prepare-variable.outputs.foo }}
+        """,
+    ):
+        workflow = Workflow.from_conf(name="tmp-wf-foreach-inside")
+        rs = workflow.execute(params={})
+        assert rs.status == SUCCESS
+        assert rs.context == {
+            "params": {},
+            "jobs": {
+                "transform": {
+                    "stages": {
+                        "get-items": {"outputs": {"items": [1, 2, 3, 4]}},
+                        "create-variable": {"outputs": {"foo": "bar"}},
+                        "foreach-stage": {
+                            "outputs": {
+                                "items": [1, 2, 3, 4],
+                                "foreach": {
+                                    1: {
+                                        "item": 1,
+                                        "stages": {
+                                            "prepare-variable": {
+                                                "outputs": {"foo": "baz1"}
+                                            },
+                                            "9263488742": {
+                                                "outputs": {},
+                                                "skipped": True,
+                                            },
+                                        },
+                                    },
+                                    2: {
+                                        "item": 2,
+                                        "stages": {
+                                            "prepare-variable": {
+                                                "outputs": {"foo": "baz2"}
+                                            },
+                                            "9263488742": {
+                                                "outputs": {},
+                                                "skipped": True,
+                                            },
+                                        },
+                                    },
+                                    3: {
+                                        "item": 3,
+                                        "stages": {
+                                            "prepare-variable": {
+                                                "outputs": {"foo": "baz3"}
+                                            },
+                                            "9263488742": {
+                                                "outputs": {},
+                                                "skipped": True,
+                                            },
+                                        },
+                                    },
+                                    4: {
+                                        "item": 4,
+                                        "stages": {
+                                            "prepare-variable": {
+                                                "outputs": {"foo": "baz4"}
+                                            },
+                                            "9263488742": {"outputs": {}},
+                                        },
+                                    },
+                                },
+                            }
+                        },
+                    }
+                }
+            },
+        }
+
+
 @mock.patch.object(Config, "stage_raise_error", False)
 def test_workflow_exec_raise_param(test_path):
     with dump_yaml_context(

ddeutil_workflow-0.0.52/src/ddeutil/workflow/__about__.py

@@ -1 +0,0 @@
-__version__: str = "0.0.52"