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

omlish/logs/std/handlers.py

@@ -0,0 +1,19 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
+import logging
+import typing as ta
+
+
+##
+
+
+class ListLoggingHandler(logging.Handler):
+    def __init__(self, record_list: ta.Optional[ta.List[logging.LogRecord]] = None) -> None:
+        super().__init__()
+
+        if record_list is None:
+            record_list = []
+        self.records: ta.List[logging.LogRecord] = record_list
+
+    def emit(self, record: logging.LogRecord) -> None:
+        self.records.append(record)

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/std/loggers.py

@@ -0,0 +1,48 @@
+# ruff: noqa: UP007
+# @omlish-lite
+import logging
+import typing as ta
+
+from ..base import Logger
+from ..base import LoggingMsgFn
+from ..contexts import CaptureLoggingContext
+from ..infos import LoggingContextInfos
+from ..levels 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 is_enabled_for(self, level: LogLevel) -> bool:
+        return self._std.isEnabledFor(level)
+
+    def get_effective_level(self) -> LogLevel:
+        return self._std.getEffectiveLevel()
+
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> None:
+        if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
+            return
+
+        ctx.set_basic(
+            name=self._std.name,
+
+            msg=msg,
+            args=args,
+        )
+
+        ctx.capture()
+
+        rec = LoggingContextLogRecord(_logging_context=ctx)
+
+        self._std.handle(rec)

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