ddeutil-workflow 0.0.50__py3-none-any.whl → 0.0.51__py3-none-any.whl

ddeutil/workflow/params.py

@@ -12,29 +12,17 @@ passing an input value to target execution method.
 """
 from __future__ import annotations
 
-import decimal
 from abc import ABC, abstractmethod
 from datetime import date, datetime
+from decimal import Decimal, InvalidOperation
 from typing import Annotated, Any, Literal, Optional, TypeVar, Union
 
 from ddeutil.core import str2dict, str2list
 from pydantic import BaseModel, Field
 
-from .__types import TupleStr
 from .exceptions import ParamValueException
 from .utils import get_d_now, get_dt_now
 
-__all__: TupleStr = (
-    "ChoiceParam",
-    "DatetimeParam",
-    "DateParam",
-    "IntParam",
-    "Param",
-    "StrParam",
-    "ArrayParam",
-    "MapParam",
-)
-
 T = TypeVar("T")
 
 
@@ -201,11 +189,60 @@ class IntParam(DefaultParam):
         return value
 
 
-# TODO: Not implement this parameter yet
+class FloatParam(DefaultParam):  # pragma: no cov
+    type: Literal["float"] = "float"
+    precision: int = 6
+
+    def rounding(self, value: float) -> float:
+        round_str: str = f"{{0:.{self.precision}f}}"
+        return float(round_str.format(round(value, self.precision)))
+
+    def receive(self, value: Optional[Union[float, int, str]] = None) -> float:
+
+        if value in None:
+            return self.default
+
+        if isinstance(value, float):
+            return self.rounding(value)
+        elif isinstance(value, int):
+            return self.rounding(float(value))
+        elif not isinstance(value, str):
+            raise TypeError(
+                "Received value type does not math with str, float, or int."
+            )
+
+        try:
+            return self.rounding(float(value))
+        except Exception:
+            raise
+
+
 class DecimalParam(DefaultParam):  # pragma: no cov
+    """Decimal parameter."""
+
     type: Literal["decimal"] = "decimal"
+    precision: int = 6
+
+    def rounding(self, value: Decimal) -> Decimal:
+        return value.quantize(Decimal(10) ** -self.precision)
+
+    def receive(self, value: float | Decimal | None = None) -> Decimal:
 
-    def receive(self, value: float | None = None) -> decimal.Decimal: ...
+        if isinstance(value, float):
+            return self.rounding(Decimal(value))
+        elif isinstance(value, Decimal):
+            return self.rounding(value)
+        elif not isinstance(value, str):
+            raise TypeError(
+                "Received value type does not math with str, float, or decimal."
+            )
+
+        try:
+            return self.rounding(Decimal(value))
+        except InvalidOperation as e:
+            raise ValueError(
+                "String that want to convert to decimal type does not valid."
+            ) from e
 
 
 class ChoiceParam(BaseParam):
@@ -223,7 +260,8 @@ class ChoiceParam(BaseParam):
         :rtype: str
         """
         # NOTE:
-        #   Return the first value in options if it does not pass any input value
+        #   Return the first value in options if it does not pass any input
+        #   value.
         if value is None:
             return self.options[0]
         if value not in self.options:
@@ -314,6 +352,8 @@ Param = Annotated[
         ChoiceParam,
         DatetimeParam,
         DateParam,
+        FloatParam,
+        DecimalParam,
         IntParam,
         StrParam,
     ],

ddeutil/workflow/reusables.py

@@ -400,12 +400,14 @@ DecoratorTagFunc = Callable[[Callable[[...], Any]], ReturnTagFunc]
 
 
 def tag(
-    name: str, alias: str | None = None
+    name: Optional[str] = None,
+    alias: Optional[str] = None,
 ) -> DecoratorTagFunc:  # pragma: no cov
     """Tag decorator function that set function attributes, ``tag`` and ``name``
     for making registries variable.
 
     :param: name: (str) A tag name for make different use-case of a function.
+        It will use 'latest' if this tag name does not set.
     :param: alias: (str) A alias function name that keeping in registries.
         If this value does not supply, it will use original function name
         from `__name__` argument.
@@ -414,7 +416,7 @@ def tag(
     """
 
     def func_internal(func: Callable[[...], Any]) -> ReturnTagFunc:
-        func.tag = name
+        func.tag = name or "latest"
         func.name = alias or func.__name__.replace("_", "-")
 
         @wraps(func)

ddeutil/workflow/scheduler.py

@@ -781,6 +781,7 @@ def schedule_control(
 def schedule_runner(
     stop: datetime | None = None,
     *,
+    max_process: int | None = None,
     extras: DictData | None = None,
     excluded: list[str] | None = None,
 ) -> Result:  # pragma: no cov
@@ -790,6 +791,7 @@ def schedule_runner(
     path by `WORKFLOW_APP_MAX_SCHEDULE_PER_PROCESS` value.
 
     :param stop: A stop datetime object that force stop running scheduler.
+    :param max_process: (int) The maximum process that want to run this func.
     :param extras: An extra parameter that want to override core config.
     :param excluded: A list of schedule name that want to exclude from finding.
 
@@ -813,7 +815,9 @@ def schedule_runner(
     context: DictData = {"schedules": [], "threads": []}
 
     with ProcessPoolExecutor(
-        max_workers=dynamic("max_schedule_process", extras=extras),
+        max_workers=dynamic(
+            "max_schedule_process", f=max_process, extras=extras
+        ),
     ) as executor:
 
         futures: list[Future] = [