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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev426'
-__revision__ = '94f5fd2fe7124da5d9b5af104cba12b1bbdb3286'
+__version__ = '0.0.0.dev428'
+__revision__ = '302f3506177c6fb44a3b8786e8125ee75d322b0e'
 
 
 #

omlish/asyncs/asyncio/subprocesses.py

@@ -4,12 +4,12 @@ import asyncio.base_subprocess
 import asyncio.subprocess
 import contextlib
 import functools
-import logging
 import subprocess
 import typing as ta
 
 from ...lite.check import check
 from ...lite.timeouts import TimeoutLike
+from ...logs.protocols import LoggerLike
 from ...subprocesses.asyncs import AbstractAsyncSubprocesses
 from ...subprocesses.run import SubprocessRun
 from ...subprocesses.run import SubprocessRunOutput
@@ -28,7 +28,7 @@ class AsyncioProcessCommunicator:
             proc: asyncio.subprocess.Process,
             loop: ta.Optional[ta.Any] = None,
             *,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 

omlish/asyncs/bluelet/runner.py

@@ -39,6 +39,7 @@ import types
 import typing as ta
 import weakref
 
+from ...logs.protocols import LoggerLike
 from .core import BlueletCoro
 from .core import BlueletExcInfo
 from .core import CoreBlueletEvent
@@ -84,7 +85,7 @@ class BlueletCoroException(Exception):  # noqa
 def _bluelet_event_select(
         events: ta.Iterable[BlueletEvent],
         *,
-        log: ta.Optional[logging.Logger] = None,
+        log: ta.Optional[LoggerLike] = None,
 ) -> ta.Set[WaitableBlueletEvent]:
     """
     Perform a select() over all the Events provided, returning the ones ready to be fired. Only WaitableEvents
@@ -182,7 +183,7 @@ class _BlueletRunner:
             self,
             root_coro: BlueletCoro,
             *,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 

omlish/formats/dotenv.py

@@ -27,7 +27,6 @@ import abc
 import codecs
 import contextlib
 import io
-import logging
 import os
 import pathlib
 import re
@@ -36,6 +35,7 @@ import tempfile
 import typing as ta
 
 from ..lite.abstract import Abstract
+from ..logs.protocols import LoggerLike
 
 
 ##
@@ -312,7 +312,7 @@ def parse_dotenv_stream(stream: ta.IO[str]) -> ta.Iterator[DotenvBinding]:
 
 def _dotenv_with_warn_for_invalid_lines(
         mappings: ta.Iterator[DotenvBinding],
-        log: ta.Optional[logging.Logger] = None,
+        log: ta.Optional[LoggerLike] = None,
 ) -> ta.Iterator[DotenvBinding]:
     for mapping in mappings:
         if mapping.error:
@@ -337,7 +337,7 @@ class Dotenv:
         interpolate: bool = True,
         override: bool = True,
         env: ta.Optional[ta.Mapping[str, str]] = None,
-        log: ta.Optional[logging.Logger] = None,
+        log: ta.Optional[LoggerLike] = None,
     ) -> None:
         super().__init__()
 
@@ -415,7 +415,7 @@ def dotenv_get_key(
     key_to_get: str,
     *,
     encoding: ta.Optional[str] = 'utf-8',
-    log: ta.Optional[logging.Logger] = None,
+    log: ta.Optional[LoggerLike] = None,
 ) -> ta.Optional[str]:
     """
     Get the value of a given key from the given .env.
@@ -461,7 +461,7 @@ def dotenv_set_key(
     quote_mode: str = 'always',
     export: bool = False,
     encoding: ta.Optional[str] = 'utf-8',
-    log: ta.Optional[logging.Logger] = None,
+    log: ta.Optional[LoggerLike] = None,
 ) -> ta.Tuple[ta.Optional[bool], str, str]:
     """
     Adds or Updates a key/value to the given .env
@@ -511,7 +511,7 @@ def dotenv_unset_key(
     *,
     quote_mode: str = 'always',
     encoding: ta.Optional[str] = 'utf-8',
-    log: ta.Optional[logging.Logger] = None,
+    log: ta.Optional[LoggerLike] = None,
 ) -> ta.Tuple[ta.Optional[bool], str]:
     """
     Removes a given key from the given `.env` file.
@@ -575,7 +575,7 @@ def dotenv_values(
     interpolate: bool = True,
     encoding: ta.Optional[str] = 'utf-8',
     env: ta.Optional[ta.Mapping[str, str]] = None,
-    log: ta.Optional[logging.Logger] = None,
+    log: ta.Optional[LoggerLike] = None,
 ) -> ta.Dict[str, ta.Optional[str]]:
     """
     Parse a .env file and return its content as a dict.

omlish/http/handlers.py

@@ -7,6 +7,7 @@ import logging
 import typing as ta
 
 from ..lite.abstract import Abstract
+from ..logs.protocols import LoggerLike
 from ..sockets.addresses import SocketAddress
 from .parsing import HttpHeaders
 
@@ -70,7 +71,7 @@ class HttpHandler_(Abstract):  # noqa
 @dc.dataclass(frozen=True)
 class LoggingHttpHandler(HttpHandler_):
     handler: HttpHandler
-    log: logging.Logger
+    log: LoggerLike
     level: int = logging.DEBUG
 
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
@@ -83,7 +84,7 @@ class LoggingHttpHandler(HttpHandler_):
 @dc.dataclass(frozen=True)
 class ExceptionLoggingHttpHandler(HttpHandler_):
     handler: HttpHandler
-    log: logging.Logger
+    log: LoggerLike
     message: ta.Union[str, ta.Callable[[HttpHandlerRequest, BaseException], str]] = 'Error in http handler'
 
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:

omlish/logs/base.py

@@ -1,229 +1,215 @@
 # 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 .contexts import CaptureLoggingContext
+from .contexts import CaptureLoggingContextImpl
+from .contexts import LoggingExcInfoArg
+from .levels import LogLevel
 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
+LoggingMsgFn = ta.Callable[[], ta.Union[str, tuple]]  # ta.TypeAlias
 
 
 ##
 
 
-@ta.final
-class LoggingContext:
-    level: NamedLogLevel
+class AnyLogger(Abstract, ta.Generic[T]):
+    def is_enabled_for(self, level: LogLevel) -> bool:
+        return self.get_effective_level() >= level
 
-    time_ns: int
+    @abc.abstractmethod
+    def get_effective_level(self) -> LogLevel:
+        raise NotImplementedError
 
-    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 isEnabledFor(self, level: LogLevel) -> bool:  # noqa
+        return self.is_enabled_for(level)
 
-    def __init__(
-            self,
-            level: LogLevel,
-            *,
-            time_ns: ta.Optional[int] = None,
+    @ta.final
+    def getEffectiveLevel(self) -> LogLevel:  # noqa
+        return self.get_effective_level()
 
-            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]
+    @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:
+        ...
 
-        if time_ns is None:
-            time_ns = time.time_ns()
-        self.time_ns: int = time_ns
+    @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)
 
-        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
+    #
 
-        #
+    @ta.overload
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-        if caller is not LoggingContext.NOT_SET:
-            self._caller = caller  # type: ignore[assignment]
-        else:
-            self._stack_offset = stack_offset
-            self._stack_info = stack_info
+    @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:
+        ...
 
-        self.thread = LoggingThreadInfo.build()
-        self.process = LoggingProcessInfo.build()
-        self.multiprocessing = LoggingMultiprocessingInfo.build()
-        self.asyncio_task = LoggingAsyncioTaskInfo.build()
+    @ta.final
+    def debug(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.DEBUG, stack_offset=1), *args, **kwargs)
 
     #
 
-    _times: LoggingTimeFields
-
-    @property
-    def times(self) -> LoggingTimeFields:
-        try:
-            return self._times
-        except AttributeError:
-            pass
-
-        times = self._times = LoggingTimeFields.build(self.time_ns)
-        return times
-
-    #
+    @ta.overload
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-    def inc_stack_offset(self, ofs: int = 1) -> 'LoggingContext':
-        if hasattr(self, '_stack_offset'):
-            self._stack_offset += ofs
-        return self
+    @ta.overload
+    def info(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-    _caller: ta.Optional[LoggingCaller]
+    @ta.overload
+    def info(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
-    def build_caller(self) -> ta.Optional[LoggingCaller]:
-        """Must be cooperatively called only from the exact configured _stack_offset."""
+    @ta.final
+    def info(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.INFO, stack_offset=1), *args, **kwargs)
 
-        try:
-            return self._caller
-        except AttributeError:
-            pass
+    #
 
-        caller = self._caller = LoggingCaller.find(
-            self._stack_offset + 1,
-            stack_info=self._stack_info,
-        )
-        return caller
+    @ta.overload
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-    def caller(self) -> ta.Optional[LoggingCaller]:
-        try:
-            return self._caller
-        except AttributeError:
-            return None
+    @ta.overload
+    def warning(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-    _source_file: ta.Optional[LoggingSourceFileInfo]
+    @ta.overload
+    def warning(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
-    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
-        try:
-            return self._source_file
-        except AttributeError:
-            pass
+    @ta.final
+    def warning(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.WARNING, stack_offset=1), *args, **kwargs)
 
-        if (caller := self.caller()) is None:
-            return None
+    #
 
-        src_file = self._source_file = LoggingSourceFileInfo.build(caller.file_path)
-        return src_file
+    @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)
 
-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.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.final
-    def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
-        return self.is_enabled_for(level)
+    @ta.overload
+    def exception(self, msg_fn: LoggingMsgFn, *, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        ...
 
     @ta.final
-    def getEffectiveLevel(self) -> LogLevel:  # noqa
-        return self.get_effective_level()
+    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.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.overload
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-    @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.overload
+    def critical(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-    @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.overload
+    def critical(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
     @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)
+    def critical(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.CRITICAL, stack_offset=1), *args, **kwargs)
+
+    ##
+
+    @classmethod
+    def _prepare_msg_args(cls, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> ta.Tuple[str, tuple]:
+        if callable(msg):
+            if args:
+                raise TypeError(f'Must not provide both a message function and args: {msg=} {args=}')
+            x = msg()
+            if isinstance(x, str):
+                return x, ()
+            elif isinstance(x, tuple):
+                if x:
+                    return x[0], x[1:]
+                else:
+                    return '', ()
+            else:
+                raise TypeError(x)
 
-    @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)
+        elif isinstance(msg, tuple):
+            if args:
+                raise TypeError(f'Must not provide both a tuple message and args: {msg=} {args=}')
+            if msg:
+                return msg[0], msg[1:]
+            else:
+                return '', ()
 
-    @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)
+        elif isinstance(msg, str):
+            return msg, args
 
-    #
+        else:
+            raise TypeError(msg)
 
     @abc.abstractmethod
-    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+    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: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+    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: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:  # noqa
         raise NotImplementedError
 
 
@@ -238,11 +224,11 @@ class AnyNopLogger(AnyLogger[T], Abstract):
 
 @ta.final
 class NopLogger(AnyNopLogger[None], Logger):
-    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+    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: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+    async def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
         pass

omlish/logs/callers.py

@@ -7,11 +7,13 @@ import traceback
 import types
 import typing as ta
 
+from .infos import LoggingContextInfo
+
 
 ##
 
 
-class LoggingCaller(ta.NamedTuple):
+class LoggingCaller(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     file_path: str
     line_no: int
     name: str
@@ -57,8 +59,6 @@ class LoggingCaller(ta.NamedTuple):
         sinfo = None
         if stack_info:
             sio = io.StringIO()
-            # 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()