beans-logging 6.0.3__py3-none-any.whl → 7.0.0__py3-none-any.whl

beans_logging/config.py

@@ -1,69 +1,60 @@
-import os
+import sys
 import datetime
 from typing import Any
-from typing_extensions import Self
 
-from pydantic import BaseModel, Field, field_validator, model_validator, ConfigDict
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
 
-from ._constants import LogLevelEnum
-from ._utils import get_slug_name
+import potato_util as utils
+from pydantic import Field, model_validator, field_validator
 
+from ._constants import LogHandlerTypeEnum, LogLevelEnum
+from .schemas import ExtraBaseModel, LogHandlerPM, LoguruHandlerPM
 
-class ExtraBaseModel(BaseModel):
-    model_config = ConfigDict(extra="allow")
 
+def _get_handlers() -> dict[str, LogHandlerPM]:
+    """Get default log handlers.
 
-class StdHandlerConfigPM(ExtraBaseModel):
-    enabled: bool = Field(default=True)
-
+    Returns:
+        dict[str, LogHandlerPM]: Default handlers as dictionary.
+    """
 
-class StreamConfigPM(ExtraBaseModel):
-    use_color: bool = Field(default=True)
-    use_icon: bool = Field(default=False)
-    format_str: str = Field(
-        default=(
-            "[<c>{time:YYYY-MM-DD HH:mm:ss.SSS Z}</c> | <level>{level_short:<5}</level> | <w>{name}:{line}</w>]: "
-            "<level>{message}</level>"
+    _log_handlers: dict[str, LogHandlerPM] = {
+        "default.all.std_handler": LogHandlerPM(type_=LogHandlerTypeEnum.STD),
+        "default.all.file_handler": LogHandlerPM(
+            type_=LogHandlerTypeEnum.FILE, enabled=False
         ),
-        min_length=8,
-        max_length=512,
-    )
-    std_handler: StdHandlerConfigPM = Field(default_factory=StdHandlerConfigPM)
+        "default.err.file_handler": LogHandlerPM(
+            type_=LogHandlerTypeEnum.FILE, error=True, enabled=False
+        ),
+        "default.all.json_handler": LogHandlerPM(
+            type_=LogHandlerTypeEnum.FILE, serialize=True, enabled=False
+        ),
+        "default.err.json_handler": LogHandlerPM(
+            type_=LogHandlerTypeEnum.FILE, serialize=True, error=True, enabled=False
+        ),
+    }
+
+    return _log_handlers
 
 
-class LogHandlersConfigPM(ExtraBaseModel):
-    enabled: bool = Field(default=False)
+class StdConfigPM(ExtraBaseModel):
     format_str: str = Field(
-        default="[{time:YYYY-MM-DD HH:mm:ss.SSS Z} | {level_short:<5} | {name}:{line}]: {message}",
+        default=(
+            "[<c>{time:YYYY-MM-DD HH:mm:ss.SSS Z}</c> | <level>{extra[level_short]:<5}</level> | <w>{name}:{line}</w>]:"
+            " <level>{message}</level>"
+        ),
         min_length=8,
         max_length=512,
     )
-    log_path: str = Field(
-        default="{app_name}.std.all.log", min_length=4, max_length=1024
-    )
-    err_path: str = Field(
-        default="{app_name}.std.err.log", min_length=4, max_length=1024
-    )
-
-    @model_validator(mode="after")
-    def _check_log_path(self) -> Self:
-        if self.log_path == self.err_path:
-            raise ValueError(
-                f"`log_path` and `err_path` attributes have same value: '{self.log_path}', must be different!"
-            )
+    colorize: bool = Field(default=True)
 
-        return self
 
-
-class JsonHandlersConfigPM(ExtraBaseModel):
-    enabled: bool = Field(default=False)
-    use_custom: bool = Field(default=False)
-    log_path: str = Field(
-        default="{app_name}.json.all.log", min_length=4, max_length=1024
-    )
-    err_path: str = Field(
-        default="{app_name}.json.err.log", min_length=4, max_length=1024
-    )
+class PathsConfigPM(ExtraBaseModel):
+    log_path: str = Field(..., min_length=4, max_length=1024)
+    err_path: str = Field(..., min_length=4, max_length=1024)
 
     @model_validator(mode="after")
     def _check_log_path(self) -> Self:
@@ -77,7 +68,7 @@ class JsonHandlersConfigPM(ExtraBaseModel):
 
 class FileConfigPM(ExtraBaseModel):
     logs_dir: str = Field(
-        default_factory=lambda: os.path.join(os.getcwd(), "logs"),
+        default="./logs",
         min_length=2,
         max_length=1024,
     )
@@ -85,10 +76,23 @@ class FileConfigPM(ExtraBaseModel):
         default=10_000_000, ge=1_000, lt=1_000_000_000  # 10MB = 10 * 1000 * 1000
     )
     rotate_time: datetime.time = Field(default_factory=lambda: datetime.time(0, 0, 0))
-    backup_count: int = Field(default=90, ge=1)
+    retention: int = Field(default=90, ge=1)
     encoding: str = Field(default="utf8", min_length=2, max_length=31)
-    log_handlers: LogHandlersConfigPM = Field(default_factory=LogHandlersConfigPM)
-    json_handlers: JsonHandlersConfigPM = Field(default_factory=JsonHandlersConfigPM)
+
+    plain: PathsConfigPM = Field(
+        default_factory=lambda: PathsConfigPM(
+            log_path="{app_name}.all.log",
+            err_path="{app_name}.err.log",
+        )
+    )
+    json_: PathsConfigPM = Field(
+        default_factory=lambda: PathsConfigPM(
+            log_path="json/{app_name}.json.all.log",
+            err_path="json/{app_name}.json.err.log",
+        ),
+        validation_alias="json",
+        serialization_alias="json",
+    )
 
     @field_validator("rotate_time", mode="before")
     @classmethod
@@ -99,14 +103,40 @@ class FileConfigPM(ExtraBaseModel):
         return val
 
 
-class AutoLoadConfigPM(ExtraBaseModel):
-    enabled: bool = Field(default=True)
-    only_base: bool = Field(default=False)
-    ignore_modules: list[str] = Field(default=[])
+class LevelConfigPM(ExtraBaseModel):
+    base: str | int | LogLevelEnum = Field(default=LogLevelEnum.INFO)
+    err: str | int | LogLevelEnum = Field(default=LogLevelEnum.WARNING)
+
+    @field_validator("base", mode="before")
+    @classmethod
+    def _check_level(cls, val: Any) -> Any:
+        if not isinstance(val, (str, int, LogLevelEnum)):
+            raise TypeError(
+                f"Level attribute type {type(val).__name__} is invalid, must be str, int or <LogLevelEnum>!"
+            )
+
+        if utils.is_debug_mode() and (val != LogLevelEnum.TRACE) and (val != 5):
+            val = LogLevelEnum.DEBUG
+
+        return val
+
+
+class DefaultConfigPM(ExtraBaseModel):
+    level: LevelConfigPM = Field(default_factory=LevelConfigPM)
+    std: StdConfigPM = Field(default_factory=StdConfigPM)
+    format_str: str = Field(
+        default="[{time:YYYY-MM-DD HH:mm:ss.SSS Z} | {extra[level_short]:<5} | {name}:{line}]: {message}",
+        min_length=8,
+        max_length=512,
+    )
+    file: FileConfigPM = Field(default_factory=FileConfigPM)
+    custom_serialize: bool = Field(default=False)
 
 
 class InterceptConfigPM(ExtraBaseModel):
-    auto_load: AutoLoadConfigPM = Field(default_factory=AutoLoadConfigPM)
+    enabled: bool = Field(default=True)
+    only_base: bool = Field(default=False)
+    ignore_modules: list[str] = Field(default=[])
     include_modules: list[str] = Field(default=[])
     mute_modules: list[str] = Field(default=[])
 
@@ -116,23 +146,41 @@ class ExtraConfigPM(ExtraBaseModel):
 
 
 class LoggerConfigPM(ExtraBaseModel):
-    app_name: str = Field(default_factory=get_slug_name, min_length=1, max_length=128)
-    level: LogLevelEnum = Field(default=LogLevelEnum.INFO)
-    use_backtrace: bool = Field(default=True)
-    use_diagnose: bool = Field(default=False)
-    stream: StreamConfigPM = Field(default_factory=StreamConfigPM)
-    file: FileConfigPM = Field(default_factory=FileConfigPM)
+    app_name: str = Field(
+        default_factory=utils.get_slug_name, min_length=1, max_length=128
+    )
+    default: DefaultConfigPM = Field(default_factory=DefaultConfigPM)
     intercept: InterceptConfigPM = Field(default_factory=InterceptConfigPM)
+    handlers: dict[str, LogHandlerPM] = Field(default_factory=_get_handlers)
     extra: ExtraConfigPM | None = Field(default_factory=ExtraConfigPM)
 
+    @field_validator("handlers", mode="before")
+    @classmethod
+    def _check_handlers(cls, val: Any) -> Any:
+        if val:
+            if not isinstance(val, dict):
+                raise TypeError(
+                    f"'handlers' attribute type {type(val).__name__} is invalid, must be a dict of <LogHandlerPM>, "
+                    f"<LoguruHandlerPM> or dict!"
+                )
+
+            for _i, _handler in val.items():
+                if not isinstance(_handler, (LogHandlerPM, LoguruHandlerPM, dict)):
+                    raise TypeError(
+                        f"'handlers' attribute index {_i} type {type(_handler).__name__} is invalid, must be "
+                        f"<LogHandlerPM>, <LoguruHandlerPM> or dict!"
+                    )
+
+                if isinstance(_handler, LoguruHandlerPM):
+                    val[_i] = LogHandlerPM(
+                        **_handler.model_dump(exclude_none=True, exclude_unset=True)
+                    )
+                elif isinstance(_handler, dict):
+                    val[_i] = LogHandlerPM(**_handler)
+
+        return val
+
 
 __all__ = [
-    "StdHandlerConfigPM",
-    "StreamConfigPM",
-    "LogHandlersConfigPM",
-    "JsonHandlersConfigPM",
-    "FileConfigPM",
-    "AutoLoadConfigPM",
-    "InterceptConfigPM",
     "LoggerConfigPM",
 ]

beans_logging/filters.py

@@ -1,33 +1,39 @@
-def add_level_short(record: dict) -> dict:
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from loguru import Record
+
+
+def add_level_short(record: "Record") -> "Record":
     """Filter for adding short level name to log record.
 
     Args:
-        record (dict, required): Log record as dictionary.
+        record (Record, required): Log record as dictionary.
 
     Returns:
-        dict: Log record as dictionary with short level name.
+        Record: Log record as dictionary with short level name.
     """
 
-    if "level_short" not in record:
+    if "level_short" not in record["extra"]:
         if record["level"].name == "SUCCESS":
-            record["level_short"] = "OK"
+            record["extra"]["level_short"] = "OK"
         elif record["level"].name == "WARNING":
-            record["level_short"] = "WARN"
+            record["extra"]["level_short"] = "WARN"
         elif record["level"].name == "CRITICAL":
-            record["level_short"] = "CRIT"
+            record["extra"]["level_short"] = "CRIT"
         elif 5 < len(record["level"].name):
-            record["level_short"] = record["level"].name[:5]
+            record["extra"]["level_short"] = record["level"].name[:5]
         else:
-            record["level_short"] = record["level"].name
+            record["extra"]["level_short"] = record["level"].name
 
     return record
 
 
-def use_all_filter(record: dict) -> bool:
+def use_all_filter(record: "Record") -> bool:
     """Filter message for all handlers that use this filter.
 
     Args:
-        record (dict): Log record as dictionary.
+        record (Record): Log record as dictionary.
 
     Returns:
         bool: False if record is disabled by extra 'disable_all' key, True otherwise.
@@ -41,7 +47,7 @@ def use_all_filter(record: dict) -> bool:
     return True
 
 
-def use_std_filter(record: dict) -> bool:
+def use_std_filter(record: "Record") -> bool:
     """Filter message for std handlers that use this filter.
 
     Args:
@@ -60,11 +66,11 @@ def use_std_filter(record: dict) -> bool:
     return True
 
 
-def use_file_filter(record: dict) -> bool:
+def use_file_filter(record: "Record") -> bool:
     """Filter message for file handlers that use this filter.
 
     Args:
-        record (dict): Log record as dictionary.
+        record (Record): Log record as dictionary.
 
     Returns:
         bool: False if record is disabled by extra 'disable_file' key, True otherwise.
@@ -79,11 +85,11 @@ def use_file_filter(record: dict) -> bool:
     return True
 
 
-def use_file_err_filter(record: dict) -> bool:
+def use_file_err_filter(record: "Record") -> bool:
     """Filter message for error file handlers that use this filter.
 
     Args:
-        record (dict): Log record as dictionary.
+        record (Record): Log record as dictionary.
 
     Returns:
         bool: False if record is disabled by extra 'disable_file_err' key, True otherwise.
@@ -98,11 +104,11 @@ def use_file_err_filter(record: dict) -> bool:
     return True
 
 
-def use_file_json_filter(record: dict) -> bool:
+def use_file_json_filter(record: "Record") -> bool:
     """Filter message for json file handlers that use this filter.
 
     Args:
-        record (dict): Log record as dictionary.
+        record (Record): Log record as dictionary.
 
     Returns:
         bool: False if record is disabled by extra 'disable_file_json' key, True otherwise.
@@ -117,11 +123,11 @@ def use_file_json_filter(record: dict) -> bool:
     return True
 
 
-def use_file_json_err_filter(record: dict) -> bool:
+def use_file_json_err_filter(record: "Record") -> bool:
     """Filter message for json error file handlers that use this filter.
 
     Args:
-        record (dict): Log record as dictionary.
+        record (Record): Log record as dictionary.
 
     Returns:
         bool: False if record is disabled by extra 'disable_file_json_err' key, True otherwise.
@@ -134,3 +140,14 @@ def use_file_json_err_filter(record: dict) -> bool:
         return False
 
     return True
+
+
+__all__ = [
+    "add_level_short",
+    "use_all_filter",
+    "use_std_filter",
+    "use_file_filter",
+    "use_file_err_filter",
+    "use_file_json_filter",
+    "use_file_json_err_filter",
+]

beans_logging/formats.py

@@ -1,8 +1,12 @@
 import json
 import traceback
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from loguru import Record
 
-def json_format(record: dict) -> str:
+
+def json_formatter(record: "Record") -> str:
     """Custom json formatter for loguru logger.
 
     Args:
@@ -16,7 +20,11 @@ def json_format(record: dict) -> str:
     if record["exception"]:
         _error = {}
         _error_type, _error_value, _error_traceback = record["exception"]
-        _error["type"] = _error_type.__name__
+        if _error_type:
+            _error["type"] = _error_type.__name__
+        else:
+            _error["type"] = "None"
+
         _error["value"] = str(_error_value)
         _error["traceback"] = "".join(traceback.format_tb(_error_traceback))
 
@@ -24,6 +32,9 @@ def json_format(record: dict) -> str:
     if record["extra"] and (0 < len(record["extra"])):
         _extra = record["extra"]
 
+    if _extra and ("serialized" in _extra):
+        del _extra["serialized"]
+
     _json_record = {
         "timestamp": record["time"].strftime("%Y-%m-%dT%H:%M:%S%z"),
         "level": record["level"].name,
@@ -39,5 +50,10 @@ def json_format(record: dict) -> str:
         "elapsed": str(record["elapsed"]),
     }
 
-    record["serialized"] = json.dumps(_json_record)
-    return "{serialized}\n"
+    record["extra"]["serialized"] = json.dumps(_json_record)
+    return "{extra[serialized]}\n"
+
+
+__all__ = [
+    "json_formatter",
+]

beans_logging/{rotation.py → rotators.py}

@@ -1,43 +1,44 @@
 import datetime
-from typing import TextIO
+from typing import TextIO, TYPE_CHECKING
 
-from loguru._handler import Message
+if TYPE_CHECKING:
+    from loguru import Message
 
 
-class RotationChecker:
-    """RotationChecker class for checking file size and time for rotation.
+class Rotator:
+    """Rotator class for checking file size and time for rotation.
 
     Attributes:
-        _size_limit  (int              ): File size limit for rotation.
-        _dtime_limit (datetime.datetime): Datetime when the log file should rotate.
+        _size_limit (int              ): File size limit for rotation.
+        _dt_limit   (datetime.datetime): Datetime when the log file should rotate.
 
     Methods:
         should_rotate(): Check if the log file should rotate.
     """
 
     def __init__(self, *, rotate_size: int, rotate_time: datetime.time):
-        """RotationChecker constructor method.
+        """Rotator constructor method.
 
         Args:
             rotate_size (int,           required): File size limit for rotation.
             rotate_time (datetime.time, required): Time when the log file should rotate.
         """
 
-        _current_dtime = datetime.datetime.now()
+        _current_dt = datetime.datetime.now()
 
         self._size_limit = rotate_size
-        self._dtime_limit = _current_dtime.replace(
+        self._dt_limit = _current_dt.replace(
             hour=rotate_time.hour,
             minute=rotate_time.minute,
             second=rotate_time.second,
         )
 
-        if _current_dtime >= self._dtime_limit:
+        if _current_dt >= self._dt_limit:
             # The current time is already past the target time so it would rotate already.
             # Add one day to prevent an immediate rotation.
-            self._dtime_limit += datetime.timedelta(days=1)
+            self._dt_limit += datetime.timedelta(days=1)
 
-    def should_rotate(self, message: Message, file: TextIO) -> bool:
+    def should_rotate(self, message: "Message", file: TextIO) -> bool:
         """Check if the log file should rotate.
 
         Args:
@@ -53,11 +54,16 @@ class RotationChecker:
             return True
 
         _elapsed_timestamp = (
-            message.record["time"].timestamp() - self._dtime_limit.timestamp()
+            message.record["time"].timestamp() - self._dt_limit.timestamp()
         )
         if _elapsed_timestamp >= 0:
             _elapsed_days = datetime.timedelta(seconds=_elapsed_timestamp).days
-            self._dtime_limit += datetime.timedelta(days=_elapsed_days + 1)
+            self._dt_limit += datetime.timedelta(days=_elapsed_days + 1)
             return True
 
         return False
+
+
+__all__ = [
+    "Rotator",
+]

beans_logging/schemas.py

@@ -0,0 +1,143 @@
+import os
+import sys
+import inspect
+import datetime
+from pathlib import Path
+from logging import Handler
+from asyncio import AbstractEventLoop
+from multiprocessing.context import BaseContext
+from typing import TYPE_CHECKING, Any, TextIO, Union, Protocol, runtime_checkable
+from collections.abc import Callable, Awaitable
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+if TYPE_CHECKING:
+    from loguru import Record, Message
+from pydantic import BaseModel, Field, ConfigDict, model_validator
+
+from ._constants import LogHandlerTypeEnum, LogLevelEnum
+
+
+class ExtraBaseModel(BaseModel):
+    model_config = ConfigDict(
+        extra="allow",
+        validate_default=True,
+        validate_assignment=True,
+        populate_by_name=True,  # Remove in Pydantic v3
+        serialize_by_alias=True,
+        validate_by_name=True,
+        arbitrary_types_allowed=True,
+    )
+
+
+@runtime_checkable
+class _SupportsWrite(Protocol):
+    def write(self, __s: str) -> Any: ...
+    def flush(self) -> Any: ...
+
+
+_SinkType = Union[
+    str,
+    Path,
+    TextIO,
+    _SupportsWrite,
+    Callable[[Any], Any],
+    Callable[[Any], Awaitable[Any]],
+    Handler,
+]
+
+
+class LoguruHandlerPM(ExtraBaseModel):
+    sink: _SinkType = Field(...)
+    level: str | int | None = Field(default=None)
+    format_: (
+        str | Callable[["Record"], str] | Callable[[dict[str, Any]], str] | None
+    ) = Field(default=None, validation_alias="format", serialization_alias="format")
+    filter_: (
+        Callable[["Record"], bool]
+        | Callable[[dict[str, Any]], bool]
+        | str
+        | dict[str, Any]
+        | None
+    ) = Field(default=None, validation_alias="filter", serialization_alias="filter")
+    colorize: bool | None = Field(default=None)
+    serialize: bool | None = Field(default=None)
+    backtrace: bool | None = Field(default=None)
+    diagnose: bool | None = Field(default=None)
+    enqueue: bool | None = Field(default=None)
+    context: BaseContext | str | None = Field(default=None)
+    catch: bool | None = Field(default=None)
+    loop: AbstractEventLoop | None = Field(default=None)
+    rotation: (
+        str
+        | int
+        | datetime.time
+        | datetime.timedelta
+        | Callable[["Message", TextIO], bool]
+        | Callable[[str, TextIO], bool]
+        | Callable[[str, Any], bool]
+        | None
+    ) = Field(default=None)
+    retention: str | int | datetime.timedelta | Callable[[Any], None] | None = Field(
+        default=None
+    )
+    compression: str | Callable[[str], None] | None = Field(default=None)
+    delay: bool | None = Field(default=None)
+    watch: bool | None = Field(default=None)
+    mode: str | None = Field(default=None)
+    buffering: int | None = Field(default=None)
+    encoding: str | None = Field(default=None)
+
+
+class LogHandlerPM(LoguruHandlerPM):
+    type_: LogHandlerTypeEnum = Field(
+        default=LogHandlerTypeEnum.UNKNOWN,
+        validation_alias="type",
+        serialization_alias="type",
+    )
+    sink: _SinkType | None = Field(default=None)
+    level: str | int | LogLevelEnum | None = Field(default=None)
+    custom_serialize: bool | None = Field(default=None)
+    error: bool = Field(default=False)
+    enabled: bool = Field(default=True)
+
+    @model_validator(mode="after")
+    def _check_all(self) -> Self:
+
+        if (self.loop is not None) and (
+            (not callable(self.sink)) or (not inspect.iscoroutinefunction(self.sink))
+        ):
+            raise ValueError(
+                f"'loop' attribute is set but 'sink' attribute type {type(self.sink)} is invalid, "
+                "'loop' only can be used with async callable (coroutine function) 'sink'!"
+            )
+
+        if not isinstance(self.sink, (str, os.PathLike)):
+            for _attr in (
+                "rotation",
+                "retention",
+                "compression",
+                "delay",
+                "watch",
+                "mode",
+                "buffering",
+                "encoding",
+            ):
+                if getattr(self, _attr) is not None:
+                    raise ValueError(
+                        f"'{_attr}' attribute is set but 'sink' attribute type {type(self.sink).__name__} is invalid, "
+                        f"'{_attr}' can only be used with file path 'sink'!"
+                    )
+
+        return self
+
+
+__all__ = [
+    "ExtraBaseModel",
+    "LoguruHandlerPM",
+    "LogHandlerPM",
+]

beans_logging/sinks.py

@@ -1,9 +1,11 @@
 import sys
+from typing import TYPE_CHECKING
 
-from loguru._handler import Message
+if TYPE_CHECKING:
+    from loguru import Message
 
 
-def std_sink(message: Message):
+def std_sink(message: "Message") -> None:
     """Print message based on log level to stdout or stderr.
 
     Args:
@@ -12,5 +14,12 @@ def std_sink(message: Message):
 
     if message.record["level"].no < 40:
         sys.stdout.write(message)
+        # sys.stdout.flush()
     else:
         sys.stderr.write(message)
+        # sys.stderr.flush()
+
+    return
+
+
+__all__ = ["std_sink"]