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

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.50"
+__version__: str = "0.0.51"

ddeutil/workflow/__init__.py

@@ -11,25 +11,9 @@ from .conf import (
     config,
     env,
 )
-from .cron import (
-    On,
-    YearOn,
-    interval2crontab,
-)
-from .exceptions import (
-    JobException,
-    ParamValueException,
-    StageException,
-    UtilException,
-    WorkflowException,
-)
-from .job import (
-    Job,
-    RunsOn,
-    Strategy,
-    local_execute,
-    local_execute_strategy,
-)
+from .cron import *
+from .exceptions import *
+from .job import *
 from .logs import (
     Audit,
     AuditModel,
@@ -41,13 +25,7 @@ from .logs import (
     get_dt_tznow,
     get_trace,
 )
-from .params import (
-    ChoiceParam,
-    DatetimeParam,
-    IntParam,
-    Param,
-    StrParam,
-)
+from .params import *
 from .result import (
     CANCEL,
     FAILED,

ddeutil/workflow/conf.py

@@ -360,13 +360,13 @@ def dynamic(
     :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)
+    rs: Optional[T] = getattr(config, key, None) if f is None else f
     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
+    return rsx if rsx is not None else rs
 
 
 class Loader(SimLoad):

ddeutil/workflow/cron.py

@@ -16,18 +16,13 @@ from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
 from .__cron import WEEKDAYS, CronJob, CronJobYear, CronRunner, Options
-from .__types import DictData, DictStr, TupleStr
+from .__types import DictData, DictStr
 from .conf import Loader
 
-__all__: TupleStr = (
-    "On",
-    "YearOn",
-    "interval2crontab",
-)
-
 
 def interval2crontab(
     interval: Literal["daily", "weekly", "monthly"],
+    *,
     day: str | None = None,
     time: str = "00:00",
 ) -> str:
@@ -67,7 +62,7 @@ class On(BaseModel):
     """On Pydantic model (Warped crontab object by model).
 
     See Also:
-        * ``generate()`` is the main use-case of this schedule object.
+        * `generate()` is the main use-case of this schedule object.
     """
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -76,12 +71,18 @@ class On(BaseModel):
         DictData,
         Field(
             default_factory=dict,
-            description="An extras mapping parameters.",
+            description=(
+                "An extras parameters that want to pass to the CronJob field."
+            ),
         ),
     ]
     cronjob: Annotated[
         CronJob,
-        Field(description="A Cronjob object of this schedule."),
+        Field(
+            description=(
+                "A Cronjob object that use for validate and generate datetime.",
+            ),
+        ),
     ]
     tz: Annotated[
         str,
@@ -118,6 +119,8 @@ class On(BaseModel):
 
         :param name: A name of config that will get from loader.
         :param extras: An extra parameter that will keep in extras.
+
+        :rtype: Self
         """
         extras: DictData = extras or {}
         loader: Loader = Loader(name, externals=extras)
@@ -142,9 +145,7 @@ class On(BaseModel):
                 )
             )
         if "cronjob" not in loader_data:
-            raise ValueError(
-                "Config does not set ``cronjob`` or ``interval`` keys"
-            )
+            raise ValueError("Config does not set `cronjob` or `interval` keys")
         return cls.model_validate(
             obj=dict(
                 cronjob=loader_data.pop("cronjob"),
@@ -155,7 +156,13 @@ class On(BaseModel):
 
     @model_validator(mode="before")
     def __prepare_values(cls, values: DictData) -> DictData:
-        """Extract tz key from value and change name to timezone key."""
+        """Extract tz key from value and change name to timezone key.
+
+        :param values: (DictData) A data that want to pass for create an On
+            model.
+
+        :rtype: DictData
+        """
         if tz := values.pop("tz", None):
             values["timezone"] = tz
         return values
@@ -170,8 +177,8 @@ class On(BaseModel):
         try:
             _ = ZoneInfo(value)
             return value
-        except ZoneInfoNotFoundError as err:
-            raise ValueError(f"Invalid timezone: {value}") from err
+        except ZoneInfoNotFoundError as e:
+            raise ValueError(f"Invalid timezone: {value}") from e
 
     @field_validator(
         "cronjob", mode="before", json_schema_input_type=Union[CronJob, str]
@@ -180,9 +187,13 @@ class On(BaseModel):
         cls, value: str | CronJob, info: ValidationInfo
     ) -> CronJob:
         """Prepare crontab value that able to receive with string type.
-        This step will get options kwargs from extras and pass to the
+        This step will get options kwargs from extras field and pass to the
         CronJob object.
 
+        :param value: (str | CronJobYear) A cronjob value that want to create.
+        :param info: (ValidationInfo) A validation info object that use to get
+            the extra parameters for create cronjob.
+
         :rtype: CronJob
         """
         extras: DictData = info.data.get("extras", {})
@@ -203,12 +214,17 @@ class On(BaseModel):
     def __serialize_cronjob(self, value: CronJob) -> str:
         """Serialize the cronjob field that store with CronJob object.
 
+        :param value: (CronJob) The CronJob field.
+
         :rtype: str
         """
         return str(value)
 
     def generate(self, start: str | datetime) -> CronRunner:
-        """Return Cron runner object.
+        """Return CronRunner object from an initial datetime.
+
+        :param start: (str | datetime) A string or datetime for generate the
+            CronRunner object.
 
         :rtype: CronRunner
         """
@@ -242,16 +258,26 @@ class YearOn(On):
     # NOTE: This is fields of the base schedule.
     cronjob: Annotated[
         CronJobYear,
-        Field(description="Cron job of this schedule"),
+        Field(
+            description=(
+                "A Cronjob object that use for validate and generate datetime.",
+            ),
+        ),
     ]
 
     @field_validator(
-        "cronjob", mode="before", json_schema_input_type=Union[CronJob, str]
+        "cronjob", mode="before", json_schema_input_type=Union[CronJobYear, str]
     )
     def __prepare_cronjob(
         cls, value: str | CronJobYear, info: ValidationInfo
     ) -> CronJobYear:
         """Prepare crontab value that able to receive with string type.
+        This step will get options kwargs from extras field and pass to the
+        CronJobYear object.
+
+        :param value: (str | CronJobYear) A cronjob value that want to create.
+        :param info: (ValidationInfo) A validation info object that use to get
+            the extra parameters for create cronjob.
 
         :rtype: CronJobYear
         """