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

omlish/funcs/pairs.py

@@ -1,5 +1,4 @@
 import abc
-import dataclasses as dc
 import typing as ta
 
 from .. import lang
@@ -19,7 +18,7 @@ T = ta.TypeVar('T')
 U = ta.TypeVar('U')
 
 
-class FnPair(abc.ABC, ta.Generic[F, T]):
+class FnPair(lang.Abstract, ta.Generic[F, T]):
     @abc.abstractmethod
     def forward(self, f: F) -> T:
         raise NotImplementedError
@@ -35,7 +34,7 @@ class FnPair(abc.ABC, ta.Generic[F, T]):
 
     def invert(self) -> 'FnPair[T, F]':
         if isinstance(self, Inverted):
-            return self.fp
+            return self._fp
         return Inverted(self)
 
     def compose(self, nxt: 'FnPair[T, U]') -> 'FnPair[F, U]':
@@ -45,11 +44,22 @@ class FnPair(abc.ABC, ta.Generic[F, T]):
 ##
 
 
-@lang.unabstract_class(['forward', 'backward'])
-@dc.dataclass(frozen=True)
 class Simple(FnPair[F, T]):
-    forward: ta.Callable[[F], T]  # type: ignore
-    backward: ta.Callable[[T], F]  # type: ignore
+    def __init__(
+            self,
+            forward: ta.Callable[[F], T],
+            backward: ta.Callable[[T], F],
+    ) -> None:
+        super().__init__()
+
+        self._forward = self.forward = forward  # type: ignore
+        self._backward = self.backward = backward  # type: ignore
+
+    def forward(self, f: F) -> T:
+        return self._forward(f)
+
+    def backward(self, t: T) -> F:
+        return self._backward(t)
 
 
 of = Simple
@@ -60,31 +70,35 @@ NOP: FnPair[ta.Any, ta.Any] = of(lang.identity, lang.identity)
 ##
 
 
-@dc.dataclass(frozen=True)
 class Inverted(FnPair[F, T]):
-    fp: FnPair[T, F]
+    def __init__(self, fp: FnPair[T, F]) -> None:
+        super().__init__()
+
+        self._fp = fp
 
     def forward(self, f: F) -> T:
-        return self.fp.backward(f)
+        return self._fp.backward(f)
 
     def backward(self, t: T) -> F:
-        return self.fp.forward(t)
+        return self._fp.forward(t)
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
 class Composite(FnPair[F, T]):
-    children: ta.Sequence[FnPair]
+    def __init__(self, children: ta.Sequence[FnPair]) -> None:
+        super().__init__()
+
+        self._children = children
 
     def forward(self, f: F) -> T:
-        for c in self.children:
+        for c in self._children:
             f = c.forward(f)
         return ta.cast(T, f)
 
     def backward(self, t: T) -> F:
-        for c in reversed(self.children):
+        for c in reversed(self._children):
             t = c.backward(t)
         return ta.cast(F, t)
 
@@ -162,15 +176,17 @@ def compose(*ps):
 ##
 
 
-@dc.dataclass(frozen=True)
 class Optional(FnPair[F | None, T | None]):
-    fp: FnPair[F, T]
+    def __init__(self, fp: FnPair[F, T]) -> None:
+        super().__init__()
+
+        self._fp = fp
 
     def forward(self, f: F | None) -> T | None:
-        return None if f is None else self.fp.forward(f)
+        return None if f is None else self._fp.forward(f)
 
     def backward(self, t: T | None) -> F | None:
-        return None if t is None else self.fp.backward(t)
+        return None if t is None else self._fp.backward(t)
 
 
 class Lines(FnPair[ta.Sequence[str], str]):
@@ -184,15 +200,17 @@ class Lines(FnPair[ta.Sequence[str], str]):
 ##
 
 
-@dc.dataclass(frozen=True)
 class Struct(FnPair[tuple, bytes]):
-    fmt: str
+    def __init__(self, fmt: str) -> None:
+        super().__init__()
+
+        self._fmt = fmt
 
     def forward(self, f: tuple) -> bytes:
-        return _struct.pack(self.fmt, *f)
+        return _struct.pack(self._fmt, *f)
 
     def backward(self, t: bytes) -> tuple:
-        return _struct.unpack(self.fmt, t)
+        return _struct.unpack(self._fmt, t)
 
 
 ##

omlish/funcs/pipes.py

@@ -1,6 +1,8 @@
 import abc
 import typing as ta
 
+from .. import lang
+
 
 T = ta.TypeVar('T')
 U = ta.TypeVar('U')
@@ -9,7 +11,7 @@ U = ta.TypeVar('U')
 ##
 
 
-class Fn(abc.ABC, ta.Generic[T]):
+class Fn(lang.Abstract, ta.Generic[T]):
     @abc.abstractmethod
     def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
         raise NotImplementedError

omlish/http/asgi.py

@@ -4,6 +4,7 @@ import typing as ta
 import urllib.parse
 
 from .. import check
+from .. import lang
 from . import consts
 
 
@@ -21,7 +22,7 @@ App: ta.TypeAlias = ta.Callable[[Scope, Recv, Send], ta.Awaitable[None]]
 Wrapper: ta.TypeAlias = ta.Callable[[App, Scope, Recv, Send], ta.Awaitable[None]]
 
 
-class App_(abc.ABC):  # noqa
+class App_(lang.Abstract):  # noqa
     @abc.abstractmethod
     async def __call__(self, scope: Scope, recv: Recv, send: Send) -> None:
         raise NotImplementedError

omlish/http/coro/client/io.py

@@ -1,9 +1,10 @@
 # @omlish-lite
 # ruff: noqa: UP006 UP007 UP043 UP045
-import abc
 import dataclasses as dc
 import typing as ta
 
+from ....lite.abstract import Abstract
+
 
 ##
 
@@ -13,7 +14,7 @@ class CoroHttpClientIo:
 
     #
 
-    class Io(abc.ABC):  # noqa
+    class Io(Abstract):
         pass
 
     #

omlish/http/coro/server/server.py

@@ -52,7 +52,6 @@ curl -v -XPOST localhost:8000 -d 'foo' --next -XFOO localhost:8000 -d 'bar'
 curl -v -XFOO localhost:8000 -d 'foo' --next -XPOST localhost:8000 -d 'bar'
 curl -v -XFOO localhost:8000 -d 'foo' --next -XFOO localhost:8000 -d 'bar'
 """
-import abc
 import dataclasses as dc
 import email.utils
 import html
@@ -62,6 +61,7 @@ import textwrap
 import time
 import typing as ta
 
+from ....lite.abstract import Abstract
 from ....lite.check import check
 from ....sockets.addresses import SocketAddress
 from ...handlers import HttpHandler
@@ -380,7 +380,7 @@ class CoroHttpServer:
 
     #
 
-    class Io(abc.ABC):  # noqa
+    class Io(Abstract):
         pass
 
     #

omlish/http/handlers.py

@@ -6,6 +6,7 @@ import http.server
 import logging
 import typing as ta
 
+from ..lite.abstract import Abstract
 from ..sockets.addresses import SocketAddress
 from .parsing import HttpHeaders
 
@@ -57,7 +58,7 @@ class UnsupportedMethodHttpHandlerError(Exception):
     pass
 
 
-class HttpHandler_(abc.ABC):  # noqa
+class HttpHandler_(Abstract):  # noqa
     @abc.abstractmethod
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
         raise NotImplementedError

omlish/http/jwt.py

@@ -34,7 +34,7 @@ def base64url_encode(b: bytes) -> bytes:
 ##
 
 
-class Algorithm(abc.ABC):
+class Algorithm(lang.Abstract):
     @property
     @abc.abstractmethod
     def name(self) -> str:

omlish/http/parsing.py

@@ -35,12 +35,12 @@
 #
 # 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
 # License Agreement.
-import abc
 import http.client
 import http.server
 import io
 import typing as ta
 
+from ..lite.abstract import Abstract
 from .versions import HttpProtocolVersion
 from .versions import HttpProtocolVersions
 
@@ -54,7 +54,7 @@ HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
 ##
 
 
-class ParseHttpRequestResult(abc.ABC):  # noqa
+class ParseHttpRequestResult(Abstract):
     __slots__ = (
         'server_version',
         'request_line',

omlish/io/compress/base.py

@@ -1,5 +1,6 @@
 import abc
 
+from ... import lang
 from ..coro import BytesSteppedCoro
 from ..coro import BytesSteppedReaderCoro
 
@@ -7,7 +8,7 @@ from ..coro import BytesSteppedReaderCoro
 ##
 
 
-class Compression(abc.ABC):
+class Compression(lang.Abstract):
     @abc.abstractmethod
     def compress(self, d: bytes) -> bytes:
         raise NotImplementedError
@@ -17,7 +18,7 @@ class Compression(abc.ABC):
         raise NotImplementedError
 
 
-class IncrementalCompression(abc.ABC):
+class IncrementalCompression(lang.Abstract):
     @abc.abstractmethod
     def compress_incremental(self) -> BytesSteppedCoro[None]:
         raise NotImplementedError

omlish/io/coro/readers.py

@@ -8,6 +8,7 @@ import abc
 import typing as ta
 
 from ... import check
+from ... import lang
 from .consts import DEFAULT_BUFFER_SIZE
 
 
@@ -50,7 +51,7 @@ class _StrJoiner:
 ##
 
 
-class CoroReader(abc.ABC, ta.Generic[T]):
+class CoroReader(lang.Abstract, ta.Generic[T]):
     @abc.abstractmethod
     def read(self, sz: int | None) -> ReaderCoro[T, T]:
         raise NotImplementedError
@@ -65,7 +66,7 @@ class CoroReader(abc.ABC, ta.Generic[T]):
 ##
 
 
-class PrependableCoroReader(CoroReader[AnyT]):
+class PrependableCoroReader(CoroReader[AnyT], lang.Abstract):
     def __init__(self) -> None:
         super().__init__()
 
@@ -133,7 +134,7 @@ prependable_str_coro_reader = PrependableStrCoroReader
 ##
 
 
-class BufferedCoroReader(PrependableCoroReader[AnyT], abc.ABC):
+class BufferedCoroReader(PrependableCoroReader[AnyT], lang.Abstract):
     def __init__(
             self,
             buffer_size: int = DEFAULT_BUFFER_SIZE,

omlish/io/fdio/handlers.py

@@ -3,6 +3,7 @@ import abc
 import socket
 import typing as ta
 
+from ...lite.abstract import Abstract
 from ...lite.check import check
 from ...sockets.addresses import SocketAddress
 
@@ -10,7 +11,7 @@ from ...sockets.addresses import SocketAddress
 ##
 
 
-class FdioHandler(abc.ABC):
+class FdioHandler(Abstract):
     @abc.abstractmethod
     def fd(self) -> int:
         raise NotImplementedError
@@ -46,7 +47,7 @@ class FdioHandler(abc.ABC):
         pass
 
 
-class SocketFdioHandler(FdioHandler, abc.ABC):
+class SocketFdioHandler(FdioHandler, Abstract):
     def __init__(
             self,
             addr: SocketAddress,

omlish/io/fdio/pollers.py

@@ -5,11 +5,13 @@ import errno
 import select
 import typing as ta
 
+from ...lite.abstract import Abstract
+
 
 ##
 
 
-class FdioPoller(abc.ABC):
+class FdioPoller(Abstract):
     def __init__(self) -> None:
         super().__init__()
 

omlish/lang/__init__.py

@@ -68,14 +68,11 @@ with _auto_proxy_init(
     )
 
     from .classes.abstract import (  # noqa
-        Abstract,
-        AbstractTypeError,
-        get_abstract_methods,
+        get_abstracts,
         is_abstract,
         is_abstract_class,
         is_abstract_method,
         make_abstract,
-        unabstract_class,
     )
 
     from .classes.bindable import (  # noqa
@@ -295,7 +292,7 @@ with _auto_proxy_init(
         asrange,
         chunk,
         common_prefix_len,
-        exhaust,
+        consume,
         flatmap,
         flatten,
         ilen,
@@ -332,9 +329,6 @@ with _auto_proxy_init(
         arg_repr,
         can_weakref,
         deep_subclasses,
-        dir_dict,
-        mro_dict,
-        mro_owner_dict,
         new_type,
         opt_repr,
         super_meta,
@@ -437,6 +431,14 @@ with _auto_proxy_init(
 
     ##
 
+    from ..lite.abstract import (  # noqa
+        is_abstract_method,
+        update_abstracts,
+
+        AbstractTypeError,
+        Abstract,
+    )
+
     from ..lite.args import (  # noqa
         Args,
     )
@@ -479,6 +481,12 @@ with _auto_proxy_init(
         run_maysync,
     )
 
+    from ..lite.objects import (  # noqa
+        mro_dict,
+        mro_owner_dict,
+        dir_dict,
+    )
+
     from ..lite.reprs import (  # noqa
         AttrRepr,
         attr_repr,
@@ -504,3 +512,7 @@ with _auto_proxy_init(
 
         typing_annotations_attr,
     )
+
+    from ..lite.wrappers import (  # noqa
+        update_wrapper_no_annotations,
+    )

omlish/lang/attrs.py

@@ -3,6 +3,8 @@ import collections.abc
 import functools
 import typing as ta
 
+from ..lite.abstract import Abstract
+
 
 T = ta.TypeVar('T')
 
@@ -74,7 +76,7 @@ def set_attr(
 ##
 
 
-class AttrOps(abc.ABC):
+class AttrOps(Abstract):
     class NOT_SET:  # noqa
         def __new__(cls, *args, **kwargs):  # noqa
             raise TypeError

omlish/lang/casing.py

@@ -2,6 +2,8 @@ import abc
 import re
 import typing as ta
 
+from ..lite.abstract import Abstract
+
 
 ##
 
@@ -31,7 +33,7 @@ def _check_all_lowercase(*ps: str) -> None:
 ##
 
 
-class StringCasing(abc.ABC):
+class StringCasing(Abstract):
     @abc.abstractmethod
     def match(self, s: str) -> bool:
         raise NotImplementedError

omlish/lang/classes/abstract.py

@@ -1,6 +1,12 @@
 import abc
 import typing as ta
 
+from ...lite.abstract import _ABSTRACT_METHODS_ATTR  # noqa
+from ...lite.abstract import _FORCE_ABSTRACT_ATTR  # noqa
+from ...lite.abstract import _IS_ABSTRACT_METHOD_ATTR  # noqa
+from ...lite.abstract import Abstract
+from ...lite.abstract import is_abstract_method
+
 
 T = ta.TypeVar('T')
 
@@ -8,82 +14,20 @@ T = ta.TypeVar('T')
 ##
 
 
-_DISABLE_CHECKS = False
-
-_ABSTRACT_METHODS_ATTR = '__abstractmethods__'
-_IS_ABSTRACT_METHOD_ATTR = '__isabstractmethod__'
-_FORCE_ABSTRACT_ATTR = '__forceabstract__'
-
-_INTERNAL_ABSTRACT_ATTRS = frozenset([_FORCE_ABSTRACT_ATTR])
-
-
-def make_abstract(obj: T) -> T:
-    if callable(obj):
-        return abc.abstractmethod(obj)
-    elif isinstance(obj, property):
-        return ta.cast(T, property(
-            abc.abstractmethod(obj.fget) if obj.fget is not None else None,
-            abc.abstractmethod(obj.fset) if obj.fset is not None else None,
-            abc.abstractmethod(obj.fdel) if obj.fdel is not None else None,
-        ))
-    elif isinstance(obj, (classmethod, staticmethod)):
-        return ta.cast(T, type(obj)(abc.abstractmethod(obj.__func__)))
-    else:
-        return obj
-
-
-class AbstractTypeError(TypeError):
-    pass
-
-
-class Abstract(abc.ABC):  # noqa
-    __slots__ = ()
-
-    def __forceabstract__(self):
-        raise TypeError
-
-    setattr(__forceabstract__, _IS_ABSTRACT_METHOD_ATTR, True)
-
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        if Abstract in cls.__bases__:
-            setattr(cls, _FORCE_ABSTRACT_ATTR, getattr(Abstract, _FORCE_ABSTRACT_ATTR))
-        else:
-            setattr(cls, _FORCE_ABSTRACT_ATTR, False)
-
-        super().__init_subclass__(**kwargs)
-
-        if (
-                not _DISABLE_CHECKS and
-                Abstract not in cls.__bases__ and
-                abc.ABC not in cls.__bases__
-        ):
-            ams = {a for a, o in cls.__dict__.items() if is_abstract_method(o)}
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update(set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen)
-                seen.update(dir(b))
-            if ams:
-                raise AbstractTypeError(
-                    f'Cannot subclass abstract class {cls.__name__} with abstract methods: '
-                    f'{", ".join(map(str, sorted(ams)))}',
-                )
-
-
-def is_abstract_method(obj: ta.Any) -> bool:
-    return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
-
-
 def is_abstract_class(obj: ta.Any) -> bool:
     if bool(getattr(obj, _ABSTRACT_METHODS_ATTR, [])):
         return True
+
     if isinstance(obj, type):
         if Abstract in obj.__bases__:
             return True
+
         if (
                 Abstract in obj.__mro__
                 and getattr(obj.__dict__.get(_FORCE_ABSTRACT_ATTR, None), _IS_ABSTRACT_METHOD_ATTR, False)
         ):
             return True
+
     return False
 
 
@@ -91,40 +35,35 @@ def is_abstract(obj: ta.Any) -> bool:
     return is_abstract_method(obj) or is_abstract_class(obj)
 
 
-def get_abstract_methods(cls: type, *, include_internal: bool = False) -> frozenset[str]:
+##
+
+
+_INTERNAL_ABSTRACT_ATTRS = frozenset([_FORCE_ABSTRACT_ATTR])
+
+
+def get_abstracts(cls: type, *, include_internal: bool = False) -> frozenset[str]:
     ms = frozenset(getattr(cls, _ABSTRACT_METHODS_ATTR))
     if not include_internal:
         ms -= _INTERNAL_ABSTRACT_ATTRS
     return ms
 
 
-def unabstract_class(
-        members: ta.Iterable[str | tuple[str, ta.Any]],
-):  # -> ta.Callable[[type[T]], type[T]]:
-    def inner(cls):
-        if isinstance(members, str):
-            raise TypeError(members)
-
-        ams = getattr(cls, _ABSTRACT_METHODS_ATTR)
-
-        names: set[str] = set()
-        for m in members:
-            if isinstance(m, str):
-                if m not in ams:
-                    raise NameError(m)
-                getattr(cls, m)
-                names.add(m)
-
-            elif isinstance(m, tuple):
-                name, impl = m
-                if name not in ams:
-                    raise NameError(name)
-                if isinstance(impl, str):
-                    impl = getattr(cls, impl)
-                setattr(cls, name, impl)
-                names.add(name)
-
-        setattr(cls, _ABSTRACT_METHODS_ATTR, ams - names)
-        return cls
-
-    return inner
+##
+
+
+def make_abstract(obj: T) -> T:
+    if callable(obj):
+        return abc.abstractmethod(obj)
+
+    elif isinstance(obj, property):
+        return ta.cast(T, property(
+            abc.abstractmethod(obj.fget) if obj.fget is not None else None,
+            abc.abstractmethod(obj.fset) if obj.fset is not None else None,
+            abc.abstractmethod(obj.fdel) if obj.fdel is not None else None,
+        ))
+
+    elif isinstance(obj, (classmethod, staticmethod)):
+        return ta.cast(T, type(obj)(abc.abstractmethod(obj.__func__)))
+
+    else:
+        return obj

omlish/lang/classes/virtual.py

@@ -59,7 +59,7 @@ class _VirtualMeta(abc.ABCMeta):
             if get_missing_reqs(subclass):
                 return False
             if user_subclasshook is not None:
-                ret = user_subclasshook(cls, subclass)
+                ret = user_subclasshook(cls, subclass)  # noqa
             else:
                 ret = super(kls, cls).__subclasshook__(subclass)  # type: ignore
             return True if ret is NotImplemented else ret
@@ -113,7 +113,7 @@ class Picklable(Virtual):
 ##
 
 
-class Callable(NotInstantiable, Final, ta.Generic[T]):
+class Callable(NotInstantiable, Final, ta.Generic[T], metaclass=abc.ABCMeta):
     def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
         raise TypeError