beans-logging 7.1.0__py3-none-any.whl → 8.0.0__py3-none-any.whl

beans_logging/__init__.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
 from .__version__ import __version__
-from .config import LoggerConfigPM
+from .schemas import LoguruHandlerPM, LogHandlerPM
+from .config import get_default_handlers, LoggerConfigPM
 from ._core import Logger, logger, LoggerLoader
 
 
 __all__ = [
     "__version__",
+    "LoguruHandlerPM",
+    "LogHandlerPM",
+    "get_default_handlers",
     "LoggerConfigPM",
     "Logger",
     "logger",

beans_logging/__version__.py

@@ -1 +1 @@
-__version__ = "7.1.0"
+__version__ = "8.0.0"

beans_logging/_builder.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 from pydantic import validate_call
 
-from ._constants import LogHandlerTypeEnum, LogLevelEnum
+from .constants import LogHandlerTypeEnum, LogLevelEnum
 from .schemas import LogHandlerPM
 from .config import LoggerConfigPM
 from .sinks import std_sink
@@ -35,17 +35,15 @@ def build_handler(handler: LogHandlerPM, config: LoggerConfigPM) -> dict[str, An
         dict[str, Any]: Loguru handler config as dictionary.
     """
 
-    _handler_dict = handler.model_dump(by_alias=True, exclude_none=True)
-
-    if _handler_dict.get("sink") is None:
-        if _handler_dict.get("type") == LogHandlerTypeEnum.STD:
-            _handler_dict["sink"] = std_sink
+    if handler.sink is None:
+        if handler.h_type == LogHandlerTypeEnum.STD:
+            handler.sink = std_sink
         else:
             raise ValueError(
                 "'sink' attribute is empty, required for any log handler except std handler!"
             )
 
-    _sink = _handler_dict.get("sink")
+    _sink = handler.sink
     if isinstance(_sink, (str, Path)):
         if not os.path.isabs(_sink):
             _sink = os.path.join(config.default.file.logs_dir, _sink)
@@ -56,72 +54,75 @@ def build_handler(handler: LogHandlerPM, config: LoggerConfigPM) -> dict[str, An
         if "{app_name}" in _sink:
             _sink = _sink.format(app_name=config.app_name)
 
-        _handler_dict["sink"] = _sink
+        handler.sink = _sink
 
-    if _handler_dict.get("level") is None:
-        if _handler_dict.get("error"):
-            _handler_dict["level"] = config.default.level.err
+    if handler.level is None:
+        if handler.error:
+            handler.level = config.default.level.err
         else:
-            _handler_dict["level"] = config.default.level.base
+            handler.level = config.default.level.base
 
-    if (_handler_dict.get("custom_serialize") is None) and _handler_dict.get(
-        "serialize"
-    ):
-        _handler_dict["custom_serialize"] = config.default.custom_serialize
-
-    if _handler_dict.get("custom_serialize"):
-        _handler_dict["serialize"] = False
-        _handler_dict["format"] = json_formatter
-
-    if (_handler_dict.get("format") is None) and (not _handler_dict.get("serialize")):
-        _handler_dict["format"] = config.default.format_str
-
-    if _handler_dict.get("filter") is None:
-        if _handler_dict.get("type") == LogHandlerTypeEnum.STD:
-            _handler_dict["filter"] = use_std_filter
-        elif _handler_dict.get("type") == LogHandlerTypeEnum.FILE:
-            if _handler_dict.get("serialize") or _handler_dict.get("custom_serialize"):
-                if _handler_dict.get("error"):
-                    _handler_dict["filter"] = use_file_json_err_filter
+    if (handler.custom_serialize is None) and handler.serialize:
+        handler.custom_serialize = config.default.custom_serialize
+
+    if handler.custom_serialize:
+        handler.serialize = False
+        handler.format_ = json_formatter
+
+    if (handler.format_ is None) and (not handler.serialize):
+        handler.format_ = config.default.format_str
+
+    if handler.filter_ is None:
+        if handler.h_type == LogHandlerTypeEnum.STD:
+            handler.filter_ = use_std_filter
+        elif handler.h_type == LogHandlerTypeEnum.FILE:
+            if handler.serialize or handler.custom_serialize:
+                if handler.error:
+                    handler.filter_ = use_file_json_err_filter
                 else:
-                    _handler_dict["filter"] = use_file_json_filter
+                    handler.filter_ = use_file_json_filter
             else:
-                if _handler_dict.get("error"):
-                    _handler_dict["filter"] = use_file_err_filter
+                if handler.error:
+                    handler.filter_ = use_file_err_filter
                 else:
-                    _handler_dict["filter"] = use_file_filter
+                    handler.filter_ = use_file_filter
         else:
-            _handler_dict["filter"] = use_all_filter
+            handler.filter_ = use_all_filter
 
-    if _handler_dict.get("backtrace") is None:
-        _handler_dict["backtrace"] = True
+    if handler.backtrace is None:
+        handler.backtrace = True
 
-    if (_handler_dict.get("diagnose") is None) and (
-        (_handler_dict.get("level") == LogLevelEnum.TRACE)
-        or (_handler_dict.get("level") == 5)
+    if (handler.diagnose is None) and (
+        (handler.level == LogLevelEnum.TRACE) or (handler.level == 5)
     ):
-        _handler_dict["diagnose"] = True
+        handler.diagnose = True
 
-    if _handler_dict.get("type") == LogHandlerTypeEnum.FILE:
-        if _handler_dict.get("enqueue") is None:
-            _handler_dict["enqueue"] = True
+    if handler.h_type == LogHandlerTypeEnum.FILE:
+        if handler.enqueue is None:
+            handler.enqueue = True
 
-        if _handler_dict.get("rotation") is None:
-            _handler_dict["rotation"] = Rotator(
+        if handler.rotation is None:
+            handler.rotation = Rotator(
                 rotate_size=config.default.file.rotate_size,
                 rotate_time=config.default.file.rotate_time,
             ).should_rotate
 
-        if _handler_dict.get("retention") is None:
-            _handler_dict["retention"] = config.default.file.retention
-
-        if _handler_dict.get("encoding") is None:
-            _handler_dict["encoding"] = config.default.file.encoding
-
-    _handler_dict.pop("type", None)
-    _handler_dict.pop("error", None)
-    _handler_dict.pop("custom_serialize", None)
-    _handler_dict.pop("enabled", None)
+        if handler.retention is None:
+            handler.retention = config.default.file.retention
+
+        if handler.encoding is None:
+            handler.encoding = config.default.file.encoding
+
+    _handler_dict = handler.model_dump(
+        by_alias=True,
+        exclude_none=True,
+        exclude={
+            "enabled",
+            "h_type",
+            "error",
+            "custom_serialize",
+        },
+    )
 
     return _handler_dict
 

beans_logging/_core.py

@@ -17,10 +17,11 @@ from pydantic import validate_call
 from potato_util import io as io_utils
 
 # Internal modules
+from .constants import DEFAULT_LOGURU_HANDLER_NAME, DEFAULT_NO_HANDLER_NAME_PREFIX
 from .schemas import LogHandlerPM, LoguruHandlerPM
 from .config import LoggerConfigPM
 from ._builder import build_handler
-from ._intercept import init_intercepter
+from .intercepters import add_intercepter
 
 
 class LoggerLoader:
@@ -52,7 +53,7 @@ class LoggerLoader:
         **kwargs,
     ) -> None:
 
-        self.handlers_map = {"default.loguru_handler": 0}
+        self.handlers_map = {DEFAULT_LOGURU_HANDLER_NAME: 0}
         if not config:
             config = LoggerConfigPM()
 
@@ -63,15 +64,15 @@ class LoggerLoader:
         self.config_path = config_path
 
         if auto_load:
-            self.load()
+            self.load(load_config_file=True)
 
     @validate_call
-    def load(self, load_config_file: bool = True) -> "Logger":
+    def load(self, load_config_file: bool = False) -> "Logger":
         """Load logger handlers based on logger config.
 
         Args:
             load_config_file (bool, optional): Whether to load config from file before loading handlers.
-                                                    Default is True.
+                                                    Default is False.
 
         Returns:
             Logger: Main loguru logger instance.
@@ -84,7 +85,7 @@ class LoggerLoader:
         for _key, _handler in self.config.handlers.items():
             self.add_handler(name=_key, handler=_handler)
 
-        init_intercepter(config=self.config)
+        add_intercepter(config=self.config)
         return logger
 
     def _load_config_file(self) -> None:
@@ -195,7 +196,7 @@ class LoggerLoader:
 
                 _handler_id = logger.add(**_handler_dict)
                 if not name:
-                    name = f"log_handler.{uuid.uuid4().hex}"
+                    name = f"{DEFAULT_NO_HANDLER_NAME_PREFIX}{uuid.uuid4().hex}"
 
                 self.handlers_map[name] = _handler_id
 

beans_logging/config.py

@@ -5,11 +5,19 @@ from typing import Any
 import potato_util as utils
 from pydantic import Field, field_validator
 
-from ._constants import LogHandlerTypeEnum, LogLevelEnum
-from .schemas import ExtraBaseModel, LogHandlerPM, LoguruHandlerPM
-
-
-def _get_handlers() -> dict[str, LogHandlerPM]:
+from .constants import (
+    LogLevelEnum,
+    LogHandlerTypeEnum,
+    DEFAULT_ALL_STD_HANDLER_NAME,
+    DEFAULT_ALL_FILE_HANDLER_NAME,
+    DEFAULT_ERR_FILE_HANDLER_NAME,
+    DEFAULT_ALL_JSON_HANDLER_NAME,
+    DEFAULT_ERR_JSON_HANDLER_NAME,
+)
+from .schemas import ExtraBaseModel, LogHandlerPM
+
+
+def get_default_handlers() -> dict[str, LogHandlerPM]:
     """Get default log handlers.
 
     Returns:
@@ -17,37 +25,37 @@ def _get_handlers() -> dict[str, LogHandlerPM]:
     """
 
     _log_handlers: dict[str, LogHandlerPM] = {
-        "default.all.std_handler": LogHandlerPM(
-            type_=LogHandlerTypeEnum.STD,
+        DEFAULT_ALL_STD_HANDLER_NAME: LogHandlerPM(
+            h_type=LogHandlerTypeEnum.STD,
             format_=(
                 "[<c>{time:YYYY-MM-DD HH:mm:ss.SSS Z}</c> | <level>{extra[level_short]:<5}</level> | "
                 "<w>{name}:{line}</w>]: <level>{message}</level>"
             ),
             colorize=True,
         ),
-        "default.all.file_handler": LogHandlerPM(
-            type_=LogHandlerTypeEnum.FILE,
-            sink="{app_name}.all.log",
+        DEFAULT_ALL_FILE_HANDLER_NAME: LogHandlerPM(
             enabled=False,
+            h_type=LogHandlerTypeEnum.FILE,
+            sink="{app_name}.all.log",
         ),
-        "default.err.file_handler": LogHandlerPM(
-            type_=LogHandlerTypeEnum.FILE,
+        DEFAULT_ERR_FILE_HANDLER_NAME: LogHandlerPM(
+            enabled=False,
+            h_type=LogHandlerTypeEnum.FILE,
             sink="{app_name}.err.log",
             error=True,
-            enabled=False,
         ),
-        "default.all.json_handler": LogHandlerPM(
-            type_=LogHandlerTypeEnum.FILE,
-            sink="json/{app_name}.json.all.log",
-            serialize=True,
+        DEFAULT_ALL_JSON_HANDLER_NAME: LogHandlerPM(
             enabled=False,
+            h_type=LogHandlerTypeEnum.FILE,
+            sink="json/{app_name}.all.json.log",
+            serialize=True,
         ),
-        "default.err.json_handler": LogHandlerPM(
-            type_=LogHandlerTypeEnum.FILE,
-            sink="json/{app_name}.json.err.log",
+        DEFAULT_ERR_JSON_HANDLER_NAME: LogHandlerPM(
+            enabled=False,
+            h_type=LogHandlerTypeEnum.FILE,
+            sink="json/{app_name}.err.json.log",
             serialize=True,
             error=True,
-            enabled=False,
         ),
     }
 
@@ -131,36 +139,54 @@ class LoggerConfigPM(ExtraBaseModel):
     )
     default: DefaultConfigPM = Field(default_factory=DefaultConfigPM)
     intercept: InterceptConfigPM = Field(default_factory=InterceptConfigPM)
-    handlers: dict[str, LogHandlerPM] = Field(default_factory=_get_handlers)
+    handlers: dict[str, LogHandlerPM] = Field(default_factory=get_default_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):
+    def _check_handlers(cls, val: Any) -> dict[str, LogHandlerPM]:
+
+        _default_handlers = get_default_handlers()
+
+        if not val:
+            val = _default_handlers
+            return val
+
+        if not isinstance(val, dict):
+            raise TypeError(
+                f"'handlers' attribute type {type(val).__name__} is invalid, must be a dict of <LogHandlerPM> or dict!"
+            )
+
+        for _key, _handler in val.items():
+            if not isinstance(_handler, (LogHandlerPM, dict)):
                 raise TypeError(
-                    f"'handlers' attribute type {type(val).__name__} is invalid, must be a dict of <LogHandlerPM>, "
-                    f"<LoguruHandlerPM> or dict!"
+                    f"'handlers' attribute's '{_key}' key -> value type {type(_handler).__name__} is invalid, must be "
+                    f"<LogHandlerPM> or dict!"
+                )
+
+            if isinstance(_handler, LogHandlerPM):
+                val[_key] = _handler.model_dump(
+                    by_alias=True, exclude_unset=True, exclude_none=True
                 )
 
-            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!"
-                    )
+        _default_dict = {
+            _key: _handler.model_dump(
+                by_alias=True, exclude_unset=True, exclude_none=True
+            )
+            for _key, _handler in _default_handlers.items()
+        }
+
+        if _default_dict != val:
+            val = utils.deep_merge(_default_dict, val)
 
-                if isinstance(_handler, LoguruHandlerPM):
-                    val[_i] = LogHandlerPM(
-                        **_handler.model_dump(exclude_none=True, exclude_unset=True)
-                    )
-                elif isinstance(_handler, dict):
-                    val[_i] = LogHandlerPM(**_handler)
+        for _key, _handler in val.items():
+            val[_key] = LogHandlerPM(**_handler)
 
         return val
 
 
 __all__ = [
     "LoggerConfigPM",
+    "InterceptConfigPM",
+    "get_default_handlers",
 ]

beans_logging/constants.py

@@ -0,0 +1,46 @@
+from enum import Enum
+
+
+class LogHandlerTypeEnum(str, Enum):
+    STD = "STD"
+    FILE = "FILE"
+    SOCKET = "SOCKET"
+    HTTP = "HTTP"
+    SYSLOG = "SYSLOG"
+    QUEUE = "QUEUE"
+    MEMORY = "MEMORY"
+    NULL = "NULL"
+    CUSTOM = "CUSTOM"
+    UNKNOWN = "UNKNOWN"
+
+
+class LogLevelEnum(str, Enum):
+    TRACE = "TRACE"
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    SUCCESS = "SUCCESS"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+DEFAULT_LOGURU_HANDLER_NAME = "default.loguru.std_handler"
+DEFAULT_ALL_STD_HANDLER_NAME = "default.all.std_handler"
+DEFAULT_ALL_FILE_HANDLER_NAME = "default.all.file_handler"
+DEFAULT_ERR_FILE_HANDLER_NAME = "default.err.file_handler"
+DEFAULT_ALL_JSON_HANDLER_NAME = "default.all.json_handler"
+DEFAULT_ERR_JSON_HANDLER_NAME = "default.err.json_handler"
+DEFAULT_NO_HANDLER_NAME_PREFIX = "log_handler."
+
+
+__all__ = [
+    "LogHandlerTypeEnum",
+    "LogLevelEnum",
+    "DEFAULT_LOGURU_HANDLER_NAME",
+    "DEFAULT_ALL_STD_HANDLER_NAME",
+    "DEFAULT_ALL_FILE_HANDLER_NAME",
+    "DEFAULT_ERR_FILE_HANDLER_NAME",
+    "DEFAULT_ALL_JSON_HANDLER_NAME",
+    "DEFAULT_ERR_JSON_HANDLER_NAME",
+    "DEFAULT_NO_HANDLER_NAME_PREFIX",
+]

beans_logging/{_intercept.py → intercepters.py}

@@ -45,7 +45,7 @@ class InterceptHandler(Handler):
 
 
 @validate_call
-def init_intercepter(config: LoggerConfigPM) -> None:
+def add_intercepter(config: LoggerConfigPM) -> None:
     """Initialize log interceptor based on provided config.
 
     Args:
@@ -102,5 +102,5 @@ def init_intercepter(config: LoggerConfigPM) -> None:
 
 __all__ = [
     "InterceptHandler",
-    "init_intercepter",
+    "add_intercepter",
 ]

beans_logging/schemas.py

@@ -19,7 +19,7 @@ if TYPE_CHECKING:
     from loguru import Record, Message
 from pydantic import BaseModel, Field, ConfigDict, model_validator
 
-from ._constants import LogHandlerTypeEnum, LogLevelEnum
+from .constants import LogHandlerTypeEnum, LogLevelEnum
 
 
 class ExtraBaseModel(BaseModel):
@@ -94,11 +94,7 @@ class LoguruHandlerPM(ExtraBaseModel):
 
 
 class LogHandlerPM(LoguruHandlerPM):
-    type_: LogHandlerTypeEnum = Field(
-        default=LogHandlerTypeEnum.UNKNOWN,
-        validation_alias="type",
-        serialization_alias="type",
-    )
+    h_type: LogHandlerTypeEnum = Field(default=LogHandlerTypeEnum.UNKNOWN)
     sink: _SinkType | None = Field(default=None)
     level: str | int | LogLevelEnum | None = Field(default=None)
     custom_serialize: bool | None = Field(default=None)

{beans_logging-7.1.0.dist-info → beans_logging-8.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beans_logging
-Version: 7.1.0
+Version: 8.0.0
 Summary: 'beans-logging' is a python package for simple logger and easily managing logs.
 Author-email: Batkhuu Byambajav <batkhuu10@gmail.com>
 Project-URL: Homepage, https://github.com/bybatkhuu/module-python-logging
@@ -25,7 +25,7 @@ Requires-Dist: pydantic[timezone]<3.0.0,>=2.5.3
 Requires-Dist: loguru<1.0.0,>=0.7.3
 Requires-Dist: potato_util<1.0.0,>=0.2.0
 Provides-Extra: fastapi
-Requires-Dist: beans-logging-fastapi<2.0.0,>=1.0.0; extra == "fastapi"
+Requires-Dist: beans-logging-fastapi<3.0.0,>=1.0.0; extra == "fastapi"
 Provides-Extra: test
 Requires-Dist: pytest<10.0.0,>=8.0.2; extra == "test"
 Requires-Dist: pytest-cov<8.0.0,>=5.0.0; extra == "test"
@@ -38,6 +38,7 @@ Requires-Dist: build<2.0.0,>=1.1.1; extra == "build"
 Requires-Dist: twine<7.0.0,>=6.0.1; extra == "build"
 Provides-Extra: docs
 Requires-Dist: pylint<5.0.0,>=3.0.4; extra == "docs"
+Requires-Dist: click<8.2.2,>=8.0.0; extra == "docs"
 Requires-Dist: mkdocs-material<10.0.0,>=9.5.50; extra == "docs"
 Requires-Dist: mkdocs-awesome-nav<4.0.0,>=3.0.0; extra == "docs"
 Requires-Dist: mkdocstrings[python]<2.0.0,>=0.24.3; extra == "docs"
@@ -52,6 +53,7 @@ Requires-Dist: wheel<1.0.0,>=0.43.0; extra == "dev"
 Requires-Dist: build<2.0.0,>=1.1.1; extra == "dev"
 Requires-Dist: twine<7.0.0,>=6.0.1; extra == "dev"
 Requires-Dist: pylint<5.0.0,>=3.0.4; extra == "dev"
+Requires-Dist: click<8.2.2,>=8.0.0; extra == "dev"
 Requires-Dist: mkdocs-material<10.0.0,>=9.5.50; extra == "dev"
 Requires-Dist: mkdocs-awesome-nav<4.0.0,>=3.0.0; extra == "dev"
 Requires-Dist: mkdocstrings[python]<2.0.0,>=0.24.3; extra == "dev"
@@ -102,42 +104,7 @@ It is a `Loguru` based custom logging package for python projects.
 - Install [**git**](https://git-scm.com/downloads)
 - Setup an [**SSH key**](https://docs.github.com/en/github/authenticating-to-github/connecting-to-github-with-ssh)
 
-### 2. 📥 Download or clone the repository
-
-[TIP] Skip this step, if you're going to install the package directly from **PyPi** or **GitHub** repository.
-
-**2.1.** Prepare projects directory (if not exists):
-
-```sh
-# Create projects directory:
-mkdir -pv ~/workspaces/projects
-
-# Enter into projects directory:
-cd ~/workspaces/projects
-```
-
-**2.2.** Follow one of the below options **[A]**, **[B]** or **[C]**:
-
-**OPTION A.** Clone the repository:
-
-```sh
-git clone https://github.com/bybatkhuu/module-python-logging.git && \
-    cd module-python-logging
-```
-
-**OPTION B.** Clone the repository (for **DEVELOPMENT**: git + ssh key):
-
-```sh
-git clone git@github.com:bybatkhuu/module-python-logging.git && \
-    cd module-python-logging
-```
-
-**OPTION C.** Download source code:
-
-1. Download archived **zip** file from [**releases**](https://github.com/bybatkhuu/module-python-logging/releases).
-2. Extract it into the projects directory.
-
-### 3. 📦 Install the package
+### 2. 📦 Install the package
 
 [NOTE] Choose one of the following methods to install the package **[A ~ F]**:
 
@@ -156,6 +123,9 @@ pip install git+https://github.com/bybatkhuu/module-python-logging.git
 **OPTION C.** Install from the downloaded **source code**:
 
 ```sh
+git clone https://github.com/bybatkhuu/module-python-logging.git && \
+    cd ./module-python-logging
+
 # Install directly from the source code:
 pip install .
 
@@ -339,30 +309,30 @@ logger:
     mute_modules: []
   handlers:
     default.all.std_handler:
-      type: STD
+      enabled: true
+      h_type: STD
       format: "[<c>{time:YYYY-MM-DD HH:mm:ss.SSS Z}</c> | <level>{extra[level_short]:<5}</level> | <w>{name}:{line}</w>]: <level>{message}</level>"
       colorize: true
-      enabled: true
     default.all.file_handler:
-      type: FILE
-      sink: "{app_name}.all.log"
       enabled: false
+      h_type: FILE
+      sink: "{app_name}.all.log"
     default.err.file_handler:
-      type: FILE
+      enabled: false
+      h_type: FILE
       sink: "{app_name}.err.log"
       error: true
-      enabled: false
     default.all.json_handler:
-      type: FILE
-      sink: "json/{app_name}.json.all.log"
-      serialize: true
       enabled: false
+      h_type: FILE
+      sink: "json/{app_name}.all.json.log"
+      serialize: true
     default.err.json_handler:
-      type: FILE
-      sink: "json/{app_name}.json.err.log"
+      enabled: false
+      h_type: FILE
+      sink: "json/{app_name}.err.json.log"
       serialize: true
       error: true
-      enabled: false
   extra:
 ```
 
@@ -415,7 +385,7 @@ To build the documentation, run the following command:
 pip install -r ./requirements/requirements.docs.txt
 
 # Serve documentation locally (for development):
-mkdocs serve -a 0.0.0.0:8000
+mkdocs serve -a 0.0.0.0:8000 --livereload
 # Or use the docs script:
 ./scripts/docs.sh
 

beans_logging-8.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+beans_logging/__init__.py,sha256=evD0GgFDj9LjQPuJLP_9uEYBPAlU04-nD5Rq1n76Utg,405
+beans_logging/__version__.py,sha256=SWqJTEDnx2fOon29wQowBCNjEkhyhMbbqVsSu4EpdWI,22
+beans_logging/_builder.py,sha256=Pg9fXFPMCe4o-hl1xJPajSTmdglJ0Emofxdzuod_9xM,3935
+beans_logging/_core.py,sha256=lG-wRvQ6vz4rS2Je74MAg80xmdHx2Iue9LHOh2S7zYc,9746
+beans_logging/auto.py,sha256=MoNuQomiIFWQVpNTkOmFFVMo00HBlErfHC728GFOyqc,218
+beans_logging/config.py,sha256=NpZo0wiwsYe25OyPMoHRtkbVG6UxuEHEfO3w7O1kbWM,6102
+beans_logging/constants.py,sha256=Ztt08flQ-378TMYiasAI5pUvLxKJ3p0WEb0w71wXKsE,1169
+beans_logging/filters.py,sha256=-Rys2rwuT7EUvuEA19jnhW6enIEkDuPzeGbAAz6RJSc,3720
+beans_logging/formats.py,sha256=Vrr4RkCfiJl-oi6BLVxeR-k0WhTR0oBI4mpsWgBJBNE,1624
+beans_logging/intercepters.py,sha256=9tgyNXE7d_OlHUl9IJ2yEeDmUWZBYGYCWXMT3r58_RM,3247
+beans_logging/rotators.py,sha256=lzR31sdEPTZVDkyhC81FL4OnezIVKlElGJDRA2Svn2I,2121
+beans_logging/schemas.py,sha256=7C8PKwWVnayX4NmPA-mKajB4Lrksgr0QUJGjbEU5mro,4360
+beans_logging/sinks.py,sha256=7Guusg3N1S-28hLnRzuunP8lXnhexzny3aj-AR0HhuQ,482
+beans_logging-8.0.0.dist-info/licenses/LICENSE.txt,sha256=CUTK-r0BWIg1r0bBiemAcMhakgV0N7HuRhw6rQ-A9A4,1074
+beans_logging-8.0.0.dist-info/METADATA,sha256=P06jptdg47p2ea3XmKb-esErDJ17MZY-Xn0oVpNHYmI,12384
+beans_logging-8.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+beans_logging-8.0.0.dist-info/top_level.txt,sha256=lx8JEqYGNha1sYbVrTtMo2Z01A7Shq8hX6bfsuKLTG8,14
+beans_logging-8.0.0.dist-info/RECORD,,

{beans_logging-7.1.0.dist-info → beans_logging-8.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

beans_logging/_constants.py

@@ -1,30 +0,0 @@
-from enum import Enum
-
-
-class LogHandlerTypeEnum(str, Enum):
-    STD = "STD"
-    FILE = "FILE"
-    SOCKET = "SOCKET"
-    HTTP = "HTTP"
-    SYSLOG = "SYSLOG"
-    QUEUE = "QUEUE"
-    MEMORY = "MEMORY"
-    NULL = "NULL"
-    CUSTOM = "CUSTOM"
-    UNKNOWN = "UNKNOWN"
-
-
-class LogLevelEnum(str, Enum):
-    TRACE = "TRACE"
-    DEBUG = "DEBUG"
-    INFO = "INFO"
-    SUCCESS = "SUCCESS"
-    WARNING = "WARNING"
-    ERROR = "ERROR"
-    CRITICAL = "CRITICAL"
-
-
-__all__ = [
-    "LogHandlerTypeEnum",
-    "LogLevelEnum",
-]

beans_logging-7.1.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-beans_logging/__init__.py,sha256=KOXpuCNTMsdlY9MF6ONwRjM5O1_JCkIzt_qetb2BFTw,261
-beans_logging/__version__.py,sha256=vrQk6cOG_uk0gOqN4qh7NRCxezXfvhv9tT7bwYHyTck,22
-beans_logging/_builder.py,sha256=6v9i6zJIVQPOElZ4x3cI-UULx0ae59qWe0E5G5Vy37M,4469
-beans_logging/_constants.py,sha256=rH9ZN-b7GXNXjbpOZUJfsft54Eiy8jnXm82jsFcMo3k,510
-beans_logging/_core.py,sha256=qkGl5NRKY7lKuVatwFmddwxeYS5viU5DDnfKucWK3Mo,9617
-beans_logging/_intercept.py,sha256=TeYze0eXRMVkOoC9Bl2qmaC7fSwExfQAmmGHz5KiuCU,3249
-beans_logging/auto.py,sha256=MoNuQomiIFWQVpNTkOmFFVMo00HBlErfHC728GFOyqc,218
-beans_logging/config.py,sha256=E_bQy-sJxTIjhpOXOTm-gg5zOcOplcBnCprdl7xDvaY,5534
-beans_logging/filters.py,sha256=-Rys2rwuT7EUvuEA19jnhW6enIEkDuPzeGbAAz6RJSc,3720
-beans_logging/formats.py,sha256=Vrr4RkCfiJl-oi6BLVxeR-k0WhTR0oBI4mpsWgBJBNE,1624
-beans_logging/rotators.py,sha256=lzR31sdEPTZVDkyhC81FL4OnezIVKlElGJDRA2Svn2I,2121
-beans_logging/schemas.py,sha256=b4igq8CkAzn7CGOBDc09hW0YTvWyuWRe97fpv_OaNdk,4444
-beans_logging/sinks.py,sha256=7Guusg3N1S-28hLnRzuunP8lXnhexzny3aj-AR0HhuQ,482
-beans_logging-7.1.0.dist-info/licenses/LICENSE.txt,sha256=CUTK-r0BWIg1r0bBiemAcMhakgV0N7HuRhw6rQ-A9A4,1074
-beans_logging-7.1.0.dist-info/METADATA,sha256=IJ80xo6ZU9nslzIfgXfuwq0ytEiaOLRvn9yZLRFTSjE,13093
-beans_logging-7.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-beans_logging-7.1.0.dist-info/top_level.txt,sha256=lx8JEqYGNha1sYbVrTtMo2Z01A7Shq8hX6bfsuKLTG8,14
-beans_logging-7.1.0.dist-info/RECORD,,