ddeutil-workflow 0.0.66__py3-none-any.whl → 0.0.68__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.66"
+__version__: str = "0.0.68"

ddeutil/workflow/api/__init__.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import contextlib
+import logging
 from collections.abc import AsyncIterator
 
 from dotenv import load_dotenv
@@ -19,11 +20,10 @@ from fastapi.responses import UJSONResponse
 
 from ..__about__ import __version__
 from ..conf import api_config
-from ..logs import get_logger
 from .routes import job, log, workflow
 
 load_dotenv()
-logger = get_logger("uvicorn.error")
+logger = logging.getLogger("uvicorn.error")
 
 
 @contextlib.asynccontextmanager
@@ -58,12 +58,16 @@ app.add_middleware(
 
 
 @app.get(path="/", response_class=UJSONResponse)
-async def health():
+async def health() -> UJSONResponse:
     """Index view that not return any template without json status."""
-    return {"message": "Workflow already start up with healthy status."}
+    logger.info("[API]: Workflow API Application already running ...")
+    return UJSONResponse(
+        content={"message": "Workflow already start up with healthy status."},
+        status_code=st.HTTP_200_OK,
+    )
 
 
-# NOTE Add the jobs and logs routes by default.
+# NOTE: Add the jobs and logs routes by default.
 app.include_router(job, prefix=api_config.prefix_path)
 app.include_router(log, prefix=api_config.prefix_path)
 app.include_router(workflow, prefix=api_config.prefix_path)
@@ -71,21 +75,18 @@ app.include_router(workflow, prefix=api_config.prefix_path)
 
 @app.exception_handler(RequestValidationError)
 async def validation_exception_handler(
-    request: Request, exc: RequestValidationError
-):
+    request: Request,
+    exc: RequestValidationError,
+) -> UJSONResponse:
+    """Error Handler for model validate does not valid."""
     _ = request
     return UJSONResponse(
         status_code=st.HTTP_422_UNPROCESSABLE_ENTITY,
-        content=jsonable_encoder({"detail": exc.errors(), "body": exc.body}),
-    )
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=80,
-        log_level="DEBUG",
+        content=jsonable_encoder(
+            {
+                "message": "Body does not parsing with model.",
+                "detail": exc.errors(),
+                "body": exc.body,
+            }
+        ),
     )

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

@@ -1,6 +1,8 @@
+from typing import Any
+
 from ..conf import config
 
-LOGGING_CONFIG = {  # pragma: no cov
+LOGGING_CONFIG: dict[str, Any] = {  # pragma: no cov
     "version": 1,
     "disable_existing_loggers": False,
     "formatters": {
@@ -22,38 +24,49 @@ LOGGING_CONFIG = {  # pragma: no cov
             "stream": "ext://sys.stderr",
         },
         "stream_handler": {
+            # "formatter": "standard",
             "formatter": "custom_formatter",
             "class": "logging.StreamHandler",
             "stream": "ext://sys.stdout",
         },
-        "file_handler": {
-            "formatter": "custom_formatter",
-            "class": "logging.handlers.RotatingFileHandler",
-            "filename": "logs/app.log",
-            "maxBytes": 1024 * 1024 * 1,
-            "backupCount": 3,
-        },
+        # "file_handler": {
+        #     "formatter": "custom_formatter",
+        #     "class": "logging.handlers.RotatingFileHandler",
+        #     "filename": "logs/app.log",
+        #     "maxBytes": 1024 * 1024 * 1,
+        #     "backupCount": 3,
+        # },
     },
     "loggers": {
         "uvicorn": {
-            "handlers": ["default", "file_handler"],
+            # "handlers": ["default", "file_handler"],
+            "handlers": ["default"],
             "level": "DEBUG" if config.debug else "INFO",
             "propagate": False,
         },
         "uvicorn.access": {
-            "handlers": ["stream_handler", "file_handler"],
+            # "handlers": ["stream_handler", "file_handler"],
+            "handlers": ["stream_handler"],
             "level": "DEBUG" if config.debug else "INFO",
             "propagate": False,
         },
         "uvicorn.error": {
-            "handlers": ["stream_handler", "file_handler"],
+            # "handlers": ["stream_handler", "file_handler"],
+            "handlers": ["stream_handler"],
             "level": "DEBUG" if config.debug else "INFO",
             "propagate": False,
         },
-        # "uvicorn.asgi": {
-        #     "handlers": ["stream_handler", "file_handler"],
-        #     "level": "TRACE",
-        #     "propagate": False,
+        "uvicorn.asgi": {
+            # "handlers": ["stream_handler", "file_handler"],
+            "handlers": ["stream_handler"],
+            "level": "TRACE",
+            "propagate": False,
+        },
+        # "ddeutil.workflow": {
+        #     "handlers": ["stream_handler"],
+        #     "level": "INFO",
+        #     # "propagate": False,
+        #     "propagate": True,
         # },
     },
 }

ddeutil/workflow/api/routes/__init__.py

@@ -3,6 +3,6 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-from .job import job_route as job
-from .logs import log_route as log
-from .workflows import workflow_route as workflow
+from .job import router as job
+from .logs import router as log
+from .workflows import router as workflow

ddeutil/workflow/api/routes/job.py

@@ -5,20 +5,21 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
+import logging
 from typing import Any, Optional
 
 from fastapi import APIRouter
+from fastapi import status as st
 from fastapi.responses import UJSONResponse
 from pydantic import BaseModel, Field
 
 from ...__types import DictData
 from ...errors import JobError
 from ...job import Job
-from ...logs import get_logger
 from ...result import Result
 
-logger = get_logger("uvicorn.error")
-job_route = APIRouter(prefix="/job", tags=["job"])
+logger = logging.getLogger("uvicorn.error")
+router = APIRouter(prefix="/job", tags=["job"])
 
 
 class ResultCreate(BaseModel):
@@ -32,14 +33,19 @@ class ResultCreate(BaseModel):
     )
 
 
-@job_route.post(path="/execute/", response_class=UJSONResponse)
+@router.post(
+    path="/execute/",
+    response_class=UJSONResponse,
+    status_code=st.HTTP_200_OK,
+)
 async def job_execute(
     result: ResultCreate,
     job: Job,
     params: dict[str, Any],
     extras: Optional[dict[str, Any]] = None,
-):
+) -> UJSONResponse:
     """Execute job via RestAPI with execute route path."""
+    logger.info("[API]: Start execute job ...")
     rs: Result = Result(
         run_id=result.run_id,
         parent_run_id=result.parent_run_id,
@@ -61,15 +67,35 @@ async def job_execute(
         )
     except JobError as err:
         rs.trace.error(f"[JOB]: {err.__class__.__name__}: {err}")
+        return UJSONResponse(
+            content={
+                "message": str(err),
+                "result": {
+                    "run_id": rs.run_id,
+                    "parent_run_id": rs.parent_run_id,
+                },
+                "job": job.model_dump(
+                    by_alias=True,
+                    exclude_none=False,
+                    exclude_unset=True,
+                ),
+                "params": params,
+                "context": context,
+            },
+            status_code=st.HTTP_500_INTERNAL_SERVER_ERROR,
+        )
 
-    return {
-        "message": "Execute job via RestAPI.",
-        "result": {"run_id": rs.run_id, "parent_run_id": rs.parent_run_id},
-        "job": job.model_dump(
-            by_alias=True,
-            exclude_none=False,
-            exclude_unset=True,
-        ),
-        "params": params,
-        "context": context,
-    }
+    return UJSONResponse(
+        content={
+            "message": "Execute job via RestAPI successful.",
+            "result": {"run_id": rs.run_id, "parent_run_id": rs.parent_run_id},
+            "job": job.model_dump(
+                by_alias=True,
+                exclude_none=False,
+                exclude_unset=True,
+            ),
+            "params": params,
+            "context": context,
+        },
+        status_code=st.HTTP_200_OK,
+    )

ddeutil/workflow/api/routes/logs.py

@@ -13,14 +13,14 @@ from fastapi.responses import UJSONResponse
 from ...logs import get_audit
 from ...result import Result
 
-log_route = APIRouter(
+router = APIRouter(
     prefix="/logs",
     tags=["logs"],
     default_response_class=UJSONResponse,
 )
 
 
-@log_route.get(
+@router.get(
     path="/traces/",
     response_class=UJSONResponse,
     status_code=st.HTTP_200_OK,
@@ -50,7 +50,7 @@ async def get_traces(
     }
 
 
-@log_route.get(
+@router.get(
     path="/traces/{run_id}",
     response_class=UJSONResponse,
     status_code=st.HTTP_200_OK,
@@ -77,7 +77,7 @@ async def get_trace_with_id(run_id: str):
     }
 
 
-@log_route.get(
+@router.get(
     path="/audits/",
     response_class=UJSONResponse,
     status_code=st.HTTP_200_OK,
@@ -94,7 +94,7 @@ async def get_audits():
     }
 
 
-@log_route.get(
+@router.get(
     path="/audits/{workflow}/",
     response_class=UJSONResponse,
     status_code=st.HTTP_200_OK,
@@ -113,7 +113,7 @@ async def get_audit_with_workflow(workflow: str):
     }
 
 
-@log_route.get(
+@router.get(
     path="/audits/{workflow}/{release}",
     response_class=UJSONResponse,
     status_code=st.HTTP_200_OK,
@@ -140,7 +140,7 @@ async def get_audit_with_workflow_release(
     }
 
 
-@log_route.get(
+@router.get(
     path="/audits/{workflow}/{release}/{run_id}",
     response_class=UJSONResponse,
     status_code=st.HTTP_200_OK,

ddeutil/workflow/api/routes/workflows.py

@@ -5,6 +5,7 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
+import logging
 from dataclasses import asdict
 from datetime import datetime
 from typing import Any
@@ -16,19 +17,19 @@ from pydantic import BaseModel
 
 from ...__types import DictData
 from ...conf import Loader
-from ...logs import Audit, get_audit, get_logger
+from ...logs import AuditModel, get_audit
 from ...result import Result
 from ...workflow import Workflow
 
-logger = get_logger("uvicorn.error")
-workflow_route = APIRouter(
+logger = logging.getLogger("uvicorn.error")
+router = APIRouter(
     prefix="/workflows",
     tags=["workflows"],
     default_response_class=UJSONResponse,
 )
 
 
-@workflow_route.get(path="/", status_code=st.HTTP_200_OK)
+@router.get(path="/", status_code=st.HTTP_200_OK)
 async def get_workflows() -> DictData:
     """Return all workflow workflows that exists in config path."""
     workflows: DictData = dict(Loader.finds(Workflow))
@@ -39,7 +40,7 @@ async def get_workflows() -> DictData:
     }
 
 
-@workflow_route.get(path="/{name}", status_code=st.HTTP_200_OK)
+@router.get(path="/{name}", status_code=st.HTTP_200_OK)
 async def get_workflow_by_name(name: str) -> DictData:
     """Return model of workflow that passing an input workflow name."""
     try:
@@ -63,7 +64,7 @@ class ExecutePayload(BaseModel):
     params: dict[str, Any]
 
 
-@workflow_route.post(path="/{name}/execute", status_code=st.HTTP_202_ACCEPTED)
+@router.post(path="/{name}/execute", status_code=st.HTTP_202_ACCEPTED)
 async def workflow_execute(name: str, payload: ExecutePayload) -> DictData:
     """Return model of workflow that passing an input workflow name."""
     try:
@@ -88,7 +89,7 @@ async def workflow_execute(name: str, payload: ExecutePayload) -> DictData:
     return asdict(result)
 
 
-@workflow_route.get(path="/{name}/audits", status_code=st.HTTP_200_OK)
+@router.get(path="/{name}/audits", status_code=st.HTTP_200_OK)
 async def get_workflow_audits(name: str):
     try:
         return {
@@ -109,11 +110,11 @@ async def get_workflow_audits(name: str):
         ) from None
 
 
-@workflow_route.get(path="/{name}/audits/{release}", status_code=st.HTTP_200_OK)
+@router.get(path="/{name}/audits/{release}", status_code=st.HTTP_200_OK)
 async def get_workflow_release_audit(name: str, release: str):
     """Get Workflow audit log with an input release value."""
     try:
-        audit: Audit = get_audit().find_audit_with_release(
+        audit: AuditModel = get_audit().find_audit_with_release(
             name=name,
             release=datetime.strptime(release, "%Y%m%d%H%M%S"),
         )

ddeutil/workflow/cli.py

@@ -1,12 +1,17 @@
 import json
-from typing import Annotated, Any
+from pathlib import Path
+from platform import python_version
+from typing import Annotated, Any, Optional
 
 import typer
 import uvicorn
 
 from .__about__ import __version__
+from .__types import DictData
 from .api import app as fastapp
-from .api.logs import LOGGING_CONFIG
+from .errors import JobError
+from .job import Job
+from .result import Result
 
 app = typer.Typer(
     pretty_exceptions_enable=True,
@@ -15,22 +20,26 @@ app = typer.Typer(
 
 @app.callback()
 def callback():
+    """Manage Workflow CLI app.
+
+    Use it with the interface workflow engine.
     """
-    Awesome Portal Gun
-    """
-    typer.echo("Start call from callback function")
 
 
 @app.command()
 def version():
     """Get the ddeutil-workflow package version."""
-    typer.echo(__version__)
+    typer.echo(f"ddeutil-workflow=={__version__}")
+    typer.echo(f"python-version=={python_version()}")
 
 
 @app.command()
 def job(
     params: Annotated[str, typer.Option(help="A job execute parameters")],
-):
+    job: Annotated[str, typer.Option(help="A job model")],
+    parent_run_id: Annotated[str, typer.Option(help="A parent running ID")],
+    run_id: Annotated[Optional[str], typer.Option(help="A running ID")] = None,
+) -> None:
     """Job execution on the local.
 
     Example:
@@ -39,8 +48,32 @@ def job(
     try:
         params_dict: dict[str, Any] = json.loads(params)
     except json.JSONDecodeError as e:
-        raise ValueError(f"params does not support format: {params!r}.") from e
+        raise ValueError(f"Params does not support format: {params!r}.") from e
+
+    try:
+        job_dict: dict[str, Any] = json.loads(job)
+        _job: Job = Job.model_validate(obj=job_dict)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Params does not support format: {params!r}.") from e
+
     typer.echo(f"Job params: {params_dict}")
+    rs: Result = Result(
+        run_id=run_id,
+        parent_run_id=parent_run_id,
+    )
+
+    context: DictData = {}
+    try:
+        _job.set_outputs(
+            _job.execute(
+                params=params_dict,
+                run_id=rs.run_id,
+                parent_run_id=rs.parent_run_id,
+            ).context,
+            to=context,
+        )
+    except JobError as err:
+        rs.trace.error(f"[JOB]: {err.__class__.__name__}: {err}")
 
 
 @app.command()
@@ -48,19 +81,39 @@ def api(
     host: Annotated[str, typer.Option(help="A host url.")] = "0.0.0.0",
     port: Annotated[int, typer.Option(help="A port url.")] = 80,
     debug: Annotated[bool, typer.Option(help="A debug mode flag")] = True,
+    workers: Annotated[int, typer.Option(help="A worker number")] = None,
+    reload: Annotated[bool, typer.Option(help="A reload flag")] = False,
 ):
     """
     Provision API application from the FastAPI.
     """
+    from .api.log_conf import LOGGING_CONFIG
+
+    # LOGGING_CONFIG = {}
 
     uvicorn.run(
         fastapp,
         host=host,
         port=port,
         log_config=uvicorn.config.LOGGING_CONFIG | LOGGING_CONFIG,
-        log_level=("DEBUG" if debug else "INFO"),
+        # NOTE: Logging level of uvicorn should be lowered case.
+        log_level=("debug" if debug else "info"),
+        workers=workers,
+        reload=reload,
     )
 
 
+@app.command()
+def make(
+    name: Annotated[Path, typer.Argument()],
+) -> None:
+    """
+    Create Workflow YAML template.
+
+    :param name:
+    """
+    typer.echo(f"Start create YAML template filename: {name.resolve()}")
+
+
 if __name__ == "__main__":
     app()

ddeutil/workflow/conf.py

@@ -109,9 +109,9 @@ class Config:  # pragma: no cov
         return env(
             "LOG_FORMAT",
             (
-                "%(asctime)s.%(msecs)03d (%(name)-10s, %(process)-5d, "
+                "%(asctime)s.%(msecs)03d (%(process)-5d, "
                 "%(thread)-5d) [%(levelname)-7s] %(message)-120s "
-                "(%(filename)s:%(lineno)s)"
+                "(%(filename)s:%(lineno)s) (%(name)-10s)"
             ),
         )
 
@@ -161,9 +161,13 @@ class Config:  # pragma: no cov
 class APIConfig:
     """API Config object."""
 
+    @property
+    def version(self) -> str:
+        return env("API_VERSION", "1")
+
     @property
     def prefix_path(self) -> str:
-        return env("API_PREFIX_PATH", "/api/v1")
+        return env("API_PREFIX_PATH", f"/api/v{self.version}")
 
 
 class BaseLoad(ABC):  # pragma: no cov

ddeutil/workflow/errors.py

@@ -90,9 +90,6 @@ class ResultError(UtilError): ...
 class StageError(BaseError): ...
 
 
-class StageRetryError(StageError): ...
-
-
 class StageCancelError(StageError): ...
 
 

ddeutil/workflow/event.py

@@ -3,8 +3,9 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-"""Event module include all event object for trigger the Workflow to release.
-Now, it has only `Crontab` and `CrontabYear` event models on this module because
+"""An Event module keep all triggerable object to the Workflow model. The simple
+event trigger that use to run workflow is `Crontab` model.
+Now, it has only `Crontab` and `CrontabYear` event models in this module because
 I think it is the core event for workflow orchestration.
 """
 from __future__ import annotations
@@ -95,7 +96,7 @@ class Crontab(BaseModel):
     tz: Annotated[
         TimeZoneName,
         Field(
-            description="A timezone string value",
+            description="A timezone string value.",
             alias="timezone",
         ),
     ] = "UTC"

ddeutil/workflow/logs.py

@@ -37,33 +37,34 @@ METADATA: str = "metadata.json"
 
 
 @lru_cache
-def get_logger(name: str):
-    """Return logger object with an input module name.
+def set_logging(name: str) -> logging.Logger:
+    """Return logger object with an input module name that already implement the
+    custom handler and formatter from this package config.
 
     :param name: (str) A module name that want to log.
+
+    :rtype: logging.Logger
     """
-    lg = logging.getLogger(name)
+    _logger = logging.getLogger(name)
 
     # NOTE: Developers using this package can then disable all logging just for
     #   this package by;
     #
     #   `logging.getLogger('ddeutil.workflow').propagate = False`
     #
-    lg.addHandler(logging.NullHandler())
+    _logger.addHandler(logging.NullHandler())
 
     formatter = logging.Formatter(
-        fmt=config.log_format,
-        datefmt=config.log_datetime_format,
+        fmt=config.log_format, datefmt=config.log_datetime_format
     )
-    stream = logging.StreamHandler()
-    stream.setFormatter(formatter)
-    lg.addHandler(stream)
-
-    lg.setLevel(logging.DEBUG if config.debug else logging.INFO)
-    return lg
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(formatter)
+    _logger.addHandler(stream_handler)
+    _logger.setLevel(logging.DEBUG if config.debug else logging.INFO)
+    return _logger
 
 
-logger = get_logger("ddeutil.workflow")
+logger = logging.getLogger("ddeutil.workflow")
 
 
 def get_dt_tznow() -> datetime:  # pragma: no cov
@@ -689,6 +690,9 @@ class BaseAudit(BaseModel, ABC):
         """
         if dynamic("enable_write_audit", extras=self.extras):
             self.do_before()
+
+        # NOTE: Start setting log config in this line with cache.
+        set_logging("ddeutil.workflow")
         return self
 
     @classmethod
@@ -732,7 +736,7 @@ class BaseAudit(BaseModel, ABC):
     @abstractmethod
     def save(self, excluded: Optional[list[str]]) -> None:  # pragma: no cov
         """Save this model logging to target logging store."""
-        raise NotImplementedError("Audit should implement ``save`` method.")
+        raise NotImplementedError("Audit should implement `save` method.")
 
 
 class FileAudit(BaseAudit):

ddeutil/workflow/result.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 
 from dataclasses import field
 from datetime import datetime
-from enum import IntEnum, auto
+from enum import Enum
 from typing import Optional, Union
 
 from pydantic import ConfigDict
@@ -36,16 +36,16 @@ from .logs import TraceModel, get_dt_tznow, get_trace
 from .utils import default_gen_id, gen_id, get_dt_now
 
 
-class Status(IntEnum):
+class Status(str, Enum):
     """Status Int Enum object that use for tracking execution status to the
     Result dataclass object.
     """
 
-    SUCCESS = auto()
-    FAILED = auto()
-    WAIT = auto()
-    SKIP = auto()
-    CANCEL = auto()
+    SUCCESS = "SUCCESS"
+    FAILED = "FAILED"
+    WAIT = "WAIT"
+    SKIP = "SKIP"
+    CANCEL = "CANCEL"
 
     @property
     def emoji(self) -> str:  # pragma: no cov
@@ -67,6 +67,9 @@ class Status(IntEnum):
     def __str__(self) -> str:
         return self.name
 
+    def is_result(self) -> bool:
+        return self in ResultStatuses
+
 
 SUCCESS = Status.SUCCESS
 FAILED = Status.FAILED
@@ -74,6 +77,8 @@ WAIT = Status.WAIT
 SKIP = Status.SKIP
 CANCEL = Status.CANCEL
 
+ResultStatuses: list[Status] = [SUCCESS, FAILED, CANCEL, SKIP]
+
 
 def validate_statuses(statuses: list[Status]) -> Status:
     """Validate the final status from list of Status object.

ddeutil/workflow/stages.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-"""Stages module include all stage model that implemented to be the minimum execution
+r"""Stages module include all stage model that implemented to be the minimum execution
 layer of this workflow core engine. The stage handle the minimize task that run
 in a thread (same thread at its job owner) that mean it is the lowest executor that
 you can track logs.
@@ -15,17 +15,39 @@ have a lot of use-case, and it should does not worry about it error output.
     So, I will create `handler_execute` for any exception class that raise from
 the stage execution method.
 
-    Execution   --> Ok      ┬--( handler )--> Result with `SUCCESS` or `CANCEL`
-                            |
-                            ├--( handler )--> Result with `FAILED` (Set `raise_error` flag)
-                            |
-                            ╰--( handler )---> Result with `SKIP`
+    Handler     --> Ok      --> Result
+                                        |-status: SUCCESS
+                                        ╰-context:
+                                            ╰-outputs: ...
+
+                --> Ok      --> Result
+                                ╰-status: CANCEL
 
-                --> Error   ---( handler )--> Raise StageError(...)
+                --> Ok      --> Result
+                                ╰-status: SKIP
+
+                --> Ok      --> Result
+                                |-status: FAILED
+                                ╰-errors:
+                                    |-name: ...
+                                    ╰-message: ...
 
     On the context I/O that pass to a stage object at execute process. The
 execute method receives a `params={"params": {...}}` value for passing template
 searching.
+
+    All stages model inherit from `BaseStage` or `AsyncBaseStage` models that has the
+base fields:
+
+| field     | alias | data type   | default  | description                                                           |
+|-----------|-------|-------------|:--------:|-----------------------------------------------------------------------|
+| id        |       | str \| None |  `None`  | A stage ID that use to keep execution output or getting by job owner. |
+| name      |       | str         |          | A stage name that want to log when start execution.               |
+| condition | if    | str \| None |  `None`  | A stage condition statement to allow stage executable.                |
+| extras    |       | dict        | `dict()` | An extra parameter that override core config values.                  |
+
+    It has a special base class is `BaseRetryStage` that inherit from `AsyncBaseStage`
+that use to handle retry execution when it got any error with `retry` field.
 """
 from __future__ import annotations
 
@@ -62,10 +84,9 @@ from pydantic import BaseModel, Field, ValidationError
 from pydantic.functional_validators import field_validator, model_validator
 from typing_extensions import Self
 
-from . import StageCancelError, StageRetryError
 from .__types import DictData, DictStr, StrOrInt, StrOrNone, TupleStr
 from .conf import dynamic, pass_env
-from .errors import StageError, StageSkipError, to_dict
+from .errors import StageCancelError, StageError, StageSkipError, to_dict
 from .result import (
     CANCEL,
     FAILED,
@@ -252,16 +273,20 @@ class BaseStage(BaseModel, ABC):
                 f"[STAGE]: Handler {to_train(self.__class__.__name__)}: "
                 f"{self.name!r}."
             )
+
+            # NOTE: Show the description of this stage before execution.
             if self.desc:
                 result.trace.debug(f"[STAGE]: Description:||{self.desc}||")
 
+            # VALIDATE: Checking stage condition before execution.
             if self.is_skipped(params):
                 raise StageSkipError(
                     f"Skip because condition {self.condition} was valid."
                 )
+
             # NOTE: Start call wrapped execution method that will use custom
             #   execution before the real execution from inherit stage model.
-            result_caught: Result = self.__execute(
+            result_caught: Result = self._execute(
                 params, result=result, event=event
             )
             if result_caught.status == WAIT:
@@ -296,7 +321,7 @@ class BaseStage(BaseModel, ABC):
             )
             return result.catch(status=FAILED, context={"errors": to_dict(e)})
 
-    def __execute(
+    def _execute(
         self, params: DictData, result: Result, event: Optional[Event]
     ) -> Result:
         """Wrapped the execute method before returning to handler execution.
@@ -447,6 +472,13 @@ class BaseStage(BaseModel, ABC):
         """
         return False
 
+    def docs(self) -> str:  # pragma: no cov
+        """Return generated document that will be the interface of this stage.
+
+        :rtype: str
+        """
+        return self.desc
+
 
 class BaseAsyncStage(BaseStage, ABC):
     """Base Async Stage model to make any stage model allow async execution for
@@ -514,11 +546,14 @@ class BaseAsyncStage(BaseStage, ABC):
                 f"[STAGE]: Handler {to_train(self.__class__.__name__)}: "
                 f"{self.name!r}."
             )
+
+            # NOTE: Show the description of this stage before execution.
             if self.desc:
                 await result.trace.adebug(
                     f"[STAGE]: Description:||{self.desc}||"
                 )
 
+            # VALIDATE: Checking stage condition before execution.
             if self.is_skipped(params=params):
                 raise StageSkipError(
                     f"Skip because condition {self.condition} was valid."
@@ -526,7 +561,7 @@ class BaseAsyncStage(BaseStage, ABC):
 
             # NOTE: Start call wrapped execution method that will use custom
             #   execution before the real execution from inherit stage model.
-            result_caught: Result = await self.__axecute(
+            result_caught: Result = await self._axecute(
                 params, result=result, event=event
             )
             if result_caught.status == WAIT:
@@ -561,7 +596,7 @@ class BaseAsyncStage(BaseStage, ABC):
             )
             return result.catch(status=FAILED, context={"errors": to_dict(e)})
 
-    async def __axecute(
+    async def _axecute(
         self, params: DictData, result: Result, event: Optional[Event]
     ) -> Result:
         """Wrapped the axecute method before returning to handler axecute.
@@ -588,10 +623,10 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         default=0,
         ge=0,
         lt=20,
-        description="Retry number if stage execution get the error.",
+        description="A retry number if stage execution get the error.",
     )
 
-    def __execute(
+    def _execute(
         self,
         params: DictData,
         result: Result,
@@ -610,15 +645,50 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         :rtype: Result
         """
         current_retry: int = 0
-        with current_retry < (self.retry + 1):
+        exception: Exception
+
+        # NOTE: First execution for not pass to retry step if it passes.
+        try:
+            result.catch(status=WAIT)
+            return self.execute(
+                params | {"retry": current_retry},
+                result=result,
+                event=event,
+            )
+        except Exception as e:
+            current_retry += 1
+            exception = e
+
+        if self.retry == 0:
+            raise exception
+
+        result.trace.warning(
+            f"[STAGE]: Retry count: {current_retry} ... "
+            f"( {exception.__class__.__name__} )"
+        )
+
+        while current_retry < (self.retry + 1):
             try:
                 result.catch(status=WAIT, context={"retry": current_retry})
-                return self.execute(params, result=result, event=event)
-            except StageRetryError:
+                return self.execute(
+                    params | {"retry": current_retry},
+                    result=result,
+                    event=event,
+                )
+            except Exception as e:
                 current_retry += 1
-        raise StageError(f"Reach the maximum of retry number: {self.retry}.")
+                result.trace.warning(
+                    f"[STAGE]: Retry count: {current_retry} ... "
+                    f"( {e.__class__.__name__} )"
+                )
+                exception = e
+
+        result.trace.error(
+            f"[STAGE]: Reach the maximum of retry number: {self.retry}."
+        )
+        raise exception
 
-    async def __axecute(
+    async def _axecute(
         self,
         params: DictData,
         result: Result,
@@ -637,13 +707,48 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         :rtype: Result
         """
         current_retry: int = 0
-        with current_retry < (self.retry + 1):
+        exception: Exception
+
+        # NOTE: First execution for not pass to retry step if it passes.
+        try:
+            result.catch(status=WAIT)
+            return await self.axecute(
+                params | {"retry": current_retry},
+                result=result,
+                event=event,
+            )
+        except Exception as e:
+            current_retry += 1
+            exception = e
+
+        if self.retry == 0:
+            raise exception
+
+        await result.trace.awarning(
+            f"[STAGE]: Retry count: {current_retry} ... "
+            f"( {exception.__class__.__name__} )"
+        )
+
+        while current_retry < (self.retry + 1):
             try:
                 result.catch(status=WAIT, context={"retry": current_retry})
-                return await self.axecute(params, result=result, event=event)
-            except StageRetryError:
+                return await self.axecute(
+                    params | {"retry": current_retry},
+                    result=result,
+                    event=event,
+                )
+            except Exception as e:
                 current_retry += 1
-        raise StageError(f"Reach the maximum of retry number: {self.retry}.")
+                await result.trace.awarning(
+                    f"[STAGE]: Retry count: {current_retry} ... "
+                    f"( {e.__class__.__name__} )"
+                )
+                exception = e
+
+        await result.trace.aerror(
+            f"[STAGE]: Reach the maximum of retry number: {self.retry}."
+        )
+        raise exception
 
 
 class EmptyStage(BaseAsyncStage):
@@ -765,7 +870,7 @@ class EmptyStage(BaseAsyncStage):
         return result.catch(status=SUCCESS)
 
 
-class BashStage(BaseAsyncStage):
+class BashStage(BaseRetryStage):
     """Bash stage executor that execute bash script on the current OS.
     If your current OS is Windows, it will run on the bash from the current WSL.
     It will use `bash` for Windows OS and use `sh` for Linux OS.
@@ -911,9 +1016,8 @@ class BashStage(BaseAsyncStage):
             )
         if rs.returncode > 0:
             e: str = rs.stderr.removesuffix("\n")
-            raise StageError(
-                f"Subprocess: {e}\n---( statement )---\n```bash\n{bash}\n```"
-            )
+            e_bash: str = bash.replace("\n", "\n\t")
+            raise StageError(f"Subprocess: {e}\n\t```bash\n\t{e_bash}\n\t```")
         return result.catch(
             status=SUCCESS,
             context={
@@ -964,9 +1068,8 @@ class BashStage(BaseAsyncStage):
 
         if rs.returncode > 0:
             e: str = rs.stderr.removesuffix("\n")
-            raise StageError(
-                f"Subprocess: {e}\n---( statement )---\n```bash\n{bash}\n```"
-            )
+            e_bash: str = bash.replace("\n", "\n\t")
+            raise StageError(f"Subprocess: {e}\n\t```bash\n\t{e_bash}\n\t```")
         return result.catch(
             status=SUCCESS,
             context={
@@ -977,7 +1080,7 @@ class BashStage(BaseAsyncStage):
         )
 
 
-class PyStage(BaseAsyncStage):
+class PyStage(BaseRetryStage):
     """Python stage that running the Python statement with the current globals
     and passing an input additional variables via `exec` built-in function.
 
@@ -1164,7 +1267,7 @@ class PyStage(BaseAsyncStage):
         )
 
 
-class CallStage(BaseAsyncStage):
+class CallStage(BaseRetryStage):
     """Call stage executor that call the Python function from registry with tag
     decorator function in `reusables` module and run it with input arguments.
 
@@ -1175,7 +1278,7 @@ class CallStage(BaseAsyncStage):
     function complexly that you can for your objective to invoked by this stage
     object.
 
-        This stage is the most powerfull stage of this package for run every
+        This stage is the most powerful stage of this package for run every
     use-case by a custom requirement that you want by creating the Python
     function and adding it to the caller registry value by importer syntax like
     `module.caller.registry` not path style like `module/caller/registry`.
@@ -1433,7 +1536,7 @@ class CallStage(BaseAsyncStage):
             return args
 
 
-class BaseNestedStage(BaseStage, ABC):
+class BaseNestedStage(BaseRetryStage, ABC):
     """Base Nested Stage model. This model is use for checking the child stage
     is the nested stage or not.
     """
@@ -1467,6 +1570,17 @@ class BaseNestedStage(BaseStage, ABC):
         else:
             context["errors"] = error.to_dict(with_refs=True)
 
+    async def axecute(
+        self,
+        params: DictData,
+        *,
+        result: Optional[Result] = None,
+        event: Optional[Event] = None,
+    ) -> Result:
+        raise NotImplementedError(
+            "The nested-stage does not implement the `axecute` method yet."
+        )
+
 
 class TriggerStage(BaseNestedStage):
     """Trigger workflow executor stage that run an input trigger Workflow

ddeutil/workflow/utils.py

@@ -6,15 +6,13 @@
 """Utility function model."""
 from __future__ import annotations
 
-import asyncio
 import stat
 import time
 from collections.abc import Iterator
 from datetime import date, datetime, timedelta
-from functools import wraps
 from hashlib import md5
 from inspect import isfunction
-from itertools import chain, islice, product
+from itertools import product
 from pathlib import Path
 from random import randrange
 from typing import Any, Final, Optional, TypeVar, Union, overload
@@ -258,34 +256,6 @@ def cross_product(matrix: Matrix) -> Iterator[DictData]:
     )
 
 
-def batch(iterable: Union[Iterator[Any], range], n: int) -> Iterator[Any]:
-    """Batch data into iterators of length n. The last batch may be shorter.
-
-    Example:
-        >>> for b in batch(iter('ABCDEFG'), 3):
-        ...     print(list(b))
-        ['A', 'B', 'C']
-        ['D', 'E', 'F']
-        ['G']
-
-    :param iterable:
-    :param n: (int) A number of returning batch size.
-
-    :rtype: Iterator[Any]
-    """
-    if n < 1:
-        raise ValueError("n must be at least one")
-
-    it: Iterator[Any] = iter(iterable)
-    while True:
-        chunk_it = islice(it, n)
-        try:
-            first_el = next(chunk_it)
-        except StopIteration:
-            return
-        yield chain((first_el,), chunk_it)
-
-
 def cut_id(run_id: str, *, num: int = 6) -> str:
     """Cutting running ID with length.
 
@@ -325,24 +295,3 @@ def dump_all(
     elif isinstance(value, BaseModel):
         return value.model_dump(by_alias=by_alias)
     return value
-
-
-def awaitable(func):
-    """Dynamic function to async or not depend on the called statement."""
-
-    @wraps(func)
-    async def async_wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    @wraps(func)
-    def sync_wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    def dispatch(*args, **kwargs):
-        try:
-            asyncio.get_running_loop()
-            return async_wrapper(*args, **kwargs)
-        except RuntimeError:
-            return sync_wrapper(*args, **kwargs)
-
-    return dispatch

{ddeutil_workflow-0.0.66.dist-info → ddeutil_workflow-0.0.68.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: ddeutil-workflow
-Version: 0.0.66
-Summary: Lightweight workflow orchestration
+Version: 0.0.68
+Summary: Lightweight workflow orchestration with YAML template
 Author-email: ddeutils <korawich.anu@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/ddeutils/ddeutil-workflow/
@@ -24,10 +24,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ddeutil[checksum]>=0.4.8
 Requires-Dist: ddeutil-io[toml,yaml]>=0.2.14
-Requires-Dist: pydantic==2.11.4
+Requires-Dist: pydantic==2.11.5
 Requires-Dist: pydantic-extra-types==2.10.4
 Requires-Dist: python-dotenv==1.1.0
-Requires-Dist: typer==0.15.4
+Requires-Dist: typer>=0.16.0
 Provides-Extra: all
 Requires-Dist: fastapi<1.0.0,>=0.115.0; extra == "all"
 Requires-Dist: uvicorn; extra == "all"
@@ -35,18 +35,9 @@ Requires-Dist: httpx; extra == "all"
 Requires-Dist: ujson; extra == "all"
 Requires-Dist: aiofiles; extra == "all"
 Requires-Dist: aiohttp; extra == "all"
-Provides-Extra: api
-Requires-Dist: fastapi<1.0.0,>=0.115.0; extra == "api"
-Requires-Dist: uvicorn; extra == "api"
-Requires-Dist: httpx; extra == "api"
-Requires-Dist: ujson; extra == "api"
-Provides-Extra: async
-Requires-Dist: aiofiles; extra == "async"
-Requires-Dist: aiohttp; extra == "async"
+Requires-Dist: requests==2.32.3; extra == "all"
 Provides-Extra: docker
 Requires-Dist: docker==7.1.0; extra == "docker"
-Provides-Extra: self-hosted
-Requires-Dist: requests==2.32.3; extra == "self-hosted"
 Dynamic: license-file
 
 # Workflow Orchestration
@@ -142,10 +133,10 @@ the base deps.
 If you want to install this package with application add-ons, you should add
 `app` in installation;
 
-| Use-case       | Install Optional         |       Support       |
-|----------------|--------------------------|:-------------------:|
-| Python         | `ddeutil-workflow`       | :heavy_check_mark:  |
-| FastAPI Server | `ddeutil-workflow[api]`  | :heavy_check_mark:  |
+| Use-case       | Install Optional        | Support |
+|----------------|-------------------------|:-------:|
+| Python         | `ddeutil-workflow`      |    ✅    |
+| FastAPI Server | `ddeutil-workflow[all]` |    ✅    |
 
 ## 🎯 Usage
 
@@ -300,40 +291,27 @@ it will use default value and do not raise any error to you.
 ## :rocket: Deployment
 
 This package able to run as an application service for receive manual trigger
-from any node via RestAPI or use to be Scheduler background application
-like crontab job but via Python API or FastAPI app.
+from any node via RestAPI with the FastAPI package.
 
 ### API Server
 
 This server use FastAPI package to be the base application.
 
 ```shell
-(.venv) $ uvicorn ddeutil.workflow.api:app \
-  --host 127.0.0.1 \
-  --port 80 \
-  --no-access-log
+(.venv) $ workflow-cli api --host 127.0.0.1 --port 80
 ```
 
 > [!NOTE]
 > If this package already deploy, it is able to use multiprocess;
-> `uvicorn ddeutil.workflow.api:app --host 127.0.0.1 --port 80 --workers 4`
-
-### Local Schedule
-
-> [!WARNING]
-> This CLI does not implement yet.
-
-```shell
-(.venv) $ ddeutil-workflow schedule
-```
+> `$ workflow-cli api --host 127.0.0.1 --port 80 --workers 4`
 
 ### Docker Container
 
 Build a Docker container from this package.
 
 ```shell
-$ docker build -t ddeutil-workflow:latest -f .container/Dockerfile .
-$ docker run -i ddeutil-workflow:latest ddeutil-workflow
+$ docker pull ghcr.io/ddeutils/ddeutil-workflow:latest
+$ docker run --rm ghcr.io/ddeutils/ddeutil-workflow:latest ddeutil-worker
 ```
 
 ## :speech_balloon: Contribute

ddeutil_workflow-0.0.68.dist-info/RECORD

@@ -0,0 +1,29 @@
+ddeutil/workflow/__about__.py,sha256=sX7SVH5YIxA4EqrZ30bmKtzuaxvEoxEAs2Bc7wFHXgY,28
+ddeutil/workflow/__cron.py,sha256=BOKQcreiex0SAigrK1gnLxpvOeF3aca_rQwyz9Kfve4,28751
+ddeutil/workflow/__init__.py,sha256=JfFZlPRDgR2J0rb0SRejt1OSrOrD3GGv9Um14z8MMfs,901
+ddeutil/workflow/__main__.py,sha256=Qd-f8z2Q2vpiEP2x6PBFsJrpACWDVxFKQk820MhFmHo,59
+ddeutil/workflow/__types.py,sha256=uNfoRbVmNK5O37UUMVnqcmoghD9oMS1q9fXC0APnjSI,4584
+ddeutil/workflow/cli.py,sha256=6cxKS3U9oyGTbCI--4x3aiv536PJ5k2KyLRjAQHE6qA,3136
+ddeutil/workflow/conf.py,sha256=p5QLqRo67nivoHDEj7Rs5P5-qdBvtDa3c9Zaylug6p0,14768
+ddeutil/workflow/errors.py,sha256=4DaKnyUm8RrUyQA5qakgW0ycSQLO7j-owyoh79LWQ5c,2893
+ddeutil/workflow/event.py,sha256=PMGXu0wH9ld-nq670QsGcpHBCNr0Yu5Y3hA_EAPIKyo,11104
+ddeutil/workflow/job.py,sha256=qcbKSOa39256nfJHL0vKJsHrelcRujX5KET2IEGS8dw,38995
+ddeutil/workflow/logs.py,sha256=4jufDRXTgtU9GZ1fVXL37tnihupD69YFSkD-mNQTr_g,31657
+ddeutil/workflow/params.py,sha256=Pco3DyjptC5Jkx53dhLL9xlIQdJvNAZs4FLzMUfXpbQ,12402
+ddeutil/workflow/result.py,sha256=GU84psZFiJ4LRf_HXgz-R98YN4lOUkER0VR7x9DDdOU,7922
+ddeutil/workflow/reusables.py,sha256=jPrOCbxagqRvRFGXJzIyDa1wKV5AZ4crZyJ10cldQP0,21620
+ddeutil/workflow/stages.py,sha256=kzMEMRTEuG52EOw51zyVO6LE-oiiqTIRUCk_OMcWZTM,106506
+ddeutil/workflow/utils.py,sha256=oKrhB-HOogeaO9RGXbe2vAs30A3rMMQxUd2B5pOw8zg,9131
+ddeutil/workflow/workflow.py,sha256=AcSGqsH1N4LqWhYIcCPy9CoV_AGlXUrBgjpl-gniv6g,28267
+ddeutil/workflow/api/__init__.py,sha256=W3fe6_NLHSUzr4Tsu79w3pmvrYjpLeP3zBk4mtpPyqg,2843
+ddeutil/workflow/api/log_conf.py,sha256=P1_a5kjB0dWjSyJvmeKUU8KZdaiNd3UELoL42SiKmzU,2269
+ddeutil/workflow/api/routes/__init__.py,sha256=JRaJZB0D6mgR17MbZo8yLtdYDtD62AA8MdKlFqhG84M,420
+ddeutil/workflow/api/routes/job.py,sha256=x809G5gCbJS257txj9eLLTbCbFK8ercXWzPDLuv5gEM,2953
+ddeutil/workflow/api/routes/logs.py,sha256=ElfXNJmwpeR_nE99RcCOUm2BRfQhly6RE9kZ7xVC530,5284
+ddeutil/workflow/api/routes/workflows.py,sha256=08p2r7xoKrW1tUMKkGCaffBckdV1VvaF3OKCjFygJdE,4392
+ddeutil_workflow-0.0.68.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
+ddeutil_workflow-0.0.68.dist-info/METADATA,sha256=o3fWmIKifoP9HHQEKiELp10WI2XEUvfLCn5hFw4Ol1M,16072
+ddeutil_workflow-0.0.68.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ddeutil_workflow-0.0.68.dist-info/entry_points.txt,sha256=qDTpPSauL0ciO6T4iSVt8bJeYrVEkkoEEw_RlGx6Kgk,63
+ddeutil_workflow-0.0.68.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
+ddeutil_workflow-0.0.68.dist-info/RECORD,,

{ddeutil_workflow-0.0.66.dist-info → ddeutil_workflow-0.0.68.dist-info}/WHEEL

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

ddeutil_workflow-0.0.66.dist-info/RECORD

@@ -1,29 +0,0 @@
-ddeutil/workflow/__about__.py,sha256=nkpvuhIACvuey4B8paloyuDA6U0uRDZqZ83SUGdlIt4,28
-ddeutil/workflow/__cron.py,sha256=BOKQcreiex0SAigrK1gnLxpvOeF3aca_rQwyz9Kfve4,28751
-ddeutil/workflow/__init__.py,sha256=JfFZlPRDgR2J0rb0SRejt1OSrOrD3GGv9Um14z8MMfs,901
-ddeutil/workflow/__main__.py,sha256=Qd-f8z2Q2vpiEP2x6PBFsJrpACWDVxFKQk820MhFmHo,59
-ddeutil/workflow/__types.py,sha256=uNfoRbVmNK5O37UUMVnqcmoghD9oMS1q9fXC0APnjSI,4584
-ddeutil/workflow/cli.py,sha256=__ydzTs_e9C1tHqhnyp__0iKelZJRUwZn8VsyVYw5yo,1458
-ddeutil/workflow/conf.py,sha256=w1WDWZDCvRVDSz2HnJxeqySzpYWSubJZjTVjXO9imK0,14669
-ddeutil/workflow/errors.py,sha256=vh_AbLegPbb61TvfwHmjSz0t2SH09RQuGHCKmoyNjn0,2934
-ddeutil/workflow/event.py,sha256=S2eJAZZx_V5TuQ0l417hFVCtjWXnfNPZBgSCICzxQ48,11041
-ddeutil/workflow/job.py,sha256=qcbKSOa39256nfJHL0vKJsHrelcRujX5KET2IEGS8dw,38995
-ddeutil/workflow/logs.py,sha256=4rL8TsRJsYVqyPfLjFW5bSoWtRwUgwmaRONu7nnVxQ8,31374
-ddeutil/workflow/params.py,sha256=Pco3DyjptC5Jkx53dhLL9xlIQdJvNAZs4FLzMUfXpbQ,12402
-ddeutil/workflow/result.py,sha256=CzSjK9EQtSS0a1z8b6oBW4gg8t0uVbZ_Ppx4Ckvcork,7786
-ddeutil/workflow/reusables.py,sha256=jPrOCbxagqRvRFGXJzIyDa1wKV5AZ4crZyJ10cldQP0,21620
-ddeutil/workflow/stages.py,sha256=s6Jc4A6ApXT40JMrnVf7n7yHG_mmjfHJIOU_niMW5hI,102555
-ddeutil/workflow/utils.py,sha256=slhBbsBNl0yaSk9EOiCK6UL-o7smgHVsLT7svRqAWXU,10436
-ddeutil/workflow/workflow.py,sha256=AcSGqsH1N4LqWhYIcCPy9CoV_AGlXUrBgjpl-gniv6g,28267
-ddeutil/workflow/api/__init__.py,sha256=0UIilYwW29RL6HrCRHACSWvnATJVLSJzXiCMny0bHQk,2627
-ddeutil/workflow/api/logs.py,sha256=NMTnOnsBrDB5129329xF2myLdrb-z9k1MQrmrP7qXJw,1818
-ddeutil/workflow/api/routes/__init__.py,sha256=jC1pM7q4_eo45IyO3hQbbe6RnL9B8ibRq_K6aCMP6Ag,434
-ddeutil/workflow/api/routes/job.py,sha256=32TkNm7QY9gt6fxIqEPjDqPgc8XqDiMPjUb7disSrCw,2143
-ddeutil/workflow/api/routes/logs.py,sha256=QJH8IF102897WLfCJ29-1g15wl29M9Yq6omroZfbahs,5305
-ddeutil/workflow/api/routes/workflows.py,sha256=Gmg3e-K5rfi95pbRtWI_aIr5C089sIde_vefZVvh3U0,4420
-ddeutil_workflow-0.0.66.dist-info/licenses/LICENSE,sha256=nGFZ1QEhhhWeMHf9n99_fdt4vQaXS29xWKxt-OcLywk,1085
-ddeutil_workflow-0.0.66.dist-info/METADATA,sha256=LhCFhlwk3N5wbnylmi7zi3sAJqwxkRVlrRThlNB4Cj0,16676
-ddeutil_workflow-0.0.66.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-ddeutil_workflow-0.0.66.dist-info/entry_points.txt,sha256=qDTpPSauL0ciO6T4iSVt8bJeYrVEkkoEEw_RlGx6Kgk,63
-ddeutil_workflow-0.0.66.dist-info/top_level.txt,sha256=m9M6XeSWDwt_yMsmH6gcOjHZVK5O0-vgtNBuncHjzW4,8
-ddeutil_workflow-0.0.66.dist-info/RECORD,,