lager - npm Package Compare versions

Comparing version 0.17.2 to 0.18.1

lager/logging/__init__.py

+# -*- coding: utf-8 -*-
+"""Lager/Loguru + std logging"""
+from __future__ import annotations
+
+import logging
+
+from logging import (
+    BASIC_FORMAT as BASIC_FORMAT,
+    CRITICAL as CRITICAL,
+    DEBUG as DEBUG,
+    ERROR as ERROR,
+    FATAL as FATAL,
+    INFO as INFO,
+    NOTSET as NOTSET,
+    WARN as WARN,
+    WARNING as WARNING,
+    BufferingFormatter as BufferingFormatter,
+    FileHandler as FileHandler,
+    Filter as Filter,
+    Formatter as Formatter,
+    Handler as _Handler,
+    Logger as _Logger,
+    LoggerAdapter as LoggerAdapter,
+    LogRecord as LogRecord,
+    NullHandler as NullHandler,
+    StreamHandler as StreamHandler,
+    addLevelName as addLevelName,
+    addLevelName as add_level_name,
+    basicConfig as basicConfig,
+    basicConfig as basic_config,
+    captureWarnings as captureWarnings,
+    captureWarnings as capture_warnings,
+    critical as critical,
+    debug as debug,
+    disable as disable,
+    error as error,
+    exception as exception,
+    fatal as fatal,
+    getLevelName as getLevelName,
+    getLevelName as get_level_name,
+    getLogger as getLogger,
+    getLogger as get_logger,
+    getLoggerClass as getLoggerClass,
+    getLoggerClass as get_logger_class,
+    getLogRecordFactory as getLogRecordFactory,
+    getLogRecordFactory as get_log_record_factory,
+    info as info,
+    lastResort as lastResort,
+    lastResort as last_resort,
+    log as log,
+    makeLogRecord as makeLogRecord,
+    makeLogRecord as make_log_record,
+    raiseExceptions as raiseExceptions,
+    raiseExceptions as raise_exceptions,
+    setLoggerClass as setLoggerClass,
+    setLoggerClass as set_logger_class,
+    setLogRecordFactory as setLogRecordFactory,
+    setLogRecordFactory as set_log_record_factory,
+    shutdown as shutdown,
+    warn as warn,
+    warning as warning,
+)
+from types import TracebackType
+from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, Type, Union
+
+from typing_extensions import Literal, Self, TypeAlias
+
+from lager.core import LOG, loglevel
+
+__all__ = (
+    "BASIC_FORMAT",
+    "BufferingFormatter",
+    "CRITICAL",
+    "DEBUG",
+    "ERROR",
+    "FATAL",
+    "FileHandler",
+    "Filter",
+    "Formatter",
+    "Handler",
+    "INFO",
+    "LogRecord",
+    "Logger",
+    "LoggerAdapter",
+    "NOTSET",
+    "NullHandler",
+    "StreamHandler",
+    "WARN",
+    "WARNING",
+    "addLevelName",
+    "add_level_name",
+    "basicConfig",
+    "basic_config",
+    "captureWarnings",
+    "capture_warnings",
+    "critical",
+    "debug",
+    "disable",
+    "error",
+    "exception",
+    "fatal",
+    "getLevelName",
+    "getLogRecordFactory",
+    "getLogger",
+    "getLoggerClass",
+    "get_level_name",
+    "get_log_record_factory",
+    "get_logger",
+    "get_logger_class",
+    "info",
+    "lastResort",
+    "last_resort",
+    "log",
+    "makeLogRecord",
+    "make_log_record",
+    "raiseExceptions",
+    "raise_exceptions",
+    "setLogRecordFactory",
+    "setLoggerClass",
+    "set_log_record_factory",
+    "set_logger_class",
+    "shutdown",
+    "warn",
+    "warning",
+    # lager.logging members
+    "__aliases__",
+    "StdLoggingHandler",
+    "loggers_dict",
+    "intercept",
+    "intercept_all",
+    "patch_logging",
+)
+
+# logging snake_case aliases bc I cannot stand camelCase
+__aliases__ = {
+    "add_level_name": "addLevelName",
+    "basic_config": "basicConfig",
+    "capture_warnings": "captureWarnings",
+    "get_level_name": "getLevelName",
+    "get_log_record_factory": "getLogRecordFactory",
+    "get_logger": "getLogger",
+    "get_logger_class": "getLoggerClass",
+    "last_resort": "lastResort",
+    "make_log_record": "makeLogRecord",
+    "raise_exceptions": "raiseExceptions",
+    "set_log_record_factory": "setLogRecordFactory",
+    "set_logger_class": "setLoggerClass",
+}
+
+_SysExcInfoType: TypeAlias = Union[
+    Tuple[Type[BaseException], BaseException, Union[TracebackType, None]],
+    Tuple[None, None, None],
+]
+_ExcInfoType: TypeAlias = Union[None, bool, _SysExcInfoType, BaseException]
+_ArgsType: TypeAlias = Union[Tuple[object, ...], Mapping[str, object]]
+_FilterType: TypeAlias = Union[Filter, Callable[[LogRecord], bool]]
+_Level: TypeAlias = Union[int, str]
+_FormatStyle: TypeAlias = Literal["%", "{", "$"]
+
+
+class Logger(_Logger):
+    def __init__(self, name: str, level: _Level = 0) -> None:
+        super().__init__(name, level)
+
+    def set_level(self, level: _Level) -> None:
+        """snake_case alias for setLevel"""
+        self.setLevel(level)
+
+    def is_enabled_for(self, level: int) -> bool:
+        """snake_case alias for isEnabledFor"""
+        return self.isEnabledFor(level)
+
+    def get_effective_level(self) -> int:
+        """snake_case alias for getEffectiveLevel"""
+        return self.getEffectiveLevel()
+
+    def get_child(self, suffix: str) -> Self:
+        """snake_case alias for getChild"""
+        return self.getChild(suffix)
+
+    def find_caller(
+        self, stack_info: bool = False, stacklevel: int = 1
+    ) -> Tuple[str, int, str, Union[str, None]]:
+        """snake_case alias for findCaller"""
+        return self.findCaller(stack_info, stacklevel)
+
+    def add_handler(self, hdlr: Handler) -> None:
+        """snake_case alias for addHandler"""
+        return self.addHandler(hdlr)
+
+    def remove_handler(self, hdlr: Handler) -> None:
+        """snake_case alias for removeHandler"""
+        return self.removeHandler(hdlr)
+
+    def make_record(
+        self,
+        name: str,
+        level: int,
+        fn: str,
+        lno: int,
+        msg: object,
+        args: _ArgsType,
+        exc_info: Union[_SysExcInfoType, None],
+        func: Optional[str] = None,
+        extra: Union[Mapping[str, object], None] = None,
+        sinfo: Optional[str] = None,
+    ) -> LogRecord:
+        return self.makeRecord(
+            name, level, fn, lno, msg, args, exc_info, func, extra, sinfo
+        )
+
+    def has_handlers(self) -> bool:
+        """snake_case alias for hasHandlers"""
+        return self.hasHandlers()
+
+    def call_handlers(self, record: LogRecord) -> None:
+        """snake_case alias for callHandlers"""
+        return self.callHandlers(record)
+
+
+class Handler(_Handler):
+    def __init__(self, level: _Level = 0) -> None:
+        super().__init__(level)
+
+    def create_lock(self) -> None:
+        """snake_case alias for createLock"""
+        return self.createLock()
+
+    def set_level(self, level: _Level) -> None:
+        """snake_case alias for setLevel"""
+        return self.setLevel(level)
+
+    def set_formatter(self, fmt: Union[Formatter, None]) -> None:
+        """snake_case alias for setFormatter"""
+        return self.setFormatter(fmt)
+
+    def handle_error(self, record: LogRecord) -> None:
+        """snake_case alias for handleError"""
+        return self.handleError(record)
+
+
+# =====================================================================================
+
+
+def patch_logging() -> None:
+    for k, v in __aliases__.items():
+        setattr(logging, k, getattr(logging, v))
+
+
+class StdLoggingHandler(logging.Handler):
+    """Logging intercept handler"""
+
+    def emit(self, record: logging.LogRecord) -> None:
+        # Get corresponding Loguru level if it exists
+        try:
+            level = LOG.level(record.levelname).name
+        except AttributeError:
+            level = loglevel(record.levelno)
+
+        # Find caller from where originated the logging call
+        frame = logging.currentframe()
+        depth = 2
+        while (
+            frame.f_code.co_filename  # pyright: ignore[reportOptionalMemberAccess]
+            == logging.__file__
+        ):
+            frame = frame.f_back  # type: ignore[assignment]
+            depth += 1
+
+        LOG.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+
+def _logger_dict() -> Any:
+    return logging.root.manager.loggerDict
+
+
+def loggers_dict() -> Dict[str, logging.Logger]:
+    return {name: logging.getLogger(name) for name in _logger_dict()}
+
+
+def intercept(loggers: List[str]) -> None:
+    for logger in loggers:
+        std_logger = logging.getLogger(logger)
+        std_logger.handlers = [StdLoggingHandler()]
+
+
+def intercept_all() -> None:
+    intercept(list(loggers_dict().keys()))

lager/py.typed

lager/__about__.py

 # -*- coding: utf-8 -*-
 """Package metadata/info"""
 
+from __future__ import annotations
+
 __all__ = ("__title__", "__description__", "__pkgroot__", "__version__")
@@ -8,2 +10,2 @@ __title__ = "lager"
 __pkgroot__ = __file__.replace("__about__.py", "").rstrip("/\\")
-__version__ = "0.17.2"
+__version__ = "0.18.1"

lager/__init__.py

 # -*- coding: utf-8 -*-
 """Python lager brewed by a loguru"""
+from __future__ import annotations
+
 from lager import logging
@@ -4,0 +6,0 @@ from lager.__about__ import __version__

lager/__main__.py

 # -*- coding: utf-8 -*-
 """pkg entry ~ `python -m lager`"""
+from __future__ import annotations
+
 import sys
@@ -4,0 +6,0 @@

lager/_meta.py

 # -*- coding: utf-8 -*-
 """Package metadata/info"""
+from __future__ import annotations
+
 import warnings
@@ -4,0 +6,0 @@

lager/const.py

 # -*- coding: utf-8 -*-
 """Constants go here!"""
+from __future__ import annotations
+
 from typing import Dict
@@ -4,0 +6,0 @@

lager/core.py

 # -*- coding: utf-8 -*-
 """Python lager brewed by a loguru"""
+from __future__ import annotations
+
 import asyncio
@@ -4,0 +6,0 @@ import sys as _sys

lager/dev.py

 # -*- coding: utf-8 -*-
 
+from __future__ import annotations
+
 from typing import Any
@@ -10,3 +12,3 @@
 
-    class HttpxSink(object):
+    class HttpxSink:
         def __init__(self, url: str, *args: Any, **kwargs: Any) -> None:
@@ -13,0 +15,0 @@ self.url = url

lager/fastapi.py

 # -*- coding: utf-8 -*-
 """FastAPI logging"""
+from __future__ import annotations
+
 from typing import List, Optional, Set, Tuple, Union
@@ -11,3 +13,4 @@
     "gunicorn",
-    "gunicorn.errors" "uvicorn",
+    "gunicorn.errors",
+    "uvicorn",
     "uvicorn.error",
@@ -14,0 +17,0 @@ "fastapi",

lager/pydantic.py

 # -*- coding: utf-8 -*-
 """Lager & pydantic"""
+from __future__ import annotations
+
 from datetime import datetime, timedelta
@@ -4,0 +6,0 @@ from types import TracebackType

PKG-INFO

 Metadata-Version: 2.1
 Name: lager
-Version: 0.17.2
+Version: 0.18.1
 Summary: EZ-PZ logging based on loguru
@@ -10,3 +10,3 @@ Home-page: https://github.com/dynamic-graphics-inc/dgpy-libs/tree/main/libs/lager
 Author-email: [e-mail]
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.8,<4.0
 Classifier: Development Status :: 5 - Production/Stable
@@ -17,3 +17,2 @@ Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
@@ -23,7 +22,4 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Typing :: Typed
@@ -30,0 +26,0 @@ Requires-Dist: loguru (>=0.7.0)

pyproject.toml

 [tool.poetry]
 name = "lager"
-version = "0.17.2"
+version = "0.18.1"
 description = "EZ-PZ logging based on loguru"
@@ -34,9 +34,12 @@ authors = ["jesse rubin <[e-mail]>"]
 [tool.poetry.dependencies]
-python = "^3.7"
+python = "^3.8"
 loguru = ">=0.7.0"
 
 [tool.poetry.dev-dependencies]
-pytest = "^7.3.1"
-pytest-cov = "^4.0.0"
+pytest = "^8.0.0"
+pytest-cov = "^4.1.0"
 
+[tool.poetry.group.dev.dependencies]
+typing-extensions = "^4.5.0"
+
 [build-system]
@@ -43,0 +46,0 @@ requires = ["poetry-core>=1.0.0"]

lager/logging.py

-# -*- coding: utf-8 -*-
-"""Lager/Loguru + std logging"""
-import logging
-
-from logging import (
-    BASIC_FORMAT as BASIC_FORMAT,
-    CRITICAL as CRITICAL,
-    DEBUG as DEBUG,
-    ERROR as ERROR,
-    FATAL as FATAL,
-    INFO as INFO,
-    NOTSET as NOTSET,
-    WARN as WARN,
-    WARNING as WARNING,
-    BufferingFormatter as BufferingFormatter,
-    FileHandler as FileHandler,
-    Filter as Filter,
-    Formatter as Formatter,
-    Handler as Handler,
-    Logger as Logger,
-    LoggerAdapter as LoggerAdapter,
-    LogRecord as LogRecord,
-    NullHandler as NullHandler,
-    StreamHandler as StreamHandler,
-    addLevelName as addLevelName,
-    addLevelName as add_level_name,
-    basicConfig as basicConfig,
-    basicConfig as basic_config,
-    captureWarnings as captureWarnings,
-    captureWarnings as capture_warnings,
-    critical as critical,
-    debug as debug,
-    disable as disable,
-    error as error,
-    exception as exception,
-    fatal as fatal,
-    getLevelName as getLevelName,
-    getLevelName as get_level_name,
-    getLogger as getLogger,
-    getLogger as get_logger,
-    getLoggerClass as getLoggerClass,
-    getLoggerClass as get_logger_class,
-    getLogRecordFactory as getLogRecordFactory,
-    getLogRecordFactory as get_log_record_factory,
-    info as info,
-    lastResort as lastResort,
-    lastResort as last_resort,
-    log as log,
-    makeLogRecord as makeLogRecord,
-    makeLogRecord as make_log_record,
-    raiseExceptions as raiseExceptions,
-    raiseExceptions as raise_exceptions,
-    setLoggerClass as setLoggerClass,
-    setLoggerClass as set_logger_class,
-    setLogRecordFactory as setLogRecordFactory,
-    setLogRecordFactory as set_log_record_factory,
-    shutdown as shutdown,
-    warn as warn,
-    warning as warning,
-)
-from typing import Any, Dict, List
-
-from lager.core import LOG, loglevel
-
-__all__ = (
-    "BASIC_FORMAT",
-    "BufferingFormatter",
-    "CRITICAL",
-    "DEBUG",
-    "ERROR",
-    "FATAL",
-    "FileHandler",
-    "Filter",
-    "Formatter",
-    "Handler",
-    "INFO",
-    "LogRecord",
-    "Logger",
-    "LoggerAdapter",
-    "NOTSET",
-    "NullHandler",
-    "StreamHandler",
-    "WARN",
-    "WARNING",
-    "addLevelName",
-    "add_level_name",
-    "basicConfig",
-    "basic_config",
-    "captureWarnings",
-    "capture_warnings",
-    "critical",
-    "debug",
-    "disable",
-    "error",
-    "exception",
-    "fatal",
-    "getLevelName",
-    "getLogRecordFactory",
-    "getLogger",
-    "getLoggerClass",
-    "get_level_name",
-    "get_log_record_factory",
-    "get_logger",
-    "get_logger_class",
-    "info",
-    "lastResort",
-    "last_resort",
-    "log",
-    "makeLogRecord",
-    "make_log_record",
-    "raiseExceptions",
-    "raise_exceptions",
-    "setLogRecordFactory",
-    "setLoggerClass",
-    "set_log_record_factory",
-    "set_logger_class",
-    "shutdown",
-    "warn",
-    "warning",
-    # lager.logging members
-    "__aliases__",
-    "StdLoggingHandler",
-    "loggers_dict",
-    "intercept",
-    "intercept_all",
-    "patch_logging",
-)
-
-# logging snake_case aliases bc I cannot stand camelCase
-__aliases__ = {
-    "add_level_name": "addLevelName",
-    "basic_config": "basicConfig",
-    "capture_warnings": "captureWarnings",
-    "get_level_name": "getLevelName",
-    "get_log_record_factory": "getLogRecordFactory",
-    "get_logger": "getLogger",
-    "get_logger_class": "getLoggerClass",
-    "last_resort": "lastResort",
-    "make_log_record": "makeLogRecord",
-    "raise_exceptions": "raiseExceptions",
-    "set_log_record_factory": "setLogRecordFactory",
-    "set_logger_class": "setLoggerClass",
-}
-
-
-def patch_logging() -> None:
-    for k, v in __aliases__.items():
-        setattr(logging, k, getattr(logging, v))
-
-
-class StdLoggingHandler(logging.Handler):
-    """Logging intercept handler"""
-
-    def emit(self, record: logging.LogRecord) -> None:
-        # Get corresponding Loguru level if it exists
-        try:
-            level = LOG.level(record.levelname).name
-        except AttributeError:
-            level = loglevel(record.levelno)
-
-        # Find caller from where originated the logging call
-        frame = logging.currentframe()
-        depth = 2
-        while (
-            frame.f_code.co_filename
-            == logging.__file__  # pyright: ignore[reportOptionalMemberAccess]
-        ):
-            frame = frame.f_back  # type: ignore[assignment]
-            depth += 1
-
-        LOG.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
-
-
-def _logger_dict() -> Any:
-    return logging.root.manager.loggerDict
-
-
-def loggers_dict() -> Dict[str, logging.Logger]:
-    return {name: logging.getLogger(name) for name in _logger_dict()}
-
-
-def intercept(loggers: List[str]) -> None:
-    for logger in loggers:
-        std_logger = logging.getLogger(logger)
-        std_logger.handlers = [StdLoggingHandler()]
-
-
-def intercept_all() -> None:
-    intercept(list(loggers_dict().keys()))

Alert delta unavailable

Currently unable to show alert delta for PyPI packages.

Improved metrics

Total package byte prevSize

27715

14.16%

Number of package files

15

7.14%

Lines of code

777

12.45%