omlish 0.0.0.dev459__py3-none-any.whl → 0.0.0.dev460__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev459'
-__revision__ = 'a12178d42c88b1d69bca74aaf2cd0f1fd8106a47'
+__version__ = '0.0.0.dev460'
+__revision__ = 'e37de6bf186be6d30e6b4de285fa5b4350e2f84e'
 
 
 #

omlish/lang/imports/capture.py

@@ -120,30 +120,27 @@ class _ImportCaptureHook:
 
             if name.startswith('.'):
                 raise ImportCaptureError
+
             self.name = name
-            self.base_name = name.rpartition('.')[2]
             self.parent = parent
 
+            self.base_name = name.rpartition('.')[2]
+            self.root: _ImportCaptureHook._Module = parent.root if parent is not None else self  # noqa
+
+            self.children: dict[str, _ImportCaptureHook._Module] = {}
+            self.descendants: set[_ImportCaptureHook._Module] = set()
+
             self.module_obj = types.ModuleType(f'<{self.__class__.__qualname__}: {name}>')
             self.module_obj.__file__ = None
             self.module_obj.__getattr__ = functools.partial(getattr_handler, self)  # type: ignore[method-assign]  # noqa
             self.initial_module_dict = dict(self.module_obj.__dict__)
 
-            self.children: dict[str, _ImportCaptureHook._Module] = {}
-            self.descendants: set[_ImportCaptureHook._Module] = set()
             self.explicit = False
             self.immediate = False
 
         def __repr__(self) -> str:
             return f'{self.__class__.__name__}<{self.name}{"!" if self.immediate else "+" if self.explicit else ""}>'
 
-        @property
-        def root(self) -> '_ImportCaptureHook._Module':
-            out = self
-            while out.parent is not None:
-                out = out.parent
-            return out
-
         def set_explicit(self) -> None:
             cur: _ImportCaptureHook._Module | None = self
             while cur is not None and not cur.explicit:
@@ -157,35 +154,32 @@ class _ImportCaptureHook:
         return sorted(self._modules_by_name.values(), key=lambda m: m.name)
 
     def _get_or_make_module(self, name: str) -> _Module:
-        def rec(name: str) -> _ImportCaptureHook._Module:  # noqa
-            try:
-                return self._modules_by_name[name]
-            except KeyError:
-                pass
-
-            parent: _ImportCaptureHook._Module | None = None
-            if '.' in name:
-                rest, _, attr = name.rpartition('.')
-                parent = rec(rest)
-                if attr in parent.children:
-                    raise ImportCaptureErrors.AttrError(rest, attr)
+        try:
+            return self._modules_by_name[name]
+        except KeyError:
+            pass
 
-            module = self._Module(
-                name,
-                self._handle_module_getattr,
-                parent=parent,
-            )
-            self._modules_by_name[name] = module
-            self._modules_by_module_obj[module.module_obj] = module
+        parent: _ImportCaptureHook._Module | None = None
+        if '.' in name:
+            rest, _, attr = name.rpartition('.')
+            parent = self._get_or_make_module(rest)
+            if attr in parent.children:
+                raise ImportCaptureErrors.AttrError(rest, attr)
 
-            if parent is not None:
-                parent.children[attr] = module  # noqa
-                setattr(parent.module_obj, attr, module.module_obj)
-                parent.root.descendants.add(module)
+        module = _ImportCaptureHook._Module(
+            name,
+            self._handle_module_getattr,
+            parent=parent,
+        )
+        self._modules_by_name[name] = module
+        self._modules_by_module_obj[module.module_obj] = module
 
-            return module
+        if parent is not None:
+            parent.children[module.base_name] = module
+            setattr(parent.module_obj, module.base_name, module.module_obj)
+            parent.root.descendants.add(module)
 
-        return rec(name)
+        return module
 
     def _make_child_module(self, module: _Module, attr: str) -> _Module:
         if attr in module.children:
@@ -322,7 +316,11 @@ class _ImportCaptureHook:
     ) -> 'ImportCapture.Captured':
         rem_explicit_mods: set[_ImportCaptureHook._Module] = set()
         if collect_unreferenced:
-            rem_explicit_mods.update([m for m in self._modules_by_name.values() if m.immediate])
+            rem_explicit_mods.update(
+                m for m in self._modules_by_name.values()
+                if m.immediate
+                and m.parent is not None  # No good way to tell if user did `import a.b.c` or `import a.b.c as c`
+            )
 
         #
 
@@ -395,8 +393,8 @@ class _ImportCaptureHook:
         for m, ts in sorted(dct.items(), key=lambda t: t[0].name):
             imps.append(ImportCapture.Import(
                 mods[m.name],
-                [r for l, r in ts if l is None],
-                [(l, r) for l, r in ts if l is not None],
+                [r for l, r in ts if l is None] or None,
+                [(l, r) for l, r in ts if l is not None] or None,
             ))
 
         #
@@ -419,6 +417,14 @@ class _ImportCaptureHook:
 
 
 class _AbstractBuiltinsImportCaptureHook(_ImportCaptureHook):
+    def __init__(
+            self,
+            *,
+            _frame: types.FrameType | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(**kwargs)
+
     def _new_import(
             self,
             old_import,
@@ -575,11 +581,24 @@ class _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook(_AbstractBuiltinsImport
 #
 
 
-_capture: ta.Any = None
-try:
-    from . import _capture  # type: ignore
-except ImportError:
-    pass
+_cext_: ta.Any
+
+
+def _cext() -> ta.Any:
+    global _cext_
+    try:
+        return _cext_
+    except NameError:
+        pass
+
+    cext: ta.Any
+    try:
+        from . import _capture as cext  # type: ignore
+    except ImportError:
+        cext = None
+
+    _cext_ = cext
+    return cext
 
 
 class _FrameBuiltinsImportCaptureHook(_AbstractBuiltinsImportCaptureHook):
@@ -599,7 +618,7 @@ class _FrameBuiltinsImportCaptureHook(_AbstractBuiltinsImportCaptureHook):
             frame: types.FrameType,
             new_builtins: dict[str, ta.Any],
     ) -> bool:
-        return _capture._set_frame_builtins(frame, frame.f_builtins, new_builtins)  # noqa
+        return _cext()._set_frame_builtins(frame, frame.f_builtins, new_builtins)  # noqa
 
     @contextlib.contextmanager
     def _hook_context(
@@ -629,22 +648,37 @@ class _FrameBuiltinsImportCaptureHook(_AbstractBuiltinsImportCaptureHook):
 #
 
 
+_CAPTURE_IMPLS: ta.Mapping[str, type[_AbstractBuiltinsImportCaptureHook]] = {
+    'cext': _FrameBuiltinsImportCaptureHook,
+    'somewhat_safe': _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook,
+    'unsafe': _UnsafeGlobalBuiltinsImportCaptureHook,
+}
+
+
 def _new_import_capture_hook(
         mod_globals: ta.MutableMapping[str, ta.Any],  # noqa
         *,
         stack_offset: int = 0,
+        capture_impl: str | None = None,
         **kwargs: ta.Any,
 ) -> '_ImportCaptureHook':
-    frame: types.FrameType | None = sys._getframe(1 + stack_offset)  # noqa
-    if frame is None or frame.f_globals is not mod_globals:
-        raise ImportCaptureError("Can't find importing frame")
+    if '_frame' not in kwargs:
+        frame: types.FrameType | None = sys._getframe(1 + stack_offset)  # noqa
+        if frame is None or frame.f_globals is not mod_globals:
+            raise ImportCaptureError("Can't find importing frame")
+        kwargs['_frame'] = frame
 
     kwargs.setdefault('package', mod_globals.get('__package__'))
 
-    if _capture is not None:
-        return _FrameBuiltinsImportCaptureHook(_frame=frame, **kwargs)
+    cls: type[_AbstractBuiltinsImportCaptureHook]
+    if capture_impl is not None:
+        cls = _CAPTURE_IMPLS[capture_impl]
+    elif _cext() is not None:
+        cls = _FrameBuiltinsImportCaptureHook
+    else:
+        cls = _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook
 
-    return _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook(**kwargs)
+    return cls(**kwargs)
 
 
 ##
@@ -693,20 +727,28 @@ class ImportCapture:
                 ')',
             ])
 
+        _root: 'ImportCapture.Module'
+
         @property
         def root(self) -> 'ImportCapture.Module':
-            out = self
-            while out.parent is not None:
-                out = out.parent
-            return out
+            try:
+                return self._root
+            except AttributeError:
+                pass
+
+            root = self
+            while root.parent is not None:
+                root = root.parent
+            self._root = root
+            return root
 
     @ta.final
     class Import:
         def __init__(
                 self,
                 module: 'ImportCapture.Module',
-                as_: ta.Sequence[str],
-                attrs: ta.Sequence[tuple[str, str]],  # ('foo', 'bar') -> `import foo as bar` - explicitly not a dict
+                as_: ta.Sequence[str] | None,
+                attrs: ta.Sequence[tuple[str, str]] | None,  # ('foo', 'bar') -> `import foo as bar` - explicitly not a dict  # noqa
         ) -> None:
             self.module = module
             self.as_ = as_
@@ -743,9 +785,11 @@ class ImportCapture:
         @property
         def attrs(self) -> ta.Iterator[str]:
             for pi in self.imports.values():
-                yield from pi.as_
-                for _, a in pi.attrs:
-                    yield a
+                if pi.as_:
+                    yield from pi.as_
+                if pi.attrs:
+                    for _, a in pi.attrs:
+                        yield a
 
     EMPTY_CAPTURED: ta.ClassVar[Captured] = Captured(
         {},

omlish/lang/imports/proxy.py

@@ -1,6 +1,27 @@
-import contextlib
+"""
+TODO:
+ - _ProxyImports
+ - if already imported just return?
+  - no, need sub-imports..
+ - seal on first use? or just per module? can't seal roots and still be usable
+  - only if not hasattr?
+ - audit for deadlock risk - does importlib._bootstrap do it for us? do we need a global _ProxyImporter lock? would only
+   happen on reification
+ - ProxyImportError
+
+See:
+ - https://peps.python.org/pep-0810/
+  - https://github.com/LazyImportsCabal/cpython/tree/lazy
+  - https://developers.facebook.com/blog/post/2022/06/15/python-lazy-imports-with-cinder/
+  - https://engineering.fb.com/2024/01/18/developer-tools/lazy-imports-cinder-machine-learning-meta/
+  - https://www.hudsonrivertrading.com/hrtbeat/inside-hrts-python-fork/
+  - https://bugreports.qt.io/browse/PYSIDE-2404
+ - https://scientific-python.org/specs/spec-0001/
+ - https://github.com/scientific-python/lazy-loader
+"""
 import functools
 import importlib.util
+import threading
 import types
 import typing as ta
 
@@ -9,179 +30,340 @@ from .capture import ImportCapture
 from .capture import _new_import_capture_hook
 
 
-##
+_ProxyImporterModuleAttr: ta.TypeAlias = ta.Literal[
+    'child',  # 'outranks' proxy_attr - all child attrs must be proxy_attrs but not vice versa
+    'proxy_attr',
+    'pending_child',
+    'pending_attr',
+]
 
 
-def _translate_old_style_import_capture(
-        cap: ImportCapture.Captured,
-) -> ta.Mapping[str, ta.Sequence[tuple[str | None, str]]]:
-    dct: dict[str, list[tuple[str | None, str]]] = {}
+##
 
-    for ci in cap.imports.values():
-        if ci.module.kind == 'leaf':
-            if (p := ci.module.parent) is None:
-                raise NotImplementedError
 
-            if ci.attrs:
-                raise NotImplementedError
+class _ProxyImporter:
+    def __init__(
+            self,
+            *,
+            owner_globals: ta.MutableMapping[str, ta.Any] | None = None,
+    ) -> None:
+        super().__init__()
 
-            for a in ci.as_:
-                dct.setdefault(p.name, []).append(
-                    (ci.module.base_name, a),
-                )
+        self._owner_globals = owner_globals
+
+        self._owner_name: str | None = owner_globals.get('__name__') if owner_globals else None
+
+        # NOTE: Import machinery may be reentrant for things like gc ops and signal handling:
+        # TODO: audit for reentrancy this lol
+        # https://github.com/python/cpython/blob/72f25a8d9a5673d39c107cf522465a566b979ed5/Lib/importlib/_bootstrap.py#L233-L237  # noqa
+        self._lock = threading.RLock()
+
+        self._modules_by_name: dict[str, _ProxyImporter._Module] = {}
+        self._modules_by_proxy_obj: dict[types.ModuleType, _ProxyImporter._Module] = {}
+
+    class _Module:
+        def __init__(
+                self,
+                name: str,
+                getattr_handler: ta.Callable[['_ProxyImporter._Module', str], ta.Any],
+                *,
+                parent: ta.Optional['_ProxyImporter._Module'] = None,
+        ) -> None:
+            super().__init__()
+
+            self.name = name
+            self.parent = parent
+
+            self.base_name = name.rpartition('.')[2]
+            self.root: _ProxyImporter._Module = parent.root if parent is not None else self  # noqa
+
+            self.children: dict[str, _ProxyImporter._Module] = {}
+            self.descendants: set[_ProxyImporter._Module] = set()
+
+            self.proxy_obj = types.ModuleType(f'<{self.__class__.__qualname__}: {name}>')
+            self.proxy_obj.__file__ = None
+            self.proxy_obj.__getattr__ = functools.partial(getattr_handler, self)  # type: ignore[method-assign]
+
+            self.pending_children: set[str] = set()
+            self.pending_attrs: set[str] = set()
+
+        real_obj: types.ModuleType | None = None
+
+        def __repr__(self) -> str:
+            return f'{self.__class__.__name__}<{self.name}{"!" if self.real_obj is not None else ""}>'
+
+        def find_attr(self, attr: str) -> _ProxyImporterModuleAttr | None:
+            is_child = attr in self.children
+            is_proxy_attr = attr in self.proxy_obj.__dict__
+            is_pending_child = attr in self.pending_children
+            is_pending_attr = attr in self.pending_attrs
+
+            if is_child:
+                if (
+                        not is_proxy_attr or
+                        is_pending_child or
+                        is_pending_attr
+                ):
+                    raise RuntimeError
+                return 'child'
+
+            elif is_proxy_attr:
+                if (
+                        is_pending_child or
+                        is_pending_attr
+                ):
+                    raise RuntimeError
+                return 'proxy_attr'
+
+            elif is_pending_child:
+                if (
+                        is_child or
+                        is_proxy_attr or
+                        is_pending_attr
+                ):
+                    raise RuntimeError
+                return 'pending_child'
+
+            elif is_pending_attr:
+                if (
+                        is_child or
+                        is_proxy_attr or
+                        is_pending_child
+                ):
+                    raise RuntimeError
+                return 'pending_attr'
 
-        elif ci.module.kind == 'terminal':
-            if ci.module.children:
-                raise NotImplementedError
+            else:
+                return None
 
-            for a in ci.as_:
-                dct.setdefault(ci.module.name, []).append(
-                    (None, a),
-                )
+    #
 
-            for sa, da in ci.attrs:
-                dct.setdefault(ci.module.name, []).append(
-                    (sa, da),
-                )
+    def _get_or_make_module_locked(self, name: str) -> _Module:
+        try:
+            return self._modules_by_name[name]
+        except KeyError:
+            pass
 
-        else:
-            raise NotImplementedError
+        parent: _ProxyImporter._Module | None = None
+        if '.' in name:
+            rest, _, attr = name.rpartition('.')
+            parent = self._get_or_make_module_locked(rest)
 
-    return dct
+            fa = parent.find_attr(attr)
+            if not (fa == 'pending_child' or fa is None):
+                raise RuntimeError
 
+            if (ro := parent.real_obj) is not None and attr not in ro.__dict__:
+                raise NotImplementedError
 
-##
+        module = self._modules_by_name[name] = _ProxyImporter._Module(
+            name,
+            self._handle_module_getattr,
+        )
 
+        self._modules_by_name[name] = module
+        self._modules_by_proxy_obj[module.proxy_obj] = module
 
-def proxy_import(
-        spec: str,
-        package: str | None = None,
-        extras: ta.Iterable[str] | None = None,
-) -> types.ModuleType:
-    if isinstance(extras, str):
-        raise TypeError(extras)
+        if parent is not None:
+            parent.pending_children.discard(module.base_name)
+            parent.children[module.base_name] = module
+            setattr(parent.proxy_obj, module.base_name, module.proxy_obj)
+            parent.root.descendants.add(module)
 
-    omod = None
+        return module
 
-    def __getattr__(att):  # noqa
-        nonlocal omod
-        if omod is None:
-            omod = importlib.import_module(spec, package=package)
-            if extras:
-                for x in extras:
-                    importlib.import_module(f'{spec}.{x}', package=package)
-        return getattr(omod, att)
+    def _extend_module_locked(
+            self,
+            module: _Module,
+            *,
+            children: ta.Iterable[str] | None = None,
+            attrs: ta.Iterable[str] | None = None,
+    ) -> None:
+        for l in (children, attrs):
+            for n in l or ():
+                if n in module.proxy_obj.__dict__:
+                    raise NotImplementedError
 
-    lmod = types.ModuleType(spec)
-    lmod.__getattr__ = __getattr__  # type: ignore[method-assign]
-    return lmod
+                if (ro := module.real_obj) is not None and n in ro.__dict__:
+                    raise NotImplementedError
 
+        for n in children or ():
+            fa = module.find_attr(n)
+            if not (fa == 'pending_child' or fa is None):
+                raise RuntimeError
 
-#
+        for n in attrs or ():
+            fa = module.find_attr(n)
+            if not (fa == 'pending_attr' or fa is None):
+                raise RuntimeError
 
+        #
 
-def auto_proxy_import(
-        mod_globals: ta.MutableMapping[str, ta.Any],
-        *,
-        disable: bool = False,
+        if children:
+            module.pending_children.update(n for n in children if n not in module.children)
+        if attrs:
+            module.pending_attrs.update(attrs)
 
-        unreferenced_callback: ta.Callable[[ta.Sequence[str]], None] | None = None,
-        raise_unreferenced: bool = False,
+    def _retrieve_from_module_locked(self, module: _Module, attr: str) -> ta.Any:
+        fa = module.find_attr(attr)
 
-        _stack_offset: int = 0,
-) -> ta.ContextManager[ImportCapture]:
-    inst = ImportCapture(
-        mod_globals,
-        _hook=_new_import_capture_hook(
-            mod_globals,
-            stack_offset=_stack_offset + 1,
-        ),
-        disable=disable,
-    )
+        if fa == 'child' or fa == 'proxy_attr':
+            return module.proxy_obj.__dict__[attr]
 
-    @contextlib.contextmanager
-    def inner() -> ta.Iterator[ImportCapture]:
-        with inst.capture(
-                unreferenced_callback=unreferenced_callback,
-                raise_unreferenced=raise_unreferenced,
-        ):
-            yield inst
+        val: ta.Any
 
-        for spec, attrs in _translate_old_style_import_capture(inst.captured).items():
-            for sa, ma in attrs:
-                mod_globals[ma] = proxy_import(spec + (('.' + sa) if sa is not None else ''))
+        if fa == 'pending_child':
+            if module.name == self._owner_name:
+                val = importlib.import_module(f'{module.name}.{attr}')
 
-    return inner()
+            else:
+                mod = __import__(
+                    module.name,
+                    self._owner_globals or {},
+                    {},
+                    [attr],
+                    0,
+                )
 
+                val = getattr(mod, attr)
 
-##
+            module.pending_children.remove(attr)
 
+        elif fa == 'pending_attr' or fa is None:
+            if module.name == self._owner_name:
+                raise NotImplementedError
 
-class _ProxyInit:
-    class NamePackage(ta.NamedTuple):
-        name: str
-        package: str
+            if (ro := module.real_obj) is None:
+                ro = module.real_obj = importlib.import_module(module.name)
 
-    class _Import(ta.NamedTuple):
-        name: str
-        attr: str | None
+            val = getattr(ro, attr)
 
-    def __init__(
-            self,
-            lazy_globals: LazyGlobals,
-            name_package: NamePackage,
-    ) -> None:
-        super().__init__()
+            if fa == 'pending_attr':
+                module.pending_attrs.remove(attr)
 
-        self._lazy_globals = lazy_globals
-        self._name_package = name_package
+        else:
+            raise TypeError(fa)
+
+        setattr(module.proxy_obj, attr, val)
+        return val
 
-        self._imps_by_attr: dict[str, _ProxyInit._Import] = {}
+    #
 
-    @property
-    def name_package(self) -> NamePackage:
-        return self._name_package
+    def _handle_module_getattr(self, module: _Module, attr: str) -> ta.Any:
+        with self._lock:
+            return self._retrieve_from_module_locked(module, attr)
 
     def add(
             self,
-            name: str,
-            attrs: ta.Iterable[tuple[str | None, str]],
-    ) -> None:
-        for imp_attr, as_attr in attrs:
-            if imp_attr is None:
-                self._imps_by_attr[as_attr] = self._Import(name, None)
-                self._lazy_globals.set_fn(as_attr, functools.partial(self.get, as_attr))
+            module: str,
+            *,
+            children: ta.Iterable[str] | None = None,
+            attrs: ta.Iterable[str] | None = None,
+    ) -> types.ModuleType:
+        if isinstance(children, str):
+            raise TypeError(children)
+
+        # Leaf modules get collapsed into parents' pending_children
+        if not children and not attrs and '.' in module:
+            module, _, child = module.rpartition('.')
+            children = [child]
+
+        with self._lock:
+            m = self._get_or_make_module_locked(module)
+
+            if children or attrs:
+                self._extend_module_locked(
+                    m,
+                    children=children,
+                    attrs=attrs,
+                )
 
-            else:
-                self._imps_by_attr[as_attr] = self._Import(name, imp_attr)
-                self._lazy_globals.set_fn(as_attr, functools.partial(self.get, as_attr))
+        return m.proxy_obj
 
-    def get(self, attr: str) -> ta.Any:
+    def get_module(self, name: str) -> types.ModuleType:
         try:
-            imp = self._imps_by_attr[attr]
+            return self._modules_by_name[name].proxy_obj
         except KeyError:
-            raise AttributeError(attr)  # noqa
-
-        val: ta.Any
+            pass
 
-        if imp.attr is None:
-            val = importlib.import_module(imp.name)
+        with self._lock:
+            return self._get_or_make_module_locked(name).proxy_obj
 
-        elif imp.name == self._name_package.name:
-            val = importlib.import_module(f'{imp.name}.{imp.attr}')
+    def lookup(self, spec: str) -> ta.Any:
+        if '.' not in spec:
+            return self._modules_by_name[spec].proxy_obj
 
+        try:
+            module = self._modules_by_name[spec]
+        except KeyError:
+            pass
         else:
-            mod = __import__(
-                imp.name,
-                self._lazy_globals._globals,  # noqa
-                {},
-                [imp.attr],
-                0,
-            )
+            return module.proxy_obj
 
-            val = getattr(mod, imp.attr)
+        rest, _, attr = spec.rpartition('.')
+        module = self._modules_by_name[rest]
+        return getattr(module.proxy_obj, attr)
 
-        return val
+
+#
+
+
+_MODULE_PROXY_IMPORTER_GLOBAL_NAME = '__proxy_importer__'
+
+
+def _get_module_proxy_importer(mod_globals: ta.MutableMapping[str, ta.Any]) -> _ProxyImporter:
+    """Assumed to only be called in a module body - no locking is done."""
+
+    pi: _ProxyImporter
+    try:
+        pi = mod_globals[_MODULE_PROXY_IMPORTER_GLOBAL_NAME]
+
+    except KeyError:
+        pi = _ProxyImporter(
+            owner_globals=mod_globals,
+        )
+        mod_globals[_MODULE_PROXY_IMPORTER_GLOBAL_NAME] = pi
+
+    else:
+        if pi.__class__ is not _ProxyImporter:
+            raise TypeError(pi)
+
+        if pi._owner_globals is not mod_globals:  # noqa
+            raise RuntimeError
+
+    return pi
+
+
+##
+
+
+def proxy_import(
+        spec: str,
+        package: str | None = None,
+        extras: ta.Iterable[str] | None = None,
+) -> types.ModuleType:
+    """'Legacy' proxy import mechanism."""
+
+    if isinstance(extras, str):
+        raise TypeError(extras)
+
+    omod = None
+
+    def __getattr__(att):  # noqa
+        nonlocal omod
+        if omod is None:
+            omod = importlib.import_module(spec, package=package)
+            if extras:
+                for x in extras:
+                    importlib.import_module(f'{spec}.{x}', package=package)
+        return getattr(omod, att)
+
+    lmod = types.ModuleType(spec)
+    lmod.__getattr__ = __getattr__  # type: ignore[method-assign]
+    return lmod
+
+
+#
 
 
 def proxy_init(
@@ -225,76 +407,143 @@ def proxy_init(
 
     #
 
-    init_name_package = _ProxyInit.NamePackage(
-        init_globals['__name__'],
-        init_globals['__package__'],
+    pi = _get_module_proxy_importer(init_globals)
+    lg = LazyGlobals.install(init_globals)
+
+    pi.add(
+        name,
+        children=[r for l, r in al if r is not None],
     )
 
-    pi: _ProxyInit
-    try:
-        pi = init_globals['__proxy_init__']
+    for imp_attr, as_attr in al:
+        lg.set_fn(as_attr, functools.partial(pi.lookup, name if imp_attr is None else f'{name}.{imp_attr}'))
 
-    except KeyError:
-        pi = _ProxyInit(
-            LazyGlobals.install(init_globals),
-            init_name_package,
+
+##
+
+
+class _AutoProxy:
+    def __init__(
+            self,
+            mod_globals: ta.MutableMapping[str, ta.Any],
+            *,
+            disable: bool = False,
+            eager: bool = False,
+
+            unreferenced_callback: ta.Callable[[ta.Sequence[str]], None] | None = None,
+            raise_unreferenced: bool = False,
+
+            update_exports: bool = False,
+
+            _stack_offset: int = 0,
+            _capture_impl: str | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._mod_globals = mod_globals
+
+        self._disabled = disable
+        self._eager = eager
+
+        self._unreferenced_callback = unreferenced_callback
+        self._raise_unreferenced = raise_unreferenced
+
+        self._update_exports = update_exports
+
+        self._ic = ImportCapture(
+            mod_globals,
+            _hook=_new_import_capture_hook(
+                mod_globals,
+                stack_offset=_stack_offset + 1,
+                capture_impl=_capture_impl,
+            ),
+            disable=disable,
         )
-        init_globals['__proxy_init__'] = pi
+        self._icc: ta.Any = None
 
-    else:
-        if pi.name_package != init_name_package:
-            raise Exception(f'Wrong init name: {pi.name_package=} != {init_name_package=}')
+    def __enter__(self) -> ImportCapture:
+        if self._icc is not None:
+            raise RuntimeError
 
-    pi.add(name, al)
+        self._icc = self._ic.capture(
+            unreferenced_callback=self._unreferenced_callback,
+            raise_unreferenced=self._raise_unreferenced,
+        )
 
+        return self._icc.__enter__()  # noqa
 
-#
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._icc is None:
+            raise RuntimeError
 
+        self._icc.__exit__(exc_type, exc_val, exc_tb)
 
-def auto_proxy_init(
-        init_globals: ta.MutableMapping[str, ta.Any],
-        *,
-        disable: bool = False,
-        eager: bool = False,
-
-        unreferenced_callback: ta.Callable[[ta.Sequence[str]], None] | None = None,
-        raise_unreferenced: bool = False,
-
-        update_exports: bool = False,
-
-        _stack_offset: int = 0,
-) -> ta.ContextManager[ImportCapture]:
-    inst = ImportCapture(
-        init_globals,
-        _hook=_new_import_capture_hook(
-            init_globals,
-            stack_offset=_stack_offset + 1,
-        ),
-        disable=disable,
-    )
+        if not self._disabled and exc_type is None:
+            self._install()
+
+    # @abc.abstractmethod
+    def _install(self) -> None:
+        raise NotImplementedError
+
+
+@ta.final
+class _AutoProxyImport(_AutoProxy):
+    def _install(self) -> None:
+        cap = self._ic.captured
+
+        for cm in cap.modules.values():
+            if cm.attrs:
+                raise RuntimeError
+
+        pi = _get_module_proxy_importer(self._mod_globals)
 
-    @contextlib.contextmanager
-    def inner() -> ta.Iterator[ImportCapture]:
-        with inst.capture(
-                unreferenced_callback=unreferenced_callback,
-                raise_unreferenced=raise_unreferenced,
-        ):
-            yield inst
-
-        for spec, attrs in _translate_old_style_import_capture(inst.captured).items():
-            proxy_init(
-                init_globals,
-                spec,
-                attrs,
+        for cm in cap.modules.values():
+            pi.add(
+                cm.name,
+                children=cm.children,
             )
 
-        if eager:
-            lg = LazyGlobals.install(init_globals)
+        for ci in cap.imports.values():
+            pm = pi.get_module(ci.module.name)
+            for a in ci.as_ or ():
+                self._mod_globals[a] = pm
 
-            for a in inst.captured.attrs:
+        if self._eager:
+            for ci in cap.imports.values():
+                pi.lookup(ci.module.name)
+
+        if self._update_exports:
+            self._ic.update_exports()
+
+
+@ta.final
+class _AutoProxyInit(_AutoProxy):
+    def _install(self) -> None:
+        cap = self._ic.captured
+
+        pi = _get_module_proxy_importer(self._mod_globals)
+        lg = LazyGlobals.install(self._mod_globals)
+
+        for cm in cap.modules.values():
+            pi.add(
+                cm.name,
+                children=cm.children,
+                attrs=cm.attrs,
+            )
+
+        for ci in cap.imports.values():
+            for a in ci.as_ or ():
+                lg.set_fn(a, functools.partial(pi.lookup, ci.module.name))
+            for sa, da in ci.attrs or ():
+                lg.set_fn(da, functools.partial(pi.lookup, f'{ci.module.name}.{sa}'))
+
+        if self._eager:
+            for a in cap.attrs:
                 lg.get(a)
 
-        if update_exports:
-            inst.update_exports()
+        if self._update_exports:
+            self._ic.update_exports()
+
 
-    return inner()
+auto_proxy_import = _AutoProxyImport
+auto_proxy_init = _AutoProxyInit

omlish/lang/lazyglobals.py

@@ -1,3 +1,4 @@
+import threading
 import typing as ta
 
 
@@ -15,6 +16,10 @@ class AmbiguousLazyGlobalsFallbackError(Exception):
         return f'{self.__class__.__name__}({self.attr!r}, {self.fallbacks!r})'
 
 
+_LAZY_GLOBALS_LOCK = threading.RLock()
+
+
+@ta.final
 class LazyGlobals:
     def __init__(
             self,
@@ -22,8 +27,6 @@ class LazyGlobals:
             globals: ta.MutableMapping[str, ta.Any] | None = None,  # noqa
             update_globals: bool = False,
     ) -> None:
-        super().__init__()
-
         self._globals = globals
         self._update_globals = update_globals
 
@@ -37,18 +40,28 @@ class LazyGlobals:
         except KeyError:
             pass
         else:
-            if not isinstance(xga, cls):
+            if xga.__class__ is not cls:
                 raise RuntimeError(f'Module already has __getattr__ hook: {xga}')  # noqa
             return xga
 
-        lm = cls(
-            globals=globals,
-            update_globals=True,
-        )
+        with _LAZY_GLOBALS_LOCK:
+            try:
+                xga = globals['__getattr__']
+            except KeyError:
+                pass
+            else:
+                if xga.__class__ is not cls:
+                    raise RuntimeError(f'Module already has __getattr__ hook: {xga}')  # noqa
+                return xga
+
+            lm = cls(
+                globals=globals,
+                update_globals=True,
+            )
 
-        globals['__getattr__'] = lm
+            globals['__getattr__'] = lm
 
-        return lm
+            return lm
 
     def set_fn(self, attr: str, fn: ta.Callable[[], ta.Any]) -> 'LazyGlobals':
         self._attr_fns[attr] = fn

omlish/term/vt100/terminal.py

@@ -5,9 +5,6 @@ import typing as ta
 from ...lite.check import check
 
 
-T = ta.TypeVar('T')
-
-
 ##
 
 

{omlish-0.0.0.dev459.dist-info → omlish-0.0.0.dev460.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev459
+Version: 0.0.0.dev460
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev459.dist-info → omlish-0.0.0.dev460.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.omlish-manifests.json,sha256=FLw7xkPiSXuImZgqSP8BwrEib2R1doSzUPLUkc-QUIA,8410
-omlish/__about__.py,sha256=xtL6Mzn2wu2_IspeSZ_MxiJmXyGvptjs7xRjcNyq79E,3613
+omlish/__about__.py,sha256=Lh3QcQsg1H85i-Syg0Z1HsN6E9om5sxdQHnAEl79_ng,3613
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ZNIMl1kwg3qdei4DiUrJPQe5M81S1e76N-GuNSwLBAE,8683
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -425,7 +425,7 @@ omlish/lang/errors.py,sha256=shcS-NCnEUudF8qC_SmO2TQyjivKlS4TDjaz_faqQ0c,44
 omlish/lang/functions.py,sha256=tZL7Yi5Oy34lvzP6HhWmV5q1eg5-mk3FrWEjsmhKRhY,5707
 omlish/lang/generators.py,sha256=nJiSmDpsfPiypGzJ8qlOO7-BUnCsrAeDow9mhtGgBio,5196
 omlish/lang/iterables.py,sha256=o_s8ouaJrdUqEVl2_bzJk5CVdabmrywXY0gPn7xss3w,3371
-omlish/lang/lazyglobals.py,sha256=YfPtWgNEa0ULtbIiQIQ12pbafUwd6INQRw_PFcAabjo,2282
+omlish/lang/lazyglobals.py,sha256=5v4S0YSUrxdZFC6znrWolfeheArMa_DEJEcz46XCQN4,2676
 omlish/lang/maybes.py,sha256=8GUpqJvyx9y5PQBQBBx6yTSE5WKsMbXMHPt4_vojKUw,209
 omlish/lang/maysync.py,sha256=S2Q_rGC4AxRa1UsGJdSzZsYpgOcX9Y8ZmYGA9v8OWn8,1635
 omlish/lang/objects.py,sha256=JMOZU5I6sK4rJm04898dOJkvef-lDIh5O3k6tlLbBJw,4616
@@ -452,10 +452,10 @@ omlish/lang/classes/simple.py,sha256=3AJSs-plVg2flq4SC6I39LxP0nBaB241puv3D5YCP5I
 omlish/lang/classes/virtual.py,sha256=J4y-uiv1RaP2rfFeptXqQ1a4MRek0TMlAFFraO_lzhs,3397
 omlish/lang/imports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/lang/imports/_capture.cc,sha256=cp-L5yFGjftfBa12sKNz0Q5Yhh54a88DH7VEN1oa5hU,2313
-omlish/lang/imports/capture.py,sha256=z91F2CVcBDX4trhd2oRB5YL_d_Nu9KBTjzhy98N9YDQ,26170
+omlish/lang/imports/capture.py,sha256=pyON5qUw9IuzzOcIHh4QNjlzAEjIGb9DwI7Z8yLDUfw,27265
 omlish/lang/imports/conditional.py,sha256=R-E47QD95mMonPImWlrde3rnJrFKCCkYz71c94W05sc,1006
 omlish/lang/imports/lazy.py,sha256=Eefs9hkj5surMdwgxX_Q3BOqPcox10v0sKT5rKIQknc,808
-omlish/lang/imports/proxy.py,sha256=tIIChKvl5TCZp_vg6D7WR7NxnN0J-L-bqjp0DYvgUuA,7562
+omlish/lang/imports/proxy.py,sha256=ZhSETt41gjb4STGz9byZ5fpTi8GVdoSmPL-tbr0BEgQ,15897
 omlish/lang/imports/resolving.py,sha256=DeRarn35Fryg5JhVhy8wbiC9lvr58AnllI9B_reswUE,2085
 omlish/lang/imports/traversal.py,sha256=pbFQIa880NGjSfcLsno2vE_G41_CLwDHb-7gWg2J3BI,2855
 omlish/lifecycles/__init__.py,sha256=zOuvV4pErPwxcKUSgshmME2Duw9GrjwckpNmW3FPKng,810
@@ -763,7 +763,7 @@ omlish/term/progressbar.py,sha256=nCnTX1dUNCGle9FzzeTBuoxQaellErOQkyBsKVrGG1I,36
 omlish/term/vt100/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/term/vt100/c.py,sha256=93HARU6Dd1rVF-n8cAyXqkEqleYLcofuLgSUNd6-GbU,3537
 omlish/term/vt100/states.py,sha256=OxPUxfFTcfz56MhtDgIigEApChOtN6XO1g6R2H08mu4,8303
-omlish/term/vt100/terminal.py,sha256=KUlg331ele7P6SHsBKdbpdQFDKsxSply1Ds27NkppTs,9359
+omlish/term/vt100/terminal.py,sha256=VHbZs5mHZPBizxseWKcRH77QAjE4bWDvuHi3NM6PvbA,9337
 omlish/testing/__init__.py,sha256=h8GMv0PhVyMECsQoYuqoBzHjYO6UJyXBZvnozzUg9M8,171
 omlish/testing/testing.py,sha256=tlBeqVmzGhjRbWygJt3mZljq662qR4nAaGNE2VoAey4,3617
 omlish/testing/pytest/__init__.py,sha256=i4ti6Q2rVYJ-XBk9UYDfUUagCrEDTC5jOeSykBjYYZQ,234
@@ -826,9 +826,9 @@ omlish/typedvalues/marshal.py,sha256=2xqX6JllhtGpmeYkU7C-qzgU__0x-vd6CzYbAsocQlc
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev459.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev459.dist-info/METADATA,sha256=vA7Ker_93at2wRMI8zaoBhaoAnE8BmZqvBEDDGy9gEg,19003
-omlish-0.0.0.dev459.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev459.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev459.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev459.dist-info/RECORD,,
+omlish-0.0.0.dev460.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev460.dist-info/METADATA,sha256=RXnH7VCjc6A71590hroJ9LF3IFEaonZi1aHkHevvASI,19003
+omlish-0.0.0.dev460.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev460.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev460.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev460.dist-info/RECORD,,