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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev454'
-__revision__ = '59a1efb9c2d924f74345aa315eef7c197a2d3a91'
+__version__ = '0.0.0.dev455'
+__revision__ = '83eb94a310c0880350d3f2b4440d1673f4d9402d'
 
 
 #

omlish/lang/functions.py

@@ -59,11 +59,11 @@ def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
 ##
 
 
-def raise_(o: BaseException) -> ta.NoReturn:
+def raise_(o: BaseException | type[BaseException]) -> ta.NoReturn:
     raise o
 
 
-def raising(o: BaseException) -> ta.Callable[..., ta.NoReturn]:
+def raising(o: BaseException | type[BaseException]) -> ta.Callable[..., ta.NoReturn]:
     def inner(*args, **kwargs):
         raise o
 

omlish/marshal/__init__.py

@@ -54,6 +54,10 @@ with _lang.auto_proxy_init(globals()):
 
     from .base.contexts import (  # noqa
         BaseContext,
+
+        MarshalFactoryContext,
+        UnmarshalFactoryContext,
+
         MarshalContext,
         UnmarshalContext,
     )

omlish/marshal/base/contexts.py

@@ -27,7 +27,7 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class BaseContext(lang.Abstract):
+class BaseContext(lang.Abstract, lang.Sealed):
     config_registry: ConfigRegistry = EMPTY_CONFIG_REGISTRY
     options: col.TypeMap[Option] = col.TypeMap()
 
@@ -40,32 +40,48 @@ class BaseContext(lang.Abstract):
         return rfl.Reflector(override=override).type(o)
 
 
+#
+
+
 @dc.dataclass(frozen=True, kw_only=True)
-class MarshalContext(BaseContext, lang.Final):
-    factory: ta.Optional['MarshalerFactory'] = None
+class MarshalFactoryContext(BaseContext, lang.Final):
+    marshaler_factory: ta.Optional['MarshalerFactory'] = None
 
-    def make(self, o: ta.Any) -> 'Marshaler':
+    def make_marshaler(self, o: ta.Any) -> 'Marshaler':
         rty = self._reflect(o)
-        fac = check.not_none(self.factory)
+        fac = check.not_none(self.marshaler_factory)
         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)
-
 
 @dc.dataclass(frozen=True, kw_only=True)
-class UnmarshalContext(BaseContext, lang.Final):
-    factory: ta.Optional['UnmarshalerFactory'] = None
+class UnmarshalFactoryContext(BaseContext, lang.Final):
+    unmarshaler_factory: ta.Optional['UnmarshalerFactory'] = None
 
-    def make(self, o: ta.Any) -> 'Unmarshaler':
+    def make_unmarshaler(self, o: ta.Any) -> 'Unmarshaler':
         rty = self._reflect(o)
-        fac = check.not_none(self.factory)
+        fac = check.not_none(self.unmarshaler_factory)
         if (mfn := fac.make_unmarshaler(self, rty)) is None:
             raise UnhandledTypeError(rty)  # noqa
         return mfn()
 
+
+#
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class MarshalContext(BaseContext, lang.Final):
+    marshal_factory_context: MarshalFactoryContext
+
+    def marshal(self, obj: ta.Any, ty: ta.Any | None = None) -> 'Value':
+        return self.marshal_factory_context.make_marshaler(ty if ty is not None else type(obj)).marshal(self, obj)
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class UnmarshalContext(BaseContext, lang.Final):
+    unmarshal_factory_context: UnmarshalFactoryContext
+
     @ta.overload
     def unmarshal(self, v: 'Value', ty: type[T]) -> T:
         ...
@@ -75,4 +91,4 @@ class UnmarshalContext(BaseContext, lang.Final):
         ...
 
     def unmarshal(self, v, ty):
-        return self.make(ty).unmarshal(self, v)
+        return self.unmarshal_factory_context.make_unmarshaler(ty).unmarshal(self, v)

omlish/marshal/base/funcs.py

@@ -3,9 +3,10 @@ import typing as ta
 
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import guard as gfs
 from .contexts import MarshalContext
+from .contexts import MarshalFactoryContext
 from .contexts import UnmarshalContext
+from .contexts import UnmarshalFactoryContext
 from .types import Marshaler
 from .types import MarshalerFactory
 from .types import MarshalerMaker
@@ -41,7 +42,7 @@ class FuncUnmarshaler(Unmarshaler, lang.Final):
 class FuncMarshalerFactory(MarshalerFactory):  # noqa
     gf: MarshalerMaker
 
-    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.gf(ctx, rty)
 
 
@@ -49,14 +50,5 @@ class FuncMarshalerFactory(MarshalerFactory):  # noqa
 class FuncUnmarshalerFactory(UnmarshalerFactory):  # noqa
     gf: UnmarshalerMaker
 
-    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.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/options.py

@@ -1,2 +1,10 @@
+"""
+TODO:
+ - MarshalOption, UnmarshalOption, check if a context got something unexpected
+ - Options only apply to Factories?
+  - MarshalFactoryOption, MarshalOption, UnmarshalFactoryOption, MarshalOption ?
+"""
+
+
 class Option:
     pass

omlish/marshal/base/types.py

@@ -6,7 +6,9 @@ from ... import reflect as rfl
 from ...funcs import guard as gfs
 from .configs import ConfigRegistry
 from .contexts import MarshalContext
+from .contexts import MarshalFactoryContext
 from .contexts import UnmarshalContext
+from .contexts import UnmarshalFactoryContext
 from .values import Value
 
 
@@ -31,19 +33,19 @@ class Unmarshaler(lang.Abstract):
 ##
 
 
-MarshalerMaker: ta.TypeAlias = gfs.GuardFn[[MarshalContext, rfl.Type], Marshaler]
-UnmarshalerMaker: ta.TypeAlias = gfs.GuardFn[[UnmarshalContext, rfl.Type], Unmarshaler]
+MarshalerMaker: ta.TypeAlias = gfs.GuardFn[[MarshalFactoryContext, rfl.Type], Marshaler]
+UnmarshalerMaker: ta.TypeAlias = gfs.GuardFn[[UnmarshalFactoryContext, rfl.Type], Unmarshaler]
 
 
 class MarshalerFactory(lang.Abstract):
     @abc.abstractmethod
-    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 UnmarshalerFactory(lang.Abstract):
     @abc.abstractmethod
-    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
 
 
@@ -63,20 +65,32 @@ class Marshaling(lang.Abstract):
     def unmarshaler_factory(self) -> UnmarshalerFactory:
         raise NotImplementedError
 
-    #
+    ##
+
+    def new_marshal_factory_context(self) -> MarshalFactoryContext:
+        return MarshalFactoryContext(
+            config_registry=self.config_registry(),
+            marshaler_factory=self.marshaler_factory(),
+        )
+
+    def new_unmarshal_factory_context(self) -> UnmarshalFactoryContext:
+        return UnmarshalFactoryContext(
+            config_registry=self.config_registry(),
+            unmarshaler_factory=self.unmarshaler_factory(),
+        )
+
+    ##
 
-    def new_marshal_context(self, **kwargs: ta.Any) -> MarshalContext:
+    def new_marshal_context(self) -> MarshalContext:
         return MarshalContext(
             config_registry=self.config_registry(),
-            factory=self.marshaler_factory(),
-            **kwargs,
+            marshal_factory_context=self.new_marshal_factory_context(),
         )
 
-    def new_unmarshal_context(self, **kwargs: ta.Any) -> UnmarshalContext:
+    def new_unmarshal_context(self) -> UnmarshalContext:
         return UnmarshalContext(
             config_registry=self.config_registry(),
-            factory=self.unmarshaler_factory(),
-            **kwargs,
+            unmarshal_factory_context=self.new_unmarshal_factory_context(),
         )
 
     #

omlish/marshal/composite/iterables.py

@@ -10,7 +10,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 Unmarshaler
 from ..base.values import Value
@@ -41,16 +43,16 @@ class IterableMarshaler(Marshaler):
 
 class IterableMarshalerFactory(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 issubclass(rty.cls, collections.abc.Iterable)):
             return None
-        return lambda: IterableMarshaler(ctx.make(check.single(rty.args)))
+        return lambda: IterableMarshaler(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, collections.abc.Iterable)):
             return None
-        return lambda: IterableMarshaler(ctx.make(ta.Any))
+        return lambda: IterableMarshaler(ctx.make_marshaler(ta.Any))
 
 
 #
@@ -67,14 +69,14 @@ class IterableUnmarshaler(Unmarshaler):
 
 class IterableUnmarshalerFactory(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 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
+        return lambda: IterableUnmarshaler(cty, ctx.make_unmarshaler(check.single(rty.args)))  # noqa
 
     @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, collections.abc.Iterable)):
             return None
-        return lambda: IterableUnmarshaler(check.isinstance(rty, type), ctx.make(ta.Any))
+        return lambda: IterableUnmarshaler(check.isinstance(rty, type), ctx.make_unmarshaler(ta.Any))

omlish/marshal/composite/literals.py

@@ -8,7 +8,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
@@ -29,11 +31,11 @@ class LiteralMarshaler(Marshaler):
 
 
 class LiteralMarshalerFactory(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.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))
+        return lambda: LiteralMarshaler(ctx.make_marshaler(ety), frozenset(rty.args))
 
 
 @dc.dataclass(frozen=True)
@@ -46,8 +48,8 @@ class LiteralUnmarshaler(Unmarshaler):
 
 
 class LiteralUnmarshalerFactory(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.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))
+        return lambda: LiteralUnmarshaler(ctx.make_unmarshaler(ety), frozenset(rty.args))

omlish/marshal/composite/mappings.py

@@ -5,7 +5,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 Unmarshaler
 from ..base.values import Value
@@ -39,17 +41,17 @@ class MappingMarshaler(Marshaler):
 
 class MappingMarshalerFactory(MarshalerFactoryMethodClass):
     @MarshalerFactoryMethodClass.make_marshaler.register
-    def _build_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 issubclass(rty.cls, collections.abc.Mapping)):
             return None
         kt, vt = rty.args
-        return lambda: MappingMarshaler(ctx.make(kt), ctx.make(vt))
+        return lambda: MappingMarshaler(ctx.make_marshaler(kt), ctx.make_marshaler(vt))
 
     @MarshalerFactoryMethodClass.make_marshaler.register
-    def _build_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, collections.abc.Mapping)):
             return None
-        return lambda: MappingMarshaler(a := ctx.make(ta.Any), a)
+        return lambda: MappingMarshaler(a := ctx.make_marshaler(ta.Any), a)
 
 
 #
@@ -70,15 +72,15 @@ class MappingUnmarshaler(Unmarshaler):
 
 class MappingUnmarshalerFactory(UnmarshalerFactoryMethodClass):
     @UnmarshalerFactoryMethodClass.make_unmarshaler.register
-    def _build_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 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))
+        return lambda: MappingUnmarshaler(cty, ctx.make_unmarshaler(kt), ctx.make_unmarshaler(vt))
 
     @UnmarshalerFactoryMethodClass.make_unmarshaler.register
-    def _build_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, collections.abc.Mapping)):
             return None
-        return lambda: MappingUnmarshaler(check.isinstance(rty, type), a := ctx.make(ta.Any), a)
+        return lambda: MappingUnmarshaler(check.isinstance(rty, type), a := ctx.make_unmarshaler(ta.Any), a)

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