ddeutil-workflow 0.0.42__py3-none-any.whl → 0.0.44__py3-none-any.whl

ddeutil/workflow/scheduler.py

@@ -56,14 +56,13 @@ from .conf import Loader, SimLoad, config, get_logger
 from .cron import On
 from .exceptions import ScheduleException, WorkflowException
 from .logs import Audit, get_audit
-from .result import Result, Status
+from .result import SUCCESS, Result
 from .utils import batch, delay
 from .workflow import Release, ReleaseQueue, Workflow, WorkflowTask
 
 P = ParamSpec("P")
-logger = get_logger("ddeutil.workflow")
 
-# NOTE: Adjust logging level on the `schedule` package.
+logger = get_logger("ddeutil.workflow")
 logging.getLogger("schedule").setLevel(logging.INFO)
 
 
@@ -393,7 +392,7 @@ class Schedule(BaseModel):
             audit=audit,
         )
 
-        return result.catch(status=Status.SUCCESS)
+        return result.catch(status=SUCCESS)
 
 
 ResultOrCancel = Union[type[CancelJob], Result]
@@ -572,9 +571,7 @@ def schedule_task(
         f"[SCHEDULE]: End schedule task that run since "
         f"{current_date:%Y-%m-%d %H:%M:%S} {'=' * 30}"
     )
-    return result.catch(
-        status=Status.SUCCESS, context={"task_date": current_date}
-    )
+    return result.catch(status=SUCCESS, context={"task_date": current_date})
 
 
 def monitor(
@@ -690,7 +687,7 @@ def scheduler_pending(
         f"[SCHEDULE]: Queue: {[list(queue[wf].queue) for wf in queue]}"
     )
     return result.catch(
-        status=Status.SUCCESS,
+        status=SUCCESS,
         context={
             "threads": [
                 {
@@ -759,7 +756,7 @@ def schedule_control(
         audit=audit,
     )
 
-    return result.catch(status=Status.SUCCESS, context={"schedules": schedules})
+    return result.catch(status=SUCCESS, context={"schedules": schedules})
 
 
 def schedule_runner(

ddeutil/workflow/stages.py

@@ -4,18 +4,18 @@
 # license information.
 # ------------------------------------------------------------------------------
 # [x] Use dynamic config
-"""Stage Model that use for getting stage data template from the Job Model.
-The stage handle the minimize task that run in some thread (same thread at
-its job owner) that mean it is the lowest executor of a workflow that can
-tracking logs.
+"""Stage model. It stores all stage model that use for getting stage data template
+from the Job Model. The stage handle the minimize task that run in some thread
+(same thread at its job owner) that mean it is the lowest executor of a workflow
+that can tracking logs.
 
     The output of stage execution only return 0 status because I do not want to
 handle stage error on this stage model. I think stage model should have a lot of
 use-case, and it does not worry when I want to create a new one.
 
-    Execution   --> Ok      --> Result with 0
+    Execution   --> Ok      --> Result with SUCCESS
 
-                --> Error   ┬-> Result with 1 (if env var was set)
+                --> Error   ┬-> Result with FAILED (if env var was set)
                             ╰-> Raise StageException(...)
 
     On the context I/O that pass to a stage object at execute process. The
@@ -52,7 +52,7 @@ from typing_extensions import Self
 from .__types import DictData, DictStr, TupleStr
 from .conf import dynamic
 from .exceptions import StageException, to_dict
-from .result import Result, Status
+from .result import FAILED, SUCCESS, Result, Status
 from .reusables import TagFunc, extract_call, not_in_template, param2template
 from .utils import (
     gen_id,
@@ -80,6 +80,10 @@ class BaseStage(BaseModel, ABC):
         This class is the abstraction class for any stage class.
     """
 
+    extras: DictData = Field(
+        default_factory=dict,
+        description="An extra override config values.",
+    )
     id: Optional[str] = Field(
         default=None,
         description=(
@@ -95,10 +99,6 @@ class BaseStage(BaseModel, ABC):
         description="A stage condition statement to allow stage executable.",
         alias="if",
     )
-    extras: DictData = Field(
-        default_factory=dict,
-        description="An extra override config values.",
-    )
 
     @property
     def iden(self) -> str:
@@ -170,12 +170,12 @@ class BaseStage(BaseModel, ABC):
         specific environment variable,`WORKFLOW_CORE_STAGE_RAISE_ERROR`.
 
             Execution   --> Ok      --> Result
-                                        |-status: Status.SUCCESS
+                                        |-status: SUCCESS
                                         ╰-context:
                                             ╰-outputs: ...
 
                         --> Error   --> Result (if env var was set)
-                                        |-status: Status.FAILED
+                                        |-status: FAILED
                                         ╰-errors:
                                             |-class: ...
                                             |-name: ...
@@ -209,26 +209,25 @@ class BaseStage(BaseModel, ABC):
 
         try:
             rs: Result = self.execute(params, result=result, event=event)
-            if to is not None:
-                return self.set_outputs(rs.context, to=to)
-            return rs
-        except Exception as err:
-            result.trace.error(f"[STAGE]: {err.__class__.__name__}: {err}")
+            return self.set_outputs(rs.context, to=to) if to is not None else rs
+        except Exception as e:
+            result.trace.error(f"[STAGE]: {e.__class__.__name__}: {e}")
 
             if dynamic("stage_raise_error", f=raise_error, extras=self.extras):
-                if isinstance(err, StageException):
+                if isinstance(e, StageException):
                     raise
 
                 raise StageException(
                     f"{self.__class__.__name__}: \n\t"
-                    f"{err.__class__.__name__}: {err}"
-                ) from None
-
-            errors: DictData = {"errors": to_dict(err)}
-            if to is not None:
-                return self.set_outputs(errors, to=to)
-
-            return result.catch(status=Status.FAILED, context=errors)
+                    f"{e.__class__.__name__}: {e}"
+                ) from e
+
+            errors: DictData = {"errors": to_dict(e)}
+            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
@@ -315,8 +314,8 @@ class BaseStage(BaseModel, ABC):
             if not isinstance(rs, bool):
                 raise TypeError("Return type of condition does not be boolean")
             return not rs
-        except Exception as err:
-            raise StageException(f"{err.__class__.__name__}: {err}") from err
+        except Exception as e:
+            raise StageException(f"{e.__class__.__name__}: {e}") from e
 
 
 class BaseAsyncStage(BaseStage):
@@ -328,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(
@@ -393,25 +395,23 @@ class BaseAsyncStage(BaseStage):
             if to is not None:
                 return self.set_outputs(rs.context, to=to)
             return rs
-        except Exception as err:
-            await result.trace.aerror(
-                f"[STAGE]: {err.__class__.__name__}: {err}"
-            )
+        except Exception as e:
+            await result.trace.aerror(f"[STAGE]: {e.__class__.__name__}: {e}")
 
             if dynamic("stage_raise_error", f=raise_error, extras=self.extras):
-                if isinstance(err, StageException):
+                if isinstance(e, StageException):
                     raise
 
                 raise StageException(
                     f"{self.__class__.__name__}: \n\t"
-                    f"{err.__class__.__name__}: {err}"
+                    f"{e.__class__.__name__}: {e}"
                 ) from None
 
-            errors: DictData = {"errors": to_dict(err)}
+            errors: DictData = {"errors": to_dict(e)}
             if to is not None:
                 return self.set_outputs(errors, to=to)
 
-            return result.catch(status=Status.FAILED, context=errors)
+            return result.catch(status=FAILED, context=errors)
 
 
 class EmptyStage(BaseAsyncStage):
@@ -472,7 +472,7 @@ class EmptyStage(BaseAsyncStage):
                 result.trace.info(f"[STAGE]: ... sleep ({self.sleep} seconds)")
             time.sleep(self.sleep)
 
-        return result.catch(status=Status.SUCCESS)
+        return result.catch(status=SUCCESS)
 
     async def axecute(
         self,
@@ -510,7 +510,7 @@ class EmptyStage(BaseAsyncStage):
                 )
             await asyncio.sleep(self.sleep)
 
-        return result.catch(status=Status.SUCCESS)
+        return result.catch(status=SUCCESS)
 
 
 class BashStage(BaseStage):
@@ -619,17 +619,17 @@ class BashStage(BaseStage):
 
         if rs.returncode > 0:
             # NOTE: Prepare stderr message that returning from subprocess.
-            err: str = (
+            e: str = (
                 rs.stderr.encode("utf-8").decode("utf-16")
                 if "\\x00" in rs.stderr
                 else rs.stderr
             ).removesuffix("\n")
             raise StageException(
-                f"Subprocess: {err}\nRunning Statement:\n---\n"
+                f"Subprocess: {e}\nRunning Statement:\n---\n"
                 f"```bash\n{bash}\n```"
             )
         return result.catch(
-            status=Status.SUCCESS,
+            status=SUCCESS,
             context={
                 "return_code": rs.returncode,
                 "stdout": None if (out := rs.stdout.strip("\n")) == "" else out,
@@ -749,7 +749,7 @@ class PyStage(BaseStage):
         )
 
         return result.catch(
-            status=Status.SUCCESS, context={"locals": lc, "globals": gb}
+            status=SUCCESS, context={"locals": lc, "globals": gb}
         )
 
 
@@ -871,7 +871,7 @@ class CallStage(BaseStage):
                 f"Return type: '{t_func.name}@{t_func.tag}' does not serialize "
                 f"to result model, you change return type to `dict`."
             )
-        return result.catch(status=Status.SUCCESS, context=rs)
+        return result.catch(status=SUCCESS, context=rs)
 
 
 class TriggerStage(BaseStage):
@@ -999,19 +999,11 @@ class ParallelStage(BaseStage):  # pragma: no cov
                     ).context,
                     to=context,
                 )
-            except StageException as err:  # pragma: no cov
+            except StageException as e:  # pragma: no cov
                 result.trace.error(
-                    f"[STAGE]: Catch:\n\t{err.__class__.__name__}:" f"\n\t{err}"
-                )
-                context.update(
-                    {
-                        "errors": {
-                            "class": err,
-                            "name": err.__class__.__name__,
-                            "message": f"{err.__class__.__name__}: {err}",
-                        },
-                    },
+                    f"[STAGE]: Catch:\n\t{e.__class__.__name__}:" f"\n\t{e}"
                 )
+                context.update({"errors": e.to_dict()})
         return context
 
     def execute(
@@ -1041,7 +1033,7 @@ class ParallelStage(BaseStage):  # pragma: no cov
             f"[STAGE]: Parallel-Execute with {self.max_parallel_core} cores."
         )
         rs: DictData = {"parallel": {}}
-        status = Status.SUCCESS
+        status = SUCCESS
         with ThreadPoolExecutor(
             max_workers=self.max_parallel_core,
             thread_name_prefix="parallel_stage_exec_",
@@ -1065,7 +1057,7 @@ class ParallelStage(BaseStage):  # pragma: no cov
                 rs["parallel"][context.pop("branch")] = context
 
                 if "errors" in context:
-                    status = Status.FAILED
+                    status = FAILED
 
         return result.catch(status=status, context=rs)
 
@@ -1144,7 +1136,7 @@ class ForEachStage(BaseStage):
 
         result.trace.info(f"[STAGE]: Foreach-Execute: {foreach!r}.")
         rs: DictData = {"items": foreach, "foreach": {}}
-        status = Status.SUCCESS
+        status: Status = SUCCESS
         # TODO: Implement concurrent more than 1.
         for item in foreach:
             result.trace.debug(f"[STAGE]: Execute foreach item: {item!r}")
@@ -1161,21 +1153,12 @@ class ForEachStage(BaseStage):
                         ).context,
                         to=context,
                     )
-                except StageException as err:  # pragma: no cov
-                    status = Status.FAILED
+                except StageException as e:  # pragma: no cov
+                    status = FAILED
                     result.trace.error(
-                        f"[STAGE]: Catch:\n\t{err.__class__.__name__}:"
-                        f"\n\t{err}"
-                    )
-                    context.update(
-                        {
-                            "errors": {
-                                "class": err,
-                                "name": err.__class__.__name__,
-                                "message": f"{err.__class__.__name__}: {err}",
-                            },
-                        },
+                        f"[STAGE]: Catch:\n\t{e.__class__.__name__}:" f"\n\t{e}"
                     )
+                    context.update({"errors": e.to_dict()})
 
             rs["foreach"][item] = context
 
@@ -1288,7 +1271,7 @@ class CaseStage(BaseStage):  # pragma: no cov
             result: Result = Result(
                 run_id=gen_id(self.name + (self.id or ""), unique=True)
             )
-        status = Status.SUCCESS
+        status = SUCCESS
         _case = param2template(self.case, params, extras=self.extras)
         _else = None
         context = {}
@@ -1310,21 +1293,12 @@ class CaseStage(BaseStage):  # pragma: no cov
                         ).context,
                         to=context,
                     )
-                except StageException as err:  # pragma: no cov
-                    status = Status.FAILED
+                except StageException as e:  # pragma: no cov
+                    status = FAILED
                     result.trace.error(
-                        f"[STAGE]: Catch:\n\t{err.__class__.__name__}:"
-                        f"\n\t{err}"
-                    )
-                    context.update(
-                        {
-                            "errors": {
-                                "class": err,
-                                "name": err.__class__.__name__,
-                                "message": f"{err.__class__.__name__}: {err}",
-                            },
-                        },
+                        f"[STAGE]: Catch:\n\t{e.__class__.__name__}:" f"\n\t{e}"
                     )
+                    context.update({"errors": e.to_dict()})
 
         return result.catch(status=status, context=context)