omlish 0.0.0.dev1__py3-none-any.whl

omlish/lang/cached.py

@@ -0,0 +1,267 @@
+"""
+TODO:
+ - integrate / expose with collections.cache
+ - weakrefs (selectable by arg)
+ - locks
+"""
+import dataclasses as dc
+import functools
+import inspect
+import typing as ta
+
+from .contextmanagers import DefaultLockable
+from .contextmanagers import default_lock
+from .functions import unwrap_func
+from .functions import unwrap_func_with_partials
+
+
+P = ta.ParamSpec('P')
+T = ta.TypeVar('T')
+
+_IGNORE = object()
+
+
+def _nullary_cache_keyer():
+    return ()
+
+
+def _simple_cache_keyer(*args, **kwargs):
+    return (args, tuple(sorted(kwargs.items())))
+
+
+def _make_cache_keyer(fn, *, simple=False, bound=False):
+    if simple:
+        return _simple_cache_keyer
+
+    fn, partials = unwrap_func_with_partials(fn)
+
+    if inspect.isgeneratorfunction(fn) or inspect.iscoroutinefunction(fn):
+        raise TypeError(fn)
+
+    sig = inspect.signature(fn)
+    sig_params = list(sig.parameters.values())[1 if bound else 0:]
+    if not sig_params:
+        return _nullary_cache_keyer
+
+    ns = {}
+    src_params = []
+    src_vals = []
+    kwargs_name = None
+    render_pos_only_separator = False
+    render_kw_only_separator = True
+    for p in sig_params:
+        formatted = p.name
+        if p.default is not inspect.Parameter.empty:
+            ns[p.name] = p.default
+            formatted = f'{formatted}={formatted}'
+        kind = p.kind
+        if kind == inspect.Parameter.VAR_POSITIONAL:
+            formatted = '*' + formatted
+        elif kind == inspect.Parameter.VAR_KEYWORD:
+            formatted = '**' + formatted
+        if kind == inspect.Parameter.POSITIONAL_ONLY:
+            render_pos_only_separator = True
+        elif render_pos_only_separator:
+            src_params.append('/')
+            render_pos_only_separator = False
+        if kind == inspect.Parameter.VAR_POSITIONAL:
+            render_kw_only_separator = False
+        elif kind == inspect.Parameter.KEYWORD_ONLY and render_kw_only_separator:
+            src_params.append('*')
+            render_kw_only_separator = False
+        src_params.append(formatted)
+        if kind == inspect.Parameter.VAR_KEYWORD:
+            kwargs_name = p.name
+        else:
+            src_vals.append(p.name)
+    if render_pos_only_separator:
+        src_params.append('/')
+
+    kwa = f', __builtins__.tuple(__builtins__.sorted({kwargs_name}.items()))' if kwargs_name else ''
+    rendered = (
+        f'def __func__({", ".join(src_params)}):\n'
+        f'    return ({", ".join(src_vals)}{kwa})\n'
+    )
+    exec(rendered, ns)
+
+    kfn = ns['__func__']
+    for part in partials[::-1]:
+        kfn = functools.partial(kfn, *part.args, **part.keywords)
+
+    return kfn
+
+
+class _CachedFunction(ta.Generic[T]):
+    @dc.dataclass(frozen=True)
+    class Opts:
+        map_maker: ta.Callable[[], ta.MutableMapping] = dict
+        simple_key: bool = False
+        lock: DefaultLockable = None
+
+    def __init__(
+            self,
+            fn: ta.Callable[P, T],
+            *,
+            opts: Opts = Opts(),
+            keyer: ta.Callable[..., tuple] | None = None,
+            values: ta.MutableMapping | None = None,
+            value_fn: ta.Optional[ta.Callable[P, T]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._opts = opts
+        self._keyer = keyer if keyer is not None else _make_cache_keyer(fn, simple=opts.simple_key)
+
+        self._lock = default_lock(opts.lock, False)() if opts.lock is not None else None
+        self._values = values if values is not None else opts.map_maker()
+        self._value_fn = value_fn if value_fn is not None else fn
+        functools.update_wrapper(self, fn)
+
+    def reset(self) -> None:
+        self._values = {}
+
+    def __bool__(self) -> bool:
+        raise TypeError
+
+    def __call__(self, *args, **kwargs) -> T:
+        k = self._keyer(*args, **kwargs)
+
+        try:
+            return self._values[k]
+        except KeyError:
+            pass
+
+        if self._lock is not None:
+            with self._lock:
+                try:
+                    return self._values[k]
+                except KeyError:
+                    pass
+
+                value = self._value_fn(*args, **kwargs)
+
+        else:
+            value = self._value_fn(*args, **kwargs)
+
+        self._values[k] = value
+        return value
+
+
+class _CachedFunctionDescriptor(_CachedFunction[T]):
+
+    def __init__(
+            self,
+            fn: ta.Callable[P, T],
+            scope: ta.Any,
+            *,
+            instance: ta.Any = None,
+            owner: ta.Any = None,
+            name: ta.Optional[str] = None,
+            **kwargs
+    ) -> None:
+        super().__init__(fn, **kwargs)
+
+        self._scope = scope
+        self._instance = instance
+        self._owner = owner
+        self._name = name if name is not None else unwrap_func(fn).__name__
+        self._bound_keyer = None
+
+    def __get__(self, instance, owner=None):
+        scope = self._scope
+        if owner is self._owner and (instance is self._instance or scope is classmethod):
+            return self
+
+        fn = self._fn
+        name = self._name
+        bound_fn = fn.__get__(instance, owner)
+        if self._bound_keyer is None:
+            self._bound_keyer = _make_cache_keyer(fn, simple=self._opts.simple_key, bound=True)
+
+        bound = self.__class__(
+            fn,
+            scope,
+            opts=self._opts,
+            instance=instance,
+            owner=owner,
+            name=name,
+            keyer=self._bound_keyer,
+            # values=None if scope is classmethod else self._values,
+            value_fn=bound_fn,
+        )
+
+        if scope is classmethod and owner is not None:
+            setattr(owner, name, bound)
+        elif instance is not None:
+            instance.__dict__[name] = bound
+
+        return bound
+
+
+def cached_function(fn=None, **kwargs):
+    if fn is None:
+        return functools.partial(cached_function, **kwargs)
+    opts = _CachedFunction.Opts(**kwargs)
+    if isinstance(fn, staticmethod):
+        return _CachedFunction(fn, opts=opts, value_fn=unwrap_func(fn))
+    scope = classmethod if isinstance(fn, classmethod) else None
+    return _CachedFunctionDescriptor(fn, scope, opts=opts)
+
+
+cached_function = cached_function
+
+
+##
+
+
+class _CachedProperty:
+    def __init__(
+            self,
+            fn,
+            *,
+            name=None,
+            ignore_if=lambda _: False,
+            clear_on_init=False,
+    ):
+        super().__init__()
+        if isinstance(fn, property):
+            fn = fn.fget
+        self._fn = fn
+        self._ignore_if = ignore_if
+        self._name = name
+        self._clear_on_init = clear_on_init
+
+    def __set_name__(self, owner, name):
+        if self._name is None:
+            self._name = name
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self._name is None:
+            raise TypeError(self)
+
+        try:
+            return instance.__dict__[self._name]
+        except KeyError:
+            pass
+
+        value = self._fn.__get__(instance, owner)()
+        if value is _IGNORE:
+            return None
+        instance.__dict__[self._name] = value
+        return value
+
+    def __set__(self, instance, value):
+        if self._ignore_if(value):
+            return
+        if instance.__dict__[self._name] == value:
+            return
+        raise TypeError(self._name)
+
+
+def cached_property(fn=None, **kwargs):
+    if fn is None:
+        return functools.partial(cached_property, **kwargs)
+    return _CachedProperty(fn, **kwargs)

omlish/lang/classes/__init__.py

@@ -0,0 +1,24 @@
+from .abstract import Abstract # noqa
+from .abstract import is_abstract # noqa
+from .abstract import is_abstract_class # noqa
+from .abstract import is_abstract_method # noqa
+from .abstract import make_abstract  # noqa
+from .restrict import Final  # noqa
+from .restrict import FinalException  # noqa
+from .restrict import NoBool  # noqa
+from .restrict import NotInstantiable  # noqa
+from .restrict import NotPicklable  # noqa
+from .restrict import PackageSealed  # noqa
+from .restrict import Sealed  # noqa
+from .restrict import SealedException  # noqa
+from .restrict import no_bool  # noqa
+from .simple import LazySingleton  # noqa
+from .simple import Marker  # noqa
+from .simple import Namespace  # noqa
+from .simple import SimpleMetaDict  # noqa
+from .simple import Singleton  # noqa
+from .virtual import Callable  # noqa
+from .virtual import Descriptor  # noqa
+from .virtual import Picklable  # noqa
+from .virtual import Virtual  # noqa
+from .virtual import virtual_check  # noqa

omlish/lang/classes/abstract.py

@@ -0,0 +1,74 @@
+import abc
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+_DISABLE_CHECKS = False
+
+
+def make_abstract(obj: T) -> T:
+    if callable(obj):
+        return ta.cast(T, 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 Abstract(abc.ABC):
+    __slots__ = ()
+
+    def __forceabstract__(self):
+        raise TypeError
+
+    setattr(__forceabstract__, '__isabstractmethod__', True)
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        if Abstract in cls.__bases__:
+            cls.__forceabstract__ = Abstract.__forceabstract__  # type: ignore
+        else:
+            cls.__forceabstract__ = False  # type: ignore
+
+        super().__init_subclass__(**kwargs)
+
+        if not _DISABLE_CHECKS and Abstract 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, '__abstractmethods__', [])) - seen)
+                seen.update(dir(b))
+            if ams:
+                raise TypeError(
+                    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, '__isabstractmethod__', False))
+
+
+def is_abstract_class(obj: ta.Any) -> bool:
+    if bool(getattr(obj, '__abstractmethods__', [])):
+        return True
+    if isinstance(obj, type):
+        if Abstract in obj.__bases__:
+            return True
+        if (
+                Abstract in obj.__mro__
+                and getattr(obj.__dict__.get('__forceabstract__', None), '__isabstractmethod__', False)
+        ):
+            return True
+    return False
+
+
+def is_abstract(obj: ta.Any) -> bool:
+    return is_abstract_method(obj) or is_abstract_class(obj)

omlish/lang/classes/restrict.py

@@ -0,0 +1,137 @@
+import functools
+import typing as ta
+
+from .abstract import Abstract
+from .abstract import is_abstract
+
+
+##
+
+
+class FinalException(TypeError):
+
+    def __init__(self, _type: ta.Type) -> None:
+        super().__init__()
+
+        self._type = _type
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}({self._type})'
+
+
+class Final(Abstract):
+    __slots__ = ()
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+
+        abstracts: set[ta.Any] = set()
+        for base in cls.__bases__:
+            if base is Abstract:
+                raise FinalException(base)
+            elif base is Final:
+                continue
+            elif Final in base.__mro__:
+                raise FinalException(base)
+            else:
+                abstracts.update(getattr(base, '__abstractmethods__', []))
+
+        for a in abstracts:
+            try:
+                v = cls.__dict__[a]
+            except KeyError:
+                raise FinalException(a)
+            if is_abstract(v):
+                raise FinalException(a)
+
+
+##
+
+
+class SealedException(TypeError):
+
+    def __init__(self, _type) -> None:
+        super().__init__()
+
+        self._type = _type
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}({self._type})'
+
+
+class Sealed:
+    __slots__ = ()
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        for base in cls.__bases__:
+            if base is not Abstract:
+                if Sealed in base.__bases__:
+                    if cls.__module__ != base.__module__:
+                        raise SealedException(base)
+        super().__init_subclass__(**kwargs)
+
+
+class PackageSealed:
+    __slots__ = ()
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        for base in cls.__bases__:
+            if base is not Abstract:
+                if PackageSealed in base.__bases__:
+                    if cls.__module__.split('.')[:-1] != base.__module__.split('.')[:-1]:
+                        raise SealedException(base)
+        super().__init_subclass__(**kwargs)
+
+
+##
+
+
+class NotInstantiable(Abstract):
+    __slots__ = ()
+
+    def __new__(cls, *args, **kwargs) -> ta.NoReturn:
+        raise TypeError
+
+
+class NotPicklable:
+    __slots__ = ()
+
+    def __getstate__(self) -> ta.NoReturn:
+        raise TypeError
+
+    def __setstate__(self, state) -> ta.NoReturn:
+        raise TypeError
+
+
+##
+
+
+class NoBool:
+
+    def __bool__(self) -> bool:
+        raise TypeError
+
+
+class _NoBoolDescriptor:
+
+    def __init__(self, fn, instance=None, owner=None) -> None:
+        super().__init__()
+        self._fn = fn
+        self._instance = instance
+        self._owner = owner
+        functools.update_wrapper(self, fn)
+
+    def __bool__(self) -> bool:
+        raise TypeError
+
+    def __get__(self, instance, owner=None):
+        if instance is self._instance and owner is self._owner:
+            return self
+        return _NoBoolDescriptor(self._fn.__get__(instance, owner), instance, owner)
+
+    def __call__(self, *args, **kwargs):
+        return self._fn(*args, **kwargs)
+
+
+def no_bool(fn):
+    return _NoBoolDescriptor(fn)

omlish/lang/classes/simple.py

@@ -0,0 +1,120 @@
+import abc
+import functools
+import threading
+import typing as ta
+
+from .restrict import Final
+from .restrict import NotInstantiable
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+class _Namespace(Final):
+
+    def __mro_entries__(self, bases, **kwargs):
+        return (Final, NotInstantiable)
+
+
+Namespace: type = _Namespace()  # type: ignore
+
+
+##
+
+
+_MARKER_NAMESPACE_KEYS: ta.Optional[set[str]] = None
+
+
+class _MarkerMeta(abc.ABCMeta):
+
+    def __new__(mcls, name, bases, namespace):
+        global _MARKER_NAMESPACE_KEYS
+        if _MARKER_NAMESPACE_KEYS is None:
+            if not (namespace.get('__module__') == __name__ and name == 'Marker'):
+                raise RuntimeError
+            _MARKER_NAMESPACE_KEYS = set(namespace)
+        else:
+            if set(namespace) - _MARKER_NAMESPACE_KEYS:
+                raise TypeError('Markers must not include contents. Did you mean to use Namespace?')
+            if Final not in bases:
+                bases += (Final,)
+        return super().__new__(mcls, name, bases, namespace)
+
+    def __instancecheck__(self, instance):
+        return instance is self
+
+    def __repr__(cls) -> str:
+        return f'<{cls.__name__}>'
+
+
+class Marker(NotInstantiable, metaclass=_MarkerMeta):
+    """A marker."""
+
+    __slots__ = ()
+
+
+##
+
+
+class SimpleMetaDict(dict):
+
+    def update(self, m: ta.Mapping[K, V], **kwargs: V) -> None:  # type: ignore
+        for k, v in m.items():
+            self[k] = v
+        for k, v in kwargs.items():  # type: ignore
+            self[k] = v
+
+
+##
+
+
+_SINGLETON_INSTANCE_ATTR = '__singleton_instance__'
+_SINGLETON_LOCK = threading.RLock()
+
+
+def _set_singleton_instance(inst):
+    cls = type(inst)
+    if _SINGLETON_INSTANCE_ATTR in cls.__dict__:
+        raise TypeError(cls)
+
+    inst.__init__()
+    old_init = cls.__init__
+
+    @functools.wraps(old_init)
+    def new_init(self):
+        if type(self) is not cls:
+            old_init(self)  # noqa
+
+    setattr(cls, '__init__', new_init)
+    setattr(cls, _SINGLETON_INSTANCE_ATTR, inst)
+
+    return inst
+
+
+class Singleton:
+
+    def __new__(cls):
+        return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        _set_singleton_instance(super().__new__(cls))  # noqa
+
+
+class LazySingleton:
+
+    def __new__(cls):
+        try:
+            return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
+        except KeyError:
+            pass
+        with _SINGLETON_LOCK:
+            try:
+                return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
+            except KeyError:
+                pass
+            return _set_singleton_instance(super().__new__(cls))

omlish/lang/classes/test/test_abstract.py

@@ -0,0 +1,89 @@
+import abc
+
+import pytest
+
+from ..abstract import Abstract
+from ..abstract import is_abstract
+
+
+def test_abstract():
+    class C(Abstract):
+        pass
+
+    class D(C):
+        pass
+
+    class E(D, Abstract):
+        pass
+
+    class F(E):
+        pass
+
+    with pytest.raises(TypeError):
+        C()
+    D()
+    with pytest.raises(TypeError):
+        E()
+    F()
+
+
+def test_abstract2():
+    class O(Abstract):
+        pass
+
+    assert is_abstract(O)
+
+    with pytest.raises(TypeError):
+        O()
+
+    class A(Abstract):
+        @abc.abstractmethod
+        def f(self):
+            pass
+
+    assert is_abstract(A)
+
+    with pytest.raises(TypeError):
+        A()  # type: ignore
+
+    class B(A, Abstract):
+        pass
+
+    with pytest.raises(TypeError):
+        B()  # type: ignore
+
+    class C(B):
+        f = 0
+
+    assert C()
+
+    with pytest.raises(TypeError):
+        class D(A):
+            pass
+
+
+def test_is_abstract():
+    class A(Abstract):
+        pass
+
+    assert is_abstract(A)
+
+    class B(A):
+        pass
+
+    assert not is_abstract(B)
+
+    class C(Abstract):
+
+        def __init_subclass__(cls, **kwargs):
+            super().__init_subclass__(**kwargs)
+            if cls.__name__ == 'D':
+                assert is_abstract(cls)
+            else:
+                assert not is_abstract(cls)
+
+    class D(C, Abstract):
+        pass
+
+    class E(D):
+        pass