omlish 0.0.0.dev430__tar.gz → 0.0.0.dev431__tar.gz

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

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

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

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev430'
-__revision__ = '36144d896de4a99623dc872d90d16dfe60a47934'
+__version__ = '0.0.0.dev431'
+__revision__ = '2294dfec3fc11ecdc80e86c2f6912e3c650d5c9c'
 
 
 #

{omlish-0.0.0.dev430 → omlish-0.0.0.dev431}/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.dev431/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.dev431}/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.dev431}/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.dev431}/omlish/logs/all.py

@@ -44,23 +44,13 @@ with _lang.auto_proxy_init(globals()):
         AsyncNopLogger,
     )
 
-    from .callers import (  # noqa
-        LoggingCaller,
-    )
-
     from .contexts import (  # noqa
-        LoggingExcInfoTuple,
-        LoggingExcInfo,
-
         LoggingContext,
     )
 
     from .infos import (  # noqa
-        LoggingSourceFileInfo,
-        LoggingThreadInfo,
-        LoggingProcessInfo,
-        LoggingMultiprocessingInfo,
-        LoggingAsyncioTaskInfo,
+        LoggingContextInfo,
+        LoggingContextInfos,
     )
 
     from .levels import (  # noqa

{omlish-0.0.0.dev430 → omlish-0.0.0.dev431}/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.dev431/omlish/logs/contexts.py

@@ -0,0 +1,160 @@
+# 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
+
+##
+
+
+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.dev431/omlish/logs/infos.py

@@ -0,0 +1,377 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
+"""
+TODO:
+ - remove redundant info fields only present for std adaptation (Level.name, ...)
+"""
+import collections.abc
+import io
+import logging
+import os.path
+import sys
+import threading
+import time
+import traceback
+import types
+import typing as ta
+
+from .levels import NamedLogLevel
+from .warnings import LoggingSetupWarning
+
+
+LoggingMsgFn = ta.Callable[[], ta.Union[str, tuple]]  # 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
+
+LoggingContextInfo = ta.Any  # ta.TypeAlias
+
+
+##
+
+
+def logging_context_info(cls):
+    return cls
+
+
+@ta.final
+class LoggingContextInfos:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    #
+
+    @logging_context_info
+    @ta.final
+    class Name(ta.NamedTuple):
+        name: str
+
+    @logging_context_info
+    @ta.final
+    class Level(ta.NamedTuple):
+        level: NamedLogLevel
+        name: str
+
+        @classmethod
+        def build(cls, level: int) -> 'LoggingContextInfos.Level':
+            nl: NamedLogLevel = level if level.__class__ is NamedLogLevel else NamedLogLevel(level)  # type: ignore[assignment]  # noqa
+            return cls(
+                level=nl,
+                name=logging.getLevelName(nl),
+            )
+
+    @logging_context_info
+    @ta.final
+    class Msg(ta.NamedTuple):
+        msg: str
+        args: ta.Union[tuple, ta.Mapping[ta.Any, ta.Any], None]
+
+        @classmethod
+        def build(
+                cls,
+                msg: ta.Union[str, tuple, LoggingMsgFn],
+                *args: ta.Any,
+        ) -> 'LoggingContextInfos.Msg':
+            s: str
+            a: ta.Any
+
+            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):
+                    s, a = x, ()
+                elif isinstance(x, tuple):
+                    if x:
+                        s, a = x[0], x[1:]
+                    else:
+                        s, a = '', ()
+                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:
+                    s, a = msg[0], msg[1:]
+                else:
+                    s, a = '', ()
+
+            elif isinstance(msg, str):
+                s, a = msg, args
+
+            else:
+                raise TypeError(msg)
+
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L307  # noqa
+            if a and len(a) == 1 and isinstance(a[0], collections.abc.Mapping) and a[0]:
+                a = a[0]
+
+            return cls(
+                msg=s,
+                args=a,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Extra(ta.NamedTuple):
+        extra: ta.Mapping[ta.Any, ta.Any]
+
+    @logging_context_info
+    @ta.final
+    class Time(ta.NamedTuple):
+        ns: int
+        secs: float
+        msecs: float
+        relative_secs: float
+
+        @classmethod
+        def get_std_start_ns(cls) -> int:
+            x: ta.Any = logging._startTime  # type: ignore[attr-defined]  # noqa
+
+            # Before 3.13.0b1 this will be `time.time()`, a float of seconds. After that, it will be `time.time_ns()`,
+            # an int.
+            #
+            # See:
+            #  - https://github.com/python/cpython/commit/1316692e8c7c1e1f3b6639e51804f9db5ed892ea
+            #
+            if isinstance(x, float):
+                return int(x * 1e9)
+            else:
+                return x
+
+        @classmethod
+        def build(
+                cls,
+                ns: int,
+                *,
+                start_ns: ta.Optional[int] = None,
+        ) -> 'LoggingContextInfos.Time':
+            # https://github.com/python/cpython/commit/1316692e8c7c1e1f3b6639e51804f9db5ed892ea
+            secs = ns / 1e9  # ns to float seconds
+
+            # Get the number of whole milliseconds (0-999) in the fractional part of seconds.
+            # Eg: 1_677_903_920_999_998_503 ns --> 999_998_503 ns--> 999 ms
+            # Convert to float by adding 0.0 for historical reasons. See gh-89047
+            msecs = (ns % 1_000_000_000) // 1_000_000 + 0.0
+
+            # https://github.com/python/cpython/commit/1500a23f33f5a6d052ff1ef6383d9839928b8ff1
+            if msecs == 999.0 and int(secs) != ns // 1_000_000_000:
+                # ns -> sec conversion can round up, e.g:
+                # 1_677_903_920_999_999_900 ns --> 1_677_903_921.0 sec
+                msecs = 0.0
+
+            if start_ns is None:
+                start_ns = cls.get_std_start_ns()
+            relative_secs = (ns - start_ns) / 1e6
+
+            return cls(
+                ns=ns,
+                secs=secs,
+                msecs=msecs,
+                relative_secs=relative_secs,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Exc(ta.NamedTuple):
+        info: LoggingExcInfo
+        info_tuple: LoggingExcInfoTuple
+
+        @classmethod
+        def build(
+                cls,
+                arg: LoggingExcInfoArg = False,
+        ) -> ta.Optional['LoggingContextInfos.Exc']:
+            if arg is True:
+                sys_exc_info = sys.exc_info()
+                if sys_exc_info[0] is not None:
+                    arg = sys_exc_info
+                else:
+                    arg = None
+            elif arg is False:
+                arg = None
+            if arg is None:
+                return None
+
+            info: LoggingExcInfo = arg
+            if isinstance(info, BaseException):
+                info_tuple: LoggingExcInfoTuple = (type(info), info, info.__traceback__)  # noqa
+            else:
+                info_tuple = info
+
+            return cls(
+                info=info,
+                info_tuple=info_tuple,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Caller(ta.NamedTuple):
+        file_path: str
+        line_no: int
+        func_name: str
+        stack_info: ta.Optional[str]
+
+        @classmethod
+        def is_internal_frame(cls, frame: types.FrameType) -> bool:
+            file_path = os.path.normcase(frame.f_code.co_filename)
+
+            # Yes, really.
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L204  # noqa
+            # https://github.com/python/cpython/commit/5ca6d7469be53960843df39bb900e9c3359f127f
+            if 'importlib' in file_path and '_bootstrap' in file_path:
+                return True
+
+            return False
+
+        @classmethod
+        def find_frame(cls, stack_offset: int = 0) -> ta.Optional[types.FrameType]:
+            f: ta.Optional[types.FrameType] = sys._getframe(2 + stack_offset)  # noqa
+
+            while f is not None:
+                # NOTE: We don't check __file__ like stdlib since we may be running amalgamated - we rely on careful,
+                # manual stack_offset management.
+                if hasattr(f, 'f_code'):
+                    return f
+
+                f = f.f_back
+
+            return None
+
+        @classmethod
+        def build(
+                cls,
+                stack_offset: int = 0,
+                *,
+                stack_info: bool = False,
+        ) -> ta.Optional['LoggingContextInfos.Caller']:
+            if (f := cls.find_frame(stack_offset + 1)) is None:
+                return None
+
+            # https://github.com/python/cpython/blob/08e9794517063c8cd92c48714071b1d3c60b71bd/Lib/logging/__init__.py#L1616-L1623  # noqa
+            sinfo = None
+            if stack_info:
+                sio = io.StringIO()
+                traceback.print_stack(f, file=sio)
+                sinfo = sio.getvalue()
+                sio.close()
+                if sinfo[-1] == '\n':
+                    sinfo = sinfo[:-1]
+
+            return cls(
+                file_path=f.f_code.co_filename,
+                line_no=f.f_lineno or 0,
+                func_name=f.f_code.co_name,
+                stack_info=sinfo,
+            )
+
+    @logging_context_info
+    @ta.final
+    class SourceFile(ta.NamedTuple):
+        file_name: str
+        module: str
+
+        @classmethod
+        def build(cls, caller_file_path: ta.Optional[str]) -> ta.Optional['LoggingContextInfos.SourceFile']:
+            if caller_file_path is None:
+                return None
+
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L331-L336  # noqa
+            try:
+                file_name = os.path.basename(caller_file_path)
+                module = os.path.splitext(file_name)[0]
+            except (TypeError, ValueError, AttributeError):
+                return None
+
+            return cls(
+                file_name=file_name,
+                module=module,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Thread(ta.NamedTuple):
+        ident: int
+        native_id: ta.Optional[int]
+        name: str
+
+        @classmethod
+        def build(cls) -> 'LoggingContextInfos.Thread':
+            return cls(
+                ident=threading.get_ident(),
+                native_id=threading.get_native_id() if hasattr(threading, 'get_native_id') else None,
+                name=threading.current_thread().name,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Process(ta.NamedTuple):
+        pid: int
+
+        @classmethod
+        def build(cls) -> 'LoggingContextInfos.Process':
+            return cls(
+                pid=os.getpid(),
+            )
+
+    @logging_context_info
+    @ta.final
+    class Multiprocessing(ta.NamedTuple):
+        process_name: str
+
+        @classmethod
+        def build(cls) -> ta.Optional['LoggingContextInfos.Multiprocessing']:
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L355-L364  # noqa
+            if (mp := sys.modules.get('multiprocessing')) is None:
+                return None
+
+            return cls(
+                process_name=mp.current_process().name,
+            )
+
+    @logging_context_info
+    @ta.final
+    class AsyncioTask(ta.NamedTuple):
+        name: str
+
+        @classmethod
+        def build(cls) -> ta.Optional['LoggingContextInfos.AsyncioTask']:
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L372-L377  # noqa
+            if (asyncio := sys.modules.get('asyncio')) is None:
+                return None
+
+            try:
+                task = asyncio.current_task()
+            except Exception:  # noqa
+                return None
+
+            if task is None:
+                return None
+
+            return cls(
+                name=task.get_name(),  # Always non-None
+            )
+
+
+##
+
+
+class UnexpectedLoggingStartTimeWarning(LoggingSetupWarning):
+    pass
+
+
+def _check_logging_start_time() -> None:
+    if (x := LoggingContextInfos.Time.get_std_start_ns()) < (t := time.time()):
+        import warnings  # noqa
+
+        warnings.warn(
+            f'Unexpected logging start time detected: '
+            f'get_std_start_ns={x}, '
+            f'time.time()={t}',
+            UnexpectedLoggingStartTimeWarning,
+        )
+
+
+_check_logging_start_time()