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

omlish/marshal/composite/maybes.py

@@ -9,7 +9,9 @@ from ... import check
 from ... import lang
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Marshaler
 from ..base.types import Unmarshaler
 from ..base.values import Value
@@ -34,16 +36,16 @@ class MaybeMarshaler(Marshaler):
 
 class MaybeMarshalerFactory(MarshalerFactoryMethodClass):
     @MarshalerFactoryMethodClass.make_marshaler.register
-    def _make_generic(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def _make_generic(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if not (isinstance(rty, rfl.Generic) and rty.cls is lang.Maybe):
             return None
-        return lambda: MaybeMarshaler(ctx.make(check.single(rty.args)))
+        return lambda: MaybeMarshaler(ctx.make_marshaler(check.single(rty.args)))
 
     @MarshalerFactoryMethodClass.make_marshaler.register
-    def _make_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def _make_concrete(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if not (isinstance(rty, type) and issubclass(rty, lang.Maybe)):
             return None
-        return lambda: MaybeMarshaler(ctx.make(ta.Any))
+        return lambda: MaybeMarshaler(ctx.make_marshaler(ta.Any))
 
 
 #
@@ -62,13 +64,13 @@ class MaybeUnmarshaler(Unmarshaler):
 
 class MaybeUnmarshalerFactory(UnmarshalerFactoryMethodClass):
     @UnmarshalerFactoryMethodClass.make_unmarshaler.register
-    def _make_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def _make_generic(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if not (isinstance(rty, rfl.Generic) and rty.cls is lang.Maybe):
             return None
-        return lambda: MaybeUnmarshaler(ctx.make(check.single(rty.args)))
+        return lambda: MaybeUnmarshaler(ctx.make_unmarshaler(check.single(rty.args)))
 
     @UnmarshalerFactoryMethodClass.make_unmarshaler.register
-    def _make_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def _make_concrete(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if not (isinstance(rty, type) and issubclass(rty, lang.Maybe)):
             return None
-        return lambda: MaybeUnmarshaler(ctx.make(ta.Any))
+        return lambda: MaybeUnmarshaler(ctx.make_unmarshaler(ta.Any))

omlish/marshal/composite/newtypes.py

@@ -2,8 +2,8 @@ import typing as ta
 
 from ... import check
 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.types import Marshaler
 from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
@@ -14,14 +14,14 @@ from ..base.types import UnmarshalerFactory
 
 
 class NewtypeMarshalerFactory(MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if not isinstance(rty, rfl.NewType):
             return None
-        return lambda: ctx.make(check.isinstance(rty, rfl.NewType).ty)
+        return lambda: ctx.make_marshaler(check.isinstance(rty, rfl.NewType).ty)
 
 
 class NewtypeUnmarshalerFactory(UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if not isinstance(rty, rfl.NewType):
             return None
-        return lambda: ctx.make(check.isinstance(rty, rfl.NewType).ty)
+        return lambda: ctx.make_unmarshaler(check.isinstance(rty, rfl.NewType).ty)

omlish/marshal/composite/optionals.py

@@ -4,7 +4,9 @@ import typing as ta
 from ... import check
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Marshaler
 from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
@@ -26,10 +28,10 @@ class OptionalMarshaler(Marshaler):
 
 
 class OptionalMarshalerFactory(MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if not (isinstance(rty, rfl.Union) and rty.is_optional):
             return None
-        return lambda: OptionalMarshaler(ctx.make(check.isinstance(rty, rfl.Union).without_none()))
+        return lambda: OptionalMarshaler(ctx.make_marshaler(check.isinstance(rty, rfl.Union).without_none()))
 
 
 @dc.dataclass(frozen=True)
@@ -43,7 +45,7 @@ class OptionalUnmarshaler(Unmarshaler):
 
 
 class OptionalUnmarshalerFactory(UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if not (isinstance(rty, rfl.Union) and rty.is_optional):
             return None
-        return lambda: OptionalUnmarshaler(ctx.make(check.isinstance(rty, rfl.Union).without_none()))
+        return lambda: OptionalUnmarshaler(ctx.make_unmarshaler(check.isinstance(rty, rfl.Union).without_none()))

omlish/marshal/composite/special.py

@@ -4,8 +4,8 @@ import typing as ta
 from ... import check
 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.types import Marshaler
 from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
@@ -19,15 +19,15 @@ from .iterables import IterableUnmarshaler
 
 
 class SequenceNotStrMarshalerFactory(MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if not (isinstance(rty, rfl.Protocol) and rty.cls is lang.SequenceNotStr):
             return None
-        return lambda: IterableMarshaler(ctx.make(check.single(rty.args)))
+        return lambda: IterableMarshaler(ctx.make_marshaler(check.single(rty.args)))
 
 
 class SequenceNotStrUnmarshalerFactory(UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if not (isinstance(rty, rfl.Protocol) and rty.cls is lang.SequenceNotStr):
             return None
         cty = DEFAULT_ITERABLE_CONCRETE_TYPES[collections.abc.Sequence]  # type: ignore[type-abstract]
-        return lambda: IterableUnmarshaler(cty, ctx.make(check.single(rty.args)))
+        return lambda: IterableUnmarshaler(cty, ctx.make_unmarshaler(check.single(rty.args)))

omlish/marshal/composite/unions/literals.py

@@ -6,7 +6,9 @@ from .... import dataclasses as dc
 from .... import lang
 from .... import reflect as rfl
 from ...base.contexts import MarshalContext
+from ...base.contexts import MarshalFactoryContext
 from ...base.contexts import UnmarshalContext
+from ...base.contexts import UnmarshalFactoryContext
 from ...base.types import Marshaler
 from ...base.types import MarshalerFactory
 from ...base.types import Unmarshaler
@@ -62,10 +64,10 @@ class LiteralUnionMarshaler(Marshaler):
 
 
 class LiteralUnionMarshalerFactory(MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if (ds := _destructure_literal_union_type(rty)) is None:
             return None
-        return lambda: LiteralUnionMarshaler(ds.v_ty, ctx.make(ds.lit), ctx.make(ds.non_lit))
+        return lambda: LiteralUnionMarshaler(ds.v_ty, ctx.make_marshaler(ds.lit), ctx.make_marshaler(ds.non_lit))
 
 
 #
@@ -85,7 +87,7 @@ class LiteralUnionUnmarshaler(Unmarshaler):
 
 
 class LiteralUnionUnmarshalerFactory(UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if (ds := _destructure_literal_union_type(rty)) is None:
             return None
-        return lambda: LiteralUnionUnmarshaler(ds.v_ty, ctx.make(ds.lit), ctx.make(ds.non_lit))
+        return lambda: LiteralUnionUnmarshaler(ds.v_ty, ctx.make_unmarshaler(ds.lit), ctx.make_unmarshaler(ds.non_lit))

omlish/marshal/composite/unions/primitives.py

@@ -5,7 +5,9 @@ from .... import collections as col
 from .... import dataclasses as dc
 from .... import reflect as rfl
 from ...base.contexts import MarshalContext
+from ...base.contexts import MarshalFactoryContext
 from ...base.contexts import UnmarshalContext
+from ...base.contexts import UnmarshalFactoryContext
 from ...base.types import Marshaler
 from ...base.types import MarshalerFactory
 from ...base.types import Unmarshaler
@@ -63,12 +65,12 @@ class PrimitiveUnionMarshaler(Marshaler):
 class PrimitiveUnionMarshalerFactory(MarshalerFactory):
     tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
 
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if (ds := _destructure_primitive_union_type(rty, self.tys)) is None:
             return None
         return lambda: PrimitiveUnionMarshaler(
             ds.prim,
-            ctx.make(check.single(ds.non_prim)) if ds.non_prim else None,
+            ctx.make_marshaler(check.single(ds.non_prim)) if ds.non_prim else None,
         )
 
 
@@ -92,10 +94,10 @@ class PrimitiveUnionUnmarshaler(Unmarshaler):
 class PrimitiveUnionUnmarshalerFactory(UnmarshalerFactory):
     tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
 
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if (ds := _destructure_primitive_union_type(rty, self.tys)) is None:
             return None
         return lambda: PrimitiveUnionUnmarshaler(
             ds.prim,
-            ctx.make(check.single(ds.non_prim)) if ds.non_prim else None,
+            ctx.make_unmarshaler(check.single(ds.non_prim)) if ds.non_prim else None,
         )

omlish/marshal/factories/invalidate.py

@@ -2,8 +2,8 @@ import threading
 import typing as ta
 
 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.types import Marshaler
 from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
@@ -59,10 +59,10 @@ class _InvalidatableFactory(ta.Generic[FactoryT]):
 
 
 class InvalidatableMarshalerFactory(_InvalidatableFactory[MarshalerFactory], MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         return self._fac().make_marshaler(ctx, rty)
 
 
 class InvalidatableUnmarshalerFactory(_InvalidatableFactory[UnmarshalerFactory], UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         return self._fac().make_unmarshaler(ctx, rty)

omlish/marshal/factories/method.py

@@ -3,8 +3,8 @@ import typing as ta
 from ... import lang
 from ... import reflect as rfl
 from ...funcs import guard as gfs
-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 Unmarshaler
@@ -15,14 +15,12 @@ from ..base.types import UnmarshalerFactory
 
 
 class MarshalerFactoryMethodClass(MarshalerFactory, lang.Abstract):
-    @ta.final
     @gfs.method(instance_cache=True)
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         raise NotImplementedError
 
 
 class UnmarshalerFactoryMethodClass(UnmarshalerFactory, lang.Abstract):
-    @ta.final
     @gfs.method(instance_cache=True)
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         raise NotImplementedError

omlish/marshal/factories/moduleimport/factories.py

@@ -12,8 +12,8 @@ import typing as ta
 
 from .... import reflect as rfl
 from ...base.contexts import BaseContext
-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 Unmarshaler
@@ -52,20 +52,20 @@ class _ModuleImportingFactory(ta.Generic[FactoryT]):
                 self._callback()
 
     def _import_if_necessary(self, ctx: BaseContext) -> None:
-        if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
+        if (mis := ctx.configs.get_of(None, ModuleImport)) and mis is not self._last_mis:
             with self._lock:
-                if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
+                if (mis := ctx.configs.get_of(None, ModuleImport)) and mis is not self._last_mis:
                     self._do_import(ctx, mis)
                     self._last_mis = mis
 
 
 class ModuleImportingMarshalerFactory(_ModuleImportingFactory[MarshalerFactory], MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         self._import_if_necessary(ctx)
         return self._fac.make_marshaler(ctx, rty)
 
 
 class ModuleImportingUnmarshalerFactory(_ModuleImportingFactory[UnmarshalerFactory], UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         self._import_if_necessary(ctx)
         return self._fac.make_unmarshaler(ctx, rty)

omlish/marshal/factories/multi.py

@@ -2,8 +2,8 @@ import typing as ta
 
 from ... import reflect as rfl
 from ...funcs import guard as gfs
-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 Unmarshaler
@@ -24,7 +24,7 @@ class MultiMarshalerFactory(MarshalerFactory):
         self._facs = facs
         self._mgf = gfs.multi(*[f.make_marshaler for f in self._facs], strict=strict)
 
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         return self._mgf(ctx, rty)
 
 
@@ -39,5 +39,5 @@ class MultiUnmarshalerFactory(UnmarshalerFactory):
         self._facs = facs
         self._mgf = gfs.multi(*[f.make_unmarshaler for f in self._facs], strict=strict)
 
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         return self._mgf(ctx, rty)

omlish/marshal/factories/recursive.py

@@ -2,7 +2,9 @@ import typing as ta
 
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Marshaler
 from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
@@ -80,7 +82,7 @@ class RecursiveMarshalerFactory(_RecursiveFactory[MarshalerFactory], MarshalerFa
     def __init__(self, fac: MarshalerFactory) -> None:
         super().__init__(fac, _ProxyMarshaler._new)  # noqa
 
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if (m := self._fac.make_marshaler(ctx, rty)) is None:
             return None
         return self._wrap(m, rty)
@@ -98,7 +100,7 @@ class RecursiveUnmarshalerFactory(_RecursiveFactory[UnmarshalerFactory], Unmarsh
     def __init__(self, fac: UnmarshalerFactory) -> None:
         super().__init__(fac, _ProxyUnmarshaler._new)  # noqa
 
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if (m := self._fac.make_unmarshaler(ctx, rty)) is None:
             return None
         return self._wrap(m, rty)

omlish/marshal/factories/typecache.py

@@ -1,15 +1,10 @@
-"""
-FIXME:
- - fix Context lifetime broken design already
-  - obvious: FactoryContext
-"""
 import threading
 import typing as ta
 
 from ... import check
 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.types import Marshaler
 from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
@@ -50,10 +45,10 @@ class _TypeCacheFactory(ta.Generic[FactoryT]):
 
 
 class TypeCacheMarshalerFactory(_TypeCacheFactory[MarshalerFactory], MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         return self._make(rty, lambda: self._fac.make_marshaler(ctx, rty))
 
 
 class TypeCacheUnmarshalerFactory(_TypeCacheFactory[UnmarshalerFactory], UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         return self._make(rty, lambda: self._fac.make_unmarshaler(ctx, rty))

omlish/marshal/factories/typemap.py

@@ -3,8 +3,8 @@ import typing as ta
 from ... import check
 from ... import dataclasses as dc
 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.types import Marshaler
 from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
@@ -24,7 +24,7 @@ class TypeMapMarshalerFactory(MarshalerFactory):
         },
     )
 
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         check.isinstance(rty, rfl.TYPES)
         try:
             m = self.m[rty]
@@ -49,7 +49,7 @@ class TypeMapUnmarshalerFactory(UnmarshalerFactory):
         },
     )
 
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         check.isinstance(rty, rfl.TYPES)
         try:
             u = self.u[rty]

omlish/marshal/objects/dataclasses.py

@@ -11,8 +11,8 @@ 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
@@ -160,22 +160,38 @@ 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:
-        if (m := getattr(fac, fac_attr)(ctx, ty)) is None:
+        if (m := fac.make_marshaler(ctx, ty)) is None:
             raise UnhandledTypeError(ty)
         return m()
-    return ctx.make(ty)
+    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)
+
 ##
 
 
@@ -204,7 +220,7 @@ def _type_or_generic_base(rty: rfl.Type) -> type | None:
 
 
 class DataclassMarshalerFactory(AbstractDataclassFactory, MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    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
@@ -223,12 +239,11 @@ class DataclassMarshalerFactory(AbstractDataclassFactory, MarshalerFactory):
             fields = [
                 (
                     fi,
-                    _make_field_obj(
+                    _make_field_marshal_obj(
                         ctx,
                         fi.type,
                         fi.metadata.marshaler,
                         fi.metadata.marshaler_factory,
-                        'make_marshaler',
                     ),
                 )
                 for fi in fis
@@ -247,7 +262,7 @@ class DataclassMarshalerFactory(AbstractDataclassFactory, MarshalerFactory):
 
 
 class DataclassUnmarshalerFactory(AbstractDataclassFactory, UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    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
@@ -287,12 +302,11 @@ class DataclassUnmarshalerFactory(AbstractDataclassFactory, UnmarshalerFactory):
                 else:
                     tup = (
                         fi,
-                        _make_field_obj(
+                        _make_field_unmarshal_obj(
                             ctx,
                             fi.type,
                             fi.metadata.unmarshaler,
                             fi.metadata.unmarshaler_factory,
-                            'make_unmarshaler',
                         ),
                     )
 

omlish/marshal/objects/marshal.py

@@ -5,6 +5,7 @@ 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
@@ -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
         ]
 
@@ -93,7 +94,7 @@ class SimpleObjectMarshalerFactory(MarshalerFactory):
 
     specials: ObjectSpecials = ObjectSpecials()
 
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    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
 

omlish/marshal/objects/namedtuples.py

@@ -5,8 +5,8 @@ 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
@@ -56,7 +56,7 @@ def get_namedtuple_field_infos(
 
 
 class NamedtupleMarshalerFactory(MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         if not _is_namedtuple(rty):
             return None
 
@@ -68,7 +68,7 @@ class NamedtupleMarshalerFactory(MarshalerFactory):
             fis = get_namedtuple_field_infos(ty, ctx.options)
 
             fields = [
-                (fi, ctx.make(fi.type))
+                (fi, ctx.make_marshaler(fi.type))
                 for fi in fis
             ]
 
@@ -83,7 +83,7 @@ class NamedtupleMarshalerFactory(MarshalerFactory):
 
 
 class NamedtupleUnmarshalerFactory(UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         if not _is_namedtuple(rty):
             return None
 
@@ -98,7 +98,7 @@ class NamedtupleUnmarshalerFactory(UnmarshalerFactory):
             defaults: dict[str, ta.Any] = {}
 
             for fi in fis:
-                tup = (fi, ctx.make(fi.type))
+                tup = (fi, ctx.make_unmarshaler(fi.type))
 
                 for un in fi.unmarshal_names:
                     if un in d:

omlish/marshal/objects/unmarshal.py

@@ -5,6 +5,7 @@ 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
@@ -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
         }
@@ -125,7 +126,7 @@ class SimpleObjectUnmarshalerFactory(UnmarshalerFactory):
 
     specials: ObjectSpecials = ObjectSpecials()
 
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+    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