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

omlish/lite/pycharm.py

@@ -6,7 +6,7 @@ import typing as ta
 ##
 
 
-DEFAULT_PYCHARM_VERSION = '242.23726.102'
+DEFAULT_PYCHARM_VERSION = '252.26199.168'
 
 
 @dc.dataclass(frozen=True)

omlish/lite/strings.py

@@ -73,13 +73,6 @@ def split_keep_delimiter(s, d):
 ##
 
 
-def attr_repr(obj: ta.Any, *attrs: str) -> str:
-    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
-
-
-##
-
-
 FORMAT_NUM_BYTES_SUFFIXES: ta.Sequence[str] = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB']
 
 

omlish/lite/timing.py

@@ -1,6 +1,9 @@
-from ..logs.timing import LogTimingContext
-from ..logs.timing import log_timing_context
-from .logs import log
+from ..logs.modules import get_module_logger
+from ..logs.utils import LogTimingContext
+from ..logs.utils import log_timing_context
+
+
+log = get_module_logger(globals())  # noqa
 
 
 LogTimingContext.DEFAULT_LOG = log

omlish/lite/typing.py

@@ -12,6 +12,12 @@ A2 = ta.TypeVar('A2')
 
 ##
 # A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+#
+# Note that this problem doesn't happen at runtime - it happens in mypy:
+#
+#   mypy <(echo "import typing as ta; MyCallback = ta.NewType('MyCallback', ta.Callable[[], None])")
+#   /dev/fd/11:1:22: error: Argument 2 to NewType(...) must be subclassable (got "Callable[[], None]")  [valid-newtype]
+#
 
 
 @dc.dataclass(frozen=True)

omlish/logs/_amalg.py

@@ -0,0 +1,8 @@
+# @omlish-lite
+# @omlish-amalg ../../omdev/scripts/lib/logs.py
+from .base import AnyLogger  # noqa
+from .standard import configure_standard_logging  # noqa
+from .std.loggers import StdLogger  # noqa
+
+
+##

omlish/logs/all.py

@@ -5,64 +5,92 @@ 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.formatters import (  # noqa
+        StdLoggingFormatter,
     )
 
-    from .filters import (  # noqa
-        TidLogFilter,
+    from .std.handlers import (  # noqa
+        ListLoggingHandler,
     )
 
-    from .handlers import (  # noqa
-        ListHandler,
+    from .std.json import (  # noqa
+        JsonLoggingFormatter,
     )
 
-    from .json import (  # noqa
-        JsonLogFormatter,
+    from .std.loggers import (  # noqa
+        StdLogger,
     )
 
-    from .levels import (  # noqa
-        LogLevel,
+    from .std.noisy import (  # noqa
+        silence_noisy_loggers,
     )
 
-    from .noisy import (  # noqa
-        silence_noisy_loggers,
+    from .std.proxy import (  # noqa
+        ProxyLoggingFilterer,
+        ProxyLoggingHandler,
+    )
+
+    from .std.records import (  # noqa
+        LoggingContextLogRecord,
+    )
+
+    from .base import (  # noqa
+        AnyLogger,
+        Logger,
+        AsyncLogger,
+
+        AnyNopLogger,
+        NopLogger,
+        AsyncNopLogger,
+    )
+
+    from .contexts import (  # noqa
+        LoggingContext,
     )
 
-    from .protocol import (  # noqa
-        AnyLogging,
-        Logging,
-        AsyncLogging,
+    from .formatters import (  # noqa
+        LoggingContextFormatter,
+    )
 
-        AnyAbstractLogging,
-        AbstractLogging,
-        AbstractAsyncLogging,
+    from .infos import (  # noqa
+        LoggingContextInfo,
+        LoggingContextInfos,
+    )
+
+    from .levels import (  # noqa
+        LogLevel,
 
-        AnyNopLogging,
-        NopLogging,
-        NopAsyncLogging,
+        NamedLogLevel,
+    )
 
-        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
-        error_logging,
+        LogTimingContext,
+        log_timing_context,
+
+        exception_logging,
+    )
+
+    from .warnings import (  # noqa
+        LoggingSetupWarning,
     )

omlish/logs/base.py

@@ -0,0 +1,204 @@
+# ruff: noqa: UP006 UP007 UP045 UP046
+# @omlish-lite
+import abc
+import typing as ta
+
+from ..lite.abstract import Abstract
+from .contexts import CaptureLoggingContext
+from .contexts import CaptureLoggingContextImpl
+from .contexts import LoggingExcInfoArg
+from .levels import LogLevel
+from .levels import NamedLogLevel
+
+
+T = ta.TypeVar('T')
+
+
+LoggingMsgFn = ta.Callable[[], ta.Union[str, tuple]]  # ta.TypeAlias
+
+
+##
+
+
+class AnyLogger(Abstract, ta.Generic[T]):
+    def is_enabled_for(self, level: LogLevel) -> bool:
+        return level >= self.get_effective_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.overload
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def log(self, level: LogLevel, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def log(self, level: LogLevel, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.final
+    def log(self, level: LogLevel, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(level, stack_offset=1), *args, **kwargs)
+
+    #
+
+    @ta.overload
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def debug(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def debug(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.final
+    def debug(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.DEBUG, stack_offset=1), *args, **kwargs)
+
+    #
+
+    @ta.overload
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def info(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def info(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.final
+    def info(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.INFO, stack_offset=1), *args, **kwargs)
+
+    #
+
+    @ta.overload
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def warning(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def warning(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.final
+    def warning(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.WARNING, stack_offset=1), *args, **kwargs)
+
+    #
+
+    @ta.overload
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def error(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def error(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.final
+    def error(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, stack_offset=1), *args, **kwargs)
+
+    #
+
+    @ta.overload
+    def exception(self, msg: str, *args: ta.Any, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def exception(self, msg: ta.Tuple[ta.Any, ...], *, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def exception(self, msg_fn: LoggingMsgFn, *, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.final
+    def exception(self, *args, exc_info: LoggingExcInfoArg = True, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, exc_info=exc_info, stack_offset=1), *args, **kwargs)  # noqa
+
+    #
+
+    @ta.overload
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def critical(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def critical(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.final
+    def critical(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.CRITICAL, stack_offset=1), *args, **kwargs)
+
+    ##
+
+    @abc.abstractmethod
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> T:  # noqa
+        raise NotImplementedError
+
+
+class Logger(AnyLogger[None], Abstract):
+    @abc.abstractmethod
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+        raise NotImplementedError
+
+
+class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
+    @abc.abstractmethod
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:  # noqa
+        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: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+        pass
+
+
+@ta.final
+class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
+    async def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+        pass

omlish/logs/contexts.py

@@ -0,0 +1,171 @@
+# ruff: noqa: UP006 UP007 UP045 UP046
+# @omlish-lite
+import abc
+import time
+import typing as ta
+
+from ..lite.abstract import Abstract
+from .infos import LoggingContextInfo
+from .infos import LoggingContextInfos
+from .infos import LoggingExcInfoArg
+from .infos import LoggingMsgFn
+from .levels import LogLevel
+
+
+LoggingContextInfoT = ta.TypeVar('LoggingContextInfoT', bound=LoggingContextInfo)
+
+
+##
+
+
+class LoggingContext(Abstract):
+    @abc.abstractmethod
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        raise NotImplementedError
+
+    @ta.final
+    def __getitem__(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self.get_info(ty)
+
+    @ta.final
+    def must_get_info(self, ty: ta.Type[LoggingContextInfoT]) -> LoggingContextInfoT:
+        if (info := self.get_info(ty)) is None:
+            raise TypeError(f'LoggingContextInfo absent: {ty}')
+        return info
+
+
+@ta.final
+class SimpleLoggingContext(LoggingContext):
+    def __init__(self, *infos: LoggingContextInfo) -> None:
+        self._infos: ta.Dict[ta.Type[LoggingContextInfo], LoggingContextInfo] = {type(i): i for i in infos}
+
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self._infos.get(ty)
+
+
+##
+
+
+class CaptureLoggingContext(LoggingContext, Abstract):
+    @abc.abstractmethod
+    def set_basic(
+            self,
+            name: str,
+
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            args: tuple,
+    ) -> 'CaptureLoggingContext':
+        raise NotImplementedError
+
+    #
+
+    class AlreadyCapturedError(Exception):
+        pass
+
+    class NotCapturedError(Exception):
+        pass
+
+    @abc.abstractmethod
+    def capture(self) -> None:
+        """Must be cooperatively called only from the expected locations."""
+
+        raise NotImplementedError
+
+
+@ta.final
+class CaptureLoggingContextImpl(CaptureLoggingContext):
+    @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[LoggingContextInfos.Caller, ta.Type[NOT_SET], None] = NOT_SET,
+            stack_offset: int = 0,
+            stack_info: bool = False,
+    ) -> None:
+        if time_ns is None:
+            time_ns = time.time_ns()
+
+        # Done early to not trample on sys.exc_info()
+        exc = LoggingContextInfos.Exc.build(exc_info)
+
+        self._infos: ta.Dict[ta.Type[LoggingContextInfo], LoggingContextInfo] = {}
+        self._set_info(
+            LoggingContextInfos.Level.build(level),
+            exc,
+            LoggingContextInfos.Time.build(time_ns),
+        )
+
+        if caller is not CaptureLoggingContextImpl.NOT_SET:
+            self._infos[LoggingContextInfos.Caller] = caller
+        else:
+            self._stack_offset = stack_offset
+            self._stack_info = stack_info
+
+    def _set_info(self, *infos: ta.Optional[LoggingContextInfo]) -> 'CaptureLoggingContextImpl':
+        for info in infos:
+            if info is not None:
+                self._infos[type(info)] = info
+        return self
+
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self._infos.get(ty)
+
+    ##
+
+    def set_basic(
+            self,
+            name: str,
+
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            args: tuple,
+    ) -> 'CaptureLoggingContextImpl':
+        return self._set_info(
+            LoggingContextInfos.Name(name),
+            LoggingContextInfos.Msg.build(msg, *args),
+        )
+
+    ##
+
+    _stack_offset: int
+    _stack_info: bool
+
+    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContext':
+        if hasattr(self, '_stack_offset'):
+            self._stack_offset += ofs
+        return self
+
+    _has_captured: bool = False
+
+    def capture(self) -> None:
+        if self._has_captured:
+            raise CaptureLoggingContextImpl.AlreadyCapturedError
+        self._has_captured = True
+
+        if LoggingContextInfos.Caller not in self._infos:
+            self._set_info(LoggingContextInfos.Caller.build(
+                self._stack_offset + 1,
+                stack_info=self._stack_info,
+            ))
+
+        if (caller := self[LoggingContextInfos.Caller]) is not None:
+            self._set_info(LoggingContextInfos.SourceFile.build(
+                caller.file_path,
+            ))
+
+        self._set_info(
+            LoggingContextInfos.Thread.build(),
+            LoggingContextInfos.Process.build(),
+            LoggingContextInfos.Multiprocessing.build(),
+            LoggingContextInfos.AsyncioTask.build(),
+        )

omlish/logs/formatters.py

@@ -0,0 +1,13 @@
+import abc
+
+from ..lite.abstract import Abstract
+from .contexts import LoggingContext
+
+
+##
+
+
+class LoggingContextFormatter(Abstract):
+    @abc.abstractmethod
+    def format(self, ctx: LoggingContext) -> str:
+        raise NotImplementedError