omlish 0.0.0.dev453__py3-none-any.whl → 0.0.0.dev455__py3-none-any.whl

omlish/marshal/factories/invalidate.py

@@ -2,44 +2,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
 
 
-R = ta.TypeVar('R')
-ContextT = ta.TypeVar('ContextT', bound=BaseContext)
+FactoryT = ta.TypeVar('FactoryT', bound=MarshalerFactory | UnmarshalerFactory)
 
 
 ##
 
 
-class _InvalidatableFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
+class _InvalidatableFactory(ta.Generic[FactoryT]):
     def __init__(
             self,
-            fn: ta.Callable[[], mfs.MatchFn[[ContextT, rfl.Type], R]],
+            fac_fac: ta.Callable,
             check_fn: ta.Callable[[], bool] | None = None,
     ) -> None:
         super().__init__()
 
-        self._fn = fn
+        self._fac_fac = fac_fac
         self._check_fn: ta.Callable[[], bool] | None = check_fn
 
         self._lock = threading.RLock()
 
     #
 
-    _f_: mfs.MatchFn[[ContextT, rfl.Type], R] | None = None
+    __fac: FactoryT | None = None
 
     def _invalidate(self) -> None:
-        self._f_ = None
+        self.__fac = None
 
     def invalidate(self) -> None:
         with self._lock:
@@ -52,67 +47,22 @@ class _InvalidatableFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
                     if self._check_fn():
                         self._invalidate()
 
-    def _f(self) -> mfs.MatchFn[[ContextT, rfl.Type], R]:
+    def _fac(self) -> FactoryT:
         self._maybe_invalidate()
 
-        if (f := self._f_) is None:
+        if (f := self.__fac) is None:
             with self._lock:
-                if (f := self._f_) is None:
-                    f = self._f_ = self._fn()
+                if (f := self.__fac) is None:
+                    f = self.__fac = self._fac_fac()
 
         return f
 
-    #
-
-    def guard(self, ctx: ContextT, rty: rfl.Type) -> bool:
-        return self._f().guard(ctx, rty)
-
-    def fn(self, ctx: ContextT, rty: rfl.Type) -> R:
-        return self._f()(ctx, rty)
-
-
-##
-
-
-class InvalidatableMarshalerFactory(MarshalerFactory):
-    def __init__(
-            self,
-            fn: ta.Callable[[], MarshalerFactory],
-            check_fn: ta.Callable[[], bool] | None = None,
-    ) -> None:
-        super().__init__()
 
-        self._fn = fn
-        self._u: _InvalidatableFactory[MarshalContext, Marshaler] = _InvalidatableFactory(
-            lambda: fn().make_marshaler,
-            check_fn,
-        )
+class InvalidatableMarshalerFactory(_InvalidatableFactory[MarshalerFactory], MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        return self._fac().make_marshaler(ctx, rty)
 
-    def invalidate(self) -> None:
-        self._u.invalidate()
-
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self._u
-
-
-class InvalidatableUnmarshalerFactory(UnmarshalerFactory):
-    def __init__(
-            self,
-            fn: ta.Callable[[], UnmarshalerFactory],
-            check_fn: ta.Callable[[], bool] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._fn = fn
-        self._u: _InvalidatableFactory[UnmarshalContext, Unmarshaler] = _InvalidatableFactory(
-            lambda: fn().make_unmarshaler,
-            check_fn,
-        )
-
-    def invalidate(self) -> None:
-        self._u.invalidate()
 
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self._u
+class InvalidatableUnmarshalerFactory(_InvalidatableFactory[UnmarshalerFactory], UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        return self._fac().make_unmarshaler(ctx, rty)

omlish/marshal/factories/method.py

@@ -0,0 +1,26 @@
+import typing as ta
+
+from ... import lang
+from ... import reflect as rfl
+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 Unmarshaler
+from ..base.types import UnmarshalerFactory
+
+
+##
+
+
+class MarshalerFactoryMethodClass(MarshalerFactory, lang.Abstract):
+    @gfs.method(instance_cache=True)
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        raise NotImplementedError
+
+
+class UnmarshalerFactoryMethodClass(UnmarshalerFactory, lang.Abstract):
+    @gfs.method(instance_cache=True)
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        raise NotImplementedError

omlish/marshal/factories/moduleimport/factories.py

@@ -11,41 +11,37 @@ 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._last_mis: ta.Any = None
 
-    def _do_import(self, ctx: ContextT, mis: ta.Sequence[ModuleImport]) -> None:
+    def _do_import(self, ctx: BaseContext, mis: ta.Sequence[ModuleImport]) -> None:
         c = 0
         for mi in mis:
             if mi.import_if_necessary():
@@ -55,58 +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:
+    def _import_if_necessary(self, ctx: BaseContext) -> None:
         if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
             with self._lock:
                 if (mis := ctx.config_registry.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,52 @@ 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]
-
-            except KeyError:
-                if self._f.guard(ctx, rty):
-                    return True
-                else:
-                    self._dct[rty] = None
-                    return False
+        self._fac = fac
 
-            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
 
-
-##
+            m = self._dct[rty] = dfl()
+            return m
 
 
-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__()
+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))
 
-        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))