omlish 0.0.0.dev414__py3-none-any.whl → 0.0.0.dev416__py3-none-any.whl

omlish/marshal/base/types.py

@@ -0,0 +1,122 @@
+import abc
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from .contexts import MarshalContext
+from .contexts import UnmarshalContext
+from .registries import Registry
+from .values import Value
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class Marshaler(lang.Abstract):
+    @abc.abstractmethod
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        raise NotImplementedError
+
+
+class Unmarshaler(lang.Abstract):
+    @abc.abstractmethod
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        raise NotImplementedError
+
+
+##
+
+
+MarshalerMaker: ta.TypeAlias = mfs.MatchFn[[MarshalContext, rfl.Type], Marshaler]
+UnmarshalerMaker: ta.TypeAlias = mfs.MatchFn[[UnmarshalContext, rfl.Type], Unmarshaler]
+
+
+class MarshalerFactory(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def make_marshaler(self) -> MarshalerMaker:
+        raise NotImplementedError
+
+
+class UnmarshalerFactory(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class MarshalerFactory_(MarshalerFactory):  # noqa
+    fn: MarshalerMaker
+
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self.fn
+
+
+@dc.dataclass(frozen=True)
+class UnmarshalerFactory_(UnmarshalerFactory):  # noqa
+    fn: UnmarshalerMaker
+
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self.fn
+
+
+##
+
+
+class Marshaling(lang.Abstract):
+    @abc.abstractmethod
+    def registry(self) -> Registry:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def marshaler_factory(self) -> MarshalerFactory:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def unmarshaler_factory(self) -> UnmarshalerFactory:
+        raise NotImplementedError
+
+    #
+
+    def new_marshal_context(self, **kwargs: ta.Any) -> MarshalContext:
+        return MarshalContext(
+            self.registry(),
+            factory=self.marshaler_factory(),
+            **kwargs,
+        )
+
+    def new_unmarshal_context(self, **kwargs: ta.Any) -> UnmarshalContext:
+        return UnmarshalContext(
+            self.registry(),
+            factory=self.unmarshaler_factory(),
+            **kwargs,
+        )
+
+    #
+
+    @ta.final
+    def marshal(self, obj: ta.Any, ty: ta.Any | None = None, **kwargs: ta.Any) -> Value:
+        return self.new_marshal_context(**kwargs).marshal(obj, ty)
+
+    @ta.overload
+    def unmarshal(self, v: Value, ty: type[T], **kwargs: ta.Any) -> T:
+        ...
+
+    @ta.overload
+    def unmarshal(self, v: Value, ty: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        ...
+
+    @ta.final
+    def unmarshal(self, v, ty, **kwargs):
+        return self.new_unmarshal_context(**kwargs).unmarshal(v, ty)

omlish/marshal/{values.py → base/values.py}

@@ -1,19 +1,7 @@
-"""
-Null
-Bool
-Int
-Float
-Number
-String
-Bytes
-Array
-Object
-Any
-"""
 import typing as ta
 
 
-Value = ta.Union[  # noqa
+Value: ta.TypeAlias = ta.Union[  # noqa
     None,
 
     bool,

omlish/marshal/composite/iterables.py

@@ -10,13 +10,13 @@ import typing as ta
 from ... import check
 from ... import reflect as rfl
 from ...funcs import match as mfs
-from ..base import MarshalContext
-from ..base import Marshaler
-from ..base import MarshalerFactoryMatchClass
-from ..base import UnmarshalContext
-from ..base import Unmarshaler
-from ..base import UnmarshalerFactoryMatchClass
-from ..values import Value
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
+from ..factories.match import MarshalerFactoryMatchClass
+from ..factories.match import UnmarshalerFactoryMatchClass
 
 
 ##

omlish/marshal/composite/literals.py

@@ -3,13 +3,13 @@ import typing as ta
 
 from ... import check
 from ... import reflect as rfl
-from ..base import MarshalContext
-from ..base import Marshaler
-from ..base import SimpleMarshalerFactory
-from ..base import SimpleUnmarshalerFactory
-from ..base import UnmarshalContext
-from ..base import Unmarshaler
-from ..values import Value
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
+from ..factories.simple import SimpleMarshalerFactory
+from ..factories.simple import SimpleUnmarshalerFactory
 
 
 ##

omlish/marshal/composite/mappings.py

@@ -5,13 +5,13 @@ import typing as ta
 from ... import check
 from ... import reflect as rfl
 from ...funcs import match as mfs
-from ..base import MarshalContext
-from ..base import Marshaler
-from ..base import MarshalerFactoryMatchClass
-from ..base import UnmarshalContext
-from ..base import Unmarshaler
-from ..base import UnmarshalerFactoryMatchClass
-from ..values import Value
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
+from ..factories.match import MarshalerFactoryMatchClass
+from ..factories.match import UnmarshalerFactoryMatchClass
 
 
 ##

omlish/marshal/composite/maybes.py

@@ -9,13 +9,13 @@ from ... import check
 from ... import lang
 from ... import reflect as rfl
 from ...funcs import match as mfs
-from ..base import MarshalContext
-from ..base import Marshaler
-from ..base import MarshalerFactoryMatchClass
-from ..base import UnmarshalContext
-from ..base import Unmarshaler
-from ..base import UnmarshalerFactoryMatchClass
-from ..values import Value
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
+from ..factories.match import MarshalerFactoryMatchClass
+from ..factories.match import UnmarshalerFactoryMatchClass
 
 
 ##

omlish/marshal/composite/newtypes.py

@@ -1,11 +1,11 @@
 from ... import check
 from ... import reflect as rfl
-from ..base import MarshalContext
-from ..base import Marshaler
-from ..base import SimpleMarshalerFactory
-from ..base import SimpleUnmarshalerFactory
-from ..base import UnmarshalContext
-from ..base import Unmarshaler
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..factories.simple import SimpleMarshalerFactory
+from ..factories.simple import SimpleUnmarshalerFactory
 
 
 ##

omlish/marshal/composite/optionals.py

@@ -3,13 +3,13 @@ import typing as ta
 
 from ... import check
 from ... import reflect as rfl
-from ..base import MarshalContext
-from ..base import Marshaler
-from ..base import SimpleMarshalerFactory
-from ..base import SimpleUnmarshalerFactory
-from ..base import UnmarshalContext
-from ..base import Unmarshaler
-from ..values import Value
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
+from ..factories.simple import SimpleMarshalerFactory
+from ..factories.simple import SimpleUnmarshalerFactory
 
 
 ##

omlish/marshal/composite/special.py

@@ -4,12 +4,12 @@ from ... import check
 from ... import lang
 from ... import reflect as rfl
 from ...funcs import match as mfs
-from ..base import MarshalContext
-from ..base import Marshaler
-from ..base import MarshalerFactoryMatchClass
-from ..base import UnmarshalContext
-from ..base import Unmarshaler
-from ..base import UnmarshalerFactoryMatchClass
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..factories.match import MarshalerFactoryMatchClass
+from ..factories.match import UnmarshalerFactoryMatchClass
 from .iterables import DEFAULT_ITERABLE_CONCRETE_TYPES
 from .iterables import IterableMarshaler
 from .iterables import IterableUnmarshaler

omlish/marshal/composite/wrapped.py

@@ -1,11 +1,11 @@
 import dataclasses as dc
 import typing as ta
 
-from ..base import MarshalContext
-from ..base import Marshaler
-from ..base import UnmarshalContext
-from ..base import Unmarshaler
-from ..values import Value
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
 
 
 ##

omlish/marshal/factories/func.py

@@ -0,0 +1,28 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FuncMarshaler(Marshaler, lang.Final):
+    fn: ta.Callable[[MarshalContext, ta.Any], Value]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        return self.fn(ctx, o)
+
+
+@dc.dataclass(frozen=True)
+class FuncUnmarshaler(Unmarshaler, lang.Final):
+    fn: ta.Callable[[UnmarshalContext, Value], ta.Any]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return self.fn(ctx, v)

omlish/marshal/factories/match.py

@@ -0,0 +1,34 @@
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
+from ..base.types import MarshalerMaker
+from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
+from ..base.types import UnmarshalerMaker
+
+
+##
+
+
+class MarshalerFactoryMatchClass(
+    MarshalerFactory,
+    mfs.MatchFnClass[[MarshalContext, rfl.Type], Marshaler],
+    lang.Abstract,
+):
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self  # noqa
+
+
+class UnmarshalerFactoryMatchClass(
+    UnmarshalerFactory,
+    mfs.MatchFnClass[[UnmarshalContext, rfl.Type], Unmarshaler],
+    lang.Abstract,
+):
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self  # noqa

omlish/marshal/factories/multi.py

@@ -0,0 +1,55 @@
+import typing as ta
+
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
+from ..base.types import MarshalerMaker
+from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
+from ..base.types import UnmarshalerMaker
+
+
+##
+
+
+class MultiMarshalerFactory(MarshalerFactory):
+    def __init__(
+            self,
+            fs: ta.Iterable[MarshalerFactory],
+            *,
+            strict: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._fs = list(fs)
+        self._mmf: mfs.MultiMatchFn[[MarshalContext, rfl.Type], Marshaler] = mfs.MultiMatchFn(
+            [f.make_marshaler for f in self._fs],
+            strict=strict,
+        )
+
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self._mmf
+
+
+class MultiUnmarshalerFactory(UnmarshalerFactory):
+    def __init__(
+            self,
+            fs: ta.Iterable[UnmarshalerFactory],
+            *,
+            strict: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._fs = list(fs)
+        self._mmf: mfs.MultiMatchFn[[UnmarshalContext, rfl.Type], Unmarshaler] = mfs.MultiMatchFn(
+            [f.make_unmarshaler for f in self._fs],
+            strict=strict,
+        )
+
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self._mmf

omlish/marshal/factories/recursive.py

@@ -0,0 +1,120 @@
+import typing as ta
+
+from ... import check
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
+from ..base.types import MarshalerMaker
+from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
+from ..base.types import UnmarshalerMaker
+from ..base.values import Value
+
+
+T = ta.TypeVar('T')
+R = ta.TypeVar('R')
+C = ta.TypeVar('C')
+
+
+##
+
+
+class _RecursiveTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
+    def __init__(
+            self,
+            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] = {}
+
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        check.isinstance(rty, rfl.TYPES)
+        return self._f.guard(ctx, rty)
+
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        check.isinstance(rty, rfl.TYPES)
+        try:
+            return self._dct[rty]
+        except KeyError:
+            pass
+        p, sp = self._prx()
+        self._dct[rty] = p
+        try:
+            r = self._f(ctx, rty)
+            sp(r)
+            return r
+        finally:
+            del self._dct[rty]
+
+
+##
+
+
+class _Proxy(ta.Generic[T]):
+    __obj: T | None = None
+
+    @property
+    def _obj(self) -> T:
+        if self.__obj is None:
+            raise TypeError('recursive proxy not set')
+        return self.__obj
+
+    def _set_obj(self, obj: T) -> None:
+        if self.__obj is not None:
+            raise TypeError('recursive proxy already set')
+        self.__obj = obj
+
+    @classmethod
+    def _new(cls) -> tuple[ta.Any, ta.Callable[[ta.Any], None]]:
+        return (p := cls()), p._set_obj  # noqa
+
+
+##
+
+
+class _ProxyMarshaler(_Proxy[Marshaler], Marshaler):
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        return self._obj.marshal(ctx, o)
+
+
+class RecursiveMarshalerFactory(MarshalerFactory, lang.Final):
+    def __init__(self, f: MarshalerFactory) -> None:
+        super().__init__()
+
+        self._f = f
+        self._rtf: _RecursiveTypeFactory[MarshalContext, Marshaler] = _RecursiveTypeFactory(
+            self._f.make_marshaler,  # noqa
+            _ProxyMarshaler._new,  # noqa
+        )
+
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self._rtf
+
+
+class _ProxyUnmarshaler(_Proxy[Unmarshaler], Unmarshaler):
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return self._obj.unmarshal(ctx, v)
+
+
+class RecursiveUnmarshalerFactory(UnmarshalerFactory, lang.Final):
+    def __init__(self, f: UnmarshalerFactory) -> None:
+        super().__init__()
+
+        self._f = f
+        self._rtf: _RecursiveTypeFactory[UnmarshalContext, Unmarshaler] = _RecursiveTypeFactory(
+            self._f.make_unmarshaler,  # noqa
+            _ProxyUnmarshaler._new,  # noqa
+        )
+
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self._rtf

omlish/marshal/factories/simple.py

@@ -0,0 +1,28 @@
+from ... import lang
+from ..base.types import MarshalerFactory
+from ..base.types import MarshalerMaker
+from ..base.types import UnmarshalerFactory
+from ..base.types import UnmarshalerMaker
+
+
+##
+
+
+class SimpleMarshalerFactory(
+    MarshalerFactory,
+    MarshalerMaker,
+    lang.Abstract,
+):
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self  # noqa
+
+
+class SimpleUnmarshalerFactory(
+    UnmarshalerFactory,
+    UnmarshalerMaker,
+    lang.Abstract,
+):
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self  # noqa

omlish/marshal/factories/typecache.py

@@ -0,0 +1,91 @@
+import threading
+import typing as ta
+
+from ... import check
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
+from ..base.types import MarshalerMaker
+from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
+from ..base.types import UnmarshalerMaker
+
+
+R = ta.TypeVar('R')
+C = ta.TypeVar('C')
+
+
+##
+
+
+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._lock = threading.RLock()
+
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        check.isinstance(rty, rfl.TYPES)
+        with self._lock:
+            try:
+                e = self._dct[rty]
+            except KeyError:
+                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._lock:
+            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 TypeCacheMarshalerFactory(MarshalerFactory):
+    def __init__(self, f: MarshalerFactory) -> None:
+        super().__init__()
+
+        self._f = f
+        self._tcf: _TypeCacheFactory[MarshalContext, Marshaler] = _TypeCacheFactory(f.make_marshaler)
+
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self._tcf
+
+
+class TypeCacheUnmarshalerFactory(UnmarshalerFactory):
+    def __init__(self, f: UnmarshalerFactory) -> None:
+        super().__init__()
+
+        self._f = f
+        self._tcf: _TypeCacheFactory[UnmarshalContext, Unmarshaler] = _TypeCacheFactory(f.make_unmarshaler)
+
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self._tcf