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

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
@@ -60,12 +60,12 @@ class _ModuleImportingFactory(ta.Generic[FactoryT]):
 
 
 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
 

omlish/marshal/polymorphism/marshal.py

@@ -5,6 +5,7 @@ import typing as ta
 from ... import lang
 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
@@ -52,10 +53,10 @@ class FieldPolymorphismMarshaler(PolymorphismMarshaler):
 def make_polymorphism_marshaler(
         impls: Impls,
         tt: TypeTagging,
-        ctx: MarshalContext,
+        ctx: MarshalFactoryContext,
 ) -> Marshaler:
     m = {
-        i.ty: (i.tag, ctx.make(i.ty))
+        i.ty: (i.tag, ctx.make_marshaler(i.ty))
         for i in impls
     }
     if isinstance(tt, WrapperTypeTagging):
@@ -71,7 +72,7 @@ class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 
-    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 rty is not self.p.ty:
             return None
         return lambda: make_polymorphism_marshaler(self.p.impls, self.tt, ctx)

omlish/marshal/polymorphism/unions.py

@@ -5,8 +5,8 @@ from ... import check
 from ... import dataclasses as dc
 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
@@ -32,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, rty: rfl.Type) -> bool:
         if not isinstance(rty, rfl.Union):
             return False
         if self.allow_partial:
@@ -47,15 +47,15 @@ class _BasePolymorphismUnionFactory(lang.Abstract):
 
 @dc.dataclass(frozen=True)
 class PolymorphismUnionMarshalerFactory(_BasePolymorphismUnionFactory, MarshalerFactory):
-    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
-        if not self._guard(ctx, rty):
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not self._guard(rty):
             return None
         return lambda: make_polymorphism_marshaler(self.get_impls(rty), self.tt, ctx)
 
 
 @dc.dataclass(frozen=True)
 class PolymorphismUnionUnmarshalerFactory(_BasePolymorphismUnionFactory, UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
-        if not self._guard(ctx, rty):
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not self._guard(rty):
             return None
         return lambda: make_polymorphism_unmarshaler(self.get_impls(rty), self.tt, ctx)

omlish/marshal/polymorphism/unmarshal.py

@@ -7,6 +7,7 @@ from ... import check
 from ... import lang
 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
@@ -58,12 +59,12 @@ class FieldPolymorphismUnmarshaler(PolymorphismUnmarshaler):
 def make_polymorphism_unmarshaler(
         impls: Impls,
         tt: TypeTagging,
-        ctx: UnmarshalContext,
+        ctx: UnmarshalFactoryContext,
 ) -> Unmarshaler:
     m = {
         t: u
         for i in impls
-        for u in [ctx.make(i.ty)]
+        for u in [ctx.make_unmarshaler(i.ty)]
         for t in [i.tag, *i.alts]
     }
     if isinstance(tt, WrapperTypeTagging):
@@ -79,7 +80,7 @@ class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 
-    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 rty is not self.p.ty:
             return None
         return lambda: make_polymorphism_unmarshaler(self.p.impls, self.tt, ctx)

omlish/marshal/singular/enums.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 MarshalerFactory
 from ..base.types import Unmarshaler
@@ -25,7 +27,7 @@ class EnumMarshaler(Marshaler):
 
 
 class EnumMarshalerFactory(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, type) and issubclass(rty, enum.Enum)):
             return None
         return lambda: EnumMarshaler(rty)  # noqa
@@ -40,7 +42,7 @@ class EnumUnmarshaler(Unmarshaler):
 
 
 class EnumUnmarshalerFactory(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, type) and issubclass(rty, enum.Enum)):
             return None
         return lambda: EnumUnmarshaler(rty)  # noqa

omlish/marshal/trivial/any.py

@@ -15,7 +15,7 @@ from ..factories.typemap import TypeMapUnmarshalerFactory
 
 class AnyMarshalerUnmarshaler(Marshaler, Unmarshaler):
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        return ctx.make(type(o)).marshal(ctx, o)
+        return ctx.marshal_factory_context.make_marshaler(type(o)).marshal(ctx, o)
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
         return v

omlish/marshal/trivial/forbidden.py

@@ -2,8 +2,8 @@ import dataclasses as dc
 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.errors import ForbiddenTypeError
 from ..base.types import Marshaler
 from ..base.types import MarshalerFactory
@@ -18,7 +18,7 @@ from ..base.types import UnmarshalerFactory
 class ForbiddenTypeMarshalerFactoryUnmarshalerFactory(MarshalerFactory, UnmarshalerFactory):
     rtys: ta.AbstractSet[rfl.Type]
 
-    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 rty not in self.rtys:
             return None
 
@@ -27,7 +27,7 @@ class ForbiddenTypeMarshalerFactoryUnmarshalerFactory(MarshalerFactory, Unmarsha
 
         return inner
 
-    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 rty not in self.rtys:
             return None
 

omlish/specs/jsonrpc/_marshal.py

@@ -25,7 +25,7 @@ class NotSpecifiedUnionMarshaler(msh.Marshaler):
 
 
 class NotSpecifiedUnionMarshalerFactory(msh.MarshalerFactory):
-    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
         if not (
             isinstance(rty, rfl.Union) and
             not rty.is_optional and
@@ -36,14 +36,14 @@ class NotSpecifiedUnionMarshalerFactory(msh.MarshalerFactory):
         def inner() -> msh.Marshaler:
             args = set(check.isinstance(rty, rfl.Union).args) - {_NOT_SPECIFIED_RTY}
             nty = rfl.type_(ta.Union[*args])
-            m = ctx.make(nty)
+            m = ctx.make_marshaler(nty)
             return NotSpecifiedUnionMarshaler(m)
 
         return inner
 
 
 class NotSpecifiedUnionUnmarshalerFactory(msh.UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
         if not (
             isinstance(rty, rfl.Union) and
             not rty.is_optional and
@@ -54,7 +54,7 @@ class NotSpecifiedUnionUnmarshalerFactory(msh.UnmarshalerFactory):
         def inner() -> msh.Unmarshaler:
             args = set(check.isinstance(rty, rfl.Union).args) - {_NOT_SPECIFIED_RTY}
             nty = rfl.type_(ta.Union[*args])
-            return ctx.make(nty)
+            return ctx.make_unmarshaler(nty)
 
         return inner
 

omlish/specs/openapi/_marshal.py

@@ -36,10 +36,13 @@ class _ReferenceUnionMarshaler(msh.Marshaler):
 
 
 class _ReferenceUnionMarshalerFactory(msh.MarshalerFactory):
-    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
         if (rua := _reference_union_arg(rty)) is None:
             return None
-        return lambda: _ReferenceUnionMarshaler(ctx.make(check.not_none(rua)), ctx.make(Reference))
+        return lambda: _ReferenceUnionMarshaler(
+            ctx.make_marshaler(check.not_none(rua)),
+            ctx.make_marshaler(Reference),
+        )
 
 
 #
@@ -60,10 +63,13 @@ class _ReferenceUnionUnmarshaler(msh.Unmarshaler):
 
 
 class _ReferenceUnionUnmarshalerFactory(msh.UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
         if (rua := _reference_union_arg(rty)) is None:
             return None
-        return lambda: _ReferenceUnionUnmarshaler(ctx.make(check.not_none(rua)), ctx.make(Reference))
+        return lambda: _ReferenceUnionUnmarshaler(
+            ctx.make_unmarshaler(check.not_none(rua)),
+            ctx.make_unmarshaler(Reference),
+        )
 
 
 ##
@@ -88,16 +94,16 @@ class _SchemaMarshaler(msh.Marshaler):
 
 
 class _SchemaMarshalerFactory(msh.MarshalerFactory):
-    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
         if rty is not Schema:
             return None
         return lambda: _SchemaMarshaler(
             {
-                f: (msh.translate_name(f, msh.Naming.LOW_CAMEL), ctx.make(rfl.type_(a)))
+                f: (msh.translate_name(f, msh.Naming.LOW_CAMEL), ctx.make_marshaler(rfl.type_(a)))
                 for f, a in dc.reflect(Schema).field_annotations.items()
                 if f != 'keywords'
             },
-            ctx.make(jsch.Keywords),
+            ctx.make_marshaler(jsch.Keywords),
         )
 
 
@@ -124,16 +130,16 @@ class _SchemaUnmarshaler(msh.Unmarshaler):
 
 
 class _SchemaUnmarshalerFactory(msh.UnmarshalerFactory):
-    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
         if rty is not Schema:
             return None
         return lambda: _SchemaUnmarshaler(
             {
-                msh.translate_name(f, msh.Naming.LOW_CAMEL): (f, ctx.make(rfl.type_(a)))
+                msh.translate_name(f, msh.Naming.LOW_CAMEL): (f, ctx.make_unmarshaler(rfl.type_(a)))
                 for f, a in dc.reflect(Schema).field_annotations.items()
                 if f != 'keywords'
             },
-            ctx.make(jsch.Keywords),
+            ctx.make_unmarshaler(jsch.Keywords),
         )