omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev7__py3-none-any.whl

omlish/marshal/base.py

@@ -2,6 +2,7 @@
 TODO:
  - mappings
  - redacted
+ - strongly typed MarshalerFactory base class?
  - strongly typed Composite/Cached Marshaler/Unmarshaler factories - footgun
  - streaming? Start/EndObject, etc..
 
@@ -80,10 +81,12 @@ import typing as ta
 from .. import check
 from .. import collections as col
 from .. import lang
+from .. import matchfns as mfs
 from .. import reflect as rfl
 from .exceptions import UnhandledTypeError
-from .factories import Factory
 from .factories import RecursiveTypeFactory
+from .factories import TypeCacheFactory
+from .factories import TypeMapFactory
 from .registries import Registry
 from .registries import RegistryItem
 from .utils import _Proxy
@@ -105,8 +108,19 @@ class Unmarshaler(lang.Abstract):
         raise NotImplementedError
 
 
-MarshalerFactory = Factory[Marshaler, 'MarshalContext', rfl.Type]
-UnmarshalerFactory = Factory[Unmarshaler, 'UnmarshalContext', rfl.Type]
+MarshalerFactory: ta.TypeAlias = mfs.MatchFn[['MarshalContext', rfl.Type], Marshaler]
+UnmarshalerFactory: ta.TypeAlias = mfs.MatchFn[['UnmarshalContext', rfl.Type], Unmarshaler]
+
+MarshalerFactoryMatchClass: ta.TypeAlias = mfs.MatchFnClass[['MarshalContext', rfl.Type], Marshaler]
+UnmarshalerFactoryMatchClass: ta.TypeAlias = mfs.MatchFnClass[['UnmarshalContext', rfl.Type], Unmarshaler]
+
+#
+
+TypeMapMarshalerFactory: ta.TypeAlias = TypeMapFactory['MarshalContext', Marshaler]
+TypeMapUnmarshalerFactory: ta.TypeAlias = TypeMapFactory['UnmarshalContext', Unmarshaler]
+
+TypeCacheMarshalerFactory: ta.TypeAlias = TypeCacheFactory['MarshalContext', Marshaler]
+TypeCacheUnmarshalerFactory: ta.TypeAlias = TypeCacheFactory['UnmarshalContext', Unmarshaler]
 
 
 ##
@@ -150,9 +164,10 @@ class MarshalContext(BaseContext, lang.Final):
 
     def make(self, o: ta.Any) -> Marshaler:
         rty = rfl.type_(o)
-        if (m := check.not_none(self.factory)(self, rty)) is not None:  # noqa
-            return m
-        raise UnhandledTypeError(rty)
+        try:
+            return check.not_none(self.factory)(self, rty)  # type: ignore
+        except mfs.MatchGuardError:
+            raise UnhandledTypeError(rty)  # noqa
 
 
 @dc.dataclass(frozen=True)
@@ -161,9 +176,10 @@ class UnmarshalContext(BaseContext, lang.Final):
 
     def make(self, o: ta.Any) -> Unmarshaler:
         rty = rfl.type_(o)
-        if (m := check.not_none(self.factory)(self, rty)) is not None:  # noqa
-            return m
-        raise UnhandledTypeError(rty)
+        try:
+            return check.not_none(self.factory)(self, rty)  # type: ignore
+        except mfs.MatchGuardError:
+            raise UnhandledTypeError(rty)  # noqa
 
 
 ##
@@ -174,7 +190,7 @@ class _ProxyMarshaler(_Proxy[Marshaler], Marshaler):
         return self._obj.marshal(ctx, o)
 
 
-class RecursiveMarshalerFactory(RecursiveTypeFactory[Marshaler, MarshalContext], lang.Final):
+class RecursiveMarshalerFactory(RecursiveTypeFactory[MarshalContext, Marshaler], lang.Final):
     def __init__(self, f: MarshalerFactory) -> None:
         super().__init__(f, _ProxyMarshaler._new)  # noqa
 
@@ -184,7 +200,7 @@ class _ProxyUnmarshaler(_Proxy[Unmarshaler], Unmarshaler):
         return self._obj.unmarshal(ctx, v)
 
 
-class RecursiveUnmarshalerFactory(RecursiveTypeFactory[Unmarshaler, UnmarshalContext], lang.Final):
+class RecursiveUnmarshalerFactory(RecursiveTypeFactory[UnmarshalContext, Unmarshaler], lang.Final):
     def __init__(self, f: UnmarshalerFactory) -> None:
         super().__init__(f, _ProxyUnmarshaler._new)  # noqa
 

omlish/marshal/base64.py

@@ -1,25 +1,40 @@
 import base64
+import typing as ta
 
 from .. import check
+from .. import dataclasses as dc
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .factories import TypeMapFactory
 from .values import Value
 
 
-class Base64MarshalerUnmarshaler(Marshaler, Unmarshaler):
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True)
+class Base64MarshalerUnmarshaler(Marshaler, Unmarshaler, ta.Generic[T]):
+    ty: type[T]
+
     def marshal(self, ctx: MarshalContext, o: bytes) -> str:
         return base64.b64encode(o).decode()
 
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> bytes:
-        return base64.b64decode(check.isinstance(v, str).encode())
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> T:
+        return self.ty(base64.b64decode(check.isinstance(v, str).encode()))  # type: ignore
+
 
+BASE64_TYPES = (
+    bytes,
+    bytearray,
+)
 
-BASE64_MARSHALER_UNMARSHALER = Base64MarshalerUnmarshaler()
+BASE64_MARSHALER_FACTORY = TypeMapMarshalerFactory({
+    ty: Base64MarshalerUnmarshaler(ty) for ty in BASE64_TYPES
+})
 
-BASE64_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({bytes: BASE64_MARSHALER_UNMARSHALER})
-BASE64_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({bytes: BASE64_MARSHALER_UNMARSHALER})
+BASE64_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({
+    ty: Base64MarshalerUnmarshaler(ty) for ty in BASE64_TYPES
+})

omlish/marshal/dataclasses.py

@@ -79,37 +79,43 @@ def _make_field_obj(ctx, ty, obj, fac):
 
 
 class DataclassMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, type) and dc.is_dataclass(rty):
-            dc_md = get_dataclass_metadata(rty)
-            fields = [
-                (fi, _make_field_obj(ctx, fi.type, fi.metadata.marshaler, fi.metadata.marshaler_factory))
-                for fi in get_field_infos(rty, ctx.options)
-            ]
-            return ObjectMarshaler(
-                fields,
-                unknown_field=dc_md.unknown_field,
-            )
-        return None
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and dc.is_dataclass(rty)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        ty = check.isinstance(rty, type)
+        check.state(dc.is_dataclass(ty))
+        dc_md = get_dataclass_metadata(ty)
+        fields = [
+            (fi, _make_field_obj(ctx, fi.type, fi.metadata.marshaler, fi.metadata.marshaler_factory))
+            for fi in get_field_infos(ty, ctx.options)
+        ]
+        return ObjectMarshaler(
+            fields,
+            unknown_field=dc_md.unknown_field,
+        )
 
 
 ##
 
 
 class DataclassUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, type) and dc.is_dataclass(rty):
-            dc_md = get_dataclass_metadata(rty)
-            d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
-            for fi in get_field_infos(rty, ctx.options):
-                tup = (fi, _make_field_obj(ctx, fi.type, fi.metadata.unmarshaler, fi.metadata.unmarshaler_factory))
-                for un in fi.unmarshal_names:
-                    if un in d:
-                        raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
-                    d[un] = tup
-            return ObjectUnmarshaler(
-                rty,
-                d,
-                unknown_field=dc_md.unknown_field,
-            )
-        return None
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and dc.is_dataclass(rty)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        ty = check.isinstance(rty, type)
+        check.state(dc.is_dataclass(ty))
+        dc_md = get_dataclass_metadata(ty)
+        d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
+        for fi in get_field_infos(ty, ctx.options):
+            tup = (fi, _make_field_obj(ctx, fi.type, fi.metadata.unmarshaler, fi.metadata.unmarshaler_factory))
+            for un in fi.unmarshal_names:
+                if un in d:
+                    raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
+                d[un] = tup
+        return ObjectUnmarshaler(
+            ty,
+            d,
+            unknown_field=dc_md.unknown_field,
+        )

omlish/marshal/datetimes.py

@@ -3,16 +3,28 @@ import datetime
 import typing as ta
 
 from .. import check
+from .. import datetimes as dts
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .factories import TypeMapFactory
 from .values import Value
 
 
+DatetimeLikeT = ta.TypeVar('DatetimeLikeT', bound=datetime.datetime | datetime.date | datetime.time)
+
+_DATETIME_LIKES = (
+    datetime.datetime,
+    datetime.date,
+    datetime.time,
+)
+
+
+##
+
+
 DATE_FORMATS: ta.Sequence[str] = [
     '%Y-%m-%d',
 ]
@@ -43,48 +55,92 @@ DATETIME_FORMATS: ta.Sequence[str] = [
 ]
 
 
+##
+
+
 @dc.dataclass(frozen=True)
-class DatetimeMarshaler(Marshaler):
+class DatetimeMarshaler(Marshaler, ta.Generic[DatetimeLikeT]):
+    cls: type[DatetimeLikeT]
     fmt: str
 
-    def marshal(self, ctx: MarshalContext, o: datetime.datetime) -> Value:
+    def marshal(self, ctx: MarshalContext, o: DatetimeLikeT) -> Value:
         return o.strftime(self.fmt)
 
 
+_ZERO_DATE = datetime.datetime.now().strptime('', '').date()  # noqa
+_ZERO_TIME = datetime.time(0)
+
+
 @dc.dataclass(frozen=True)
-class DatetimeUnmarshaler(Unmarshaler):
+class DatetimeUnmarshaler(Unmarshaler, ta.Generic[DatetimeLikeT]):
+    cls: type[DatetimeLikeT]
     fmts: ta.Sequence[str]
     try_iso: bool = False
 
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> datetime.datetime:
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> DatetimeLikeT:
         v = check.isinstance(v, str)
 
         if self.try_iso:
             try:
-                return datetime.datetime.fromisoformat(v)
+                return self.cls.fromisoformat(v)  # type: ignore
             except ValueError:
                 pass
 
         for fmt in self.fmts:
             try:
-                return datetime.datetime.strptime(v, fmt)  # FIXME: timezone  # noqa
+                dt = datetime.datetime.strptime(v, fmt)  # FIXME: timezone  # noqa
             except ValueError:
                 pass
+            else:
+                if self.cls is datetime.datetime:
+                    return dt  # type: ignore
+                elif self.cls is datetime.date:
+                    if dt.time() != _ZERO_TIME:
+                        raise ValueError(dt)
+                    return dt.date()  # type: ignore
+                elif self.cls is datetime.time:
+                    if dt.date() != _ZERO_DATE:
+                        raise ValueError(dt)
+                    return dt.time()  # type: ignore
+                else:
+                    raise TypeError(self.cls)
 
         raise ValueError(v)
 
 
-DATETIME_MARSHALER = DatetimeMarshaler(DATETIME_FORMATS[0])
-DATETIME_UNMARSHALER = DatetimeUnmarshaler(DATETIME_FORMATS, try_iso=True)
-
-DATETIME_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({datetime.datetime: DATETIME_MARSHALER})
-DATETIME_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({datetime.datetime: DATETIME_UNMARSHALER})
+##
 
 
-class IsoDatetimeMarshalerUnmarshaler(Marshaler, Unmarshaler):
+class IsoDatetimeMarshalerUnmarshaler(Marshaler, Unmarshaler, ta.Generic[DatetimeLikeT]):
+    cls: type[DatetimeLikeT]
 
-    def marshal(self, ctx: MarshalContext, o: datetime.datetime) -> Value:
+    def marshal(self, ctx: MarshalContext, o: DatetimeLikeT) -> Value:
         return o.isoformat()
 
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> datetime.datetime:
-        return datetime.datetime.fromisoformat(v)  # type: ignore
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> DatetimeLikeT:
+        return self.cls.fromisoformat(v)  # type: ignore
+
+
+##
+
+
+class TimedeltaMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: datetime.timedelta) -> Value:
+        return str(o)
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return dts.parse_timedelta(check.isinstance(v, str))
+
+
+##
+
+
+DATETIME_MARSHALER_FACTORY = TypeMapMarshalerFactory({
+    **{cls: DatetimeMarshaler(cls, DATETIME_FORMATS[0]) for cls in _DATETIME_LIKES},
+    datetime.timedelta: TimedeltaMarshalerUnmarshaler(),
+})
+
+DATETIME_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({
+    **{cls: DatetimeUnmarshaler(cls, DATETIME_FORMATS, try_iso=True) for cls in _DATETIME_LIKES},
+    datetime.timedelta: TimedeltaMarshalerUnmarshaler(),
+})

omlish/marshal/enums.py

@@ -22,10 +22,13 @@ class EnumMarshaler(Marshaler):
 
 
 class EnumMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, type) and issubclass(rty, enum.Enum):
-            return EnumMarshaler(rty)
-        return None
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and issubclass(rty, enum.Enum)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        ty = check.isinstance(rty, type)
+        check.state(issubclass(ty, enum.Enum))
+        return EnumMarshaler(ty)
 
 
 @dc.dataclass(frozen=True)
@@ -37,7 +40,10 @@ class EnumUnmarshaler(Unmarshaler):
 
 
 class EnumUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, type) and issubclass(rty, enum.Enum):
-            return EnumUnmarshaler(rty)
-        return None
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and issubclass(rty, enum.Enum)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        ty = check.isinstance(rty, type)
+        check.state(issubclass(ty, enum.Enum))
+        return EnumUnmarshaler(ty)

omlish/marshal/exceptions.py

@@ -1,7 +1,17 @@
 from .. import reflect as rfl
 
 
-class UnhandledTypeError(Exception):
+class MarshalError(Exception):
+    pass
+
+
+class UnhandledTypeError(MarshalError):
+    @property
+    def rty(self) -> rfl.Type:
+        return self.args[0]
+
+
+class ForbiddenTypeError(MarshalError):
     @property
     def rty(self) -> rfl.Type:
         return self.args[0]

omlish/marshal/factories.py

@@ -1,86 +1,105 @@
-import abc
 import dataclasses as dc
-import enum
 import threading
 import typing as ta
 
+from .. import check
+from .. import matchfns as mfs
 from .. import reflect as rfl
 
 
 R = ta.TypeVar('R')
 C = ta.TypeVar('C')
-A = ta.TypeVar('A')
-
-
-##
-
-
-class Factory(abc.ABC, ta.Generic[R, C, A]):
-    @abc.abstractmethod
-    def __call__(self, ctx: C, arg: A) -> R | None:
-        raise NotImplementedError
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class FuncFactory(ta.Generic[R, C, A]):
-    fn: ta.Callable[[C, A], R | None]
-
-    def __call__(self, ctx: C, arg: A) -> R | None:
-        return self.fn(ctx, arg)
-
-
-##
+class TypeMapFactory(mfs.MatchFn[[C, rfl.Type], R]):
+    m: ta.Mapping[rfl.Type, R] = dc.field(default_factory=dict)
 
+    def __post_init__(self) -> None:
+        for k in self.m:
+            if not isinstance(k, rfl.TYPES):
+                raise TypeError(k)
 
-@dc.dataclass(frozen=True)
-class TypeMapFactory(Factory[R, C, rfl.Type]):
-    m: ta.Mapping[rfl.Type, R] = dc.field(default_factory=dict)
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        check.isinstance(rty, rfl.TYPES)
+        return rty in self.m
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
-        return self.m.get(rty)
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        check.isinstance(rty, rfl.TYPES)
+        try:
+            return self.m[rty]
+        except KeyError:
+            raise mfs.MatchGuardError(ctx, rty)  # noqa
 
 
 ##
 
 
-class TypeCacheFactory(Factory[R, C, rfl.Type]):
-    def __init__(self, f: Factory[R, C, rfl.Type]) -> None:
+class TypeCacheFactory(mfs.MatchFn[[C, rfl.Type], R]):
+    def __init__(self, f: mfs.MatchFn[[C, rfl.Type], R]) -> None:
         super().__init__()
         self._f = f
         self._dct: dict[rfl.Type, R | None] = {}
         self._mtx = threading.RLock()
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
-        try:
-            return self._dct[rty]
-        except KeyError:
-            pass
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        check.isinstance(rty, rfl.TYPES)
         with self._mtx:
             try:
-                return self._dct[rty]
+                e = self._dct[rty]
             except KeyError:
-                ret = self._dct[rty] = self._f(ctx, rty)
-                return ret
+                if self._f.guard(ctx, rty):
+                    return True
+                else:
+                    self._dct[rty] = None
+                    return False
+            else:
+                return e is not None
+
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        check.isinstance(rty, rfl.TYPES)
+        with self._mtx:
+            try:
+                e = self._dct[rty]
+            except KeyError:
+                try:
+                    ret = self._f(ctx, rty)
+                except mfs.MatchGuardError:
+                    self._dct[rty] = None
+                    raise
+                else:
+                    self._dct[rty] = ret
+                    return ret
+            else:
+                if e is None:
+                    raise mfs.MatchGuardError(ctx, rty)
+                else:
+                    return e
 
 
 ##
 
 
-class RecursiveTypeFactory(Factory[R, C, rfl.Type]):
+class RecursiveTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
     def __init__(
             self,
-            f: Factory[R, C, rfl.Type],
-            prx: ta.Callable[[], tuple[R | None, ta.Callable[[R | None], None]]],
+            f: mfs.MatchFn[[C, rfl.Type], R],
+            prx: ta.Callable[[], tuple[R, ta.Callable[[R], None]]],
     ) -> None:
         super().__init__()
         self._f = f
         self._prx = prx
-        self._dct: dict[rfl.Type, R | None] = {}
+        self._dct: dict[rfl.Type, R] = {}
+
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        check.isinstance(rty, rfl.TYPES)
+        return self._f.guard(ctx, rty)
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        check.isinstance(rty, rfl.TYPES)
         try:
             return self._dct[rty]
         except KeyError:
@@ -93,37 +112,3 @@ class RecursiveTypeFactory(Factory[R, C, rfl.Type]):
             return r
         finally:
             del self._dct[rty]
-
-
-##
-
-
-class CompositeFactory(Factory[R, C, A]):
-    class Strategy(enum.Enum):
-        FIRST = enum.auto()
-        ONE = enum.auto()
-
-    def __init__(self, *fs: Factory[R, C, A], strategy: Strategy = Strategy.FIRST) -> None:
-        super().__init__()
-        self._fs = fs
-        self._st = strategy
-
-    def __call__(self, ctx: C, arg: A) -> R | None:
-        w: list[R] = []
-        for c in self._fs:
-            if (r := c(ctx, arg)) is None:
-                continue
-            if self._st is CompositeFactory.Strategy.FIRST:
-                return r
-            w.append(r)
-
-        if not w:
-            return None
-
-        if self._st is CompositeFactory.Strategy.ONE:
-            if len(w) == 1:
-                return w[0]
-
-            raise TypeError(f'multiple implementations: {arg} {w}')
-
-        raise TypeError(f'unknown composite strategy: {self._st}')

omlish/marshal/forbidden.py

@@ -0,0 +1,35 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import matchfns as mfs
+from .. import reflect as rfl
+from .base import MarshalContext
+from .base import Marshaler
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .exceptions import ForbiddenTypeError
+
+
+C = ta.TypeVar('C')
+R = ta.TypeVar('R')
+
+
+@dc.dataclass(frozen=True)
+class ForbiddenTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
+    rtys: ta.AbstractSet[rfl.Type]
+
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        return rty in self.rtys
+
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        raise ForbiddenTypeError(rty)
+
+
+@dc.dataclass(frozen=True)
+class ForbiddenTypeMarshalerFactory(ForbiddenTypeFactory[MarshalContext, Marshaler]):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class ForbiddenTypeUnmarshalerFactory(ForbiddenTypeFactory[UnmarshalContext, Unmarshaler]):
+    pass

omlish/marshal/global_.py

@@ -1,7 +1,10 @@
 import typing as ta
 
+from .. import lang
 from .base import MarshalContext
+from .base import MarshalerFactory
 from .base import UnmarshalContext
+from .base import UnmarshalerFactory
 from .registries import Registry
 from .standard import new_standard_marshaler_factory
 from .standard import new_standard_unmarshaler_factory
@@ -20,20 +23,24 @@ GLOBAL_REGISTRY = Registry()
 ##
 
 
-GLOBAL_MARSHALER_FACTORY = new_standard_marshaler_factory()
+@lang.cached_function(lock=True)
+def global_marshaler_factory() -> MarshalerFactory:
+    return new_standard_marshaler_factory()
 
 
 def marshal(obj: ta.Any, ty: type | None = None, **kwargs: ta.Any) -> Value:
-    mc = MarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_MARSHALER_FACTORY, **kwargs)
+    mc = MarshalContext(GLOBAL_REGISTRY, factory=global_marshaler_factory(), **kwargs)
     return mc.make(ty if ty is not None else type(obj)).marshal(mc, obj)
 
 
 ##
 
 
-GLOBAL_UNMARSHALER_FACTORY = new_standard_unmarshaler_factory()
+@lang.cached_function(lock=True)
+def global_unmarshaler_factory() -> UnmarshalerFactory:
+    return new_standard_unmarshaler_factory()
 
 
 def unmarshal(v: Value, ty: type[T], **kwargs: ta.Any) -> T:
-    uc = UnmarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_UNMARSHALER_FACTORY, **kwargs)
+    uc = UnmarshalContext(GLOBAL_REGISTRY, factory=global_unmarshaler_factory(), **kwargs)
     return uc.make(ty).unmarshal(uc, v)