omlish 0.0.0.dev419__py3-none-any.whl → 0.0.0.dev421__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

@@ -1,50 +1,68 @@
-from .callers import (  # noqa
-    LoggingCaller,
-)
+# rufF: noqa: I001
+from .. import lang as _lang
 
-from .color import (  # noqa
-    ColorLogFormatter,
-)
 
-from .filters import (  # noqa
-    TidLogFilter,
-)
+with _lang.auto_proxy_init(globals()):
+    ##
 
-from .handlers import (  # noqa
-    ListHandler,
-)
+    from .callers import (  # noqa
+        LoggingCaller,
+    )
 
-from .json import (  # noqa
-    JsonLogFormatter,
-)
+    from .color import (  # noqa
+        ColorLogFormatter,
+    )
 
-from .noisy import (  # noqa
-    silence_noisy_loggers,
-)
+    from .filters import (  # noqa
+        TidLogFilter,
+    )
 
-from .protocol import (  # noqa
-    LogLevel,
+    from .handlers import (  # noqa
+        ListHandler,
+    )
 
-    Logging,
-    NopLogging,
-    AbstractLogging,
-    StdlibLogging,
-)
+    from .json import (  # noqa
+        JsonLogFormatter,
+    )
 
-from .proxy import (  # noqa
-    ProxyLogFilterer,
-    ProxyLogHandler,
-)
+    from .levels import (  # noqa
+        LogLevel,
+    )
 
-from .standard import (  # noqa
-    STANDARD_LOG_FORMAT_PARTS,
-    StandardLogFormatter,
+    from .noisy import (  # noqa
+        silence_noisy_loggers,
+    )
 
-    StandardConfiguredLogHandler,
+    from .protocol import (  # noqa
+        AnyLogging,
+        Logging,
+        AsyncLogging,
 
-    configure_standard_logging,
-)
+        AnyAbstractLogging,
+        AbstractLogging,
+        AbstractAsyncLogging,
 
-from .utils import (  # noqa
-    error_logging,
-)
+        AnyNopLogging,
+        NopLogging,
+        NopAsyncLogging,
+
+        StdlibLogging,
+    )
+
+    from .proxy import (  # noqa
+        ProxyLogFilterer,
+        ProxyLogHandler,
+    )
+
+    from .standard import (  # noqa
+        STANDARD_LOG_FORMAT_PARTS,
+        StandardLogFormatter,
+
+        StandardConfiguredLogHandler,
+
+        configure_standard_logging,
+    )
+
+    from .utils import (  # noqa
+        error_logging,
+    )

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,4 @@
+# @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) -> None:
-        ...
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
 
-    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
 
-    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+    def error(self, 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 exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs: ta.Any) -> T_co: ...
 
-    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
 
-    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
-        ...
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
+
+
+class Logging(AnyLogging[None], ta.Protocol):
+    pass
+
+
+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,29 +67,38 @@ 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, **kwargs: ta.Any) -> T:
+        return self.log(logging.DEBUG, msg, *args, **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, **kwargs: ta.Any) -> T:
+        return self.log(logging.INFO, msg, *args, **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, **kwargs: ta.Any) -> T:
+        return self.log(logging.WARNING, msg, *args, **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, **kwargs: ta.Any) -> T:
+        return self.log(logging.ERROR, msg, *args, **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, **kwargs: ta.Any) -> T:
+        return self.error(msg, *args, exc_info=exc_info, **kwargs)
 
-    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, **kwargs: ta.Any) -> T:
+        return self.log(logging.CRITICAL, msg, *args, **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,
+    ) -> T:
+        raise NotImplementedError
+
+
+class AbstractLogging(AnyAbstractLogging[None], abc.ABC):
     def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
         if not isinstance(level, int):
             raise TypeError('Level must be an integer.')
@@ -109,17 +119,45 @@ class AbstractLogging(abc.ABC):
         raise NotImplementedError
 
 
+class AbstractAsyncLogging(AnyAbstractLogging[ta.Awaitable[None]], abc.ABC):
+    async def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+        if not isinstance(level, int):
+            raise TypeError('Level must be an integer.')
+        if self.is_enabled_for(level):
+            await self._log(level, msg, args, **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,
+    ) -> 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
+
+
 ##
 
 

omlish/marshal/__init__.py

@@ -9,6 +9,7 @@ TODO:
   - can't disambiguate from str - can't coexist in bare union
  - factories being free MatchFns does more harm than good - in practice these are such big guns you want to write a
    class body if only ceremonially
+ - simple lite interop like inj - alt ObjMarshalerManager impl for Context
 
 See:
  - https://github.com/python-attrs/cattrs

omlish/os/atomics.py

@@ -6,6 +6,7 @@ import shutil
 import tempfile
 import typing as ta
 
+from ..lite.abstract import Abstract
 from ..lite.check import check
 from ..lite.strings import attr_repr
 
@@ -17,7 +18,7 @@ AtomicPathSwapState = ta.Literal['open', 'committed', 'aborted']  # ta.TypeAlias
 ##
 
 
-class AtomicPathSwap(abc.ABC):
+class AtomicPathSwap(Abstract):
     def __init__(
             self,
             kind: AtomicPathSwapKind,
@@ -105,7 +106,7 @@ class AtomicPathSwap(abc.ABC):
             self.abort()
 
 
-class AtomicPathSwapping(abc.ABC):
+class AtomicPathSwapping(Abstract):
     @abc.abstractmethod
     def begin_atomic_path_swap(
             self,

omlish/os/deathpacts/base.py

@@ -5,11 +5,13 @@ import sys
 import time
 import typing as ta
 
+from ... import lang
+
 
 ##
 
 
-class Deathpact(abc.ABC):
+class Deathpact(lang.Abstract):
     @abc.abstractmethod
     def poll(self) -> None:
         raise NotImplementedError
@@ -23,7 +25,7 @@ class NopDeathpact(Deathpact):
 ##
 
 
-class BaseDeathpact(Deathpact, abc.ABC):
+class BaseDeathpact(Deathpact, lang.Abstract):
     def __init__(
             self,
             *,

omlish/os/forkhooks.py

@@ -1,10 +1,10 @@
 # ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
-import abc
 import os
 import threading
 import typing as ta
 
+from ..lite.abstract import Abstract
 from ..lite.check import check
 
 
@@ -145,7 +145,7 @@ class _ForkHookManager:
 #
 
 
-class ForkHook(abc.ABC):  # noqa
+class ForkHook(Abstract):
     @ta.final
     def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError

omlish/os/pidfiles/pinning.py

@@ -27,6 +27,7 @@ import typing as ta
 
 from ...diag.lslocks import LslocksCommand
 from ...diag.lsof import LsofCommand
+from ...lite.abstract import Abstract
 from ...lite.check import check
 from ...lite.timeouts import Timeout
 from ...lite.timeouts import TimeoutLike
@@ -37,7 +38,7 @@ from .pidfile import Pidfile
 ##
 
 
-class PidfilePinner(abc.ABC):
+class PidfilePinner(Abstract):
     def __init__(
             self,
             *,

omlish/reflect/types.py

@@ -16,12 +16,13 @@ TODO:
  - cache this shit, esp generic_mro shit
   - cache __hash__ in Generic/Union
 """
-import abc
 import dataclasses as dc
 import threading
 import types
 import typing as ta
 
+from ..lite.abstract import Abstract
+
 
 _NoneType = types.NoneType  # type: ignore
 
@@ -275,7 +276,7 @@ def get_type_var_bound(obj: ta.Any) -> ta.Any:
 ##
 
 
-class TypeInfo(abc.ABC):  # noqa
+class TypeInfo(Abstract):
     pass
 
 
@@ -320,7 +321,7 @@ GenericLikeCls = ta.TypeVar('GenericLikeCls')
 
 
 @dc.dataclass(frozen=True)
-class GenericLike(TypeInfo, abc.ABC, ta.Generic[GenericLikeCls]):
+class GenericLike(TypeInfo, Abstract, ta.Generic[GenericLikeCls]):
     cls: GenericLikeCls
 
     # args and params are the same length - params maps to the generic origin's params:

omlish/secrets/crypto.py

@@ -58,7 +58,7 @@ class DecryptionError(Exception):
     pass
 
 
-class Crypto(abc.ABC):
+class Crypto(lang.Abstract):
     @abc.abstractmethod
     def generate_key(self) -> bytes:
         raise NotImplementedError

omlish/sockets/bind.py

@@ -15,6 +15,7 @@ import socket as socket_
 import stat
 import typing as ta
 
+from ..lite.abstract import Abstract
 from ..lite.check import check
 from ..lite.dataclasses import dataclass_maybe_post_init
 from .addresses import SocketAddress
@@ -31,7 +32,7 @@ CanSocketBinder = ta.Union['SocketBinder', CanSocketBinderConfig]  # ta.TypeAlia
 ##
 
 
-class SocketBinder(abc.ABC, ta.Generic[SocketBinderConfigT]):
+class SocketBinder(Abstract, ta.Generic[SocketBinderConfigT]):
     @dc.dataclass(frozen=True)
     class Config:
         listen_backlog: int = 5

omlish/sockets/handlers.py

@@ -3,8 +3,9 @@
 import abc
 import typing as ta
 
+from ..lite.abstract import Abstract
 from .addresses import SocketAddress
-from .io import SocketIoPair  # noqa
+from .io import SocketIoPair
 
 
 SocketHandler = ta.Callable[[SocketAddress, 'SocketIoPair'], None]  # ta.TypeAlias
@@ -13,7 +14,7 @@ SocketHandler = ta.Callable[[SocketAddress, 'SocketIoPair'], None]  # ta.TypeAli
 ##
 
 
-class SocketHandler_(abc.ABC):  # noqa
+class SocketHandler_(Abstract):  # noqa
     @abc.abstractmethod
     def __call__(self, addr: SocketAddress, f: SocketIoPair) -> None:
         raise NotImplementedError

omlish/sockets/server/handlers.py

@@ -7,6 +7,7 @@ import logging
 import socket
 import typing as ta
 
+from ...lite.abstract import Abstract
 from ..addresses import SocketAndAddress
 from ..handlers import SocketHandler
 from ..io import SocketIoPair
@@ -19,7 +20,7 @@ SocketServerHandler = ta.Callable[['SocketAndAddress'], None]  # ta.TypeAlias
 ##
 
 
-class SocketServerHandler_(abc.ABC):  # noqa
+class SocketServerHandler_(Abstract):  # noqa
     @abc.abstractmethod
     def __call__(self, conn: SocketAndAddress) -> None:
         raise NotImplementedError