omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/lite/dataclasses.py

@@ -100,6 +100,36 @@ def dataclass_repr_omit_falsey(obj: ta.Any) -> str:
 ##
 
 
+def dataclass_descriptor_method(*bind_attrs: str, bind_owner: bool = False) -> ta.Callable:
+    if not bind_attrs:
+        def __get__(self, instance, owner=None):  # noqa
+            return self
+
+    elif bind_owner:
+        def __get__(self, instance, owner=None):  # noqa
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    else:
+        def __get__(self, instance, owner=None):  # noqa
+            if instance is None:
+                return self
+
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    return __get__
+
+
+##
+
+
 def dataclass_kw_only_init():
     def inner(cls):
         if not isinstance(cls, type) and dc.is_dataclass(cls):
@@ -161,3 +191,17 @@ def dataclass_kw_only_init():
         return cls
 
     return inner
+
+
+##
+
+
+@dc.dataclass()
+class DataclassFieldRequiredError(Exception):
+    name: str
+
+
+def dataclass_field_required(name: str) -> ta.Callable[[], ta.Any]:
+    def inner() -> ta.NoReturn:
+        raise DataclassFieldRequiredError(name)
+    return inner

omlish/lite/maybes.py

@@ -1,6 +1,7 @@
 # ruff: noqa: UP007 UP045
 import abc
 import functools
+import operator
 import typing as ta
 
 from .abstract import Abstract
@@ -208,3 +209,10 @@ class _EmptyMaybe(_Maybe[T]):
 
 
 Maybe._empty = _EmptyMaybe()  # noqa
+
+
+##
+
+
+setattr(Maybe, 'just', _JustMaybe)  # noqa
+setattr(Maybe, 'empty', functools.partial(operator.attrgetter('_empty'), Maybe))

omlish/lite/maysync.py

@@ -25,6 +25,7 @@ Internally, it's not really correct to say that there is 'no event loop' in the
 ===
 
 TODO:
+ - ! impl iterators not just generators !
  - __del__
  - (test) maysync context managers
  - CancelledError
@@ -33,11 +34,6 @@ TODO:
   - works down to 3.8
  - make_maysync_from_sync can run with asyncio.run_in_thread
  - make_maysync_from_async can run with asyncio.run_soon
-
-TODO OVERHAUL:
- - no more sync/async context, just one Context, and it means sync
- - make FpMaywaitable *not reusable*
-  - `cannot reuse already awaited coroutine`
 """
 import abc
 import inspect

omlish/lite/pycharm.py

@@ -6,7 +6,7 @@ import typing as ta
 ##
 
 
-DEFAULT_PYCHARM_VERSION = '242.23726.102'
+DEFAULT_PYCHARM_VERSION = '252.26199.168'
 
 
 @dc.dataclass(frozen=True)

omlish/lite/typing.py

@@ -12,6 +12,12 @@ A2 = ta.TypeVar('A2')
 
 ##
 # A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+#
+# Note that this problem doesn't happen at runtime - it happens in mypy:
+#
+#   mypy <(echo "import typing as ta; MyCallback = ta.NewType('MyCallback', ta.Callable[[], None])")
+#   /dev/fd/11:1:22: error: Argument 2 to NewType(...) must be subclassable (got "Callable[[], None]")  [valid-newtype]
+#
 
 
 @dc.dataclass(frozen=True)
@@ -57,6 +63,24 @@ class Func3(ta.Generic[A0, A1, A2, T]):
 ##
 
 
+@dc.dataclass(frozen=True)
+class CachedFunc0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        try:
+            return object.__getattribute__(self, '_value')
+        except AttributeError:
+            pass
+
+        value = self.fn()
+        object.__setattr__(self, '_value', value)
+        return value
+
+
+##
+
+
 _TYPING_ANNOTATIONS_ATTR = '__annotate__' if sys.version_info >= (3, 14) else '__annotations__'
 
 

omlish/logs/_amalg.py

@@ -1,8 +1,8 @@
 # @omlish-lite
 # @omlish-amalg ../../omdev/scripts/lib/logs.py
 from .base import AnyLogger  # noqa
-from .standard import configure_standard_logging  # noqa
 from .std.loggers import StdLogger  # noqa
+from .std.standard import configure_standard_logging  # noqa
 
 
 ##

omlish/logs/all.py

@@ -38,6 +38,20 @@ with _lang.auto_proxy_init(globals()):
         LoggingContextLogRecord,
     )
 
+    from .std.standard import (  # noqa
+        STANDARD_LOG_FORMAT_PARTS,
+        StandardLoggingFormatter,
+
+        StandardConfiguredLoggingHandler,
+
+        configure_standard_logging,
+    )
+
+    from .asyncs import (  # noqa
+        AsyncLoggerToLogger,
+        LoggerToAsyncLogger,
+    )
+
     from .base import (  # noqa
         AnyLogger,
         Logger,
@@ -67,28 +81,28 @@ with _lang.auto_proxy_init(globals()):
         NamedLogLevel,
     )
 
+    from .lists import (  # noqa
+        AnyListLogger,
+        ListLogger,
+        AsyncLogger,
+    )
+
     from .modules import (  # noqa
         get_module_logger,
+        get_module_async_logger,
+        get_module_loggers,
     )
 
     from .protocols import (  # noqa
         LoggerLike,
     )
 
-    from .standard import (  # noqa
-        STANDARD_LOG_FORMAT_PARTS,
-        StandardLoggingFormatter,
-
-        StandardConfiguredLoggingHandler,
-
-        configure_standard_logging,
-    )
-
     from .utils import (  # noqa
+        exception_logging,
+        async_exception_logging,
+
         LogTimingContext,
         log_timing_context,
-
-        error_logging,
     )
 
     from .warnings import (  # noqa

omlish/logs/asyncs.py

@@ -0,0 +1,73 @@
+# ruff: noqa: UP006 UP007 UP045 UP046
+# @omlish-lite
+import typing as ta
+
+from ..lite.asyncs import sync_await
+from ..lite.check import check
+from .base import AsyncLogger
+from .base import CaptureLoggingContext
+from .base import Logger
+from .base import LoggingMsgFn
+from .contexts import CaptureLoggingContextImpl
+from .infos import LoggingContextInfos
+from .levels import LogLevel
+
+
+##
+
+
+class AsyncLoggerToLogger(Logger):
+    def __init__(self, u: AsyncLogger) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        # Nope out early to avoid sync_await if possible - don't bother in the LoggerToAsyncLogger.
+        if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
+            return
+
+        # Note: we hardcode the stack offset of sync_await (which is 2 - sync_await + sync_await.thunk). In non-lite
+        # code, lang.sync_await uses a cext if present to avoid being on the py stack, which would obviously complicate
+        # this, but this is lite code so we will always have the non-c version.
+        sync_await(
+            self._u._log(  # noqa
+                check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(3),
+                msg,
+                *args,
+                **kwargs,
+            ),
+        )
+
+
+class LoggerToAsyncLogger(AsyncLogger):
+    def __init__(self, u: Logger) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        return self._u._log(  # noqa
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )

omlish/logs/base.py

@@ -40,6 +40,11 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     ##
 
+    # This will be 1 for [Sync]Logger and 0 for AsyncLogger - in sync loggers these methods remain present on the stack,
+    # in async loggers they return a coroutine to be awaited and thus aren't actually present when said coroutine is
+    # awaited.
+    _level_proxy_method_stack_offset: ta.ClassVar[int]
+
     @ta.overload
     def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
         ...
@@ -54,7 +59,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def log(self, level: LogLevel, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(level, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                level,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -72,7 +84,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def debug(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.DEBUG, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.DEBUG,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -90,7 +109,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def info(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.INFO, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.INFO,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -108,7 +134,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def warning(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.WARNING, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.WARNING,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -126,7 +159,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def error(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.ERROR,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -144,7 +184,15 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def exception(self, *args, exc_info: LoggingExcInfoArg = True, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, exc_info=exc_info, stack_offset=1), *args, **kwargs)  # noqa
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.ERROR,
+                exc_info=exc_info,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -162,24 +210,53 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def critical(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.CRITICAL, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.CRITICAL,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     ##
 
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> T:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> T:
         raise NotImplementedError
 
 
 class Logger(AnyLogger[None], Abstract):
+    _level_proxy_method_stack_offset: ta.ClassVar[int] = 1
+
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         raise NotImplementedError
 
 
 class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
+    _level_proxy_method_stack_offset: ta.ClassVar[int] = 0
+
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Awaitable[None]:
         raise NotImplementedError
 
 
@@ -194,11 +271,23 @@ class AnyNopLogger(AnyLogger[T], Abstract):
 
 @ta.final
 class NopLogger(AnyNopLogger[None], Logger):
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         pass
 
 
 @ta.final
 class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
-    async def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         pass

omlish/logs/contexts.py

@@ -118,6 +118,9 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
                 self._infos[type(info)] = info
         return self
 
+    def get_infos(self) -> ta.Mapping[ta.Type[LoggingContextInfo], LoggingContextInfo]:
+        return self._infos
+
     def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
         return self._infos.get(ty)
 
@@ -140,7 +143,7 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
     _stack_offset: int
     _stack_info: bool
 
-    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContext':
+    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContextImpl':
         if hasattr(self, '_stack_offset'):
             self._stack_offset += ofs
         return self

omlish/logs/lists.py

@@ -0,0 +1,125 @@
+# ruff: noqa: N802 UP006 UP007 UP045
+# @omlish-lite
+import dataclasses as dc
+import typing as ta
+
+from ..lite.abstract import Abstract
+from ..lite.check import check
+from .base import AnyLogger
+from .base import AsyncLogger
+from .base import CaptureLoggingContext
+from .base import Logger
+from .base import LoggingMsgFn
+from .contexts import CaptureLoggingContextImpl
+from .infos import LoggingContextInfo
+from .infos import LoggingContextInfos
+from .levels import LogLevel
+from .levels import NamedLogLevel
+
+
+T = ta.TypeVar('T')
+
+LoggingContextInfoT = ta.TypeVar('LoggingContextInfoT', bound=LoggingContextInfo)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ListLoggerEntry:
+    infos: ta.Mapping[ta.Type[LoggingContextInfo], LoggingContextInfo]
+
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self.infos.get(ty)
+
+    @ta.final
+    def __getitem__(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self.get_info(ty)
+
+    def must_get_info(self, ty: ta.Type[LoggingContextInfoT]) -> LoggingContextInfoT:
+        return check.not_none(self.get_info(ty))
+
+
+class AnyListLogger(AnyLogger[T], Abstract):
+    def __init__(
+            self,
+            *,
+            name: ta.Optional[str] = None,
+            level: LogLevel = NamedLogLevel.NOTSET,
+    ) -> None:
+        super().__init__()
+
+        if name is None:
+            name = f'{type(self).__name__}@{id(self):x}'
+        self._name = name
+        self._level = level
+
+        self._entries: ta.List[ListLoggerEntry] = []
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def entries(self) -> ta.List[ListLoggerEntry]:
+        """Intentionally mutable."""
+
+        return self._entries
+
+    def set_level(self, level: LogLevel) -> None:
+        self._level = level
+
+    def get_effective_level(self) -> LogLevel:
+        return self._level
+
+    def _add_entry(
+            self,
+            ctx: CaptureLoggingContextImpl,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+    ) -> None:
+        if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
+            return
+
+        ctx.set_basic(
+            name=self._name,
+
+            msg=msg,
+            args=args,
+        )
+
+        ctx.capture()
+
+        self._entries.append(ListLoggerEntry(ctx.get_infos()))
+
+
+class ListLogger(AnyListLogger[None], Logger):
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        self._add_entry(
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )
+
+
+class ListAsyncLogger(AnyListLogger[ta.Awaitable[None]], AsyncLogger):
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        self._add_entry(
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )

omlish/logs/modules.py

@@ -1,7 +1,10 @@
+# ruff: noqa: UP006
 # @omlish-lite
 import logging
 import typing as ta
 
+from .asyncs import LoggerToAsyncLogger
+from .base import AsyncLogger
 from .base import Logger
 from .std.loggers import StdLogger
 
@@ -9,5 +12,20 @@ from .std.loggers import StdLogger
 ##
 
 
+def _get_module_std_logger(mod_globals: ta.Mapping[str, ta.Any]) -> logging.Logger:
+    return logging.getLogger(mod_globals.get('__name__'))
+
+
 def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> Logger:
-    return StdLogger(logging.getLogger(mod_globals.get('__name__')))  # noqa
+    return StdLogger(_get_module_std_logger(mod_globals))
+
+
+def get_module_async_logger(mod_globals: ta.Mapping[str, ta.Any]) -> AsyncLogger:
+    return LoggerToAsyncLogger(get_module_logger(mod_globals))
+
+
+def get_module_loggers(mod_globals: ta.Mapping[str, ta.Any]) -> ta.Tuple[Logger, AsyncLogger]:
+    return (
+        log := get_module_logger(mod_globals),
+        LoggerToAsyncLogger(log),
+    )

omlish/logs/std/loggers.py

@@ -30,7 +30,12 @@ class StdLogger(Logger):
     def get_effective_level(self) -> LogLevel:
         return self._std.getEffectiveLevel()
 
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> None:
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+    ) -> None:
         if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
             return
 

omlish/logs/std/noisy.py

@@ -4,16 +4,18 @@ import logging
 ##
 
 
-NOISY_LOGGERS: set[str] = {
-    'boto3.resources.action',
-    'datadog.dogstatsd',
-    'elasticsearch',
-    'httpx',
-    'kazoo.client',
-    'requests.packages.urllib3.connectionpool',
+NOISY_LOGGER_LEVELS: dict[str, int] = {
+    'boto3.resources.action': logging.WARNING,
+    'datadog.dogstatsd': logging.WARNING,
+    'elasticsearch': logging.WARNING,
+    'httpcore': logging.INFO,
+    'httpx': logging.WARNING,
+    'kazoo.client': logging.WARNING,
+    'markdown_it': logging.INFO,
+    'requests.packages.urllib3.connectionpool': logging.WARNING,
 }
 
 
 def silence_noisy_loggers() -> None:
-    for noisy_logger in NOISY_LOGGERS:
-        logging.getLogger(noisy_logger).setLevel(logging.WARNING)
+    for name, level in NOISY_LOGGER_LEVELS.items():
+        logging.getLogger(name).setLevel(level)