ddeutil-workflow 0.0.22__py3-none-any.whl → 0.0.24__py3-none-any.whl

ddeutil/workflow/stage.py

@@ -51,9 +51,9 @@ from typing_extensions import Self
 from .__types import DictData, DictStr, Re, TupleStr
 from .conf import config, get_logger
 from .exceptions import StageException
+from .result import Result
 from .utils import (
     Registry,
-    Result,
     TagFunc,
     cut_id,
     gen_id,
@@ -346,6 +346,11 @@ class EmptyStage(BaseStage):
             f"( {param2template(self.echo, params=params) or '...'} )"
         )
         if self.sleep > 0:
+            if self.sleep > 30:
+                logger.info(
+                    f"({cut_id(run_id)}) [STAGE]: ... sleep "
+                    f"({self.sleep} seconds)"
+                )
             time.sleep(self.sleep)
         return Result(status=0, context={}, run_id=run_id)
 

ddeutil/workflow/utils.py

@@ -9,11 +9,9 @@ import inspect
 import logging
 import stat
 import time
-from abc import ABC, abstractmethod
 from ast import Call, Constant, Expr, Module, Name, parse
 from collections.abc import Iterator
-from dataclasses import field
-from datetime import date, datetime, timedelta
+from datetime import datetime, timedelta
 from functools import wraps
 from hashlib import md5
 from importlib import import_module
@@ -21,7 +19,7 @@ from inspect import isfunction
 from itertools import chain, islice, product
 from pathlib import Path
 from random import randrange
-from typing import Any, Callable, Literal, Optional, Protocol, TypeVar, Union
+from typing import Any, Callable, Protocol, TypeVar, Union
 from zoneinfo import ZoneInfo
 
 try:
@@ -31,14 +29,11 @@ except ImportError:
 
 from ddeutil.core import getdot, hasdot, hash_str, import_string, lazy
 from ddeutil.io import search_env_replace
-from pydantic import BaseModel, Field
-from pydantic.dataclasses import dataclass
-from pydantic.functional_validators import model_validator
-from typing_extensions import Self
+from pydantic import BaseModel
 
 from .__types import DictData, Matrix, Re
 from .conf import config
-from .exceptions import ParamValueException, UtilException
+from .exceptions import UtilException
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -198,238 +193,6 @@ def make_registry(submodule: str) -> dict[str, Registry]:
     return rs
 
 
-class BaseParam(BaseModel, ABC):
-    """Base Parameter that use to make Params Model."""
-
-    desc: Optional[str] = Field(
-        default=None, description="A description of parameter providing."
-    )
-    required: bool = Field(
-        default=True,
-        description="A require flag that force to pass this parameter value.",
-    )
-    type: str = Field(description="A type of parameter.")
-
-    @abstractmethod
-    def receive(self, value: Optional[Any] = None) -> Any:
-        raise NotImplementedError(
-            "Receive value and validate typing before return valid value."
-        )
-
-
-class DefaultParam(BaseParam):
-    """Default Parameter that will check default if it required. This model do
-    not implement the receive method.
-    """
-
-    required: bool = Field(
-        default=False,
-        description="A require flag for the default-able parameter value.",
-    )
-    default: Optional[str] = Field(
-        default=None,
-        description="A default value if parameter does not pass.",
-    )
-
-    @abstractmethod
-    def receive(self, value: Optional[Any] = None) -> Any:
-        raise NotImplementedError(
-            "Receive value and validate typing before return valid value."
-        )
-
-
-class DatetimeParam(DefaultParam):
-    """Datetime parameter."""
-
-    type: Literal["datetime"] = "datetime"
-    default: datetime = Field(default_factory=get_dt_now)
-
-    def receive(self, value: str | datetime | date | None = None) -> datetime:
-        """Receive value that match with datetime. If a input value pass with
-        None, it will use default value instead.
-
-        :param value: A value that want to validate with datetime parameter
-            type.
-        :rtype: datetime
-        """
-        if value is None:
-            return self.default
-
-        if isinstance(value, datetime):
-            return value
-        elif isinstance(value, date):
-            return datetime(value.year, value.month, value.day)
-        elif not isinstance(value, str):
-            raise ParamValueException(
-                f"Value that want to convert to datetime does not support for "
-                f"type: {type(value)}"
-            )
-        try:
-            return datetime.fromisoformat(value)
-        except ValueError:
-            raise ParamValueException(
-                f"Invalid isoformat string: {value!r}"
-            ) from None
-
-
-class StrParam(DefaultParam):
-    """String parameter."""
-
-    type: Literal["str"] = "str"
-
-    def receive(self, value: str | None = None) -> str | None:
-        """Receive value that match with str.
-
-        :param value: A value that want to validate with string parameter type.
-        :rtype: str | None
-        """
-        if value is None:
-            return self.default
-        return str(value)
-
-
-class IntParam(DefaultParam):
-    """Integer parameter."""
-
-    type: Literal["int"] = "int"
-    default: Optional[int] = Field(
-        default=None,
-        description="A default value if parameter does not pass.",
-    )
-
-    def receive(self, value: int | None = None) -> int | None:
-        """Receive value that match with int.
-
-        :param value: A value that want to validate with integer parameter type.
-        :rtype: int | None
-        """
-        if value is None:
-            return self.default
-        if not isinstance(value, int):
-            try:
-                return int(str(value))
-            except ValueError as err:
-                raise ParamValueException(
-                    f"Value can not convert to int, {value}, with base 10"
-                ) from err
-        return value
-
-
-class ChoiceParam(BaseParam):
-    """Choice parameter."""
-
-    type: Literal["choice"] = "choice"
-    options: list[str] = Field(description="A list of choice parameters.")
-
-    def receive(self, value: str | None = None) -> str:
-        """Receive value that match with options.
-
-        :param value: A value that want to select from the options field.
-        :rtype: str
-        """
-        # NOTE:
-        #   Return the first value in options if does not pass any input value
-        if value is None:
-            return self.options[0]
-        if value not in self.options:
-            raise ParamValueException(
-                f"{value!r} does not match any value in choice options."
-            )
-        return value
-
-
-Param = Union[
-    ChoiceParam,
-    DatetimeParam,
-    IntParam,
-    StrParam,
-]
-
-
-@dataclass
-class Result:
-    """Result Pydantic Model for passing and receiving data context from any
-    module execution process like stage execution, job execution, or workflow
-    execution.
-
-        For comparison property, this result will use ``status``, ``context``,
-    and ``_run_id`` fields to comparing with other result instance.
-    """
-
-    status: int = field(default=2)
-    context: DictData = field(default_factory=dict)
-
-    # NOTE: Ignore this field to compare another result model with __eq__.
-    run_id: Optional[str] = field(default=None)
-    parent_run_id: Optional[str] = field(default=None, compare=False)
-
-    @model_validator(mode="after")
-    def __prepare_run_id(self) -> Self:
-        """Prepare running ID which use default ID if it initialize at the first
-        time
-
-        :rtype: Self
-        """
-        self._run_id = gen_id("manual", unique=True)
-        return self
-
-    def set_run_id(self, running_id: str) -> Self:
-        """Set a running ID.
-
-        :param running_id: A running ID that want to update on this model.
-        :rtype: Self
-        """
-        self.run_id = running_id
-        return self
-
-    def set_parent_run_id(self, running_id: str) -> Self:
-        """Set a parent running ID.
-
-        :param running_id: A running ID that want to update on this model.
-        :rtype: Self
-        """
-        self.parent_run_id: str = running_id
-        return self
-
-    def catch(self, status: int, context: DictData) -> Self:
-        """Catch the status and context to current data."""
-        self.__dict__["status"] = status
-        self.__dict__["context"].update(context)
-        return self
-
-    def receive(self, result: Result) -> Self:
-        """Receive context from another result object.
-
-        :rtype: Self
-        """
-        self.__dict__["status"] = result.status
-        self.__dict__["context"].update(result.context)
-
-        # NOTE: Update running ID from an incoming result.
-        self.parent_run_id = result.parent_run_id
-        self.run_id = result.run_id
-        return self
-
-    def receive_jobs(self, result: Result) -> Self:
-        """Receive context from another result object that use on the workflow
-        execution which create a ``jobs`` keys on the context if it do not
-        exist.
-
-        :rtype: Self
-        """
-        self.__dict__["status"] = result.status
-
-        # NOTE: Check the context has jobs key.
-        if "jobs" not in self.__dict__["context"]:
-            self.__dict__["context"]["jobs"] = {}
-        self.__dict__["context"]["jobs"].update(result.context)
-
-        # NOTE: Update running ID from an incoming result.
-        self.parent_run_id: str = result.parent_run_id
-        self.run_id: str = result.run_id
-        return self
-
-
 def make_exec(path: str | Path) -> None:
     """Change mode of file to be executable file.
 
@@ -814,10 +577,6 @@ def batch(iterable: Iterator[Any], n: int) -> Iterator[Any]:
         yield chain((first_el,), chunk_it)
 
 
-def queue2str(queue: list[datetime]) -> Iterator[str]:  # pragma: no cov
-    return (f"{q:%Y-%m-%d %H:%M:%S}" for q in queue)
-
-
 def cut_id(run_id: str, *, num: int = 6):
     """Cutting running ID with length.