omlish 0.0.0.dev420__py3-none-any.whl → 0.0.0.dev422__py3-none-any.whl

omlish/lite/reflect.py

@@ -91,18 +91,3 @@ def is_literal_type(spec: ta.Any) -> bool:
 
 def get_literal_type_args(spec: ta.Any) -> ta.Iterable[ta.Any]:
     return spec.__args__
-
-
-##
-
-
-def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
-    seen = set()
-    todo = list(reversed(cls.__subclasses__()))
-    while todo:
-        cur = todo.pop()
-        if cur in seen:
-            continue
-        seen.add(cur)
-        yield cur
-        todo.extend(reversed(cur.__subclasses__()))

omlish/lite/timeouts.py

@@ -7,6 +7,8 @@ import abc
 import time
 import typing as ta
 
+from .abstract import Abstract
+
 
 TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.DEFAULT'], ta.Iterable['TimeoutLike'], float, None]  # ta.TypeAlias
 
@@ -14,7 +16,7 @@ TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.DEFAULT'], ta.Iterable['Timeo
 ##
 
 
-class Timeout(abc.ABC):
+class Timeout(Abstract):
     @property
     @abc.abstractmethod
     def can_expire(self) -> bool:

omlish/lite/wrappers.py

@@ -0,0 +1,23 @@
+# ruff: noqa: UP006
+import functools
+import typing as ta
+
+
+##
+
+
+_ANNOTATION_ATTRS: ta.FrozenSet[str] = frozenset([
+    '__annotations__',
+
+    '__annotate__',
+    '__annotate_func__',
+
+    '__annotations_cache__',
+])
+
+_UPDATE_WRAPPER_ASSIGNMENTS_NO_ANNOTATIONS: ta.Sequence[str] = list(frozenset(functools.WRAPPER_ASSIGNMENTS) - _ANNOTATION_ATTRS)  # noqa
+
+
+def update_wrapper_no_annotations(wrapper, wrapped):
+    functools.update_wrapper(wrapper, wrapped, assigned=_UPDATE_WRAPPER_ASSIGNMENTS_NO_ANNOTATIONS)
+    return wrapper

omlish/logs/abc.py

@@ -1,6 +1,4 @@
-# ruff: noqa: A002
-# ruff: noqa: N802
-# ruff: noqa: N815
+# ruff: noqa: A002 N802 N815
 import types
 import typing as ta
 
@@ -94,6 +92,8 @@ class LogRecord:
 
 
 class Formatter(ta.Protocol):
+    """https://docs.python.org/3/library/logging.html#formatter-objects"""
+
     default_time_format: ta.ClassVar[str]
     default_msec_format: ta.ClassVar[str]
 
@@ -111,6 +111,8 @@ class Formatter(ta.Protocol):
 
 
 class BufferingFormatter(ta.Protocol):
+    """https://docs.python.org/3/library/logging.html#logging.BufferingFormatter"""
+
     def formatHeader(self, records: ta.Sequence[LogRecord]) -> str: ...
 
     def formatFooter(self, records: ta.Sequence[LogRecord]) -> str: ...
@@ -122,10 +124,14 @@ class BufferingFormatter(ta.Protocol):
 
 
 class Filter(ta.Protocol):
+    """https://docs.python.org/3/library/logging.html#filter-objects"""
+
     def filter(self, record: LogRecord) -> bool: ...
 
 
 class Filterer(ta.Protocol):
+    """A base class for loggers and handlers which allows them to share common code."""
+
     def addFilter(self, filter: Filter) -> None: ...
 
     def removeFilter(self, filter: Filter) -> None: ...
@@ -136,7 +142,9 @@ class Filterer(ta.Protocol):
 ##
 
 
-class Handler(ta.Protocol):
+class Handler(Filterer, ta.Protocol):
+    """https://docs.python.org/3/library/logging.html#handler-objects"""
+
     level: Level
 
     def get_name(self) -> str: ...
@@ -176,7 +184,9 @@ class Stream(ta.Protocol):
     def close(self) -> None: ...  # OPTIONAL METHOD
 
 
-class StreamHandler(Handler):
+class StreamHandler(Handler, ta.Protocol):
+    """https://docs.python.org/3/library/logging.handlers.html#logging.StreamHandler"""
+
     terminator: ta.ClassVar[str]
 
     stream: Stream
@@ -192,6 +202,8 @@ class StreamHandler(Handler):
 
 
 class Manager(ta.Protocol):
+    """There is [under normal circumstances] just one Manager instance, which holds the hierarchy of loggers."""
+
     root: 'Logger'
 
     disable: Level
@@ -215,6 +227,8 @@ Caller: ta.TypeAlias = tuple[
 
 
 class Logger(Filterer, ta.Protocol):
+    """https://docs.python.org/3/library/logging.html#logger-objects"""
+
     name: str
     level: Level
     parent: ta.Optional['Logger']
@@ -274,6 +288,8 @@ class Logger(Filterer, ta.Protocol):
 
 
 class LoggerAdapter(ta.Protocol):
+    """https://docs.python.org/3/library/logging.html#loggeradapter-objects"""
+
     logger: Logger
     extra: ta.Mapping[str, ta.Any]
 

omlish/logs/all.py

@@ -25,16 +25,27 @@ with _lang.auto_proxy_init(globals()):
         JsonLogFormatter,
     )
 
+    from .levels import (  # noqa
+        LogLevel,
+    )
+
     from .noisy import (  # noqa
         silence_noisy_loggers,
     )
 
     from .protocol import (  # noqa
-        LogLevel,
-
+        AnyLogging,
         Logging,
-        NopLogging,
+        AsyncLogging,
+
+        AnyAbstractLogging,
         AbstractLogging,
+        AbstractAsyncLogging,
+
+        AnyNopLogging,
+        NopLogging,
+        NopAsyncLogging,
+
         StdlibLogging,
     )
 

omlish/logs/callers.py

@@ -1,6 +1,7 @@
 # ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
 import io
+import os.path
 import sys
 import traceback
 import types
@@ -16,18 +17,36 @@ class LoggingCaller(ta.NamedTuple):
     func: str
     sinfo: ta.Optional[str]
 
+    @classmethod
+    def is_internal_frame(cls, frame: types.FrameType) -> bool:
+        filename = os.path.normcase(frame.f_code.co_filename)
+
+        # https://github.com/python/cpython/commit/5ca6d7469be53960843df39bb900e9c3359f127f
+        if 'importlib' in filename and '_bootstrap' in filename:
+            return True
+
+        return False
+
     @classmethod
     def find_frame(cls, ofs: int = 0) -> types.FrameType:
-        f: ta.Any = sys._getframe(2 + ofs)  # noqa
-        while hasattr(f, 'f_code'):
+        f: ta.Optional[types.FrameType] = sys._getframe(2 + ofs)  # noqa
+
+        while f is not None and hasattr(f, 'f_code'):
             if f.f_code.co_filename != __file__:
                 return f
+
             f = f.f_back
+
         raise RuntimeError
 
     @classmethod
-    def find(cls, stack_info: bool = False) -> 'LoggingCaller':
-        f = cls.find_frame(1)
+    def find(
+            cls,
+            ofs: int = 0,
+            *,
+            stack_info: bool = False,
+    ) -> 'LoggingCaller':
+        f = cls.find_frame(ofs + 1)
         # TODO: ('(unknown file)', 0, '(unknown function)', None) ?
 
         sinfo = None

omlish/logs/configs.py

@@ -1,17 +1,20 @@
+# ruff: noqa: UP006 UP045
+# @omlish-lite
 """
 https://docs.python.org/3/howto/logging.html#configuring-logging
+https://docs.python.org/3/library/logging.config.html#logging-config-dictschema
 """
 import dataclasses as dc
 import typing as ta
 
 
-##
+FilterConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
+FormatterConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
+HandlerConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
+LoggerConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
 
 
-FilterConfig: ta.TypeAlias = dict[str, ta.Any]
-FormatterConfig: ta.TypeAlias = dict[str, ta.Any]
-HandlerConfig: ta.TypeAlias = dict[str, ta.Any]
-LoggerConfig: ta.TypeAlias = dict[str, ta.Any]
+##
 
 
 @dc.dataclass()
@@ -19,8 +22,8 @@ class DictConfig:
     version: int = 1
     incremental: bool = False
     disable_existing_loggers: bool = False
-    filters: dict[str, FilterConfig] = dc.field(default_factory=dict)
-    formatters: dict[str, FormatterConfig] = dc.field(default_factory=dict)
-    handlers: dict[str, HandlerConfig] = dc.field(default_factory=dict)
-    loggers: dict[str, LoggerConfig] = dc.field(default_factory=dict)
-    root: LoggerConfig | None = None
+    filters: ta.Dict[str, FilterConfig] = dc.field(default_factory=dict)
+    formatters: ta.Dict[str, FormatterConfig] = dc.field(default_factory=dict)
+    handlers: ta.Dict[str, HandlerConfig] = dc.field(default_factory=dict)
+    loggers: ta.Dict[str, LoggerConfig] = dc.field(default_factory=dict)
+    root: ta.Optional[LoggerConfig] = None

omlish/logs/levels.py

@@ -0,0 +1,7 @@
+# @omlish-lite
+
+
+LogLevel = int  # ta.TypeAlias
+
+
+##

omlish/logs/protocol.py

@@ -6,49 +6,50 @@ import sys
 import typing as ta
 
 from .callers import LoggingCaller
+from .levels import LogLevel
 
 
-LogLevel = int  # ta.TypeAlias
+T = ta.TypeVar('T')
+T_co = ta.TypeVar('T_co', covariant=True)
 
 
 ##
 
 
-class Logging(ta.Protocol):
-    def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
-        ...
+class AnyLogging(ta.Protocol[T_co]):
+    def isEnabledFor(self, level: LogLevel) -> bool: ...  # noqa
 
-    def getEffectiveLevel(self) -> LogLevel:  # noqa
-        ...
+    def getEffectiveLevel(self) -> LogLevel: ...  # noqa
 
     #
 
-    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
+
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
+
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
+
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
 
-    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs: ta.Any) -> T_co: ...
 
-    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
 
-    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
 
-    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs) -> None:
-        ...
 
-    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+class Logging(AnyLogging[None], ta.Protocol):
+    pass
 
-    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+
+class AsyncLogging(AnyLogging[ta.Awaitable[None]], ta.Protocol):
+    pass
 
 
 ##
 
 
-class AbstractLogging(abc.ABC):
+class AnyAbstractLogging(abc.ABC, ta.Generic[T]):
     @ta.final
     def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
         return self.is_enabled_for(level)
@@ -66,34 +67,44 @@ class AbstractLogging(abc.ABC):
 
     #
 
-    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        if self.is_enabled_for(logging.DEBUG):
-            self.log(logging.DEBUG, msg, args, **kwargs)
+    def debug(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
+        return self.log(logging.DEBUG, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
 
-    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        if self.is_enabled_for(logging.INFO):
-            self.log(logging.INFO, msg, args, **kwargs)
+    def info(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
+        return self.log(logging.INFO, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
 
-    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        if self.is_enabled_for(logging.WARNING):
-            self.log(logging.WARNING, msg, args, **kwargs)
+    def warning(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
+        return self.log(logging.WARNING, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
 
-    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        if self.is_enabled_for(logging.ERROR):
-            self.log(logging.ERROR, msg, args, **kwargs)
+    def error(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
+        return self.log(logging.ERROR, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
 
-    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs: ta.Any) -> None:
-        self.error(msg, *args, exc_info=exc_info, **kwargs)
+    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:  # noqa
+        return self.error(msg, *args, exc_info=exc_info, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)  # noqa
 
-    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        if self.is_enabled_for(logging.CRITICAL):
-            self.log(logging.CRITICAL, msg, args, **kwargs)
+    def critical(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
+        return self.log(logging.CRITICAL, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
 
-    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+    @abc.abstractmethod
+    def log(
+            self,
+            level: int,
+            msg: str,
+            *args: ta.Any,
+            exc_info: ta.Any = None,
+            extra: ta.Any = None,
+            stack_info: bool = False,
+            _logging_stack_offset: int = 0,
+    ) -> T:
+        raise NotImplementedError
+
+
+class AbstractLogging(AnyAbstractLogging[None], abc.ABC):
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> None:
         if not isinstance(level, int):
             raise TypeError('Level must be an integer.')
         if self.is_enabled_for(level):
-            self._log(level, msg, args, **kwargs)
+            self._log(level, msg, args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
 
     @abc.abstractmethod
     def _log(
@@ -105,21 +116,51 @@ class AbstractLogging(abc.ABC):
             exc_info: ta.Any = None,
             extra: ta.Any = None,
             stack_info: bool = False,
+            _logging_stack_offset: int = 0,
     ) -> None:
         raise NotImplementedError
 
 
+class AbstractAsyncLogging(AnyAbstractLogging[ta.Awaitable[None]], abc.ABC):
+    async def log(self, level: LogLevel, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> None:  # noqa
+        if not isinstance(level, int):
+            raise TypeError('Level must be an integer.')
+        if self.is_enabled_for(level):
+            await self._log(level, msg, args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
+
+    @abc.abstractmethod
+    def _log(
+            self,
+            level: int,
+            msg: str,
+            args: ta.Any,
+            *,
+            exc_info: ta.Any = None,
+            extra: ta.Any = None,
+            stack_info: bool = False,
+            _logging_stack_offset: int = 0,
+    ) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
 ##
 
 
-class NopLogging(AbstractLogging):
+class AnyNopLogging(AnyAbstractLogging[T], abc.ABC):
     def get_effective_level(self) -> LogLevel:
         return logging.CRITICAL + 1
 
+
+class NopLogging(AnyNopLogging[None], AbstractLogging):
     def _log(self, *args: ta.Any, **kwargs: ta.Any) -> None:
         pass
 
 
+class NopAsyncLogging(AnyNopLogging[ta.Awaitable[None]], AbstractAsyncLogging):
+    async def _log(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        pass
+
+
 ##
 
 
@@ -151,8 +192,9 @@ class StdlibLogging(AbstractLogging):
             exc_info: ta.Any = None,
             extra: ta.Any = None,
             stack_info: bool = False,
+            _logging_stack_offset: int = 0,
     ) -> None:
-        caller = LoggingCaller.find(stack_info)
+        caller = LoggingCaller.find(_logging_stack_offset, stack_info=stack_info)
 
         if exc_info:
             if isinstance(exc_info, BaseException):