omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev425__py3-none-any.whl

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/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

omlish/logs/standard.py

@@ -2,6 +2,7 @@
 # @omlish-lite
 """
 TODO:
+ - !! move to std !!
  - structured
  - prefixed
  - debug
@@ -12,9 +13,9 @@ import datetime
 import logging
 import typing as ta
 
-from .filters import TidLogFilter
-from .json import JsonLogFormatter
-from .proxy import ProxyLogHandler
+from .std.filters import TidLoggingFilter
+from .std.json import JsonLoggingFormatter
+from .std.proxy import ProxyLoggingHandler
 
 
 ##
@@ -31,7 +32,7 @@ STANDARD_LOG_FORMAT_PARTS = [
 ]
 
 
-class StandardLogFormatter(logging.Formatter):
+class StandardLoggingFormatter(logging.Formatter):
     @staticmethod
     def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
         return ' '.join(v for k, v in parts)
@@ -50,7 +51,7 @@ class StandardLogFormatter(logging.Formatter):
 ##
 
 
-class StandardConfiguredLogHandler(ProxyLogHandler):
+class StandardConfiguredLoggingHandler(ProxyLoggingHandler):
     def __init_subclass__(cls, **kwargs):
         raise TypeError('This class serves only as a marker and should not be subclassed.')
 
@@ -83,7 +84,7 @@ def configure_standard_logging(
         target: ta.Optional[logging.Logger] = None,
         force: bool = False,
         handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardConfiguredLogHandler]:
+) -> ta.Optional[StandardConfiguredLoggingHandler]:
     with _locking_logging_module_lock():
         if target is None:
             target = logging.root
@@ -91,7 +92,7 @@ def configure_standard_logging(
         #
 
         if not force:
-            if any(isinstance(h, StandardConfiguredLogHandler) for h in list(target.handlers)):
+            if any(isinstance(h, StandardConfiguredLoggingHandler) for h in list(target.handlers)):
                 return None
 
         #
@@ -105,14 +106,14 @@ def configure_standard_logging(
 
         formatter: logging.Formatter
         if json:
-            formatter = JsonLogFormatter()
+            formatter = JsonLoggingFormatter()
         else:
-            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
+            formatter = StandardLoggingFormatter(StandardLoggingFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
         handler.setFormatter(formatter)
 
         #
 
-        handler.addFilter(TidLogFilter())
+        handler.addFilter(TidLoggingFilter())
 
         #
 
@@ -125,4 +126,4 @@ def configure_standard_logging(
 
         #
 
-        return StandardConfiguredLogHandler(handler)
+        return StandardConfiguredLoggingHandler(handler)

omlish/logs/std/adapters.py

@@ -0,0 +1,41 @@
+# @omlish-lite
+import logging
+import typing as ta
+
+from ..base import Logger
+from ..base import LoggingContext
+from ..base import LogLevel
+from .records import LoggingContextLogRecord
+
+
+##
+
+
+class StdLogger(Logger):
+    def __init__(self, std: logging.Logger) -> None:
+        super().__init__()
+
+        self._std = std
+
+    @property
+    def std(self) -> logging.Logger:
+        return self._std
+
+    def get_effective_level(self) -> LogLevel:
+        return self._std.getEffectiveLevel()
+
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any) -> None:
+        if not self.is_enabled_for(ctx.level):
+            return
+
+        ctx.build_caller()
+
+        rec = LoggingContextLogRecord(
+            name=self._std.name,
+            msg=msg,
+            args=args,
+
+            _logging_context=ctx,
+        )
+
+        self._std.handle(rec)

omlish/logs/std/configs.py

@@ -0,0 +1,29 @@
+# ruff: noqa: UP006 UP045
+# @omlish-lite
+"""
+https://docs.python.org/3/howto/logging.html#configuring-logging
+https://docs.python.org/3/library/logging.config.html#logging-config-dictschema
+"""
+import dataclasses as dc
+import typing as ta
+
+
+FilterDictLoggingConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
+FormatterDictLoggingConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
+HandlerDictLoggingConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
+LoggerDictLoggingConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
+
+
+##
+
+
+@dc.dataclass()
+class DictLoggingConfig:
+    version: int = 1
+    incremental: bool = False
+    disable_existing_loggers: bool = False
+    filters: ta.Dict[str, FilterDictLoggingConfig] = dc.field(default_factory=dict)
+    formatters: ta.Dict[str, FormatterDictLoggingConfig] = dc.field(default_factory=dict)
+    handlers: ta.Dict[str, HandlerDictLoggingConfig] = dc.field(default_factory=dict)
+    loggers: ta.Dict[str, LoggerDictLoggingConfig] = dc.field(default_factory=dict)
+    root: ta.Optional[LoggerDictLoggingConfig] = None

omlish/logs/{filters.py → std/filters.py}

@@ -7,7 +7,7 @@ import threading
 ##
 
 
-class TidLogFilter(logging.Filter):
+class TidLoggingFilter(logging.Filter):
     def filter(self, record):
         # FIXME: handle better - missing from wasm and cosmos
         if hasattr(threading, 'get_native_id'):

omlish/logs/{handlers.py → std/handlers.py}

@@ -7,7 +7,7 @@ import typing as ta
 ##
 
 
-class ListHandler(logging.Handler):
+class ListLoggingHandler(logging.Handler):
     def __init__(self) -> None:
         super().__init__()
 

omlish/logs/{json.py → std/json.py}

@@ -7,13 +7,13 @@ TODO:
 import logging
 import typing as ta
 
-from ..lite.json import json_dumps_compact
+from ...lite.json import json_dumps_compact
 
 
 ##
 
 
-class JsonLogFormatter(logging.Formatter):
+class JsonLoggingFormatter(logging.Formatter):
     KEYS: ta.Mapping[str, bool] = {
         'name': False,
         'msg': False,

omlish/logs/{proxy.py → std/proxy.py}

@@ -6,7 +6,7 @@ import logging
 ##
 
 
-class ProxyLogFilterer(logging.Filterer):
+class ProxyLoggingFilterer(logging.Filterer):
     def __init__(self, underlying: logging.Filterer) -> None:  # noqa
         self._underlying = underlying
 
@@ -32,9 +32,9 @@ class ProxyLogFilterer(logging.Filterer):
         return self._underlying.filter(record)
 
 
-class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
+class ProxyLoggingHandler(ProxyLoggingFilterer, logging.Handler):
     def __init__(self, underlying: logging.Handler) -> None:  # noqa
-        ProxyLogFilterer.__init__(self, underlying)
+        ProxyLoggingFilterer.__init__(self, underlying)
 
     _underlying: logging.Handler