omlish 0.0.0.dev459__tar.gz → 0.0.0.dev460__tar.gz

{omlish-0.0.0.dev459/omlish.egg-info → omlish-0.0.0.dev460}/PKG-INFO

@@ -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 → omlish-0.0.0.dev460}/omlish/__about__.py

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

{omlish-0.0.0.dev459 → omlish-0.0.0.dev460}/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(
         {},