omlish 0.0.0.dev413__py3-none-any.whl → 0.0.0.dev415__py3-none-any.whl

omlish/marshal/base/contexts.py

@@ -0,0 +1,75 @@
+import typing as ta
+
+from ... import check
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from .errors import UnhandledTypeError
+from .options import Option
+from .overrides import ReflectOverride
+from .registries import Registry
+from .types import Marshaler
+from .types import MarshalerFactory
+from .types import Unmarshaler
+from .types import UnmarshalerFactory
+from .values import Value
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class BaseContext(lang.Abstract):
+    registry: Registry
+    options: col.TypeMap[Option] = col.TypeMap()
+
+    def _reflect(self, o: ta.Any) -> rfl.Type:
+        def override(o):
+            if (ovr := self.registry.get_of(o, ReflectOverride)):
+                return ovr[-1].rty
+            return None
+
+        return rfl.Reflector(override=override).type(o)
+
+
+@dc.dataclass(frozen=True)
+class MarshalContext(BaseContext, lang.Final):
+    factory: MarshalerFactory | None = None
+
+    def make(self, o: ta.Any) -> Marshaler:
+        rty = self._reflect(o)
+        try:
+            return check.not_none(self.factory).make_marshaler(self, rty)
+        except mfs.MatchGuardError:
+            raise UnhandledTypeError(rty)  # noqa
+
+    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)
+class UnmarshalContext(BaseContext, lang.Final):
+    factory: UnmarshalerFactory | None = None
+
+    def make(self, o: ta.Any) -> Unmarshaler:
+        rty = self._reflect(o)
+        try:
+            return check.not_none(self.factory).make_unmarshaler(self, rty)
+        except mfs.MatchGuardError:
+            raise UnhandledTypeError(rty)  # noqa
+
+    @ta.overload
+    def unmarshal(self, v: Value, ty: type[T]) -> T:
+        ...
+
+    @ta.overload
+    def unmarshal(self, v: Value, ty: ta.Any) -> ta.Any:
+        ...
+
+    def unmarshal(self, v, ty):
+        return self.make(ty).unmarshal(self, v)

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

@@ -1,4 +1,4 @@
-from .. import reflect as rfl
+from ... import reflect as rfl
 
 
 ##

omlish/marshal/base/options.py

@@ -0,0 +1,2 @@
+class Option:
+    pass

omlish/marshal/base/overrides.py

@@ -0,0 +1,25 @@
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from .registries import RegistryItem
+from .types import Marshaler
+from .types import MarshalerFactory
+from .types import Unmarshaler
+from .types import UnmarshalerFactory
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Override(RegistryItem, lang.Final):
+    marshaler: Marshaler | None = dc.xfield(None, check_type=(Marshaler, None))
+    marshaler_factory: MarshalerFactory | None = None
+
+    unmarshaler: Unmarshaler | None = dc.xfield(None, check_type=(Unmarshaler, None))
+    unmarshaler_factory: UnmarshalerFactory | None = None
+
+
+@dc.dataclass(frozen=True)
+class ReflectOverride(RegistryItem, lang.Final):
+    rty: rfl.Type

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

@@ -1,13 +1,9 @@
-"""
-TODO:
- - inheritance
-"""
 import dataclasses as dc
 import threading
 import typing as ta
 
-from .. import collections as col
-from .. import lang
+from ... import collections as col
+from ... import lang
 
 
 ##
@@ -36,7 +32,7 @@ class Registry:
     def __init__(self) -> None:
         super().__init__()
 
-        self._mtx = threading.Lock()
+        self._lock = threading.Lock()
         self._idct: ta.MutableMapping[ta.Any, _KeyRegistryItems] = col.IdentityKeyDict()
         self._dct: dict[ta.Any, _KeyRegistryItems] = {}
 
@@ -46,7 +42,7 @@ class Registry:
             *items: RegistryItem,
             identity: bool = False,
     ) -> 'Registry':
-        with self._mtx:
+        with self._lock:
             dct: ta.Any = self._idct if identity else self._dct
             if (sr := dct.get(key)) is None:
                 sr = dct[key] = _KeyRegistryItems(key)

omlish/marshal/base/types.py

@@ -0,0 +1,70 @@
+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 .values import Value
+
+
+if ta.TYPE_CHECKING:
+    from .contexts import MarshalContext
+    from .contexts import UnmarshalContext
+
+
+##
+
+
+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

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