ddeutil-workflow 0.0.67__py3-none-any.whl → 0.0.69__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.67"
+__version__: str = "0.0.69"

ddeutil/workflow/__init__.py

@@ -5,23 +5,16 @@
 # ------------------------------------------------------------------------------
 from .__cron import CronJob, CronRunner
 from .__types import DictData, DictStr, Matrix, Re, TupleStr
-from .conf import *
-from .errors import *
-from .event import *
-from .job import *
-from .logs import (
+from .audits import (
     Audit,
     AuditModel,
     FileAudit,
-    FileTrace,
-    Trace,
-    TraceData,
-    TraceMeta,
-    TraceModel,
     get_audit,
-    get_dt_tznow,
-    get_trace,
 )
+from .conf import *
+from .errors import *
+from .event import *
+from .job import *
 from .params import *
 from .result import (
     CANCEL,
@@ -34,5 +27,14 @@ from .result import (
 )
 from .reusables import *
 from .stages import *
+from .traces import (
+    ConsoleTrace,
+    FileTrace,
+    Trace,
+    TraceData,
+    TraceMeta,
+    TraceModel,
+    get_trace,
+)
 from .utils import *
 from .workflow import *

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/log_conf.py

@@ -0,0 +1,59 @@
+from typing import Any
+
+from uvicorn.config import LOGGING_CONFIG as LOGGING_CONFIG_UVICORN
+
+from ..conf import config
+
+LOGGING_CONFIG: dict[str, Any] = {  # pragma: no cov
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "default": LOGGING_CONFIG_UVICORN["formatters"]["default"],
+        "access": LOGGING_CONFIG_UVICORN["formatters"]["access"],
+        "custom": {
+            "format": config.log_format,
+            "datefmt": config.log_datetime_format,
+        },
+    },
+    "root": {
+        "level": "DEBUG" if config.debug else "INFO",
+    },
+    "handlers": {
+        "default": LOGGING_CONFIG_UVICORN["handlers"]["default"],
+        "access": LOGGING_CONFIG_UVICORN["handlers"]["access"],
+        "stream_custom": {
+            "formatter": "custom",
+            "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,
+        # },
+    },
+    "loggers": {
+        "uvicorn": {
+            "handlers": ["default"],
+            "level": "DEBUG" if config.debug else "INFO",
+            "propagate": False,
+        },
+        "uvicorn.access": {
+            "handlers": ["access"],
+            "level": "DEBUG" if config.debug else "INFO",
+            "propagate": False,
+        },
+        "uvicorn.error": {
+            "handlers": ["default"],
+            "level": "DEBUG" if config.debug else "INFO",
+        },
+        "ddeutil.workflow": {
+            "handlers": ["stream_custom"],
+            "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

@@ -10,17 +10,17 @@ from fastapi import APIRouter, Path, Query
 from fastapi import status as st
 from fastapi.responses import UJSONResponse
 
-from ...logs import get_audit
+from ...audits 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
@@ -15,23 +16,23 @@ from fastapi.responses import UJSONResponse
 from pydantic import BaseModel
 
 from ...__types import DictData
-from ...conf import Loader
-from ...logs import Audit, get_audit, get_logger
+from ...audits import AuditModel, get_audit
+from ...conf import YamlParser
 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))
+    workflows: DictData = dict(YamlParser.finds(Workflow))
     return {
         "message": f"Getting all workflows: {len(workflows)}",
         "count": len(workflows),
@@ -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"),
         )