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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev454'
-__revision__ = '59a1efb9c2d924f74345aa315eef7c197a2d3a91'
+__version__ = '0.0.0.dev456'
+__revision__ = '490c7e083d622b5af435b695219421a568eb45b7'
 
 
 #

omlish/lang/__init__.py

@@ -334,7 +334,6 @@ with _auto_proxy_init(globals(), update_exports=True):
         ilen,
         take,
         consume,
-        iterfrom,
         peek,
         chunk,
         interleave,
@@ -454,6 +453,13 @@ with _auto_proxy_init(globals(), update_exports=True):
         get_relative_resources,
     )
 
+    from .sequences import (  # noqa
+        iterslice,
+        iterrange,
+
+        SeqView,
+    )
+
     from .strings import (  # noqa
         prefix_delimited,
         prefix_lines,

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/lang/iterables.py

@@ -26,14 +26,6 @@ def consume(it: ta.Iterable[ta.Any]) -> None:
     collections.deque(it, maxlen=0)
 
 
-def iterfrom(seq: ta.Sequence[T], start: int = 0, stop: int | None = None) -> ta.Iterator[T]:
-    if start < 0:
-        start += len(seq)
-    if stop is None:
-        stop = len(seq)
-    return map(seq.__getitem__, range(start, stop))
-
-
 def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
     it = iter(vs)
     v = next(it)

omlish/lang/sequences.py

@@ -0,0 +1,124 @@
+"""
+TODO:
+ - StrView, BytesView - in lieu of hkt lol
+ - cext? even necessary?
+ - __eq__, cmp, __hash__
+ - __buffer__
+ - optimize `slice(None)`, keep as SeqView but fast path ops
+ - shorter repr if __len__ > some threshold
+  - use materialize()?
+"""
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def iterslice(
+        seq: ta.Sequence[T],
+        slc: slice,
+) -> ta.Iterator[T]:
+    return map(seq.__getitem__, range(*slc.indices(len(seq))))
+
+
+def iterrange(
+        seq: ta.Sequence[T],
+        start: int | None = None,
+        stop: int | None = None,
+        step: int | None = None,
+) -> ta.Iterator[T]:
+    return iterslice(seq, slice(start, stop, step))
+
+
+##
+
+
+@ta.final
+class SeqView(ta.Sequence[T]):
+    def __init__(self, data: ta.Sequence[T], slice_: slice = slice(None)) -> None:
+        if data.__class__ is SeqView:
+            self._data = data._data  # type: ignore[attr-defined]  # noqa
+            self._range = data._range[slice_]  # type: ignore[attr-defined]  # noqa
+        else:
+            self._data = data
+            self._range = range(*slice_.indices(len(data)))
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    _data: ta.Sequence[T]
+    _range: range
+
+    @classmethod
+    def _from_range(cls, base: ta.Sequence[T], rng: range) -> 'SeqView[T]':
+        self = object.__new__(cls)
+        self._data = base
+        self._range = rng
+        return self
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._data!r}, {self.slice!r})'
+
+    #
+
+    def __len__(self) -> int:
+        return len(self._range)
+
+    def __getitem__(self, key: int | slice) -> ta.Union[T, 'SeqView[T]']:  # type: ignore[override]
+        if isinstance(key, slice):
+            nr = self._range[key]
+            return SeqView._from_range(self._data, nr)
+        return self._data[self._range[key]]
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return map(self._data.__getitem__, self._range)
+
+    def __reversed__(self) -> ta.Iterator[T]:
+        return map(self._data.__getitem__, reversed(self._range))
+
+    def count(self, value: ta.Any) -> int:
+        c = 0
+        for i in self._range:
+            if self._data[i] == value:
+                c += 1
+        return c
+
+    def index(self, value: ta.Any, start: int = 0, stop: int | None = None) -> int:
+        sub = self._range[slice(start, stop, 1)]
+        for off, i in enumerate(sub):
+            if self._data[i] == value:
+                return off
+        raise ValueError(f'{value!r} is not in view')
+
+    #
+
+    @property
+    def data(self) -> ta.Sequence[T]:
+        return self._data
+
+    _slice: slice
+
+    @property
+    def slice(self) -> slice:
+        try:
+            return self._slice
+        except AttributeError:
+            pass
+
+        step = self._range.step
+        start = self._range.start
+        if len(self._range) == 0:
+            stop = start
+        else:
+            last = start + (len(self._range) - 1) * step
+            stop = last + (1 if step > 0 else -1)
+        slc = slice(start, stop, step)
+
+        self._slice = slc
+        return slc
+
+    def materialize(self) -> ta.Sequence[T]:
+        return self._data[self.slice]

omlish/marshal/__init__.py

@@ -49,11 +49,17 @@ with _lang.auto_proxy_init(globals()):
 
     from .base.configs import (  # noqa
         Config,
+        Configs,
+
         ConfigRegistry,
     )
 
     from .base.contexts import (  # noqa
         BaseContext,
+
+        MarshalFactoryContext,
+        UnmarshalFactoryContext,
+
         MarshalContext,
         UnmarshalContext,
     )

omlish/marshal/base/configs.py

@@ -3,6 +3,10 @@ import typing as ta
 from ... import lang
 from .registries import Registry
 from .registries import RegistryItem
+from .registries import RegistryView
+
+
+ConfigT = ta.TypeVar('ConfigT', bound='Config')
 
 
 ##
@@ -12,7 +16,15 @@ class Config(RegistryItem, lang.Abstract):
     pass
 
 
+Configs: ta.TypeAlias = RegistryView[Config]
+
+
+##
+
+
 ConfigRegistry: ta.TypeAlias = Registry[Config]
 
+lang.static_check_issubclass[Configs](ConfigRegistry)
+
 
 EMPTY_CONFIG_REGISTRY = ConfigRegistry().seal()

omlish/marshal/base/contexts.py

@@ -6,7 +6,7 @@ from ... import collections as col
 from ... import lang
 from ... import reflect as rfl
 from .configs import EMPTY_CONFIG_REGISTRY
-from .configs import ConfigRegistry
+from .configs import Configs
 from .errors import UnhandledTypeError
 from .options import Option
 from .overrides import ReflectOverride
@@ -27,45 +27,61 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class BaseContext(lang.Abstract):
-    config_registry: ConfigRegistry = EMPTY_CONFIG_REGISTRY
+class BaseContext(lang.Abstract, lang.Sealed):
+    configs: Configs = EMPTY_CONFIG_REGISTRY
     options: col.TypeMap[Option] = col.TypeMap()
 
     def _reflect(self, o: ta.Any) -> rfl.Type:
         def override(o):
-            if (ovr := self.config_registry.get_of(o, ReflectOverride)):
+            if (ovr := self.configs.get_of(o, ReflectOverride)):
                 return ovr[-1].rty
             return None
 
         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/registries.py

@@ -3,6 +3,7 @@ TODO:
  - col.TypeMap?
   - at least get_any
 """
+import abc
 import dataclasses as dc
 import threading
 import typing as ta
@@ -21,11 +22,38 @@ RegistryItemT = ta.TypeVar('RegistryItemT', bound=RegistryItem)
 RegistryItemU = ta.TypeVar('RegistryItemU', bound=RegistryItem)
 
 
+##
+
+
+class RegistryView(lang.Abstract, ta.Generic[RegistryItemT]):
+    @abc.abstractmethod
+    def get(
+            self,
+            key: ta.Any,
+            *,
+            identity: bool | None = None,
+    ) -> ta.Sequence[RegistryItemT]:
+        ...
+
+    @abc.abstractmethod
+    def get_of(
+            self,
+            key: ta.Any,
+            item_ty: type[RegistryItemU],
+            *,
+            identity: bool | None = None,
+    ) -> ta.Sequence[RegistryItemU]:
+        ...
+
+
+##
+
+
 class RegistrySealedError(Exception):
     pass
 
 
-class Registry(ta.Generic[RegistryItemT]):
+class Registry(RegistryView[RegistryItemT]):
     def __init__(
             self,
             *,
@@ -203,8 +231,8 @@ class Registry(ta.Generic[RegistryItemT]):
             key: ta.Any,
             *,
             identity: bool | None = None,
-    ) -> ta.Sequence[RegistryItem]:
-        return self._state.get(key, identity=identity)
+    ) -> ta.Sequence[RegistryItemT]:
+        return self._state.get(key, identity=identity)  # type: ignore [return-value]
 
     def get_of(
             self,
@@ -213,4 +241,4 @@ class Registry(ta.Generic[RegistryItemT]):
             *,
             identity: bool | None = None,
     ) -> ta.Sequence[RegistryItemU]:
-        return self._state.get_of(key, item_ty, identity=identity)  # type: ignore[return-value]
+        return self._state.get_of(key, item_ty, identity=identity)  # type: ignore [return-value]

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(
+            configs=self.config_registry(),
+            marshaler_factory=self.marshaler_factory(),
+        )
+
+    def new_unmarshal_factory_context(self) -> UnmarshalFactoryContext:
+        return UnmarshalFactoryContext(
+            configs=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,
+            configs=self.config_registry(),
+            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,
+            configs=self.config_registry(),
+            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)