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

omlish/marshal/objects/dataclasses.py

@@ -13,11 +13,12 @@ from ... import reflect as rfl
 from ...lite import marshal as lm
 from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
+from ..base.errors import UnhandledTypeError
 from ..base.options import Option
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
+from ..base.types import UnmarshalerFactory
 from ..naming import Naming
 from ..naming import translate_name
 from .marshal import ObjectMarshaler
@@ -169,7 +170,9 @@ def _make_field_obj(
     if obj is not None:
         return obj
     if fac is not None:
-        return getattr(fac, fac_attr)(ctx, ty)
+        if (m := getattr(fac, fac_attr)(ctx, ty)) is None:
+            raise UnhandledTypeError(ty)
+        return m()
     return ctx.make(ty)
 
 
@@ -200,119 +203,125 @@ def _type_or_generic_base(rty: rfl.Type) -> type | None:
         return None
 
 
-class DataclassMarshalerFactory(AbstractDataclassFactory, SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return (
+class DataclassMarshalerFactory(AbstractDataclassFactory, MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (
             (ty := _type_or_generic_base(rty)) is not None and
             dc.is_dataclass(ty) and
             not lang.is_abstract_class(ty)
-        )
+        ):
+            return None
+
+        def inner() -> Marshaler:
+            ty = check.isinstance(_type_or_generic_base(rty), type)
+            check.state(dc.is_dataclass(ty))
+            check.state(not lang.is_abstract_class(ty))
+
+            dc_md = self._get_metadata(ty)
+            fis = self._get_field_infos(ty, ctx.options)
 
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        ty = check.isinstance(_type_or_generic_base(rty), type)
-        check.state(dc.is_dataclass(ty))
-        check.state(not lang.is_abstract_class(ty))
-
-        dc_md = self._get_metadata(ty)
-        fis = self._get_field_infos(ty, ctx.options)
-
-        fields = [
-            (
-                fi,
-                _make_field_obj(
-                    ctx,
-                    fi.type,
-                    fi.metadata.marshaler,
-                    fi.metadata.marshaler_factory,
-                    'make_marshaler',
-                ),
+            fields = [
+                (
+                    fi,
+                    _make_field_obj(
+                        ctx,
+                        fi.type,
+                        fi.metadata.marshaler,
+                        fi.metadata.marshaler_factory,
+                        'make_marshaler',
+                    ),
+                )
+                for fi in fis
+                if fi.name not in dc_md.specials.set
+            ]
+
+            return ObjectMarshaler(
+                fields,
+                specials=dc_md.specials,
             )
-            for fi in fis
-            if fi.name not in dc_md.specials.set
-        ]
 
-        return ObjectMarshaler(
-            fields,
-            specials=dc_md.specials,
-        )
+        return inner
 
 
 ##
 
 
-class DataclassUnmarshalerFactory(AbstractDataclassFactory, SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return (
+class DataclassUnmarshalerFactory(AbstractDataclassFactory, UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (
             (ty := _type_or_generic_base(rty)) is not None and
             dc.is_dataclass(ty) and
             not lang.is_abstract_class(ty)
-        )
+        ):
+            return None
 
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        ty = check.isinstance(_type_or_generic_base(rty), type)
-        check.state(dc.is_dataclass(ty))
-        check.state(not lang.is_abstract_class(ty))
+        def inner() -> Unmarshaler:
+            ty = check.isinstance(_type_or_generic_base(rty), type)
+            check.state(dc.is_dataclass(ty))
+            check.state(not lang.is_abstract_class(ty))
 
-        dc_md = self._get_metadata(ty)
-        fis = self._get_field_infos(ty, ctx.options)
+            dc_md = self._get_metadata(ty)
+            fis = self._get_field_infos(ty, ctx.options)
 
-        d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
-        defaults: dict[str, ta.Any] = {}
-        embeds: dict[str, type] = {}
-        embeds_by_unmarshal_name: dict[str, tuple[str, str]] = {}
+            d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
+            defaults: dict[str, ta.Any] = {}
+            embeds: dict[str, type] = {}
+            embeds_by_unmarshal_name: dict[str, tuple[str, str]] = {}
 
-        def add_field(fi: FieldInfo, *, prefixes: ta.Iterable[str] = ('',)) -> ta.Iterable[str]:
-            ret: list[str] = []
+            def add_field(fi: FieldInfo, *, prefixes: ta.Iterable[str] = ('',)) -> ta.Iterable[str]:
+                ret: list[str] = []
 
-            if fi.options.embed:
-                e_ty = check.isinstance(fi.type, type)
-                check.state(dc.is_dataclass(e_ty))
-                e_dc_md = get_dataclass_metadata(e_ty)
-                if e_dc_md.specials.set:
-                    raise Exception(f'Embedded fields cannot have specials: {e_ty}')
+                if fi.options.embed:
+                    e_ty = check.isinstance(fi.type, type)
+                    check.state(dc.is_dataclass(e_ty))
+                    e_dc_md = get_dataclass_metadata(e_ty)
+                    if e_dc_md.specials.set:
+                        raise Exception(f'Embedded fields cannot have specials: {e_ty}')
 
-                embeds[fi.name] = e_ty
-                for e_fi in self._get_field_infos(e_ty, ctx.options):
-                    e_ns = add_field(e_fi, prefixes=[p + ep for p in prefixes for ep in fi.unmarshal_names])
-                    embeds_by_unmarshal_name.update({e_f: (fi.name, e_fi.name) for e_f in e_ns})
-                    ret.extend(e_ns)
+                    embeds[fi.name] = e_ty
+                    for e_fi in self._get_field_infos(e_ty, ctx.options):
+                        e_ns = add_field(e_fi, prefixes=[p + ep for p in prefixes for ep in fi.unmarshal_names])
+                        embeds_by_unmarshal_name.update({e_f: (fi.name, e_fi.name) for e_f in e_ns})
+                        ret.extend(e_ns)
 
-            else:
-                tup = (
-                    fi,
-                    _make_field_obj(
-                        ctx,
-                        fi.type,
-                        fi.metadata.unmarshaler,
-                        fi.metadata.unmarshaler_factory,
-                        'make_unmarshaler',
-                    ),
-                )
+                else:
+                    tup = (
+                        fi,
+                        _make_field_obj(
+                            ctx,
+                            fi.type,
+                            fi.metadata.unmarshaler,
+                            fi.metadata.unmarshaler_factory,
+                            'make_unmarshaler',
+                        ),
+                    )
 
-                for pfx in prefixes:
-                    for un in fi.unmarshal_names:
-                        un = pfx + un
-                        if un in d:
-                            raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
-                        d[un] = tup
-                        ret.append(un)
-
-                if fi.options.default.present:
-                    defaults[fi.name] = fi.options.default.must()
-
-            return ret
-
-        for fi in fis:
-            if fi.name in dc_md.specials.set:
-                continue
-            add_field(fi)
-
-        return ObjectUnmarshaler(
-            ty,
-            d,
-            specials=dc_md.specials,
-            defaults=defaults,
-            embeds=embeds,
-            embeds_by_unmarshal_name=embeds_by_unmarshal_name,
-            ignore_unknown=dc_md.ignore_unknown,
-        )
+                    for pfx in prefixes:
+                        for un in fi.unmarshal_names:
+                            un = pfx + un
+                            if un in d:
+                                raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
+                            d[un] = tup
+                            ret.append(un)
+
+                    if fi.options.default.present:
+                        defaults[fi.name] = fi.options.default.must()
+
+                return ret
+
+            for fi in fis:
+                if fi.name in dc_md.specials.set:
+                    continue
+                add_field(fi)
+
+            return ObjectUnmarshaler(
+                ty,
+                d,
+                specials=dc_md.specials,
+                defaults=defaults,
+                embeds=embeds,
+                embeds_by_unmarshal_name=embeds_by_unmarshal_name,
+                ignore_unknown=dc_md.ignore_unknown,
+            )
+
+        return inner

omlish/marshal/objects/marshal.py

@@ -6,8 +6,8 @@ from ... import dataclasses as dc
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleMarshalerFactory
 from .metadata import FieldInfo
 from .metadata import FieldInfos
 from .metadata import ObjectSpecials
@@ -86,23 +86,26 @@ class ObjectMarshaler(Marshaler):
 
 
 @dc.dataclass(frozen=True)
-class SimpleObjectMarshalerFactory(SimpleMarshalerFactory):
+class SimpleObjectMarshalerFactory(MarshalerFactory):
     dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
 
     _: dc.KW_ONLY
 
     specials: ObjectSpecials = ObjectSpecials()
 
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, type) and rty in self.dct
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, type) and rty in self.dct):
+            return None
 
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        ty = check.isinstance(rty, type)
+        def inner() -> Marshaler:
+            ty = check.isinstance(rty, type)
 
-        fis = FieldInfos(self.dct[ty])
+            fis = FieldInfos(self.dct[ty])
 
-        return ObjectMarshaler.make(
-            ctx,
-            fis,
-            specials=self.specials,
-        )
+            return ObjectMarshaler.make(
+                ctx,
+                fis,
+                specials=self.specials,
+            )
+
+        return inner

omlish/marshal/objects/namedtuples.py

@@ -9,9 +9,9 @@ from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
 from ..base.options import Option
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
+from ..base.types import UnmarshalerFactory
 from .marshal import ObjectMarshaler
 from .metadata import FieldInfo
 from .metadata import FieldInfos
@@ -55,57 +55,63 @@ def get_namedtuple_field_infos(
 ##
 
 
-class NamedtupleMarshalerFactory(SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return _is_namedtuple(rty)
+class NamedtupleMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not _is_namedtuple(rty):
+            return None
 
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        check.state(_is_namedtuple(rty))
-        ty = check.isinstance(rty, type)
-        check.state(not lang.is_abstract_class(ty))
+        def inner() -> Marshaler:
+            check.state(_is_namedtuple(rty))
+            ty = check.isinstance(rty, type)
+            check.state(not lang.is_abstract_class(ty))
 
-        fis = get_namedtuple_field_infos(ty, ctx.options)
+            fis = get_namedtuple_field_infos(ty, ctx.options)
 
-        fields = [
-            (fi, ctx.make(fi.type))
-            for fi in fis
-        ]
+            fields = [
+                (fi, ctx.make(fi.type))
+                for fi in fis
+            ]
 
-        return ObjectMarshaler(
-            fields,
-        )
+            return ObjectMarshaler(
+                fields,
+            )
+
+        return inner
 
 
 ##
 
 
-class NamedtupleUnmarshalerFactory(SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return _is_namedtuple(rty)
+class NamedtupleUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not _is_namedtuple(rty):
+            return None
+
+        def inner() -> Unmarshaler:
+            check.state(_is_namedtuple(rty))
+            ty = check.isinstance(rty, type)
+            check.state(not lang.is_abstract_class(ty))
 
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        check.state(_is_namedtuple(rty))
-        ty = check.isinstance(rty, type)
-        check.state(not lang.is_abstract_class(ty))
+            fis = get_namedtuple_field_infos(ty, ctx.options)
 
-        fis = get_namedtuple_field_infos(ty, ctx.options)
+            d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
+            defaults: dict[str, ta.Any] = {}
 
-        d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
-        defaults: dict[str, ta.Any] = {}
+            for fi in fis:
+                tup = (fi, ctx.make(fi.type))
 
-        for fi in fis:
-            tup = (fi, ctx.make(fi.type))
+                for un in fi.unmarshal_names:
+                    if un in d:
+                        raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
+                    d[un] = tup
 
-            for un in fi.unmarshal_names:
-                if un in d:
-                    raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
-                d[un] = tup
+                if fi.options.default.present:
+                    defaults[fi.name] = fi.options.default.must()
 
-            if fi.options.default.present:
-                defaults[fi.name] = fi.options.default.must()
+            return ObjectUnmarshaler(
+                ty,
+                d,
+                defaults=defaults,
+            )
 
-        return ObjectUnmarshaler(
-            ty,
-            d,
-            defaults=defaults,
-        )
+        return inner

omlish/marshal/objects/unmarshal.py

@@ -6,8 +6,8 @@ from ... import dataclasses as dc
 from ... import reflect as rfl
 from ..base.contexts import UnmarshalContext
 from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleUnmarshalerFactory
 from .metadata import FieldInfo
 from .metadata import FieldInfos
 from .metadata import ObjectSpecials
@@ -118,24 +118,27 @@ class ObjectUnmarshaler(Unmarshaler):
 
 
 @dc.dataclass(frozen=True)
-class SimpleObjectUnmarshalerFactory(SimpleUnmarshalerFactory):
+class SimpleObjectUnmarshalerFactory(UnmarshalerFactory):
     dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
 
     _: dc.KW_ONLY
 
     specials: ObjectSpecials = ObjectSpecials()
 
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, type) and rty in self.dct
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, type) and rty in self.dct):
+            return None
 
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        ty = check.isinstance(rty, type)
+        def inner() -> Unmarshaler:
+            ty = check.isinstance(rty, type)
 
-        fis = FieldInfos(self.dct[ty])
+            fis = FieldInfos(self.dct[ty])
 
-        return ObjectUnmarshaler.make(
-            ctx,
-            ty,
-            fis,
-            specials=self.specials,
-        )
+            return ObjectUnmarshaler.make(
+                ctx,
+                ty,
+                fis,
+                specials=self.specials,
+            )
+
+        return inner

omlish/marshal/polymorphism/marshal.py

@@ -2,13 +2,12 @@ import abc
 import dataclasses as dc
 import typing as ta
 
-from ... import check
 from ... import lang
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleMarshalerFactory
 from .metadata import FieldTypeTagging
 from .metadata import Impls
 from .metadata import Polymorphism
@@ -68,13 +67,11 @@ def make_polymorphism_marshaler(
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismMarshalerFactory(SimpleMarshalerFactory):
+class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return rty is self.p.ty
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        check.is_(rty, self.p.ty)
-        return make_polymorphism_marshaler(self.p.impls, self.tt, ctx)
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if rty is not self.p.ty:
+            return None
+        return lambda: make_polymorphism_marshaler(self.p.impls, self.tt, ctx)

omlish/marshal/polymorphism/unions.py

@@ -1,3 +1,5 @@
+import typing as ta
+
 from ... import cached
 from ... import check
 from ... import dataclasses as dc
@@ -6,9 +8,9 @@ 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 ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
+from ..base.types import UnmarshalerFactory
 from .marshal import make_polymorphism_marshaler
 from .metadata import Impls
 from .metadata import TypeTagging
@@ -30,7 +32,7 @@ class _BasePolymorphismUnionFactory(lang.Abstract):
     def rtys(self) -> frozenset[rfl.Type]:
         return frozenset(i.ty for i in self.impls)
 
-    def guard(self, ctx: MarshalContext | UnmarshalContext, rty: rfl.Type) -> bool:
+    def _guard(self, ctx: MarshalContext | UnmarshalContext, rty: rfl.Type) -> bool:
         if not isinstance(rty, rfl.Union):
             return False
         if self.allow_partial:
@@ -44,12 +46,16 @@ class _BasePolymorphismUnionFactory(lang.Abstract):
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnionMarshalerFactory(_BasePolymorphismUnionFactory, SimpleMarshalerFactory):
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return make_polymorphism_marshaler(self.get_impls(rty), self.tt, ctx)
+class PolymorphismUnionMarshalerFactory(_BasePolymorphismUnionFactory, MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not self._guard(ctx, rty):
+            return None
+        return lambda: make_polymorphism_marshaler(self.get_impls(rty), self.tt, ctx)
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnionUnmarshalerFactory(_BasePolymorphismUnionFactory, SimpleUnmarshalerFactory):
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return make_polymorphism_unmarshaler(self.get_impls(rty), self.tt, ctx)
+class PolymorphismUnionUnmarshalerFactory(_BasePolymorphismUnionFactory, UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not self._guard(ctx, rty):
+            return None
+        return lambda: make_polymorphism_unmarshaler(self.get_impls(rty), self.tt, ctx)

omlish/marshal/polymorphism/unmarshal.py

@@ -8,8 +8,8 @@ from ... import lang
 from ... import reflect as rfl
 from ..base.contexts import UnmarshalContext
 from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleUnmarshalerFactory
 from .metadata import FieldTypeTagging
 from .metadata import Impls
 from .metadata import Polymorphism
@@ -75,13 +75,11 @@ def make_polymorphism_unmarshaler(
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnmarshalerFactory(SimpleUnmarshalerFactory):
+class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return rty is self.p.ty
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        check.is_(rty, self.p.ty)
-        return make_polymorphism_unmarshaler(self.p.impls, self.tt, ctx)
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if rty is not self.p.ty:
+            return None
+        return lambda: make_polymorphism_unmarshaler(self.p.impls, self.tt, ctx)

omlish/marshal/singular/enums.py

@@ -7,10 +7,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
 
 
 ##
@@ -24,14 +24,11 @@ class EnumMarshaler(Marshaler):
         return o.name
 
 
-class EnumMarshalerFactory(SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, type) and issubclass(rty, enum.Enum)
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        ty = check.isinstance(rty, type)
-        check.state(issubclass(ty, enum.Enum))
-        return EnumMarshaler(ty)  # noqa
+class EnumMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, enum.Enum)):
+            return None
+        return lambda: EnumMarshaler(rty)  # noqa
 
 
 @dc.dataclass(frozen=True)
@@ -42,11 +39,8 @@ class EnumUnmarshaler(Unmarshaler):
         return self.ty[check.isinstance(v, str)]
 
 
-class EnumUnmarshalerFactory(SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, type) and issubclass(rty, enum.Enum)
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        ty = check.isinstance(rty, type)
-        check.state(issubclass(ty, enum.Enum))
-        return EnumUnmarshaler(ty)
+class EnumUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, enum.Enum)):
+            return None
+        return lambda: EnumUnmarshaler(rty)  # noqa