ddeutil-workflow 0.0.69__tar.gz → 0.0.70__tar.gz

{ddeutil_workflow-0.0.69/src/ddeutil_workflow.egg-info → ddeutil_workflow-0.0.70}/PKG-INFO

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

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

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

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil/workflow/cli.py

@@ -1,17 +1,21 @@
 import json
 from pathlib import Path
 from platform import python_version
-from typing import Annotated, Any, Optional
+from typing import Annotated, Any, Literal, Optional, Union
 
 import typer
 import uvicorn
+from pydantic import Field, TypeAdapter
 
 from .__about__ import __version__
 from .__types import DictData
 from .api import app as fastapp
 from .errors import JobError
+from .event import Crontab
 from .job import Job
+from .params import Param
 from .result import Result
+from .workflow import Workflow
 
 app = typer.Typer(
     pretty_exceptions_enable=True,
@@ -129,5 +133,51 @@ def workflow_execute():
     """"""
 
 
+WORKFLOW_TYPE = Literal["Workflow"]
+
+
+class WorkflowSchema(Workflow):
+    """Override workflow model fields for generate JSON schema file."""
+
+    type: WORKFLOW_TYPE = Field(description="A type of workflow template.")
+    name: Optional[str] = Field(default=None, description="A workflow name.")
+    params: dict[str, Union[Param, str]] = Field(
+        default_factory=dict,
+        description="A parameters that need to use on this workflow.",
+    )
+    on: Union[list[Union[Crontab, str]], str] = Field(
+        default_factory=list,
+        description="A list of Crontab instance for this workflow schedule.",
+    )
+
+
+CRONTAB_TYPE = Literal["Crontab"]
+
+
+class CrontabSchema(Crontab):
+    """Override crontab model fields for generate JSON schema file."""
+
+    type: CRONTAB_TYPE = Field(description="A type of crontab template.")
+
+
+@workflow_app.command(name="json-schema")
+def workflow_json_schema(
+    output: Annotated[
+        Path,
+        typer.Option(help="An output file to export the JSON schema."),
+    ] = Path("./json-schema.json"),
+) -> None:
+    """Generate JSON schema file from the Workflow model."""
+    template = dict[str, Union[WorkflowSchema, CrontabSchema]]
+    json_schema = TypeAdapter(template).json_schema(by_alias=True)
+    template_schema: dict[str, str] = {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "title": "Workflow Configuration Schema",
+        "version": "1.0.0",
+    }
+    with open(output, mode="w", encoding="utf-8") as f:
+        json.dump(template_schema | json_schema, f, indent=2)
+
+
 if __name__ == "__main__":
     app()

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil/workflow/conf.py

@@ -327,13 +327,13 @@ class YamlParser:
         *,
         ignore_filename: Optional[str] = None,
     ) -> bool:
-        """Check this file was ignored.
+        """Check this file was ignored from the `.confignore` format.
 
         :param file: (Path) A file path that want to check.
         :param path: (Path) A config path that want to read the config
             ignore file.
         :param ignore_filename: (str) An ignore filename. Default is
-            `.confignore` filename.
+            ``.confignore`` filename.
 
         :rtype: bool
         """

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil/workflow/errors.py

@@ -38,8 +38,14 @@ def to_dict(exception: Exception, **kwargs) -> ErrorData:  # pragma: no cov
 
 
 class BaseError(Exception):
-    """Base Workflow exception class will implement the `refs` argument for
+    """Base Workflow exception class will implement the ``refs`` argument for
     making an error context to the result context.
+
+    Attributes:
+        refs: (:obj:str, optional)
+        context: (:obj:DictData)
+        params: (:obj:DictData)
+
     """
 
     def __init__(

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil/workflow/job.py

@@ -402,13 +402,19 @@ class Job(BaseModel):
         """
         # VALIDATE: Validate stage id should not duplicate.
         rs: list[str] = []
+        rs_raise: list[str] = []
         for stage in value:
             name: str = stage.iden
             if name in rs:
-                raise ValueError(
-                    f"Stage name, {name!r}, should not be duplicate."
-                )
+                rs_raise.append(name)
+                continue
             rs.append(name)
+
+        if rs_raise:
+            raise ValueError(
+                f"Stage name, {', '.join(repr(s) for s in rs_raise)}, should "
+                f"not be duplicate."
+            )
         return value
 
     @model_validator(mode="after")

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil/workflow/reusables.py

@@ -44,7 +44,7 @@ from .errors import UtilError
 T = TypeVar("T")
 P = ParamSpec("P")
 
-# NOTE: Adjust logging level of the `asyncio` to INFO level.
+# NOTE: Adjust logging level of the ``asyncio`` to INFO level.
 logging.getLogger("asyncio").setLevel(logging.INFO)
 
 

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil/workflow/traces.py

@@ -333,6 +333,124 @@ class BaseTrace(BaseModel, ABC):  # pragma: no cov
             "Adjust make message method for this trace object before using."
         )
 
+    @abstractmethod
+    def _logging(
+        self,
+        message: str,
+        mode: str,
+        *,
+        is_err: bool = False,
+    ):
+        """Write trace log with append mode and logging this message with any
+        logging level.
+
+        :param message: (str) A message that want to log.
+        :param mode: (str)
+        :param is_err: (bool)
+        """
+        raise NotImplementedError(
+            "Logging action should be implement for making trace log."
+        )
+
+    def debug(self, message: str):
+        """Write trace log with append mode and logging this message with the
+        DEBUG level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="debug")
+
+    def info(self, message: str) -> None:
+        """Write trace log with append mode and logging this message with the
+        INFO level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="info")
+
+    def warning(self, message: str) -> None:
+        """Write trace log with append mode and logging this message with the
+        WARNING level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="warning")
+
+    def error(self, message: str) -> None:
+        """Write trace log with append mode and logging this message with the
+        ERROR level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="error", is_err=True)
+
+    def exception(self, message: str) -> None:
+        """Write trace log with append mode and logging this message with the
+        EXCEPTION level.
+
+        :param message: (str) A message that want to log.
+        """
+        self._logging(message, mode="exception", is_err=True)
+
+    @abstractmethod
+    async def _alogging(
+        self,
+        message: str,
+        mode: str,
+        *,
+        is_err: bool = False,
+    ) -> None:
+        """Async write trace log with append mode and logging this message with
+        any logging level.
+
+        :param message: (str) A message that want to log.
+        :param mode: (str)
+        :param is_err: (bool)
+        """
+        raise NotImplementedError(
+            "Async Logging action should be implement for making trace log."
+        )
+
+    async def adebug(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the DEBUG level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="debug")
+
+    async def ainfo(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the INFO level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="info")
+
+    async def awarning(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the WARNING level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="warning")
+
+    async def aerror(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the ERROR level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="error", is_err=True)
+
+    async def aexception(self, message: str) -> None:  # pragma: no cov
+        """Async write trace log with append mode and logging this message with
+        the EXCEPTION level.
+
+        :param message: (str) A message that want to log.
+        """
+        await self._alogging(message, mode="exception", is_err=True)
+
 
 class ConsoleTrace(BaseTrace):  # pragma: no cov
     """Console Trace log model."""
@@ -416,7 +534,7 @@ class ConsoleTrace(BaseTrace):  # pragma: no cov
             f"{PrefixMsg.from_str(message).prepare(self.extras)}"
         )
 
-    def __logging(
+    def _logging(
         self, message: str, mode: str, *, is_err: bool = False
     ) -> None:
         """Write trace log with append mode and logging this message with any
@@ -433,47 +551,7 @@ class ConsoleTrace(BaseTrace):  # pragma: no cov
 
         getattr(logger, mode)(msg, stacklevel=3, extra={"cut_id": self.cut_id})
 
-    def debug(self, message: str):
-        """Write trace log with append mode and logging this message with the
-        DEBUG level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="debug")
-
-    def info(self, message: str) -> None:
-        """Write trace log with append mode and logging this message with the
-        INFO level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="info")
-
-    def warning(self, message: str) -> None:
-        """Write trace log with append mode and logging this message with the
-        WARNING level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="warning")
-
-    def error(self, message: str) -> None:
-        """Write trace log with append mode and logging this message with the
-        ERROR level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="error", is_err=True)
-
-    def exception(self, message: str) -> None:
-        """Write trace log with append mode and logging this message with the
-        EXCEPTION level.
-
-        :param message: (str) A message that want to log.
-        """
-        self.__logging(message, mode="exception", is_err=True)
-
-    async def __alogging(
+    async def _alogging(
         self, message: str, mode: str, *, is_err: bool = False
     ) -> None:
         """Write trace log with append mode and logging this message with any
@@ -490,46 +568,6 @@ class ConsoleTrace(BaseTrace):  # pragma: no cov
 
         getattr(logger, mode)(msg, stacklevel=3, extra={"cut_id": self.cut_id})
 
-    async def adebug(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the DEBUG level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="debug")
-
-    async def ainfo(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the INFO level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="info")
-
-    async def awarning(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the WARNING level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="warning")
-
-    async def aerror(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the ERROR level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="error", is_err=True)
-
-    async def aexception(self, message: str) -> None:  # pragma: no cov
-        """Async write trace log with append mode and logging this message with
-        the EXCEPTION level.
-
-        :param message: (str) A message that want to log.
-        """
-        await self.__alogging(message, mode="exception", is_err=True)
-
 
 class FileTrace(ConsoleTrace):  # pragma: no cov
     """File Trace dataclass that write file to the local storage."""

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil/workflow/utils.py

@@ -163,21 +163,23 @@ def gen_id(
     extras: DictData | None = None,
 ) -> str:
     """Generate running ID for able to tracking. This generates process use
-    `md5` algorithm function if `WORKFLOW_CORE_WORKFLOW_ID_SIMPLE_MODE` set
+    ``md5`` algorithm function if ``WORKFLOW_CORE_WORKFLOW_ID_SIMPLE_MODE`` set
     to false. But it will cut this hashing value length to 10 it the setting
     value set to true.
 
     Simple Mode:
 
-        ... 0000 00    00  00   00     00     000000        T   0000000000
-        ... year month day hour minute second microsecond   sep simple-id
+        ... 0000 00    00  00   00     00     000000       T    0000000000
+        ... year month day hour minute second microsecond  sep  simple-id
 
     :param value: A value that want to add to prefix before hashing with md5.
-    :param sensitive: A flag that convert the value to lower case before hashing
-    :param unique: A flag that add timestamp at microsecond level to value
-        before hashing.
-    :param simple_mode: A flag for generate ID by simple mode.
-    :param extras: An extra parameter that use for override config value.
+    :param sensitive: (bool) A flag that enable to convert the value to lower
+        case before hashing that value before generate ID.
+    :param unique: (bool) A flag that add timestamp at microsecond level to
+        value before hashing.
+    :param simple_mode: (bool | None) A flag for generate ID by simple mode.
+    :param extras: (DictData) An extra parameter that use for override config
+        value.
 
     :rtype: str
     """
@@ -212,7 +214,8 @@ def default_gen_id() -> str:
 def make_exec(path: Union[Path, str]) -> None:
     """Change mode of file to be executable file.
 
-    :param path: A file path that want to make executable permission.
+    :param path: (Path | str) A file path that want to make executable
+        permission.
     """
     f: Path = Path(path) if isinstance(path, str) else path
     f.chmod(f.stat().st_mode | stat.S_IEXEC)
@@ -285,9 +288,14 @@ def dump_all(value: T, by_alias: bool = False) -> T: ...  # pragma: no cov
 
 
 def dump_all(
-    value: Union[T, BaseModel], by_alias: bool = False
+    value: Union[T, BaseModel],
+    by_alias: bool = False,
 ) -> Union[T, DictData]:
-    """Dump all BaseModel object to dict."""
+    """Dump all nested BaseModel object to dict object.
+
+    :param value: (T | BaseModel)
+    :param by_alias: (bool)
+    """
     if isinstance(value, dict):
         return {k: dump_all(value[k], by_alias=by_alias) for k in value}
     elif isinstance(value, (list, tuple, set)):

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil/workflow/workflow.py

@@ -257,8 +257,10 @@ class Workflow(BaseModel):
                     f"{self.name!r}."
                 )
 
-            # NOTE: Set job ID to the job model.
-            self.jobs[job].id = job
+            # NOTE: Copy the job model and set job ID to the job model.
+            job_model = self.jobs[job].model_copy()
+            job_model.id = job
+            self.jobs[job] = job_model
 
         # VALIDATE: Validate workflow name should not dynamic with params
         #   template.
@@ -771,3 +773,217 @@ class Workflow(BaseModel):
                 ).to_dict(),
             },
         )
+
+    def rerun(
+        self,
+        context: DictData,
+        *,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
+        timeout: float = 3600,
+        max_job_parallel: int = 2,
+    ) -> Result:
+        """Re-Execute workflow with passing the error context data.
+
+        :param context: A context result that get the failed status.
+        :param parent_run_id: (Optional[str]) A parent workflow running ID.
+        :param event: (Event) An Event manager instance that use to cancel this
+            execution if it forces stopped by parent execution.
+        :param timeout: (float) A workflow execution time out in second unit
+            that use for limit time of execution and waiting job dependency.
+            This value does not force stop the task that still running more than
+            this limit time. (Default: 60 * 60 seconds)
+        :param max_job_parallel: (int) The maximum workers that use for job
+            execution in `ThreadPoolExecutor` object. (Default: 2 workers)
+
+        :rtype: Result
+        """
+        ts: float = time.monotonic()
+
+        result: Result = Result.construct_with_rs_or_id(
+            parent_run_id=parent_run_id,
+            id_logic=self.name,
+            extras=self.extras,
+        )
+        if context["status"] == SUCCESS:
+            result.trace.info(
+                "[WORKFLOW]: Does not rerun because it already executed with "
+                "success status."
+            )
+            return result.catch(status=SUCCESS, context=context)
+
+        err = context["errors"]
+        result.trace.info(f"[WORKFLOW]: Previous error: {err}")
+
+        event: Event = event or Event()
+        max_job_parallel: int = dynamic(
+            "max_job_parallel", f=max_job_parallel, extras=self.extras
+        )
+        result.trace.info(
+            f"[WORKFLOW]: Execute: {self.name!r} ("
+            f"{'parallel' if max_job_parallel > 1 else 'sequential'} jobs)"
+        )
+        if not self.jobs:
+            result.trace.warning(f"[WORKFLOW]: {self.name!r} does not set jobs")
+            return result.catch(status=SUCCESS, context=context)
+
+        # NOTE: Prepare the new context for rerun process.
+        jobs: DictData = context.get("jobs")
+        new_context: DictData = {
+            "params": context["params"].copy(),
+            "jobs": {j: jobs[j] for j in jobs if jobs[j]["status"] == SUCCESS},
+        }
+
+        total_job: int = 0
+        job_queue: Queue = Queue()
+        for job_id in self.jobs:
+
+            if job_id in new_context["jobs"]:
+                continue
+
+            job_queue.put(job_id)
+            total_job += 1
+
+        if total_job == 0:
+            result.trace.warning("[WORKFLOW]: It does not have job to rerun.")
+            return result.catch(status=SUCCESS, context=context)
+
+        not_timeout_flag: bool = True
+        statuses: list[Status] = [WAIT] * total_job
+        skip_count: int = 0
+        sequence_statuses: list[Status] = []
+        timeout: float = dynamic(
+            "max_job_exec_timeout", f=timeout, extras=self.extras
+        )
+
+        result.catch(status=WAIT, context=new_context)
+        if event and event.is_set():
+            return result.catch(
+                status=CANCEL,
+                context={
+                    "errors": WorkflowCancelError(
+                        "Execution was canceled from the event was set before "
+                        "workflow execution."
+                    ).to_dict(),
+                },
+            )
+
+        with ThreadPoolExecutor(max_job_parallel, "wf") as executor:
+            futures: list[Future] = []
+
+            while not job_queue.empty() and (
+                not_timeout_flag := ((time.monotonic() - ts) < timeout)
+            ):
+                job_id: str = job_queue.get()
+                job: Job = self.job(name=job_id)
+                if (check := job.check_needs(new_context["jobs"])) == WAIT:
+                    job_queue.task_done()
+                    job_queue.put(job_id)
+                    time.sleep(0.15)
+                    continue
+                elif check == FAILED:  # pragma: no cov
+                    return result.catch(
+                        status=FAILED,
+                        context={
+                            "status": FAILED,
+                            "errors": WorkflowError(
+                                f"Validate job trigger rule was failed with "
+                                f"{job.trigger_rule.value!r}."
+                            ).to_dict(),
+                        },
+                    )
+                elif check == SKIP:  # pragma: no cov
+                    result.trace.info(
+                        f"[JOB]: Skip job: {job_id!r} from trigger rule."
+                    )
+                    job.set_outputs(output={"status": SKIP}, to=new_context)
+                    job_queue.task_done()
+                    skip_count += 1
+                    continue
+
+                if max_job_parallel > 1:
+                    futures.append(
+                        executor.submit(
+                            self.execute_job,
+                            job=job,
+                            params=new_context,
+                            result=result,
+                            event=event,
+                        ),
+                    )
+                    job_queue.task_done()
+                    continue
+
+                if len(futures) < 1:
+                    futures.append(
+                        executor.submit(
+                            self.execute_job,
+                            job=job,
+                            params=new_context,
+                            result=result,
+                            event=event,
+                        )
+                    )
+                elif (future := futures.pop(0)).done():
+                    if e := future.exception():
+                        sequence_statuses.append(get_status_from_error(e))
+                    else:
+                        st, _ = future.result()
+                        sequence_statuses.append(st)
+                    job_queue.put(job_id)
+                elif future.cancelled():
+                    sequence_statuses.append(CANCEL)
+                    job_queue.put(job_id)
+                elif future.running() or "state=pending" in str(future):
+                    futures.insert(0, future)
+                    job_queue.put(job_id)
+                else:  # pragma: no cov
+                    job_queue.put(job_id)
+                    futures.insert(0, future)
+                    result.trace.warning(
+                        f"[WORKFLOW]: ... Execution non-threading not "
+                        f"handle: {future}."
+                    )
+
+                job_queue.task_done()
+
+            if not_timeout_flag:
+                job_queue.join()
+                for total, future in enumerate(as_completed(futures), start=0):
+                    try:
+                        statuses[total], _ = future.result()
+                    except WorkflowError as e:
+                        statuses[total] = get_status_from_error(e)
+
+                # NOTE: Update skipped status from the job trigger.
+                for i in range(skip_count):
+                    statuses[total + 1 + i] = SKIP
+
+                # NOTE: Update status from none-parallel job execution.
+                for i, s in enumerate(sequence_statuses, start=0):
+                    statuses[total + 1 + skip_count + i] = s
+
+                return result.catch(
+                    status=validate_statuses(statuses), context=new_context
+                )
+
+            event.set()
+            for future in futures:
+                future.cancel()
+
+            result.trace.error(
+                f"[WORKFLOW]: {self.name!r} was timeout because it use exec "
+                f"time more than {timeout} seconds."
+            )
+
+            time.sleep(0.0025)
+
+        return result.catch(
+            status=FAILED,
+            context={
+                "errors": WorkflowTimeoutError(
+                    f"{self.name!r} was timeout because it use exec time more "
+                    f"than {timeout} seconds."
+                ).to_dict(),
+            },
+        )

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70/src/ddeutil_workflow.egg-info}/PKG-INFO

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

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/src/ddeutil_workflow.egg-info/SOURCES.txt

@@ -52,4 +52,5 @@ tests/test_utils.py
 tests/test_workflow.py
 tests/test_workflow_exec.py
 tests/test_workflow_exec_job.py
-tests/test_workflow_release.py
+tests/test_workflow_release.py
+tests/test_workflow_rerun.py

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/tests/test_workflow.py

@@ -42,7 +42,10 @@ def test_workflow():
     )
 
     assert workflow.name == "manual-workflow"
-    assert workflow.job("demo-run") == job
+
+    set_job_id = job.model_copy()
+    set_job_id.id = "demo-run"
+    assert workflow.job("demo-run") == set_job_id
 
     # NOTE: Raise ValueError when get a job with ID that does not exist.
     with pytest.raises(ValueError):

{ddeutil_workflow-0.0.69 → ddeutil_workflow-0.0.70}/tests/test_workflow_exec.py

@@ -25,20 +25,21 @@ def test_workflow_exec():
         name="demo-workflow",
         jobs={"sleep-run": job, "sleep-again-run": job},
     )
+    assert all(j in workflow.jobs for j in ("sleep-run", "sleep-again-run"))
+
     rs: Result = workflow.execute(params={}, max_job_parallel=1)
     assert rs.status == SUCCESS
     assert rs.context == {
         "status": SUCCESS,
         "params": {},
         "jobs": {
+            "sleep-run": {
+                "status": SUCCESS,
+                "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},
+            },
             "sleep-again-run": {
                 "status": SUCCESS,
-                "stages": {
-                    "7972360640": {
-                        "outputs": {},
-                        "status": SUCCESS,
-                    }
-                },
+                "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},
             },
         },
     }
@@ -64,7 +65,7 @@ def test_workflow_exec_timeout():
         "status": FAILED,
         "params": {},
         "jobs": {
-            "sleep-again-run": {
+            "sleep-run": {
                 "status": CANCEL,
                 "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},
                 "errors": {
@@ -189,6 +190,10 @@ def test_workflow_exec_parallel():
         "status": SUCCESS,
         "params": {},
         "jobs": {
+            "sleep-run": {
+                "status": SUCCESS,
+                "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},
+            },
             "sleep-again-run": {
                 "status": SUCCESS,
                 "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},

ddeutil_workflow-0.0.70/tests/test_workflow_rerun.py

@@ -0,0 +1,167 @@
+from ddeutil.workflow import (
+    CANCEL,
+    FAILED,
+    SUCCESS,
+    Job,
+    Result,
+    Workflow,
+)
+
+
+def test_workflow_rerun():
+    job: Job = Job(
+        stages=[{"name": "Sleep", "run": "import time\ntime.sleep(2)"}],
+    )
+    workflow: Workflow = Workflow(
+        name="demo-workflow",
+        jobs={"sleep-run": job, "sleep-again-run": job},
+    )
+    rs: Result = workflow.rerun(
+        context={
+            "status": SUCCESS,
+            "params": {},
+            "jobs": {
+                "sleep-run": {
+                    "status": SUCCESS,
+                    "stages": {
+                        "7972360640": {"outputs": {}, "status": SUCCESS}
+                    },
+                },
+                "sleep-again-run": {
+                    "status": SUCCESS,
+                    "stages": {
+                        "7972360640": {"outputs": {}, "status": SUCCESS}
+                    },
+                },
+            },
+        },
+        max_job_parallel=1,
+    )
+    assert rs.status == SUCCESS
+    assert rs.context == {
+        "status": SUCCESS,
+        "params": {},
+        "jobs": {
+            "sleep-run": {
+                "status": SUCCESS,
+                "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},
+            },
+            "sleep-again-run": {
+                "status": SUCCESS,
+                "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},
+            },
+        },
+    }
+
+    rs: Result = workflow.rerun(
+        context={
+            "status": FAILED,
+            "params": {},
+            "jobs": {
+                "sleep-run": {
+                    "status": SUCCESS,
+                    "stages": {
+                        "7972360640": {"outputs": {}, "status": SUCCESS}
+                    },
+                },
+                "sleep-again-run": {
+                    "status": FAILED,
+                    "stages": {"7972360640": {"outputs": {}, "status": FAILED}},
+                    "errors": {
+                        "name": "DemoError",
+                        "message": "Force error in job context.",
+                    },
+                },
+            },
+            "errors": {
+                "name": "DemoError",
+                "message": "Force error in context data before rerun.",
+            },
+        },
+        max_job_parallel=1,
+    )
+    assert rs.status == SUCCESS
+    assert rs.context == {
+        "status": SUCCESS,
+        "params": {},
+        "jobs": {
+            "sleep-run": {
+                "status": SUCCESS,
+                "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},
+            },
+            "sleep-again-run": {
+                "status": SUCCESS,
+                "stages": {"7972360640": {"outputs": {}, "status": SUCCESS}},
+            },
+        },
+    }
+
+
+def test_workflow_rerun_parallel_timeout():
+    job: Job = Job(
+        stages=[
+            {"name": "Sleep", "run": "import time\ntime.sleep(2)"},
+            {"name": "Echo Last Stage", "echo": "the last stage"},
+        ],
+    )
+    workflow: Workflow = Workflow(
+        name="demo-workflow",
+        jobs={
+            "sleep-run": job,
+            "sleep-again-run": job.model_copy(update={"needs": ["sleep-run"]}),
+        },
+        extras={"stage_default_id": False},
+    )
+    rs: Result = workflow.rerun(
+        context={
+            "status": FAILED,
+            "params": {},
+            "jobs": {
+                "sleep-run": {
+                    "status": CANCEL,
+                    "stages": {},
+                    "errors": {
+                        "name": "JobCancelError",
+                        "message": (
+                            "Strategy execution was canceled from the event before "
+                            "start stage execution."
+                        ),
+                    },
+                },
+            },
+            "errors": {
+                "name": "WorkflowTimeoutError",
+                "message": (
+                    "'demo-workflow' was timeout because it use exec time more "
+                    "than 1.25 seconds."
+                ),
+            },
+        },
+        timeout=1.25,
+        max_job_parallel=2,
+    )
+    assert rs.status == FAILED
+    assert rs.context == {
+        "status": FAILED,
+        "params": {},
+        "jobs": {
+            "sleep-run": {
+                "status": CANCEL,
+                "stages": {},
+                "errors": {
+                    "name": "JobCancelError",
+                    "message": (
+                        "Strategy execution was canceled from the event before "
+                        "start stage execution."
+                    ),
+                },
+            },
+        },
+        "errors": {
+            "name": "WorkflowTimeoutError",
+            "message": (
+                "'demo-workflow' was timeout because it use exec time more "
+                "than 1.25 seconds."
+            ),
+        },
+    }

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

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