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

omlish/marshal/iterables.py

@@ -4,13 +4,14 @@ import functools
 import typing as ta
 
 from .. import check
+from .. import matchfns as mfs
 from .. import reflect as rfl
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import MarshalerFactoryMatchClass
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
+from .base import UnmarshalerFactoryMatchClass
 from .values import Value
 
 
@@ -22,17 +23,15 @@ class IterableMarshaler(Marshaler):
         return list(map(functools.partial(self.e.marshal, ctx), o))
 
 
-class IterableMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable):
-            if (e := ctx.make(check.single(rty.args))) is None:
-                return None  # type: ignore
-            return IterableMarshaler(e)
-        if isinstance(rty, type) and issubclass(rty, collections.abc.Iterable):
-            if (e := ctx.make(ta.Any)) is None:
-                return None  # type: ignore
-            return IterableMarshaler(e)
-        return None
+class IterableMarshalerFactory(MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable))
+    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        gty = check.isinstance(rty, rfl.Generic)
+        return IterableMarshaler(ctx.make(check.single(gty.args)))
+
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Iterable))
+    def _build_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        return IterableMarshaler(ctx.make(ta.Any))
 
 
 @dc.dataclass(frozen=True)
@@ -44,14 +43,12 @@ class IterableUnmarshaler(Unmarshaler):
         return self.ctor(map(functools.partial(self.e.unmarshal, ctx), check.isinstance(v, collections.abc.Iterable)))
 
 
-class IterableUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable):
-            if (e := ctx.make(check.single(rty.args))) is None:
-                return None  # type: ignore
-            return IterableUnmarshaler(rty.cls, e)  # noqa
-        if isinstance(rty, type) and issubclass(rty, collections.abc.Iterable):
-            if (e := ctx.make(ta.Any)) is None:
-                return None  # type: ignore
-            return IterableUnmarshaler(rty, e)  # noqa
-        return None
+class IterableUnmarshalerFactory(UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable))
+    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        gty = check.isinstance(rty, rfl.Generic)
+        return IterableUnmarshaler(gty.cls, ctx.make(check.single(gty.args)))
+
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Iterable))
+    def _build_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        return IterableUnmarshaler(check.isinstance(rty, type), ctx.make(ta.Any))

omlish/marshal/mappings.py

@@ -3,13 +3,14 @@ import dataclasses as dc
 import typing as ta
 
 from .. import check
+from .. import matchfns as mfs
 from .. import reflect as rfl
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import MarshalerFactoryMatchClass
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
+from .base import UnmarshalerFactoryMatchClass
 from .values import Value
 
 
@@ -25,18 +26,16 @@ class MappingMarshaler(Marshaler):
         }
 
 
-class MappingMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping):
-            kt, vt = rty.args
-            if (ke := ctx.make(kt)) is None or (ve := ctx.make(vt)) is None:
-                return None  # type: ignore
-            return MappingMarshaler(ke, ve)
-        if isinstance(rty, type) and issubclass(rty, collections.abc.Mapping):
-            if (e := ctx.make(ta.Any)) is None:
-                return None  # type: ignore
-            return MappingMarshaler(e, e)
-        return None
+class MappingMarshalerFactory(MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping))
+    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        gty = check.isinstance(rty, rfl.Generic)
+        kt, vt = gty.args
+        return MappingMarshaler(ctx.make(kt), ctx.make(vt))
+
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Mapping))
+    def _build_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        return MappingMarshaler(a := ctx.make(ta.Any), a)
 
 
 @dc.dataclass(frozen=True)
@@ -52,15 +51,13 @@ class MappingUnmarshaler(Unmarshaler):
         return self.ctor(dct)
 
 
-class MappingUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping):
-            kt, vt = rty.args
-            if (ke := ctx.make(kt)) is None or (ve := ctx.make(vt)) is None:
-                return None  # type: ignore
-            return MappingUnmarshaler(rty.cls, ke, ve)
-        if isinstance(rty, type) and issubclass(rty, collections.abc.Mapping):
-            if (e := ctx.make(ta.Any)) is None:
-                return None  # type: ignore
-            return MappingUnmarshaler(rty, e, e)
-        return None
+class MappingUnmarshalerFactory(UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping))
+    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        gty = check.isinstance(rty, rfl.Generic)
+        kt, vt = gty.args
+        return MappingUnmarshaler(gty.cls, ctx.make(kt), ctx.make(vt))
+
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Mapping))
+    def _build_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        return MappingUnmarshaler(check.isinstance(rty, type), a := ctx.make(ta.Any), a)

omlish/marshal/naming.py

@@ -7,6 +7,7 @@ from .base import Option
 class Naming(Option, enum.Enum):
     SNAKE = 'snake'
     CAMEL = 'camel'
+    LOW_CAMEL = 'low_camel'
 
 
 def translate_name(n: str, e: Naming) -> str:
@@ -14,4 +15,7 @@ def translate_name(n: str, e: Naming) -> str:
         return lang.snake_case(n)
     if e is Naming.CAMEL:
         return lang.camel_case(n)
+    if e is Naming.LOW_CAMEL:
+        r = lang.camel_case(n)
+        return (r[0].lower() + r[1:]) if r else r
     raise ValueError(e)

omlish/marshal/numbers.py

@@ -0,0 +1,51 @@
+import decimal
+import fractions
+import typing as ta
+
+from .. import check
+from .base import MarshalContext
+from .base import Marshaler
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .values import Value
+
+
+class ComplexMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: complex) -> Value:
+        return [o.real, o.imag]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        real, imag = check.isinstance(v, list)
+        return complex(real, imag)  # type: ignore
+
+
+class DecimalMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: decimal.Decimal) -> Value:
+        return str(o)
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return decimal.Decimal(check.isinstance(v, str))
+
+
+class FractionMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: fractions.Fraction) -> Value:
+        return [o.numerator, o.denominator]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        num, denom = check.isinstance(v, list)
+        return fractions.Fraction(num, denom)  # type: ignore
+
+
+NUMBERS_MARSHALER_FACTORY = TypeMapMarshalerFactory({
+    complex: ComplexMarshalerUnmarshaler(),
+    decimal.Decimal: DecimalMarshalerUnmarshaler(),
+    fractions.Fraction: FractionMarshalerUnmarshaler(),
+})
+
+NUMBERS_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({
+    complex: ComplexMarshalerUnmarshaler(),
+    decimal.Decimal: DecimalMarshalerUnmarshaler(),
+    fractions.Fraction: FractionMarshalerUnmarshaler(),
+})

omlish/marshal/objects.py

@@ -2,6 +2,7 @@
 TODO:
  - cfg naming
  - adapters for dataclasses / namedtuples / user objects (as confitured)
+ - mro-merge ObjectMetadata
 """
 import collections.abc
 import typing as ta

omlish/marshal/optionals.py

@@ -1,6 +1,7 @@
 import dataclasses as dc
 import typing as ta
 
+from .. import check
 from .. import reflect as rfl
 from .base import MarshalContext
 from .base import Marshaler
@@ -22,12 +23,11 @@ class OptionalMarshaler(Marshaler):
 
 
 class OptionalMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, rfl.Union) and rty.is_optional:
-            if (e := ctx.make(rty.without_none())) is None:
-                return None  # type: ignore
-            return OptionalMarshaler(e)
-        return None
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and rty.is_optional
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        return OptionalMarshaler(ctx.make(check.isinstance(rty, rfl.Union).without_none()))
 
 
 @dc.dataclass(frozen=True)
@@ -41,9 +41,8 @@ class OptionalUnmarshaler(Unmarshaler):
 
 
 class OptionalUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, rfl.Union) and rty.is_optional:
-            if (e := ctx.make(rty.without_none())) is None:
-                return None  # type: ignore
-            return OptionalUnmarshaler(e)
-        return None
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and rty.is_optional
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        return OptionalUnmarshaler(ctx.make(check.isinstance(rty, rfl.Union).without_none()))

omlish/marshal/polymorphism.py

@@ -19,12 +19,29 @@ from .base import Unmarshaler
 from .base import UnmarshalerFactory
 from .naming import Naming
 from .naming import translate_name
+from .registries import RegistryItem
 from .values import Value
 
 
 ##
 
 
+class TypeTagging(RegistryItem, lang.Abstract, lang.Sealed):
+    pass
+
+
+class WrapperTypeTagging(TypeTagging, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class FieldTypeTagging(TypeTagging, lang.Final):
+    field: str
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class Impl:
     ty: type
@@ -33,7 +50,11 @@ class Impl:
 
 
 class Polymorphism:
-    def __init__(self, ty: type, impls: ta.Iterable[Impl]) -> None:
+    def __init__(
+            self,
+            ty: type,
+            impls: ta.Iterable[Impl],
+    ) -> None:
         super().__init__()
         self._ty = ty
         self._impls = list(impls)
@@ -72,7 +93,11 @@ class Polymorphism:
         return self._by_tag
 
 
-def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> Polymorphism:
+def polymorphism_from_subclasses(
+        ty: type,
+        *,
+        naming: Naming | None = None,
+) -> Polymorphism:
     dct: dict[str, Impl] = {}
     seen: set[type] = set()
     todo: list[type] = [ty]
@@ -97,7 +122,7 @@ def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> P
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismMarshaler(Marshaler):
+class WrapperPolymorphismMarshaler(Marshaler):
     m: ta.Mapping[type, tuple[str, Marshaler]]
 
     def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
@@ -105,24 +130,43 @@ class PolymorphismMarshaler(Marshaler):
         return {tag: m.marshal(ctx, o)}
 
 
+@dc.dataclass(frozen=True)
+class FieldPolymorphismMarshaler(Marshaler):
+    m: ta.Mapping[type, tuple[str, Marshaler]]
+    tf: str
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        tag, m = self.m[type(o)]
+        return {self.tf: tag, **m.marshal(ctx, o)}  # type: ignore
+
+
 @dc.dataclass(frozen=True)
 class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
+    tt: TypeTagging = WrapperTypeTagging()
 
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if rty is self.p.ty:
-            return PolymorphismMarshaler({
-                i.ty: (i.tag, ctx.make(i.ty))
-                for i in self.p.impls
-            })
-        return None
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return rty is self.p.ty
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        check.is_(rty, self.p.ty)
+        m = {
+            i.ty: (i.tag, ctx.make(i.ty))
+            for i in self.p.impls
+        }
+        if isinstance(self.tt, WrapperTypeTagging):
+            return WrapperPolymorphismMarshaler(m)
+        elif isinstance(self.tt, FieldTypeTagging):
+            return FieldPolymorphismMarshaler(m, self.tt.field)
+        else:
+            raise TypeError(self.tt)
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnmarshaler(Unmarshaler):
+class WrapperPolymorphismUnmarshaler(Unmarshaler):
     m: ta.Mapping[str, Unmarshaler]
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
@@ -132,16 +176,37 @@ class PolymorphismUnmarshaler(Unmarshaler):
         return u.unmarshal(ctx, iv)  # type: ignore
 
 
+@dc.dataclass(frozen=True)
+class FieldPolymorphismUnmarshaler(Unmarshaler):
+    m: ta.Mapping[str, Unmarshaler]
+    tf: str
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        ma = dict(check.isinstance(v, collections.abc.Mapping))
+        tag = ma.pop(self.tf)  # type: ignore
+        u = self.m[tag]  # type: ignore
+        return u.unmarshal(ctx, ma)
+
+
 @dc.dataclass(frozen=True)
 class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
     p: Polymorphism
-
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if rty is self.p.ty:
-            return PolymorphismUnmarshaler({
-                t: u
-                for i in self.p.impls
-                for u in [ctx.make(i.ty)]
-                for t in [i.tag, *i.alts]
-            })
-        return None
+    tt: TypeTagging = WrapperTypeTagging()
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return rty is self.p.ty
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        check.is_(rty, self.p.ty)
+        m = {
+            t: u
+            for i in self.p.impls
+            for u in [ctx.make(i.ty)]
+            for t in [i.tag, *i.alts]
+        }
+        if isinstance(self.tt, WrapperTypeTagging):
+            return WrapperPolymorphismUnmarshaler(m)
+        elif isinstance(self.tt, FieldTypeTagging):
+            return FieldPolymorphismUnmarshaler(m, self.tt.field)
+        else:
+            raise TypeError(self.tt)

omlish/marshal/primitives.py

@@ -2,11 +2,10 @@ import typing as ta
 
 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
 
 
@@ -34,10 +33,10 @@ class PrimitiveMarshalerUnmarshaler(Marshaler, Unmarshaler):
 
 PRIMITIVE_MARSHALER_UNMARSHALER = PrimitiveMarshalerUnmarshaler()
 
-PRIMITIVE_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({  # noqa
+PRIMITIVE_MARSHALER_FACTORY = TypeMapMarshalerFactory({  # noqa
     t: PRIMITIVE_MARSHALER_UNMARSHALER for t in PRIMITIVE_TYPES
 })
 
-PRIMITIVE_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({  # noqa
+PRIMITIVE_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({  # noqa
     t: PRIMITIVE_MARSHALER_UNMARSHALER for t in PRIMITIVE_TYPES
 })

omlish/marshal/standard.py

@@ -1,8 +1,11 @@
+from .. import matchfns as mfs
 from .any import ANY_MARSHALER_FACTORY
 from .any import ANY_UNMARSHALER_FACTORY
 from .base import MarshalerFactory
 from .base import RecursiveMarshalerFactory
 from .base import RecursiveUnmarshalerFactory
+from .base import TypeCacheMarshalerFactory
+from .base import TypeCacheUnmarshalerFactory
 from .base import UnmarshalerFactory
 from .base64 import BASE64_MARSHALER_FACTORY
 from .base64 import BASE64_UNMARSHALER_FACTORY
@@ -12,12 +15,12 @@ from .datetimes import DATETIME_MARSHALER_FACTORY
 from .datetimes import DATETIME_UNMARSHALER_FACTORY
 from .enums import EnumMarshalerFactory
 from .enums import EnumUnmarshalerFactory
-from .factories import CompositeFactory
-from .factories import TypeCacheFactory
 from .iterables import IterableMarshalerFactory
 from .iterables import IterableUnmarshalerFactory
 from .mappings import MappingMarshalerFactory
 from .mappings import MappingUnmarshalerFactory
+from .numbers import NUMBERS_MARSHALER_FACTORY
+from .numbers import NUMBERS_UNMARSHALER_FACTORY
 from .optionals import OptionalMarshalerFactory
 from .optionals import OptionalUnmarshalerFactory
 from .primitives import PRIMITIVE_MARSHALER_FACTORY
@@ -34,6 +37,7 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     OptionalMarshalerFactory(),
     DataclassMarshalerFactory(),
     EnumMarshalerFactory(),
+    NUMBERS_MARSHALER_FACTORY,
     UUID_MARSHALER_FACTORY,
     BASE64_MARSHALER_FACTORY,
     DATETIME_MARSHALER_FACTORY,
@@ -44,10 +48,10 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
 
 
 def new_standard_marshaler_factory() -> MarshalerFactory:
-    return TypeCacheFactory(  # noqa
+    return TypeCacheMarshalerFactory(
         RecursiveMarshalerFactory(
-            CompositeFactory(
-                *STANDARD_MARSHALER_FACTORIES,
+            mfs.MultiMatchFn(
+                list(STANDARD_MARSHALER_FACTORIES),
             ),
         ),
     )
@@ -61,6 +65,7 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     OptionalUnmarshalerFactory(),
     DataclassUnmarshalerFactory(),
     EnumUnmarshalerFactory(),
+    NUMBERS_UNMARSHALER_FACTORY,
     UUID_UNMARSHALER_FACTORY,
     BASE64_UNMARSHALER_FACTORY,
     DATETIME_UNMARSHALER_FACTORY,
@@ -71,10 +76,10 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
 
 
 def new_standard_unmarshaler_factory() -> UnmarshalerFactory:
-    return TypeCacheFactory(  # noqa
+    return TypeCacheUnmarshalerFactory(
         RecursiveUnmarshalerFactory(
-            CompositeFactory(
-                *STANDARD_UNMARSHALER_FACTORIES,
+            mfs.MultiMatchFn(
+                list(STANDARD_UNMARSHALER_FACTORIES),
             ),
         ),
     )

omlish/marshal/uuids.py

@@ -4,11 +4,10 @@ import uuid
 from .. import check
 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
 
 
@@ -25,5 +24,5 @@ class UuidMarshalerUnmarshaler(Marshaler, Unmarshaler):
 
 UUID_MARSHALER_UNMARSHALER = UuidMarshalerUnmarshaler()
 
-UUID_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})
-UUID_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})
+UUID_MARSHALER_FACTORY = TypeMapMarshalerFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})
+UUID_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})