omlish 0.0.0.dev429__py3-none-any.whl → 0.0.0.dev431__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev429'
-__revision__ = 'aec560601e4f8ecdc171e4341c2b17e996a0ef91'
+__version__ = '0.0.0.dev431'
+__revision__ = '2294dfec3fc11ecdc80e86c2f6912e3c650d5c9c'
 
 
 #

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/asyncs.py

@@ -19,9 +19,7 @@ def as_async(fn: ta.Callable[P, T], *, wrap: bool = False) -> ta.Callable[P, ta.
 ##
 
 
-async def async_list(
-        ai: ta.AsyncIterable[T],
-) -> list[T]:
+async def async_list(ai: ta.AsyncIterable[T]) -> list[T]:
     """Simply eagerly reads the full contents of a function call returning an async iterator."""
 
     return [v async for v in ai]
@@ -30,9 +28,7 @@ async def async_list(
 ##
 
 
-def sync_await(
-        aw: ta.Awaitable[T],
-) -> T:
+def sync_await(aw: ta.Awaitable[T]) -> T:
     """
     Allows for the synchronous execution of async functions which will never actually *externally* await anything. These
     functions are allowed to await any number of other functions - including contextmanagers and generators - so long as

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/lite/attrops.py

@@ -285,8 +285,6 @@ class AttrOps(ta.Generic[T]):
         self._eq = _eq
         return _eq
 
-    #
-
     @property
     def hash_eq(self) -> ta.Tuple[
         ta.Callable[[T], int],
@@ -294,6 +292,8 @@ class AttrOps(ta.Generic[T]):
     ]:
         return (self.hash, self.eq)
 
+    #
+
     @property
     def repr_hash_eq(self) -> ta.Tuple[
         ta.Callable[[T], str],
@@ -304,20 +304,25 @@ class AttrOps(ta.Generic[T]):
 
     #
 
+    class NOT_SET:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
     def install(
             self,
             locals_dct: ta.MutableMapping[str, ta.Any],
             *,
-            all: bool = False,  # noqa
-            repr: bool = False,  # noqa
-            hash: bool = False,  # noqa
-            eq: bool = False,
+            repr: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,  # noqa
+            hash: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,  # noqa
+            eq: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,
     ) -> 'AttrOps[T]':
-        if repr or all:
+        if all(a is self.NOT_SET for a in (repr, hash, eq)):
+            repr = hash = eq = True  # noqa
+        if repr:
             locals_dct.update(__repr__=self.repr)
-        if hash or all:
+        if hash:
             locals_dct.update(__hash__=self.hash)
-        if eq or all:
+        if eq:
             locals_dct.update(__eq__=self.eq)
         return self
 

omlish/logs/all.py

@@ -17,6 +17,10 @@ with _lang.auto_proxy_init(globals()):
         JsonLoggingFormatter,
     )
 
+    from .std.loggers import (  # noqa
+        StdLogger,
+    )
+
     from .std.noisy import (  # noqa
         silence_noisy_loggers,
     )
@@ -26,8 +30,27 @@ with _lang.auto_proxy_init(globals()):
         ProxyLoggingHandler,
     )
 
-    from .callers import (  # noqa
-        LoggingCaller,
+    from .std.records import (  # noqa
+        LoggingContextLogRecord,
+    )
+
+    from .base import (  # noqa
+        AnyLogger,
+        Logger,
+        AsyncLogger,
+
+        AnyNopLogger,
+        NopLogger,
+        AsyncNopLogger,
+    )
+
+    from .contexts import (  # noqa
+        LoggingContext,
+    )
+
+    from .infos import (  # noqa
+        LoggingContextInfo,
+        LoggingContextInfos,
     )
 
     from .levels import (  # noqa
@@ -59,3 +82,7 @@ with _lang.auto_proxy_init(globals()):
 
         error_logging,
     )
+
+    from .warnings import (  # noqa
+        LoggingSetupWarning,
+    )

omlish/logs/base.py

@@ -21,7 +21,6 @@ LoggingMsgFn = ta.Callable[[], ta.Union[str, tuple]]  # ta.TypeAlias
 
 
 class AnyLogger(Abstract, ta.Generic[T]):
-    @ta.final
     def is_enabled_for(self, level: LogLevel) -> bool:
         return level >= self.get_effective_level()
 
@@ -167,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
@@ -220,7 +189,7 @@ class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
 class AnyNopLogger(AnyLogger[T], Abstract):
     @ta.final
     def get_effective_level(self) -> LogLevel:
-        return 999
+        return -999
 
 
 @ta.final

omlish/logs/contexts.py

@@ -1,94 +1,54 @@
 # 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
-
-    #
+    @ta.final
+    def __getitem__(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self.get_info(ty)
 
-    @property
-    @abc.abstractmethod
-    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
-        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
 
-    @property
-    @abc.abstractmethod
-    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
-        raise NotImplementedError
+##
 
-    #
 
+class CaptureLoggingContext(LoggingContext, Abstract):
     @abc.abstractmethod
-    def caller(self) -> ta.Optional[LoggingCaller]:
-        raise NotImplementedError
+    def set_basic(
+            self,
+            name: str,
 
-    @abc.abstractmethod
-    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            args: tuple,
+    ) -> 'CaptureLoggingContext':
         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):
     class AlreadyCapturedError(Exception):
         pass
 
@@ -119,80 +79,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 +136,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(),
+        )