omlish 0.0.0.dev1__py3-none-any.whl

omlish/lang/classes/test/test_restrict.py

@@ -0,0 +1,71 @@
+import typing as ta
+
+import pytest
+
+from ..restrict import Final
+from ..restrict import FinalException
+from ..restrict import NoBool
+from ..restrict import Sealed
+from ..restrict import SealedException
+from ..restrict import no_bool
+
+
+def test_final():
+    class A:
+        pass
+
+    A()
+
+    class B(A, Final):
+        pass
+
+    B()
+
+    with pytest.raises(FinalException):
+        class C(B):
+            pass
+
+    T = ta.TypeVar('T')
+
+    class D(ta.Generic[T], Final):
+        pass
+
+    D()
+    D[int]  # noqa
+
+    with pytest.raises(FinalException):
+        class E(D[int]):
+            pass
+
+
+def test_sealed():
+    class A(Sealed):
+        __module__ = 'a'
+
+    class B(A):
+        __module__ = 'a'
+
+    with pytest.raises(SealedException):
+        class C(A):
+            __module__ = 'c'
+
+    class D(B):
+        __module__ = 'd'
+
+
+def test_no_bool():
+    @no_bool
+    def f():
+        return 1
+
+    assert f() == 1
+    assert bool(f())
+    with pytest.raises(TypeError):
+        bool(f)
+
+    class C(NoBool):
+        pass
+
+    assert C  # type: ignore
+    with pytest.raises(TypeError):
+        bool(C())

omlish/lang/classes/test/test_simple.py

@@ -0,0 +1,58 @@
+import pytest
+
+from ..restrict import FinalException
+from ..simple import LazySingleton
+from ..simple import Marker
+from ..simple import Singleton
+
+
+def test_marker():
+    class M(Marker):
+        pass
+
+    with pytest.raises(FinalException):
+        class N(M):
+            pass
+    with pytest.raises(TypeError):
+        M()
+
+    assert repr(M) == '<M>'
+
+    assert isinstance(M, M)
+    assert issubclass(M, M)  # noqa
+
+    class O(Marker):
+        pass
+
+    assert isinstance(O, O)
+    assert issubclass(O, O)  # noqa
+
+    assert not isinstance(M, O)
+    assert not issubclass(M, O)
+    assert not isinstance(O, M)
+    assert not issubclass(O, M)
+
+
+def test_singletons():
+    for bcls in [Singleton, LazySingleton]:
+        foo_init_calls = 0
+        foo2_init_calls = 0
+
+        class Foo(bcls):  # type: ignore
+            def __init__(self):
+                super().__init__()
+                nonlocal foo_init_calls
+                foo_init_calls += 1
+
+        assert Foo() is Foo()
+        assert foo_init_calls == 1
+
+        class Foo2(Foo):
+            def __init__(self):
+                super().__init__()
+                nonlocal foo2_init_calls
+                foo2_init_calls += 1
+
+        assert Foo2() is Foo2()
+        assert foo2_init_calls == 1
+        assert foo_init_calls == 2

omlish/lang/classes/test/test_virtual.py

@@ -0,0 +1,72 @@
+import abc
+
+import pytest
+
+from ..virtual import Callable
+from ..virtual import Virtual
+from ..virtual import virtual_check
+
+
+def test_virtual():
+    class P(Virtual):
+        @abc.abstractmethod
+        def f(self):
+            raise NotImplementedError
+
+    with pytest.raises(TypeError):
+        P()  # type: ignore
+
+    class A:
+        def f(self):
+            pass
+
+    class B:
+        def g(self):
+            pass
+
+    A()
+
+    assert issubclass(A, P)
+    assert not issubclass(B, P)
+    assert isinstance(A(), P)
+    assert not isinstance(B(), P)
+
+    class C(P):
+        def f(self):
+            pass
+
+    with pytest.raises(TypeError):
+        class D(P):
+            pass
+
+        D()  # type: ignore
+
+    virtual_check(P)(A)
+    with pytest.raises(TypeError):
+        virtual_check(P)(B)
+
+
+def test_callable():
+    with pytest.raises(Exception):
+        Callable()
+
+    with pytest.raises(Exception):
+        class C(Callable):  # noqa
+            pass
+
+    def f():
+        pass
+
+    assert isinstance(f, Callable)
+    assert not isinstance(5, Callable)
+
+    class D:
+        pass
+
+    class E:
+        def __call__(self):
+            pass
+
+    assert isinstance(D, Callable)
+    assert isinstance(E, Callable)
+    assert isinstance(E(), Callable)

omlish/lang/classes/virtual.py

@@ -0,0 +1,130 @@
+import abc
+import types
+import typing as ta
+
+from .abstract import make_abstract
+from .restrict import NotInstantiable
+from .restrict import Final
+
+
+T = ta.TypeVar('T')
+Ty = ta.TypeVar('Ty', bound=type)
+
+
+##
+
+
+def _make_not_instantiable():
+    def __new__(cls, *args, **kwargs):
+        raise TypeError(cls)
+
+    def __init__(self, *args, **kwargs):
+        raise TypeError(self)
+
+    return {
+        '__new__': __new__,
+        '__initT__': __init__,
+    }
+
+
+class _VirtualMeta(abc.ABCMeta):
+
+    def __new__(mcls, name, bases, namespace):
+        if 'Virtual' not in globals():
+            return super().__new__(mcls, name, bases, namespace)
+        if Virtual not in bases:
+            raise TypeError
+
+        for k, v in list(namespace.items()):
+            absv = make_abstract(v)
+            if absv is not v:
+                namespace[k] = absv
+
+        reqs = {k: v for k, v in namespace.items() if getattr(v, '__isabstractmethod__', False)}
+        user_subclasshook = namespace.pop('__subclasshook__', None)
+
+        def get_missing_reqs(cls):
+            reqset = set(reqs)
+            for mro_cls in cls.__mro__:
+                reqset -= set(mro_cls.__dict__)
+            return reqset
+
+        def __subclasshook__(cls, subclass):
+            if cls is not kls:
+                return super(kls, cls).__subclasshook__(subclass)  # type: ignore
+            if get_missing_reqs(subclass):
+                return False
+            if user_subclasshook is not None:
+                ret = user_subclasshook(cls, subclass)
+            else:
+                ret = super(kls, cls).__subclasshook__(subclass)  # type: ignore
+            return True if ret is NotImplemented else ret
+
+        namespace['__subclasshook__'] = classmethod(__subclasshook__)
+
+        namespace.update(_make_not_instantiable())
+
+        kls = ta.cast(
+            type,
+            super().__new__(
+                abc.ABCMeta,
+                name,
+                tuple(b for b in bases if b is not Virtual),
+                namespace,
+            ),
+        )
+        return kls
+
+
+class Virtual(metaclass=_VirtualMeta):
+    """Like Protocol but supports more than just methods."""
+
+
+def virtual_check(virtual: type) -> ta.Callable[[Ty], Ty]:
+    def inner(cls):
+        if not issubclass(cls, virtual):
+            raise TypeError(cls)
+        return cls
+    # if not issubclass(type(virtual), _VirtualMeta):
+    #     raise TypeError(virtual)
+    return inner
+
+
+##
+
+
+class Descriptor(Virtual):
+
+    def __get__(self, instance, owner=None):
+        raise NotImplementedError
+
+
+class Picklable(Virtual):
+
+    def __getstate__(self):
+        raise NotImplementedError
+
+    def __setstate__(self, state):
+        raise NotImplementedError
+
+
+##
+
+
+class Callable(NotInstantiable, Final, ta.Generic[T]):
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        raise TypeError
+
+    @classmethod
+    def __instancecheck__(cls, instance):
+        return callable(instance)
+
+    @classmethod
+    def __subclasscheck__(cls, subclass):
+        if not hasattr(subclass, '__call__'):
+            return False
+        call = subclass.__call__
+        if isinstance(call, types.MethodWrapperType) and call.__self__ is subclass:
+            return False
+        return True

omlish/lang/clsdct.py

@@ -0,0 +1,67 @@
+import functools
+import sys
+import types
+import typing as ta
+
+
+_CLS_DCT_ATTR_SETS = [
+    {
+        '__module__',
+        '__qualname__',
+    },
+    {
+        '__all__',
+    },
+]
+
+
+def _skip_cls_dct_frames(f: types.FrameType) -> types.FrameType:
+    if sys.implementation.name == 'pypy':
+        if f.f_code is functools.partial.__call__.__code__:  # noqa
+            return _skip_cls_dct_frames(f.f_back)  # type: ignore
+
+    return f
+
+
+def is_possibly_cls_dct(dct: ta.Mapping[str, ta.Any]) -> bool:
+    return any(all(a in dct for a in s) for s in _CLS_DCT_ATTR_SETS)
+
+
+def get_caller_cls_dct(offset: int = 0) -> ta.MutableMapping[str, ta.Any]:
+    f = sys._getframe(offset + 2)  # noqa
+    cls_dct = _skip_cls_dct_frames(f).f_locals
+    if not is_possibly_cls_dct(cls_dct):
+        raise TypeError(cls_dct)
+    return cls_dct
+
+
+class ClassDctFn:
+
+    def __init__(self, fn: ta.Callable, offset: ta.Optional[int] = None, *, wrap=True) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._offset = offset if offset is not None else 1
+
+        if wrap:
+            functools.update_wrapper(self, fn)
+
+    def __get__(self, instance, owner=None):
+        return type(self)(self._fn.__get__(instance, owner), self._offset)  # noqa
+
+    def __call__(self, *args, **kwargs):
+        try:
+            cls_dct = kwargs.pop('cls_dct')
+        except KeyError:
+            f = sys._getframe(self._offset)  # noqa
+            cls_dct = _skip_cls_dct_frames(f).f_locals
+        if not is_possibly_cls_dct(cls_dct):
+            raise TypeError(cls_dct)
+        return self._fn(cls_dct, *args, **kwargs)
+
+
+def cls_dct_fn(offset=1, *, wrap=True):
+    def outer(fn):
+        return ClassDctFn(fn, offset, wrap=wrap)
+
+    return outer

omlish/lang/cmp.py

@@ -0,0 +1,63 @@
+import typing as ta
+
+
+def cmp(l: ta.Any, r: ta.Any) -> int:
+    return int(l > r) - int(l < r)
+
+
+class InfinityType:
+    def __repr__(self) -> str:
+        return 'Infinity'
+
+    def __hash__(self) -> int:
+        return hash(repr(self))
+
+    def __lt__(self, other: ta.Any) -> bool:
+        return False
+
+    def __le__(self, other: ta.Any) -> bool:
+        return False
+
+    def __eq__(self, other: ta.Any) -> bool:
+        return isinstance(other, self.__class__)
+
+    def __gt__(self, other: ta.Any) -> bool:
+        return True
+
+    def __ge__(self, other: ta.Any) -> bool:
+        return True
+
+    def __neg__(self: ta.Any) -> 'NegativeInfinityType':
+        return NegativeInfinity
+
+
+Infinity = InfinityType()
+
+
+class NegativeInfinityType:
+    def __repr__(self) -> str:
+        return '-Infinity'
+
+    def __hash__(self) -> int:
+        return hash(repr(self))
+
+    def __lt__(self, other: ta.Any) -> bool:
+        return True
+
+    def __le__(self, other: ta.Any) -> bool:
+        return True
+
+    def __eq__(self, other: ta.Any) -> bool:
+        return isinstance(other, self.__class__)
+
+    def __gt__(self, other: ta.Any) -> bool:
+        return False
+
+    def __ge__(self, other: ta.Any) -> bool:
+        return False
+
+    def __neg__(self: ta.Any) -> InfinityType:
+        return Infinity
+
+
+NegativeInfinity = NegativeInfinityType()

omlish/lang/contextmanagers.py

@@ -0,0 +1,249 @@
+import contextlib
+import contextvars
+import functools
+import threading
+import types
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class ContextManaged:
+
+    def __enter__(self: ta.Self) -> ta.Self:
+        return self
+
+    def __exit__(
+            self,
+            exc_type: ta.Optional[ta.Type[Exception]],
+            exc_val: ta.Optional[Exception],
+            exc_tb: ta.Optional[types.TracebackType]
+    ) -> ta.Optional[bool]:
+        return None
+
+
+class NopContextManaged(ContextManaged):
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+
+NOP_CONTEXT_MANAGED = NopContextManaged()
+
+
+class NopContextManager:
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    def __call__(self, *args, **kwargs):
+        return NOP_CONTEXT_MANAGED
+
+
+NOP_CONTEXT_MANAGER = NopContextManager()
+
+
+##
+
+
+@contextlib.contextmanager
+def defer(fn: ta.Callable) -> ta.Iterator[ta.Callable]:
+    try:
+        yield fn
+    finally:
+        fn()
+
+
+@contextlib.asynccontextmanager
+async def a_defer(fn: ta.Awaitable) -> ta.AsyncIterator[ta.Awaitable]:
+    try:
+        yield fn
+    finally:
+        await fn
+
+
+@contextlib.contextmanager
+def maybe_managing(obj: T) -> ta.Iterator[T]:
+    if isinstance(obj, ta.ContextManager):
+        with obj:
+            yield ta.cast(T, obj)
+    else:
+        yield obj
+
+
+@contextlib.contextmanager
+def disposing(obj: T, attr: str = 'dispose') -> ta.Iterator[T]:
+    try:
+        yield obj
+    finally:
+        getattr(obj, attr)()
+
+
+@contextlib.contextmanager
+def breakpoint_on_exception():
+    try:
+        yield
+    except Exception as e:  # noqa
+        breakpoint()
+        raise
+
+
+@contextlib.contextmanager
+def context_var_setting(var: contextvars.ContextVar[T], val: T) -> ta.Iterator[T]:
+    token = var.set(val)
+    try:
+        yield val
+    finally:
+        var.reset(token)
+
+
+@contextlib.contextmanager
+def attr_setting(obj, attr, val, *, default=None):
+    not_set = object()
+    orig = getattr(obj, attr, not_set)
+    try:
+        setattr(obj, attr, val)
+        if orig is not not_set:
+            yield orig
+        else:
+            yield default
+    finally:
+        if orig is not_set:
+            delattr(obj, attr)
+        else:
+            setattr(obj, attr, orig)
+
+
+##
+
+
+class ExitStacked:
+
+    @property
+    def _exit_stack(self) -> contextlib.ExitStack:
+        try:
+            return self.__exit_stack  # type: ignore
+        except AttributeError:
+            es = self.__exit_stack = contextlib.ExitStack()
+            return es
+
+    def _enter_context(self, context_manager: ta.ContextManager[T]) -> T:
+        return self._exit_stack.enter_context(ta.cast(ta.ContextManager, context_manager))
+
+    def __enter__(self: ta.Self) -> ta.Self:
+        try:
+            superfn = super().__enter__  # type: ignore
+        except AttributeError:
+            ret = self
+        else:
+            ret = superfn()
+        self._exit_stack.__enter__()
+        return ret
+
+    def __exit__(
+            self,
+            exc_type: ta.Optional[ta.Type[Exception]],
+            exc_val: ta.Optional[Exception],
+            exc_tb: ta.Optional[types.TracebackType]
+    ) -> ta.Optional[bool]:
+        self._exit_stack.__exit__(exc_type, exc_val, exc_tb)
+        try:
+            superfn = super().__exit__  # type: ignore
+        except AttributeError:
+            return None
+        else:
+            return superfn(exc_type, exc_val, exc_tb)
+
+
+##
+
+
+ContextWrappable: ta.TypeAlias = ta.Union[ta.ContextManager, str, ta.Callable[..., ta.ContextManager]]
+
+
+class ContextWrapped:
+
+    def __init__(self, fn: ta.Callable, cm: ta.Union[str, ContextWrappable]) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._cm = cm
+        self._name: str | None = None
+
+        functools.update_wrapper(self, fn)
+
+    def __set_name__(self, owner, name):
+        if name is not None:
+            if self._name is not None:
+                if name != self._name:
+                    raise NameError(name, self._name)
+            else:
+                self._name = name
+
+    def __get__(self, instance, owner=None):
+        if instance is None and owner is None:
+            return self
+        fn = self._fn.__get__(instance, owner)  # noqa
+        cm: ta.Any = self._cm
+        if isinstance(self._cm, str):
+            if instance is not None:
+                cm = getattr(instance, cm)
+            elif owner is not None:
+                cm = getattr(owner, cm)
+            else:
+                raise TypeError(cm)
+        elif hasattr(cm, '__enter__'):
+            pass
+        elif callable(cm):
+            cm = cm.__get__(instance, owner)  # noqa
+        else:
+            raise TypeError(cm)
+        ret = type(self)(fn, cm)
+        if self._name is not None:
+            try:
+                instance.__dict__[self._name] = ret
+            except TypeError:
+                pass
+        return ret
+
+    def __call__(self, *args, **kwargs):
+        if isinstance(self._cm, str):
+            raise TypeError(self._cm)
+        cm = self._cm
+        if not hasattr(cm, '__enter__') and callable(cm):
+            cm = cm(*args, **kwargs)
+        with cm:  # type: ignore
+            return self._fn(*args, **kwargs)
+
+
+def context_wrapped(cm):  # ContextWrappable -> ta.Callable[[CallableT], CallableT]:
+    def inner(fn):
+        return ContextWrapped(fn, cm)
+    return inner
+
+
+##
+
+
+Lockable = ta.Callable[[], ta.ContextManager]
+DefaultLockable = ta.Union[None, bool, Lockable, ta.ContextManager]
+
+
+def default_lock(value: DefaultLockable, default: DefaultLockable) -> Lockable:
+    if value is None:
+        value = default
+    if value is True:
+        lock = threading.RLock()
+        return lambda: lock
+    elif value is False or value is None:
+        return NOP_CONTEXT_MANAGER
+    elif callable(value):
+        return value
+    elif isinstance(value, ta.ContextManager):
+        return lambda: value
+    else:
+        raise TypeError(value)