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

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.7"
+__version__: str = "0.0.9"

ddeutil/workflow/__init__.py

@@ -10,22 +10,11 @@ from .exceptions import (
     StageException,
     UtilException,
 )
-from .on import AwsOn, On
-from .pipeline import Job, Pipeline
-from .stage import (
-    BashStage,
-    EmptyStage,
-    HookStage,
-    PyStage,
-    Stage,
-    TriggerStage,
-)
+from .on import On, interval2crontab
+from .pipeline import Job, Pipeline, Strategy
+from .stage import Stage, handler_result
 from .utils import (
-    ChoiceParam,
-    DatetimeParam,
-    IntParam,
     Param,
-    StrParam,
     dash2underscore,
     param2template,
 )

ddeutil/workflow/api.py

@@ -6,104 +6,62 @@
 from __future__ import annotations
 
 import asyncio
-import queue
-import time
+import logging
+import os
 import uuid
-from contextlib import asynccontextmanager
-from datetime import datetime
-
-from apscheduler.executors.pool import ProcessPoolExecutor
-from apscheduler.jobstores.memory import MemoryJobStore
-from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
-from fastapi import BackgroundTasks, FastAPI
+from queue import Empty, Queue
+
+from ddeutil.core import str2bool
+from dotenv import load_dotenv
+from fastapi import FastAPI
 from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import UJSONResponse
 from pydantic import BaseModel
 
-from .log import get_logger
 from .repeat import repeat_every
-from .route import schedule_route, workflow_route
 
-logger = get_logger(__name__)
+load_dotenv()
+logger = logging.getLogger(__name__)
+logging.basicConfig(
+    level=logging.DEBUG,
+    format=(
+        "%(asctime)s.%(msecs)03d (%(name)-10s, %(process)-5d, %(thread)-5d) "
+        "[%(levelname)-7s] %(message)-120s (%(filename)s:%(lineno)s)"
+    ),
+    handlers=[logging.StreamHandler()],
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+
+
+app = FastAPI()
+app.add_middleware(GZipMiddleware, minimum_size=1000)
+app.queue = Queue()
+app.output_dict = {}
+app.queue_limit = 2
 
 
+@app.on_event("startup")
+@repeat_every(seconds=10, logger=logger)
 def broker_upper_messages():
+    """Broker for receive message from the `/upper` path and change it to upper
+    case.
+    """
     for _ in range(app.queue_limit):
         try:
             obj = app.queue.get_nowait()
             app.output_dict[obj["request_id"]] = obj["text"].upper()
             logger.info(f"Upper message: {app.output_dict}")
-        except queue.Empty:
+        except Empty:
             pass
 
 
-jobstores = {
-    "default": MemoryJobStore(),
-    "sqlite": SQLAlchemyJobStore(url="sqlite:///jobs-store.sqlite"),
-}
-executors = {
-    "default": {"type": "threadpool", "max_workers": 5},
-    "processpool": ProcessPoolExecutor(max_workers=5),
-}
-scheduler = AsyncIOScheduler(
-    jobstores=jobstores,
-    executors=executors,
-    timezone="Asia/Bangkok",
-)
-
-
-@asynccontextmanager
-async def lifespan(_: FastAPI):
-    scheduler.start()
-    yield
-    scheduler.shutdown(wait=False)
-
-
-app = FastAPI(lifespan=lifespan)
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-app.include_router(schedule_route)
-app.include_router(workflow_route)
-
-app.scheduler = scheduler
-app.scheduler.add_job(
-    broker_upper_messages,
-    "interval",
-    seconds=10,
-)
-app.queue = queue.Queue()
-app.output_dict = {}
-app.queue_limit = 2
-
-
-def write_pipeline(task_id: str, message=""):
-    logger.info(f"{task_id} : {message}")
-    time.sleep(5)
-    logger.info(f"{task_id} : run task successfully!!!")
-
-
-@app.post("/schedule/{name}", response_class=UJSONResponse)
-async def send_schedule(name: str, background_tasks: BackgroundTasks):
-    background_tasks.add_task(
-        write_pipeline,
-        name,
-        message=f"some message for {name}",
-    )
-    await fetch_current_time()
-    return {"message": f"Schedule sent {name!r} in the background"}
-
-
-@repeat_every(seconds=2, max_repetitions=3)
-async def fetch_current_time():
-    logger.info(f"Fetch: {datetime.now()}")
-
-
 class Payload(BaseModel):
     text: str
 
 
 async def get_result(request_id):
-    while 1:
+    """Get data from output dict that global."""
+    while True:
         if request_id in app.output_dict:
             result = app.output_dict[request_id]
             del app.output_dict[request_id]
@@ -118,3 +76,14 @@ async def message_upper(payload: Payload):
         {"text": payload.text, "request_id": request_id},
     )
     return await get_result(request_id)
+
+
+if str2bool(os.getenv("WORKFLOW_API_ENABLE_ROUTE_WORKFLOW", "true")):
+    from .route import workflow
+
+    app.include_router(workflow)
+
+if str2bool(os.getenv("WORKFLOW_API_ENABLE_ROUTE_SCHEDULE", "true")):
+    from .route import schedule
+
+    app.include_router(schedule)

ddeutil/workflow/cli.py

@@ -0,0 +1,51 @@
+# ------------------------------------------------------------------------------
+# 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 typing import Optional
+
+from typer import Typer
+
+cli: Typer = Typer()
+state = {"verbose": False}
+
+
+@cli.command()
+def run(pipeline: str):
+    """Run workflow manually"""
+    if state["verbose"]:
+        print("About to create a user")
+
+    print(f"Creating user: {pipeline}")
+
+    if state["verbose"]:
+        print("Just created a user")
+
+
+@cli.command()
+def schedule(exclude: Optional[str]):
+    """Start workflow scheduler"""
+    if state["verbose"]:
+        print("About to delete a user")
+
+    print(f"Deleting user: {exclude}")
+
+    if state["verbose"]:
+        print("Just deleted a user")
+
+
+@cli.callback()
+def main(verbose: bool = False):
+    """
+    Manage workflow with CLI.
+    """
+    if verbose:
+        print("Will write verbose output")
+        state["verbose"] = True
+
+
+if __name__ == "__main__":
+    cli()