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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev453'
-__revision__ = '66cf981e193780bd726e2a5ea06dd1ac590f7298'
+__version__ = '0.0.0.dev454'
+__revision__ = '59a1efb9c2d924f74345aa315eef7c197a2d3a91'
 
 
 #

omlish/collections/identity.py

@@ -105,6 +105,7 @@ class IdentityWeakKeyDictionary(ta.MutableMapping[K, V]):
 
     TODO:
      - audit for freethreaded
+      - leans on stdlib impls so shouldn't matter?
     """
 
     def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:

omlish/dataclasses/__init__.py

@@ -159,6 +159,8 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
         is_immediate_dataclass,
 
         dataclass_maybe_post_init as maybe_post_init,
+
+        dataclass_descriptor_method as descriptor_method,
     )
 
 

omlish/funcs/guard.py

@@ -18,7 +18,7 @@ P = ta.ParamSpec('P')
 
 
 class GuardFn(ta.Protocol[P, T_co]):
-    def __get__(self, instance, owner=None) -> ta.Self: ...
+    def __get__(self, instance, owner=None): ...
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T_co] | None: ...
 
@@ -53,12 +53,19 @@ class MultiGuardFn(ta.Generic[P, T]):
     def __init__(
             self,
             *children: GuardFn[P, T],
+            default: GuardFn[P, T] | None = None,
             strict: bool = False,
     ) -> None:
-        self._children, self._strict = children, strict
+        self._children, self._default, self._strict = children, default, strict
+
+    lang.attr_ops(lambda self: (
+        self._children,
+        self._default,
+        self._strict,
+    )).install(locals())
 
     def __get__(self, instance, owner=None):
-        return MultiGuardFn(*map(operator.methodcaller('__get__', instance, owner), self._children), strict=self._strict)  # noqa
+        return MultiGuardFn(*map(operator.methodcaller('__get__', instance, owner), self._children), default=self._default.__get__(instance, owner) if self._default is not None else None, strict=self._strict)  # noqa
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T] | None:
         matches = []
@@ -68,7 +75,10 @@ class MultiGuardFn(ta.Generic[P, T]):
                     return m
                 matches.append(m)
         if not matches:
-            return None
+            if (dfl := self._default) is not None:
+                return dfl(*args, **kwargs)
+            else:
+                return None
         elif len(matches) > 1:
             raise AmbiguousGuardFnError
         else:
@@ -88,13 +98,13 @@ class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
             strict: bool = False,
             requires_override: bool = False,
             instance_cache: bool = False,
-            prototype: ta.Callable[P, T] | None = None,
+            default: GuardFn[P, T] | None = None,
     ) -> None:
         super().__init__()
 
         self._strict = strict
         self._instance_cache = instance_cache
-        self._prototype = prototype
+        self._default = default
 
         self._registry: col.AttrRegistry[ta.Callable, None] = col.AttrRegistry(
             requires_override=requires_override,
@@ -122,6 +132,7 @@ class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
     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],
+            default=self._default,
             strict=self._strict,
         )
 
@@ -153,6 +164,7 @@ class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
 #
 
 
+@ta.final
 class GuardFnMethod(_BaseGuardFnMethod[P, T]):
     def _bind(self, instance, owner):
         return self._cache.get(type(instance)).__get__(instance, owner)  # noqa
@@ -166,13 +178,14 @@ def method(
         strict: bool = False,
         requires_override: bool = False,
         instance_cache: bool = False,
+        default: 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,
+            default=fn if default else None,
         )
 
     return inner
@@ -181,15 +194,13 @@ def method(
 #
 
 
-class DumbGuardFnMethod(_BaseGuardFnMethod[P, T]):
+@ta.final
+class ImmediateGuardFnMethod(_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 gf(*args, **kwargs)()  # Note: cannot be None due to non-optional default
 
         return inner
 
@@ -197,18 +208,18 @@ class DumbGuardFnMethod(_BaseGuardFnMethod[P, T]):
         return self._call(*args, **kwargs)
 
 
-def dumb_method(
+def immediate_method(
         *,
         strict: bool = False,
         requires_override: bool = False,
         instance_cache: bool = False,
-) -> ta.Callable[[ta.Callable[P, T]], DumbGuardFnMethod[P, T]]:  # noqa
+) -> ta.Callable[[ta.Callable[P, T]], ImmediateGuardFnMethod[P, T]]:  # noqa
     def inner(fn):
-        return DumbGuardFnMethod(
+        return ImmediateGuardFnMethod(
             strict=strict,
             requires_override=requires_override,
             instance_cache=instance_cache,
-            prototype=fn,
+            default=(lambda *args, **kwargs: lambda: fn(*args, **kwargs)),
         )
 
     return inner

omlish/lang/__init__.py

@@ -334,6 +334,7 @@ with _auto_proxy_init(globals(), update_exports=True):
         ilen,
         take,
         consume,
+        iterfrom,
         peek,
         chunk,
         interleave,

omlish/lang/iterables.py

@@ -26,6 +26,14 @@ def consume(it: ta.Iterable[ta.Any]) -> None:
     collections.deque(it, maxlen=0)
 
 
+def iterfrom(seq: ta.Sequence[T], start: int = 0, stop: int | None = None) -> ta.Iterator[T]:
+    if start < 0:
+        start += len(seq)
+    if stop is None:
+        stop = len(seq)
+    return map(seq.__getitem__, range(start, stop))
+
+
 def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
     it = iter(vs)
     v = next(it)

omlish/lite/attrops.py

@@ -6,6 +6,8 @@ TODO:
  - per-attr repr transform / filter
  - __ne__ ? cases where it still matters
  - ordering ?
+ - repr_filter: ta.Union[ta.Callable[[ta.Any], ta.Optional[str]], ta.Literal['not_none', 'truthy']]] ?
+  - unify repr/repr_fn/repr_filter
 """
 import types  # noqa
 import typing as ta

omlish/lite/dataclasses.py

@@ -100,6 +100,36 @@ def dataclass_repr_omit_falsey(obj: ta.Any) -> str:
 ##
 
 
+def dataclass_descriptor_method(*bind_attrs: str, bind_owner: bool = False) -> ta.Callable:
+    if not bind_attrs:
+        def __get__(self, instance, owner=None):  # noqa
+            return self
+
+    elif bind_owner:
+        def __get__(self, instance, owner=None):  # noqa
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    else:
+        def __get__(self, instance, owner=None):  # noqa
+            if instance is None:
+                return self
+
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    return __get__
+
+
+##
+
+
 def dataclass_kw_only_init():
     def inner(cls):
         if not isinstance(cls, type) and dc.is_dataclass(cls):

omlish/marshal/__init__.py

@@ -113,10 +113,15 @@ with _lang.auto_proxy_init(globals()):
         OptionalUnmarshaler,
     )
 
-    from .composite.unions import (  # noqa
-        MatchUnionMarshaler,
-        MatchUnionUnmarshaler,
+    from .composite.unions.literals import (  # noqa
+        LITERAL_UNION_TYPES,
+        LiteralUnionMarshaler,
+        LiteralUnionMarshalerFactory,
+        LiteralUnionUnmarshaler,
+        LiteralUnionUnmarshalerFactory,
+    )
 
+    from .composite.unions.primitives import (  # noqa
         PRIMITIVE_UNION_TYPES,
         PrimitiveUnionMarshaler,
         PrimitiveUnionMarshalerFactory,
@@ -129,14 +134,9 @@ with _lang.auto_proxy_init(globals()):
         WrappedUnmarshaler,
     )
 
-    from .factories.simple import (  # noqa
-        SimpleMarshalerFactory,
-        SimpleUnmarshalerFactory,
-    )
-
-    from .factories.match import (  # noqa
-        MarshalerFactoryMatchClass,
-        UnmarshalerFactoryMatchClass,
+    from .factories.method import (  # noqa
+        MarshalerFactoryMethodClass,
+        UnmarshalerFactoryMethodClass,
     )
 
     from .factories.moduleimport.configs import (  # noqa
@@ -246,6 +246,7 @@ with _lang.auto_proxy_init(globals()):
 
     from .trivial.forbidden import (  # noqa
         ForbiddenTypeMarshalerFactory,
+        ForbiddenTypeMarshalerFactoryUnmarshalerFactory,
         ForbiddenTypeUnmarshalerFactory,
     )
 

omlish/marshal/base/contexts.py

@@ -5,7 +5,6 @@ from ... import check
 from ... import collections as col
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from .configs import EMPTY_CONFIG_REGISTRY
 from .configs import ConfigRegistry
 from .errors import UnhandledTypeError
@@ -48,10 +47,9 @@ class MarshalContext(BaseContext, lang.Final):
     def make(self, o: ta.Any) -> 'Marshaler':
         rty = self._reflect(o)
         fac = check.not_none(self.factory)
-        try:
-            return fac.make_marshaler(self, rty)
-        except mfs.MatchGuardError:
+        if (mfn := fac.make_marshaler(self, rty)) is None:
             raise UnhandledTypeError(rty)  # noqa
+        return mfn()
 
     def marshal(self, obj: ta.Any, ty: ta.Any | None = None) -> 'Value':
         return self.make(ty if ty is not None else type(obj)).marshal(self, obj)
@@ -64,10 +62,9 @@ class UnmarshalContext(BaseContext, lang.Final):
     def make(self, o: ta.Any) -> 'Unmarshaler':
         rty = self._reflect(o)
         fac = check.not_none(self.factory)
-        try:
-            return fac.make_unmarshaler(self, rty)
-        except mfs.MatchGuardError:
+        if (mfn := fac.make_unmarshaler(self, rty)) is None:
             raise UnhandledTypeError(rty)  # noqa
+        return mfn()
 
     @ta.overload
     def unmarshal(self, v: 'Value', ty: type[T]) -> T:

omlish/marshal/base/funcs.py

@@ -3,7 +3,7 @@ import typing as ta
 
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
+from ...funcs import guard as gfs
 from .contexts import MarshalContext
 from .contexts import UnmarshalContext
 from .types import Marshaler
@@ -39,19 +39,24 @@ class FuncUnmarshaler(Unmarshaler, lang.Final):
 
 @dc.dataclass(frozen=True)
 class FuncMarshalerFactory(MarshalerFactory):  # noqa
-    guard: ta.Callable[[MarshalContext, rfl.Type], bool]
-    fn: ta.Callable[[MarshalContext, rfl.Type], Marshaler]
+    gf: MarshalerMaker
 
-    @lang.cached_property
-    def make_marshaler(self) -> MarshalerMaker:
-        return mfs.simple(self.guard, self.fn)
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        return self.gf(ctx, rty)
 
 
 @dc.dataclass(frozen=True)
 class FuncUnmarshalerFactory(UnmarshalerFactory):  # noqa
-    guard: ta.Callable[[UnmarshalContext, rfl.Type], bool]
-    fn: ta.Callable[[UnmarshalContext, rfl.Type], Unmarshaler]
+    gf: UnmarshalerMaker
 
-    @lang.cached_property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return mfs.simple(self.guard, self.fn)
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        return self.gf(ctx, rty)
+
+
+##
+
+
+class GuardMethodMarshalerFactory(MarshalerFactory):
+    @gfs.method(instance_cache=True)
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        raise NotImplementedError

omlish/marshal/base/types.py

@@ -3,7 +3,7 @@ import typing as ta
 
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
+from ...funcs import guard as gfs
 from .configs import ConfigRegistry
 from .contexts import MarshalContext
 from .contexts import UnmarshalContext
@@ -31,21 +31,19 @@ class Unmarshaler(lang.Abstract):
 ##
 
 
-MarshalerMaker: ta.TypeAlias = mfs.MatchFn[[MarshalContext, rfl.Type], Marshaler]
-UnmarshalerMaker: ta.TypeAlias = mfs.MatchFn[[UnmarshalContext, rfl.Type], Unmarshaler]
+MarshalerMaker: ta.TypeAlias = gfs.GuardFn[[MarshalContext, rfl.Type], Marshaler]
+UnmarshalerMaker: ta.TypeAlias = gfs.GuardFn[[UnmarshalContext, rfl.Type], Unmarshaler]
 
 
 class MarshalerFactory(lang.Abstract):
-    @property
     @abc.abstractmethod
-    def make_marshaler(self) -> MarshalerMaker:
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         raise NotImplementedError
 
 
 class UnmarshalerFactory(lang.Abstract):
-    @property
     @abc.abstractmethod
-    def make_unmarshaler(self) -> UnmarshalerMaker:
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         raise NotImplementedError
 
 
@@ -98,3 +96,15 @@ class Marshaling(lang.Abstract):
     @ta.final
     def unmarshal(self, v, ty, **kwargs):
         return self.new_unmarshal_context(**kwargs).unmarshal(v, ty)
+
+
+##
+
+
+# MarshalerOrUnmarshaler: ta.TypeAlias = Marshaler | Unmarshaler
+# MarshalerOrUnmarshalerT = ta.TypeVar('MarshalerOrUnmarshalerT', bound=MarshalerOrUnmarshaler)
+#
+# MarshalContextOrUnmarshalContext: ta.TypeAlias = MarshalContext | UnmarshalContext
+# MarshalContextOrUnmarshalContextT = ta.TypeVar('MarshalContextOrUnmarshalContextT', bound=MarshalContextOrUnmarshalContext)  # noqa
+#
+# MarshalerMakerOrUnmarshalerMaker: ta.TypeAlias = MarshalerMaker | UnmarshalerMaker

omlish/marshal/composite/iterables.py

@@ -9,14 +9,13 @@ import typing as ta
 
 from ... import check
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
 from ..base.types import Marshaler
 from ..base.types import Unmarshaler
 from ..base.values import Value
-from ..factories.match import MarshalerFactoryMatchClass
-from ..factories.match import UnmarshalerFactoryMatchClass
+from ..factories.method import MarshalerFactoryMethodClass
+from ..factories.method import UnmarshalerFactoryMethodClass
 
 
 ##
@@ -29,6 +28,9 @@ DEFAULT_ITERABLE_CONCRETE_TYPES: dict[type[collections.abc.Iterable], type[colle
 }
 
 
+#
+
+
 @dc.dataclass(frozen=True)
 class IterableMarshaler(Marshaler):
     e: Marshaler
@@ -37,15 +39,21 @@ class IterableMarshaler(Marshaler):
         return list(map(functools.partial(self.e.marshal, ctx), o))
 
 
-class IterableMarshalerFactory(MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable))
-    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        gty = check.isinstance(rty, rfl.Generic)
-        return IterableMarshaler(ctx.make(check.single(gty.args)))
+class IterableMarshalerFactory(MarshalerFactoryMethodClass):
+    @MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_generic(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable)):
+            return None
+        return lambda: IterableMarshaler(ctx.make(check.single(rty.args)))
+
+    @MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, collections.abc.Iterable)):
+            return None
+        return lambda: IterableMarshaler(ctx.make(ta.Any))
+
 
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Iterable))
-    def _build_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return IterableMarshaler(ctx.make(ta.Any))
+#
 
 
 @dc.dataclass(frozen=True)
@@ -57,13 +65,16 @@ class IterableUnmarshaler(Unmarshaler):
         return self.ctor(map(functools.partial(self.e.unmarshal, ctx), check.isinstance(v, collections.abc.Iterable)))
 
 
-class IterableUnmarshalerFactory(UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable))
-    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        gty = check.isinstance(rty, rfl.Generic)
-        cty = DEFAULT_ITERABLE_CONCRETE_TYPES.get(gty.cls, gty.cls)  # noqa
-        return IterableUnmarshaler(cty, ctx.make(check.single(gty.args)))
+class IterableUnmarshalerFactory(UnmarshalerFactoryMethodClass):
+    @UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _make_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable)):
+            return None
+        cty = DEFAULT_ITERABLE_CONCRETE_TYPES.get(rty.cls, rty.cls)  # noqa
+        return lambda: IterableUnmarshaler(cty, ctx.make(check.single(rty.args)))  # noqa
 
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Iterable))
-    def _build_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return IterableUnmarshaler(check.isinstance(rty, type), ctx.make(ta.Any))
+    @UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _make_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, collections.abc.Iterable)):
+            return None
+        return lambda: IterableUnmarshaler(check.isinstance(rty, type), ctx.make(ta.Any))

omlish/marshal/composite/literals.py

@@ -10,10 +10,10 @@ from ... import reflect as rfl
 from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
 
 
 ##
@@ -28,14 +28,12 @@ class LiteralMarshaler(Marshaler):
         return self.e.marshal(ctx, check.in_(o, self.vs))
 
 
-class LiteralMarshalerFactory(SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        lty = check.isinstance(rty, rfl.Literal)
-        ety = check.single(set(map(type, lty.args)))
-        return LiteralMarshaler(ctx.make(ety), frozenset(lty.args))
+class LiteralMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1):
+            return None
+        ety = check.single(set(map(type, rty.args)))
+        return lambda: LiteralMarshaler(ctx.make(ety), frozenset(rty.args))
 
 
 @dc.dataclass(frozen=True)
@@ -47,11 +45,9 @@ class LiteralUnmarshaler(Unmarshaler):
         return check.in_(self.e.unmarshal(ctx, v), self.vs)
 
 
-class LiteralUnmarshalerFactory(SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        lty = check.isinstance(rty, rfl.Literal)
-        ety = check.single(set(map(type, lty.args)))
-        return LiteralUnmarshaler(ctx.make(ety), frozenset(lty.args))
+class LiteralUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1):
+            return None
+        ety = check.single(set(map(type, rty.args)))
+        return lambda: LiteralUnmarshaler(ctx.make(ety), frozenset(rty.args))

omlish/marshal/composite/mappings.py

@@ -4,14 +4,13 @@ import typing as ta
 
 from ... import check
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
 from ..base.types import Marshaler
 from ..base.types import Unmarshaler
 from ..base.values import Value
-from ..factories.match import MarshalerFactoryMatchClass
-from ..factories.match import UnmarshalerFactoryMatchClass
+from ..factories.method import MarshalerFactoryMethodClass
+from ..factories.method import UnmarshalerFactoryMethodClass
 
 
 ##
@@ -23,6 +22,9 @@ DEFAULT_MAPPING_CONCRETE_TYPES: dict[type[collections.abc.Mapping], type[collect
 }
 
 
+#
+
+
 @dc.dataclass(frozen=True)
 class MappingMarshaler(Marshaler):
     ke: Marshaler
@@ -35,16 +37,22 @@ class MappingMarshaler(Marshaler):
         }
 
 
-class MappingMarshalerFactory(MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping))
-    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        gty = check.isinstance(rty, rfl.Generic)
-        kt, vt = gty.args
-        return MappingMarshaler(ctx.make(kt), ctx.make(vt))
+class MappingMarshalerFactory(MarshalerFactoryMethodClass):
+    @MarshalerFactoryMethodClass.make_marshaler.register
+    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping)):
+            return None
+        kt, vt = rty.args
+        return lambda: MappingMarshaler(ctx.make(kt), ctx.make(vt))
+
+    @MarshalerFactoryMethodClass.make_marshaler.register
+    def _build_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, collections.abc.Mapping)):
+            return None
+        return lambda: MappingMarshaler(a := ctx.make(ta.Any), a)
 
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Mapping))
-    def _build_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return MappingMarshaler(a := ctx.make(ta.Any), a)
+
+#
 
 
 @dc.dataclass(frozen=True)
@@ -60,14 +68,17 @@ class MappingUnmarshaler(Unmarshaler):
         return self.ctor(dct)
 
 
-class MappingUnmarshalerFactory(UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping))
-    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        gty = check.isinstance(rty, rfl.Generic)
-        cty = DEFAULT_MAPPING_CONCRETE_TYPES.get(gty.cls, gty.cls)  # noqa
-        kt, vt = gty.args
-        return MappingUnmarshaler(cty, ctx.make(kt), ctx.make(vt))
-
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Mapping))
-    def _build_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return MappingUnmarshaler(check.isinstance(rty, type), a := ctx.make(ta.Any), a)
+class MappingUnmarshalerFactory(UnmarshalerFactoryMethodClass):
+    @UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping)):
+            return None
+        cty = DEFAULT_MAPPING_CONCRETE_TYPES.get(rty.cls, rty.cls)  # noqa
+        kt, vt = rty.args
+        return lambda: MappingUnmarshaler(cty, ctx.make(kt), ctx.make(vt))
+
+    @UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _build_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, collections.abc.Mapping)):
+            return None
+        return lambda: MappingUnmarshaler(check.isinstance(rty, type), a := ctx.make(ta.Any), a)