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

omlish/marshal/base/registries.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - col.TypeMap?
+  - at least get_any
+"""
 import dataclasses as dc
 import threading
 import typing as ta
@@ -14,41 +19,84 @@ class RegistryItem(lang.Abstract):
 
 
 RegistryItemT = ta.TypeVar('RegistryItemT', bound=RegistryItem)
+RegistryItemU = ta.TypeVar('RegistryItemU', bound=RegistryItem)
 
 
 @dc.dataclass(frozen=True)
-class _KeyRegistryItems:
+class _KeyRegistryItems(ta.Generic[RegistryItemT]):
     key: ta.Any
-    items: list[RegistryItem] = dc.field(default_factory=list)
-    item_lists_by_ty: dict[type[RegistryItem], list[RegistryItem]] = dc.field(default_factory=dict)
+    items: list[RegistryItemT] = dc.field(default_factory=list)
+    item_lists_by_ty: dict[type[RegistryItemT], list[RegistryItemT]] = dc.field(default_factory=dict)
 
-    def add(self, *items: RegistryItem) -> None:
+    def add(self, *items: RegistryItemT) -> None:
         for i in items:
             self.items.append(i)
             self.item_lists_by_ty.setdefault(type(i), []).append(i)
 
 
-class Registry:
-    def __init__(self) -> None:
+class RegistrySealedError(Exception):
+    pass
+
+
+class Registry(ta.Generic[RegistryItemT]):
+    def __init__(
+            self,
+            *,
+            lock: ta.Optional[threading.RLock] = None,  # noqa
+    ) -> None:
         super().__init__()
 
-        self._lock = threading.Lock()
-        self._idct: ta.MutableMapping[ta.Any, _KeyRegistryItems] = col.IdentityKeyDict()
-        self._dct: dict[ta.Any, _KeyRegistryItems] = {}
+        if lock is None:
+            lock = threading.RLock()
+        self._lock = lock
+
+        self._dct: dict[ta.Any, _KeyRegistryItems[RegistryItemT]] = {}
+        self._id_dct: ta.MutableMapping[ta.Any, _KeyRegistryItems[RegistryItemT]] = col.IdentityKeyDict()
+
+        self._sealed = False
+
+    #
+
+    def is_sealed(self) -> bool:
+        if self._sealed:
+            return True
+        with self._lock:
+            return self._sealed
+
+    def seal(self) -> ta.Self:
+        if self._sealed:
+            raise RegistrySealedError(self)
+        with self._lock:
+            self._seal()
+        return self
+
+    def _seal(self) -> None:
+        if self._sealed:
+            raise RegistrySealedError(self)
+
+        self._sealed = True
+
+    #
 
     def register(
             self,
             key: ta.Any,
-            *items: RegistryItem,
+            *items: RegistryItemT,
             identity: bool = False,
-    ) -> 'Registry':
+    ) -> ta.Self:
         with self._lock:
-            dct: ta.Any = self._idct if identity else self._dct
+            if self._sealed:
+                raise RegistrySealedError(self)
+
+            dct: ta.Any = self._id_dct if identity else self._dct
             if (sr := dct.get(key)) is None:
                 sr = dct[key] = _KeyRegistryItems(key)
             sr.add(*items)
+
         return self
 
+    #
+
     def get(
             self,
             key: ta.Any,
@@ -60,7 +108,8 @@ class Registry:
                 *self.get(key, identity=True),
                 *self.get(key, identity=False),
             )
-        dct: ta.Any = self._idct if identity else self._dct
+
+        dct: ta.Any = self._id_dct if identity else self._dct
         try:
             return dct[key].items
         except KeyError:
@@ -69,16 +118,17 @@ class Registry:
     def get_of(
             self,
             key: ta.Any,
-            item_ty: type[RegistryItemT],
+            item_ty: type[RegistryItemU],
             *,
             identity: bool | None = None,
-    ) -> ta.Sequence[RegistryItemT]:
+    ) -> ta.Sequence[RegistryItemU]:
         if identity is None:
             return (
                 *self.get_of(key, item_ty, identity=True),
                 *self.get_of(key, item_ty, identity=False),
             )
-        dct: ta.Any = self._idct if identity else self._dct
+
+        dct: ta.Any = self._id_dct if identity else self._dct
         try:
             sr = dct[key]
         except KeyError:

omlish/marshal/base/types.py

@@ -1,16 +1,17 @@
 import abc
+import dataclasses as dc
 import typing as ta
 
-from ... import dataclasses as dc
 from ... import lang
 from ... import reflect as rfl
 from ...funcs import match as mfs
+from .configs import ConfigRegistry
+from .contexts import MarshalContext
+from .contexts import UnmarshalContext
 from .values import Value
 
 
-if ta.TYPE_CHECKING:
-    from .contexts import MarshalContext
-    from .contexts import UnmarshalContext
+T = ta.TypeVar('T')
 
 
 ##
@@ -18,21 +19,21 @@ if ta.TYPE_CHECKING:
 
 class Marshaler(lang.Abstract):
     @abc.abstractmethod
-    def marshal(self, ctx: 'MarshalContext', o: ta.Any) -> Value:
+    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:
+    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]
+MarshalerMaker: ta.TypeAlias = mfs.MatchFn[[MarshalContext, rfl.Type], Marshaler]
+UnmarshalerMaker: ta.TypeAlias = mfs.MatchFn[[UnmarshalContext, rfl.Type], Unmarshaler]
 
 
 class MarshalerFactory(lang.Abstract):
@@ -68,3 +69,54 @@ class UnmarshalerFactory_(UnmarshalerFactory):  # noqa
     @property
     def make_unmarshaler(self) -> UnmarshalerMaker:
         return self.fn
+
+
+##
+
+
+class Marshaling(lang.Abstract):
+    @abc.abstractmethod
+    def config_registry(self) -> ConfigRegistry:
+        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(
+            config_registry=self.config_registry(),
+            factory=self.marshaler_factory(),
+            **kwargs,
+        )
+
+    def new_unmarshal_context(self, **kwargs: ta.Any) -> UnmarshalContext:
+        return UnmarshalContext(
+            config_registry=self.config_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/factories/invalidate.py

@@ -0,0 +1,118 @@
+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.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)
+
+
+##
+
+
+class _InvalidatableFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
+    def __init__(
+            self,
+            fn: ta.Callable[[], mfs.MatchFn[[ContextT, rfl.Type], R]],
+            check_fn: ta.Callable[[], bool] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._check_fn: ta.Callable[[], bool] | None = check_fn
+
+        self._lock = threading.RLock()
+
+    #
+
+    _f_: mfs.MatchFn[[ContextT, rfl.Type], R] | None = None
+
+    def _invalidate(self) -> None:
+        self._f_ = None
+
+    def invalidate(self) -> None:
+        with self._lock:
+            self._invalidate()
+
+    def _maybe_invalidate(self) -> None:
+        if self._check_fn is not None:
+            if self._check_fn():
+                with self._lock:
+                    if self._check_fn():
+                        self._invalidate()
+
+    def _f(self) -> mfs.MatchFn[[ContextT, rfl.Type], R]:
+        self._maybe_invalidate()
+
+        if (f := self._f_) is None:
+            with self._lock:
+                if (f := self._f_) is None:
+                    f = self._f_ = self._fn()
+
+        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,
+        )
+
+    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

omlish/marshal/factories/moduleimport/configs.py

@@ -0,0 +1,26 @@
+import dataclasses as dc
+import importlib
+import sys
+
+from .... import lang
+from ...base.configs import Config
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ModuleImport(Config, lang.Final):
+    name: str
+    package: str | None = None
+
+    @lang.cached_function
+    def resolve(self) -> str:
+        return lang.resolve_import_name(self.name, self.package)
+
+    def import_if_necessary(self) -> bool:
+        if (mn := self.resolve()) in sys.modules:
+            return False
+
+        importlib.import_module(mn)
+        return True

omlish/marshal/factories/moduleimport/factories.py

@@ -0,0 +1,114 @@
+"""
+FIXME:
+ - lol support late registration and such, this is broken
+  - need to cache in the registry somehow, cannot iterate over all ModuleImports each time
+   - probably use something like dataclass driver context items or some such
+
+TODO:
+ - per-type module imports
+"""
+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.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)
+
+
+##
+
+
+class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
+    def __init__(
+            self,
+            f: mfs.MatchFn[[ContextT, rfl.Type], R],
+            callback: ta.Callable[[], None] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._f = f
+        self._callback = callback
+
+        self._lock = threading.RLock()
+        self._has_imported = False
+
+    def _do_import(self, ctx: ContextT) -> None:
+        c = 0
+        for mi in ctx.config_registry.get_of(None, ModuleImport):
+            if mi.import_if_necessary():
+                c += 1
+
+        if c:
+            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 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:
+        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__()
+
+        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

omlish/marshal/factories/typecache.py

@@ -31,23 +31,43 @@ class _TypeCacheFactory(mfs.MatchFn[[C, rfl.Type], R]):
 
     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
+
             else:
                 return e is not None
 
     def fn(self, ctx: C, rty: rfl.Type) -> R:
         check.isinstance(rty, rfl.TYPES)
+
+        try:
+            e = 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]
+
             except KeyError:
                 try:
                     ret = self._f(ctx, rty)
@@ -57,11 +77,11 @@ class _TypeCacheFactory(mfs.MatchFn[[C, rfl.Type], R]):
                 else:
                     self._dct[rty] = ret
                     return ret
+
+            if e is None:
+                raise mfs.MatchGuardError(ctx, rty)
             else:
-                if e is None:
-                    raise mfs.MatchGuardError(ctx, rty)
-                else:
-                    return e
+                return e
 
 
 ##

omlish/marshal/globals.py

@@ -1,15 +1,20 @@
+import threading
 import typing as ta
 
 from .. import lang
-from .base.contexts import MarshalContext
-from .base.contexts import UnmarshalContext
-from .base.registries import Registry
-from .base.registries import RegistryItem
+from .base.configs import Config
+from .base.configs import ConfigRegistry
 from .base.types import MarshalerFactory
+from .base.types import Marshaling
 from .base.types import UnmarshalerFactory
 from .base.values import Value
-from .standard import new_standard_marshaler_factory
-from .standard import new_standard_unmarshaler_factory
+from .factories.moduleimport.configs import ModuleImport
+
+
+if ta.TYPE_CHECKING:
+    from . import standard
+else:
+    standard = lang.proxy_import('.standard', __package__)
 
 
 T = ta.TypeVar('T')
@@ -18,31 +23,45 @@ T = ta.TypeVar('T')
 ##
 
 
-GLOBAL_REGISTRY: Registry = Registry()
+_GLOBAL_LOCK = threading.RLock()
 
 
-##
+@lang.cached_function(lock=_GLOBAL_LOCK)
+def global_config_registry() -> ConfigRegistry:
+    return ConfigRegistry(lock=_GLOBAL_LOCK)
 
 
-@lang.cached_function(lock=True)
+@lang.cached_function(lock=_GLOBAL_LOCK)
 def global_marshaler_factory() -> MarshalerFactory:
-    return new_standard_marshaler_factory()
+    return standard.new_standard_marshaler_factory()
 
 
-def marshal(obj: ta.Any, ty: ta.Any | None = None, **kwargs: ta.Any) -> Value:
-    return MarshalContext(
-        GLOBAL_REGISTRY,
-        factory=global_marshaler_factory(),
-        **kwargs,
-    ).marshal(obj, ty)
+@lang.cached_function(lock=_GLOBAL_LOCK)
+def global_unmarshaler_factory() -> UnmarshalerFactory:
+    return standard.new_standard_unmarshaler_factory()
+
+
+class _GlobalMarshaling(Marshaling, lang.Final):
+    def config_registry(self) -> ConfigRegistry:
+        return global_config_registry()
+
+    def marshaler_factory(self) -> MarshalerFactory:
+        return global_marshaler_factory()
+
+    def unmarshaler_factory(self) -> UnmarshalerFactory:
+        return global_unmarshaler_factory()
+
+
+@lang.cached_function(lock=_GLOBAL_LOCK)
+def global_marshaling() -> Marshaling:
+    return _GlobalMarshaling()
 
 
 ##
 
 
-@lang.cached_function(lock=True)
-def global_unmarshaler_factory() -> UnmarshalerFactory:
-    return new_standard_unmarshaler_factory()
+def marshal(obj: ta.Any, ty: ta.Any | None = None, **kwargs: ta.Any) -> Value:
+    return global_marshaling().marshal(obj, ty, **kwargs)
 
 
 @ta.overload
@@ -56,23 +75,29 @@ def unmarshal(v: Value, ty: ta.Any, **kwargs: ta.Any) -> ta.Any:
 
 
 def unmarshal(v, ty, **kwargs):
-    return UnmarshalContext(
-        GLOBAL_REGISTRY,
-        factory=global_unmarshaler_factory(),
-        **kwargs,
-    ).unmarshal(v, ty)
+    return global_marshaling().unmarshal(v, ty, **kwargs)
 
 
 ##
 
 
-def register_global(
+def register_global_config(
         key: ta.Any,
-        *items: RegistryItem,
+        *items: Config,
         identity: bool = False,
 ) -> None:
-    GLOBAL_REGISTRY.register(
+    global_config_registry().register(
         key,
         *items,
         identity=identity,
     )
+
+
+def register_global_module_import(
+        name: str,
+        package: str | None = None,
+) -> None:
+    global_config_registry().register(
+        None,
+        ModuleImport(name, package),
+    )

omlish/marshal/polymorphism/metadata.py

@@ -2,7 +2,7 @@ import dataclasses as dc
 import typing as ta
 
 from ... import lang
-from ..base.registries import RegistryItem
+from ..base.configs import Config
 from ..naming import Naming
 from ..naming import translate_name
 
@@ -10,7 +10,7 @@ from ..naming import translate_name
 ##
 
 
-class TypeTagging(RegistryItem, lang.Abstract, lang.Sealed):
+class TypeTagging(Config, lang.Abstract, lang.Sealed):
     pass