ddeutil-workflow 0.0.23__py3-none-any.whl → 0.0.25__py3-none-any.whl

ddeutil/workflow/conf.py

@@ -16,14 +16,14 @@ from pathlib import Path
 from typing import ClassVar, Optional, TypeVar, Union
 from zoneinfo import ZoneInfo
 
-from ddeutil.core import import_string, str2bool
+from ddeutil.core import str2bool
 from ddeutil.io import PathSearch, YamlFlResolve
 from dotenv import load_dotenv
 from pydantic import BaseModel, Field
 from pydantic.functional_validators import model_validator
 from typing_extensions import Self
 
-from .__types import DictData
+from .__types import DictData, TupleStr
 
 AnyModel = TypeVar("AnyModel", bound=BaseModel)
 AnyModelType = type[AnyModel]
@@ -32,6 +32,18 @@ load_dotenv()
 
 env = os.getenv
 
+__all__: TupleStr = (
+    "get_logger",
+    "Config",
+    "SimLoad",
+    "Loader",
+    "config",
+    "logger",
+    "FileLog",
+    "SQLiteLog",
+    "Log",
+)
+
 
 @lru_cache
 def get_logger(name: str):
@@ -70,7 +82,7 @@ class Config:
 
     # NOTE: Register
     regis_hook_str: str = os.getenv(
-        "WORKFLOW_CORE_REGISTRY", "ddeutil.workflow"
+        "WORKFLOW_CORE_REGISTRY", "src,src.ddeutil.workflow,tests,tests.utils"
     )
     regis_filter_str: str = os.getenv(
         "WORKFLOW_CORE_REGISTRY_FILTER", "ddeutil.workflow.utils"
@@ -107,7 +119,10 @@ class Config:
         os.getenv("WORKFLOW_CORE_MAX_NUM_POKING", "4")
     )
     max_on_per_workflow: int = int(
-        env("WORKFLOW_CORE_MAX_ON_PER_WORKFLOW", "5")
+        env("WORKFLOW_CORE_MAX_CRON_PER_WORKFLOW", "5")
+    )
+    max_queue_complete_hist: int = int(
+        os.getenv("WORKFLOW_CORE_MAX_QUEUE_COMPLETE_HIST", "16")
     )
 
     # NOTE: Schedule App
@@ -120,11 +135,12 @@ class Config:
     )
 
     # NOTE: API
+    prefix_path: str = env("WORKFLOW_API_PREFIX_PATH", "/api/v1")
     enable_route_workflow: bool = str2bool(
-        os.getenv("WORKFLOW_API_ENABLE_ROUTE_WORKFLOW", "true")
+        env("WORKFLOW_API_ENABLE_ROUTE_WORKFLOW", "true")
     )
     enable_route_schedule: bool = str2bool(
-        os.getenv("WORKFLOW_API_ENABLE_ROUTE_SCHEDULE", "true")
+        env("WORKFLOW_API_ENABLE_ROUTE_SCHEDULE", "true")
     )
 
     def __init__(self) -> None:
@@ -215,8 +231,8 @@ class SimLoad:
         obj: object,
         conf: Config,
         *,
-        include: list[str] | None = None,
-        exclude: list[str] | None = None,
+        included: list[str] | None = None,
+        excluded: list[str] | None = None,
     ) -> Iterator[tuple[str, DictData]]:
         """Find all data that match with object type in config path. This class
         method can use include and exclude list of identity name for filter and
@@ -224,22 +240,23 @@ class SimLoad:
 
         :param obj: A object that want to validate matching before return.
         :param conf: A config object.
-        :param include:
-        :param exclude:
+        :param included:
+        :param excluded:
 
         :rtype: Iterator[tuple[str, DictData]]
         """
-        exclude: list[str] = exclude or []
+        exclude: list[str] = excluded or []
         for file in PathSearch(conf.conf_path).files:
+
             for key, data in cls.filter_suffix(file).items():
 
                 if key in exclude:
                     continue
 
-                if issubclass(get_type(data["type"], conf), obj):
+                if data["type"] == obj.__name__:
                     yield key, (
-                        {k: data[k] for k in data if k in include}
-                        if include
+                        {k: data[k] for k in data if k in included}
+                        if included
                         else data
                     )
 
@@ -251,14 +268,14 @@ class SimLoad:
         return {}
 
     @cached_property
-    def type(self) -> AnyModelType:
+    def type(self) -> str:
         """Return object of string type which implement on any registry. The
         object type.
 
         :rtype: AnyModelType
         """
         if _typ := self.data.get("type"):
-            return get_type(_typ, self.conf)
+            return _typ
         raise ValueError(
             f"the 'type' value: {_typ} does not exists in config data."
         )
@@ -276,47 +293,26 @@ class Loader(SimLoad):
         cls,
         obj: object,
         *,
-        include: list[str] | None = None,
-        exclude: list[str] | None = None,
+        included: list[str] | None = None,
+        excluded: list[str] | None = None,
         **kwargs,
     ) -> Iterator[tuple[str, DictData]]:
         """Override the find class method from the Simple Loader object.
 
         :param obj: A object that want to validate matching before return.
-        :param include:
-        :param exclude:
+        :param included:
+        :param excluded:
 
         :rtype: Iterator[tuple[str, DictData]]
         """
         return super().finds(
-            obj=obj, conf=Config(), include=include, exclude=exclude
+            obj=obj, conf=Config(), included=included, excluded=excluded
         )
 
     def __init__(self, name: str, externals: DictData) -> None:
         super().__init__(name, conf=Config(), externals=externals)
 
 
-def get_type(t: str, params: Config) -> AnyModelType:
-    """Return import type from string importable value in the type key.
-
-    :param t: A importable type string.
-    :param params: A config parameters that use registry to search this
-        type.
-
-    :rtype: AnyModelType
-    """
-    try:
-        # NOTE: Auto adding module prefix if it does not set
-        return import_string(f"ddeutil.workflow.{t}")
-    except ModuleNotFoundError:
-        for registry in params.regis_hook:
-            try:
-                return import_string(f"{registry}.{t}")
-            except ModuleNotFoundError:
-                continue
-        return import_string(f"{t}")
-
-
 config = Config()
 logger = get_logger("ddeutil.workflow")
 
@@ -472,9 +468,6 @@ class FileLog(BaseLog):
         if not config.enable_write_log:
             return self
 
-        logger.debug(
-            f"({self.run_id}) [LOG]: Start writing log: {self.name!r}."
-        )
         log_file: Path = self.pointer() / f"{self.run_id}.log"
         log_file.write_text(
             json.dumps(

ddeutil/workflow/{on.py → cron.py}

@@ -121,7 +121,7 @@ class On(BaseModel):
         loader: Loader = Loader(name, externals=externals)
 
         # NOTE: Validate the config type match with current connection model
-        if loader.type != cls:
+        if loader.type != cls.__name__:
             raise ValueError(f"Type {loader.type} does not match with {cls}")
 
         loader_data: DictData = loader.data

ddeutil/workflow/exceptions.py

@@ -29,3 +29,6 @@ class WorkflowFailException(WorkflowException): ...
 
 
 class ParamValueException(WorkflowException): ...
+
+
+class CliException(BaseWorkflowException): ...