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

ddeutil/workflow/repeat.py

@@ -3,29 +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_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()
-    cron = croniter(cron, now)
-    return (cron.get_next(datetime) - now).total_seconds()
+    now: datetime = datetime.now(
+        tz=ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
+    )
+    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,
 ):
@@ -34,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:
-                        sleepTime = get_delta(cron)
-                        await asyncio.sleep(sleepTime)
-                        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
+                    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))
@@ -81,7 +111,6 @@ def repeat_every(
     *,
     seconds: float,
     wait_first: bool = False,
-    logger: logging.Logger = None,
     raise_exceptions: bool = False,
     max_repetitions: int = None,
 ):
@@ -93,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):
@@ -111,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,78 +1,92 @@
-from enum import Enum
-
-from fastapi import APIRouter, Request, status
-from pydantic import BaseModel, ConfigDict, Field
-
+# ------------------------------------------------------------------------------
+# 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, 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_route = APIRouter(prefix="/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_route.get("/{name}")
-async def get_pipeline(name: str):
-    return {"message": f"getting pipeline {name}"}
+@workflow.get(
+    "/",
+    response_class=UJSONResponse,
+    status_code=st.HTTP_200_OK,
+)
+async def get_workflows():
+    """Return all pipeline workflows that exists in config path."""
+    pipelines: DictData = Loader.finds(Pipeline)
+    return {
+        "message": f"getting all pipelines: {pipelines}",
+    }
+
+
+@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_route.get("/{name}/logs")
-async def get_pipeline_log(name: str):
+@workflow.get("/{name}/logs")
+async def get_workflow_logs(name: str):
     return {"message": f"getting pipeline {name} logs"}
 
 
-class JobNotFoundError(Exception):
-    pass
-
+@workflow.get("/{name}/logs/{release}")
+async def get_workflow_release_log(name: str, release: str):
+    return {"message": f"getting pipeline {name} log in release {release}"}
 
-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
+@workflow.delete(
+    "/{name}/logs/{release}",
+    status_code=st.HTTP_204_NO_CONTENT,
 )
-async def add_job(request: Request, job: Job):
-    job = request.app.scheduler.add_job(**job.dict())
-    return {"job": f"{job.id}"}
+async def del_workflow_release_log(name: str, release: str):
+    return {"message": f"getting pipeline {name} log in release {release}"}
 
 
-@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.on_event("startup")
+@repeat_every(seconds=60)
+def schedule_broker_up():
+    logger.info("Start listening schedule from queue ...")
 
 
-@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
+@schedule.get("/", response_class=UJSONResponse)
+async def get_jobs(request: Request):
+    return {}