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

omlish/lang/imports/proxyinit.py

@@ -183,6 +183,9 @@ class AutoProxyInitErrors:
         def __repr__(self) -> str:
             return f'{self.__class__.__qualname__}(unreferenced={self.unreferenced!r})'
 
+    class CaptureInProgressError(AutoProxyInitError):
+        pass
+
 
 class _AutoProxyInitCapture:
     class ModuleSpec(ta.NamedTuple):
@@ -418,20 +421,12 @@ class _AutoProxyInitCapture:
 
     #
 
-    class ProxyInit(ta.NamedTuple):
-        package: str
-        attrs: ta.Sequence[tuple[str | None, str]]
-
-    class BuiltProxyInits(ta.NamedTuple):
-        proxy_inits: ta.Sequence['_AutoProxyInitCapture.ProxyInit']
-        unreferenced: ta.Mapping[str, ta.Sequence[str | None]] | None
-
     def build_proxy_inits(
             self,
             init_globals: ta.MutableMapping[str, ta.Any],  # noqa
             *,
             collect_unreferenced: bool = False,
-    ) -> BuiltProxyInits:
+    ) -> 'AutoProxyInit.CapturedProxyInits':
         dct: dict[_AutoProxyInitCapture._Module, list[tuple[str | None, str]]] = {}
 
         rem_whole_mods: set[_AutoProxyInitCapture._Module] = set()
@@ -462,7 +457,7 @@ class _AutoProxyInitCapture:
                 dct.setdefault(m, []).append((None, attr))
                 rem_whole_mods.discard(m)
 
-        lst: list[_AutoProxyInitCapture.ProxyInit] = []
+        lst: list[AutoProxyInit.ProxyInit] = []
         for m, ts in dct.items():
             if not m.spec.name:
                 if not m.spec.level:
@@ -470,13 +465,13 @@ class _AutoProxyInitCapture:
                 for imp_attr, as_attr in ts:
                     if not imp_attr:
                         raise RuntimeError
-                    lst.append(_AutoProxyInitCapture.ProxyInit(
+                    lst.append(AutoProxyInit.ProxyInit(
                         '.' * m.spec.level + imp_attr,
                         [(None, as_attr)],
                     ))
 
             else:
-                lst.append(_AutoProxyInitCapture.ProxyInit(
+                lst.append(AutoProxyInit.ProxyInit(
                     str(m.spec),
                     ts,
                 ))
@@ -490,12 +485,152 @@ class _AutoProxyInitCapture:
                 m, a = self._attrs[ma]
                 unreferenced.setdefault(str(m.spec), []).append(a)
 
-        return _AutoProxyInitCapture.BuiltProxyInits(
+        return AutoProxyInit.CapturedProxyInits(
             lst,
             unreferenced,
         )
 
 
+class AutoProxyInit:
+    class ProxyInit(ta.NamedTuple):
+        package: str
+        attrs: ta.Sequence[tuple[str | None, str]]
+
+    class CapturedProxyInits(ta.NamedTuple):
+        proxy_inits: ta.Sequence['AutoProxyInit.ProxyInit']
+        unreferenced: ta.Mapping[str, ta.Sequence[str | None]] | None
+
+        @property
+        def attrs(self) -> ta.Iterator[str]:
+            for pi in self.proxy_inits:
+                for _, a in pi.attrs:
+                    yield a
+
+    #
+
+    def __init__(
+            self,
+            init_globals: ta.MutableMapping[str, ta.Any],
+            *,
+            disable: bool,
+            eager: bool,
+    ) -> None:
+        super().__init__()
+
+        self._init_globals = init_globals
+
+        self._disable = disable
+        self._eager = eager
+
+    @property
+    def disable(self) -> bool:
+        return self._disable
+
+    @property
+    def eager(self) -> bool:
+        return self._eager
+
+    #
+
+    class _Result(ta.NamedTuple):
+        captured: 'AutoProxyInit.CapturedProxyInits'
+
+    _result_: _Result | None = None
+
+    @property
+    def _result(self) -> _Result:
+        if (rs := self._result_) is None:
+            raise AutoProxyInitErrors.CaptureInProgressError
+        return rs
+
+    @property
+    def is_complete(self) -> bool:
+        return self._result_ is not None
+
+    @property
+    def captured(self) -> CapturedProxyInits:
+        return self._result.captured
+
+    #
+
+    @contextlib.contextmanager
+    def _capture(
+            self,
+            *,
+            unreferenced_callback: ta.Callable[[ta.Mapping[str, ta.Sequence[str | None]]], None] | None = None,
+            raise_unreferenced: bool = False,
+    ) -> ta.Iterator[None]:
+        if self._result_ is not None:
+            raise AutoProxyInitError('capture already complete')
+
+        if self._disable:
+            self._result_ = AutoProxyInit._Result(
+                AutoProxyInit.CapturedProxyInits(
+                    [],
+                    None,
+                ),
+            )
+            yield
+            return
+
+        cap = _AutoProxyInitCapture()
+
+        with cap.hook_context(self._init_globals):
+            yield
+
+        cap.verify_state(self._init_globals)
+
+        blt = cap.build_proxy_inits(
+            self._init_globals,
+            collect_unreferenced=unreferenced_callback is not None or raise_unreferenced,
+        )
+
+        if blt.unreferenced:
+            if unreferenced_callback:
+                unreferenced_callback(blt.unreferenced)
+            if raise_unreferenced:
+                raise AutoProxyInitErrors.UnreferencedImportsError(blt.unreferenced)
+
+        for pi in blt.proxy_inits:
+            for _, a in pi.attrs:
+                del self._init_globals[a]
+
+            proxy_init(
+                self._init_globals,
+                pi.package,
+                pi.attrs,
+            )
+
+        if self._eager:
+            lg = LazyGlobals.install(self._init_globals)
+
+            for a in blt.attrs:
+                lg.get(a)
+
+        self._result_ = AutoProxyInit._Result(
+            blt,
+        )
+
+    #
+
+    def update_exports(self) -> None:
+        cap = self._result.captured
+
+        try:
+            al: ta.Any = self._init_globals['__all__']
+        except KeyError:
+            al = self._init_globals['__all__'] = [k for k in self._init_globals if not k.startswith('_')]
+        else:
+            if not isinstance(al, ta.MutableSequence):
+                al = self._init_globals['__all__'] = list(al)
+
+        al_s = set(al)
+        for a in cap.attrs:
+            if a not in al_s:
+                al.append(a)
+                al_s.add(a)
+
+
 @contextlib.contextmanager
 def auto_proxy_init(
         init_globals: ta.MutableMapping[str, ta.Any],
@@ -505,48 +640,26 @@ def auto_proxy_init(
 
         unreferenced_callback: ta.Callable[[ta.Mapping[str, ta.Sequence[str | None]]], None] | None = None,
         raise_unreferenced: bool = False,
-) -> ta.Iterator[None]:
+
+        update_exports: bool = False,
+) -> ta.Iterator[AutoProxyInit]:
     """
     This is a bit extreme - use sparingly. It relies on an interpreter-global import lock, but much of the ecosystem
     implicitly does anyway. It further relies on temporarily patching `__builtins__.__import__`, but could be switched
     to use any number of other import hooks.
     """
 
-    if disable:
-        yield
-        return
-
-    cap = _AutoProxyInitCapture()
-
-    with cap.hook_context(init_globals):
-        yield
-
-    cap.verify_state(init_globals)
-
-    blt = cap.build_proxy_inits(
+    inst = AutoProxyInit(
         init_globals,
-        collect_unreferenced=unreferenced_callback is not None or raise_unreferenced,
+        disable=disable,
+        eager=eager,
     )
 
-    if blt.unreferenced:
-        if unreferenced_callback:
-            unreferenced_callback(blt.unreferenced)
-        if raise_unreferenced:
-            raise AutoProxyInitErrors.UnreferencedImportsError(blt.unreferenced)
-
-    for pi in blt.proxy_inits:
-        for _, a in pi.attrs:
-            del init_globals[a]
-
-        proxy_init(
-            init_globals,
-            pi.package,
-            pi.attrs,
-        )
-
-    if eager:
-        lg = LazyGlobals.install(init_globals)
+    with inst._capture(  # noqa
+        unreferenced_callback=unreferenced_callback,
+        raise_unreferenced=raise_unreferenced,
+    ):
+        yield inst
 
-        for pi in blt.proxy_inits:
-            for _, a in pi.attrs:
-                lg.get(a)
+    if update_exports:
+        inst.update_exports()

omlish/lang/maybes.py

@@ -0,0 +1,8 @@
+from ..lite.maybes import Maybe
+
+
+##
+
+
+empty = Maybe.empty
+just = Maybe.just

omlish/marshal/__init__.py

@@ -195,12 +195,12 @@ from .trivial.nop import (  # noqa
 )
 
 from .globals import (  # noqa
-    GLOBAL_REGISTRY,
-
+    global_registry,
     global_marshaler_factory,
-    marshal,
-
     global_unmarshaler_factory,
+    global_marshaling,
+
+    marshal,
     unmarshal,
 
     register_global,

omlish/marshal/base/contexts.py

@@ -9,12 +9,15 @@ 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
+
+
+if ta.TYPE_CHECKING:
+    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')
@@ -25,7 +28,7 @@ T = ta.TypeVar('T')
 
 @dc.dataclass(frozen=True)
 class BaseContext(lang.Abstract):
-    registry: Registry
+    registry: 'Registry'
     options: col.TypeMap[Option] = col.TypeMap()
 
     def _reflect(self, o: ta.Any) -> rfl.Type:
@@ -39,24 +42,24 @@ class BaseContext(lang.Abstract):
 
 @dc.dataclass(frozen=True)
 class MarshalContext(BaseContext, lang.Final):
-    factory: MarshalerFactory | None = None
+    factory: ta.Optional['MarshalerFactory'] = None
 
-    def make(self, o: ta.Any) -> Marshaler:
+    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:
+    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
+    factory: ta.Optional['UnmarshalerFactory'] = None
 
-    def make(self, o: ta.Any) -> Unmarshaler:
+    def make(self, o: ta.Any) -> 'Unmarshaler':
         rty = self._reflect(o)
         try:
             return check.not_none(self.factory).make_unmarshaler(self, rty)
@@ -64,11 +67,11 @@ class UnmarshalContext(BaseContext, lang.Final):
             raise UnhandledTypeError(rty)  # noqa
 
     @ta.overload
-    def unmarshal(self, v: Value, ty: type[T]) -> T:
+    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: 'Value', ty: ta.Any) -> ta.Any:
         ...
 
     def unmarshal(self, v, ty):

omlish/marshal/base/overrides.py

@@ -1,11 +1,20 @@
+import typing as ta
+
 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
+
+
+if ta.TYPE_CHECKING:
+    from . import types as _types
+    from .types import Marshaler
+    from .types import MarshalerFactory
+    from .types import Unmarshaler
+    from .types import UnmarshalerFactory
+
+else:
+    _types = lang.proxy_import('.types', __package__)
 
 
 ##
@@ -13,11 +22,11 @@ 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
+    marshaler: ta.Optional['Marshaler'] = dc.xfield(None, validate=lambda v: isinstance(v, (_types.Marshaler, type(None))))  # noqa
+    marshaler_factory: ta.Optional['MarshalerFactory'] = None
 
-    unmarshaler: Unmarshaler | None = dc.xfield(None, check_type=(Unmarshaler, None))
-    unmarshaler_factory: UnmarshalerFactory | None = None
+    unmarshaler: ta.Optional['Unmarshaler'] = dc.xfield(None, validate=lambda v: isinstance(v, (_types.Unmarshaler, type(None))))  # noqa
+    unmarshaler_factory: ta.Optional['UnmarshalerFactory'] = None
 
 
 @dc.dataclass(frozen=True)

omlish/marshal/base/registries.py

@@ -29,10 +29,16 @@ class _KeyRegistryItems:
 
 
 class Registry:
-    def __init__(self) -> None:
+    def __init__(
+            self,
+            *,
+            lock: ta.Optional[threading.RLock] = None,  # noqa
+    ) -> None:
         super().__init__()
 
-        self._lock = threading.Lock()
+        if lock is None:
+            lock = threading.RLock()
+        self._lock = lock
         self._idct: ta.MutableMapping[ta.Any, _KeyRegistryItems] = col.IdentityKeyDict()
         self._dct: dict[ta.Any, _KeyRegistryItems] = {}
 

omlish/marshal/base/types.py

@@ -5,12 +5,13 @@ 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
 
 
-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 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/globals.py

@@ -1,11 +1,11 @@
+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.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
@@ -18,31 +18,45 @@ T = ta.TypeVar('T')
 ##
 
 
-GLOBAL_REGISTRY: Registry = Registry()
+_GLOBAL_LOCK = threading.RLock()
 
 
-##
+@lang.cached_function(lock=_GLOBAL_LOCK)
+def global_registry() -> Registry:
+    return Registry(lock=_GLOBAL_LOCK)
 
 
-@lang.cached_function(lock=True)
+@lang.cached_function(lock=_GLOBAL_LOCK)
 def global_marshaler_factory() -> MarshalerFactory:
     return 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 new_standard_unmarshaler_factory()
+
+
+class _GlobalMarshaling(Marshaling, lang.Final):
+    def registry(self) -> Registry:
+        return global_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,11 +70,7 @@ 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)
 
 
 ##
@@ -71,7 +81,7 @@ def register_global(
         *items: RegistryItem,
         identity: bool = False,
 ) -> None:
-    GLOBAL_REGISTRY.register(
+    global_registry().register(
         key,
         *items,
         identity=identity,