ddeutil-workflow 0.0.63__py3-none-any.whl → 0.0.64__py3-none-any.whl

ddeutil/workflow/api/routes/schedules.py

@@ -1,141 +0,0 @@
-# ------------------------------------------------------------------------------
-# 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
-
-import copy
-from datetime import datetime, timedelta
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi import status as st
-from fastapi.responses import UJSONResponse
-
-from ...conf import config
-from ...logs import get_logger
-from ...scheduler import Schedule
-
-logger = get_logger("uvicorn.error")
-schedule_route = APIRouter(
-    prefix="/schedules",
-    tags=["schedules"],
-    default_response_class=UJSONResponse,
-)
-
-
-@schedule_route.get(path="/{name}", status_code=st.HTTP_200_OK)
-async def get_schedules(name: str):
-    """Get schedule object."""
-    try:
-        schedule: Schedule = Schedule.from_conf(name=name, extras={})
-    except ValueError:
-        raise HTTPException(
-            status_code=st.HTTP_404_NOT_FOUND,
-            detail=f"Schedule name: {name!r} does not found in /conf path",
-        ) from None
-    return schedule.model_dump(
-        by_alias=True,
-        exclude_none=True,
-        exclude_unset=True,
-        exclude_defaults=True,
-    )
-
-
-@schedule_route.get(path="/deploy/", status_code=st.HTTP_200_OK)
-async def get_deploy_schedulers(request: Request):
-    snapshot = copy.deepcopy(request.state.scheduler)
-    return {"schedule": snapshot}
-
-
-@schedule_route.get(path="/deploy/{name}", status_code=st.HTTP_200_OK)
-async def get_deploy_scheduler(request: Request, name: str):
-    if name in request.state.scheduler:
-        schedule = Schedule.from_conf(name)
-        getter: list[dict[str, dict[str, list[datetime]]]] = []
-        for workflow in schedule.workflows:
-            getter.append(
-                {
-                    workflow.name: {
-                        "queue": copy.deepcopy(
-                            request.state.workflow_queue[workflow.name]
-                        ),
-                        "running": copy.deepcopy(
-                            request.state.workflow_running[workflow.name]
-                        ),
-                    }
-                }
-            )
-        return {
-            "message": f"Getting {name!r} to schedule listener.",
-            "scheduler": getter,
-        }
-    raise HTTPException(
-        status_code=st.HTTP_404_NOT_FOUND,
-        detail=f"Does not found {name!r} in schedule listener",
-    )
-
-
-@schedule_route.post(path="/deploy/{name}", status_code=st.HTTP_202_ACCEPTED)
-async def add_deploy_scheduler(request: Request, name: str):
-    """Adding schedule name to application state store."""
-    if name in request.state.scheduler:
-        raise HTTPException(
-            status_code=st.HTTP_302_FOUND,
-            detail=f"This schedule {name!r} already exists in scheduler list.",
-        )
-
-    request.state.scheduler.append(name)
-
-    start_date: datetime = datetime.now(tz=config.tz)
-    start_date_waiting: datetime = (start_date + timedelta(minutes=1)).replace(
-        second=0, microsecond=0
-    )
-
-    # NOTE: Create a pair of workflow and on from schedule model.
-    try:
-        schedule: Schedule = Schedule.from_conf(name)
-    except ValueError as err:
-        request.state.scheduler.remove(name)
-        logger.exception(err)
-        raise HTTPException(
-            status_code=st.HTTP_404_NOT_FOUND,
-            detail=str(err),
-        ) from None
-
-    request.state.workflow_tasks.extend(
-        schedule.tasks(
-            start_date_waiting,
-            queue=request.state.workflow_queue,
-        ),
-    )
-    return {
-        "message": f"Adding {name!r} to schedule listener.",
-        "start_date": start_date_waiting,
-    }
-
-
-@schedule_route.delete(path="/deploy/{name}", status_code=st.HTTP_202_ACCEPTED)
-async def del_deploy_scheduler(request: Request, name: str):
-    """Delete workflow task on the schedule listener."""
-    if name in request.state.scheduler:
-
-        # NOTE: Remove current schedule name from the state.
-        request.state.scheduler.remove(name)
-
-        schedule: Schedule = Schedule.from_conf(name)
-
-        for task in schedule.tasks(datetime.now(tz=config.tz), queue={}):
-            if task in request.state.workflow_tasks:
-                request.state.workflow_tasks.remove(task)
-
-        for workflow in schedule.workflows:
-            if workflow.alias in request.state.workflow_queue:
-                request.state.workflow_queue.pop(workflow.alias)
-
-        return {"message": f"Deleted schedule {name!r} in listener."}
-
-    raise HTTPException(
-        status_code=st.HTTP_404_NOT_FOUND,
-        detail=f"Does not found schedule {name!r} in listener",
-    )

ddeutil/workflow/api/utils.py

@@ -1,174 +0,0 @@
-# ------------------------------------------------------------------------------
-# Copyright (c) 2023 Priyanshu Panwar. All rights reserved.
-# Licensed under the MIT License.
-# This code refs from: https://github.com/priyanshu-panwar/fastapi-utilities
-# ------------------------------------------------------------------------------
-from __future__ import annotations
-
-import asyncio
-from asyncio import ensure_future
-from datetime import datetime
-from functools import wraps
-
-from starlette.concurrency import run_in_threadpool
-
-from ..__cron import CronJob
-from ..conf import config
-from ..logs import get_logger
-
-logger = get_logger("uvicorn.error")
-
-
-def get_cronjob_delta(cron: str) -> float:
-    """This function returns the time delta between now and the next cron
-    execution time.
-
-    :rtype: float
-    """
-    now: datetime = datetime.now(tz=config.tz)
-    cron = CronJob(cron)
-    return (cron.schedule(now).next - now).total_seconds()
-
-
-def cron_valid(cron: str, raise_error: bool = True) -> bool:
-    """Check this crontab string value is valid with its cron syntax.
-
-    :rtype: bool
-    """
-    try:
-        CronJob(cron)
-        return True
-    except Exception as err:
-        if raise_error:
-            raise ValueError(f"Crontab value does not valid, {cron}") from err
-        return False
-
-
-async def run_func(
-    is_coroutine,
-    func,
-    *args,
-    raise_exceptions: bool = False,
-    **kwargs,
-):
-    """Run function inside the repeat decorator functions."""
-    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,
-    delay: float = 0,
-    raise_exceptions: bool = False,
-    max_repetitions: int = None,
-):
-    """This function returns a decorator that makes a function execute
-    periodically as per the cron expression provided.
-
-    :param cron: (str) A Cron-style string for periodic execution, e.g.
-        '0 0 * * *' every midnight
-    :param delay: (float) A delay seconds value.
-    :param raise_exceptions: (bool) A raise exception flag. Whether to raise
-        exceptions or log them if raise was set be false.
-    :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: bool = asyncio.iscoroutinefunction(func)
-
-        @wraps(func)
-        def wrapper(*_args, **_kwargs):
-            repetitions: int = 0
-            cron_valid(cron)
-
-            async def loop(*args, **kwargs):
-                nonlocal repetitions
-                while max_repetitions is None or repetitions < max_repetitions:
-                    sleep_time = get_cronjob_delta(cron) + delay
-                    await asyncio.sleep(sleep_time)
-                    await run_func(
-                        is_coroutine,
-                        func,
-                        *args,
-                        raise_exceptions=raise_exceptions,
-                        **kwargs,
-                    )
-                    repetitions += 1
-
-            ensure_future(loop(*_args, **_kwargs))
-
-        return wrapper
-
-    return decorator
-
-
-def repeat_every(
-    *,
-    seconds: float,
-    wait_first: bool = False,
-    raise_exceptions: bool = False,
-    max_repetitions: int = None,
-):
-    """This function returns a decorator that schedules a function to execute
-    periodically after every `seconds` seconds.
-
-    :param seconds: float
-        The number of seconds to wait before executing the function again.
-    :param wait_first: bool (default False)
-        Whether to wait `seconds` seconds before executing the function for the
-        first time.
-    :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: bool = asyncio.iscoroutinefunction(func)
-
-        @wraps(func)
-        async def wrapper(*_args, **_kwargs):
-            repetitions = 0
-
-            async def loop(*args, **kwargs):
-                nonlocal repetitions
-
-                if wait_first:
-                    await asyncio.sleep(seconds)
-
-                while max_repetitions is None or repetitions < max_repetitions:
-                    await run_func(
-                        is_coroutine,
-                        func,
-                        *args,
-                        raise_exceptions=raise_exceptions,
-                        **kwargs,
-                    )
-
-                    repetitions += 1
-                    await asyncio.sleep(seconds)
-
-            ensure_future(loop(*_args, **_kwargs))
-
-        return wrapper
-
-    return decorator