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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev426'
-__revision__ = '94f5fd2fe7124da5d9b5af104cba12b1bbdb3286'
+__version__ = '0.0.0.dev427'
+__revision__ = '13723ced41ac43696831e7a640c46f91663c9a46'
 
 
 #

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()

omlish/logs/contexts.py

@@ -0,0 +1,250 @@
+# 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 LogLevel
+from .levels import NamedLogLevel
+from .times import LoggingTimeFields
+
+
+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
+
+
+##
+
+
+class LoggingContext(Abstract):
+    @property
+    @abc.abstractmethod
+    def level(self) -> NamedLogLevel:
+        raise NotImplementedError
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def time_ns(self) -> int:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def times(self) -> LoggingTimeFields:
+        raise NotImplementedError
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def caller(self) -> ta.Optional[LoggingCaller]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def thread(self) -> ta.Optional[LoggingThreadInfo]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def process(self) -> ta.Optional[LoggingProcessInfo]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
+        raise NotImplementedError
+
+
+##
+
+
+class CaptureLoggingContext(LoggingContext, Abstract):
+    @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[LoggingCaller, ta.Type[NOT_SET], None] = NOT_SET,
+            stack_offset: int = 0,
+            stack_info: bool = False,
+    ) -> None:
+        self._level: NamedLogLevel = level if level.__class__ is NamedLogLevel else NamedLogLevel(level)  # type: ignore[assignment]  # noqa
+
+        #
+
+        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: ta.Optional[LoggingExcInfo] = exc_info
+            if isinstance(exc_info, BaseException):
+                self._exc_info_tuple: ta.Optional[LoggingExcInfoTuple] = (type(exc_info), exc_info, exc_info.__traceback__)  # noqa
+            else:
+                self._exc_info_tuple = exc_info
+        else:
+            self._exc_info = None
+            self._exc_info_tuple = None
+
+        #
+
+        if caller is not CaptureLoggingContextImpl.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()
+
+    #
+
+    @property
+    def level(self) -> NamedLogLevel:
+        return self._level
+
+    #
+
+    @property
+    def time_ns(self) -> int:
+        return self._time_ns
+
+    _times: LoggingTimeFields
+
+    @property
+    def times(self) -> LoggingTimeFields:
+        try:
+            return self._times
+        except AttributeError:
+            pass
+
+        times = self._times = LoggingTimeFields.build(self.time_ns)
+        return times
+
+    @property
+    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
+        return self._exc_info
+
+    @property
+    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
+        return self._exc_info_tuple
+
+    #
+
+    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 capture(self) -> None:
+        """Must be cooperatively called only from the exact configured _stack_offset."""
+
+        try:
+            self._caller  # noqa
+        except AttributeError:
+            pass
+
+        self._caller = LoggingCaller.find(
+            self._stack_offset + 1,
+            stack_info=self._stack_info,
+        )
+
+    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
+
+    #
+
+    def thread(self) -> ta.Optional[LoggingThreadInfo]:
+        return self._thread
+
+    def process(self) -> ta.Optional[LoggingProcessInfo]:
+        return self._process
+
+    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
+        return self._multiprocessing
+
+    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
+        return self._asyncio_task

omlish/logs/infos.py

@@ -9,8 +9,19 @@ import typing as ta
 ##
 
 
+class _LoggingContextInfo:
+    def __mro_entries__(self, bases):
+        return ()
+
+
+LoggingContextInfo: type = ta.cast(ta.Any, _LoggingContextInfo())
+
+
+##
+
+
 @ta.final
-class LoggingSourceFileInfo(ta.NamedTuple):
+class LoggingSourceFileInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     file_name: str
     module: str
 
@@ -36,7 +47,7 @@ class LoggingSourceFileInfo(ta.NamedTuple):
 
 
 @ta.final
-class LoggingThreadInfo(ta.NamedTuple):
+class LoggingThreadInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     ident: int
     native_id: ta.Optional[int]
     name: str
@@ -54,7 +65,7 @@ class LoggingThreadInfo(ta.NamedTuple):
 
 
 @ta.final
-class LoggingProcessInfo(ta.NamedTuple):
+class LoggingProcessInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     pid: int
 
     @classmethod
@@ -68,7 +79,7 @@ class LoggingProcessInfo(ta.NamedTuple):
 
 
 @ta.final
-class LoggingMultiprocessingInfo(ta.NamedTuple):
+class LoggingMultiprocessingInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     process_name: str
 
     @classmethod
@@ -86,7 +97,7 @@ class LoggingMultiprocessingInfo(ta.NamedTuple):
 
 
 @ta.final
-class LoggingAsyncioTaskInfo(ta.NamedTuple):
+class LoggingAsyncioTaskInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     name: str
 
     @classmethod

omlish/logs/protocols.py

@@ -16,16 +16,16 @@ class LoggerLike(ta.Protocol):
 
     #
 
-    def debug(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
 
-    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+    def debug(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 info(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 warning(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 error(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 exception(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
+    def critical(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa

omlish/logs/std/adapters.py

@@ -1,10 +1,12 @@
+# ruff: noqa: UP007
 # @omlish-lite
 import logging
 import typing as ta
 
 from ..base import Logger
-from ..base import LoggingContext
-from ..base import LogLevel
+from ..base import LoggingMsgFn
+from ..contexts import CaptureLoggingContext
+from ..levels import LogLevel
 from .records import LoggingContextLogRecord
 
 
@@ -24,15 +26,17 @@ class StdLogger(Logger):
     def get_effective_level(self) -> LogLevel:
         return self._std.getEffectiveLevel()
 
-    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any) -> None:
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> None:
         if not self.is_enabled_for(ctx.level):
             return
 
-        ctx.build_caller()
+        ctx.capture()
+
+        ms, args = self._prepare_msg_args(msg, *args)
 
         rec = LoggingContextLogRecord(
             name=self._std.name,
-            msg=msg,
+            msg=ms,
             args=args,
 
             _logging_context=ctx,

omlish/logs/std/records.py

@@ -5,8 +5,9 @@ import logging
 import sys
 import typing as ta
 
-from ..base import LoggingContext
-from ..base import LoggingExcInfoTuple
+from ...lite.check import check
+from ..contexts import LoggingContext
+from ..contexts import LoggingExcInfoTuple
 from ..warnings import LoggingSetupWarning
 
 
@@ -268,19 +269,33 @@ class LoggingContextLogRecord(logging.LogRecord):
         self.msecs: float = times.msecs
         self.relativeCreated: float = times.relative_created
 
-        thread = ctx.thread
-        self.thread: ta.Optional[int] = thread.ident
-        self.threadName: ta.Optional[str] = thread.name
+        if logging.logThreads:
+            thread = check.not_none(ctx.thread())
+            self.thread: ta.Optional[int] = thread.ident
+            self.threadName: ta.Optional[str] = thread.name
+        else:
+            self.thread = None
+            self.threadName = None
 
-        process = ctx.process
-        self.process: ta.Optional[int] = process.pid
+        if logging.logProcesses:
+            process = check.not_none(ctx.process())
+            self.process: ta.Optional[int] = process.pid
+        else:
+            self.process = None
 
-        if (mp := ctx.multiprocessing) is not None:
-            self.processName: ta.Optional[str] = mp.process_name
+        if logging.logMultiprocessing:
+            if (mp := ctx.multiprocessing()) is not None:
+                self.processName: ta.Optional[str] = mp.process_name
+            else:
+                self.processName = None
         else:
             self.processName = None
 
-        if (at := ctx.asyncio_task) is not None:
-            self.taskName: ta.Optional[str] = at.name
+        # Absent <3.12
+        if getattr(logging, 'logAsyncioTasks', None):
+            if (at := ctx.asyncio_task()) is not None:
+                self.taskName: ta.Optional[str] = at.name
+            else:
+                self.taskName = None
         else:
             self.taskName = None

omlish/logs/times.py

@@ -4,13 +4,14 @@ import logging
 import time
 import typing as ta
 
+from .infos import LoggingContextInfo
 from .warnings import LoggingSetupWarning
 
 
 ##
 
 
-class LoggingTimeFields(ta.NamedTuple):
+class LoggingTimeFields(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     """Maps directly to stdlib `logging.LogRecord` fields, and must be kept in sync with it."""
 
     created: float

omlish/manifests/loading.py

@@ -8,6 +8,12 @@ TODO:
  - TypeMap style weak cache of issubclass queries
   - wait.. lazily load the class for virtual subclass queries? xor support virtual bases?
  - weakref class dict keys?
+ - cheap_discover_package_root_dirs: Seq[str] | None = None or smth
+ - maaaybe.. add an EnvVar? OMLISH_MANIFEST_ROOT_DIRS? if set to : delimited, turns off package disco and overrides
+   scan_root_dirs
+  - currently the cli cant subprocess itself and keep manifests working
+  - EnvVar cls is already lite
+
 """
 import dataclasses as dc
 import importlib.machinery

omlish/sockets/server/server.py

@@ -20,7 +20,7 @@ from .handlers import SocketServerHandler
 ##
 
 
-class SocketServer(Abstract):
+class SocketServer:
     _DEFAULT_LOGGER = logging.getLogger('.'.join([__name__, 'SocketServer']))
 
     def __init__(

{omlish-0.0.0.dev426.dist-info → omlish-0.0.0.dev427.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev426
+Version: 0.0.0.dev427
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev426.dist-info → omlish-0.0.0.dev427.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.omlish-manifests.json,sha256=FLw7xkPiSXuImZgqSP8BwrEib2R1doSzUPLUkc-QUIA,8410
-omlish/__about__.py,sha256=MYyAs26jJT38QRig9P3Am4tubSo27oP0MXHBDXiAQ_g,3575
+omlish/__about__.py,sha256=QkXaBAuv7ZX9gYuayTSwd9nc5AxEetkjHMvq5rsSLtM,3575
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ZNIMl1kwg3qdei4DiUrJPQe5M81S1e76N-GuNSwLBAE,8683
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -498,25 +498,26 @@ omlish/lite/typing.py,sha256=m2CyJTz2OVOCPRvp-0UuEx7oleZgXqs3rYXijE0bTsA,1280
 omlish/lite/wrappers.py,sha256=d00Ls2kFHuogKd5wEBaU65VNCN10YXIZtiwu1mbMpmA,530
 omlish/logs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/logs/all.py,sha256=9VOobL0p3E_6QWsnBmlCPhxz5zqs-AiH4jvZR3--ZZA,1085
-omlish/logs/base.py,sha256=BOKgiimvHboKE9UTMKpRSeSZoZhhyf0TQ5u-mRozLWU,7071
-omlish/logs/callers.py,sha256=j6zq_cKdCrlG4O1ODgZPqUKmQ2ebmCnJrdzHmtffCtQ,2094
-omlish/logs/infos.py,sha256=-FRTuawNwvK2SBjNKby5IUsS0Q2o9H1q8tFTqDNeWIE,2348
+omlish/logs/base.py,sha256=LxDnvCDzZr9AfjO_5NmoE9z1Mqw_7meQ7WGgGYissXk,6649
+omlish/logs/callers.py,sha256=tRj24LxlEimDGCplDVVJDvRSt_u72cgjnnvb0mdZgvU,2065
+omlish/logs/contexts.py,sha256=apXaLOk7LlXNdz_gpF5zHhTLpFFBmB2_SHX8UVxopks,6537
+omlish/logs/infos.py,sha256=VPx9VrcN1fCPnXjc8QCsMlww0fgEG3qdkzo2KhSxMwY,2716
 omlish/logs/levels.py,sha256=b3i-70OcvNMcOQBzg1IUHBPESfHz0uu5mi5t_jbwv1Y,1966
 omlish/logs/modules.py,sha256=EFOqubbU5P0GW576OL6j9fmizNN2oyfpsp5YnKCoUgk,194
-omlish/logs/protocols.py,sha256=19Hre-98MWnN9oGz4O4RBczpwA5Slg15l9Y-ilbixgs,918
+omlish/logs/protocols.py,sha256=8l5TgNUNgfrqYPA6dVijPFGLxzWhvgS4Cca64XHT0jo,939
 omlish/logs/standard.py,sha256=ppho-wDecGxUiRXOdCIlblmrQhqXZ0oQOGayy8N53XY,3237
-omlish/logs/times.py,sha256=KFe7FuBjkFxVz6Kl9TlTD2J1FLLeHUs8OI8tKw8StKQ,2491
+omlish/logs/times.py,sha256=ro2TSD_Xwq_cNN8f_FrEGfdhD4PTbh0PLSG13PGx39E,2571
 omlish/logs/utils.py,sha256=fKvP342qBmE8wwTgUQ8Tf0-ATVhCm90UYBQt2pk0044,1883
 omlish/logs/warnings.py,sha256=xyhDgiPy1p8Kp5D9sb_NZiBnQ26SUppaHqC27dtQzok,67
 omlish/logs/std/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/logs/std/adapters.py,sha256=8Z3e9hZRz-8HpW3PnlTURAQLzGG7gb327P4tQ9AZSV8,853
+omlish/logs/std/adapters.py,sha256=qRXusW8iGYF29C3cy1srb4pgJ0Fv5li8bUvnegxo9o8,1005
 omlish/logs/std/configs.py,sha256=aDQahqBJXJpmQBaxXVK5S2xi_I_nrLLcCLTq6Q2K6EQ,1037
 omlish/logs/std/filters.py,sha256=Z8tHOvBRiP-OYm2z5cwY-lYXRimNgferEARMwvwx5Pw,380
 omlish/logs/std/handlers.py,sha256=nYPKV6Kzz8Oeyw4-3ZdJKKEUfgubfmwzqr3RaCNcmS4,338
 omlish/logs/std/json.py,sha256=QJ5lywLsRsPyVno2nk2kOw-Z1z3bfrDiZzqcRUdWUMY,1382
 omlish/logs/std/noisy.py,sha256=hWpbseerZqlHdEPEajDTSmcRhx8LmmNAxz_7GBZAO9s,353
 omlish/logs/std/proxy.py,sha256=9MVV5kbj9nwl3KZGtrYCIb5XTpv33f33zZ7P_B58fX0,2394
-omlish/logs/std/records.py,sha256=TCpslKiIBYI2ZIvJWyABpa7Ovt-f4jpQYsYuHE2oYTA,10183
+omlish/logs/std/records.py,sha256=muJA3KKjGm5mgsHXtOyrpaEZu553M-UviNgNvXdISXY,10718
 omlish/logs/typed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/logs/typed/bindings.py,sha256=H_B-3LTGFlBIWYDJ8rei1VMfInE8KrBwRo3bJ_BgFj8,18184
 omlish/logs/typed/contexts.py,sha256=MU1RqHtmYbnxoLfLhMZbTbRd-WfYEyeVo7_3VnG3rY0,4027
@@ -525,7 +526,7 @@ omlish/logs/typed/values.py,sha256=w8ukpJZ3lx_st7Mj7riP2squzGmMaz7OuUxw_NZCZsY,3
 omlish/manifests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/manifests/base.py,sha256=wW-De-pU3cef-0vGsgo-ypftDwc3tCBxhRAzPtrdark,918
 omlish/manifests/globals.py,sha256=kVqQ-fT4kc7xWzLHoI731GviitFPv2v2yqw-p7t7Exs,2628
-omlish/manifests/loading.py,sha256=RUFRZ8ILU_aG11BYDpWAYlc--58HmlSYSLHkHqLUwd8,17208
+omlish/manifests/loading.py,sha256=s6KnhdFQCsI2i0Rus1sMU0so2v8dUBnk59BJkSnxGt8,17514
 omlish/manifests/static.py,sha256=9BaPBLkuzxHmg5A-5k9BjjBFINCdmFOIu06dMFgCfz4,497
 omlish/manifests/types.py,sha256=NeOGuIVrcbqjCDbQ3MnCxxHAgHnw0CkWJsBzo230PWE,453
 omlish/marshal/__init__.py,sha256=cdRll_tPZaTBIY0yLejCXZdZB3fUVkIoDMb8aESLkl8,5981
@@ -646,7 +647,7 @@ omlish/sockets/ports.py,sha256=WofuoMTQNUhbEreL0lrMQyVEZm6awuLLpFvn6jnFKrw,1778
 omlish/sockets/wait.py,sha256=GQIRABh_NWHePuNVz5bBeg7iVln-YHc3945ZA0qr-mA,1565
 omlish/sockets/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/sockets/server/handlers.py,sha256=T--CSns9810f25--0Blv5bspAXhMjULtKEcXSGUpxOo,3912
-omlish/sockets/server/server.py,sha256=Z3kJ5LbO-sdJICxouv85KtDEmRb5_0kGNyHgdVrVzlM,6299
+omlish/sockets/server/server.py,sha256=Il1y0LHRa_eB6FLLcuVXbfu9tLOpOttLBCffh3wWSBA,6289
 omlish/sockets/server/ssl.py,sha256=QLiPcng1f1RFDhw4aS-Fy57fm0R7CXm76STpHmT55z0,1067
 omlish/sockets/server/threading.py,sha256=CPr_290vpN3o4p2ehQBIwk-d8Ciasylp9v2zUQSB5xk,2862
 omlish/specs/__init__.py,sha256=fxpcfXEWESH2kiPStKhl2dAdfLkZVTt_cssZKyqBLiQ,87
@@ -891,9 +892,9 @@ omlish/typedvalues/marshal.py,sha256=AtBz7Jq-BfW8vwM7HSxSpR85JAXmxK2T0xDblmm1HI0
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev426.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev426.dist-info/METADATA,sha256=3sUi7uVlvrzlrg2y4hzuNQqNdMcPQ7K_V1wfLElyjrM,19243
-omlish-0.0.0.dev426.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev426.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev426.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev426.dist-info/RECORD,,
+omlish-0.0.0.dev427.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev427.dist-info/METADATA,sha256=XcyPFrnqymcaHcY3ycLj3wJn1_l-E-qdd3MilxfuI8o,19243
+omlish-0.0.0.dev427.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev427.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev427.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev427.dist-info/RECORD,,