ddeutil-workflow 0.0.43__py3-none-any.whl → 0.0.45__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.43"
+__version__: str = "0.0.45"

ddeutil/workflow/conf.py

@@ -341,6 +341,32 @@ class SimLoad:
         )
 
 
+config: Config = Config()
+api_config: APIConfig = APIConfig()
+
+
+def dynamic(
+    key: Optional[str] = None,
+    *,
+    f: Optional[T] = None,
+    extras: Optional[DictData] = None,
+) -> Optional[T]:
+    """Dynamic get config if extra value was passed at run-time.
+
+    :param key: (str) A config key that get from Config object.
+    :param f: An inner config function scope.
+    :param extras: An extra values that pass at run-time.
+    """
+    rsx: Optional[T] = extras[key] if extras and key in extras else None
+    rs: Optional[T] = f or getattr(config, key, None)
+    if rsx is not None and not isinstance(rsx, type(rs)):
+        raise TypeError(
+            f"Type of config {key!r} from extras: {rsx!r} does not valid "
+            f"as config {type(rs)}."
+        )
+    return rsx or rs
+
+
 class Loader(SimLoad):
     """Loader Object that get the config `yaml` file from current path.
 
@@ -355,6 +381,7 @@ class Loader(SimLoad):
         *,
         included: list[str] | None = None,
         excluded: list[str] | None = None,
+        path: Path | None = None,
         **kwargs,
     ) -> Iterator[tuple[str, DictData]]:
         """Override the find class method from the Simple Loader object.
@@ -362,44 +389,23 @@ class Loader(SimLoad):
         :param obj: An object that want to validate matching before return.
         :param included:
         :param excluded:
+        :param path:
 
         :rtype: Iterator[tuple[str, DictData]]
         """
         return super().finds(
             obj=obj,
-            conf_path=config.conf_path,
+            conf_path=(path or config.conf_path),
             included=included,
             excluded=excluded,
         )
 
     def __init__(self, name: str, externals: DictData) -> None:
-        super().__init__(name, conf_path=config.conf_path, externals=externals)
-
-
-config: Config = Config()
-api_config: APIConfig = APIConfig()
-
-
-def dynamic(
-    key: Optional[str] = None,
-    *,
-    f: Optional[T] = None,
-    extras: Optional[DictData] = None,
-) -> Optional[T]:
-    """Dynamic get config if extra value was passed at run-time.
-
-    :param key: (str) A config key that get from Config object.
-    :param f: An inner config function scope.
-    :param extras: An extra values that pass at run-time.
-    """
-    rsx: Optional[T] = extras[key] if extras and key in extras else None
-    rs: Optional[T] = f or getattr(config, key, None)
-    if rsx is not None and not isinstance(rsx, type(rs)):
-        raise TypeError(
-            f"Type of config {key!r} from extras: {rsx!r} does not valid "
-            f"as config {type(rs)}."
+        super().__init__(
+            name,
+            conf_path=dynamic("conf_path", extras=externals),
+            externals=externals,
         )
-    return rsx or rs
 
 
 @lru_cache

ddeutil/workflow/job.py

@@ -38,6 +38,7 @@ from .exceptions import (
     JobException,
     StageException,
     UtilException,
+    to_dict,
 )
 from .result import FAILED, SKIP, SUCCESS, WAIT, Result, Status
 from .reusables import has_template, param2template
@@ -415,6 +416,7 @@ class Job(BaseModel):
         need_exist: dict[str, Any] = {
             need: jobs[need] for need in self.needs if need in jobs
         }
+
         if len(need_exist) != len(self.needs):
             return WAIT
         elif all("skipped" in need_exist[job] for job in need_exist):
@@ -630,19 +632,6 @@ def local_execute_strategy(
         result: Result = Result(run_id=gen_id(job.id or "not-set", unique=True))
 
     strategy_id: str = gen_id(strategy)
-
-    # PARAGRAPH:
-    #
-    #       Create strategy execution context and update a matrix and copied
-    #   of params. So, the context value will have structure like;
-    #
-    #   {
-    #       "params": { ... },      <== Current input params
-    #       "jobs": { ... },        <== Current input params
-    #       "matrix": { ... }       <== Current strategy value
-    #       "stages": { ... }       <== Catching stage outputs
-    #   }
-    #
     context: DictData = copy.deepcopy(params)
     context.update({"matrix": strategy, "stages": {}})
 
@@ -650,7 +639,6 @@ def local_execute_strategy(
         result.trace.info(f"[JOB]: Execute Strategy ID: {strategy_id}")
         result.trace.info(f"[JOB]: ... Matrix: {strategy_id}")
 
-    # IMPORTANT: The stage execution only run sequentially one-by-one.
     for stage in job.stages:
 
         if stage.is_skipped(params=context):
@@ -674,34 +662,30 @@ def local_execute_strategy(
                 },
             )
 
-        # PARAGRAPH:
-        #
-        #       This step will add the stage result to `stages` key in that
-        #   stage id. It will have structure like;
-        #
-        #   {
-        #       "params": { ... },
-        #       "jobs": { ... },
-        #       "matrix": { ... },
-        #       "stages": { { "stage-id-01": { "outputs": { ... } } }, ... }
-        #   }
-        #
-        # IMPORTANT:
-        #   This execution change all stage running IDs to the current job
-        #   running ID, but it still trac log to the same parent running ID
-        #   (with passing `run_id` and `parent_run_id` to the stage
-        #   execution arguments).
-        #
         try:
-            stage.set_outputs(
-                stage.handler_execute(
-                    params=context,
-                    run_id=result.run_id,
-                    parent_run_id=result.parent_run_id,
-                    event=event,
-                ).context,
-                to=context,
+            rs: Result = stage.handler_execute(
+                params=context,
+                run_id=result.run_id,
+                parent_run_id=result.parent_run_id,
+                event=event,
             )
+            stage.set_outputs(rs.context, to=context)
+            if rs.status == FAILED:
+                error_msg: str = (
+                    f"Job strategy was break because it has a stage, "
+                    f"{stage.iden}, failed without raise error."
+                )
+                return result.catch(
+                    status=FAILED,
+                    context={
+                        strategy_id: {
+                            "matrix": strategy,
+                            "stages": context.pop("stages", {}),
+                            "errors": JobException(error_msg).to_dict(),
+                        },
+                    },
+                )
+
         except (StageException, UtilException) as err:
             result.trace.error(f"[JOB]: {err.__class__.__name__}: {err}")
             do_raise: bool = dynamic(
@@ -746,8 +730,8 @@ def local_execute(
     raise_error: bool | None = None,
 ) -> Result:
     """Local job execution with passing dynamic parameters from the workflow
-    execution. It will generate matrix values at the first step and run
-    multithread on this metrics to the `stages` field of this job.
+    execution or itself execution. It will generate matrix values at the first
+    step and run multithread on this metrics to the `stages` field of this job.
 
         This method does not raise any JobException if it runs with
     multi-threading strategy.
@@ -798,7 +782,7 @@ def local_execute(
                 raise_error=raise_error,
             )
 
-        return result.catch(status=SUCCESS)
+        return result.catch(status=result.status)
 
     fail_fast_flag: bool = job.strategy.fail_fast
     ls: str = "Fail-Fast" if fail_fast_flag else "All-Completed"
@@ -818,8 +802,6 @@ def local_execute(
             },
         )
 
-    # IMPORTANT: Start running strategy execution by multithreading because
-    #   it will run by strategy values without waiting previous execution.
     with ThreadPoolExecutor(
         max_workers=job.strategy.max_parallel,
         thread_name_prefix="job_strategy_exec_",
@@ -885,6 +867,22 @@ def self_hosted_execute(
     event: Event | None = None,
     raise_error: bool | None = None,
 ) -> Result:  # pragma: no cov
+    """Self-Hosted job execution with passing dynamic parameters from the
+    workflow execution or itself execution. It will make request to the
+    self-hosted host url.
+
+    :param job: (Job) A job model that want to execute.
+    :param params: (DictData) An input parameters that use on job execution.
+    :param run_id: (str) A job running ID for this execution.
+    :param parent_run_id: (str) A parent workflow running ID for this release.
+    :param result: (Result) A result object for keeping context and status
+        data.
+    :param event: (Event) An event manager that pass to the PoolThreadExecutor.
+    :param raise_error: (bool) A flag that all this method raise error to the
+        strategy execution.
+
+    :rtype: Result
+    """
     result: Result = Result.construct_with_rs_or_id(
         result,
         run_id=run_id,
@@ -893,14 +891,31 @@ def self_hosted_execute(
     )
 
     if event and event.is_set():
-        return result.catch(status=FAILED)
+        return result.catch(
+            status=FAILED,
+            context={
+                "errors": JobException(
+                    "Job self-hosted execution was canceled from event that "
+                    "had set before start execution."
+                ).to_dict()
+            },
+        )
 
     import requests
 
-    resp = requests.post(
-        job.runs_on.args.host,
-        data={"job": job.model_dump(), "params": params},
-    )
+    try:
+        resp = requests.post(
+            job.runs_on.args.host,
+            headers={"Auth": f"Barer {job.runs_on.args.token}"},
+            data={
+                "job": job.model_dump(),
+                "params": params,
+                "result": result.__dict__,
+                "raise_error": raise_error,
+            },
+        )
+    except requests.exceptions.RequestException as e:
+        return result.catch(status=FAILED, context={"errors": to_dict(e)})
 
     if resp.status_code != 200:
         do_raise: bool = dynamic(

ddeutil/workflow/logs.py

@@ -80,6 +80,8 @@ class TraceMeda(BaseModel):  # pragma: no cov
 
 
 class TraceData(BaseModel):  # pragma: no cov
+    """Trace Data model for keeping data for any Trace models."""
+
     stdout: str = Field(description="A standard output trace data.")
     stderr: str = Field(description="A standard error trace data.")
     meta: list[TraceMeda] = Field(
@@ -92,6 +94,12 @@ class TraceData(BaseModel):  # pragma: no cov
 
     @classmethod
     def from_path(cls, file: Path) -> Self:
+        """Construct this trace data model with a trace path.
+
+        :param file: (Path) A trace path.
+
+        :rtype: Self
+        """
         data: DictStr = {"stdout": "", "stderr": "", "meta": []}
 
         if (file / "stdout.txt").exists():
@@ -207,27 +215,52 @@ class BaseTraceLog(ABC):  # pragma: no cov
         logger.exception(msg, stacklevel=2)
 
     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.
+        """
         msg: str = self.make_message(message)
         if config.debug:
             await self.awriter(msg)
         logger.info(msg, stacklevel=2)
 
     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.
+        """
         msg: str = self.make_message(message)
         await self.awriter(msg)
         logger.info(msg, stacklevel=2)
 
     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.
+        """
         msg: str = self.make_message(message)
         await self.awriter(msg)
         logger.warning(msg, stacklevel=2)
 
     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.
+        """
         msg: str = self.make_message(message)
         await self.awriter(msg, is_err=True)
         logger.error(msg, stacklevel=2)
 
     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.
+        """
         msg: str = self.make_message(message)
         await self.awriter(msg, is_err=True)
         logger.exception(msg, stacklevel=2)
@@ -237,23 +270,29 @@ class FileTraceLog(BaseTraceLog):  # pragma: no cov
     """Trace Log object that write file to the local storage."""
 
     @classmethod
-    def find_logs(cls) -> Iterator[TraceData]:  # pragma: no cov
+    def find_logs(
+        cls, path: Path | None = None
+    ) -> Iterator[TraceData]:  # pragma: no cov
+        """Find trace logs."""
         for file in sorted(
-            config.log_path.glob("./run_id=*"),
+            (path or config.log_path).glob("./run_id=*"),
             key=lambda f: f.lstat().st_mtime,
         ):
             yield TraceData.from_path(file)
 
     @classmethod
     def find_log_with_id(
-        cls, run_id: str, force_raise: bool = True
+        cls, run_id: str, force_raise: bool = True, *, path: Path | None = None
     ) -> TraceData:
-        file: Path = config.log_path / f"run_id={run_id}"
+        """Find trace log with an input specific run ID."""
+        base_path: Path = path or config.log_path
+        file: Path = base_path / f"run_id={run_id}"
         if file.exists():
             return TraceData.from_path(file)
         elif force_raise:
             raise FileNotFoundError(
-                f"Trace log on path 'run_id={run_id}' does not found."
+                f"Trace log on path {base_path}, does not found trace "
+                f"'run_id={run_id}'."
             )
         return {}
 

ddeutil/workflow/result.py

@@ -72,6 +72,7 @@ class Result:
     ts: datetime = field(default_factory=get_dt_tznow, compare=False)
 
     trace: Optional[TraceLog] = field(default=None, compare=False, repr=False)
+    extras: DictData = field(default_factory=dict)
 
     @classmethod
     def construct_with_rs_or_id(
@@ -80,6 +81,8 @@ class Result:
         run_id: str | None = None,
         parent_run_id: str | None = None,
         id_logic: str | None = None,
+        *,
+        extras: DictData | None = None,
     ) -> Self:
         """Create the Result object or set parent running id if passing Result
         object.
@@ -88,16 +91,22 @@ class Result:
         :param run_id:
         :param parent_run_id:
         :param id_logic:
+        :param extras:
 
         :rtype: Self
         """
         if result is None:
-            result: Result = cls(
+            return cls(
                 run_id=(run_id or gen_id(id_logic or "", unique=True)),
                 parent_run_id=parent_run_id,
+                extras=(extras or {}),
             )
         elif parent_run_id:
             result.set_parent_run_id(parent_run_id)
+
+        if extras is not None:
+            result.extras.update(extras)
+
         return result
 
     @model_validator(mode="after")

ddeutil/workflow/reusables.py

@@ -499,6 +499,7 @@ class CallSearchData:
 
 def extract_call(
     call: str,
+    *,
     registries: Optional[list[str]] = None,
 ) -> Callable[[], TagFunc]:
     """Extract Call function from string value to call partial function that

ddeutil/workflow/stages.py

@@ -223,10 +223,11 @@ class BaseStage(BaseModel, ABC):
                 ) from e
 
             errors: DictData = {"errors": to_dict(e)}
-            if to is not None:
-                return self.set_outputs(errors, to=to)
-
-            return result.catch(status=FAILED, context=errors)
+            return (
+                self.set_outputs(errors, to=to)
+                if to is not None
+                else result.catch(status=FAILED, context=errors)
+            )
 
     def set_outputs(self, output: DictData, to: DictData) -> DictData:
         """Set an outputs from execution process to the received context. The
@@ -326,7 +327,10 @@ class BaseAsyncStage(BaseStage):
         *,
         result: Result | None = None,
         event: Event | None = None,
-    ) -> Result: ...
+    ) -> Result:
+        raise NotImplementedError(
+            "Async Stage should implement `execute` method."
+        )
 
     @abstractmethod
     async def axecute(

ddeutil/workflow/workflow.py

@@ -314,7 +314,8 @@ class Workflow(BaseModel):
 
         loader_data: DictData = copy.deepcopy(loader.data)
         loader_data["name"] = name.replace(" ", "_")
-        if extras:  # pragma: no cov
+
+        if extras:
             loader_data["extras"] = extras
 
         cls.__bypass_on__(loader_data, path=loader.conf_path, extras=extras)
@@ -325,6 +326,7 @@ class Workflow(BaseModel):
         cls,
         name: str,
         path: Path,
+        *,
         extras: DictData | None = None,
     ) -> Self:
         """Create Workflow instance from the specific path. The loader object
@@ -349,7 +351,8 @@ class Workflow(BaseModel):
 
         loader_data: DictData = copy.deepcopy(loader.data)
         loader_data["name"] = name.replace(" ", "_")
-        if extras:  # pragma: no cov
+
+        if extras:
             loader_data["extras"] = extras
 
         cls.__bypass_on__(loader_data, path=path, extras=extras)
@@ -981,11 +984,11 @@ class Workflow(BaseModel):
                     ).context,
                     to=params,
                 )
-        except JobException as err:
-            result.trace.error(f"[WORKFLOW]: {err.__class__.__name__}: {err}")
+        except JobException as e:
+            result.trace.error(f"[WORKFLOW]: {e.__class__.__name__}: {e}")
             if raise_error:
                 raise WorkflowException(
-                    f"Get job execution error {job_id}: JobException: {err}"
+                    f"Get job execution error {job_id}: JobException: {e}"
                 ) from None
             raise NotImplementedError(
                 "Handle error from the job execution does not support yet."
@@ -1042,16 +1045,12 @@ class Workflow(BaseModel):
         )
 
         result.trace.info(f"[WORKFLOW]: Start Execute: {self.name!r} ...")
-
-        # NOTE: It should not do anything if it does not have job.
         if not self.jobs:
             result.trace.warning(
                 f"[WORKFLOW]: {self.name!r} does not have any jobs"
             )
             return result.catch(status=SUCCESS, context=params)
 
-        # NOTE: Create a job queue that keep the job that want to run after
-        #   its dependency condition.
         jq: Queue = Queue()
         for job_id in self.jobs:
             jq.put(job_id)
@@ -1090,9 +1089,9 @@ class Workflow(BaseModel):
                     timeout=timeout,
                     event=event,
                 )
-        except WorkflowException as err:
-            status = FAILED
-            context.update({"errors": err.to_dict()})
+        except WorkflowException as e:
+            status: Status = FAILED
+            context.update({"errors": e.to_dict()})
 
         return result.catch(status=status, context=context)
 
@@ -1149,7 +1148,8 @@ class Workflow(BaseModel):
                     continue
                 elif check == FAILED:  # pragma: no cov
                     raise WorkflowException(
-                        "Check job trigger rule was failed."
+                        f"Validate job trigger rule was failed with "
+                        f"{job.trigger_rule.value!r}."
                     )
                 elif check == SKIP:  # pragma: no cov
                     result.trace.info(f"[JOB]: Skip job: {job_id!r}")
@@ -1157,16 +1157,6 @@ class Workflow(BaseModel):
                     job_queue.task_done()
                     continue
 
-                # NOTE: Start workflow job execution with deep copy context data
-                #   before release.
-                #
-                #   Context:
-                #   ---
-                #   {
-                #       'params': <input-params>,
-                #       'jobs': { <job's-id>: ... },
-                #   }
-                #
                 futures.append(
                     executor.submit(
                         self.execute_job,
@@ -1177,19 +1167,14 @@ class Workflow(BaseModel):
                     ),
                 )
 
-                # NOTE: Mark this job queue done.
                 job_queue.task_done()
 
             if not_timeout_flag:
-
-                # NOTE: Wait for all items to finish processing by `task_done()`
-                #   method.
                 job_queue.join()
-
                 for future in as_completed(futures, timeout=thread_timeout):
-                    if err := future.exception():
-                        result.trace.error(f"[WORKFLOW]: {err}")
-                        raise WorkflowException(str(err))
+                    if e := future.exception():
+                        result.trace.error(f"[WORKFLOW]: {e}")
+                        raise WorkflowException(str(e))
 
                     future.result()
 
@@ -1235,78 +1220,74 @@ class Workflow(BaseModel):
             "max_job_exec_timeout", f=timeout, extras=self.extras
         )
         event: Event = event or Event()
-        future: Future | None = None
         result.trace.debug(f"[WORKFLOW]: Run {self.name!r} with non-threading.")
-
-        executor = ThreadPoolExecutor(
+        with ThreadPoolExecutor(
             max_workers=1,
             thread_name_prefix="wf_exec_non_threading_",
-        )
+        ) as executor:
+            future: Future | None = None
 
-        while not job_queue.empty() and (
-            not_timeout_flag := ((time.monotonic() - ts) < timeout)
-        ):
-            job_id: str = job_queue.get()
-            job: Job = self.jobs[job_id]
+            while not job_queue.empty() and (
+                not_timeout_flag := ((time.monotonic() - ts) < timeout)
+            ):
+                job_id: str = job_queue.get()
+                job: Job = self.jobs[job_id]
 
-            if (check := job.check_needs(context["jobs"])) == WAIT:
-                job_queue.task_done()
-                job_queue.put(job_id)
-                time.sleep(0.075)
-                continue
-            elif check == FAILED:  # pragma: no cov
-                raise WorkflowException("Check job trigger rule was failed.")
-            elif check == SKIP:  # pragma: no cov
-                result.trace.info(f"[JOB]: Skip job: {job_id!r}")
-                job.set_outputs({"SKIP": {"skipped": True}}, to=context)
-                job_queue.task_done()
-                continue
+                if (check := job.check_needs(context["jobs"])) == WAIT:
+                    job_queue.task_done()
+                    job_queue.put(job_id)
+                    time.sleep(0.075)
+                    continue
+                elif check == FAILED:
+                    raise WorkflowException(
+                        f"Validate job trigger rule was failed with "
+                        f"{job.trigger_rule.value!r}."
+                    )
+                elif check == SKIP:  # pragma: no cov
+                    result.trace.info(f"[JOB]: Skip job: {job_id!r}")
+                    job.set_outputs({"SKIP": {"skipped": True}}, to=context)
+                    job_queue.task_done()
+                    continue
 
-            # NOTE: Start workflow job execution with deep copy context data
-            #   before release. This job execution process will run until
-            #   done before checking all execution timeout or not.
-            #
-            #   {
-            #       'params': <input-params>,
-            #       'jobs': {},
-            #   }
-            if future is None:
-                future: Future = executor.submit(
-                    self.execute_job,
-                    job_id=job_id,
-                    params=context,
-                    result=result,
-                    event=event,
-                )
-                result.trace.debug(f"[WORKFLOW]: Make future: {future}")
-                time.sleep(0.025)
-            elif future.done():
-                if err := future.exception():
-                    result.trace.error(f"[WORKFLOW]: {err}")
-                    raise WorkflowException(str(err))
-
-                future = None
-                job_queue.put(job_id)
-            elif future.running():
-                time.sleep(0.075)
-                job_queue.put(job_id)
-            else:  # pragma: no cov
-                job_queue.put(job_id)
-                result.trace.debug(
-                    f"Execution non-threading does not handle case: {future} "
-                    f"that not running."
-                )
+                if future is None:
+                    future: Future = executor.submit(
+                        self.execute_job,
+                        job_id=job_id,
+                        params=context,
+                        result=result,
+                        event=event,
+                    )
+                    time.sleep(0.025)
+                elif future.done():
+                    if e := future.exception():
+                        result.trace.error(f"[WORKFLOW]: {e}")
+                        raise WorkflowException(str(e))
 
-            job_queue.task_done()
+                    future = None
+                    job_queue.put(job_id)
+                elif future.running():
+                    time.sleep(0.075)
+                    job_queue.put(job_id)
+                else:  # pragma: no cov
+                    job_queue.put(job_id)
+                    result.trace.debug(
+                        f"Execution non-threading does not handle case: {future} "
+                        f"that not running."
+                    )
+
+                job_queue.task_done()
+
+            if not_timeout_flag:
+                job_queue.join()
+                return context
 
-        if not_timeout_flag:
-            job_queue.join()
-            executor.shutdown()
-            return context
+            result.trace.error(
+                f"[WORKFLOW]: Execution: {self.name!r} was timeout."
+            )
+            event.set()
+            if future:
+                future.cancel()
 
-        result.trace.error(f"[WORKFLOW]: Execution: {self.name!r} was timeout.")
-        event.set()
-        executor.shutdown()
         raise WorkflowException(f"Execution: {self.name!r} was timeout.")
 
 

{ddeutil_workflow-0.0.43.dist-info → ddeutil_workflow-0.0.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.43
+Version: 0.0.45
 Summary: Lightweight workflow orchestration
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -30,7 +30,6 @@ Requires-Dist: schedule<2.0.0,==1.2.2
 Provides-Extra: all
 Requires-Dist: fastapi<1.0.0,>=0.115.0; extra == "all"
 Requires-Dist: httpx; extra == "all"
-Requires-Dist: ujson; extra == "all"
 Requires-Dist: aiofiles; extra == "all"
 Requires-Dist: aiohttp; extra == "all"
 Provides-Extra: api
@@ -71,9 +70,9 @@ configuration. It called **Metadata Driven Data Workflow**.
 
 **:pushpin: <u>Rules of This Workflow engine</u>**:
 
-1. The Minimum frequency unit of scheduling is **1 Minute** 🕘
+1. The Minimum frequency unit of built-in scheduling is **1 Minute** 🕘
 2. **Can not** re-run only failed stage and its pending downstream ↩️
-3. All parallel tasks inside workflow engine use **Multi-Threading**
+3. All parallel tasks inside workflow core engine use **Multi-Threading** pool
    (Python 3.13 unlock GIL 🐍🔓)
 
 ---
@@ -266,11 +265,11 @@ it will use default value and do not raise any error to you.
 | **ROOT_PATH**                |   Core    | `.`                                                                                                                             |    No    | The root path of the workflow application.                                                                         |
 | **REGISTRY_CALLER**          |   Core    | `.`                                                                                                                             |   Yes    | List of importable string for the call stage.                                                                      |
 | **REGISTRY_FILTER**          |   Core    | `ddeutil.workflow.templates`                                                                                                    |   Yes    | List of importable string for the filter template.                                                                 |
-| **CONF_PATH**                |   Core    | `conf`                                                                                                                          |    No    | The config path that keep all template `.yaml` files.                                                              |
+| **CONF_PATH**                |   Core    | `conf`                                                                                                                          |   Yes    | The config path that keep all template `.yaml` files.                                                              |
 | **TIMEZONE**                 |   Core    | `Asia/Bangkok`                                                                                                                  |    No    | A Timezone string value that will pass to `ZoneInfo` object.                                                       |
-| **STAGE_DEFAULT_ID**         |   Core    | `true`                                                                                                                          |    No    | A flag that enable default stage ID that use for catch an execution output.                                        |
+| **STAGE_DEFAULT_ID**         |   Core    | `true`                                                                                                                          |   Yes    | A flag that enable default stage ID that use for catch an execution output.                                        |
 | **STAGE_RAISE_ERROR**        |   Core    | `false`                                                                                                                         |   Yes    | A flag that all stage raise StageException from stage execution.                                                   |
-| **JOB_DEFAULT_ID**           |   Core    | `false`                                                                                                                         |    No    | A flag that enable default job ID that use for catch an execution output. The ID that use will be sequence number. |
+| **JOB_DEFAULT_ID**           |   Core    | `false`                                                                                                                         |   Yes    | A flag that enable default job ID that use for catch an execution output. The ID that use will be sequence number. |
 | **JOB_RAISE_ERROR**          |   Core    | `true`                                                                                                                          |   Yes    | A flag that all job raise JobException from job strategy execution.                                                |
 | **MAX_CRON_PER_WORKFLOW**    |   Core    | `5`                                                                                                                             |    No    |                                                                                                                    |
 | **MAX_QUEUE_COMPLETE_HIST**  |   Core    | `16`                                                                                                                            |    No    |                                                                                                                    |

{ddeutil_workflow-0.0.43.dist-info → ddeutil_workflow-0.0.45.dist-info}/RECORD

@@ -1,19 +1,19 @@
-ddeutil/workflow/__about__.py,sha256=feByUkEJfWx0d1Lb9oGvd2f3clHHuGXDT7T7Ki5zoEA,28
+ddeutil/workflow/__about__.py,sha256=SRGMEfbOwgNFzpR_XZJUPWxcNUSIkcCKp1M3mCR6pQk,28
 ddeutil/workflow/__cron.py,sha256=h8rLeIUAAEB2SdZ4Jhch7LU1Yl3bbJ-iNNJ3tQ0eYVM,28095
 ddeutil/workflow/__init__.py,sha256=m7ZTCuUOarcTKJuXOyuaXd5WTIO7NTkqCeCrNX3d5i8,1943
 ddeutil/workflow/__types.py,sha256=8jBdbfb3aZSetjz0mvNrpGHwwxJff7mK8_4v41cLqlc,4316
-ddeutil/workflow/conf.py,sha256=lDzWiVSNlNAhTzxbNIhIbQAIF1ggbmetAp0yn2fgnsc,12385
+ddeutil/workflow/conf.py,sha256=n8grMRUVMtZFFc0J0g0wwG7JpDbvzpQcLoRehca1Qnk,12519
 ddeutil/workflow/cron.py,sha256=80SijzMdDOBxTWRsiF-Fmuz7Ym7leY0XT2lzRAPGdXc,8781
 ddeutil/workflow/exceptions.py,sha256=uLNxzav3HRcr4vaZnvbUIF_eTR6UXXZNaxroMWFOUL4,1418
-ddeutil/workflow/job.py,sha256=6CqLb1F_z3mHU_rOVRY7Z2V2B1tY3p7FZIJgb8DM1YE,29969
-ddeutil/workflow/logs.py,sha256=RkM5o_JPoWhFY7NrbYAARZQWjLC62YB_FYzTTcyDp8U,19816
+ddeutil/workflow/job.py,sha256=NgEPgMAUL2mqDctLpdoEVx4g0ZsTj4RmkQluCh_ZUdM,30614
+ddeutil/workflow/logs.py,sha256=Ki1t6HkThwimzAe1OSxPPc7OQ4r-kXAc1kB63x2DsOg,21160
 ddeutil/workflow/params.py,sha256=xCtFEh0-G-G-f8y_SXxyf31bU6Ox5p5Z-WbBFXrjy8M,9960
-ddeutil/workflow/result.py,sha256=iwkUzOubxhLCuO-ngWEWL6t-CpYBpINIIO_ubg4kz14,4701
-ddeutil/workflow/reusables.py,sha256=AtZO83HDFu1uK_azUinv5d8jsA36f2i3n_tqMrolbvc,17529
+ddeutil/workflow/result.py,sha256=9tbCmP0Sjy7h9GKWyD5e1bjAzNOWZcnvBFuC6to_f-8,4929
+ddeutil/workflow/reusables.py,sha256=ZE8WfD0WyQUKRV5aujJpGG6g6ODJz-wtgwHbQiCrN-E,17536
 ddeutil/workflow/scheduler.py,sha256=_MDsEHbBVOeF-381U8DfIMDyca_nG3XNXmgX4229_EU,27437
-ddeutil/workflow/stages.py,sha256=RMyOU9KqPhS-49kQduT6-iysGJZFwX0Cbgo9o8kzIAY,47304
+ddeutil/workflow/stages.py,sha256=cvSNt4IjbE4O9llCIL2bojnl4W50GHNa1ANQ4oGefUo,47438
 ddeutil/workflow/utils.py,sha256=sblje9qOtejCHVt8EVrbC0KY98vKqvxccaR5HIkRiTA,7363
-ddeutil/workflow/workflow.py,sha256=LPZzGNf55Tca0XXQZytTiyWbocC1T47cB_XsWpiXdyc,50482
+ddeutil/workflow/workflow.py,sha256=Pkm2e7Edph3l7ITjo3iTtvpbXmKD_fCeq7HrxdV0KAo,49708
 ddeutil/workflow/api/__init__.py,sha256=F53NMBWtb9IKaDWkPU5KvybGGfKAcbehgn6TLBwHuuM,21
 ddeutil/workflow/api/api.py,sha256=b-bMg0aRsEqt8Qb2hNUtamEt2Fq2CgNotF2oXSAdDu8,5226
 ddeutil/workflow/api/log.py,sha256=NMTnOnsBrDB5129329xF2myLdrb-z9k1MQrmrP7qXJw,1818
@@ -23,8 +23,8 @@ ddeutil/workflow/api/routes/job.py,sha256=YVta083i8vU8-o4WdKFwDpfdC9vN1dZ6goZSmN
 ddeutil/workflow/api/routes/logs.py,sha256=TeRDrEelbKS2Hu_EovgLh0bOdmSv9mfnrIZsrE7uPD4,5353
 ddeutil/workflow/api/routes/schedules.py,sha256=rUWBm5RgLS1PNBHSWwWXJ0l-c5mYWfl9os0BA9_OTEw,4810
 ddeutil/workflow/api/routes/workflows.py,sha256=ctgQGxXfpIV6bHFDM9IQ1_qaQHT6n5-HjJ1-D4GKWpc,4527
-ddeutil_workflow-0.0.43.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.43.dist-info/METADATA,sha256=eOwkhUh-w_bSW0LOlOCielBQTg0mvf2gEkkNMlbwIU4,19134
-ddeutil_workflow-0.0.43.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ddeutil_workflow-0.0.43.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.43.dist-info/RECORD,,
+ddeutil_workflow-0.0.45.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.45.dist-info/METADATA,sha256=4i4i_79_2HjUuyzyB6LWhP2wEKh3xifSfiDf8o_bENY,19116
+ddeutil_workflow-0.0.45.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ddeutil_workflow-0.0.45.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.45.dist-info/RECORD,,