omlish 0.0.0.dev244__py3-none-any.whl → 0.0.0.dev246__py3-none-any.whl

omlish/lang/{cached.py → cached/function.py}

@@ -2,37 +2,43 @@
 TODO:
  - integrate / expose with collections.cache
  - weakrefs (selectable by arg)
- - locks
+ - more rigorous descriptor pickling
+  - must support free functions (which have no instance nor owner)
+  - 'staticmethod' or effective equiv - which must resolve to the shared instance
+   - and must be transient?
+ - use __transient_dict__ to support common state nuking
 """
 import dataclasses as dc
 import functools
 import inspect
 import typing as ta
 
-from .contextmanagers import DefaultLockable
-from .contextmanagers import default_lock
-from .descriptors import unwrap_func
-from .descriptors import unwrap_func_with_partials
+from ..classes.abstract import Abstract
+from ..contextmanagers import DefaultLockable
+from ..contextmanagers import default_lock
+from ..descriptors import unwrap_func
+from ..descriptors import unwrap_func_with_partials
 
 
 P = ta.ParamSpec('P')
 T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
-_IGNORE = object()
+
+##
 
 
-def _nullary_cache_keyer():
+def _nullary_cache_key_maker():
     return ()
 
 
-def _simple_cache_keyer(*args, **kwargs):
+def _simple_cache_key_maker(*args, **kwargs):
     return (args, tuple(sorted(kwargs.items())))
 
 
-def _make_cache_keyer(fn, *, simple=False, bound=False):
+def _make_cache_key_maker(fn, *, simple=False, bound=False):
     if simple:
-        return _simple_cache_keyer
+        return _simple_cache_key_maker
 
     fn, partials = unwrap_func_with_partials(fn)
 
@@ -42,7 +48,7 @@ def _make_cache_keyer(fn, *, simple=False, bound=False):
     sig = inspect.signature(fn)
     sig_params = list(sig.parameters.values())[1 if bound else 0:]
     if not sig_params:
-        return _nullary_cache_keyer
+        return _nullary_cache_key_maker
 
     ns = {}
     src_params = []
@@ -92,19 +98,23 @@ def _make_cache_keyer(fn, *, simple=False, bound=False):
     return kfn
 
 
-class _CachedFunction(ta.Generic[T]):
+##
+
+
+class _CachedFunction(ta.Generic[T], Abstract):
     @dc.dataclass(frozen=True)
     class Opts:
         map_maker: ta.Callable[[], ta.MutableMapping] = dict
         simple_key: bool = False
         lock: DefaultLockable = None
+        transient: bool = False
 
     def __init__(
             self,
             fn: ta.Callable[P, T],
             *,
             opts: Opts = Opts(),
-            keyer: ta.Callable[..., tuple] | None = None,
+            key_maker: ta.Callable[..., tuple] | None = None,
             values: ta.MutableMapping | None = None,
             value_fn: ta.Callable[P, T] | None = None,
     ) -> None:
@@ -112,7 +122,7 @@ class _CachedFunction(ta.Generic[T]):
 
         self._fn = (fn,)
         self._opts = opts
-        self._keyer = keyer if keyer is not None else _make_cache_keyer(fn, simple=opts.simple_key)
+        self._key_maker = key_maker if key_maker is not None else _make_cache_key_maker(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()
@@ -134,7 +144,7 @@ class _CachedFunction(ta.Generic[T]):
         raise TypeError
 
     def __call__(self, *args, **kwargs) -> T:
-        k = self._keyer(*args, **kwargs)
+        k = self._key_maker(*args, **kwargs)
 
         try:
             return self._values[k]
@@ -157,11 +167,42 @@ class _CachedFunction(ta.Generic[T]):
         return value
 
 
-class _CachedFunctionDescriptor(_CachedFunction[T]):
+#
+
+
+class _FreeCachedFunction(_CachedFunction[T]):
+    @classmethod
+    def _unpickle(
+            cls,
+            fn,
+            opts,
+            values,
+    ):
+        return cls(
+            fn,
+            opts=opts,
+            values=values,
+        )
+
+    def __reduce__(self):
+        return (
+            _FreeCachedFunction._unpickle,
+            (
+                self._fn,
+                self._opts,
+                self._values if not self._opts.transient else None,
+            ),
+        )
+
+
+#
+
+
+class _DescriptorCachedFunction(_CachedFunction[T]):
     def __init__(
             self,
             fn: ta.Callable[P, T],
-            scope: ta.Any,
+            scope: ta.Any,  # classmethod | None
             *,
             instance: ta.Any = None,
             owner: ta.Any = None,
@@ -174,9 +215,61 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
         self._instance = instance
         self._owner = owner
         self._name = name if name is not None else unwrap_func(fn).__name__
-        self._bound_keyer = None
+        self._bound_key_maker = None
 
-    def __get__(self, instance, owner=None):
+    @classmethod
+    def _unpickle(
+            cls,
+            scope,
+            instance,
+            owner,
+            name,
+            values,
+    ):
+        if scope is not None:
+            raise NotImplementedError
+
+        if instance is None:
+            raise RuntimeError
+        obj = type(instance)
+
+        desc: _DescriptorCachedFunction = object.__getattribute__(obj, name)
+        if not isinstance(desc, cls):
+            raise TypeError(desc)
+        if (desc._instance is not None or desc._owner is not None):
+            raise RuntimeError
+
+        return desc._bind(
+            instance,
+            owner,
+            values=values,
+        )
+
+    def __reduce__(self):
+        if self._scope is not None:
+            raise NotImplementedError
+
+        if not (self._instance is not None or self._owner is not None):
+            raise RuntimeError
+
+        return (
+            _DescriptorCachedFunction._unpickle,
+            (
+                self._scope,
+                self._instance,
+                self._owner,
+                self._name,
+                self._values if not self._opts.transient else None,
+            ),
+        )
+
+    def _bind(
+            self,
+            instance,
+            owner=None,
+            *,
+            values: ta.MutableMapping | None = None,
+    ):
         scope = self._scope
         if owner is self._owner and (instance is self._instance or scope is classmethod):
             return self
@@ -184,8 +277,8 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
         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)
+        if self._bound_key_maker is None:
+            self._bound_key_maker = _make_cache_key_maker(fn, simple=self._opts.simple_key, bound=True)
 
         bound = self.__class__(
             fn,
@@ -194,8 +287,9 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
             instance=instance,
             owner=owner,
             name=name,
-            keyer=self._bound_keyer,
-            # values=None if scope is classmethod else self._values,
+            key_maker=self._bound_key_maker,
+            # values=None if scope is classmethod else self._values,  # FIXME: ?
+            values=values,
             value_fn=bound_fn,
         )
 
@@ -206,76 +300,24 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
 
         return bound
 
+    def __get__(self, instance, owner=None):
+        return self._bind(instance, owner)
+
+
+#
+
 
 def cached_function(fn=None, **kwargs):  # noqa
     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))
+        return _FreeCachedFunction(fn, opts=opts, value_fn=unwrap_func(fn))
     scope = classmethod if isinstance(fn, classmethod) else None
-    return _CachedFunctionDescriptor(fn, scope, opts=opts)
+    return _DescriptorCachedFunction(fn, scope, opts=opts)
 
 
 def static_init(fn: CallableT) -> CallableT:
     fn = cached_function(fn)
     fn()
     return fn
-
-
-##
-
-
-class _CachedProperty(property):
-    def __init__(
-            self,
-            fn,
-            *,
-            name=None,
-            ignore_if=lambda _: False,
-            clear_on_init=False,
-    ):
-        if isinstance(fn, property):
-            fn = fn.fget
-        super().__init__(fn)
-        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 __delete__(self, instance):
-        raise TypeError
-
-
-def cached_property(fn=None, **kwargs):  # noqa
-    if fn is None:
-        return functools.partial(cached_property, **kwargs)
-    return _CachedProperty(fn, **kwargs)

omlish/lang/cached/property.py

@@ -0,0 +1,118 @@
+import abc
+import functools
+import typing as ta
+
+from ..attrs import transient_getattr
+from ..attrs import transient_setattr
+from ..classes.abstract import Abstract
+
+
+_IGNORE = object()
+
+
+##
+
+
+class _CachedProperty(property, Abstract):
+    def __init__(
+            self,
+            fn,
+            *,
+            name=None,
+            ignore_if=lambda _: False,
+    ):
+        if isinstance(fn, property):
+            fn = fn.fget
+
+        super().__init__(fn)
+
+        self._fn = fn
+        self._ignore_if = ignore_if
+
+        self._name = name
+
+    def __set_name__(self, owner, name):
+        if self._name is None:
+            self._name = name
+
+    @abc.abstractmethod
+    def _instance_get(self, instance: ta.Any) -> tuple[ta.Any, bool]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _instance_set(self, instance: ta.Any, value: ta.Any) -> None:
+        raise NotImplementedError
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self._name is None:
+            raise TypeError(self)
+
+        value, ok = self._instance_get(instance)
+        if ok:
+            return value
+
+        value = self._fn.__get__(instance, owner)()
+        if value is _IGNORE:
+            return None
+
+        self._instance_set(instance, value)
+        return value
+
+    def __set__(self, instance, value):
+        if self._ignore_if(value):
+            return
+
+        ev, ok = self._instance_get(instance)
+        if ok and ev == value:
+            return
+
+        raise TypeError(self._name)
+
+    def __delete__(self, instance):
+        raise TypeError
+
+
+#
+
+
+class _DictCachedProperty(_CachedProperty):
+    def _instance_get(self, instance: ta.Any) -> tuple[ta.Any, bool]:
+        try:
+            value = instance.__dict__[self._name]
+        except KeyError:
+            return None, False
+        else:
+            return value, True
+
+    def _instance_set(self, instance: ta.Any, value: ta.Any) -> None:
+        instance.__dict__[self._name] = value
+
+
+#
+
+
+class _TransientCachedProperty(_CachedProperty):
+    def _instance_get(self, instance: ta.Any) -> tuple[ta.Any, bool]:
+        try:
+            value = transient_getattr(instance, self._name)
+        except AttributeError:
+            return None, False
+        else:
+            return value, True
+
+    def _instance_set(self, instance: ta.Any, value: ta.Any) -> None:
+        transient_setattr(instance, self._name, value)
+
+
+#
+
+
+def cached_property(fn=None, *, transient=False, **kwargs):  # noqa
+    if fn is None:
+        return functools.partial(cached_property, transient=transient, **kwargs)
+    if transient:
+        return _TransientCachedProperty(fn, **kwargs)
+    else:
+        return _DictCachedProperty(fn, **kwargs)

omlish/lang/classes/__init__.py

@@ -1,41 +0,0 @@
-from .abstract import (  # noqa
-    Abstract,
-    AbstractTypeError,
-    get_abstract_methods,
-    is_abstract,
-    is_abstract_class,
-    is_abstract_method,
-    make_abstract,
-    unabstract_class,
-)
-
-from .restrict import (  # noqa
-    AnySensitive,
-    Final,
-    FinalTypeError,
-    NoBool,
-    NotInstantiable,
-    NotPicklable,
-    PackageSealed,
-    SENSITIVE_ATTR,
-    Sealed,
-    SealedError,
-    Sensitive,
-    no_bool,
-)
-
-from .simple import (  # noqa
-    LazySingleton,
-    Marker,
-    Namespace,
-    SimpleMetaDict,
-    Singleton,
-)
-
-from .virtual import (  # noqa
-    Callable,
-    Descriptor,
-    Picklable,
-    Virtual,
-    virtual_check,
-)

omlish/lang/collections.py

@@ -0,0 +1,50 @@
+import collections.abc
+import typing as ta
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+def yield_dict_init(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterable[tuple[ta.Any, ta.Any]]:
+    if len(args) > 1:
+        raise TypeError
+    if args:
+        [src] = args
+        if isinstance(src, collections.abc.Mapping):
+            for k in src:
+                yield (k, src[k])
+        else:
+            for k, v in src:
+                yield (k, v)
+    for k, v in kwargs.items():
+        yield (k, v)
+
+
+def merge_dicts(
+        *dcts: ta.Mapping[K, V],
+        pair_fn: ta.Callable[[K, V], tuple[K, V] | None] | None = None,
+        conflict_fn: ta.Callable[[K, V, V], tuple[K, V] | None] | None = None,
+) -> dict[K, V]:
+    out: dict[K, V] = {}
+
+    for d in dcts:
+        for k_v in d.items():
+            if pair_fn is not None and (k_v := pair_fn(*k_v)) is None:  # type: ignore[assignment]
+                continue
+
+            k, v = k_v
+            if k in out:
+                if conflict_fn is None:
+                    raise KeyError(k)
+
+                if (k_v := conflict_fn(k, out[k], v)) is None:  # type: ignore[assignment]
+                    continue
+                k, v = k_v
+
+            out[k] = v
+
+    return out

omlish/marshal/__init__.py

@@ -28,6 +28,16 @@ from .base import (  # noqa
     ReflectOverride,
 )
 
+from .composite.iterables import (  # noqa
+    IterableMarshaler,
+    IterableUnmarshaler,
+)
+
+from .composite.wrapped import (  # noqa
+    WrappedMarshaler,
+    WrappedUnmarshaler,
+)
+
 from .exceptions import (  # noqa
     ForbiddenTypeError,
     MarshalError,
@@ -49,6 +59,14 @@ from .naming import (  # noqa
     translate_name,
 )
 
+from .objects.dataclasses import (  # noqa
+    AbstractDataclassFactory,
+    DataclassMarshalerFactory,
+    DataclassUnmarshalerFactory,
+    get_dataclass_field_infos,
+    get_dataclass_metadata,
+)
+
 from .objects.helpers import (  # noqa
     update_field_metadata,
     update_fields_metadata,
@@ -75,14 +93,18 @@ from .objects.unmarshal import (  # noqa
 )
 
 from .polymorphism.marshal import (  # noqa
+    PolymorphismMarshaler,
     PolymorphismMarshalerFactory,
     make_polymorphism_marshaler,
 )
 
 from .polymorphism.metadata import (  # noqa
+    FieldTypeTagging,
     Impl,
     Impls,
     Polymorphism,
+    TypeTagging,
+    WrapperTypeTagging,
     polymorphism_from_subclasses,
 )
 
@@ -97,6 +119,7 @@ from .polymorphism.unions import (  # noqa
 )
 
 from .polymorphism.unmarshal import (  # noqa
+    PolymorphismUnmarshaler,
     PolymorphismUnmarshalerFactory,
     make_polymorphism_unmarshaler,
 )

omlish/marshal/composite/wrapped.py

@@ -0,0 +1,26 @@
+import dataclasses as dc
+import typing as ta
+
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..values import Value
+
+
+@dc.dataclass(frozen=True)
+class WrappedMarshaler(Marshaler):
+    wrapper: ta.Callable[[MarshalContext, ta.Any], ta.Any]
+    m: Marshaler
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        return self.m.marshal(ctx, self.wrapper(ctx, o))
+
+
+@dc.dataclass(frozen=True)
+class WrappedUnmarshaler(Unmarshaler):
+    unwrapper: ta.Callable[[UnmarshalContext, ta.Any], ta.Any]
+    u: Unmarshaler
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return self.unwrapper(ctx, self.u.unmarshal(ctx, v))