ddeutil-workflow 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.24"
+__version__: str = "0.0.26"

ddeutil/workflow/api/__init__.py

@@ -0,0 +1 @@
+from .api import app

ddeutil/workflow/{api.py → api/api.py}

@@ -11,7 +11,6 @@ import uuid
 from collections.abc import AsyncIterator
 from datetime import datetime, timedelta
 from queue import Empty, Queue
-from threading import Thread
 from typing import TypedDict
 
 from dotenv import load_dotenv
@@ -20,34 +19,39 @@ from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import UJSONResponse
 from pydantic import BaseModel
 
-from .__about__ import __version__
-from .conf import config, get_logger
+from ..__about__ import __version__
+from ..conf import config, get_logger
+from ..scheduler import ReleaseThread, ReleaseThreads
+from ..workflow import WorkflowQueue, WorkflowTask
 from .repeat import repeat_at, repeat_every
-from .workflow import WorkflowTask
 
 load_dotenv()
 logger = get_logger("ddeutil.workflow")
 
 
 class State(TypedDict):
+    """TypeDict for State of FastAPI application."""
+
+    # NOTE: For upper queue route.
     upper_queue: Queue
     upper_result: dict[str, str]
+
+    # NOTE: For schedule listener.
     scheduler: list[str]
-    workflow_threads: dict[str, Thread]
+    workflow_threads: ReleaseThreads
     workflow_tasks: list[WorkflowTask]
-    workflow_queue: dict[str, list[datetime]]
-    workflow_running: dict[str, list[datetime]]
+    workflow_queue: dict[str, WorkflowQueue]
 
 
 @contextlib.asynccontextmanager
 async def lifespan(a: FastAPI) -> AsyncIterator[State]:
+    """Lifespan function for the FastAPI application."""
     a.state.upper_queue = Queue()
     a.state.upper_result = {}
     a.state.scheduler = []
     a.state.workflow_threads = {}
     a.state.workflow_tasks = []
     a.state.workflow_queue = {}
-    a.state.workflow_running = {}
 
     await asyncio.create_task(broker_upper_messages())
 
@@ -65,7 +69,6 @@ async def lifespan(a: FastAPI) -> AsyncIterator[State]:
         #
         "scheduler": a.state.scheduler,
         "workflow_queue": a.state.workflow_queue,
-        "workflow_running": a.state.workflow_running,
         "workflow_threads": a.state.workflow_threads,
         "workflow_tasks": a.state.workflow_tasks,
     }
@@ -114,12 +117,11 @@ async def get_result(request_id: str) -> dict[str, str]:
 
 
 @app.get("/")
-@app.get("/api")
 async def health():
     return {"message": "Workflow API already start up"}
 
 
-@app.post("/api")
+@app.post(f"{config.prefix_path}/upper")
 async def message_upper(payload: Payload):
     """Convert message from any case to the upper case."""
     request_id: str = str(uuid.uuid4())
@@ -129,27 +131,47 @@ async def message_upper(payload: Payload):
     return await get_result(request_id)
 
 
+# NOTE: Enable the workflow route.
 if config.enable_route_workflow:
-    from .route import workflow
+    from .route import workflow_route
+
+    app.include_router(workflow_route, prefix=config.prefix_path)
 
-    app.include_router(workflow)
 
+# NOTE: Enable the schedule route.
 if config.enable_route_schedule:
-    from .route import schedule
-    from .scheduler import workflow_task
+    from ..conf import FileLog
+    from ..scheduler import schedule_task
+    from .route import schedule_route
 
-    app.include_router(schedule)
+    app.include_router(schedule_route, prefix=config.prefix_path)
 
-    @schedule.on_event("startup")
+    @schedule_route.on_event("startup")
     @repeat_at(cron="* * * * *", delay=2)
-    def schedule_broker_up():
+    def scheduler_listener():
+        """Schedule broker every minute at 02 second."""
         logger.debug(
             f"[SCHEDULER]: Start listening schedule from queue "
             f"{app.state.scheduler}"
         )
         if app.state.workflow_tasks:
-            workflow_task(
+            schedule_task(
                 app.state.workflow_tasks,
-                stop=datetime.now() + timedelta(minutes=1),
+                stop=datetime.now(config.tz) + timedelta(minutes=1),
+                queue=app.state.workflow_queue,
                 threads=app.state.workflow_threads,
+                log=FileLog,
             )
+
+    @schedule_route.on_event("startup")
+    @repeat_at(cron="*/5 * * * *")
+    def monitoring():
+        logger.debug("[MONITOR]: Start monitoring threading.")
+        snapshot_threads: list[str] = list(app.state.workflow_threads.keys())
+        for t_name in snapshot_threads:
+
+            thread_release: ReleaseThread = app.state.workflow_threads[t_name]
+
+            # NOTE: remove the thread that running success.
+            if not thread_release["thread"].is_alive():
+                app.state.workflow_threads.pop(t_name)

ddeutil/workflow/{repeat.py → api/repeat.py}

@@ -12,8 +12,8 @@ from functools import wraps
 
 from starlette.concurrency import run_in_threadpool
 
-from .__cron import CronJob
-from .conf import config, get_logger
+from ..__cron import CronJob
+from ..conf import config, get_logger
 
 logger = get_logger("ddeutil.workflow")
 

ddeutil/workflow/{route.py → api/route.py}

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import copy
+from dataclasses import asdict
 from datetime import datetime, timedelta
 from typing import Any
 
@@ -14,41 +15,43 @@ from fastapi import status as st
 from fastapi.responses import UJSONResponse
 from pydantic import BaseModel
 
-from . import Workflow
-from .__types import DictData
-from .conf import Loader, config, get_logger
-from .result import Result
-from .scheduler import Schedule
+from ..__types import DictData
+from ..conf import Loader, config, get_logger
+from ..result import Result
+from ..scheduler import Schedule
+from ..workflow import Workflow
 
 logger = get_logger("ddeutil.workflow")
-workflow = APIRouter(
-    prefix="/api/workflow",
-    tags=["workflow"],
+
+workflow_route = APIRouter(
+    prefix="/workflows",
+    tags=["workflows"],
     default_response_class=UJSONResponse,
 )
-schedule = APIRouter(
-    prefix="/api/schedule",
-    tags=["schedule"],
+
+schedule_route = APIRouter(
+    prefix="/schedules",
+    tags=["schedules"],
     default_response_class=UJSONResponse,
 )
 
-ListDate = list[datetime]
 
-
-@workflow.get("/")
-async def get_workflows():
+@workflow_route.get(path="/")
+async def get_workflows() -> DictData:
     """Return all workflow workflows that exists in config path."""
-    workflows: DictData = Loader.finds(Workflow)
+    workflows: DictData = dict(Loader.finds(Workflow))
     return {
-        "message": f"getting all workflows: {workflows}",
+        "message": f"Getting all workflows: {len(workflows)}",
+        "count": len(workflows),
+        "workflows": workflows,
     }
 
 
-@workflow.get("/{name}")
-async def get_workflow(name: str) -> DictData:
+@workflow_route.get(path="/{name}")
+async def get_workflow_by_name(name: str) -> DictData:
     """Return model of workflow that passing an input workflow name."""
     try:
-        wf: Workflow = Workflow.from_loader(name=name, externals={})
+        workflow: Workflow = Workflow.from_loader(name=name, externals={})
     except ValueError as err:
         logger.exception(err)
         raise HTTPException(
@@ -57,7 +60,7 @@ async def get_workflow(name: str) -> DictData:
                 f"Workflow workflow name: {name!r} does not found in /conf path"
             ),
         ) from None
-    return wf.model_dump(
+    return workflow.model_dump(
         by_alias=True,
         exclude_none=True,
         exclude_unset=True,
@@ -69,11 +72,11 @@ class ExecutePayload(BaseModel):
     params: dict[str, Any]
 
 
-@workflow.post("/{name}/execute", status_code=st.HTTP_202_ACCEPTED)
+@workflow_route.post(path="/{name}/execute", status_code=st.HTTP_202_ACCEPTED)
 async def execute_workflow(name: str, payload: ExecutePayload) -> DictData:
     """Return model of workflow that passing an input workflow name."""
     try:
-        wf: Workflow = Workflow.from_loader(name=name, externals={})
+        workflow: Workflow = Workflow.from_loader(name=name, externals={})
     except ValueError:
         raise HTTPException(
             status_code=st.HTTP_404_NOT_FOUND,
@@ -83,36 +86,45 @@ async def execute_workflow(name: str, payload: ExecutePayload) -> DictData:
         ) from None
 
     # NOTE: Start execute manually
-    rs: Result = wf.execute(params=payload.params)
+    try:
+        result: Result = workflow.execute(params=payload.params)
+    except Exception as err:
+        raise HTTPException(
+            status_code=st.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"{type(err)}: {err}",
+        ) from None
 
-    return dict(rs)
+    return asdict(result)
 
 
-@workflow.get("/{name}/logs")
+@workflow_route.get(path="/{name}/logs")
 async def get_workflow_logs(name: str):
-    return {"message": f"getting workflow {name!r} logs"}
+    return {"message": f"Getting workflow {name!r} logs"}
 
 
-@workflow.get("/{name}/logs/{release}")
+@workflow_route.get(path="/{name}/logs/{release}")
 async def get_workflow_release_log(name: str, release: str):
-    return {"message": f"getting workflow {name!r} log in release {release}"}
+    return {"message": f"Getting workflow {name!r} log in release {release}"}
 
 
-@workflow.delete("/{name}/logs/{release}", status_code=st.HTTP_204_NO_CONTENT)
+@workflow_route.delete(
+    path="/{name}/logs/{release}",
+    status_code=st.HTTP_204_NO_CONTENT,
+)
 async def del_workflow_release_log(name: str, release: str):
-    return {"message": f"deleted workflow {name!r} log in release {release}"}
+    return {"message": f"Deleted workflow {name!r} log in release {release}"}
 
 
-@schedule.get("/{name}")
-async def get_schedule(name: str):
+@schedule_route.get(path="/{name}")
+async def get_schedules(name: str):
     try:
-        sch: Schedule = Schedule.from_loader(name=name, externals={})
+        schedule: Schedule = Schedule.from_loader(name=name, externals={})
     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 sch.model_dump(
+    return schedule.model_dump(
         by_alias=True,
         exclude_none=True,
         exclude_unset=True,
@@ -120,32 +132,32 @@ async def get_schedule(name: str):
     )
 
 
-@schedule.get("/deploy")
+@schedule_route.get(path="/deploy")
 async def get_deploy_schedulers(request: Request):
     snapshot = copy.deepcopy(request.state.scheduler)
     return {"schedule": snapshot}
 
 
-@schedule.get("/deploy/{name}")
+@schedule_route.get(path="/deploy/{name}")
 async def get_deploy_scheduler(request: Request, name: str):
     if name in request.state.scheduler:
         sch = Schedule.from_loader(name)
         getter: list[dict[str, dict[str, list[datetime]]]] = []
-        for wf in sch.workflows:
+        for workflow in sch.workflows:
             getter.append(
                 {
-                    wf.name: {
+                    workflow.name: {
                         "queue": copy.deepcopy(
-                            request.state.workflow_queue[wf.name]
+                            request.state.workflow_queue[workflow.name]
                         ),
                         "running": copy.deepcopy(
-                            request.state.workflow_running[wf.name]
+                            request.state.workflow_running[workflow.name]
                         ),
                     }
                 }
             )
         return {
-            "message": f"getting {name!r} to schedule listener.",
+            "message": f"Getting {name!r} to schedule listener.",
             "scheduler": getter,
         }
     raise HTTPException(
@@ -154,13 +166,13 @@ async def get_deploy_scheduler(request: Request, name: str):
     )
 
 
-@schedule.post("/deploy/{name}")
+@schedule_route.post(path="/deploy/{name}")
 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="This schedule already exists in scheduler list.",
+            detail=f"This schedule {name!r} already exists in scheduler list.",
         )
 
     request.state.scheduler.append(name)
@@ -172,42 +184,49 @@ async def add_deploy_scheduler(request: Request, name: str):
 
     # NOTE: Create pair of workflow and on from schedule model.
     try:
-        sch = Schedule.from_loader(name)
-    except ValueError as e:
+        schedule: Schedule = Schedule.from_loader(name)
+    except ValueError as err:
         request.state.scheduler.remove(name)
-        logger.exception(e)
+        logger.exception(err)
         raise HTTPException(
             status_code=st.HTTP_404_NOT_FOUND,
-            detail=str(e),
+            detail=str(err),
         ) from None
+
     request.state.workflow_tasks.extend(
-        sch.tasks(
+        schedule.tasks(
             start_date_waiting,
             queue=request.state.workflow_queue,
-            running=request.state.workflow_running,
+            externals={},
         ),
     )
-    return {"message": f"adding {name!r} to schedule listener."}
+    return {
+        "message": f"Adding {name!r} to schedule listener.",
+        "start_date": start_date_waiting,
+    }
 
 
-@schedule.delete("/deploy/{name}")
+@schedule_route.delete(path="/deploy/{name}")
 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)
-        sche = Schedule.from_loader(name)
-        for workflow_task in sche.tasks(datetime.now(), {}, {}):
-            request.state.workflow_tasks.remove(workflow_task)
 
-        for wf in sche.workflows:
-            if wf in request.state.workflow_queue:
-                request.state.workflow_queue.pop(wf, {})
+        schedule: Schedule = Schedule.from_loader(name)
 
-            if wf in request.state.workflow_running:
-                request.state.workflow_running.pop(wf, {})
+        for task in schedule.tasks(datetime.now(tz=config.tz), queue={}):
+            if task in request.state.workflow_tasks:
+                request.state.workflow_tasks.remove(task)
 
-        return {"message": f"deleted {name!r} to schedule listener."}
+        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 {name!r} in schedule listener",
+        detail=f"Does not found schedule {name!r} in listener",
     )

ddeutil/workflow/conf.py

@@ -16,7 +16,7 @@ from pathlib import Path
 from typing import ClassVar, Optional, TypeVar, Union
 from zoneinfo import ZoneInfo
 
-from ddeutil.core import import_string, str2bool
+from ddeutil.core import str2bool
 from ddeutil.io import PathSearch, YamlFlResolve
 from dotenv import load_dotenv
 from pydantic import BaseModel, Field
@@ -37,7 +37,6 @@ __all__: TupleStr = (
     "Config",
     "SimLoad",
     "Loader",
-    "get_type",
     "config",
     "logger",
     "FileLog",
@@ -83,7 +82,7 @@ class Config:
 
     # NOTE: Register
     regis_hook_str: str = os.getenv(
-        "WORKFLOW_CORE_REGISTRY", "ddeutil.workflow"
+        "WORKFLOW_CORE_REGISTRY", "src,src.ddeutil.workflow,tests,tests.utils"
     )
     regis_filter_str: str = os.getenv(
         "WORKFLOW_CORE_REGISTRY_FILTER", "ddeutil.workflow.utils"
@@ -136,11 +135,12 @@ class Config:
     )
 
     # NOTE: API
+    prefix_path: str = env("WORKFLOW_API_PREFIX_PATH", "/api/v1")
     enable_route_workflow: bool = str2bool(
-        os.getenv("WORKFLOW_API_ENABLE_ROUTE_WORKFLOW", "true")
+        env("WORKFLOW_API_ENABLE_ROUTE_WORKFLOW", "true")
     )
     enable_route_schedule: bool = str2bool(
-        os.getenv("WORKFLOW_API_ENABLE_ROUTE_SCHEDULE", "true")
+        env("WORKFLOW_API_ENABLE_ROUTE_SCHEDULE", "true")
     )
 
     def __init__(self) -> None:
@@ -231,8 +231,8 @@ class SimLoad:
         obj: object,
         conf: Config,
         *,
-        include: list[str] | None = None,
-        exclude: list[str] | None = None,
+        included: list[str] | None = None,
+        excluded: list[str] | None = None,
     ) -> Iterator[tuple[str, DictData]]:
         """Find all data that match with object type in config path. This class
         method can use include and exclude list of identity name for filter and
@@ -240,22 +240,23 @@ class SimLoad:
 
         :param obj: A object that want to validate matching before return.
         :param conf: A config object.
-        :param include:
-        :param exclude:
+        :param included:
+        :param excluded:
 
         :rtype: Iterator[tuple[str, DictData]]
         """
-        exclude: list[str] = exclude or []
+        exclude: list[str] = excluded or []
         for file in PathSearch(conf.conf_path).files:
+
             for key, data in cls.filter_suffix(file).items():
 
                 if key in exclude:
                     continue
 
-                if issubclass(get_type(data["type"], conf), obj):
+                if data["type"] == obj.__name__:
                     yield key, (
-                        {k: data[k] for k in data if k in include}
-                        if include
+                        {k: data[k] for k in data if k in included}
+                        if included
                         else data
                     )
 
@@ -267,14 +268,14 @@ class SimLoad:
         return {}
 
     @cached_property
-    def type(self) -> AnyModelType:
+    def type(self) -> str:
         """Return object of string type which implement on any registry. The
         object type.
 
         :rtype: AnyModelType
         """
         if _typ := self.data.get("type"):
-            return get_type(_typ, self.conf)
+            return _typ
         raise ValueError(
             f"the 'type' value: {_typ} does not exists in config data."
         )
@@ -292,47 +293,26 @@ class Loader(SimLoad):
         cls,
         obj: object,
         *,
-        include: list[str] | None = None,
-        exclude: list[str] | None = None,
+        included: list[str] | None = None,
+        excluded: list[str] | None = None,
         **kwargs,
     ) -> Iterator[tuple[str, DictData]]:
         """Override the find class method from the Simple Loader object.
 
         :param obj: A object that want to validate matching before return.
-        :param include:
-        :param exclude:
+        :param included:
+        :param excluded:
 
         :rtype: Iterator[tuple[str, DictData]]
         """
         return super().finds(
-            obj=obj, conf=Config(), include=include, exclude=exclude
+            obj=obj, conf=Config(), included=included, excluded=excluded
         )
 
     def __init__(self, name: str, externals: DictData) -> None:
         super().__init__(name, conf=Config(), externals=externals)
 
 
-def get_type(t: str, params: Config) -> AnyModelType:
-    """Return import type from string importable value in the type key.
-
-    :param t: A importable type string.
-    :param params: A config parameters that use registry to search this
-        type.
-
-    :rtype: AnyModelType
-    """
-    try:
-        # NOTE: Auto adding module prefix if it does not set
-        return import_string(f"ddeutil.workflow.{t}")
-    except ModuleNotFoundError:
-        for registry in params.regis_hook:
-            try:
-                return import_string(f"{registry}.{t}")
-            except ModuleNotFoundError:
-                continue
-        return import_string(f"{t}")
-
-
 config = Config()
 logger = get_logger("ddeutil.workflow")
 
@@ -488,9 +468,6 @@ class FileLog(BaseLog):
         if not config.enable_write_log:
             return self
 
-        logger.debug(
-            f"({self.run_id}) [LOG]: Start writing log: {self.name!r}."
-        )
         log_file: Path = self.pointer() / f"{self.run_id}.log"
         log_file.write_text(
             json.dumps(

ddeutil/workflow/cron.py

@@ -121,7 +121,7 @@ class On(BaseModel):
         loader: Loader = Loader(name, externals=externals)
 
         # NOTE: Validate the config type match with current connection model
-        if loader.type != cls:
+        if loader.type != cls.__name__:
             raise ValueError(f"Type {loader.type} does not match with {cls}")
 
         loader_data: DictData = loader.data

ddeutil/workflow/exceptions.py

@@ -29,3 +29,6 @@ class WorkflowFailException(WorkflowException): ...
 
 
 class ParamValueException(WorkflowException): ...
+
+
+class CliException(BaseWorkflowException): ...

ddeutil/workflow/scheduler.py

@@ -30,10 +30,10 @@ from concurrent.futures import (
 )
 from datetime import datetime, timedelta
 from functools import wraps
-from heapq import heappop
+from heapq import heappop, heappush
 from textwrap import dedent
 from threading import Thread
-from typing import Callable, Optional
+from typing import Callable, Optional, TypedDict
 
 from pydantic import BaseModel, Field
 from pydantic.functional_validators import field_validator, model_validator
@@ -74,6 +74,8 @@ __all__: TupleStr = (
     "monitor",
     "schedule_control",
     "schedule_runner",
+    "ReleaseThreads",
+    "ReleaseThread",
 )
 
 
@@ -265,7 +267,7 @@ class Schedule(BaseModel):
         loader: Loader = Loader(name, externals=(externals or {}))
 
         # NOTE: Validate the config type match with current connection model
-        if loader.type != cls:
+        if loader.type != cls.__name__:
             raise ValueError(f"Type {loader.type} does not match with {cls}")
 
         loader_data: DictData = copy.deepcopy(loader.data)
@@ -341,12 +343,20 @@ def catch_exceptions(cancel_on_failure: bool = False) -> DecoratorCancelJob:
     return decorator
 
 
-@catch_exceptions(cancel_on_failure=True)  # pragma: no cov
+class ReleaseThread(TypedDict):
+    thread: Thread
+    start_date: datetime
+
+
+ReleaseThreads = dict[str, ReleaseThread]
+
+
+@catch_exceptions(cancel_on_failure=True)
 def schedule_task(
     tasks: list[WorkflowTask],
     stop: datetime,
     queue: dict[str, WorkflowQueue],
-    threads: dict[str, Thread],
+    threads: ReleaseThreads,
     log: type[Log],
 ) -> CancelJob | None:
     """Workflow task generator that create release pair of workflow and on to
@@ -397,53 +407,53 @@ def schedule_task(
             continue
 
         # VALIDATE: Check this task is the first release in the queue or not.
-        current_date: datetime = current_date.replace(second=0, microsecond=0)
-        if (first_date := q.first_queue.date) != current_date:
+        current_release: datetime = current_date.replace(
+            second=0, microsecond=0
+        )
+        if (first_date := q.first_queue.date) != current_release:
             logger.debug(
                 f"[WORKFLOW]: Skip schedule "
-                f"{first_date:%Y-%m-%d %H:%M:%S} "
-                f"for : {task.alias!r} : {task.runner.cron}"
+                f"{first_date:%Y-%m-%d %H:%M:%S} for : {task.alias!r}"
             )
             continue
 
         # NOTE: Pop the latest release and push it to running.
         release: WorkflowRelease = heappop(q.queue)
-        q.push_running(release)
+        heappush(q.running, release)
 
         logger.info(
-            f"[WORKFLOW]: Start thread: '{task.alias}|{str(task.runner.cron)}|"
+            f"[WORKFLOW]: Start thread: '{task.alias}|"
             f"{release.date:%Y%m%d%H%M}'"
         )
 
         # NOTE: Create thread name that able to tracking with observe schedule
         #   job.
-        thread_name: str = (
-            f"{task.alias}|{str(task.runner.cron)}|"
-            f"{release.date:%Y%m%d%H%M}"
-        )
-
-        wf_thread: Thread = Thread(
+        thread_name: str = f"{task.alias}|{release.date:%Y%m%d%H%M}"
+        thread: Thread = Thread(
             target=catch_exceptions(cancel_on_failure=True)(task.release),
             kwargs={"release": release, "queue": q, "log": log},
             name=thread_name,
             daemon=True,
         )
 
-        threads[thread_name] = wf_thread
+        threads[thread_name] = {
+            "thread": thread,
+            "start_date": datetime.now(tz=config.tz),
+        }
 
-        wf_thread.start()
+        thread.start()
 
         delay()
 
     logger.debug(f"[SCHEDULE]: End schedule release {'=' * 80}")
 
 
-def monitor(threads: dict[str, Thread]) -> None:  # pragma: no cov
+def monitor(threads: ReleaseThreads) -> None:  # pragma: no cov
     """Monitoring function that running every five minute for track long running
     thread instance from the schedule_control function that run every minute.
 
     :param threads: A mapping of Thread object and its name.
-    :type threads: dict[str, Thread]
+    :type threads: ReleaseThreads
     """
     logger.debug(
         "[MONITOR]: Start checking long running workflow release task."
@@ -452,8 +462,10 @@ def monitor(threads: dict[str, Thread]) -> None:  # pragma: no cov
     snapshot_threads: list[str] = list(threads.keys())
     for t_name in snapshot_threads:
 
+        thread_release: ReleaseThread = threads[t_name]
+
         # NOTE: remove the thread that running success.
-        if not threads[t_name].is_alive():
+        if not thread_release["thread"].is_alive():
             threads.pop(t_name)
 
 
@@ -488,7 +500,7 @@ def schedule_control(
 
     # IMPORTANT: Create main mapping of queue and thread object.
     queue: dict[str, WorkflowQueue] = {}
-    threads: dict[str, Thread] = {}
+    threads: ReleaseThreads = {}
 
     start_date_waiting: datetime = start_date.replace(
         second=0, microsecond=0

ddeutil/workflow/utils.py

@@ -74,6 +74,12 @@ def get_diff_sec(
     )
 
 
+def wait_a_minute(now: datetime, second: float = 2) -> None:  # pragma: no cov
+    """Wait with sleep to the next minute with an offset second value."""
+    future = now.replace(second=0, microsecond=0) + timedelta(minutes=1)
+    time.sleep((future - now).total_seconds() + second)
+
+
 def delay(second: float = 0) -> None:  # pragma: no cov
     """Delay time that use time.sleep with random second value between
     0.00 - 0.99 seconds.
@@ -326,7 +332,7 @@ def get_args_from_filter(
 
     if func_name not in filters:
         raise UtilException(
-            f"The post-filter: {func_name} does not support yet."
+            f"The post-filter: {func_name!r} does not support yet."
         )
 
     if isinstance((f_func := filters[func_name]), list) and (args or kwargs):

ddeutil/workflow/workflow.py

@@ -50,11 +50,11 @@ from .params import Param
 from .result import Result
 from .utils import (
     cut_id,
-    delay,
     gen_id,
     get_dt_now,
     has_template,
     param2template,
+    wait_a_minute,
 )
 
 logger = get_logger("ddeutil.workflow")
@@ -201,22 +201,12 @@ class WorkflowQueue:
             or (value in self.complete)
         )
 
-    def push_queue(self, value: WorkflowRelease) -> Self:
-        """Push data to the waiting queue."""
-        heappush(self.queue, value)
-        return self
-
-    def push_running(self, value: WorkflowRelease) -> Self:
-        """Push WorkflowRelease to the running queue."""
-        heappush(self.running, value)
-        return self
-
     def remove_running(self, value: WorkflowRelease) -> Self:
         """Remove WorkflowRelease in the running queue if it exists."""
         if value in self.running:
             self.running.remove(value)
 
-    def push_complete(self, value: WorkflowRelease) -> Self:
+    def mark_complete(self, value: WorkflowRelease) -> Self:
         """Push WorkflowRelease to the complete queue."""
         heappush(self.complete, value)
 
@@ -284,7 +274,7 @@ class Workflow(BaseModel):
         loader: Loader = Loader(name, externals=(externals or {}))
 
         # NOTE: Validate the config type match with current connection model
-        if loader.type != cls:
+        if loader.type != cls.__name__:
             raise ValueError(f"Type {loader.type} does not match with {cls}")
 
         loader_data: DictData = copy.deepcopy(loader.data)
@@ -492,6 +482,14 @@ class Workflow(BaseModel):
             This method allow workflow use log object to save the execution
         result to log destination like file log to the local `/logs` directory.
 
+        :Steps:
+            - Initialize WorkflowQueue and WorkflowRelease if they do not pass.
+            - Create release data for pass to parameter templating function.
+            - Execute this workflow with mapping release data to its parameters.
+            - Writing log
+            - Remove this release on the running queue
+            - Push this release to complete queue
+
         :param release: A release datetime or WorkflowRelease object.
         :param params: A workflow parameter that pass to execute method.
         :param queue: A list of release time that already queue.
@@ -507,6 +505,7 @@ class Workflow(BaseModel):
         name: str = override_log_name or self.name
         run_id: str = run_id or gen_id(name, unique=True)
         rs_release: Result = Result(run_id=run_id)
+        rs_release_type: str = "release"
 
         # VALIDATE: Change queue value to WorkflowQueue object.
         if queue is None or isinstance(queue, list):
@@ -514,6 +513,7 @@ class Workflow(BaseModel):
 
         # VALIDATE: Change release value to WorkflowRelease object.
         if isinstance(release, datetime):
+            rs_release_type: str = "datetime"
             release: WorkflowRelease = WorkflowRelease.from_dt(release)
 
         logger.debug(
@@ -555,12 +555,14 @@ class Workflow(BaseModel):
         )
 
         # NOTE: Saving execution result to destination of the input log object.
+        logger.debug(f"({cut_id(run_id)}) [LOG]: Writing log: {name!r}.")
         rs_log.save(excluded=None)
 
         # NOTE: Remove this release from running.
         queue.remove_running(release)
-        queue.push_complete(release)
+        queue.mark_complete(release)
 
+        # NOTE: Remove the params key from the result context for deduplicate.
         context: dict[str, Any] = rs.context
         context.pop("params")
 
@@ -568,7 +570,12 @@ class Workflow(BaseModel):
             status=0,
             context={
                 "params": params,
-                "release": {"status": "success", "logical_date": release.date},
+                "release": {
+                    "status": "success",
+                    "type": rs_release_type,
+                    "logical_date": release.date,
+                    "release": release,
+                },
                 "outputs": context,
             },
         )
@@ -628,7 +635,7 @@ class Workflow(BaseModel):
                 continue
 
             # NOTE: Push the WorkflowRelease object to queue.
-            queue.push_queue(workflow_release)
+            heappush(queue.queue, workflow_release)
 
         return queue
 
@@ -742,7 +749,7 @@ class Workflow(BaseModel):
                         f"release has diff time more than 60 seconds ..."
                     )
                     heappush(wf_queue.queue, release)
-                    delay(60)
+                    wait_a_minute(get_dt_now(tz=config.tz, offset=offset))
 
                     # WARNING: I already call queue poking again because issue
                     #   about the every minute crontab.
@@ -756,7 +763,7 @@ class Workflow(BaseModel):
                     continue
 
                 # NOTE: Push the latest WorkflowRelease to the running queue.
-                wf_queue.push_running(release)
+                heappush(wf_queue.running, release)
 
                 futures.append(
                     executor.submit(
@@ -1145,8 +1152,18 @@ class WorkflowTask:
         :rtype: Result
         """
         log: type[Log] = log or FileLog
+
+        if release is None:
+            if queue.check_queue(self.runner.date):
+                release = self.runner.next
+
+                while queue.check_queue(release):
+                    release = self.runner.next
+            else:
+                release = self.runner.date
+
         return self.workflow.release(
-            release=release or self.runner.next,
+            release=release,
             params=self.values,
             run_id=run_id,
             log=log,
@@ -1199,7 +1216,7 @@ class WorkflowTask:
             return queue
 
         # NOTE: Push the WorkflowRelease object to queue.
-        queue.push_queue(workflow_release)
+        heappush(queue.queue, workflow_release)
 
         return queue
 

{ddeutil_workflow-0.0.24.dist-info → ddeutil_workflow-0.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddeutil-workflow
-Version: 0.0.24
+Version: 0.0.26
 Summary: Lightweight workflow orchestration with less dependencies
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
@@ -26,7 +26,6 @@ Requires-Dist: ddeutil>=0.4.3
 Requires-Dist: ddeutil-io[toml,yaml]>=0.2.3
 Requires-Dist: pydantic==2.10.4
 Requires-Dist: python-dotenv==1.0.1
-Requires-Dist: typer==0.15.1
 Requires-Dist: schedule<2.0.0,==1.2.2
 Provides-Extra: api
 Requires-Dist: fastapi<1.0.0,>=0.115.0; extra == "api"
@@ -68,8 +67,8 @@ configuration. It called **Metadata Driven Data Workflow**.
 > with `.yml` files and all of config file from several data orchestration framework
 > tools from my experience on Data Engineer. :grimacing:
 >
-> Other workflow that I interest on them and pick some interested feature to this
-> package:
+> Other workflow tools that I interest on them and pick some interested feature
+> implement to this package:
 >
 > - [Google **Workflows**](https://cloud.google.com/workflows)
 > - [AWS **Step Functions**](https://aws.amazon.com/step-functions/)
@@ -80,23 +79,10 @@ This project need `ddeutil` and `ddeutil-io` extension namespace packages.
 If you want to install this package with application add-ons, you should add
 `app` in installation;
 
-| Usecase           | Install Optional                         | Support            |
-|-------------------|------------------------------------------|--------------------|
-| Python & CLI      | `pip install ddeutil-workflow`           | :heavy_check_mark: |
-| FastAPI Server    | `pip install ddeutil-workflow[api]`      | :heavy_check_mark: |
-
-
-> I added this feature to the main milestone.
->
-> :egg: **Docker Images** supported:
->
-> | Docker Image                | Python Version | Support |
-> |-----------------------------|----------------|---------|
-> | ddeutil-workflow:latest     | `3.9`          | :x:     |
-> | ddeutil-workflow:python3.10 | `3.10`         | :x:     |
-> | ddeutil-workflow:python3.11 | `3.11`         | :x:     |
-> | ddeutil-workflow:python3.12 | `3.12`         | :x:     |
-> | ddeutil-workflow:python3.12 | `3.13`         | :x:     |
+| Usecase        | Install Optional                         | Support            |
+|----------------|------------------------------------------|--------------------|
+| Python         | `pip install ddeutil-workflow`           | :heavy_check_mark: |
+| FastAPI Server | `pip install ddeutil-workflow[api]`      | :heavy_check_mark: |
 
 ## :beers: Usage
 
@@ -113,7 +99,7 @@ use-case.
 run-py-local:
 
    # Validate model that use to parsing exists for template file
-   type: ddeutil.workflow.Workflow
+   type: ddeutil.workflow.workflow.Workflow
    on:
       # If workflow deploy to schedule, it will running every 5 minutes
       # with Asia/Bangkok timezone.
@@ -182,35 +168,35 @@ The main configuration that use to dynamic changing with your propose of this
 application. If any configuration values do not set yet, it will use default value
 and do not raise any error to you.
 
-| Environment                             | Component | Default                          | Description                                                                                                        | Remark |
-|:----------------------------------------|:----------|:---------------------------------|--------------------------------------------------------------------------------------------------------------------|--------|
-| `WORKFLOW_ROOT_PATH`                    | Core      | .                                | The root path of the workflow application.                                                                         |        |
-| `WORKFLOW_CORE_REGISTRY`                | Core      | src.ddeutil.workflow,tests.utils | List of importable string for the hook stage.                                                                      |        |
-| `WORKFLOW_CORE_REGISTRY_FILTER`         | Core      | ddeutil.workflow.utils           | List of importable string for the filter template.                                                                 |        |
-| `WORKFLOW_CORE_PATH_CONF`               | Core      | conf                             | The config path that keep all template `.yaml` files.                                                              |        |
-| `WORKFLOW_CORE_TIMEZONE`                | Core      | Asia/Bangkok                     | A Timezone string value that will pass to `ZoneInfo` object.                                                       |        |
-| `WORKFLOW_CORE_STAGE_DEFAULT_ID`        | Core      | true                             | A flag that enable default stage ID that use for catch an execution output.                                        |        |
-| `WORKFLOW_CORE_STAGE_RAISE_ERROR`       | Core      | false                            | A flag that all stage raise StageException from stage execution.                                                   |        |
-| `WORKFLOW_CORE_JOB_DEFAULT_ID`          | Core      | false                            | A flag that enable default job ID that use for catch an execution output. The ID that use will be sequence number. |        |
-| `WORKFLOW_CORE_JOB_RAISE_ERROR`         | Core      | true                             | A flag that all job raise JobException from job strategy execution.                                                |        |
-| `WORKFLOW_CORE_MAX_NUM_POKING`          | Core      | 4                                | .                                                                                                                  |        |
-| `WORKFLOW_CORE_MAX_JOB_PARALLEL`        | Core      | 2                                | The maximum job number that able to run parallel in workflow executor.                                             |        |
-| `WORKFLOW_CORE_MAX_JOB_EXEC_TIMEOUT`    | Core      | 600                              |                                                                                                                    |        |
-| `WORKFLOW_CORE_MAX_CRON_PER_WORKFLOW`   | Core      | 5                                |                                                                                                                    |        |
-| `WORKFLOW_CORE_MAX_QUEUE_COMPLETE_HIST` | Core      | 16                               |                                                                                                                    |        |
-| `WORKFLOW_CORE_GENERATE_ID_SIMPLE_MODE` | Core      | true                             | A flog that enable generating ID with `md5` algorithm.                                                             |        |
-| `WORKFLOW_LOG_DEBUG_MODE`               | Log       | true                             | A flag that enable logging with debug level mode.                                                                  |        |
-| `WORKFLOW_LOG_ENABLE_WRITE`             | Log       | true                             | A flag that enable logging object saving log to its destination.                                                   |        |
-| `WORKFLOW_APP_MAX_PROCESS`              | Schedule  | 2                                | The maximum process worker number that run in scheduler app module.                                                |        |
-| `WORKFLOW_APP_MAX_SCHEDULE_PER_PROCESS` | Schedule  | 100                              | A schedule per process that run parallel.                                                                          |        |
-| `WORKFLOW_APP_STOP_BOUNDARY_DELTA`      | Schedule  | '{"minutes": 5, "seconds": 20}'  | A time delta value that use to stop scheduler app in json string format.                                           |        |
+| Environment                             | Component  | Default                                            | Description                                                                                                        | Remark |
+|:----------------------------------------|:----------:|:---------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------|--------|
+| `WORKFLOW_ROOT_PATH`                    |    Core    | .                                                  | The root path of the workflow application.                                                                         |        |
+| `WORKFLOW_CORE_REGISTRY`                |    Core    | src,src.ddeutil.workflow,tests,tests.utils         | List of importable string for the hook stage.                                                                      |        |
+| `WORKFLOW_CORE_REGISTRY_FILTER`         |    Core    | src.ddeutil.workflow.utils,ddeutil.workflow.utils  | List of importable string for the filter template.                                                                 |        |
+| `WORKFLOW_CORE_PATH_CONF`               |    Core    | conf                                               | The config path that keep all template `.yaml` files.                                                              |        |
+| `WORKFLOW_CORE_TIMEZONE`                |    Core    | Asia/Bangkok                                       | A Timezone string value that will pass to `ZoneInfo` object.                                                       |        |
+| `WORKFLOW_CORE_STAGE_DEFAULT_ID`        |    Core    | true                                               | A flag that enable default stage ID that use for catch an execution output.                                        |        |
+| `WORKFLOW_CORE_STAGE_RAISE_ERROR`       |    Core    | false                                              | A flag that all stage raise StageException from stage execution.                                                   |        |
+| `WORKFLOW_CORE_JOB_DEFAULT_ID`          |    Core    | false                                              | A flag that enable default job ID that use for catch an execution output. The ID that use will be sequence number. |        |
+| `WORKFLOW_CORE_JOB_RAISE_ERROR`         |    Core    | true                                               | A flag that all job raise JobException from job strategy execution.                                                |        |
+| `WORKFLOW_CORE_MAX_NUM_POKING`          |    Core    | 4                                                  | .                                                                                                                  |        |
+| `WORKFLOW_CORE_MAX_JOB_PARALLEL`        |    Core    | 2                                                  | The maximum job number that able to run parallel in workflow executor.                                             |        |
+| `WORKFLOW_CORE_MAX_JOB_EXEC_TIMEOUT`    |    Core    | 600                                                |                                                                                                                    |        |
+| `WORKFLOW_CORE_MAX_CRON_PER_WORKFLOW`   |    Core    | 5                                                  |                                                                                                                    |        |
+| `WORKFLOW_CORE_MAX_QUEUE_COMPLETE_HIST` |    Core    | 16                                                 |                                                                                                                    |        |
+| `WORKFLOW_CORE_GENERATE_ID_SIMPLE_MODE` |    Core    | true                                               | A flog that enable generating ID with `md5` algorithm.                                                             |        |
+| `WORKFLOW_LOG_DEBUG_MODE`               |    Log     | true                                               | A flag that enable logging with debug level mode.                                                                  |        |
+| `WORKFLOW_LOG_ENABLE_WRITE`             |    Log     | true                                               | A flag that enable logging object saving log to its destination.                                                   |        |
+| `WORKFLOW_APP_MAX_PROCESS`              |  Schedule  | 2                                                  | The maximum process worker number that run in scheduler app module.                                                |        |
+| `WORKFLOW_APP_MAX_SCHEDULE_PER_PROCESS` |  Schedule  | 100                                                | A schedule per process that run parallel.                                                                          |        |
+| `WORKFLOW_APP_STOP_BOUNDARY_DELTA`      |  Schedule  | '{"minutes": 5, "seconds": 20}'                    | A time delta value that use to stop scheduler app in json string format.                                           |        |
 
 **API Application**:
 
-| Environment                           | Component | Default | Description                                                                        | Remark |
-|:--------------------------------------|-----------|---------|------------------------------------------------------------------------------------|--------|
-| `WORKFLOW_API_ENABLE_ROUTE_WORKFLOW`  | API       | true    | A flag that enable workflow route to manage execute manually and workflow logging. |        |
-| `WORKFLOW_API_ENABLE_ROUTE_SCHEDULE`  | API       | true    | A flag that enable run scheduler.                                                  |        |
+| Environment                           |  Component  | Default | Description                                                                        | Remark |
+|:--------------------------------------|:-----------:|---------|------------------------------------------------------------------------------------|--------|
+| `WORKFLOW_API_ENABLE_ROUTE_WORKFLOW`  |     API     | true    | A flag that enable workflow route to manage execute manually and workflow logging. |        |
+| `WORKFLOW_API_ENABLE_ROUTE_SCHEDULE`  |     API     | true    | A flag that enable run scheduler.                                                  |        |
 
 ## :rocket: Deployment
 
@@ -218,12 +204,6 @@ This package able to run as a application service for receive manual trigger
 from the master node via RestAPI or use to be Scheduler background service
 like crontab job but via Python API.
 
-### Schedule App
-
-```shell
-(venv) $ ddeutil-workflow schedule
-```
-
 ### API Server
 
 ```shell
@@ -231,7 +211,7 @@ like crontab job but via Python API.
 ```
 
 > [!NOTE]
-> If this package already deploy, it able to use
+> If this package already deploy, it able to use multiprocess;
 > `uvicorn ddeutil.workflow.api:app --host 127.0.0.1 --port 80 --workers 4`
 
 ### Docker Container

ddeutil_workflow-0.0.26.dist-info/RECORD

@@ -0,0 +1,23 @@
+ddeutil/workflow/__about__.py,sha256=YOPdjr7wsJbawVBpWp1ZSxpo-8M9kGnIdMF9N0v_4HM,28
+ddeutil/workflow/__cron.py,sha256=uA8XcbY_GwA9rJSHaHUaXaJyGDObJN0ZeYlJSinL8y8,26880
+ddeutil/workflow/__init__.py,sha256=49eGrCuchPVZKMybRouAviNhbulK_F6VwCmLm76hIss,1478
+ddeutil/workflow/__types.py,sha256=Ia7f38kvL3NibwmRKi0wQ1ud_45Z-SojYGhNJwIqcu8,3713
+ddeutil/workflow/conf.py,sha256=YY2zZ_qv9JkTDs_73bkyrF1n1cqBINuxzMxbBjzYw-8,15361
+ddeutil/workflow/cron.py,sha256=75A0hqevvouziKoLALncLJspVAeki9qCH3zniAJaxzY,7513
+ddeutil/workflow/exceptions.py,sha256=P56K7VD3etGm9y-k_GXrzEyqsTCaz9EJazTIshZDf9g,943
+ddeutil/workflow/job.py,sha256=cvSLMdc1sMl1MeU7so7Oe2SdRYxQwt6hm55mLV1iP-Y,24219
+ddeutil/workflow/params.py,sha256=uPGkZx18E-iZ8BteqQ2ONgg0frhF3ZmP5cOyfK2j59U,5280
+ddeutil/workflow/result.py,sha256=WIC8MsnfLiWNpZomT6jS4YCdYhlbIVVBjtGGe2dkoKk,3404
+ddeutil/workflow/scheduler.py,sha256=_V812UlqcwfVF2Sl_45nIatMklioBXcXfGZSFoAAjwo,20452
+ddeutil/workflow/stage.py,sha256=a2sngzs9DkP6GU2pgAD3QvGoijyBQTR_pOhyJUIuWAo,26692
+ddeutil/workflow/utils.py,sha256=pucRnCi9aLJDptXhzzReHZd5d-S0o5oZif5tr6H4iy8,18736
+ddeutil/workflow/workflow.py,sha256=AD0rs1tRT2EpvUyNVAEr2bBPgF6-KOzGmLedR3o4y0Q,42177
+ddeutil/workflow/api/__init__.py,sha256=F53NMBWtb9IKaDWkPU5KvybGGfKAcbehgn6TLBwHuuM,21
+ddeutil/workflow/api/api.py,sha256=Md1cz3Edc7_uz63s_L_i-R3IE4mkO3aTADrX8GOGU-Y,5644
+ddeutil/workflow/api/repeat.py,sha256=zyvsrXKk-3-_N8ZRZSki0Mueshugum2jtqctEOp9QSc,4927
+ddeutil/workflow/api/route.py,sha256=MQXtkF5uM_ZL1SGDuXFzgkNkbT5cpAXVNRp6mvewupM,7447
+ddeutil_workflow-0.0.26.dist-info/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.26.dist-info/METADATA,sha256=MD2MuUFEap5vrkRukNQzf2pLGnZI1QZh9CkmIo5ZVyU,14075
+ddeutil_workflow-0.0.26.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+ddeutil_workflow-0.0.26.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.26.dist-info/RECORD,,

{ddeutil_workflow-0.0.24.dist-info → ddeutil_workflow-0.0.26.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.7.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ddeutil/workflow/cli.py

@@ -1,130 +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 json
-from datetime import datetime
-from enum import Enum
-from typing import Annotated, Optional
-
-from ddeutil.core import str2list
-from typer import Argument, Option, Typer
-
-from .conf import config, get_logger
-
-logger = get_logger("ddeutil.workflow")
-cli: Typer = Typer()
-cli_log: Typer = Typer()
-cli.add_typer(
-    cli_log,
-    name="log",
-    help="Logging of workflow CLI",
-)
-
-
-@cli.command()
-def run(
-    workflow: Annotated[
-        str,
-        Argument(help="A workflow name that want to run manually"),
-    ],
-    params: Annotated[
-        str,
-        Argument(
-            help="A json string for parameters of this workflow execution."
-        ),
-    ],
-):
-    """Run workflow workflow manually with an input custom parameters that able
-    to receive with workflow params config.
-    """
-    logger.info(f"Running workflow name: {workflow}")
-    logger.info(f"... with Parameters: {json.dumps(json.loads(params))}")
-
-
-@cli.command()
-def schedule(
-    stop: Annotated[
-        Optional[datetime],
-        Argument(
-            formats=["%Y-%m-%d", "%Y-%m-%d %H:%M:%S"],
-            help="A stopping datetime that want to stop on schedule app.",
-        ),
-    ] = None,
-    excluded: Annotated[
-        Optional[str],
-        Argument(help="A list of exclude workflow name in str."),
-    ] = None,
-    externals: Annotated[
-        Optional[str],
-        Argument(
-            help="A json string for parameters of this workflow execution."
-        ),
-    ] = None,
-):
-    """Start workflow scheduler that will call workflow function from scheduler
-    module.
-    """
-    excluded: list[str] = str2list(excluded) if excluded else []
-    externals: str = externals or "{}"
-    if stop:
-        stop: datetime = stop.astimezone(tz=config.tz)
-
-    from .scheduler import schedule_runner
-
-    # NOTE: Start running workflow scheduler application.
-    workflow_rs: list[str] = schedule_runner(
-        stop=stop, excluded=excluded, externals=json.loads(externals)
-    )
-    logger.info(f"Application run success: {workflow_rs}")
-
-
-@cli_log.command("workflow-get")
-def workflow_log_get(
-    name: Annotated[
-        str,
-        Argument(help="A workflow name that want to getting log"),
-    ],
-    limit: Annotated[
-        int,
-        Argument(help="A number of the limitation of logging"),
-    ] = 100,
-    desc: Annotated[
-        bool,
-        Option(
-            "--desc",
-            help="A descending flag that order by logging release datetime.",
-        ),
-    ] = True,
-):
-    logger.info(f"{name} : limit {limit} : desc: {desc}")
-    return [""]
-
-
-class LogMode(str, Enum):
-    get = "get"
-    delete = "delete"
-
-
-@cli_log.command("workflow-delete")
-def workflow_log_delete(
-    mode: Annotated[
-        LogMode,
-        Argument(case_sensitive=True),
-    ]
-):
-    logger.info(mode)
-
-
-@cli.callback()
-def main():
-    """
-    Manage workflow with CLI.
-    """
-
-
-if __name__ == "__main__":
-    cli()

ddeutil_workflow-0.0.24.dist-info/RECORD

@@ -1,24 +0,0 @@
-ddeutil/workflow/__about__.py,sha256=LbAkk7O3dezpuJ-KPhsDQuHdrO9T0qmhBd-oDJzBhq4,28
-ddeutil/workflow/__cron.py,sha256=uA8XcbY_GwA9rJSHaHUaXaJyGDObJN0ZeYlJSinL8y8,26880
-ddeutil/workflow/__init__.py,sha256=49eGrCuchPVZKMybRouAviNhbulK_F6VwCmLm76hIss,1478
-ddeutil/workflow/__types.py,sha256=Ia7f38kvL3NibwmRKi0wQ1ud_45Z-SojYGhNJwIqcu8,3713
-ddeutil/workflow/api.py,sha256=cdRxqwVyGm_Ni_OmflIP35vUkkq8lHpF3xHh_BvVrKs,4692
-ddeutil/workflow/cli.py,sha256=8C5Xri1_82B-sxQcKMPRjDJcuYJG3FZ2bJehvs_xZ4s,3278
-ddeutil/workflow/conf.py,sha256=Al-00Uru2fCJaW2C_vt4IFuBDpI8Y5C4oAuLJ0Vdvbk,16110
-ddeutil/workflow/cron.py,sha256=0SxC3SH-8V1idgAEFOY-gYFEQPjK_zymmc5XqPoX_0I,7504
-ddeutil/workflow/exceptions.py,sha256=NqnQJP52S59XIYMeXbTDbr4xH2UZ5EA3ejpU5Z4g6cQ,894
-ddeutil/workflow/job.py,sha256=cvSLMdc1sMl1MeU7so7Oe2SdRYxQwt6hm55mLV1iP-Y,24219
-ddeutil/workflow/params.py,sha256=uPGkZx18E-iZ8BteqQ2ONgg0frhF3ZmP5cOyfK2j59U,5280
-ddeutil/workflow/repeat.py,sha256=s0azh-f5JQeow7kpxM8GKlqgAmKL7oU6St3L4Ggx4cY,4925
-ddeutil/workflow/result.py,sha256=WIC8MsnfLiWNpZomT6jS4YCdYhlbIVVBjtGGe2dkoKk,3404
-ddeutil/workflow/route.py,sha256=bH5IT90JVjCDe9A0gIefpQQBEfcd-o1uCHE9AvNglvU,6754
-ddeutil/workflow/scheduler.py,sha256=UI8wK2xBYmM3Bh_hel0TMzuJWyezM83Yn4xoiYqTSSQ,20238
-ddeutil/workflow/stage.py,sha256=a2sngzs9DkP6GU2pgAD3QvGoijyBQTR_pOhyJUIuWAo,26692
-ddeutil/workflow/utils.py,sha256=PhNJ54oKnZfq4nVOeP3tDjFN43ArUsMOnpcbSu7bo4I,18450
-ddeutil/workflow/workflow.py,sha256=JyT65Tql7CueQn2z4ZGhp6r44jgYDMcCOpxhiwI19uM,41403
-ddeutil_workflow-0.0.24.dist-info/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.24.dist-info/METADATA,sha256=0yh6zKsIu1COnhl-25rOxBGEqLQbrJZzA0IhriO3XwA,14234
-ddeutil_workflow-0.0.24.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-ddeutil_workflow-0.0.24.dist-info/entry_points.txt,sha256=0BVOgO3LdUdXVZ-CiHHDKxzEk2c8J30jEwHeKn2YCWI,62
-ddeutil_workflow-0.0.24.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.24.dist-info/RECORD,,

ddeutil_workflow-0.0.24.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-ddeutil-workflow = ddeutil.workflow.cli:cli