omlish 0.0.0.dev424__py3-none-any.whl → 0.0.0.dev426__py3-none-any.whl

omlish/logs/all.py

@@ -5,64 +5,57 @@ from .. import lang as _lang
 with _lang.auto_proxy_init(globals()):
     ##
 
-    from .callers import (  # noqa
-        LoggingCaller,
+    from .std.filters import (  # noqa
+        TidLoggingFilter,
     )
 
-    from .color import (  # noqa
-        ColorLogFormatter,
+    from .std.handlers import (  # noqa
+        ListLoggingHandler,
     )
 
-    from .filters import (  # noqa
-        TidLogFilter,
+    from .std.json import (  # noqa
+        JsonLoggingFormatter,
     )
 
-    from .handlers import (  # noqa
-        ListHandler,
+    from .std.noisy import (  # noqa
+        silence_noisy_loggers,
     )
 
-    from .json import (  # noqa
-        JsonLogFormatter,
+    from .std.proxy import (  # noqa
+        ProxyLoggingFilterer,
+        ProxyLoggingHandler,
+    )
+
+    from .callers import (  # noqa
+        LoggingCaller,
     )
 
     from .levels import (  # noqa
         LogLevel,
-    )
 
-    from .noisy import (  # noqa
-        silence_noisy_loggers,
+        NamedLogLevel,
     )
 
-    from .protocol import (  # noqa
-        AnyLogging,
-        Logging,
-        AsyncLogging,
-
-        AnyAbstractLogging,
-        AbstractLogging,
-        AbstractAsyncLogging,
-
-        AnyNopLogging,
-        NopLogging,
-        NopAsyncLogging,
-
-        StdlibLogging,
+    from .modules import (  # noqa
+        get_module_logger,
     )
 
-    from .proxy import (  # noqa
-        ProxyLogFilterer,
-        ProxyLogHandler,
+    from .protocols import (  # noqa
+        LoggerLike,
     )
 
     from .standard import (  # noqa
         STANDARD_LOG_FORMAT_PARTS,
-        StandardLogFormatter,
+        StandardLoggingFormatter,
 
-        StandardConfiguredLogHandler,
+        StandardConfiguredLoggingHandler,
 
         configure_standard_logging,
     )
 
     from .utils import (  # noqa
+        LogTimingContext,
+        log_timing_context,
+
         error_logging,
     )

omlish/logs/base.py

@@ -0,0 +1,248 @@
+# ruff: noqa: UP006 UP007 UP045 UP046
+# @omlish-lite
+import abc
+import sys
+import time
+import types
+import typing as ta
+
+from ..lite.abstract import Abstract
+from .callers import LoggingCaller
+from .infos import LoggingAsyncioTaskInfo
+from .infos import LoggingMultiprocessingInfo
+from .infos import LoggingProcessInfo
+from .infos import LoggingSourceFileInfo
+from .infos import LoggingThreadInfo
+from .levels import NamedLogLevel
+from .times import LoggingTimeFields
+
+
+T = ta.TypeVar('T')
+
+
+LogLevel = int  # ta.TypeAlias
+
+LoggingExcInfoTuple = ta.Tuple[ta.Type[BaseException], BaseException, ta.Optional[types.TracebackType]]  # ta.TypeAlias
+LoggingExcInfo = ta.Union[BaseException, LoggingExcInfoTuple]  # ta.TypeAlias
+LoggingExcInfoArg = ta.Union[LoggingExcInfo, bool, None]  # ta.TypeAlias
+
+
+##
+
+
+@ta.final
+class LoggingContext:
+    level: NamedLogLevel
+
+    time_ns: int
+
+    exc_info: ta.Optional[LoggingExcInfo] = None
+    exc_info_tuple: ta.Optional[LoggingExcInfoTuple] = None
+
+    @ta.final
+    class NOT_SET:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    #
+
+    def __init__(
+            self,
+            level: LogLevel,
+            *,
+            time_ns: ta.Optional[int] = None,
+
+            exc_info: LoggingExcInfoArg = False,
+
+            caller: ta.Union[LoggingCaller, ta.Type[NOT_SET], None] = NOT_SET,
+            stack_offset: int = 0,
+            stack_info: bool = False,
+    ) -> None:
+        self.level = level if level.__class__ is NamedLogLevel else NamedLogLevel(level)  # type: ignore[assignment]
+
+        #
+
+        if time_ns is None:
+            time_ns = time.time_ns()
+        self.time_ns: int = time_ns
+
+        #
+
+        if exc_info is True:
+            sys_exc_info = sys.exc_info()
+            if sys_exc_info[0] is not None:
+                exc_info = sys_exc_info
+            else:
+                exc_info = None
+        elif exc_info is False:
+            exc_info = None
+
+        if exc_info is not None:
+            self.exc_info = exc_info
+            if isinstance(exc_info, BaseException):
+                self.exc_info_tuple = (type(exc_info), exc_info, exc_info.__traceback__)
+            else:
+                self.exc_info_tuple = exc_info
+
+        #
+
+        if caller is not LoggingContext.NOT_SET:
+            self._caller = caller  # type: ignore[assignment]
+        else:
+            self._stack_offset = stack_offset
+            self._stack_info = stack_info
+
+        #
+
+        self.thread = LoggingThreadInfo.build()
+        self.process = LoggingProcessInfo.build()
+        self.multiprocessing = LoggingMultiprocessingInfo.build()
+        self.asyncio_task = LoggingAsyncioTaskInfo.build()
+
+    #
+
+    _times: LoggingTimeFields
+
+    @property
+    def times(self) -> LoggingTimeFields:
+        try:
+            return self._times
+        except AttributeError:
+            pass
+
+        times = self._times = LoggingTimeFields.build(self.time_ns)
+        return times
+
+    #
+
+    def inc_stack_offset(self, ofs: int = 1) -> 'LoggingContext':
+        if hasattr(self, '_stack_offset'):
+            self._stack_offset += ofs
+        return self
+
+    _caller: ta.Optional[LoggingCaller]
+
+    def build_caller(self) -> ta.Optional[LoggingCaller]:
+        """Must be cooperatively called only from the exact configured _stack_offset."""
+
+        try:
+            return self._caller
+        except AttributeError:
+            pass
+
+        caller = self._caller = LoggingCaller.find(
+            self._stack_offset + 1,
+            stack_info=self._stack_info,
+        )
+        return caller
+
+    def caller(self) -> ta.Optional[LoggingCaller]:
+        try:
+            return self._caller
+        except AttributeError:
+            return None
+
+    _source_file: ta.Optional[LoggingSourceFileInfo]
+
+    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
+        try:
+            return self._source_file
+        except AttributeError:
+            pass
+
+        if (caller := self.caller()) is None:
+            return None
+
+        src_file = self._source_file = LoggingSourceFileInfo.build(caller.file_path)
+        return src_file
+
+
+##
+
+
+class AnyLogger(Abstract, ta.Generic[T]):
+    def is_enabled_for(self, level: LogLevel) -> bool:
+        return self.get_effective_level() >= level
+
+    @abc.abstractmethod
+    def get_effective_level(self) -> LogLevel:
+        raise NotImplementedError
+
+    #
+
+    @ta.final
+    def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
+        return self.is_enabled_for(level)
+
+    @ta.final
+    def getEffectiveLevel(self) -> LogLevel:  # noqa
+        return self.get_effective_level()
+
+    #
+
+    @ta.final
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.DEBUG, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.INFO, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.WARNING, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.ERROR, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def exception(self, msg: str, *args: ta.Any, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.ERROR, exc_info=exc_info, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.CRITICAL, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(level, stack_offset=1), msg, *args, **kwargs)
+
+    #
+
+    @abc.abstractmethod
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        raise NotImplementedError
+
+
+class Logger(AnyLogger[None], Abstract):
+    @abc.abstractmethod
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+        raise NotImplementedError
+
+
+class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
+    @abc.abstractmethod
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
+##
+
+
+class AnyNopLogger(AnyLogger[T], Abstract):
+    @ta.final
+    def get_effective_level(self) -> LogLevel:
+        return 999
+
+
+@ta.final
+class NopLogger(AnyNopLogger[None], Logger):
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+        pass
+
+
+@ta.final
+class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
+    async def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+        pass

omlish/logs/callers.py

@@ -12,32 +12,36 @@ import typing as ta
 
 
 class LoggingCaller(ta.NamedTuple):
-    filename: str
-    lineno: int
-    func: str
-    sinfo: ta.Optional[str]
+    file_path: str
+    line_no: int
+    name: str
+    stack_info: ta.Optional[str]
 
     @classmethod
     def is_internal_frame(cls, frame: types.FrameType) -> bool:
-        filename = os.path.normcase(frame.f_code.co_filename)
+        file_path = os.path.normcase(frame.f_code.co_filename)
 
+        # Yes, really.
+        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L204
         # https://github.com/python/cpython/commit/5ca6d7469be53960843df39bb900e9c3359f127f
-        if 'importlib' in filename and '_bootstrap' in filename:
+        if 'importlib' in file_path and '_bootstrap' in file_path:
             return True
 
         return False
 
     @classmethod
-    def find_frame(cls, ofs: int = 0) -> types.FrameType:
+    def find_frame(cls, ofs: int = 0) -> ta.Optional[types.FrameType]:
         f: ta.Optional[types.FrameType] = sys._getframe(2 + ofs)  # noqa
 
-        while f is not None and hasattr(f, 'f_code'):
-            if f.f_code.co_filename != __file__:
+        while f is not None:
+            # NOTE: We don't check __file__ like stdlib since we may be running amalgamated - we rely on careful, manual
+            # stack_offset management.
+            if hasattr(f, 'f_code'):
                 return f
 
             f = f.f_back
 
-        raise RuntimeError
+        return None
 
     @classmethod
     def find(
@@ -45,14 +49,16 @@ class LoggingCaller(ta.NamedTuple):
             ofs: int = 0,
             *,
             stack_info: bool = False,
-    ) -> 'LoggingCaller':
-        f = cls.find_frame(ofs + 1)
-        # TODO: ('(unknown file)', 0, '(unknown function)', None) ?
+    ) -> ta.Optional['LoggingCaller']:
+        if (f := cls.find_frame(ofs + 1)) is None:
+            return None
 
+        # https://github.com/python/cpython/blob/08e9794517063c8cd92c48714071b1d3c60b71bd/Lib/logging/__init__.py#L1616-L1623  # noqa
         sinfo = None
         if stack_info:
             sio = io.StringIO()
-            sio.write('Stack (most recent call last):\n')
+            # In stdlib, but done elsewhere here:
+            # sio.write('Stack (most recent call last):\n')
             traceback.print_stack(f, file=sio)
             sinfo = sio.getvalue()
             sio.close()
@@ -61,7 +67,7 @@ class LoggingCaller(ta.NamedTuple):
 
         return cls(
             f.f_code.co_filename,
-            f.f_lineno,
+            f.f_lineno or 0,
             f.f_code.co_name,
             sinfo,
         )

omlish/logs/infos.py

@@ -0,0 +1,105 @@
+# ruff: noqa: UP045
+# @omlish-lite
+import os.path
+import sys
+import threading
+import typing as ta
+
+
+##
+
+
+@ta.final
+class LoggingSourceFileInfo(ta.NamedTuple):
+    file_name: str
+    module: str
+
+    @classmethod
+    def build(cls, file_path: ta.Optional[str]) -> ta.Optional['LoggingSourceFileInfo']:
+        if file_path is None:
+            return None
+
+        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L331-L336  # noqa
+        try:
+            file_name = os.path.basename(file_path)
+            module = os.path.splitext(file_name)[0]
+        except (TypeError, ValueError, AttributeError):
+            return None
+
+        return cls(
+            file_name,
+            module,
+        )
+
+
+##
+
+
+@ta.final
+class LoggingThreadInfo(ta.NamedTuple):
+    ident: int
+    native_id: ta.Optional[int]
+    name: str
+
+    @classmethod
+    def build(cls) -> 'LoggingThreadInfo':
+        return cls(
+            threading.get_ident(),
+            threading.get_native_id() if hasattr(threading, 'get_native_id') else None,
+            threading.current_thread().name,
+        )
+
+
+##
+
+
+@ta.final
+class LoggingProcessInfo(ta.NamedTuple):
+    pid: int
+
+    @classmethod
+    def build(cls) -> 'LoggingProcessInfo':
+        return cls(
+            os.getpid(),
+        )
+
+
+##
+
+
+@ta.final
+class LoggingMultiprocessingInfo(ta.NamedTuple):
+    process_name: str
+
+    @classmethod
+    def build(cls) -> ta.Optional['LoggingMultiprocessingInfo']:
+        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L355-L364  # noqa
+        if (mp := sys.modules.get('multiprocessing')) is None:
+            return None
+
+        return cls(
+            mp.current_process().name,
+        )
+
+
+##
+
+
+@ta.final
+class LoggingAsyncioTaskInfo(ta.NamedTuple):
+    name: str
+
+    @classmethod
+    def build(cls) -> ta.Optional['LoggingAsyncioTaskInfo']:
+        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L372-L377  # noqa
+        if (asyncio := sys.modules.get('asyncio')) is None:
+            return None
+
+        try:
+            task = asyncio.current_task()
+        except Exception:  # noqa
+            return None
+
+        return cls(
+            task.get_name(),  # Always non-None
+        )

omlish/logs/levels.py

@@ -1,7 +1,71 @@
+# ruff: noqa: UP006 UP045
 # @omlish-lite
+import logging
+import typing as ta
 
 
 LogLevel = int  # ta.TypeAlias
 
 
 ##
+
+
+@ta.final
+class NamedLogLevel(int):
+    # logging.getLevelNamesMapping (or, as that is unavailable <3.11, logging._nameToLevel) includes the deprecated
+    # aliases.
+    _NAMES_BY_INT: ta.ClassVar[ta.Mapping[LogLevel, str]] = dict(sorted(logging._levelToName.items(), key=lambda t: -t[0]))  # noqa
+
+    _INTS_BY_NAME: ta.ClassVar[ta.Mapping[str, LogLevel]] = {v: k for k, v in _NAMES_BY_INT.items()}
+
+    _NAME_INT_PAIRS: ta.ClassVar[ta.Sequence[ta.Tuple[str, LogLevel]]] = list(_INTS_BY_NAME.items())
+
+    #
+
+    @property
+    def exact_name(self) -> ta.Optional[str]:
+        return self._NAMES_BY_INT.get(self)
+
+    _effective_name: ta.Optional[str]
+
+    @property
+    def effective_name(self) -> ta.Optional[str]:
+        try:
+            return self._effective_name
+        except AttributeError:
+            pass
+
+        if (n := self.exact_name) is None:
+            for n, i in self._NAME_INT_PAIRS:  # noqa
+                if self >= i:
+                    break
+            else:
+                n = None
+
+        self._effective_name = n
+        return n
+
+    #
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({int(self)})'
+
+    def __str__(self) -> str:
+        return self.exact_name or f'{self.effective_name or "INVALID"}:{int(self)}'
+
+    #
+
+    CRITICAL: ta.ClassVar['NamedLogLevel']
+    ERROR: ta.ClassVar['NamedLogLevel']
+    WARNING: ta.ClassVar['NamedLogLevel']
+    INFO: ta.ClassVar['NamedLogLevel']
+    DEBUG: ta.ClassVar['NamedLogLevel']
+    NOTSET: ta.ClassVar['NamedLogLevel']
+
+
+NamedLogLevel.CRITICAL = NamedLogLevel(logging.CRITICAL)
+NamedLogLevel.ERROR = NamedLogLevel(logging.ERROR)
+NamedLogLevel.WARNING = NamedLogLevel(logging.WARNING)
+NamedLogLevel.INFO = NamedLogLevel(logging.INFO)
+NamedLogLevel.DEBUG = NamedLogLevel(logging.DEBUG)
+NamedLogLevel.NOTSET = NamedLogLevel(logging.NOTSET)

omlish/logs/modules.py

@@ -0,0 +1,10 @@
+# @omlish-lite
+import logging
+import typing as ta
+
+
+##
+
+
+def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> logging.Logger:
+    return logging.getLogger(mod_globals.get('__name__'))

omlish/logs/protocols.py

@@ -0,0 +1,31 @@
+# @omlish-lite
+import typing as ta
+
+from .levels import LogLevel
+
+
+##
+
+
+class LoggerLike(ta.Protocol):
+    """Satisfied by both our Logger and stdlib logging.Logger."""
+
+    def isEnabledFor(self, level: LogLevel) -> bool: ...  # noqa
+
+    def getEffectiveLevel(self) -> LogLevel: ...  # noqa
+
+    #
+
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def exception(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa