omlish 0.0.0.dev430__tar.gz → 0.0.0.dev432__tar.gz

{omlish-0.0.0.dev430/omlish.egg-info → omlish-0.0.0.dev432}/PKG-INFO

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

{omlish-0.0.0.dev430 → omlish-0.0.0.dev432}/omlish/__about__.py

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

{omlish-0.0.0.dev430 → omlish-0.0.0.dev432}/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-0.0.0.dev432/omlish/concurrent/__init__.py

@@ -0,0 +1,17 @@
+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-0.0.0.dev430 → omlish-0.0.0.dev432}/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-0.0.0.dev430 → omlish-0.0.0.dev432}/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-0.0.0.dev430 → omlish-0.0.0.dev432}/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-0.0.0.dev430 → omlish-0.0.0.dev432}/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-0.0.0.dev432/omlish/logs/contexts.py

@@ -0,0 +1,170 @@
+# 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:
+        # TODO: Name, Msg, Extra
+
+        if time_ns is None:
+            time_ns = time.time_ns()
+
+        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._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-0.0.0.dev432/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