omlish 0.0.0.dev430__py3-none-any.whl → 0.0.0.dev432__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev430'
-__revision__ = '36144d896de4a99623dc872d90d16dfe60a47934'
+__version__ = '0.0.0.dev432'
+__revision__ = '7ead9c62b6897ffcbdb85f12366ebaaf41f89d7a'
 
 
 #

omlish/asyncs/ioproxy/proxy.py

@@ -104,7 +104,7 @@ class AsyncIoProxy:
     __proxied_cls__: ta.ClassVar[type]
 
     def __init_subclass__(cls, *, proxied_cls=None, **kwargs):  # noqa
-        super().__init_subclass__()
+        super().__init_subclass__(**kwargs)
 
         cls.__proxied_cls__ = check.isinstance(proxied_cls, (type, None))
 

omlish/concurrent/__init__.py

@@ -1,11 +1,17 @@
-from .executors import (  # noqa
-    ImmediateExecutor,
-    new_executor,
-)
-
-from .futures import (  # noqa
-    FutureError,
-    FutureTimeoutError,
-    wait_futures,
-    wait_dependent_futures,
-)
+from .. import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .executors import (  # noqa
+        ImmediateExecutor,
+        new_executor,
+    )
+
+    from .futures import (  # noqa
+        FutureError,
+        FutureTimeoutError,
+        wait_futures,
+        wait_dependent_futures,
+    )

omlish/funcs/match.py

@@ -208,7 +208,7 @@ class MatchFnClass(MatchFn[P, T]):
         return mf
 
     def __init_subclass__(cls, strict: bool = False, **kwargs: ta.Any) -> None:
-        super().__init_subclass__()
+        super().__init_subclass__(**kwargs)
 
         if '_cls_match_fn' in cls.__dict__:
             raise AttributeError('_cls_match_fn')

omlish/lang/imports/proxyinit.py

@@ -644,9 +644,10 @@ def auto_proxy_init(
         update_exports: bool = False,
 ) -> ta.Iterator[AutoProxyInit]:
     """
-    This is a bit extreme - use sparingly. It relies on an interpreter-global import lock, but much of the ecosystem
-    implicitly does anyway. It further relies on temporarily patching `__builtins__.__import__`, but could be switched
-    to use any number of other import hooks.
+    This is a bit extreme, but worth it. For simplicity, it currently relies on temporarily patching
+    `__builtins__.__import__` for the duration of its context manager, but it can be switched to use any number of other
+    import hooks (like `sys.meta_path`). It does not rely on any permanent modification to import machinery, only for
+    the duration of its capture.
     """
 
     inst = AutoProxyInit(

omlish/logs/all.py

@@ -9,6 +9,10 @@ with _lang.auto_proxy_init(globals()):
         TidLoggingFilter,
     )
 
+    from .std.formatters import (  # noqa
+        StdLoggingFormatter,
+    )
+
     from .std.handlers import (  # noqa
         ListLoggingHandler,
     )
@@ -44,23 +48,17 @@ with _lang.auto_proxy_init(globals()):
         AsyncNopLogger,
     )
 
-    from .callers import (  # noqa
-        LoggingCaller,
-    )
-
     from .contexts import (  # noqa
-        LoggingExcInfoTuple,
-        LoggingExcInfo,
-
         LoggingContext,
     )
 
+    from .formatters import (  # noqa
+        LoggingContextFormatter,
+    )
+
     from .infos import (  # noqa
-        LoggingSourceFileInfo,
-        LoggingThreadInfo,
-        LoggingProcessInfo,
-        LoggingMultiprocessingInfo,
-        LoggingAsyncioTaskInfo,
+        LoggingContextInfo,
+        LoggingContextInfos,
     )
 
     from .levels import (  # noqa

omlish/logs/base.py

@@ -166,36 +166,6 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     ##
 
-    @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)
-
-        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 '', ()
-
-        elif isinstance(msg, str):
-            return msg, args
-
-        else:
-            raise TypeError(msg)
-
     @abc.abstractmethod
     def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> T:  # noqa
         raise NotImplementedError

omlish/logs/contexts.py

@@ -1,94 +1,64 @@
 # 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 .infos import LoggingContextInfo
+from .infos import LoggingContextInfos
+from .infos import LoggingExcInfoArg
+from .infos import LoggingMsgFn
 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
+LoggingContextInfoT = ta.TypeVar('LoggingContextInfoT', bound=LoggingContextInfo)
 
 
 ##
 
 
 class LoggingContext(Abstract):
-    @property
     @abc.abstractmethod
-    def level(self) -> NamedLogLevel:
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
         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
+    @ta.final
+    def __getitem__(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self.get_info(ty)
 
-    @property
-    @abc.abstractmethod
-    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
-        raise NotImplementedError
+    @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
 
-    #
 
-    @abc.abstractmethod
-    def caller(self) -> ta.Optional[LoggingCaller]:
-        raise NotImplementedError
+@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}
 
-    @abc.abstractmethod
-    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
-        raise NotImplementedError
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self._infos.get(ty)
 
-    #
 
-    @abc.abstractmethod
-    def thread(self) -> ta.Optional[LoggingThreadInfo]:
-        raise NotImplementedError
+##
 
-    @abc.abstractmethod
-    def process(self) -> ta.Optional[LoggingProcessInfo]:
-        raise NotImplementedError
 
+class CaptureLoggingContext(LoggingContext, Abstract):
     @abc.abstractmethod
-    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
-        raise NotImplementedError
+    def set_basic(
+            self,
+            name: str,
 
-    @abc.abstractmethod
-    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            args: tuple,
+    ) -> 'CaptureLoggingContext':
         raise NotImplementedError
 
+    #
 
-##
-
-
-class CaptureLoggingContext(LoggingContext, Abstract):
     class AlreadyCapturedError(Exception):
         pass
 
@@ -119,80 +89,50 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
 
             exc_info: LoggingExcInfoArg = False,
 
-            caller: ta.Union[LoggingCaller, ta.Type[NOT_SET], None] = NOT_SET,
+            caller: ta.Union[LoggingContextInfos.Caller, 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
-
-        #
+        # TODO: Name, Msg, Extra
 
         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
 
-        #
+        self._infos: ta.Dict[ta.Type[LoggingContextInfo], LoggingContextInfo] = {}
+        self._set_info(
+            LoggingContextInfos.Level.build(level),
+            LoggingContextInfos.Time.build(time_ns),
+            LoggingContextInfos.Exc.build(exc_info),
+        )
 
         if caller is not CaptureLoggingContextImpl.NOT_SET:
-            self._caller = caller  # type: ignore[assignment]
+            self._infos[LoggingContextInfos.Caller] = caller
         else:
             self._stack_offset = stack_offset
             self._stack_info = stack_info
 
-    ##
-
-    @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
+    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)
 
-    _exc_info: ta.Optional[LoggingExcInfo] = None
-    _exc_info_tuple: ta.Optional[LoggingExcInfoTuple] = None
+    ##
 
-    @property
-    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
-        return self._exc_info
+    def set_basic(
+            self,
+            name: str,
 
-    @property
-    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
-        return self._exc_info_tuple
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            args: tuple,
+    ) -> 'CaptureLoggingContextImpl':
+        return self._set_info(
+            LoggingContextInfos.Name(name),
+            LoggingContextInfos.Msg.build(msg, *args),
+        )
 
     ##
 
@@ -206,71 +146,25 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
 
     _has_captured: bool = False
 
-    _caller: ta.Optional[LoggingCaller]
-    _source_file: ta.Optional[LoggingSourceFileInfo]
-
-    _thread: ta.Optional[LoggingThreadInfo]
-    _process: ta.Optional[LoggingProcessInfo]
-    _multiprocessing: ta.Optional[LoggingMultiprocessingInfo]
-    _asyncio_task: ta.Optional[LoggingAsyncioTaskInfo]
-
     def capture(self) -> None:
         if self._has_captured:
             raise CaptureLoggingContextImpl.AlreadyCapturedError
         self._has_captured = True
 
-        if not hasattr(self, '_caller'):
-            self._caller = LoggingCaller.find(
+        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._caller) is not None:
-            self._source_file = LoggingSourceFileInfo.build(caller.file_path)
-        else:
-            self._source_file = None
-
-        self._thread = LoggingThreadInfo.build()
-        self._process = LoggingProcessInfo.build()
-        self._multiprocessing = LoggingMultiprocessingInfo.build()
-        self._asyncio_task = LoggingAsyncioTaskInfo.build()
-
-    #
-
-    def caller(self) -> ta.Optional[LoggingCaller]:
-        try:
-            return self._caller
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
-
-    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
-        try:
-            return self._source_file
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
-
-    #
-
-    def thread(self) -> ta.Optional[LoggingThreadInfo]:
-        try:
-            return self._thread
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
-
-    def process(self) -> ta.Optional[LoggingProcessInfo]:
-        try:
-            return self._process
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
-
-    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
-        try:
-            return self._multiprocessing
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
-
-    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
-        try:
-            return self._asyncio_task
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
+            ))
+
+        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