omlish 0.0.0.dev6__py3-none-any.whl → 0.0.0.dev8__py3-none-any.whl

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)

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/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/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()))