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

omlish/marshal/factories/typemap.py

@@ -3,63 +3,62 @@ import typing as ta
 from ... import check
 from ... import dataclasses as dc
 from ... import reflect as rfl
-from ...funcs import match as mfs
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Marshaler
 from ..base.types import MarshalerFactory
-from ..base.types import MarshalerMaker
 from ..base.types import Unmarshaler
 from ..base.types import UnmarshalerFactory
-from ..base.types import UnmarshalerMaker
-
-
-R = ta.TypeVar('R')
-C = ta.TypeVar('C')
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class _TypeMapFactory(mfs.MatchFn[[C, rfl.Type], R]):
-    m: ta.Mapping[rfl.Type, R] = dc.field(default_factory=dict)
-
-    def __post_init__(self) -> None:
-        for k in self.m:
-            if not isinstance(k, rfl.TYPES):
-                raise TypeError(k)
-
-    def guard(self, ctx: C, rty: rfl.Type) -> bool:
-        check.isinstance(rty, rfl.TYPES)
-        return rty in self.m
-
-    def fn(self, ctx: C, rty: rfl.Type) -> R:
+class TypeMapMarshalerFactory(MarshalerFactory):
+    m: ta.Mapping[rfl.Type, Marshaler | MarshalerFactory] = dc.xfield(
+        default_factory=dict,
+        coerce=lambda d: {
+            check.isinstance(k, rfl.TYPES): check.isinstance(v, (Marshaler, UnmarshalerFactory))
+            for k, v in d.items()
+        },
+    )
+
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         check.isinstance(rty, rfl.TYPES)
         try:
-            return self.m[rty]
+            m = self.m[rty]
         except KeyError:
-            raise mfs.MatchGuardError(ctx, rty)  # noqa
-
+            return None
 
-##
-
-
-@dc.dataclass(frozen=True)
-class TypeMapMarshalerFactory(
-    _TypeMapFactory[MarshalContext, Marshaler],
-    MarshalerFactory,
-):
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self  # noqa
+        if isinstance(m, Marshaler):
+            return lambda: m
+        elif isinstance(m, MarshalerFactory):
+            return m.make_marshaler(ctx, rty)
+        else:
+            raise TypeError(m)
 
 
 @dc.dataclass(frozen=True)
-class TypeMapUnmarshalerFactory(
-    _TypeMapFactory[UnmarshalContext, Unmarshaler],
-    UnmarshalerFactory,
-):
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self  # noqa
+class TypeMapUnmarshalerFactory(UnmarshalerFactory):
+    u: ta.Mapping[rfl.Type, Unmarshaler | UnmarshalerFactory] = dc.xfield(
+        default_factory=dict,
+        coerce=lambda d: {
+            check.isinstance(k, rfl.TYPES): check.isinstance(v, (Unmarshaler, UnmarshalerFactory))
+            for k, v in d.items()
+        },
+    )
+
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        check.isinstance(rty, rfl.TYPES)
+        try:
+            u = self.u[rty]
+        except KeyError:
+            return None
+
+        if isinstance(u, Unmarshaler):
+            return lambda: u
+        elif isinstance(u, UnmarshalerFactory):
+            return u.make_unmarshaler(ctx, rty)
+        else:
+            raise TypeError(u)

omlish/marshal/objects/dataclasses.py

@@ -11,13 +11,14 @@ from ... import dataclasses as dc
 from ... import lang
 from ... import reflect as rfl
 from ...lite import marshal as lm
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
+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
@@ -159,19 +160,37 @@ def get_dataclass_field_infos(
     return FieldInfos(ret)
 
 
-def _make_field_obj(
-        ctx,
-        ty,
-        obj,
-        fac,
-        fac_attr,
+##
+
+
+def _make_field_marshal_obj(
+        ctx: MarshalFactoryContext,
+        ty: ta.Any,
+        obj: Marshaler | None,
+        fac: MarshalerFactory | None,
 ):
     if obj is not None:
         return obj
     if fac is not None:
-        return getattr(fac, fac_attr)(ctx, ty)
-    return ctx.make(ty)
+        if (m := fac.make_marshaler(ctx, ty)) is None:
+            raise UnhandledTypeError(ty)
+        return m()
+    return ctx.make_marshaler(ty)
+
 
+def _make_field_unmarshal_obj(
+        ctx: UnmarshalFactoryContext,
+        ty: ta.Any,
+        obj: Unmarshaler | None,
+        fac: UnmarshalerFactory | None,
+):
+    if obj is not None:
+        return obj
+    if fac is not None:
+        if (m := fac.make_unmarshaler(ctx, ty)) is None:
+            raise UnhandledTypeError(ty)
+        return m()
+    return ctx.make_unmarshaler(ty)
 
 ##
 
@@ -200,119 +219,123 @@ 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: MarshalFactoryContext, 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)
+
+            fields = [
+                (
+                    fi,
+                    _make_field_marshal_obj(
+                        ctx,
+                        fi.type,
+                        fi.metadata.marshaler,
+                        fi.metadata.marshaler_factory,
+                    ),
+                )
+                for fi in fis
+                if fi.name not in dc_md.specials.set
+            ]
 
-    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',
-                ),
+            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: UnmarshalFactoryContext, 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_unmarshal_obj(
+                            ctx,
+                            fi.type,
+                            fi.metadata.unmarshaler,
+                            fi.metadata.unmarshaler_factory,
+                        ),
+                    )
 
-                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

@@ -5,9 +5,10 @@ from ... import check
 from ... import dataclasses as dc
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 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
@@ -29,12 +30,12 @@ class ObjectMarshaler(Marshaler):
     @classmethod
     def make(
             cls,
-            ctx: MarshalContext,
+            ctx: MarshalFactoryContext,
             fis: FieldInfos,
             **kwargs: ta.Any,
     ) -> Marshaler:
         fields = [
-            (fi, ctx.make(fi.type))
+            (fi, ctx.make_marshaler(fi.type))
             for fi in fis
         ]
 
@@ -86,23 +87,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: MarshalFactoryContext, 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

@@ -5,13 +5,13 @@ from ... import check
 from ... import collections as col
 from ... import lang
 from ... import reflect as rfl
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 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: MarshalFactoryContext, 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_marshaler(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: UnmarshalFactoryContext, 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_unmarshaler(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

@@ -5,9 +5,10 @@ from ... import check
 from ... import dataclasses as dc
 from ... import reflect as rfl
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 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
@@ -35,13 +36,13 @@ class ObjectUnmarshaler(Unmarshaler):
     @classmethod
     def make(
             cls,
-            ctx: UnmarshalContext,
+            ctx: UnmarshalFactoryContext,
             factory: ta.Callable,
             fis: FieldInfos,
             **kwargs: ta.Any,
     ) -> Unmarshaler:
         fields_by_unmarshal_name = {
-            n: (fi, ctx.make(fi.type))
+            n: (fi, ctx.make_unmarshaler(fi.type))
             for fi in fis
             for n in fi.unmarshal_names
         }
@@ -118,24 +119,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: UnmarshalFactoryContext, 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