omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/marshal/factories/moduleimport/factories.py

@@ -11,43 +11,39 @@ import threading
 import typing as ta
 
 from .... import reflect as rfl
-from ....funcs import match as mfs
 from ...base.contexts import BaseContext
-from ...base.contexts import MarshalContext
-from ...base.contexts import UnmarshalContext
+from ...base.contexts import MarshalFactoryContext
+from ...base.contexts import UnmarshalFactoryContext
 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 .configs import ModuleImport
 
 
-R = ta.TypeVar('R')
-ContextT = ta.TypeVar('ContextT', bound=BaseContext)
+FactoryT = ta.TypeVar('FactoryT', bound=MarshalerFactory | UnmarshalerFactory)
 
 
 ##
 
 
-class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
+class _ModuleImportingFactory(ta.Generic[FactoryT]):
     def __init__(
             self,
-            f: mfs.MatchFn[[ContextT, rfl.Type], R],
+            fac: FactoryT,
             callback: ta.Callable[[], None] | None = None,
     ) -> None:
         super().__init__()
 
-        self._f = f
+        self._fac = fac
         self._callback = callback
 
         self._lock = threading.RLock()
-        self._has_imported = False
+        self._last_mis: ta.Any = None
 
-    def _do_import(self, ctx: ContextT) -> None:
+    def _do_import(self, ctx: BaseContext, mis: ta.Sequence[ModuleImport]) -> None:
         c = 0
-        for mi in ctx.config_registry.get_of(None, ModuleImport):
+        for mi in mis:
             if mi.import_if_necessary():
                 c += 1
 
@@ -55,60 +51,21 @@ class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
             if self._callback is not None:
                 self._callback()
 
-    def _import_if_necessary(self, ctx: ContextT) -> None:
-        # FIXME:
-        # if not self._has_imported:
-        #     with self._lock:
-        #         if not self._has_imported:
-        #             self._do_import(ctx)
-        #             self._has_imported = True
-        self._do_import(ctx)
+    def _import_if_necessary(self, ctx: BaseContext) -> None:
+        if (mis := ctx.configs.get_of(None, ModuleImport)) and mis is not self._last_mis:
+            with self._lock:
+                if (mis := ctx.configs.get_of(None, ModuleImport)) and mis is not self._last_mis:
+                    self._do_import(ctx, mis)
+                    self._last_mis = mis
 
-    def guard(self, ctx: ContextT, rty: rfl.Type) -> bool:
-        self._import_if_necessary(ctx)
-        return self._f.guard(ctx, rty)
 
-    def fn(self, ctx: ContextT, rty: rfl.Type) -> R:
+class ModuleImportingMarshalerFactory(_ModuleImportingFactory[MarshalerFactory], MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         self._import_if_necessary(ctx)
-        return self._f(ctx, rty)
-
-
-##
-
-
-class ModuleImportingMarshalerFactory(MarshalerFactory):
-    def __init__(
-            self,
-            f: MarshalerFactory,
-            callback: ta.Callable[[], None] | None = None,
-    ) -> None:
-        super().__init__()
+        return self._fac.make_marshaler(ctx, rty)
 
-        self._f = f
-        self._tcf: _ModuleImportingFactory[MarshalContext, Marshaler] = _ModuleImportingFactory(
-            f.make_marshaler,
-            callback,
-        )
 
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self._tcf
-
-
-class ModuleImportingUnmarshalerFactory(UnmarshalerFactory):
-    def __init__(
-            self,
-            f: UnmarshalerFactory,
-            callback: ta.Callable[[], None] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._f = f
-        self._tcf: _ModuleImportingFactory[UnmarshalContext, Unmarshaler] = _ModuleImportingFactory(
-            f.make_unmarshaler,
-            callback,
-        )
-
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self._tcf
+class ModuleImportingUnmarshalerFactory(_ModuleImportingFactory[UnmarshalerFactory], UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        self._import_if_necessary(ctx)
+        return self._fac.make_unmarshaler(ctx, rty)

omlish/marshal/factories/multi.py

@@ -1,15 +1,13 @@
 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 ...funcs import guard as gfs
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 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
 
 
 ##
@@ -18,38 +16,28 @@ from ..base.types import UnmarshalerMaker
 class MultiMarshalerFactory(MarshalerFactory):
     def __init__(
             self,
-            fs: ta.Iterable[MarshalerFactory],
-            *,
+            *facs: 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,
-        )
+        self._facs = facs
+        self._mgf = gfs.multi(*[f.make_marshaler for f in self._facs], strict=strict)
 
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self._mmf
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        return self._mgf(ctx, rty)
 
 
 class MultiUnmarshalerFactory(UnmarshalerFactory):
     def __init__(
             self,
-            fs: ta.Iterable[UnmarshalerFactory],
-            *,
+            *facs: 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,
-        )
+        self._facs = facs
+        self._mgf = gfs.multi(*[f.make_unmarshaler for f in self._facs], strict=strict)
 
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self._mmf
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        return self._mgf(ctx, rty)

omlish/marshal/factories/recursive.py

@@ -1,61 +1,54 @@
 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 MarshalFactoryContext
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 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
 
 
+FactoryT = ta.TypeVar('FactoryT', bound=MarshalerFactory | UnmarshalerFactory)
 T = ta.TypeVar('T')
-R = ta.TypeVar('R')
-C = ta.TypeVar('C')
 
 
 ##
 
 
-class _RecursiveTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
+class _RecursiveFactory(ta.Generic[FactoryT]):
     def __init__(
             self,
-            f: mfs.MatchFn[[C, rfl.Type], R],
-            prx: ta.Callable[[], tuple[R, ta.Callable[[R], None]]],
+            fac: FactoryT,
+            prx: ta.Callable[[], tuple[ta.Any, ta.Callable[[ta.Any], None]]],
     ) -> None:
         super().__init__()
 
-        self._f = f
+        self._fac = fac
         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]
 
+        self._dct: dict[rfl.Type, ta.Any] = {}
 
-##
+    def _wrap(self, m, rty):
+        def inner():
+            try:
+                return self._dct[rty]
+            except KeyError:
+                pass
+
+            p, sp = self._prx()
+            self._dct[rty] = p
+            try:
+                r = m()
+                sp(r)
+                return r
+            finally:
+                del self._dct[rty]
+
+        return inner
 
 
 class _Proxy(ta.Generic[T]):
@@ -77,7 +70,7 @@ class _Proxy(ta.Generic[T]):
         return (p := cls()), p._set_obj  # noqa
 
 
-##
+#
 
 
 class _ProxyMarshaler(_Proxy[Marshaler], Marshaler):
@@ -85,19 +78,17 @@ class _ProxyMarshaler(_Proxy[Marshaler], Marshaler):
         return self._obj.marshal(ctx, o)
 
 
-class RecursiveMarshalerFactory(MarshalerFactory, lang.Final):
-    def __init__(self, f: MarshalerFactory) -> None:
-        super().__init__()
+class RecursiveMarshalerFactory(_RecursiveFactory[MarshalerFactory], MarshalerFactory):
+    def __init__(self, fac: MarshalerFactory) -> None:
+        super().__init__(fac, _ProxyMarshaler._new)  # noqa
 
-        self._f = f
-        self._rtf: _RecursiveTypeFactory[MarshalContext, Marshaler] = _RecursiveTypeFactory(
-            self._f.make_marshaler,  # noqa
-            _ProxyMarshaler._new,  # noqa
-        )
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if (m := self._fac.make_marshaler(ctx, rty)) is None:
+            return None
+        return self._wrap(m, rty)
 
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self._rtf
+
+#
 
 
 class _ProxyUnmarshaler(_Proxy[Unmarshaler], Unmarshaler):
@@ -105,16 +96,11 @@ class _ProxyUnmarshaler(_Proxy[Unmarshaler], Unmarshaler):
         return self._obj.unmarshal(ctx, v)
 
 
-class RecursiveUnmarshalerFactory(UnmarshalerFactory, lang.Final):
-    def __init__(self, f: UnmarshalerFactory) -> None:
-        super().__init__()
+class RecursiveUnmarshalerFactory(_RecursiveFactory[UnmarshalerFactory], UnmarshalerFactory):
+    def __init__(self, fac: UnmarshalerFactory) -> None:
+        super().__init__(fac, _ProxyUnmarshaler._new)  # noqa
 
-        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
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if (m := self._fac.make_unmarshaler(ctx, rty)) is None:
+            return None
+        return self._wrap(m, rty)

omlish/marshal/factories/typecache.py

@@ -3,109 +3,64 @@ 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.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 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')
+FactoryT = ta.TypeVar('FactoryT', bound=MarshalerFactory | UnmarshalerFactory)
 
 
 ##
 
 
-class _TypeCacheFactory(mfs.MatchFn[[C, rfl.Type], R]):
-    def __init__(self, f: mfs.MatchFn[[C, rfl.Type], R]) -> None:
+class _TypeCacheFactory(ta.Generic[FactoryT]):
+    def __init__(self, fac: FactoryT) -> 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)
-
-        try:
-            return self._dct[rty] is not None
-        except KeyError:
-            pass
-
-        with self._lock:
-            try:
-                e = self._dct[rty]
+        self._fac = fac
 
-            except KeyError:
-                if self._f.guard(ctx, rty):
-                    return True
-                else:
-                    self._dct[rty] = None
-                    return False
-
-            else:
-                return e is not None
+        self._dct: dict[rfl.Type, ta.Any | None] = {}
+        self._lock = threading.RLock()
 
-    def fn(self, ctx: C, rty: rfl.Type) -> R:
+    def _make(self, rty, dfl):
         check.isinstance(rty, rfl.TYPES)
 
         try:
-            e = self._dct[rty]
+            return self._dct[rty]
         except KeyError:
             pass
-        else:
-            if e is None:
-                raise mfs.MatchGuardError(ctx, rty)
-            else:
-                return e
 
         with self._lock:
             try:
-                e = self._dct[rty]
-
+                return 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
-
-            if e is None:
-                raise mfs.MatchGuardError(ctx, rty)
-            else:
-                return e
+                pass
 
+            if (m := dfl()) is None:
+                self._dct[rty] = None
+                return None
 
-##
-
+            x = None
 
-class TypeCacheMarshalerFactory(MarshalerFactory):
-    def __init__(self, f: MarshalerFactory) -> None:
-        super().__init__()
+            def inner():
+                nonlocal x
+                if x is None:
+                    x = m()
+                return x
 
-        self._f = f
-        self._tcf: _TypeCacheFactory[MarshalContext, Marshaler] = _TypeCacheFactory(f.make_marshaler)
+            self._dct[rty] = inner
+            return inner
 
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self._tcf
 
+class TypeCacheMarshalerFactory(_TypeCacheFactory[MarshalerFactory], MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        return self._make(rty, lambda: self._fac.make_marshaler(ctx, rty))
 
-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
+class TypeCacheUnmarshalerFactory(_TypeCacheFactory[UnmarshalerFactory], UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        return self._make(rty, lambda: self._fac.make_unmarshaler(ctx, rty))

omlish/marshal/factories/typemap.py

@@ -3,63 +3,62 @@ import typing as ta
 from ... import check
 from ... import dataclasses as dc
 from ... import reflect as rfl
-from ...funcs import match as mfs
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 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')
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-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)
-
-    def guard(self, ctx: C, rty: rfl.Type) -> bool:
-        check.isinstance(rty, rfl.TYPES)
-        return rty in self.m
-
-    def fn(self, ctx: C, rty: rfl.Type) -> R:
+class TypeMapMarshalerFactory(MarshalerFactory):
+    m: ta.Mapping[rfl.Type, Marshaler | MarshalerFactory] = dc.xfield(
+        default_factory=dict,
+        coerce=lambda d: {
+            check.isinstance(k, rfl.TYPES): check.isinstance(v, (Marshaler, UnmarshalerFactory))
+            for k, v in d.items()
+        },
+    )
+
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         check.isinstance(rty, rfl.TYPES)
         try:
-            return self.m[rty]
+            m = self.m[rty]
         except KeyError:
-            raise mfs.MatchGuardError(ctx, rty)  # noqa
-
+            return None
 
-##
-
-
-@dc.dataclass(frozen=True)
-class TypeMapMarshalerFactory(
-    _TypeMapFactory[MarshalContext, Marshaler],
-    MarshalerFactory,
-):
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self  # noqa
+        if isinstance(m, Marshaler):
+            return lambda: m
+        elif isinstance(m, MarshalerFactory):
+            return m.make_marshaler(ctx, rty)
+        else:
+            raise TypeError(m)
 
 
 @dc.dataclass(frozen=True)
-class TypeMapUnmarshalerFactory(
-    _TypeMapFactory[UnmarshalContext, Unmarshaler],
-    UnmarshalerFactory,
-):
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self  # noqa
+class TypeMapUnmarshalerFactory(UnmarshalerFactory):
+    u: ta.Mapping[rfl.Type, Unmarshaler | UnmarshalerFactory] = dc.xfield(
+        default_factory=dict,
+        coerce=lambda d: {
+            check.isinstance(k, rfl.TYPES): check.isinstance(v, (Unmarshaler, UnmarshalerFactory))
+            for k, v in d.items()
+        },
+    )
+
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        check.isinstance(rty, rfl.TYPES)
+        try:
+            u = self.u[rty]
+        except KeyError:
+            return None
+
+        if isinstance(u, Unmarshaler):
+            return lambda: u
+        elif isinstance(u, UnmarshalerFactory):
+            return u.make_unmarshaler(ctx, rty)
+        else:
+            raise TypeError(u)