ddeutil-workflow 0.0.9__py3-none-any.whl → 0.0.10__py3-none-any.whl

ddeutil/workflow/repeat.py

@@ -3,33 +3,62 @@
 # Licensed under the MIT License.
 # This code refs from: https://github.com/priyanshu-panwar/fastapi-utilities
 # ------------------------------------------------------------------------------
+from __future__ import annotations
+
 import asyncio
-import logging
 import os
 from asyncio import ensure_future
 from datetime import datetime
 from functools import wraps
 from zoneinfo import ZoneInfo
 
-from croniter import croniter
 from starlette.concurrency import run_in_threadpool
 
+from .cron import CronJob
+from .log import get_logger
+
+logger = get_logger("ddeutil.workflow")
 
-def get_cron_delta(cron: str):
+
+def get_cronjob_delta(cron: str):
     """This function returns the time delta between now and the next cron
     execution time.
     """
     now: datetime = datetime.now(
         tz=ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
     )
-    cron = croniter(cron, now)
-    return (cron.get_next(datetime) - now).total_seconds()
+    cron = CronJob(cron)
+    return (cron.schedule(now).next - now).total_seconds()
+
+
+def cron_valid(cron: str):
+    try:
+        CronJob(cron)
+    except Exception as err:
+        raise ValueError(f"Crontab value does not valid, {cron}") from err
+
+
+async def run_func(
+    is_coroutine,
+    func,
+    *args,
+    raise_exceptions: bool = False,
+    **kwargs,
+):
+    try:
+        if is_coroutine:
+            await func(*args, **kwargs)
+        else:
+            await run_in_threadpool(func, *args, **kwargs)
+    except Exception as e:
+        logger.exception(e)
+        if raise_exceptions:
+            raise e
 
 
 def repeat_at(
     *,
     cron: str,
-    logger: logging.Logger = None,
     raise_exceptions: bool = False,
     max_repetitions: int = None,
 ):
@@ -38,40 +67,37 @@ def repeat_at(
 
     :param cron: str
         Cron-style string for periodic execution, eg. '0 0 * * *' every midnight
-    :param logger: logging.Logger (default None)
-        Logger object to log exceptions
     :param raise_exceptions: bool (default False)
         Whether to raise exceptions or log them
     :param max_repetitions: int (default None)
         Maximum number of times to repeat the function. If None, repeat
         indefinitely.
-
     """
+    if max_repetitions and max_repetitions <= 0:
+        raise ValueError(
+            "max_repetitions should more than zero if it want to set"
+        )
 
     def decorator(func):
-        is_coroutine = asyncio.iscoroutinefunction(func)
+        is_coroutine: bool = asyncio.iscoroutinefunction(func)
 
         @wraps(func)
         def wrapper(*_args, **_kwargs):
-            repititions = 0
-            if not croniter.is_valid(cron):
-                raise ValueError("Invalid cron expression")
+            repititions: int = 0
+            cron_valid(cron)
 
             async def loop(*args, **kwargs):
                 nonlocal repititions
                 while max_repetitions is None or repititions < max_repetitions:
-                    try:
-                        sleep_time = get_cron_delta(cron)
-                        await asyncio.sleep(sleep_time)
-                        if is_coroutine:
-                            await func(*args, **kwargs)
-                        else:
-                            await run_in_threadpool(func, *args, **kwargs)
-                    except Exception as e:
-                        if logger:
-                            logger.exception(e)
-                        if raise_exceptions:
-                            raise e
+                    sleep_time = get_cronjob_delta(cron)
+                    await asyncio.sleep(sleep_time)
+                    await run_func(
+                        is_coroutine,
+                        func,
+                        *args,
+                        raise_exceptions=raise_exceptions,
+                        **kwargs,
+                    )
                     repititions += 1
 
             ensure_future(loop(*_args, **_kwargs))
@@ -85,7 +111,6 @@ def repeat_every(
     *,
     seconds: float,
     wait_first: bool = False,
-    logger: logging.Logger = None,
     raise_exceptions: bool = False,
     max_repetitions: int = None,
 ):
@@ -97,17 +122,19 @@ def repeat_every(
     :param wait_first: bool (default False)
         Whether to wait `seconds` seconds before executing the function for the
         first time.
-    :param logger: logging.Logger (default None)
-        The logger to use for logging exceptions.
     :param raise_exceptions: bool (default False)
         Whether to raise exceptions instead of logging them.
     :param max_repetitions: int (default None)
         The maximum number of times to repeat the function. If None, the
         function will repeat indefinitely.
     """
+    if max_repetitions and max_repetitions <= 0:
+        raise ValueError(
+            "max_repetitions should more than zero if it want to set"
+        )
 
     def decorator(func):
-        is_coroutine = asyncio.iscoroutinefunction(func)
+        is_coroutine: bool = asyncio.iscoroutinefunction(func)
 
         @wraps(func)
         async def wrapper(*_args, **_kwargs):
@@ -115,19 +142,19 @@ def repeat_every(
 
             async def loop(*args, **kwargs):
                 nonlocal repetitions
+
                 if wait_first:
                     await asyncio.sleep(seconds)
+
                 while max_repetitions is None or repetitions < max_repetitions:
-                    try:
-                        if is_coroutine:
-                            await func(*args, **kwargs)
-                        else:
-                            await run_in_threadpool(func, *args, **kwargs)
-                    except Exception as e:
-                        if logger is not None:
-                            logger.exception(e)
-                        if raise_exceptions:
-                            raise e
+                    await run_func(
+                        is_coroutine,
+                        func,
+                        *args,
+                        raise_exceptions=raise_exceptions,
+                        **kwargs,
+                    )
+
                     repetitions += 1
                     await asyncio.sleep(seconds)
 

ddeutil/workflow/route.py

@@ -1,22 +1,66 @@
+# ------------------------------------------------------------------------------
+# Copyright (c) 2022 Korawich Anuttra. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root for
+# license information.
+# ------------------------------------------------------------------------------
 from __future__ import annotations
 
-from fastapi import APIRouter, Request
+from fastapi import APIRouter, HTTPException, Request
 from fastapi import status as st
+from fastapi.responses import UJSONResponse
 
+from .__types import DictData
 from .log import get_logger
-
-logger = get_logger(__name__)
-workflow = APIRouter(prefix="/wf", tags=["workflow"])
+from .pipeline import Pipeline
+from .repeat import repeat_every
+from .utils import Loader
+
+logger = get_logger("ddeutil.workflow")
+workflow = APIRouter(
+    prefix="/workflow",
+    tags=["workflow"],
+)
+schedule = APIRouter(
+    prefix="/schedule",
+    tags=["schedule"],
+)
 
 
-@workflow.get("/")
+@workflow.get(
+    "/",
+    response_class=UJSONResponse,
+    status_code=st.HTTP_200_OK,
+)
 async def get_workflows():
-    return {"message": "getting all pipelines: []"}
+    """Return all pipeline workflows that exists in config path."""
+    pipelines: DictData = Loader.finds(Pipeline)
+    return {
+        "message": f"getting all pipelines: {pipelines}",
+    }
 
 
-@workflow.get("/{name}")
-async def get_workflow(name: str):
-    return {"message": f"getting pipeline {name}"}
+@workflow.get(
+    "/{name}",
+    response_class=UJSONResponse,
+    status_code=st.HTTP_200_OK,
+)
+async def get_workflow(name: str) -> DictData:
+    """Return model of pipeline that passing an input pipeline name."""
+    try:
+        pipeline: Pipeline = Pipeline.from_loader(name=name, externals={})
+    except ValueError:
+        raise HTTPException(
+            status_code=st.HTTP_404_NOT_FOUND,
+            detail=(
+                f"Workflow pipeline name: {name!r} does not found in /conf path"
+            ),
+        ) from None
+    return pipeline.model_dump(
+        by_alias=True,
+        exclude_none=True,
+        exclude_unset=True,
+        exclude_defaults=True,
+    )
 
 
 @workflow.get("/{name}/logs")
@@ -37,35 +81,12 @@ async def del_workflow_release_log(name: str, release: str):
     return {"message": f"getting pipeline {name} log in release {release}"}
 
 
-class JobNotFoundError(Exception):
-    pass
-
+@schedule.on_event("startup")
+@repeat_every(seconds=60)
+def schedule_broker_up():
+    logger.info("Start listening schedule from queue ...")
 
-schedule = APIRouter(prefix="/schedule", tags=["schedule"])
 
-
-@schedule.post("/", name="scheduler:add_job", status_code=st.HTTP_201_CREATED)
-async def add_job(request: Request):
-    return {"job": f"{request}"}
-
-
-@schedule.get("/", name="scheduler:get_jobs", response_model=list)
+@schedule.get("/", response_class=UJSONResponse)
 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.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
+    return {}