omlish 0.0.0.dev419__py3-none-any.whl → 0.0.0.dev421__py3-none-any.whl

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
 

omlish/lang/contextmanagers.py

@@ -13,6 +13,8 @@ import time
 import types
 import typing as ta
 
+from ..lite.abstract import Abstract
+
 
 T = ta.TypeVar('T')
 K = ta.TypeVar('K')
@@ -22,7 +24,7 @@ V = ta.TypeVar('V')
 ##
 
 
-class ContextManaged(abc.ABC):  # noqa
+class ContextManaged(Abstract):
     def __enter__(self):
         return None
 
@@ -56,7 +58,7 @@ NOP_CONTEXT_MANAGER = ValueContextManager(None)
 #
 
 
-class AsyncContextManaged(abc.ABC):  # noqa
+class AsyncContextManaged(Abstract):
     async def __aenter__(self):
         return None
 
@@ -90,7 +92,7 @@ NOP_ASYNC_CONTEXT_MANAGER = ValueAsyncContextManager(None)
 ##
 
 
-class ContextManager(abc.ABC, ta.Generic[T]):
+class ContextManager(Abstract, ta.Generic[T]):
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
@@ -122,7 +124,7 @@ class ContextManager(abc.ABC, ta.Generic[T]):
 #
 
 
-class AsyncContextManager(abc.ABC, ta.Generic[T]):
+class AsyncContextManager(Abstract, ta.Generic[T]):
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 

omlish/lang/generators.py

@@ -2,8 +2,8 @@ import abc
 import functools
 import typing as ta
 
+from ..lite.abstract import Abstract
 from ..lite.maybes import Maybe
-from .classes.restrict import Abstract
 
 
 T = ta.TypeVar('T')
@@ -45,7 +45,7 @@ class GeneratorLike(ta.Protocol[O_co, I_contra, R_co]):
         ...
 
 
-class GeneratorLike_(abc.ABC, ta.Generic[O, I, R]):  # noqa
+class GeneratorLike_(Abstract, ta.Generic[O, I, R]):  # noqa
     @abc.abstractmethod
     def send(self, i: I) -> O:  # Raises[StopIteration[R]]
         raise NotImplementedError

omlish/lang/iterables.py

@@ -1,4 +1,4 @@
-import dataclasses as dc
+import collections
 import functools
 import itertools
 import typing as ta
@@ -22,9 +22,8 @@ def take(n: int, it: ta.Iterable[T]) -> list[T]:
     return list(itertools.islice(it, n))
 
 
-def exhaust(it: ta.Iterable[ta.Any]) -> None:
-    for _ in it:
-        pass
+def consume(it: ta.Iterable[ta.Any]) -> None:
+    collections.deque(it, maxlen=0)
 
 
 def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
@@ -87,9 +86,10 @@ def readiter(f, sz):
 ##
 
 
-@dc.dataclass(frozen=True)
+@ta.final
 class IterGen(ta.Generic[T]):
-    fn: ta.Callable[[], ta.Iterable[T]]
+    def __init__(self, fn: ta.Callable[[], ta.Iterable[T]]) -> None:
+        self.fn = fn
 
     def __iter__(self):
         return iter(self.fn())

omlish/lang/objects.py

@@ -101,64 +101,6 @@ def deep_subclasses(
         todo.extend(reversed(cur.__subclasses__()))
 
 
-def mro_owner_dict(
-        instance_cls: type,
-        owner_cls: type | None = None,
-        *,
-        bottom_up_key_order: bool = False,
-        sort_keys: bool = False,
-) -> ta.Mapping[str, tuple[type, ta.Any]]:
-    if owner_cls is None:
-        owner_cls = instance_cls
-
-    mro = instance_cls.__mro__[-2::-1]
-    try:
-        pos = mro.index(owner_cls)
-    except ValueError:
-        raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}') from None
-
-    dct: dict[str, tuple[type, ta.Any]] = {}
-    if not bottom_up_key_order:
-        for cur_cls in mro[:pos + 1][::-1]:
-            for k, v in cur_cls.__dict__.items():
-                if k not in dct:
-                    dct[k] = (cur_cls, v)
-
-    else:
-        for cur_cls in mro[:pos + 1]:
-            dct.update({k: (cur_cls, v) for k, v in cur_cls.__dict__.items()})
-
-    if sort_keys:
-        dct = dict(sorted(dct.items(), key=lambda t: t[0]))
-
-    return dct
-
-
-def mro_dict(
-        instance_cls: type,
-        owner_cls: type | None = None,
-        *,
-        bottom_up_key_order: bool = False,
-        sort_keys: bool = False,
-) -> ta.Mapping[str, ta.Any]:
-    return {
-        k: v
-        for k, (o, v) in mro_owner_dict(
-            instance_cls,
-            owner_cls,
-            bottom_up_key_order=bottom_up_key_order,
-            sort_keys=sort_keys,
-        ).items()
-    }
-
-
-def dir_dict(o: ta.Any) -> dict[str, ta.Any]:
-    return {
-        a: getattr(o, a)
-        for a in dir(o)
-    }
-
-
 ##
 
 

omlish/lang/outcomes.py

@@ -22,6 +22,8 @@ import abc
 import dataclasses as dc
 import typing as ta
 
+from ..lite.abstract import Abstract
+
 
 T = ta.TypeVar('T')
 ValueT_co = ta.TypeVar('ValueT_co', covariant=True)
@@ -131,7 +133,7 @@ async def acapture(
 
 
 @dc.dataclass(repr=False, init=False, slots=True, frozen=True, order=True)
-class Outcome(abc.ABC, ta.Generic[ValueT_co]):
+class Outcome(Abstract, ta.Generic[ValueT_co]):
     """
     An abstract class representing the result of a Python computation.
 

omlish/lang/typing.py

@@ -5,10 +5,11 @@ TODO:
   - probably need to gen types per inst
  - typed_factory
 """
-import functools
 import inspect
 import typing as ta
 
+from ..lite.wrappers import update_wrapper_no_annotations
+
 
 Ty = ta.TypeVar('Ty', bound=type)
 
@@ -59,26 +60,6 @@ def protocol_check(proto: type) -> ta.Callable[[Ty], Ty]:
 ##
 
 
-_ANN_ATTRS: frozenset[str] = frozenset([
-    '__annotations__',
-
-    '__annotate__',
-    '__annotate_func__',
-
-    '__annotations_cache__',
-])
-
-_UPDATE_WRAPPER_ASSIGNED_NO_ANNS = list(frozenset(functools.WRAPPER_ASSIGNMENTS) - _ANN_ATTRS)
-
-
-def _update_wrapper_no_anns(wrapper, wrapped):
-    functools.update_wrapper(wrapper, wrapped, assigned=_UPDATE_WRAPPER_ASSIGNED_NO_ANNS)
-    return wrapper
-
-
-##
-
-
 _MISSING = object()
 
 
@@ -113,7 +94,7 @@ def typed_lambda(ret=_MISSING, **kw):  # noqa
         src = f'{"".join(proto)} {"".join(call)}'
         exec(src, ns)
 
-        lam = _update_wrapper_no_anns(ns['__lam'], fn)
+        lam = update_wrapper_no_annotations(ns['__lam'], fn)
         lam.__signature__ = inspect.signature(lam, follow_wrapped=False)
         return lam
 
@@ -131,7 +112,7 @@ def typed_partial(obj, **kw):  # noqa
 
     sig = inspect.signature(obj)
 
-    inner = _update_wrapper_no_anns(lambda **lkw: obj(**lkw, **kw), obj)
+    inner = update_wrapper_no_annotations(lambda **lkw: obj(**lkw, **kw), obj)
 
     ret = (
         obj if isinstance(obj, type) else
@@ -149,7 +130,7 @@ def typed_partial(obj, **kw):  # noqa
         },
     )(inner)
 
-    return _update_wrapper_no_anns(lam, obj)
+    return update_wrapper_no_annotations(lam, obj)
 
 
 ##

omlish/lite/abstract.py

@@ -0,0 +1,119 @@
+# ruff: noqa: UP006
+import abc
+import typing as ta
+
+
+##
+
+
+_ABSTRACT_METHODS_ATTR = '__abstractmethods__'
+_IS_ABSTRACT_METHOD_ATTR = '__isabstractmethod__'
+
+
+def is_abstract_method(obj: ta.Any) -> bool:
+    return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
+
+
+def update_abstracts(cls, *, force=False):
+    if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
+        # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
+        # implementation (especially during testing), and we want to handle both cases.
+        return cls
+
+    abstracts: ta.Set[str] = set()
+
+    for scls in cls.__bases__:
+        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
+            value = getattr(cls, name, None)
+            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
+                abstracts.add(name)
+
+    for name, value in cls.__dict__.items():
+        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
+            abstracts.add(name)
+
+    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    return cls
+
+
+#
+
+
+class AbstractTypeError(TypeError):
+    pass
+
+
+_FORCE_ABSTRACT_ATTR = '__forceabstract__'
+
+
+class Abstract:
+    """
+    Different from, but interoperable with, abc.ABC / abc.ABCMeta:
+
+     - This raises AbstractTypeError during class creation, not instance instantiation - unless Abstract or abc.ABC are
+       explicitly present in the class's direct bases.
+     - This will forbid instantiation of classes with Abstract in their direct bases even if there are no
+       abstractmethods left on the class.
+     - This is a mixin, not a metaclass.
+     - As it is not an ABCMeta, this does not support virtual base classes. As a result, operations like `isinstance`
+       and `issubclass` are ~7x faster.
+     - It additionally enforces a base class order of (Abstract, abc.ABC) to preemptively prevent common mro conflicts.
+
+    If not mixed-in with an ABCMeta, it will update __abstractmethods__ itself.
+    """
+
+    __slots__ = ()
+
+    __abstractmethods__: ta.ClassVar[ta.FrozenSet[str]] = frozenset()
+
+    #
+
+    def __forceabstract__(self):
+        raise TypeError
+
+    # This is done manually, rather than through @abc.abstractmethod, to mask it from static analysis.
+    setattr(__forceabstract__, _IS_ABSTRACT_METHOD_ATTR, True)
+
+    #
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        setattr(
+            cls,
+            _FORCE_ABSTRACT_ATTR,
+            getattr(Abstract, _FORCE_ABSTRACT_ATTR) if Abstract in cls.__bases__ else False,
+        )
+
+        super().__init_subclass__(**kwargs)
+
+        if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
+            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
+
+            seen = set(cls.__dict__)
+            for b in cls.__bases__:
+                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
+                seen.update(dir(b))
+
+            if ams:
+                raise AbstractTypeError(
+                    f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
+                    ', '.join(sorted([
+                        '.'.join([
+                            *([m] if (m := getattr(c, '__module__')) else []),
+                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            a,
+                        ])
+                        for a, c in ams.items()
+                    ])),
+                )
+
+        xbi = (Abstract, abc.ABC)  # , ta.Generic ?
+        bis = [(cls.__bases__.index(b), b) for b in xbi if b in cls.__bases__]
+        if bis != sorted(bis):
+            raise TypeError(
+                f'Abstract subclass {cls.__name__} must have proper base class order of '
+                f'({", ".join(getattr(b, "__name__") for b in xbi)}), got: '
+                f'({", ".join(getattr(b, "__name__") for _, b in sorted(bis))})',
+            )
+
+        if not isinstance(cls, abc.ABCMeta):
+            update_abstracts(cls, force=True)

omlish/lite/contextmanagers.py

@@ -190,7 +190,7 @@ def attr_setting(obj, attr, val, *, default=None):  # noqa
 ##
 
 
-class aclosing(contextlib.AbstractAsyncContextManager):  # noqa
+class AsyncClosingManager(contextlib.AbstractAsyncContextManager):
     def __init__(self, thing):
         self.thing = thing
 
@@ -199,3 +199,6 @@ class aclosing(contextlib.AbstractAsyncContextManager):  # noqa
 
     async def __aexit__(self, *exc_info):
         await self.thing.aclose()
+
+
+aclosing = AsyncClosingManager

omlish/lite/inject.py

@@ -9,6 +9,7 @@ import types
 import typing as ta
 import weakref
 
+from .abstract import Abstract
 from .check import check
 from .maybes import Maybe
 from .reflect import get_optional_alias_arg
@@ -58,7 +59,7 @@ def check_valid_injector_key_cls(cls: T) -> T:
 ##
 
 
-class InjectorProvider(abc.ABC):
+class InjectorProvider(Abstract):
     @abc.abstractmethod
     def provider_fn(self) -> InjectorProviderFn:
         raise NotImplementedError
@@ -77,7 +78,7 @@ class InjectorBinding:
         check.isinstance(self.provider, InjectorProvider)
 
 
-class InjectorBindings(abc.ABC):
+class InjectorBindings(Abstract):
     @abc.abstractmethod
     def bindings(self) -> ta.Iterator[InjectorBinding]:
         raise NotImplementedError
@@ -85,7 +86,7 @@ class InjectorBindings(abc.ABC):
 ##
 
 
-class Injector(abc.ABC):
+class Injector(Abstract):
     @abc.abstractmethod
     def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
         raise NotImplementedError
@@ -344,14 +345,12 @@ def injector_override(p: InjectorBindings, *args: InjectorBindingOrBindings) ->
 # scopes
 
 
-class InjectorScope(abc.ABC):  # noqa
+class InjectorScope(Abstract):
     def __init__(
             self,
             *,
             _i: Injector,
     ) -> None:
-        check.not_in(abc.ABC, type(self).__bases__)
-
         super().__init__()
 
         self._i = _i
@@ -382,7 +381,7 @@ class InjectorScope(abc.ABC):  # noqa
         raise NotImplementedError
 
 
-class ExclusiveInjectorScope(InjectorScope, abc.ABC):
+class ExclusiveInjectorScope(InjectorScope, Abstract):
     _st: ta.Optional[InjectorScope.State] = None
 
     def state(self) -> InjectorScope.State:
@@ -398,12 +397,13 @@ class ExclusiveInjectorScope(InjectorScope, abc.ABC):
             self._st = None
 
 
-class ContextvarInjectorScope(InjectorScope, abc.ABC):
+class ContextvarInjectorScope(InjectorScope, Abstract):
     _cv: contextvars.ContextVar
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
+        check.not_in(Abstract, cls.__bases__)
         check.not_in(abc.ABC, cls.__bases__)
         check.state(not hasattr(cls, '_cv'))
         cls._cv = contextvars.ContextVar(f'{cls.__name__}_cv')
@@ -909,7 +909,7 @@ class InjectorBinder:
         pws: ta.List[ta.Any] = []
         if in_ is not None:
             check.issubclass(in_, InjectorScope)
-            check.not_in(abc.ABC, in_.__bases__)
+            check.not_in(Abstract, in_.__bases__)
             pws.append(functools.partial(ScopedInjectorProvider, k=key, sc=in_))
         if singleton:
             pws.append(SingletonInjectorProvider)