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

ddeutil/workflow/__about__.py

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

ddeutil/workflow/__init__.py

@@ -6,8 +6,8 @@
 from .__cron import CronJob, CronRunner
 from .__types import DictData, DictStr, Matrix, Re, TupleStr
 from .conf import *
+from .errors import *
 from .event import *
-from .exceptions import *
 from .job import *
 from .logs import (
     Audit,

ddeutil/workflow/__main__.py

@@ -1,30 +1,4 @@
-import typer
-
-app = typer.Typer()
-
-
-@app.callback()
-def callback():
-    """
-    Awesome Portal Gun
-    """
-
-
-@app.command()
-def provision():
-    """
-    Shoot the portal gun
-    """
-    typer.echo("Shooting portal gun")
-
-
-@app.command()
-def job():
-    """
-    Load the portal gun
-    """
-    typer.echo("Loading portal gun")
-
+from .cli import app
 
 if __name__ == "__main__":
     app()

ddeutil/workflow/api/routes/job.py

@@ -12,7 +12,7 @@ from fastapi.responses import UJSONResponse
 from pydantic import BaseModel, Field
 
 from ...__types import DictData
-from ...exceptions import JobException
+from ...errors import JobError
 from ...job import Job
 from ...logs import get_logger
 from ...result import Result
@@ -59,7 +59,7 @@ async def job_execute(
             ).context,
             to=context,
         )
-    except JobException as err:
+    except JobError as err:
         rs.trace.error(f"[JOB]: {err.__class__.__name__}: {err}")
 
     return {

ddeutil/workflow/cli.py

@@ -0,0 +1,66 @@
+import json
+from typing import Annotated, Any
+
+import typer
+import uvicorn
+
+from .__about__ import __version__
+from .api import app as fastapp
+from .api.logs import LOGGING_CONFIG
+
+app = typer.Typer(
+    pretty_exceptions_enable=True,
+)
+
+
+@app.callback()
+def callback():
+    """
+    Awesome Portal Gun
+    """
+    typer.echo("Start call from callback function")
+
+
+@app.command()
+def version():
+    """Get the ddeutil-workflow package version."""
+    typer.echo(__version__)
+
+
+@app.command()
+def job(
+    params: Annotated[str, typer.Option(help="A job execute parameters")],
+):
+    """Job execution on the local.
+
+    Example:
+        ... workflow-cli job --params "{\"test\": 1}"
+    """
+    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
+    typer.echo(f"Job params: {params_dict}")
+
+
+@app.command()
+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,
+):
+    """
+    Provision API application from the FastAPI.
+    """
+
+    uvicorn.run(
+        fastapp,
+        host=host,
+        port=port,
+        log_config=uvicorn.config.LOGGING_CONFIG | LOGGING_CONFIG,
+        log_level=("DEBUG" if debug else "INFO"),
+    )
+
+
+if __name__ == "__main__":
+    app()

ddeutil/workflow/conf.py

@@ -18,7 +18,7 @@ from zoneinfo import ZoneInfo
 from ddeutil.core import str2bool
 from ddeutil.io import YamlFlResolve, search_env_replace
 from ddeutil.io.paths import glob_files, is_ignored, read_ignore
-from pydantic import SecretStr, TypeAdapter
+from pydantic import SecretStr
 
 from .__types import DictData
 
@@ -141,10 +141,6 @@ class Config:  # pragma: no cov
     def log_datetime_format(self) -> str:
         return env("LOG_DATETIME_FORMAT", "%Y-%m-%d %H:%M:%S")
 
-    @property
-    def stage_raise_error(self) -> bool:
-        return str2bool(env("CORE_STAGE_RAISE_ERROR", "false"))
-
     @property
     def stage_default_id(self) -> bool:
         return str2bool(env("CORE_STAGE_DEFAULT_ID", "false"))
@@ -474,7 +470,3 @@ class CallerSecret(SecretStr):  # pragma: no cov
         :rtype: str
         """
         return pass_env(super().get_secret_value())
-
-
-# NOTE: Define the caller secret type for use it directly in the caller func.
-CallerSecretType = TypeAdapter(CallerSecret)

ddeutil/workflow/{exceptions.py → errors.py}

@@ -11,6 +11,8 @@ from __future__ import annotations
 
 from typing import Literal, Optional, TypedDict, Union, overload
 
+from .__types import DictData, StrOrInt
+
 
 class ErrorData(TypedDict):
     """Error data type dict for typing necessary keys of return of to_dict func
@@ -21,7 +23,7 @@ class ErrorData(TypedDict):
     message: str
 
 
-def to_dict(exception: Exception) -> ErrorData:  # pragma: no cov
+def to_dict(exception: Exception, **kwargs) -> ErrorData:  # pragma: no cov
     """Create dict data from exception instance.
 
     :param exception: An exception object.
@@ -31,17 +33,27 @@ def to_dict(exception: Exception) -> ErrorData:  # pragma: no cov
     return {
         "name": exception.__class__.__name__,
         "message": str(exception),
+        **kwargs,
     }
 
 
-class BaseWorkflowException(Exception):
+class BaseError(Exception):
     """Base Workflow exception class will implement the `refs` argument for
     making an error context to the result context.
     """
 
-    def __init__(self, message: str, *, refs: Optional[str] = None):
+    def __init__(
+        self,
+        message: str,
+        *,
+        refs: Optional[StrOrInt] = None,
+        context: Optional[DictData] = None,
+        params: Optional[DictData] = None,
+    ) -> None:
         super().__init__(message)
         self.refs: Optional[str] = refs
+        self.context: DictData = context or {}
+        self.params: DictData = params or {}
 
     @overload
     def to_dict(
@@ -54,7 +66,9 @@ class BaseWorkflowException(Exception):
     ) -> ErrorData: ...  # pragma: no cov
 
     def to_dict(
-        self, with_refs: bool = False
+        self,
+        with_refs: bool = False,
+        **kwargs,
     ) -> Union[ErrorData, dict[str, ErrorData]]:
         """Return ErrorData data from the current exception object. If with_refs
         flag was set, it will return mapping of refs and itself data.
@@ -64,22 +78,43 @@ class BaseWorkflowException(Exception):
         data: ErrorData = to_dict(self)
         if with_refs and (self.refs is not None and self.refs != "EMPTY"):
             return {self.refs: data}
-        return data
+        return data | kwargs
+
+
+class UtilError(BaseError): ...
+
+
+class ResultError(UtilError): ...
+
+
+class StageError(BaseError): ...
+
+
+class StageRetryError(StageError): ...
+
+
+class StageCancelError(StageError): ...
+
+
+class StageSkipError(StageError): ...
+
+
+class JobError(BaseError): ...
 
 
-class UtilException(BaseWorkflowException): ...
+class JobCancelError(JobError): ...
 
 
-class ResultException(UtilException): ...
+class JobSkipError(JobError): ...
 
 
-class StageException(BaseWorkflowException): ...
+class WorkflowError(BaseError): ...
 
 
-class JobException(BaseWorkflowException): ...
+class WorkflowCancelError(WorkflowError): ...
 
 
-class WorkflowException(BaseWorkflowException): ...
+class WorkflowTimeoutError(WorkflowError): ...
 
 
-class ParamValueException(WorkflowException): ...
+class ParamError(WorkflowError): ...