ddeutil-workflow 0.0.56__py3-none-any.whl → 0.0.58__py3-none-any.whl

ddeutil/workflow/logs.py

@@ -29,7 +29,7 @@ from typing_extensions import Self
 
 from .__types import DictData, DictStr
 from .conf import config, dynamic
-from .utils import cut_id, get_dt_now
+from .utils import cut_id, get_dt_now, prepare_newline
 
 
 @lru_cache
@@ -70,16 +70,28 @@ def get_dt_tznow() -> datetime:  # pragma: no cov
     return get_dt_now(tz=config.tz)
 
 
+PREFIX_LOGS: dict[str, dict] = {
+    "CALLER": {"emoji": ""},
+    "STAGE": {"emoji": ""},
+    "JOB": {"emoji": ""},
+    "WORKFLOW": {"emoji": "🏃"},
+    "RELEASE": {"emoji": ""},
+    "POKE": {"emoji": ""},
+}  # pragma: no cov
+
+
 class TraceMeta(BaseModel):  # pragma: no cov
-    """Trace Meta model."""
+    """Trace Metadata model for making the current metadata of this CPU, Memory
+    process, and thread data.
+    """
 
-    mode: Literal["stdout", "stderr"]
-    datetime: str
-    process: int
-    thread: int
-    message: str
-    filename: str
-    lineno: int
+    mode: Literal["stdout", "stderr"] = Field(description="A meta mode.")
+    datetime: str = Field(description="A datetime in string format.")
+    process: int = Field(description="A process ID.")
+    thread: int = Field(description="A thread ID.")
+    message: str = Field(description="A message log.")
+    filename: str = Field(description="A filename of this log.")
+    lineno: int = Field(description="A line number of this log.")
 
     @classmethod
     def make(
@@ -91,6 +103,11 @@ class TraceMeta(BaseModel):  # pragma: no cov
     ) -> Self:
         """Make the current TraceMeta instance that catching local state.
 
+        :param mode: A metadata mode.
+        :param message: A message.
+        :param extras: (DictData) An extra parameter that want to override core
+            config values.
+
         :rtype: Self
         """
         frame_info: Traceback = getframeinfo(
@@ -135,11 +152,9 @@ class TraceData(BaseModel):  # pragma: no cov
         """
         data: DictStr = {"stdout": "", "stderr": "", "meta": []}
 
-        if (file / "stdout.txt").exists():
-            data["stdout"] = (file / "stdout.txt").read_text(encoding="utf-8")
-
-        if (file / "stderr.txt").exists():
-            data["stderr"] = (file / "stderr.txt").read_text(encoding="utf-8")
+        for mode in ("stdout", "stderr"):
+            if (file / f"{mode}.txt").exists():
+                data[mode] = (file / f"{mode}.txt").read_text(encoding="utf-8")
 
         if (file / "metadata.json").exists():
             data["meta"] = [
@@ -232,7 +247,7 @@ class BaseTrace(ABC):  # pragma: no cov
 
         :param message: (str) A message that want to log.
         """
-        msg: str = self.make_message(message)
+        msg: str = prepare_newline(self.make_message(message))
 
         if mode != "debug" or (
             mode == "debug" and dynamic("debug", extras=self.extras)
@@ -281,16 +296,30 @@ class BaseTrace(ABC):  # pragma: no cov
         """
         self.__logging(message, mode="exception", is_err=True)
 
+    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
+        logging level.
+
+        :param message: (str) A message that want to log.
+        """
+        msg: str = prepare_newline(self.make_message(message))
+
+        if mode != "debug" or (
+            mode == "debug" and dynamic("debug", extras=self.extras)
+        ):
+            await self.awriter(msg, is_err=is_err)
+
+        getattr(logger, mode)(msg, stacklevel=3)
+
     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 dynamic("debug", extras=self.extras):
-            await self.awriter(msg)
-        logger.info(msg, stacklevel=2)
+        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
@@ -298,9 +327,7 @@ class BaseTrace(ABC):  # pragma: no cov
 
         :param message: (str) A message that want to log.
         """
-        msg: str = self.make_message(message)
-        await self.awriter(msg)
-        logger.info(msg, stacklevel=2)
+        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
@@ -308,9 +335,7 @@ class BaseTrace(ABC):  # pragma: no cov
 
         :param message: (str) A message that want to log.
         """
-        msg: str = self.make_message(message)
-        await self.awriter(msg)
-        logger.warning(msg, stacklevel=2)
+        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
@@ -318,9 +343,7 @@ class BaseTrace(ABC):  # pragma: no cov
 
         :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)
+        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
@@ -328,9 +351,7 @@ class BaseTrace(ABC):  # pragma: no cov
 
         :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)
+        await self.__alogging(message, mode="exception", is_err=True)
 
 
 class FileTrace(BaseTrace):  # pragma: no cov
@@ -344,7 +365,7 @@ class FileTrace(BaseTrace):  # pragma: no cov
     ) -> Iterator[TraceData]:  # pragma: no cov
         """Find trace logs.
 
-        :param path: (Path)
+        :param path: (Path) A trace path that want to find.
         :param extras: An extra parameter that want to override core config.
         """
         for file in sorted(
@@ -357,16 +378,16 @@ class FileTrace(BaseTrace):  # pragma: no cov
     def find_trace_with_id(
         cls,
         run_id: str,
-        force_raise: bool = True,
         *,
+        force_raise: bool = True,
         path: Path | None = None,
         extras: Optional[DictData] = None,
     ) -> TraceData:
         """Find trace log with an input specific run ID.
 
         :param run_id: A running ID of trace log.
-        :param force_raise:
-        :param path:
+        :param force_raise: (bool)
+        :param path: (Path)
         :param extras: An extra parameter that want to override core config.
         """
         base_path: Path = path or dynamic("trace_path", extras=extras)
@@ -445,6 +466,7 @@ class FileTrace(BaseTrace):  # pragma: no cov
     async def awriter(
         self, message: str, is_err: bool = False
     ) -> None:  # pragma: no cov
+        """Write with async mode."""
         if not dynamic("enable_write_log", extras=self.extras):
             return
 
@@ -744,7 +766,7 @@ class FileAudit(BaseAudit):
 
         # NOTE: Check environ variable was set for real writing.
         if not dynamic("enable_write_audit", extras=self.extras):
-            trace.debug("[LOG]: Skip writing log cause config was set")
+            trace.debug("[AUDIT]: Skip writing log cause config was set")
             return self
 
         log_file: Path = (
@@ -813,7 +835,7 @@ class SQLiteAudit(BaseAudit):  # pragma: no cov
 
         # NOTE: Check environ variable was set for real writing.
         if not dynamic("enable_write_audit", extras=self.extras):
-            trace.debug("[LOG]: Skip writing log cause config was set")
+            trace.debug("[AUDIT]: Skip writing log cause config was set")
             return self
 
         raise NotImplementedError("SQLiteAudit does not implement yet.")

ddeutil/workflow/params.py

@@ -190,10 +190,13 @@ class IntParam(DefaultParam):
 
 
 class FloatParam(DefaultParam):  # pragma: no cov
+    """Float parameter."""
+
     type: Literal["float"] = "float"
     precision: int = 6
 
     def rounding(self, value: float) -> float:
+        """Rounding float value with the specific precision field."""
         round_str: str = f"{{0:.{self.precision}f}}"
         return float(round_str.format(round(value, self.precision)))
 
@@ -224,6 +227,7 @@ class DecimalParam(DefaultParam):  # pragma: no cov
     precision: int = 6
 
     def rounding(self, value: Decimal) -> Decimal:
+        """Rounding float value with the specific precision field."""
         return value.quantize(Decimal(10) ** -self.precision)
 
     def receive(self, value: float | Decimal | None = None) -> Decimal:

ddeutil/workflow/result.py

@@ -37,6 +37,14 @@ class Status(IntEnum):
     SKIP: int = 3
     CANCEL: int = 4
 
+    @property
+    def emoji(self) -> str:
+        """Return the emoji value of this status.
+
+        :rtype: str
+        """
+        return {0: "✅", 1: "❌", 2: "🟡", 3: "⏩", 4: "🚫"}[self.value]
+
 
 SUCCESS = Status.SUCCESS
 FAILED = Status.FAILED
@@ -46,10 +54,7 @@ CANCEL = Status.CANCEL
 
 
 @dataclass(
-    config=ConfigDict(
-        arbitrary_types_allowed=True,
-        use_enum_values=True,
-    ),
+    config=ConfigDict(arbitrary_types_allowed=True, use_enum_values=True),
 )
 class Result:
     """Result Pydantic Model for passing and receiving data context from any

ddeutil/workflow/scheduler.py

@@ -3,7 +3,6 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-# [x] Use dynamic config
 """The main schedule running is `schedule_runner` function that trigger the
 multiprocess of `schedule_control` function for listing schedules on the
 config by `Loader.finds(Schedule)`.
@@ -17,6 +16,11 @@ functions; `workflow_task`, and `workflow_monitor`.
     The `schedule_task` will run `task.release` method in threading object
 for multithreading strategy. This `release` method will run only one crontab
 value with the on field.
+
+Steps:
+    - Extract all schedule config on the conf path.
+    - Slice schedules to multiprocess
+    - Start running task.
 """
 from __future__ import annotations
 
@@ -53,7 +57,7 @@ except ImportError:  # pragma: no cov
 from .__cron import CronRunner
 from .__types import DictData, TupleStr
 from .conf import FileLoad, Loader, dynamic
-from .event import On
+from .event import Crontab
 from .exceptions import ScheduleException, WorkflowException
 from .logs import Audit, get_audit
 from .result import SUCCESS, Result
@@ -99,9 +103,9 @@ class ScheduleWorkflow(BaseModel):
         description="An alias name of workflow that use for schedule model.",
     )
     name: str = Field(description="A workflow name.")
-    on: list[On] = Field(
+    on: list[Crontab] = Field(
         default_factory=list,
-        description="An override the list of On object values.",
+        description="An override the list of Crontab object values.",
     )
     values: DictData = Field(
         default_factory=dict,
@@ -154,15 +158,17 @@ class ScheduleWorkflow(BaseModel):
         return data
 
     @field_validator("on", mode="after")
-    def __on_no_dup__(cls, value: list[On], info: ValidationInfo) -> list[On]:
+    def __on_no_dup__(
+        cls, value: list[Crontab], info: ValidationInfo
+    ) -> list[Crontab]:
         """Validate the on fields should not contain duplicate values and if it
         contains every minute value, it should have only one on value.
 
-        :param value: (list[On]) A list of `On` object.
+        :param value: (list[Crontab]) A list of `Crontab` object.
         :param info: (ValidationInfo) An validation info object for getting an
             extra parameter.
 
-        :rtype: list[On]
+        :rtype: list[Crontab]
         """
         set_ons: set[str] = {str(on.cronjob) for on in value}
         if len(set_ons) != len(value):
@@ -205,7 +211,7 @@ class ScheduleWorkflow(BaseModel):
 
         # IMPORTANT: Create the default 'on' value if it does not pass the `on`
         #   field to the Schedule object.
-        ons: list[On] = self.on or wf.on.copy()
+        ons: list[Crontab] = self.on or wf.on.copy()
         workflow_tasks: list[WorkflowTask] = []
         for on in ons:
 
@@ -699,7 +705,7 @@ def schedule_control(
     :rtype: Result
     """
     audit: type[Audit] = audit or get_audit(extras=extras)
-    result: Result = Result().set_parent_run_id(parent_run_id)
+    result: Result = Result.construct_with_rs_or_id(parent_run_id=parent_run_id)
 
     # NOTE: Create the start and stop datetime.
     start_date: datetime = datetime.now(tz=dynamic("tz", extras=extras))