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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev458'
-__revision__ = '03501d1fe0a74615b61159ca12f11879ce2029b3'
+__version__ = '0.0.0.dev459'
+__revision__ = 'a12178d42c88b1d69bca74aaf2cd0f1fd8106a47'
 
 
 #
@@ -83,7 +83,7 @@ class Project(ProjectBase):
         ],
 
         'secrets': [
-            'cryptography ~= 45.0',
+            'cryptography ~= 46.0',
         ],
 
         'sqlalchemy': [

omlish/diag/pydevd.py

@@ -6,7 +6,7 @@ an already-debugging PyCharm instance to debug PySpark jobs.
 TODO:
  - https://www.jetbrains.com/help/pycharm/remote-debugging-with-product.html#
 
-==
+====
 
 https://www.jetbrains.com/help/pycharm/remote-debugging-with-product.html#remote-debug-config ->
 
@@ -25,6 +25,28 @@ buf = textwrap.dedent(f'''
            stderrToServer=True,
        )
 ''') + '\n' * 2 + buf
+
+====
+
+TODO: monkeypatch:
+
+/Applications/PyCharm.app/Contents/plugins/python-ce/helpers/pydev/_pydev_bundle/pydev_monkey.py ::
+
+def starts_with_python_shebang(path):
+    try:
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    for name in PYTHON_NAMES:
+                        if line.startswith('#!/usr/bin/env %s' % name):
+                            return True
+                    return False
+    except (UnicodeDecodeError, IsADirectoryError):  # <-- Add catch for `IsADirectoryError`
+        return False
+    except:
+        traceback.print_exc()
+        return False
 """
 import json
 import os

omlish/lang/imports/_capture.cc

@@ -5,6 +5,9 @@
 #define Py_BUILD_CORE 1
 #include "Python.h"
 #include "internal/pycore_frame.h"
+#if PY_VERSION_HEX >= 0x030E0000
+#include "internal/pycore_interpframe.h"
+#endif
 #undef Py_BUILD_CORE
 
 #if PY_VERSION_HEX < 0x030D0000
@@ -50,14 +53,12 @@ _set_frame_builtins(PyObject *self, PyObject *args)
 
     std::atomic_ref<PyObject*> builtins_ref(iframe->f_builtins);
     PyObject* expected = old_builtins;
-    bool success = builtins_ref.compare_exchange_strong(
+    if (builtins_ref.compare_exchange_strong(
         expected,
         new_builtins,
         std::memory_order_acq_rel,
         std::memory_order_acquire
-    );
-
-    if (success) {
+    )) {
         Py_RETURN_TRUE;
     } else {
         Py_RETURN_FALSE;

omlish/lang/imports/capture.py

@@ -15,6 +15,7 @@ Possible alt impls:
 import builtins
 import contextlib
 import functools
+import importlib.util
 import sys
 import threading
 import types
@@ -46,14 +47,27 @@ class ImportCaptureErrors:
             return f'{self.__class__.__qualname__}(module={self.module!r}, name={self.name!r})'
 
     class ImportError(ImportCaptureError):  # noqa
-        def __init__(self, module: str, from_list: ta.Sequence[str] | None) -> None:
+        def __init__(
+                self,
+                name: str,
+                *,
+                level: int | None = None,
+                from_list: ta.Sequence[str] | None,
+        ) -> None:
             super().__init__()
 
-            self.module = module
+            self.name = name
+            self.level = level
             self.from_list = from_list
 
         def __repr__(self) -> str:
-            return f'{self.__class__.__qualname__}(module={self.module!r}, from_list={self.from_list!r})'
+            return ''.join([
+                f'{self.__class__.__qualname__}(',
+                f'name={self.name!r}',
+                *([f', level={self.level!r}'] if self.level is not None else []),
+                *([f', from_list={self.from_list!r}'] if self.from_list is not None else []),
+                ')',
+            ])
 
     class ImportStarForbiddenError(ImportError):
         pass
@@ -62,7 +76,7 @@ class ImportCaptureErrors:
         pass
 
     class UnreferencedImportsError(ImportCaptureError):
-        def __init__(self, unreferenced: ta.Mapping[str, ta.Sequence[str | None]]) -> None:
+        def __init__(self, unreferenced: ta.Sequence[str]) -> None:
             super().__init__()
 
             self.unreferenced = unreferenced
@@ -78,136 +92,144 @@ class ImportCaptureErrors:
 
 
 class _ImportCaptureHook:
-    class ModuleSpec(ta.NamedTuple):
-        name: str
-        level: int
-
-        def __str__(self) -> str:
-            return f'{"." * self.level}{self.name}'
-
-        def __repr__(self) -> str:
-            return repr(str(self))
-
     def __init__(
             self,
             *,
+            package: str | None = None,
             forbid_uncaptured_imports: bool = False,
     ) -> None:
         super().__init__()
 
+        self._package = package
         self._forbid_uncaptured_imports = forbid_uncaptured_imports
 
-        self._modules_by_spec: dict[_ImportCaptureHook.ModuleSpec, _ImportCaptureHook._Module] = {}
+        self._modules_by_name: dict[str, _ImportCaptureHook._Module] = {}
         self._modules_by_module_obj: dict[types.ModuleType, _ImportCaptureHook._Module] = {}
 
-        self._attrs: dict[_ImportCaptureHook._ModuleAttr, tuple[_ImportCaptureHook._Module, str]] = {}
-
     #
 
-    class _ModuleAttr:
+    class _Module:
         def __init__(
                 self,
-                module: '_ImportCaptureHook._Module',
                 name: str,
+                getattr_handler: ta.Callable[['_ImportCaptureHook._Module', str], ta.Any],
+                *,
+                parent: ta.Optional['_ImportCaptureHook._Module'] = None,
         ) -> None:
             super().__init__()
 
-            self.__module = module
-            self.__name = name
+            if name.startswith('.'):
+                raise ImportCaptureError
+            self.name = name
+            self.base_name = name.rpartition('.')[2]
+            self.parent = parent
+
+            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__}: {f"{self.__module.spec}:{self.__name}"!r}>'
+            return f'{self.__class__.__name__}<{self.name}{"!" if self.immediate else "+" if self.explicit else ""}>'
 
-    class _Module:
-        def __init__(
-                self,
-                spec: '_ImportCaptureHook.ModuleSpec',
-                *,
-                getattr_handler: ta.Callable[['_ImportCaptureHook._Module', str], ta.Any] | None = None,
-        ) -> None:
-            super().__init__()
+        @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:
+                cur.explicit = True
+                cur = cur.parent
 
-            self.spec = spec
+    #
 
-            self.module_obj = types.ModuleType(f'<{self.__class__.__qualname__}: {spec!r}>')
-            if getattr_handler is not None:
-                self.module_obj.__getattr__ = functools.partial(getattr_handler, self)  # type: ignore[method-assign]  # noqa
-            self.initial_module_dict = dict(self.module_obj.__dict__)
+    @property
+    def _modules(self) -> ta.Sequence[_Module]:
+        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)
+
+            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
 
-            self.contents: dict[str, _ImportCaptureHook._ModuleAttr | types.ModuleType] = {}
-            self.imported_whole = False
+            if parent is not None:
+                parent.children[attr] = module  # noqa
+                setattr(parent.module_obj, attr, module.module_obj)
+                parent.root.descendants.add(module)
 
-        def __repr__(self) -> str:
-            return f'{self.__class__.__name__}({self.spec!r})'
+            return module
 
-    def _get_or_make_module(self, spec: ModuleSpec) -> _Module:
-        try:
-            return self._modules_by_spec[spec]
-        except KeyError:
-            pass
+        return rec(name)
 
-        module = self._Module(
-            spec,
-            getattr_handler=self._handle_module_getattr,
-        )
-        self._modules_by_spec[spec] = module
-        self._modules_by_module_obj[module.module_obj] = module
-        return module
+    def _make_child_module(self, module: _Module, attr: str) -> _Module:
+        if attr in module.children:
+            raise ImportCaptureErrors.AttrError(module.name, attr)
 
-    def _handle_module_getattr(self, module: _Module, attr: str) -> ta.Any:
-        if attr in module.contents:
-            raise ImportCaptureErrors.AttrError(str(module.spec), attr)
+        return self._get_or_make_module(f'{module.name}.{attr}')
 
-        v: _ImportCaptureHook._ModuleAttr | types.ModuleType
-        if not module.spec.name:
-            if not module.spec.level:
-                raise ImportCaptureError
-            cs = _ImportCaptureHook.ModuleSpec(attr, module.spec.level)
-            cm = self._get_or_make_module(cs)
-            cm.imported_whole = True
-            v = cm.module_obj
+    #
 
-        else:
-            ma = _ImportCaptureHook._ModuleAttr(module, attr)
-            self._attrs[ma] = (module, attr)
-            v = ma
+    def _handle_module_getattr(self, module: _Module, attr: str) -> ta.Any:
+        if not module.explicit:
+            raise ImportCaptureErrors.AttrError(module.name, attr)
 
-        module.contents[attr] = v
-        setattr(module.module_obj, attr, v)
-        return v
+        return self._make_child_module(module, attr).module_obj
 
     def _handle_import(
             self,
-            module: _Module,
+            name: str,
             *,
             from_list: ta.Sequence[str] | None,
-    ) -> None:
-        if from_list is None:
-            if module.spec.level or not module.spec.name:
-                raise ImportCaptureError
+    ) -> types.ModuleType:
+        module = self._get_or_make_module(name)
 
-            module.imported_whole = True
+        if from_list is None:
+            module.set_explicit()
+            module.root.immediate = True
+            return module.root.module_obj
 
         else:
             for attr in from_list:
                 if attr == '*':
-                    raise ImportCaptureErrors.ImportStarForbiddenError(str(module.spec), from_list)
+                    raise ImportCaptureErrors.ImportStarForbiddenError(module.name, from_list=from_list)
+
+                if (cm := module.children.get(attr)) is None:
+                    cm = self._make_child_module(module, attr)
+                    cm.set_explicit()
+                    cm.immediate = True
+                    continue
 
                 x = getattr(module.module_obj, attr)
+                if x is not cm.module_obj or x not in self._modules_by_module_obj:
+                    raise ImportCaptureErrors.AttrError(module.name, attr)
 
-                bad = False
-                if x is not module.contents.get(attr):
-                    bad = True
-                if isinstance(x, _ImportCaptureHook._ModuleAttr):
-                    if self._attrs[x] != (module, attr):
-                        bad = True
-                elif isinstance(x, types.ModuleType):
-                    if x not in self._modules_by_module_obj:
-                        bad = True
-                else:
-                    bad = True
-                if bad:
-                    raise ImportCaptureErrors.AttrError(str(module.spec), attr)
+            return module.module_obj
 
     #
 
@@ -227,16 +249,16 @@ class _ImportCaptureHook:
         ):
             return None
 
-        spec = _ImportCaptureHook.ModuleSpec(name, level)
-        module = self._get_or_make_module(spec)
+        if level:
+            if not self._package:
+                raise ImportCaptureError
+            name = importlib.util.resolve_name(('.' * level) + name, self._package)
 
-        self._handle_import(
-            module,
+        return self._handle_import(
+            name,
             from_list=from_list,
         )
 
-        return module.module_obj
-
     @ta.final
     @contextlib.contextmanager
     def hook_context(
@@ -271,18 +293,24 @@ class _ImportCaptureHook:
             self,
             mod_globals: ta.MutableMapping[str, ta.Any],  # noqa
     ) -> None:
-        for m in self._modules_by_spec.values():
+        for m in self._modules_by_name.values():
+            if m.immediate and not m.explicit:
+                raise ImportCaptureError
+
+            if not m.explicit and m.children:
+                raise ImportCaptureError
+
             for a, o in m.module_obj.__dict__.items():
                 try:
                     i = m.initial_module_dict[a]
 
                 except KeyError:
-                    if o is not m.contents[a]:
-                        raise ImportCaptureErrors.AttrError(str(m.spec), a) from None
+                    if o is not m.children[a].module_obj:
+                        raise ImportCaptureErrors.AttrError(m.name, a) from None
 
                 else:
                     if o != i:
-                        raise ImportCaptureErrors.AttrError(str(m.spec), a)
+                        raise ImportCaptureErrors.AttrError(m.name, a)
 
     #
 
@@ -292,24 +320,16 @@ class _ImportCaptureHook:
             *,
             collect_unreferenced: bool = False,
     ) -> 'ImportCapture.Captured':
-        dct: dict[_ImportCaptureHook._Module, list[tuple[str | None, str]]] = {}
-
-        rem_whole_mods: set[_ImportCaptureHook._Module] = set()
-        rem_mod_attrs: set[_ImportCaptureHook._ModuleAttr] = set()
+        rem_explicit_mods: set[_ImportCaptureHook._Module] = set()
         if collect_unreferenced:
-            rem_whole_mods.update([m for m in self._modules_by_spec.values() if m.imported_whole])
-            rem_mod_attrs.update(self._attrs)
+            rem_explicit_mods.update([m for m in self._modules_by_name.values() if m.immediate])
 
-        for attr, obj in mod_globals.items():
-            if isinstance(obj, _ImportCaptureHook._ModuleAttr):
-                try:
-                    m, a = self._attrs[obj]
-                except KeyError:
-                    raise ImportCaptureErrors.AttrError(None, attr) from None
-                dct.setdefault(m, []).append((a, attr))
-                rem_mod_attrs.discard(obj)
+        #
+
+        dct: dict[_ImportCaptureHook._Module, list[tuple[str | None, str]]] = {}
 
-            elif isinstance(obj, _ImportCaptureHook._Module):
+        for attr, obj in mod_globals.items():
+            if isinstance(obj, _ImportCaptureHook._Module):
                 raise ImportCaptureErrors.AttrError(None, attr) from None
 
             elif isinstance(obj, types.ModuleType):
@@ -317,41 +337,80 @@ class _ImportCaptureHook:
                     m = self._modules_by_module_obj[obj]
                 except KeyError:
                     continue
-                if not m.imported_whole:
-                    raise RuntimeError(f'ImportCapture module {m.spec!r} not imported_whole')
-                dct.setdefault(m, []).append((None, attr))
-                rem_whole_mods.discard(m)
-
-        lst: list[ImportCapture.Import] = []
-        for m, ts in dct.items():
-            if not m.spec.name:
-                if not m.spec.level:
-                    raise ImportCaptureError
-                for imp_attr, as_attr in ts:
-                    if not imp_attr:
-                        raise RuntimeError
-                    lst.append(ImportCapture.Import(
-                        '.' * m.spec.level + imp_attr,
-                        [(None, as_attr)],
-                    ))
 
-            else:
-                lst.append(ImportCapture.Import(
-                    str(m.spec),
-                    ts,
-                ))
-
-        unreferenced: dict[str, list[str | None]] | None = None
-        if collect_unreferenced and (rem_whole_mods or rem_mod_attrs):
-            unreferenced = {}
-            for m in rem_whole_mods:
-                unreferenced.setdefault(str(m.spec), []).append(None)
-            for ma in rem_mod_attrs:
-                m, a = self._attrs[ma]
-                unreferenced.setdefault(str(m.spec), []).append(a)
+                if m.explicit:
+                    dct.setdefault(m, []).append((None, attr))
+                    if m in rem_explicit_mods:
+                        # Remove everything reachable from this root *except* items imported immediately, such as
+                        # `from x import y` - those still need to be immediately reachable.
+                        rem_explicit_mods -= {dm for dm in m.descendants if not dm.immediate}
+                        rem_explicit_mods.remove(m)
+
+                else:
+                    p = m.parent
+                    if p is None or not p.explicit:
+                        raise ImportCaptureError
+                    dct.setdefault(p, []).append((m.base_name, attr))
+
+        #
+
+        mods: dict[str, ImportCapture.Module] = {}
+
+        def build_import_module(m: _ImportCaptureHook._Module) -> ImportCapture.Module:
+            children: dict[str, ImportCapture.Module] = {}
+            attrs: list[str] = []
+            for cm in sorted(m.children.values(), key=lambda cm: cm.name):
+                if not cm.explicit:
+                    attrs.append(cm.base_name)
+                else:
+                    children[cm.base_name] = build_import_module(cm)
+
+            mod = ImportCapture.Module(
+                m.name,
+                children or None,
+                attrs or None,
+            )
+
+            if m.parent is None:
+                mod.parent = None
+            for c in children.values():
+                c.parent = mod
+
+            mods[mod.name] = mod
+            return mod
+
+        root_mods: dict[str, ImportCapture.Module] = {
+            m.base_name: build_import_module(m)
+            for m in self._modules_by_name.values()
+            if m.parent is None
+        }
+
+        mods = dict(sorted(mods.items(), key=lambda t: t[0]))
+        root_mods = dict(sorted(root_mods.items(), key=lambda t: t[0]))
+
+        #
+
+        imps: list[ImportCapture.Import] = []
+
+        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],
+            ))
+
+        #
+
+        unreferenced: list[str] | None = None
+        if collect_unreferenced and rem_explicit_mods:
+            unreferenced = sorted(m.name for m in rem_explicit_mods)
 
         return ImportCapture.Captured(
-            lst,
+            {i.module.name: i for i in imps},
+
+            mods,
+            root_mods,
+
             unreferenced,
         )
 
@@ -379,8 +438,9 @@ class _AbstractBuiltinsImportCaptureHook(_ImportCaptureHook):
 
         if self._forbid_uncaptured_imports:
             raise ImportCaptureErrors.UncapturedImportForbiddenError(
-                str(_ImportCaptureHook.ModuleSpec(name, level)),
-                fromlist,
+                name,
+                level=level,
+                from_list=fromlist,
             )
 
         return old_import(
@@ -579,6 +639,8 @@ def _new_import_capture_hook(
     if frame is None or frame.f_globals is not mod_globals:
         raise ImportCaptureError("Can't find importing frame")
 
+    kwargs.setdefault('package', mod_globals.get('__package__'))
+
     if _capture is not None:
         return _FrameBuiltinsImportCaptureHook(_frame=frame, **kwargs)
 
@@ -588,21 +650,110 @@ def _new_import_capture_hook(
 ##
 
 
+ImportCaptureModuleKind: ta.TypeAlias = ta.Literal[
+    'parent',
+    'terminal',
+    'leaf',
+]
+
+
 class ImportCapture:
-    class Import(ta.NamedTuple):
-        spec: str
-        attrs: ta.Sequence[tuple[str | None, str]]
+    @ta.final
+    class Module:
+        def __init__(
+                self,
+                name: str,
+                children: ta.Mapping[str, 'ImportCapture.Module'] | None = None,
+                attrs: ta.Sequence[str] | None = None,
+        ) -> None:
+            self.name = name
+            self.children = children
+            self.attrs = attrs
+
+            self.base_name = name.rpartition('.')[2]
+
+            if not self.children and not self.attrs:
+                self.kind = 'leaf'
+            elif not self.children or all(c.kind == 'leaf' for c in self.children.values()):
+                self.kind = 'terminal'
+            else:
+                self.kind = 'parent'
+
+        parent: ta.Optional['ImportCapture.Module']
+
+        kind: ImportCaptureModuleKind
+
+        def __repr__(self) -> str:
+            return ''.join([
+                f'{self.__class__.__name__}(',
+                f'{self.name!r}',
+                f', :{self.kind}',
+                *([f', children=[{", ".join(map(repr, self.children))}]'] if self.children else []),
+                *([f', attrs={self.attrs!r}'] if self.attrs else []),
+                ')',
+            ])
+
+        @property
+        def root(self) -> 'ImportCapture.Module':
+            out = self
+            while out.parent is not None:
+                out = out.parent
+            return out
+
+    @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
+        ) -> None:
+            self.module = module
+            self.as_ = as_
+            self.attrs = attrs
+
+        def __repr__(self) -> str:
+            return ''.join([
+                f'{self.__class__.__name__}(',
+                f'{self.module.name!r}',
+                *([f', as_={self.as_!r}'] if self.as_ else []),
+                *([f', attrs={self.attrs!r}'] if self.attrs else []),
+                ')',
+            ])
+
+    @ta.final
+    class Captured:
+        def __init__(
+                self,
 
-    class Captured(ta.NamedTuple):
-        imports: ta.Sequence['ImportCapture.Import']
-        unreferenced: ta.Mapping[str, ta.Sequence[str | None]] | None
+                imports: ta.Mapping[str, 'ImportCapture.Import'],
+
+                modules: ta.Mapping[str, 'ImportCapture.Module'],
+                root_modules: ta.Mapping[str, 'ImportCapture.Module'],
+
+                unreferenced: ta.Sequence[str] | None,
+        ) -> None:
+            self.imports = imports
+
+            self.modules = modules
+            self.root_modules = root_modules
+
+            self.unreferenced = unreferenced
 
         @property
         def attrs(self) -> ta.Iterator[str]:
-            for pi in self.imports:
+            for pi in self.imports.values():
+                yield from pi.as_
                 for _, a in pi.attrs:
                     yield a
 
+    EMPTY_CAPTURED: ta.ClassVar[Captured] = Captured(
+        {},
+        {},
+        {},
+        None,
+    )
+
     #
 
     def __init__(
@@ -651,7 +802,7 @@ class ImportCapture:
     def capture(
             self,
             *,
-            unreferenced_callback: ta.Callable[[ta.Mapping[str, ta.Sequence[str | None]]], None] | None = None,
+            unreferenced_callback: ta.Callable[[ta.Sequence[str]], None] | None = None,
             raise_unreferenced: bool = False,
     ) -> ta.Iterator[ta.Self]:
         if self._result_ is not None:
@@ -659,10 +810,7 @@ class ImportCapture:
 
         if self._disabled:
             self._result_ = ImportCapture._Result(
-                ImportCapture.Captured(
-                    [],
-                    None,
-                ),
+                ImportCapture.EMPTY_CAPTURED,
             )
             yield self
             return
@@ -683,9 +831,8 @@ class ImportCapture:
             if raise_unreferenced:
                 raise ImportCaptureErrors.UnreferencedImportsError(blt.unreferenced)
 
-        for pi in blt.imports:
-            for _, a in pi.attrs:
-                del self._mod_globals[a]
+        for a in blt.attrs:
+            del self._mod_globals[a]
 
         self._result_ = ImportCapture._Result(
             blt,

omlish/lang/imports/proxy.py

@@ -1,7 +1,3 @@
-"""
-TODO:
- - if already imported just return?
-"""
 import contextlib
 import functools
 import importlib.util
@@ -16,6 +12,47 @@ from .capture import _new_import_capture_hook
 ##
 
 
+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
+
+            for a in ci.as_:
+                dct.setdefault(p.name, []).append(
+                    (ci.module.base_name, a),
+                )
+
+        elif ci.module.kind == 'terminal':
+            if ci.module.children:
+                raise NotImplementedError
+
+            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),
+                )
+
+        else:
+            raise NotImplementedError
+
+    return dct
+
+
+##
+
+
 def proxy_import(
         spec: str,
         package: str | None = None,
@@ -48,7 +85,7 @@ def auto_proxy_import(
         *,
         disable: bool = False,
 
-        unreferenced_callback: ta.Callable[[ta.Mapping[str, ta.Sequence[str | None]]], None] | None = None,
+        unreferenced_callback: ta.Callable[[ta.Sequence[str]], None] | None = None,
         raise_unreferenced: bool = False,
 
         _stack_offset: int = 0,
@@ -70,10 +107,9 @@ def auto_proxy_import(
         ):
             yield inst
 
-        pkg = mod_globals.get('__package__')
-        for pi in inst.captured.imports:
-            for sa, ma in pi.attrs:
-                mod_globals[ma] = proxy_import(pi.spec + (('.' + sa) if sa is not None else ''), pkg)
+        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 ''))
 
     return inner()
 
@@ -87,7 +123,7 @@ class _ProxyInit:
         package: str
 
     class _Import(ta.NamedTuple):
-        spec: str
+        name: str
         attr: str | None
 
     def __init__(
@@ -101,7 +137,6 @@ class _ProxyInit:
         self._name_package = name_package
 
         self._imps_by_attr: dict[str, _ProxyInit._Import] = {}
-        self._mods_by_spec: dict[str, ta.Any] = {}
 
     @property
     def name_package(self) -> NamePackage:
@@ -109,21 +144,18 @@ class _ProxyInit:
 
     def add(
             self,
-            package: str,
+            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(package, None)
+                self._imps_by_attr[as_attr] = self._Import(name, None)
                 self._lazy_globals.set_fn(as_attr, functools.partial(self.get, as_attr))
 
             else:
-                self._imps_by_attr[as_attr] = self._Import(package, imp_attr)
+                self._imps_by_attr[as_attr] = self._Import(name, imp_attr)
                 self._lazy_globals.set_fn(as_attr, functools.partial(self.get, as_attr))
 
-    def _import_module(self, name: str) -> ta.Any:
-        return importlib.import_module(name, package=self._name_package.package)
-
     def get(self, attr: str) -> ta.Any:
         try:
             imp = self._imps_by_attr[attr]
@@ -133,14 +165,19 @@ class _ProxyInit:
         val: ta.Any
 
         if imp.attr is None:
-            val = self._import_module(imp.spec)
+            val = importlib.import_module(imp.name)
+
+        elif imp.name == self._name_package.name:
+            val = importlib.import_module(f'{imp.name}.{imp.attr}')
 
         else:
-            try:
-                mod = self._mods_by_spec[imp.spec]
-            except KeyError:
-                mod = self._import_module(imp.spec)
-                self._mods_by_spec[imp.spec] = mod
+            mod = __import__(
+                imp.name,
+                self._lazy_globals._globals,  # noqa
+                {},
+                [imp.attr],
+                0,
+            )
 
             val = getattr(mod, imp.attr)
 
@@ -152,6 +189,13 @@ def proxy_init(
         spec: str,
         attrs: ta.Iterable[str | tuple[str | None, str | None] | None] | None = None,
 ) -> None:
+    name = importlib.util.resolve_name(
+        spec,
+        package=init_globals['__package__'] if spec.startswith('.') else None,
+    )
+
+    #
+
     if isinstance(attrs, str):
         raise TypeError(attrs)
 
@@ -201,7 +245,7 @@ def proxy_init(
         if pi.name_package != init_name_package:
             raise Exception(f'Wrong init name: {pi.name_package=} != {init_name_package=}')
 
-    pi.add(spec, al)
+    pi.add(name, al)
 
 
 #
@@ -213,7 +257,7 @@ def auto_proxy_init(
         disable: bool = False,
         eager: bool = False,
 
-        unreferenced_callback: ta.Callable[[ta.Mapping[str, ta.Sequence[str | None]]], None] | None = None,
+        unreferenced_callback: ta.Callable[[ta.Sequence[str]], None] | None = None,
         raise_unreferenced: bool = False,
 
         update_exports: bool = False,
@@ -237,11 +281,11 @@ def auto_proxy_init(
         ):
             yield inst
 
-        for pi in inst.captured.imports:
+        for spec, attrs in _translate_old_style_import_capture(inst.captured).items():
             proxy_init(
                 init_globals,
-                pi.spec,
-                pi.attrs,
+                spec,
+                attrs,
             )
 
         if eager:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev458
+Version: 0.0.0.dev459
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -34,7 +34,7 @@ Requires-Dist: cbor2~=5.7; extra == "all"
 Requires-Dist: cloudpickle~=3.1; extra == "all"
 Requires-Dist: httpx[http2]~=0.28; extra == "all"
 Requires-Dist: wrapt~=1.17; extra == "all"
-Requires-Dist: cryptography~=45.0; extra == "all"
+Requires-Dist: cryptography~=46.0; extra == "all"
 Requires-Dist: sqlalchemy[asyncio]~=2.0; extra == "all"
 Requires-Dist: pg8000~=1.31; extra == "all"
 Requires-Dist: pymysql~=1.1; extra == "all"
@@ -80,7 +80,7 @@ Requires-Dist: httpx[http2]~=0.28; extra == "http"
 Provides-Extra: misc
 Requires-Dist: wrapt~=1.17; extra == "misc"
 Provides-Extra: secrets
-Requires-Dist: cryptography~=45.0; extra == "secrets"
+Requires-Dist: cryptography~=46.0; extra == "secrets"
 Provides-Extra: sqlalchemy
 Requires-Dist: sqlalchemy[asyncio]~=2.0; extra == "sqlalchemy"
 Provides-Extra: sqldrivers

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

@@ -1,5 +1,5 @@
 omlish/.omlish-manifests.json,sha256=FLw7xkPiSXuImZgqSP8BwrEib2R1doSzUPLUkc-QUIA,8410
-omlish/__about__.py,sha256=JFsg8-NJ-oUZhhnc3zS3hNbni2_vxB5zayG1vEx5f2c,3613
+omlish/__about__.py,sha256=xtL6Mzn2wu2_IspeSZ_MxiJmXyGvptjs7xRjcNyq79E,3613
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ZNIMl1kwg3qdei4DiUrJPQe5M81S1e76N-GuNSwLBAE,8683
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -205,7 +205,7 @@ omlish/diag/procfs.py,sha256=eeB3L9UpNBpAfsax3U6OczayYboPlFzOGplqlQ4gBNY,9700
 omlish/diag/procstats.py,sha256=EJEe2Zc58ykBoTfqMXro7H52aQa_pd6uC2hsIPFceso,825
 omlish/diag/ps.py,sha256=MEpMU6fbkh0bSWrOHh_okOa0JDTUSUQUVSYBdh1TGvE,1672
 omlish/diag/pycharm.py,sha256=_WVmPm1E66cBtR4ukgUAaApe_3rX9Cv3sQRP5PL37P8,5013
-omlish/diag/pydevd.py,sha256=QfpOrVAHV7-PT3X8kLquXM7gpC-41oxIM4NtKhTdywE,7700
+omlish/diag/pydevd.py,sha256=JEHC0hiSJxL-vVtuxKUi1BNkgUKnRC1N4alDg6JP5WQ,8363
 omlish/diag/threads.py,sha256=sjtlTl41wxssoVCDkBB6xeLF-9kJEK3eA6hmSFWJSQA,3643
 omlish/diag/timers.py,sha256=cxX3GgjTIjBx9DI4pzCCO5Hfqb1TM3uo22yim7kjfRU,3831
 omlish/diag/_pycharm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -451,11 +451,11 @@ omlish/lang/classes/restrict.py,sha256=xHLIK20MQ_jJPQ7JVzMNhyN4Xc4eLBgrcxqDnTbeK
 omlish/lang/classes/simple.py,sha256=3AJSs-plVg2flq4SC6I39LxP0nBaB241puv3D5YCP5I,2973
 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=jAKW9pOV3ER4Vzd-aywmAeOxbv-b_jNdaxAaVdxfueg,2261
-omlish/lang/imports/capture.py,sha256=wjWuXDUYYHUZ78t_OxVzi27PshBOlhpSoglg7H67zXA,21890
+omlish/lang/imports/_capture.cc,sha256=cp-L5yFGjftfBa12sKNz0Q5Yhh54a88DH7VEN1oa5hU,2313
+omlish/lang/imports/capture.py,sha256=z91F2CVcBDX4trhd2oRB5YL_d_Nu9KBTjzhy98N9YDQ,26170
 omlish/lang/imports/conditional.py,sha256=R-E47QD95mMonPImWlrde3rnJrFKCCkYz71c94W05sc,1006
 omlish/lang/imports/lazy.py,sha256=Eefs9hkj5surMdwgxX_Q3BOqPcox10v0sKT5rKIQknc,808
-omlish/lang/imports/proxy.py,sha256=wlXJrl1GiXQ-t5cO_aJLqp1mr_Erl4oMk4uySkkK7bg,6516
+omlish/lang/imports/proxy.py,sha256=tIIChKvl5TCZp_vg6D7WR7NxnN0J-L-bqjp0DYvgUuA,7562
 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
@@ -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.dev458.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev458.dist-info/METADATA,sha256=1ECWQXj_iU52Kb0BHM0TatXwVbcHx5q-eFY8mHzDYbU,19003
-omlish-0.0.0.dev458.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev458.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev458.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev458.dist-info/RECORD,,
+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,,