ddeutil-workflow 0.0.58__py3-none-any.whl → 0.0.59__py3-none-any.whl

ddeutil/workflow/__about__.py

@@ -1 +1 @@
-__version__: str = "0.0.58"
+__version__: str = "0.0.59"

ddeutil/workflow/__cron.py

@@ -699,9 +699,9 @@ class CronJob:
 
     def schedule(
         self,
-        date: datetime | None = None,
+        date: Optional[datetime] = None,
         *,
-        tz: str | None = None,
+        tz: Optional[str] = None,
     ) -> CronRunner:
         """Returns CronRunner instance that be datetime runner with this
         cronjob. It can use `next`, `prev`, or `reset` methods to generate
@@ -766,7 +766,7 @@ class CronRunner:
     def __init__(
         self,
         cron: CronJob | CronJobYear,
-        date: datetime | None = None,
+        date: Optional[datetime] = None,
         *,
         tz: str | ZoneInfo | None = None,
     ) -> None:

ddeutil/workflow/conf.py

@@ -5,6 +5,7 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
+import copy
 import json
 import os
 from abc import ABC, abstractmethod
@@ -26,13 +27,13 @@ T = TypeVar("T")
 PREFIX: Final[str] = "WORKFLOW"
 
 
-def env(var: str, default: str | None = None) -> str | None:
+def env(var: str, default: Optional[str] = None) -> Optional[str]:
     """Get environment variable with uppercase and adding prefix string.
 
     :param var: (str) A env variable name.
-    :param default: (str | None) A default value if an env var does not set.
+    :param default: (Optional[str]) A default value if an env var does not set.
 
-    :rtype: str | None
+    :rtype: Optional[str]
     """
     return os.getenv(f"{PREFIX}_{var.upper().replace(' ', '_')}", default)
 
@@ -298,6 +299,7 @@ class FileLoad(BaseLoad):
                 f"Multi-config paths does not support for type: {type(paths)}"
             )
         else:
+            paths: list[Path] = copy.deepcopy(paths)
             paths.append(path)
 
         all_data: list[tuple[float, DictData]] = []
@@ -398,7 +400,7 @@ class FileLoad(BaseLoad):
         return is_ignored(file, read_ignore(path / ignore_filename))
 
     @classmethod
-    def filter_yaml(cls, file: Path, name: str | None = None) -> DictData:
+    def filter_yaml(cls, file: Path, name: Optional[str] = None) -> DictData:
         """Read a YAML file context from an input file path and specific name.
 
         :param file: (Path) A file path that want to extract YAML context.

ddeutil/workflow/event.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from dataclasses import fields
 from datetime import datetime
-from typing import Annotated, Any, Literal, Union
+from typing import Annotated, Any, Literal, Optional, Union
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 from pydantic import BaseModel, ConfigDict, Field, ValidationInfo
@@ -28,7 +28,7 @@ Interval = Literal["daily", "weekly", "monthly"]
 def interval2crontab(
     interval: Interval,
     *,
-    day: str | None = None,
+    day: Optional[str] = None,
     time: str = "00:00",
 ) -> str:
     """Return the crontab string that was generated from specific values.

ddeutil/workflow/exceptions.py

@@ -9,7 +9,7 @@ annotate for handle error only.
 """
 from __future__ import annotations
 
-from typing import Literal, TypedDict, overload
+from typing import Literal, Optional, TypedDict, overload
 
 
 class ErrorData(TypedDict):
@@ -39,9 +39,9 @@ class BaseWorkflowException(Exception):
     making an error context to the result context.
     """
 
-    def __init__(self, message: str, *, refs: str | None = None):
+    def __init__(self, message: str, *, refs: Optional[str] = None):
         super().__init__(message)
-        self.refs: str | None = refs
+        self.refs: Optional[str] = refs
 
     @overload
     def to_dict(

ddeutil/workflow/job.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import copy
 import time
+from collections.abc import Iterator
 from concurrent.futures import (
     FIRST_EXCEPTION,
     CancelledError,
@@ -67,8 +68,8 @@ def make(
 
     :param matrix: (Matrix) A matrix values that want to cross product to
         possible parallelism values.
-    :param include: (A list of additional matrix that want to adds-in.
-    :param exclude: (A list of exclude matrix that want to filter-out.
+    :param include: A list of additional matrix that want to adds-in.
+    :param exclude: A list of exclude matrix that want to filter-out.
 
     :rtype: list[DictStr]
     """
@@ -191,22 +192,22 @@ class Strategy(BaseModel):
 class Rule(str, Enum):
     """Rule enum object for assign trigger option."""
 
-    ALL_SUCCESS: str = "all_success"
-    ALL_FAILED: str = "all_failed"
-    ALL_DONE: str = "all_done"
-    ONE_FAILED: str = "one_failed"
-    ONE_SUCCESS: str = "one_success"
-    NONE_FAILED: str = "none_failed"
-    NONE_SKIPPED: str = "none_skipped"
+    ALL_SUCCESS = "all_success"
+    ALL_FAILED = "all_failed"
+    ALL_DONE = "all_done"
+    ONE_FAILED = "one_failed"
+    ONE_SUCCESS = "one_success"
+    NONE_FAILED = "none_failed"
+    NONE_SKIPPED = "none_skipped"
 
 
 class RunsOn(str, Enum):
     """Runs-On enum object."""
 
-    LOCAL: str = "local"
-    SELF_HOSTED: str = "self_hosted"
-    AZ_BATCH: str = "azure_batch"
-    DOCKER: str = "docker"
+    LOCAL = "local"
+    SELF_HOSTED = "self_hosted"
+    AZ_BATCH = "azure_batch"
+    DOCKER = "docker"
 
 
 class BaseRunsOn(BaseModel):  # pragma: no cov
@@ -566,7 +567,7 @@ class Job(BaseModel):
         :param output: (DictData) A result data context that want to extract
             and transfer to the `strategies` key in receive context.
         :param to: (DictData) A received context data.
-        :param job_id: (str | None) A job ID if the `id` field does not set.
+        :param job_id: (Optional[str]) A job ID if the `id` field does not set.
 
         :rtype: DictData
         """
@@ -606,9 +607,9 @@ class Job(BaseModel):
         self,
         params: DictData,
         *,
-        run_id: str | None = None,
-        parent_run_id: str | None = None,
-        event: Event | None = None,
+        run_id: Optional[str] = None,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
     ) -> Result:
         """Job execution with passing dynamic parameters from the workflow
         execution. It will generate matrix values at the first step and run
@@ -676,8 +677,8 @@ def local_execute_strategy(
     strategy: DictData,
     params: DictData,
     *,
-    result: Result | None = None,
-    event: Event | None = None,
+    result: Optional[Result] = None,
+    event: Optional[Event] = None,
 ) -> Result:
     """Local strategy execution with passing dynamic parameters from the
     job execution and strategy matrix.
@@ -799,9 +800,9 @@ def local_execute(
     job: Job,
     params: DictData,
     *,
-    run_id: str | None = None,
-    parent_run_id: str | None = None,
-    event: Event | None = None,
+    run_id: Optional[str] = None,
+    parent_run_id: Optional[str] = None,
+    event: Optional[Event] = None,
 ) -> Result:
     """Local job execution with passing dynamic parameters from the workflow
     execution or directly. It will generate matrix values at the first
@@ -874,10 +875,10 @@ def local_execute(
         status: Status = SUCCESS
 
         if not fail_fast_flag:
-            done: list[Future] = as_completed(futures)
+            done: Iterator[Future] = as_completed(futures)
         else:
             done, not_done = wait(futures, return_when=FIRST_EXCEPTION)
-            if len(done) != len(futures):
+            if len(list(done)) != len(futures):
                 result.trace.warning(
                     "[JOB]: Handler Fail-Fast: Got exception and set event."
                 )
@@ -895,7 +896,7 @@ def local_execute(
                 else ""
             )
             result.trace.debug(f"[JOB]: ... Job was set Fail-Fast{nd}")
-            done: list[Future] = as_completed(futures)
+            done: Iterator[Future] = as_completed(futures)
 
         for future in done:
             try:
@@ -918,9 +919,9 @@ def self_hosted_execute(
     job: Job,
     params: DictData,
     *,
-    run_id: str | None = None,
-    parent_run_id: str | None = None,
-    event: Event | None = None,
+    run_id: Optional[str] = None,
+    parent_run_id: Optional[str] = None,
+    event: Optional[Event] = None,
 ) -> Result:  # pragma: no cov
     """Self-Hosted job execution with passing dynamic parameters from the
     workflow execution or itself execution. It will make request to the
@@ -981,9 +982,9 @@ def azure_batch_execute(
     job: Job,
     params: DictData,
     *,
-    run_id: str | None = None,
-    parent_run_id: str | None = None,
-    event: Event | None = None,
+    run_id: Optional[str] = None,
+    parent_run_id: Optional[str] = None,
+    event: Optional[Event] = None,
 ) -> Result:  # pragma: no cov
     """Azure Batch job execution that will run all job's stages on the Azure
     Batch Node and extract the result file to be returning context result.
@@ -1035,9 +1036,9 @@ def docker_execution(
     job: Job,
     params: DictData,
     *,
-    run_id: str | None = None,
-    parent_run_id: str | None = None,
-    event: Event | None = None,
+    run_id: Optional[str] = None,
+    parent_run_id: Optional[str] = None,
+    event: Optional[Event] = None,
 ):  # pragma: no cov
     """Docker job execution.
 

ddeutil/workflow/logs.py

@@ -3,7 +3,6 @@
 # Licensed under the MIT License. See LICENSE in the project root for
 # license information.
 # ------------------------------------------------------------------------------
-# [x] Use dynamic config
 # [x] Use fix config for `get_logger`, and Model initialize step.
 """A Logs module contain Trace dataclass and Audit Pydantic model.
 """
@@ -14,7 +13,6 @@ import logging
 import os
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
-from dataclasses import field
 from datetime import datetime
 from functools import lru_cache
 from inspect import Traceback, currentframe, getframeinfo
@@ -22,12 +20,11 @@ from pathlib import Path
 from threading import get_ident
 from typing import ClassVar, Literal, Optional, TypeVar, Union
 
-from pydantic import BaseModel, Field
-from pydantic.dataclasses import dataclass
+from pydantic import BaseModel, ConfigDict, Field
 from pydantic.functional_validators import model_validator
 from typing_extensions import Self
 
-from .__types import DictData, DictStr
+from .__types import DictData
 from .conf import config, dynamic
 from .utils import cut_id, get_dt_now, prepare_newline
 
@@ -86,6 +83,7 @@ class TraceMeta(BaseModel):  # pragma: no cov
     """
 
     mode: Literal["stdout", "stderr"] = Field(description="A meta mode.")
+    level: str = Field(description="A log level.")
     datetime: str = Field(description="A datetime in string format.")
     process: int = Field(description="A process ID.")
     thread: int = Field(description="A thread ID.")
@@ -98,13 +96,15 @@ class TraceMeta(BaseModel):  # pragma: no cov
         cls,
         mode: Literal["stdout", "stderr"],
         message: str,
+        level: str,
         *,
         extras: Optional[DictData] = None,
     ) -> Self:
         """Make the current TraceMeta instance that catching local state.
 
-        :param mode: A metadata mode.
-        :param message: A message.
+        :param mode: (Literal["stdout", "stderr"]) A metadata mode.
+        :param message: (str) A message.
+        :param level: (str) A log level.
         :param extras: (DictData) An extra parameter that want to override core
             config values.
 
@@ -116,6 +116,7 @@ class TraceMeta(BaseModel):  # pragma: no cov
         extras: DictData = extras or {}
         return cls(
             mode=mode,
+            level=level,
             datetime=(
                 get_dt_now(tz=dynamic("tz", extras=extras)).strftime(
                     dynamic("log_datetime_format", extras=extras)
@@ -150,7 +151,7 @@ class TraceData(BaseModel):  # pragma: no cov
 
         :rtype: Self
         """
-        data: DictStr = {"stdout": "", "stderr": "", "meta": []}
+        data: DictData = {"stdout": "", "stderr": "", "meta": []}
 
         for mode in ("stdout", "stderr"):
             if (file / f"{mode}.txt").exists():
@@ -169,19 +170,28 @@ class TraceData(BaseModel):  # pragma: no cov
         return cls.model_validate(data)
 
 
-@dataclass(frozen=True)
-class BaseTrace(ABC):  # pragma: no cov
-    """Base Trace dataclass with abstraction class property."""
+class BaseTrace(BaseModel, ABC):  # pragma: no cov
+    """Base Trace model with abstraction class property."""
 
-    run_id: str
-    parent_run_id: Optional[str] = field(default=None)
-    extras: DictData = field(default_factory=dict, compare=False, repr=False)
+    model_config = ConfigDict(frozen=True)
+
+    run_id: str = Field(default="A running ID")
+    parent_run_id: Optional[str] = Field(
+        default=None, description="A parent running ID"
+    )
+    extras: DictData = Field(
+        default_factory=dict,
+        description=(
+            "An extra parameter that want to override on the core config "
+            "values."
+        ),
+    )
 
     @classmethod
     @abstractmethod
     def find_traces(
         cls,
-        path: Path | None = None,
+        path: Optional[Path] = None,
         extras: Optional[DictData] = None,
     ) -> Iterator[TraceData]:  # pragma: no cov
         raise NotImplementedError(
@@ -195,7 +205,7 @@ class BaseTrace(ABC):  # pragma: no cov
         run_id: str,
         force_raise: bool = True,
         *,
-        path: Path | None = None,
+        path: Optional[Path] = None,
         extras: Optional[DictData] = None,
     ) -> TraceData:
         raise NotImplementedError(
@@ -204,24 +214,30 @@ class BaseTrace(ABC):  # pragma: no cov
         )
 
     @abstractmethod
-    def writer(self, message: str, is_err: bool = False) -> None:
+    def writer(self, message: str, level: str, is_err: bool = False) -> None:
         """Write a trace message after making to target pointer object. The
         target can be anything be inherited this class and overwrite this method
         such as file, console, or database.
 
-        :param message: A message after making.
-        :param is_err: A flag for writing with an error trace or not.
+        :param message: (str) A message after making.
+        :param level: (str) A log level.
+        :param is_err: (bool) A flag for writing with an error trace or not.
+            (Default be False)
         """
         raise NotImplementedError(
             "Create writer logic for this trace object before using."
         )
 
     @abstractmethod
-    async def awriter(self, message: str, is_err: bool = False) -> None:
+    async def awriter(
+        self, message: str, level: str, is_err: bool = False
+    ) -> None:
         """Async Write a trace message after making to target pointer object.
 
-        :param message:
-        :param is_err:
+        :param message: (str) A message after making.
+        :param level: (str) A log level.
+        :param is_err: (bool) A flag for writing with an error trace or not.
+            (Default be False)
         """
         raise NotImplementedError(
             "Create async writer logic for this trace object before using."
@@ -252,7 +268,7 @@ class BaseTrace(ABC):  # pragma: no cov
         if mode != "debug" or (
             mode == "debug" and dynamic("debug", extras=self.extras)
         ):
-            self.writer(msg, is_err=is_err)
+            self.writer(msg, level=mode, is_err=is_err)
 
         getattr(logger, mode)(msg, stacklevel=3)
 
@@ -309,7 +325,7 @@ class BaseTrace(ABC):  # pragma: no cov
         if mode != "debug" or (
             mode == "debug" and dynamic("debug", extras=self.extras)
         ):
-            await self.awriter(msg, is_err=is_err)
+            await self.awriter(msg, level=mode, is_err=is_err)
 
         getattr(logger, mode)(msg, stacklevel=3)
 
@@ -360,7 +376,7 @@ class FileTrace(BaseTrace):  # pragma: no cov
     @classmethod
     def find_traces(
         cls,
-        path: Path | None = None,
+        path: Optional[Path] = None,
         extras: Optional[DictData] = None,
     ) -> Iterator[TraceData]:  # pragma: no cov
         """Find trace logs.
@@ -380,7 +396,7 @@ class FileTrace(BaseTrace):  # pragma: no cov
         run_id: str,
         *,
         force_raise: bool = True,
-        path: Path | None = None,
+        path: Optional[Path] = None,
         extras: Optional[DictData] = None,
     ) -> TraceData:
         """Find trace log with an input specific run ID.
@@ -399,7 +415,7 @@ class FileTrace(BaseTrace):  # pragma: no cov
                 f"Trace log on path {base_path}, does not found trace "
                 f"'run_id={run_id}'."
             )
-        return {}
+        return TraceData(stdout="", stderr="")
 
     @property
     def pointer(self) -> Path:
@@ -433,7 +449,7 @@ class FileTrace(BaseTrace):  # pragma: no cov
         """
         return f"({self.cut_id}) {message}"
 
-    def writer(self, message: str, is_err: bool = False) -> None:
+    def writer(self, message: str, level: str, is_err: bool = False) -> None:
         """Write a trace message after making to target file and write metadata
         in the same path of standard files.
 
@@ -443,16 +459,19 @@ class FileTrace(BaseTrace):  # pragma: no cov
             ... ./logs/run_id=<run-id>/stdout.txt
             ... ./logs/run_id=<run-id>/stderr.txt
 
-        :param message: A message after making.
+        :param message: (str) A message after making.
+        :param level: (str) A log level.
         :param is_err: A flag for writing with an error trace or not.
         """
         if not dynamic("enable_write_log", extras=self.extras):
             return
 
-        write_file: str = "stderr" if is_err else "stdout"
-        trace_meta: TraceMeta = TraceMeta.make(mode=write_file, message=message)
+        mode: Literal["stdout", "stderr"] = "stderr" if is_err else "stdout"
+        trace_meta: TraceMeta = TraceMeta.make(
+            mode=mode, level=level, message=message
+        )
 
-        with (self.pointer / f"{write_file}.txt").open(
+        with (self.pointer / f"{mode}.txt").open(
             mode="at", encoding="utf-8"
         ) as f:
             fmt: str = dynamic("log_format_file", extras=self.extras)
@@ -464,7 +483,7 @@ class FileTrace(BaseTrace):  # pragma: no cov
             f.write(trace_meta.model_dump_json() + "\n")
 
     async def awriter(
-        self, message: str, is_err: bool = False
+        self, message: str, level: str, is_err: bool = False
     ) -> None:  # pragma: no cov
         """Write with async mode."""
         if not dynamic("enable_write_log", extras=self.extras):
@@ -475,11 +494,13 @@ class FileTrace(BaseTrace):  # pragma: no cov
         except ImportError as e:
             raise ImportError("Async mode need aiofiles package") from e
 
-        write_file: str = "stderr" if is_err else "stdout"
-        trace_meta: TraceMeta = TraceMeta.make(mode=write_file, message=message)
+        mode: Literal["stdout", "stderr"] = "stderr" if is_err else "stdout"
+        trace_meta: TraceMeta = TraceMeta.make(
+            mode=mode, level=level, message=message
+        )
 
         async with aiofiles.open(
-            self.pointer / f"{write_file}.txt", mode="at", encoding="utf-8"
+            self.pointer / f"{mode}.txt", mode="at", encoding="utf-8"
         ) as f:
             fmt: str = dynamic("log_format_file", extras=self.extras)
             await f.write(f"{fmt}\n".format(**trace_meta.model_dump()))
@@ -507,7 +528,7 @@ class SQLiteTrace(BaseTrace):  # pragma: no cov
     @classmethod
     def find_traces(
         cls,
-        path: Path | None = None,
+        path: Optional[Path] = None,
         extras: Optional[DictData] = None,
     ) -> Iterator[TraceData]: ...
 
@@ -517,15 +538,19 @@ class SQLiteTrace(BaseTrace):  # pragma: no cov
         run_id: str,
         force_raise: bool = True,
         *,
-        path: Path | None = None,
+        path: Optional[Path] = None,
         extras: Optional[DictData] = None,
     ) -> TraceData: ...
 
     def make_message(self, message: str) -> str: ...
 
-    def writer(self, message: str, is_err: bool = False) -> None: ...
+    def writer(
+        self, message: str, level: str, is_err: bool = False
+    ) -> None: ...
 
-    def awriter(self, message: str, is_err: bool = False) -> None: ...
+    def awriter(
+        self, message: str, level: str, is_err: bool = False
+    ) -> None: ...
 
 
 Trace = TypeVar("Trace", bound=BaseTrace)
@@ -538,7 +563,7 @@ TraceModel = Union[
 def get_trace(
     run_id: str,
     *,
-    parent_run_id: str | None = None,
+    parent_run_id: Optional[str] = None,
     extras: Optional[DictData] = None,
 ) -> TraceModel:  # pragma: no cov
     """Get dynamic Trace instance from the core config (it can override by an
@@ -553,9 +578,11 @@ def get_trace(
     """
     if dynamic("trace_path", extras=extras).is_file():
         return SQLiteTrace(
-            run_id, parent_run_id=parent_run_id, extras=(extras or {})
+            run_id=run_id, parent_run_id=parent_run_id, extras=(extras or {})
         )
-    return FileTrace(run_id, parent_run_id=parent_run_id, extras=(extras or {}))
+    return FileTrace(
+        run_id=run_id, parent_run_id=parent_run_id, extras=(extras or {})
+    )
 
 
 class BaseAudit(BaseModel, ABC):
@@ -619,7 +646,7 @@ class BaseAudit(BaseModel, ABC):
     def find_audit_with_release(
         cls,
         name: str,
-        release: datetime | None = None,
+        release: Optional[datetime] = None,
         *,
         extras: Optional[DictData] = None,
     ) -> Self:
@@ -631,7 +658,7 @@ class BaseAudit(BaseModel, ABC):
         """To something before end up of initial log model."""
 
     @abstractmethod
-    def save(self, excluded: list[str] | None) -> None:  # pragma: no cov
+    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.")
 
@@ -676,7 +703,7 @@ class FileAudit(BaseAudit):
     def find_audit_with_release(
         cls,
         name: str,
-        release: datetime | None = None,
+        release: Optional[datetime] = None,
         *,
         extras: Optional[DictData] = None,
     ) -> Self:
@@ -749,7 +776,7 @@ class FileAudit(BaseAudit):
             "audit_path", extras=self.extras
         ) / self.filename_fmt.format(name=self.name, release=self.release)
 
-    def save(self, excluded: list[str] | None) -> Self:
+    def save(self, excluded: Optional[list[str]]) -> Self:
         """Save logging data that receive a context data from a workflow
         execution result.
 
@@ -758,7 +785,7 @@ class FileAudit(BaseAudit):
 
         :rtype: Self
         """
-        trace: Trace = get_trace(
+        trace: TraceModel = get_trace(
             self.run_id,
             parent_run_id=self.parent_run_id,
             extras=self.extras,
@@ -818,16 +845,16 @@ class SQLiteAudit(BaseAudit):  # pragma: no cov
     def find_audit_with_release(
         cls,
         name: str,
-        release: datetime | None = None,
+        release: Optional[datetime] = None,
         *,
         extras: Optional[DictData] = None,
     ) -> Self: ...
 
-    def save(self, excluded: list[str] | None) -> SQLiteAudit:
+    def save(self, excluded: Optional[list[str]]) -> SQLiteAudit:
         """Save logging data that receive a context data from a workflow
         execution result.
         """
-        trace: Trace = get_trace(
+        trace: TraceModel = get_trace(
             self.run_id,
             parent_run_id=self.parent_run_id,
             extras=self.extras,

ddeutil/workflow/params.py

@@ -82,7 +82,9 @@ class DateParam(DefaultParam):  # pragma: no cov
         description="A default date that make from the current date func.",
     )
 
-    def receive(self, value: Optional[str | datetime | date] = None) -> date:
+    def receive(
+        self, value: Optional[Union[str, datetime, date]] = None
+    ) -> date:
         """Receive value that match with date. If an input value pass with
         None, it will use default value instead.
 
@@ -121,7 +123,9 @@ class DatetimeParam(DefaultParam):
         ),
     )
 
-    def receive(self, value: str | datetime | date | None = None) -> datetime:
+    def receive(
+        self, value: Optional[Union[str, datetime, date]] = None
+    ) -> datetime:
         """Receive value that match with datetime. If an input value pass with
         None, it will use default value instead.
 
@@ -155,11 +159,11 @@ class StrParam(DefaultParam):
 
     type: Literal["str"] = "str"
 
-    def receive(self, value: str | None = None) -> str | None:
+    def receive(self, value: Optional[str] = None) -> Optional[str]:
         """Receive value that match with str.
 
         :param value: A value that want to validate with string parameter type.
-        :rtype: str | None
+        :rtype: Optional[str]
         """
         if value is None:
             return self.default
@@ -171,7 +175,7 @@ class IntParam(DefaultParam):
 
     type: Literal["int"] = "int"
 
-    def receive(self, value: int | None = None) -> int | None:
+    def receive(self, value: Optional[int] = None) -> Optional[int]:
         """Receive value that match with int.
 
         :param value: A value that want to validate with integer parameter type.