ddeutil-workflow 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

ddeutil/workflow/route.py

@@ -0,0 +1,78 @@
+from enum import Enum
+
+from fastapi import APIRouter, Request, status
+from pydantic import BaseModel, ConfigDict, Field
+
+from .log import get_logger
+
+logger = get_logger(__name__)
+workflow_route = APIRouter(prefix="/workflow")
+
+
+@workflow_route.get("/{name}")
+async def get_pipeline(name: str):
+    return {"message": f"getting pipeline {name}"}
+
+
+@workflow_route.get("/{name}/logs")
+async def get_pipeline_log(name: str):
+    return {"message": f"getting pipeline {name} logs"}
+
+
+class JobNotFoundError(Exception):
+    pass
+
+
+schedule_route = APIRouter(prefix="/schedule", tags=["schedule"])
+
+
+class TriggerEnum(str, Enum):
+    interval = "interval"
+    cron = "cron"
+
+
+class Job(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "func": "example.main:pytest_job",
+                "trigger": "interval",
+                "seconds": 3,
+                "id": "pytest_job",
+            },
+        },
+    )
+    func: str = Field()
+    trigger: TriggerEnum = Field(title="Trigger type")
+    seconds: int = Field(title="Interval in seconds")
+    id: str = Field(title="Job ID")
+
+
+@schedule_route.post(
+    "/", name="scheduler:add_job", status_code=status.HTTP_201_CREATED
+)
+async def add_job(request: Request, job: Job):
+    job = request.app.scheduler.add_job(**job.dict())
+    return {"job": f"{job.id}"}
+
+
+@schedule_route.get("/", name="scheduler:get_jobs", response_model=list)
+async def get_jobs(request: Request):
+    jobs = request.app.scheduler.get_jobs()
+    jobs = [
+        {k: v for k, v in job.__getstate__().items() if k != "trigger"}
+        for job in jobs
+    ]
+    return jobs
+
+
+@schedule_route.delete("/{job_id}", name="scheduler:remove_job")
+async def remove_job(request: Request, job_id: str):
+    try:
+        deleted = request.app.scheduler.remove_job(job_id=job_id)
+        logger.debug(f"Job {job_id} deleted: {deleted}")
+        return {"job": f"{job_id}"}
+    except AttributeError as err:
+        raise JobNotFoundError(
+            f"No job by the id of {job_id} was found"
+        ) from err

ddeutil/workflow/stage.py

@@ -99,9 +99,7 @@ class BaseStage(BaseModel, ABC):
 
         _g: DictData = globals() | params
         try:
-            rs: bool = eval(
-                param2template(self.condition, params, repr_flag=True), _g, {}
-            )
+            rs: bool = eval(param2template(self.condition, params), _g, {})
             if not isinstance(rs, bool):
                 raise TypeError("Return type of condition does not be boolean")
             return not rs
@@ -113,6 +111,12 @@ class BaseStage(BaseModel, ABC):
 class EmptyStage(BaseStage):
     """Empty stage that do nothing (context equal empty stage) and logging the
     name of stage only to stdout.
+
+    Data Validate:
+        >>> stage = {
+        ...     "name": "Empty stage execution",
+        ...     "echo": "Hello World",
+        ... }
     """
 
     echo: Optional[str] = Field(
@@ -127,7 +131,8 @@ class EmptyStage(BaseStage):
         :param params: A context data that want to add output result. But this
             stage does not pass any output.
         """
-        logging.info(f"[STAGE]: Empty-Execute: {self.name!r}")
+        stm: str = param2template(self.echo, params=params) or "..."
+        logging.info(f"[STAGE]: Empty-Execute: {self.name!r}: " f"( {stm} )")
         return Result(status=0, context={})
 
 
@@ -207,8 +212,8 @@ class BashStage(BaseStage):
                 if "\\x00" in rs.stderr
                 else rs.stderr
             )
-            logging.error(f"{err}\nRunning Statement:\n---\n{bash}")
-            raise StageException(f"{err}\nRunning Statement:\n---\n{bash}")
+            logging.error(f"{err}\n\n```bash\n{bash}```")
+            raise StageException(f"{err}\n\n```bash\n{bash}```")
         return Result(
             status=0,
             context={
@@ -341,7 +346,7 @@ class HookStage(BaseStage):
         return rgt[hook.func][hook.tag]
 
     def execute(self, params: DictData) -> Result:
-        """Execute the Task function that already mark registry.
+        """Execute the Hook function that already in the hook registry.
 
         :param params: A parameter that want to pass before run any statement.
         :type params: DictData
@@ -351,12 +356,12 @@ class HookStage(BaseStage):
         if not callable(t_func):
             raise ImportError("Hook caller function does not callable.")
 
-        args: DictData = param2template(self.args, params)
         # VALIDATE: check input task caller parameters that exists before
         #   calling.
+        args: DictData = param2template(self.args, params)
         ips = inspect.signature(t_func)
         if any(
-            k not in args
+            (k.removeprefix("_") not in args and k not in args)
             for k in ips.parameters
             if ips.parameters[k].default == Parameter.empty
         ):
@@ -365,11 +370,23 @@ class HookStage(BaseStage):
                 f"does not set to args"
             )
 
+        # NOTE: add '_' prefix if it want to use.
+        for k in ips.parameters:
+            if k.removeprefix("_") in args:
+                args[k] = args.pop(k.removeprefix("_"))
+
         try:
             logging.info(f"[STAGE]: Hook-Execute: {t_func.name}@{t_func.tag}")
             rs: DictData = t_func(**param2template(args, params))
         except Exception as err:
             raise StageException(f"{err.__class__.__name__}: {err}") from err
+
+        # VALIDATE: Check the result type from hook function, it should be dict.
+        if not isinstance(rs, dict):
+            raise StageException(
+                f"Return of hook function: {t_func.name}@{t_func.tag} does not "
+                f"serialize to result model, you should fix it to `dict` type."
+            )
         return Result(status=0, context=rs)
 
 
@@ -385,11 +402,23 @@ class TriggerStage(BaseStage):
         :param params: A parameter data that want to use in this execution.
         :rtype: Result
         """
+        from .exceptions import PipelineException
         from .pipeline import Pipeline
 
-        pipe: Pipeline = Pipeline.from_loader(name=self.trigger, externals={})
-        rs = pipe.execute(params=self.params)
-        return Result(status=0, context=rs)
+        try:
+            # NOTE: Loading pipeline object from trigger name.
+            pipe: Pipeline = Pipeline.from_loader(
+                name=self.trigger, externals={}
+            )
+            rs: Result = pipe.execute(
+                params=param2template(self.params, params)
+            )
+        except PipelineException as err:
+            _alias_stage: str = self.id or self.name
+            raise StageException(
+                f"Trigger Stage: {_alias_stage} get trigger pipeline exception."
+            ) from err
+        return rs
 
 
 # NOTE: Order of parsing stage data