omlish 0.0.0.dev452__py3-none-any.whl → 0.0.0.dev453__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev452'
-__revision__ = '85534912bc13f26aa289d4d012b6bf27695609c5'
+__version__ = '0.0.0.dev453'
+__revision__ = '66cf981e193780bd726e2a5ea06dd1ac590f7298'
 
 
 #

omlish/collections/__init__.py

@@ -6,6 +6,11 @@ from .. import lang as _lang
 with _lang.auto_proxy_init(globals()):
     ##
 
+    from .attrregistry import (  # noqa
+        AttrRegistry,
+        AttrRegistryCache,
+    )
+
     from .bimap import (  # noqa
         BiMap,
 
@@ -64,9 +69,10 @@ with _lang.auto_proxy_init(globals()):
     from . import kv  # noqa
 
     from .mappings import (  # noqa
+        DynamicTypeMap,
         MissingDict,
         TypeMap,
-        DynamicTypeMap,
+        dict_factory,
         guarded_map_update,
         multikey_dict,
     )

omlish/collections/attrregistry.py

@@ -0,0 +1,182 @@
+import dataclasses as dc
+import typing as ta
+import weakref
+
+from .. import check
+from .. import lang
+from .mappings import dict_factory
+
+
+T = ta.TypeVar('T')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+class AttrRegistry(ta.Generic[K, V]):
+    """
+    MRO-honoring class member registry. There are many ways to do this, and this one is attr name based: a class is
+    considered to have objects registered to it based on whether or not they are accessible by a non-shadowed,
+    MRO-resolved named attribute on that class.
+
+    Care must be taken when overriding registered objects from superclasses in subclasses - shadowing the attribute name
+    of the superclass member will not automatically register the new member with the same name to the registry - it must
+    be explicitly registered itself. This is a feature, allowing for selective de-registration of objects in subclasses
+    via name shadowing.
+    """
+
+    def __init__(
+            self,
+            *,
+            requires_override: bool = False,
+            is_override: ta.Callable[[ta.Any], bool] | None = None,
+            forbid_duplicates: bool = False,
+            identity: bool = False,
+            weak: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._requires_override = requires_override
+        self._is_override = is_override
+        self._forbid_duplicates = forbid_duplicates
+        self._identity = identity
+        self._weak = weak
+
+        self._objs: ta.MutableMapping[K, V] = dict_factory(identity=identity, weak=weak)()
+        self._invalidate_callbacks: list[ta.Callable[[], None]] = []
+
+    def add_invalidate_callback(self, callback: ta.Callable[[], None]) -> None:
+        self._invalidate_callbacks.append(callback)
+
+    def register(self, obj: K, val: V) -> None:
+        check.not_in(obj, self._objs)
+
+        self._objs[obj] = val
+
+        for iv in self._invalidate_callbacks:
+            iv()
+
+    def _lookup(self, obj: ta.Any) -> lang.Maybe[V]:
+        if not self._identity:
+            try:
+                hash(obj)
+            except TypeError:
+                return lang.empty()
+
+        try:
+            val = self._objs[obj]
+        except KeyError:
+            return lang.empty()
+        else:
+            return lang.just(val)
+
+    @dc.dataclass()
+    class DuplicatesForbiddenError(Exception):
+        owner_cls: type
+        instance_cls: type
+        att: str
+        ex_att: str
+
+    def collect(self, instance_cls: type, owner_cls: type | None = None) -> dict[str, tuple[K, V]]:
+        if owner_cls is None:
+            owner_cls = instance_cls
+
+        mro = instance_cls.__mro__[-2::-1]
+        try:
+            mro_pos = mro.index(owner_cls)
+        except ValueError:
+            raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}') from None
+
+        mro_dct: dict[str, list[tuple[type, ta.Any]]] = {}
+        for cur_cls in mro[:mro_pos + 1]:
+            for att, obj in cur_cls.__dict__.items():
+                if att not in mro_dct:
+                    if not self._lookup(obj).present:
+                        continue
+
+                try:
+                    lst = mro_dct[att]
+                except KeyError:
+                    lst = mro_dct[att] = []
+                lst.append((cur_cls, obj))
+
+        #
+
+        seen: ta.MutableMapping[ta.Any, str] | None = None
+        if self._forbid_duplicates:
+            seen = dict_factory(identity=self._identity)()
+
+        out: dict[str, tuple[K, V]] = {}
+        for att, lst in mro_dct.items():
+            if not lst:
+                raise RuntimeError
+            _, obj = lst[-1]
+
+            if len(lst) > 1:
+                if self._requires_override and not (self._is_override or lang.is_override)(obj):
+                    raise lang.RequiresOverrideError(
+                        att,
+                        instance_cls,
+                        lst[-1][0],
+                        lst[0][0],
+                    )
+
+            if not (mv := self._lookup(obj)).present:
+                continue
+
+            if seen is not None:
+                try:
+                    ex_att = seen[obj]
+                except KeyError:
+                    pass
+                else:
+                    raise AttrRegistry.DuplicatesForbiddenError(owner_cls, instance_cls, att, ex_att)  # noqa
+                seen[obj] = att
+
+            out[att] = (obj, mv.must())
+
+        return out
+
+
+##
+
+
+class AttrRegistryCache(ta.Generic[K, V, T]):
+    def __init__(
+            self,
+            registry: AttrRegistry[K, V],
+            prepare: ta.Callable[[type, dict[str, tuple[K, V]]], T],
+    ) -> None:
+        super().__init__()
+
+        self._registry = registry
+        self._prepare = prepare
+
+        self._cache: dict[ta.Any, T] = {}
+
+        def cache_remove(k, self_ref=weakref.ref(self)):
+            if (ref_self := self_ref()) is not None:
+                cache = ref_self._cache  # noqa
+                try:
+                    del cache[k]
+                except KeyError:
+                    pass
+
+        self._cache_remove = cache_remove
+
+        registry.add_invalidate_callback(self._cache.clear)
+
+    def get(self, instance_cls: type) -> T:
+        cls_ref = weakref.ref(instance_cls)
+        try:
+            return self._cache[cls_ref]
+        except KeyError:
+            pass
+        del cls_ref
+
+        collected = self._registry.collect(instance_cls)
+        out = self._prepare(instance_cls, collected)
+        self._cache[weakref.ref(instance_cls, self._cache_remove)] = out
+        return out

omlish/collections/mappings.py

@@ -1,6 +1,12 @@
 import typing as ta
 import weakref
 
+from .. import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import identity as _identity
+
 
 T = ta.TypeVar('T')
 K = ta.TypeVar('K')
@@ -141,3 +147,22 @@ class MissingDict(dict[K, V]):
     def __missing__(self, key):
         v = self[key] = self._missing_fn(key)
         return v
+
+
+##
+
+
+def dict_factory[K, V](
+        *,
+        identity: bool = False,
+        weak: bool = False,
+) -> ta.Callable[..., ta.MutableMapping[K, V]]:
+    if identity:
+        if weak:
+            return _identity.IdentityWeakKeyDictionary
+        else:
+            return _identity.IdentityKeyDict
+    elif weak:
+        return weakref.WeakKeyDictionary
+    else:
+        return dict

omlish/dispatch/methods.py

@@ -4,13 +4,11 @@ TODO:
  - ALT: A.f(super(), ... ? :/
  - classmethod/staticmethod
 """
-import contextlib
 import functools
 import typing as ta
-import weakref
 
 from .. import check
-from .. import lang
+from .. import collections as col
 from .dispatch import Dispatcher
 from .impls import get_impl_func_cls_set
 
@@ -34,9 +32,8 @@ class Method(ta.Generic[P, R]):
     it must be explicitly `@register`'ed itself. This is a feature, allowing for selective de-registration of
     implementations in subclasses via name shadowing.
 
-    Methods have ability to choose to allow external installation of implementations outside of direct subclasses. This
-    is to be used *extremely* rarely - basically only in the rare case of externally extensible type hierarchies with
-    visitors.
+    Methods can choose to allow external installation of implementations outside of direct subclasses. This is to be
+    used *extremely* rarely - basically only in the rare case of externally extensible type hierarchies with visitors.
     """
 
     def __init__(
@@ -45,6 +42,7 @@ class Method(ta.Generic[P, R]):
             *,
             installable: bool = False,
             requires_override: bool = False,
+            instance_cache: bool = False,
     ) -> None:
         super().__init__()
 
@@ -53,9 +51,16 @@ class Method(ta.Generic[P, R]):
 
         self._func = func
         self._installable = installable
-        self._requires_override = requires_override
+        self._instance_cache = instance_cache
 
-        self._impls: ta.MutableMapping[ta.Callable, frozenset[type] | None] = weakref.WeakKeyDictionary()
+        self._registry: col.AttrRegistry[ta.Callable, Method._Entry] = col.AttrRegistry(
+            requires_override=requires_override,
+        )
+
+        self._cache: col.AttrRegistryCache[ta.Callable, Method._Entry, ta.Callable] = col.AttrRegistryCache(
+            self._registry,
+            self._prepare,
+        )
 
         # bpo-45678: special-casing for classmethod/staticmethod in Python <=3.9, as functools.update_wrapper doesn't
         # work properly in singledispatchmethod.__get__ if it is applied to an unbound classmethod/staticmethod
@@ -68,19 +73,12 @@ class Method(ta.Generic[P, R]):
         self._is_abstractmethod = getattr(func, '__isabstractmethod__', False)  # noqa
         self.update_wrapper(self)
 
-        self._dispatch_func_cache: dict[ta.Any, ta.Callable] = {}
-
-        def dispatch_func_cache_remove(k, self_ref=weakref.ref(self)):
-            if (ref_self := self_ref()) is not None:
-                cache = ref_self._dispatch_func_cache  # noqa
-                with contextlib.suppress(KeyError):
-                    del cache[k]
-
-        self._dispatch_func_cache_remove = dispatch_func_cache_remove
-
         self._owner: type | None = None
         self._name: str | None = None
 
+    class _Entry:
+        cls_set: frozenset[type]
+
     def __set_name__(self, owner, name):
         if self._owner is None:
             self._owner = owner
@@ -102,83 +100,29 @@ class Method(ta.Generic[P, R]):
 
     def register(self, impl: T, cls_set: frozenset[type] | None = None) -> T:
         check.callable(impl)
-        if impl not in self._impls:
-            self._impls[impl] = cls_set  # type: ignore
-            self._dispatch_func_cache.clear()
-
-        return impl
-
-    def _is_impl(self, obj: ta.Any) -> bool:
-        try:
-            hash(obj)
-        except TypeError:
-            return False
-
-        return obj in self._impls
 
-    def build_attr_dispatcher(self, instance_cls: type, owner_cls: type | None = None) -> Dispatcher[str]:
-        if owner_cls is None:
-            owner_cls = instance_cls
+        entry = Method._Entry()
+        if cls_set is not None:
+            entry.cls_set = cls_set
 
-        mro = instance_cls.__mro__[-2::-1]
-        try:
-            mro_pos = mro.index(owner_cls)
-        except ValueError:
-            raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}') from None
+        self._registry.register(ta.cast(ta.Callable, impl), entry)
 
-        mro_dct: dict[str, list[tuple[type, ta.Any]]] = {}
-        for cur_cls in mro[:mro_pos + 1]:
-            for att, obj in cur_cls.__dict__.items():
-                if att not in mro_dct:
-                    if not self._is_impl(obj):
-                        continue
-
-                try:
-                    lst = mro_dct[att]
-                except KeyError:
-                    lst = mro_dct[att] = []
-                lst.append((cur_cls, obj))
-
-        #
+        return impl
 
+    def _build_dispatcher(self, collected: ta.Mapping[str, tuple[ta.Callable, _Entry]]) -> Dispatcher[str]:
         disp: Dispatcher[str] = Dispatcher()
 
-        seen: dict[ta.Any, str] = {}
-        for att, lst in mro_dct.items():
-            if not lst:
-                raise RuntimeError
-            _, obj = lst[-1]
-
-            if len(lst) > 1:
-                if self._requires_override and not lang.is_override(obj):
-                    raise lang.RequiresOverrideError(
-                        att,
-                        instance_cls,
-                        lst[-1][0],
-                        lst[0][0],
-                    )
-
-            if not self._is_impl(obj):
-                continue
-
-            cls_set = self._impls[obj]
-            if cls_set is None:
-                cls_set = get_impl_func_cls_set(obj, arg_offset=1)
-                self._impls[obj] = cls_set
-
+        for a, (f, e) in collected.items():
             try:
-                ex_att = seen[obj]
-            except KeyError:
-                pass
-            else:
-                raise TypeError(f'Duplicate impl: {owner_cls} {instance_cls} {att} {ex_att}')
-            seen[obj] = att
+                cls_set = e.cls_set
+            except AttributeError:
+                cls_set = e.cls_set = get_impl_func_cls_set(f, arg_offset=1)
 
-            disp.register(att, cls_set)
+            disp.register(a, cls_set)
 
         return disp
 
-    def build_dispatch_func(self, disp: Dispatcher[str]) -> ta.Callable:
+    def _build_dispatch_func(self, disp: Dispatcher[str]) -> ta.Callable:
         dispatch = disp.dispatch
         type_ = type
         getattr_ = getattr
@@ -190,25 +134,16 @@ class Method(ta.Generic[P, R]):
                 raise TypeError(f'{func_name} requires at least 1 positional argument')
 
             if (impl_att := dispatch(type_(args[0]))) is not None:
-                fn = getattr_(self, impl_att)
-                return fn(*args, **kwargs)
+                return getattr_(self, impl_att)(*args, **kwargs)
 
             return base_func.__get__(self)(*args, **kwargs)  # noqa
 
         self.update_wrapper(__call__)
         return __call__
 
-    def get_dispatch_func(self, instance_cls: type) -> ta.Callable:
-        cls_ref = weakref.ref(instance_cls)
-        try:
-            return self._dispatch_func_cache[cls_ref]
-        except KeyError:
-            pass
-        del cls_ref
-
-        att_disp = self.build_attr_dispatcher(instance_cls)
-        func = self.build_dispatch_func(att_disp)
-        self._dispatch_func_cache[weakref.ref(instance_cls, self._dispatch_func_cache_remove)] = func
+    def _prepare(self, instance_cls: type, collected: ta.Mapping[str, tuple[ta.Callable, _Entry]]) -> ta.Callable:
+        disp = self._build_dispatcher(collected)
+        func = self._build_dispatch_func(disp)
         return func
 
     def __get__(self, instance, owner=None):
@@ -216,16 +151,21 @@ class Method(ta.Generic[P, R]):
             # FIXME: classmethod/staticmethod
             return self
 
-        instance_cls = type(instance)
-        try:
-            func = self._dispatch_func_cache[weakref.ref(instance_cls)]
-        except KeyError:
-            func = self.get_dispatch_func(instance_cls)
-        return func.__get__(instance, owner)  # noqa
+        if self._instance_cache:
+            try:
+                return instance.__dict__[self._name]
+            except KeyError:
+                pass
+
+        bound = self._cache.get(type(instance)).__get__(instance, owner)  # noqa
+
+        if self._instance_cache:
+            instance.__dict__[self._name] = bound
+
+        return bound
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
         instance, *rest = args
-        instance_cls = type(instance)
 
         # if instance_cls is super:
         #     owner = instance.__self_class__.__mro__[instance.__self_class__.__mro__.index(instance.__thisclass__) + 1]
@@ -233,55 +173,25 @@ class Method(ta.Generic[P, R]):
         #     func = self.build_dispatch_func(att_disp)
         #     return func.__get__(instance, instance.__thisclass__)(*rest, **kwargs)
 
-        try:
-            func = self._dispatch_func_cache[weakref.ref(instance_cls)]
-        except KeyError:
-            func = self.get_dispatch_func(instance_cls)
-        return func.__get__(instance)(*rest, **kwargs)  # noqa
+        return self.__get__(instance)(*rest, **kwargs)
 
 
 ##
 
 
-@ta.overload
-def method(
-        func: ta.Callable[P, R],
-        /,
-        *,
-        installable: bool = False,
-        requires_override: bool = False,
-) -> Method[P, R]:  # noqa
-    ...
-
-
-@ta.overload
 def method(
-        func: None = None,
-        /,
         *,
         installable: bool = False,
         requires_override: bool = False,
+        instance_cache: bool = False,
 ) -> ta.Callable[[ta.Callable[P, R]], Method[P, R]]:  # noqa
-    ...
-
-
-def method(
-        func=None,
-        /,
-        *,
-        installable=False,
-        requires_override=False,
-):
-    kw = dict(
+    return functools.partial(
+        Method,  # type: ignore[arg-type]
         installable=installable,
         requires_override=requires_override,
+        instance_cache=instance_cache,
     )
 
-    if func is None:
-        return functools.partial(Method, **kw)
-
-    return Method(func, **kw)
-
 
 #
 
@@ -305,7 +215,7 @@ def install_method(
         if on is None:
             cls = owner
         else:
-            cls = check.issubclass(on, owner)
+            cls = check.issubclass(on, owner)  # noqa
 
         check.arg(not hasattr(cls, a))
         setattr(cls, a, fn)

omlish/dom/rendering.py

@@ -100,7 +100,7 @@ class Renderer:
 
     #
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def render(self, o: ta.Any) -> None:
         raise TypeError(o)
 

omlish/funcs/guard.py

@@ -0,0 +1,214 @@
+import abc
+import functools
+import operator
+import typing as ta
+
+from .. import check
+from .. import collections as col
+from .. import lang
+
+
+T = ta.TypeVar('T')
+T_co = ta.TypeVar('T_co', covariant=True)
+U = ta.TypeVar('U')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+class GuardFn(ta.Protocol[P, T_co]):
+    def __get__(self, instance, owner=None) -> ta.Self: ...
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T_co] | None: ...
+
+
+##
+
+
+@ta.final
+class DumbGuardFn(ta.Generic[P, T]):
+    def __init__(self, fn: ta.Callable[P, T]) -> None:
+        self._fn = fn
+
+    def __get__(self, instance, owner=None):
+        return DumbGuardFn(self._fn.__get__(instance, owner))  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T]:
+        return functools.partial(self._fn, *args, **kwargs)
+
+
+dumb = DumbGuardFn
+
+
+##
+
+
+class AmbiguousGuardFnError(Exception):
+    pass
+
+
+@ta.final
+class MultiGuardFn(ta.Generic[P, T]):
+    def __init__(
+            self,
+            *children: GuardFn[P, T],
+            strict: bool = False,
+    ) -> None:
+        self._children, self._strict = children, strict
+
+    def __get__(self, instance, owner=None):
+        return MultiGuardFn(*map(operator.methodcaller('__get__', instance, owner), self._children), strict=self._strict)  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T] | None:
+        matches = []
+        for c in self._children:
+            if (m := c(*args, **kwargs)) is not None:
+                if not self._strict:
+                    return m
+                matches.append(m)
+        if not matches:
+            return None
+        elif len(matches) > 1:
+            raise AmbiguousGuardFnError
+        else:
+            return matches[0]
+
+
+multi = MultiGuardFn
+
+
+##
+
+
+class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
+    def __init__(
+            self,
+            *,
+            strict: bool = False,
+            requires_override: bool = False,
+            instance_cache: bool = False,
+            prototype: ta.Callable[P, T] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._strict = strict
+        self._instance_cache = instance_cache
+        self._prototype = prototype
+
+        self._registry: col.AttrRegistry[ta.Callable, None] = col.AttrRegistry(
+            requires_override=requires_override,
+        )
+
+        self._cache: col.AttrRegistryCache[ta.Callable, None, MultiGuardFn] = col.AttrRegistryCache(
+            self._registry,
+            self._prepare,
+        )
+
+    _owner: type | None = None
+    _name: str | None = None
+
+    def __set_name__(self, owner, name):
+        if self._owner is None:
+            self._owner = owner
+        if self._name is None:
+            self._name = name
+
+    def register(self, fn: U) -> U:
+        check.callable(fn)
+        self._registry.register(ta.cast(ta.Callable, fn), None)
+        return fn
+
+    def _prepare(self, instance_cls: type, collected: ta.Mapping[str, tuple[ta.Callable, None]]) -> MultiGuardFn:
+        return MultiGuardFn(
+            *[getattr(instance_cls, a) for a in collected],
+            strict=self._strict,
+        )
+
+    @abc.abstractmethod
+    def _bind(self, instance, owner):
+        raise NotImplementedError
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+
+        if self._instance_cache:
+            try:
+                return instance.__dict__[self._name]
+            except KeyError:
+                pass
+
+        bound = self._bind(instance, owner)
+
+        if self._instance_cache:
+            instance.__dict__[self._name] = bound
+
+        return bound
+
+    def _call(self, *args, **kwargs):
+        instance, *rest = args
+        return self.__get__(instance)(*rest, **kwargs)
+
+#
+
+
+class GuardFnMethod(_BaseGuardFnMethod[P, T]):
+    def _bind(self, instance, owner):
+        return self._cache.get(type(instance)).__get__(instance, owner)  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T] | None:
+        return self._call(*args, **kwargs)
+
+
+def method(
+        *,
+        strict: bool = False,
+        requires_override: bool = False,
+        instance_cache: bool = False,
+) -> ta.Callable[[ta.Callable[P, T]], GuardFnMethod[P, T]]:  # noqa
+    def inner(fn):
+        return GuardFnMethod(
+            strict=strict,
+            requires_override=requires_override,
+            instance_cache=instance_cache,
+            prototype=fn,
+        )
+
+    return inner
+
+
+#
+
+
+class DumbGuardFnMethod(_BaseGuardFnMethod[P, T]):
+    def _bind(self, instance, owner):
+        gf = self._cache.get(type(instance)).__get__(instance, owner)  # noqa
+        x = self._prototype.__get__(instance, owner)  # type: ignore
+
+        def inner(*args, **kwargs):
+            if (m := gf(*args, **kwargs)) is not None:
+                return m()
+            return x(*args, **kwargs)
+
+        return inner
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self._call(*args, **kwargs)
+
+
+def dumb_method(
+        *,
+        strict: bool = False,
+        requires_override: bool = False,
+        instance_cache: bool = False,
+) -> ta.Callable[[ta.Callable[P, T]], DumbGuardFnMethod[P, T]]:  # noqa
+    def inner(fn):
+        return DumbGuardFnMethod(
+            strict=strict,
+            requires_override=requires_override,
+            instance_cache=instance_cache,
+            prototype=fn,
+        )
+
+    return inner

omlish/graphs/dot/rendering.py

@@ -29,7 +29,7 @@ class Renderer:
 
         self._out = out
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def render(self, item: Item) -> None:
         raise TypeError(item)
 

omlish/lite/maybes.py

@@ -1,6 +1,7 @@
 # ruff: noqa: UP007 UP045
 import abc
 import functools
+import operator
 import typing as ta
 
 from .abstract import Abstract
@@ -208,3 +209,10 @@ class _EmptyMaybe(_Maybe[T]):
 
 
 Maybe._empty = _EmptyMaybe()  # noqa
+
+
+##
+
+
+setattr(Maybe, 'just', _JustMaybe)  # noqa
+setattr(Maybe, 'empty', functools.partial(operator.attrgetter('_empty'), Maybe))

omlish/sql/queries/rendering.py

@@ -81,7 +81,7 @@ class Renderer(lang.Abstract):
     def args(self) -> lang.Args:
         return self._params_preparer.prepare()
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def render(self, o: ta.Any) -> tp.Part:
         raise TypeError(o)
 

omlish/text/parts.py

@@ -75,7 +75,7 @@ class PartTransform:
     def __call__(self, part: Part | None) -> Part:
         return self._transform(part)
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def _transform(self, part: Part | None) -> Part:
         raise TypeError(part)
 
@@ -214,7 +214,7 @@ class PartRenderer:
     def __call__(self, part: Part | None) -> None:
         return self._render(part)
 
-    @dispatch.method
+    @dispatch.method()
     def _render(self, part: Part | None) -> None:
         raise TypeError(part)
 

{omlish-0.0.0.dev452.dist-info → omlish-0.0.0.dev453.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev452
+Version: 0.0.0.dev453
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev452.dist-info → omlish-0.0.0.dev453.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.omlish-manifests.json,sha256=FLw7xkPiSXuImZgqSP8BwrEib2R1doSzUPLUkc-QUIA,8410
-omlish/__about__.py,sha256=Ia-k2mCoU1psSy7-YOmB-XdT8JnxIXK5ICScX_nTpxs,3613
+omlish/__about__.py,sha256=UyBs9jXm7W7VwfekZgY2BWyGcs6fJ0_zJqOMdeCn8aY,3613
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ZNIMl1kwg3qdei4DiUrJPQe5M81S1e76N-GuNSwLBAE,8683
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -64,14 +64,15 @@ omlish/codecs/funcs.py,sha256=or0Jogczuzk7csDTRl-HURMEjl8LXXqxxXYK45xcM5w,855
 omlish/codecs/registry.py,sha256=y7gjhBY1tTTHZmaK4X02zL5HD_25AAiZ8k27Op69Ag0,4006
 omlish/codecs/standard.py,sha256=eiZ4u9ep0XrA4Z_D1zJI0vmWyuN8HLrX4Se_r_Cq_ZM,60
 omlish/codecs/text.py,sha256=P9-xpdiQE3nbI5CzEentf07FBHPzD7_SwOtUQUJ01So,5710
-omlish/collections/__init__.py,sha256=BIc806ri5Eq-kR03Ya2YfYTRI0g1rn_0haQPUqxXqys,2816
+omlish/collections/__init__.py,sha256=cSNZ670-GaNW_sCazmLi41HPx5tfzMvkHCvPoyebTEY,2934
 omlish/collections/abc.py,sha256=p9zhL5oNV5WPyWmMn34fWfkuxPQAjOtL7WQA-Xsyhwk,2628
+omlish/collections/attrregistry.py,sha256=SPvIt8rT8nWvEBqf35I8wPgBU55m0u2ssSmNcYHm_FM,5563
 omlish/collections/bimap.py,sha256=3szDCscPJlFRtkpyVQNWneg4s50mr6Rd0jdTzVEIcnE,1661
 omlish/collections/coerce.py,sha256=tAls15v_7p5bUN33R7Zbko87KW5toWHl9fRialCqyNY,7030
 omlish/collections/frozen.py,sha256=drarjcMFpwKhBM01b1Gh6XDcaRaUgpyuxEiqppaKRkU,4220
 omlish/collections/hasheq.py,sha256=uHypfZlHhicQPvx9OOlpT9MSLwfc_mFil-WaxF9dTOo,3732
 omlish/collections/identity.py,sha256=00UAYIjCRhyj73Es0jVNvOloXjRxHcjRxGQeWo75OEo,4834
-omlish/collections/mappings.py,sha256=FWDErWR63y3xcjBfxXH58M1yOAqCdMyFWwzBjGAE7UQ,3346
+omlish/collections/mappings.py,sha256=c3ojUN9Ca3oGfmMXSFkDQYou5J15obDfgjCvzq3Url4,3833
 omlish/collections/multimaps.py,sha256=azuif-PeLGvLpCE9_XX5zYx7XtVbsulWq0owvEKNy_g,3897
 omlish/collections/ordered.py,sha256=jBSj5CamdKJAezXM8GlRd7jjaRDk6BHIeOhlxcC9lJI,2468
 omlish/collections/ranked.py,sha256=McB8C2UQfUvrbmxGTpBz1-EZuyCLkBFtktzncMdt8_Y,2287
@@ -217,7 +218,7 @@ omlish/dispatch/__init__.py,sha256=UwVT6SSk5HKk9xF9vc_UJD8BDSIQWSw98Ldx-G-6PC0,1
 omlish/dispatch/dispatch.py,sha256=TzWihCt9Zr8wfIwVpKHVOOrYFVKpDXRevxYomtEfqYc,3176
 omlish/dispatch/functions.py,sha256=cwNzGIg2ZIalEgn9I03cnJVbMTHjWloyDTaowlO3UPs,1524
 omlish/dispatch/impls.py,sha256=3kyLw5yiYXWCN1DiqQbD1czMVrM8v1mpQ8NyD0tUrnk,1870
-omlish/dispatch/methods.py,sha256=RJ-gLF2UdCQKZFhiuV4R1N3lRB_dMH3ItiHwmm-s62o,9873
+omlish/dispatch/methods.py,sha256=aberuaB1ujTwhTdTyZQ2j4azNVkO54nEc28k5ZQ--J4,7337
 omlish/docker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/docker/all.py,sha256=t5jBNZAzqCoB05-nwCuSZ6C3PBEBD6T3wsIJvIXJaRg,576
 omlish/docker/cli.py,sha256=ws3ypayxdnp3nWeLww45jHG0Vwr5e4bUbLTqkpejAhc,2570
@@ -232,7 +233,7 @@ omlish/docker/timebomb.py,sha256=EnFt8pJeXkowF_F5NXnN0ogDmxUmVymV4h1CYPwyJr4,356
 omlish/dom/__init__.py,sha256=RYkv9inuebWIKsRuPXr3j0njgLFKzIo-ujKc4JEp0wc,301
 omlish/dom/building.py,sha256=VPMbGxv730dYjS_jlrrp0qiZhuGT8OheFamUAgtQdF4,1022
 omlish/dom/content.py,sha256=1NkE1eb0ITfps-yJ-Lbtm6kGnvUmQy6HWo01gnvSkiU,2775
-omlish/dom/rendering.py,sha256=5cQK3A_uifh3Th5v3c0nx-tW8d1KyGL6C9tASPaNVNI,4336
+omlish/dom/rendering.py,sha256=zypSFpZO0pBfPY_ZJXeywovu0pbEtQzLYzn6TZfpRlk,4357
 omlish/formats/__init__.py,sha256=T0AG1gFnqQ5JiHN0UPQjQ-7g5tnxMIG-mgOvMYExYAM,21
 omlish/formats/cbor.py,sha256=o_Hbe4kthO9CeXK-FySrw0dHVlrdyTo2Y8PpGRDfZ3c,514
 omlish/formats/cloudpickle.py,sha256=16si4yUp_pAdDWGECAWf6HLA2PwSANGGgDoMLGZUem8,579
@@ -287,6 +288,7 @@ omlish/formats/toml/writer.py,sha256=9NT8sRy3I9KubxFx56Qbislvrdtbd23rEuBT-GSdUYA
 omlish/funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/funcs/builders.py,sha256=ZSBQS2xqriXp5x0t074EEZvuTmMp4Yue2YGBoTLAioo,4044
 omlish/funcs/genmachine.py,sha256=BOxO1OTjxZ7ewv_WpqYkY8bwlGQIJIjwjvYMflEFa_M,2571
+omlish/funcs/guard.py,sha256=vrsUtaGJj-eCOkfjxlHV9lw5qDLimiHOW4X0LINDKmk,5495
 omlish/funcs/match.py,sha256=cBtG7kdpWdxvHwlte5CWlBxXSoJSV48joV4bwJJC3pk,6352
 omlish/funcs/pairs.py,sha256=XhYTJdqooAJKeoGZmEaiKYeFRq5-Dj2_y92IdBl_C20,4371
 omlish/funcs/pipes.py,sha256=E1dQZMBmgT2qautG1vEqy5v3QBsO2Nzryv33j4YAngA,2520
@@ -297,7 +299,7 @@ omlish/graphs/trees.py,sha256=r_kZw-83c1KXe7fida-CVWNGDX9quPTmhAjJ5I5uKRc,8198
 omlish/graphs/dot/__init__.py,sha256=Y1MZRQBZkcYyG1Tn7K2FhL8aYbm4v4tk6f5g9AqEkUw,359
 omlish/graphs/dot/items.py,sha256=GIzUqLHJPR4AVtF141uA8JnyybkRZx6mFYsNJHu_JVg,4087
 omlish/graphs/dot/make.py,sha256=e-M1IEdh4kHEjJmBxpaEUPxvFLrm5uIXdGxjQZr2HRo,365
-omlish/graphs/dot/rendering.py,sha256=IOCEEOqlsRctoIgnz1I9v0ycHHDAr5zYubTXT7v_YwA,3634
+omlish/graphs/dot/rendering.py,sha256=SGSpwswdFqsjEnznQDyryIsXE8bzPXSUFAJHlB2uT2Y,3655
 omlish/graphs/dot/utils.py,sha256=8cGKIdcM-w1q4ITUYyC0lnYwLqNWuH2OddmmbLxVgEo,806
 omlish/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/http/all.py,sha256=ChV0KcPN8CKcwlQiWqYyMvmjHuH9qhBsd2kV7-HrFto,1409
@@ -478,7 +480,7 @@ omlish/lite/imports.py,sha256=GyEDKL-WuHtdOKIL-cc8aFd0-bHwZFDEjAB52ItabX0,1341
 omlish/lite/inject.py,sha256=BQgjBj2mzJgMimLam-loSpQzcb31-8NYPVRQgHVv3cQ,29159
 omlish/lite/json.py,sha256=m0Ce9eqUZG23-H7-oOp8n1sf4fzno5vtK4AK_4Vc-Mg,706
 omlish/lite/marshal.py,sha256=oVqVwqTArFUj9lYhmKg_MVgnqlCAUvOnYgtU3bBu_bk,23020
-omlish/lite/maybes.py,sha256=sJ4dawgBxlZ4oB9dZ3bhBb_8AOJlIW0nVIFgFZ1huXE,4384
+omlish/lite/maybes.py,sha256=NCnMZaSbIfvOMqz69aYmmvZQDd0c61QjG3ju7uJc8t8,4531
 omlish/lite/maysync.py,sha256=Otd-xqWaMzY9xBF5SiLKxu4kG_GaWGk8qTGFDAHXDm4,14803
 omlish/lite/objects.py,sha256=HzN_4J6w6WDLKDrW8jSNUKgfAR5vUsB42rtSCu04oqQ,1921
 omlish/lite/pycharm.py,sha256=fdSTwtdqGRL0P9IkCrDAPqQkJsegq1NfYyVG2N6cy4w,1174
@@ -730,7 +732,7 @@ omlish/sql/queries/names.py,sha256=25kPRYse_ivI17lMD9st04k7QQMOGf5plb4b8yZFpUI,2
 omlish/sql/queries/ops.py,sha256=pDZ_2Jo_Fa8DDbtYkc6-9eehkWsZPI-jh-KFlubcY6Y,134
 omlish/sql/queries/params.py,sha256=ocjaJbhv_5LWgxdjoZg8vyAWDZxsij4cKH8Lx4hXMT0,1261
 omlish/sql/queries/relations.py,sha256=P0qBqNICyeig9sEZAYLZcTXcI1YFiBe6REm6jNhpHUI,2630
-omlish/sql/queries/rendering.py,sha256=3Ocw52DDDsUavEmb8xH-2Mhp-3pZCXsJVXFuVTOUBqk,7779
+omlish/sql/queries/rendering.py,sha256=Kc7GqLKnuzfeVv4MPTkjYb6-n4fTBLOKo4QjfPc-WBY,7800
 omlish/sql/queries/selects.py,sha256=XNisb2draHURYhbZsTFw7DJQaN1Zfo2Znm-Ty0lHNTo,1773
 omlish/sql/queries/std.py,sha256=FdJkXD7oiuj8mtVzvbsL1ZocEEAfaSdOsfTVB1YhtrE,699
 omlish/sql/queries/stmts.py,sha256=pBqwD7dRlqMu6uh6vR3xaWOEgbZCcFWbOQ9ryYd17T4,441
@@ -808,7 +810,7 @@ omlish/text/indent.py,sha256=BWVVaHs_B1ppwHJJIxKCDG3iCutkYy5e1qr59Z_Suzg,1524
 omlish/text/linecache.py,sha256=hRYlEhD63ZfA6_ZOTkQIcnON-3W56QMAhcG3vEJqj9M,1858
 omlish/text/mangle.py,sha256=k7mYavVgxJ2ENV2wfjw3c9u3hqH5NeVpjoxYbyaYC0Y,2796
 omlish/text/minja.py,sha256=7UKNalkWpTG_364OIo7p5ym--uiNPR2RFBW_W8rrO4I,9194
-omlish/text/parts.py,sha256=MpiCUyfpcL4PLb2Etj8V7Yj4qofhy0xVwBrIL6RfNdg,6646
+omlish/text/parts.py,sha256=MFi-ANxXlBiOMqW2y2S0BRg6xDwPYxSXSfrYPM3rtcE,6669
 omlish/text/random.py,sha256=8feS5JE_tSjYlMl-lp0j93kCfzBae9AM2cXlRLebXMA,199
 omlish/text/templating.py,sha256=i-HU7W-GtKdnBhEG3mnSey5ig7vV0q02D3pVzMoOzJY,3318
 omlish/text/go/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -823,9 +825,9 @@ omlish/typedvalues/marshal.py,sha256=TWwqiGROaQwcxglGiBt_t5D9AvlWsy3ELm7do-nPeao
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev452.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev452.dist-info/METADATA,sha256=6HeJlCFmWua6YWGrp4v6KNC037N-n4-CEcHqBzCBUqc,19003
-omlish-0.0.0.dev452.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev452.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev452.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev452.dist-info/RECORD,,
+omlish-0.0.0.dev453.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev453.dist-info/METADATA,sha256=2xNQ3KjE39xJl-eAkz-XOpj2tek1YFZnNCNmy_ZaYBk,19003
+omlish-0.0.0.dev453.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev453.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev453.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev453.dist-info/RECORD,,