omlish 0.0.0.dev414__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/lite/maysyncs.py

@@ -100,6 +100,7 @@ class AnyMaysyncFn(abc.ABC, ta.Generic[_MaysyncRS, _MaysyncRA]):  # noqa
         raise NotImplementedError
 
 
+@ta.final
 class MaywaitableAlreadyConsumedError(Exception):
     pass
 

omlish/manifests/base.py

@@ -15,7 +15,7 @@ class ModAttrManifest:
     module: str
     attr: str
 
-    def load(self) -> ta.Any:
+    def resolve(self) -> ta.Any:
         import importlib  # noqa
 
         mod = importlib.import_module(self.module)

omlish/marshal/__init__.py

@@ -1,4 +1,48 @@
-from .base import (  # noqa
+"""
+TODO:
+ - redacted
+ - strongly typed MarshalerFactory base class?
+ - strongly typed Composite/Cached Marshaler/Unmarshaler factories - footgun
+ - streaming? Start/EndObject, etc..
+ - lang.Marker - class name, handle type[Foo]
+  - can't disambiguate from str - can't coexist in bare union
+ - factories being free MatchFns does more harm than good - in practice these are such big guns you want to write a
+   class body if only ceremonially
+
+See:
+ - https://github.com/python-attrs/cattrs
+ - https://github.com/jcrist/msgspec
+ - https://github.com/Fatal1ty/mashumaro
+ - https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serializers.md#custom-serializers
+"""
+
+
+from .base.contexts import (  # noqa
+    BaseContext,
+    MarshalContext,
+    UnmarshalContext,
+)
+
+from .base.errors import (  # noqa
+    ForbiddenTypeError,
+    MarshalError,
+    UnhandledTypeError,
+)
+
+from .base.options import (  # noqa
+    Option,
+)
+
+from .base.overrides import (  # noqa
+    Override,
+    ReflectOverride,
+)
+
+from .base.registries import (  # noqa
+    Registry,
+)
+
+from .base.types import (  # noqa
     Marshaler,
     Unmarshaler,
 
@@ -10,67 +54,55 @@ from .base import (  # noqa
 
     MarshalerFactory_,
     UnmarshalerFactory_,
+)
+
+from .base.values import (  # noqa
+    Value,
+)
 
+from .composite.iterables import (  # noqa
+    IterableMarshaler,
+    IterableUnmarshaler,
+)
+
+from .composite.wrapped import (  # noqa
+    WrappedMarshaler,
+    WrappedUnmarshaler,
+)
+
+from .factories.simple import (  # noqa
     SimpleMarshalerFactory,
     SimpleUnmarshalerFactory,
+)
 
+from .factories.match import (  # noqa
     MarshalerFactoryMatchClass,
     UnmarshalerFactoryMatchClass,
+)
 
+from .factories.multi import (  # noqa
     MultiMarshalerFactory,
     MultiUnmarshalerFactory,
+)
 
+from .factories.typemap import (  # noqa
     TypeMapMarshalerFactory,
     TypeMapUnmarshalerFactory,
+)
 
+from .factories.typecache import (  # noqa
     TypeCacheMarshalerFactory,
     TypeCacheUnmarshalerFactory,
+)
 
+from .factories.func import (  # noqa
     FuncMarshaler,
     FuncUnmarshaler,
+)
 
-    BaseContext,
-    MarshalContext,
-    UnmarshalContext,
-
+from .factories.recursive import (  # noqa
     RecursiveMarshalerFactory,
     RecursiveUnmarshalerFactory,
-
-    Override,
-    ReflectOverride,
-)
-
-from .composite.iterables import (  # noqa
-    IterableMarshaler,
-    IterableUnmarshaler,
-)
-
-from .composite.wrapped import (  # noqa
-    WrappedMarshaler,
-    WrappedUnmarshaler,
-)
-
-from .errors import (  # noqa
-    ForbiddenTypeError,
-    MarshalError,
-    UnhandledTypeError,
-)
-
-from .globals import (  # noqa
-    GLOBAL_REGISTRY,
-
-    global_marshaler_factory,
-    marshal,
-
-    global_unmarshaler_factory,
-    unmarshal,
-
-    register_global,
-)
-
-from .naming import (  # noqa
-    Naming,
-    translate_name,
 )
 
 from .objects.dataclasses import (  # noqa
@@ -152,20 +184,6 @@ from .singular.primitives import (  # noqa
     PRIMITIVE_TYPES,
 )
 
-from .registries import (  # noqa
-    Registry,
-)
-
-from .standard import (  # noqa
-    STANDARD_MARSHALER_FACTORIES,
-    new_standard_marshaler_factory,
-
-    STANDARD_UNMARSHALER_FACTORIES,
-    new_standard_unmarshaler_factory,
-
-    install_standard_factories,
-)
-
 from .trivial.forbidden import (  # noqa
     ForbiddenTypeMarshalerFactory,
     ForbiddenTypeUnmarshalerFactory,
@@ -176,8 +194,31 @@ from .trivial.nop import (  # noqa
     NopMarshalerUnmarshaler,
 )
 
-from .values import (  # noqa
-    Value,
+from .globals import (  # noqa
+    global_registry,
+    global_marshaler_factory,
+    global_unmarshaler_factory,
+    global_marshaling,
+
+    marshal,
+    unmarshal,
+
+    register_global,
+)
+
+from .naming import (  # noqa
+    Naming,
+    translate_name,
+)
+
+from .standard import (  # noqa
+    STANDARD_MARSHALER_FACTORIES,
+    new_standard_marshaler_factory,
+
+    STANDARD_UNMARSHALER_FACTORIES,
+    new_standard_unmarshaler_factory,
+
+    install_standard_factories,
 )
 
 

omlish/marshal/base/contexts.py

@@ -0,0 +1,78 @@
+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
+
+
+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')
+
+
+##
+
+
+@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: ta.Optional['MarshalerFactory'] = 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: ta.Optional['UnmarshalerFactory'] = 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,34 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from .registries import RegistryItem
+
+
+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__)
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Override(RegistryItem, lang.Final):
+    marshaler: ta.Optional['Marshaler'] = dc.xfield(None, validate=lambda v: isinstance(v, (_types.Marshaler, type(None))))  # noqa
+    marshaler_factory: ta.Optional['MarshalerFactory'] = 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)
+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
 
 
 ##
@@ -33,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._mtx = 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] = {}
 
@@ -46,7 +48,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)