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

beans_logging/config.py

@@ -0,0 +1,186 @@
+import sys
+import datetime
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+import potato_util as utils
+from pydantic import Field, model_validator, field_validator
+
+from ._constants import LogHandlerTypeEnum, LogLevelEnum
+from .schemas import ExtraBaseModel, LogHandlerPM, LoguruHandlerPM
+
+
+def _get_handlers() -> dict[str, LogHandlerPM]:
+    """Get default log handlers.
+
+    Returns:
+        dict[str, LogHandlerPM]: Default handlers as dictionary.
+    """
+
+    _log_handlers: dict[str, LogHandlerPM] = {
+        "default.all.std_handler": LogHandlerPM(type_=LogHandlerTypeEnum.STD),
+        "default.all.file_handler": LogHandlerPM(
+            type_=LogHandlerTypeEnum.FILE, enabled=False
+        ),
+        "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 StdConfigPM(ExtraBaseModel):
+    format_str: str = Field(
+        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,
+    )
+    colorize: bool = Field(default=True)
+
+
+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:
+        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!"
+            )
+
+        return self
+
+
+class FileConfigPM(ExtraBaseModel):
+    logs_dir: str = Field(
+        default="./logs",
+        min_length=2,
+        max_length=1024,
+    )
+    rotate_size: int = Field(
+        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))
+    retention: int = Field(default=90, ge=1)
+    encoding: str = Field(default="utf8", min_length=2, max_length=31)
+
+    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
+    def _check_rotate_time(cls, val: Any) -> Any:
+        if isinstance(val, str):
+            val = datetime.time.fromisoformat(val)
+
+        return val
+
+
+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):
+    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=[])
+
+
+class ExtraConfigPM(ExtraBaseModel):
+    pass
+
+
+class LoggerConfigPM(ExtraBaseModel):
+    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__ = [
+    "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",
+]