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

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,138 @@ 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
 
-        def __repr__(self) -> str:
-            return f'<{self.__class__.__name__}: {f"{self.__module.spec}:{self.__name}"!r}>'
+            self.name = name
+            self.parent = parent
 
-    class _Module:
-        def __init__(
-                self,
-                spec: '_ImportCaptureHook.ModuleSpec',
-                *,
-                getattr_handler: ta.Callable[['_ImportCaptureHook._Module', str], ta.Any] | None = None,
-        ) -> None:
-            super().__init__()
+            self.base_name = name.rpartition('.')[2]
+            self.root: _ImportCaptureHook._Module = parent.root if parent is not None else self  # noqa
 
-            self.spec = spec
+            self.children: dict[str, _ImportCaptureHook._Module] = {}
+            self.descendants: set[_ImportCaptureHook._Module] = set()
 
-            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.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.contents: dict[str, _ImportCaptureHook._ModuleAttr | types.ModuleType] = {}
-            self.imported_whole = False
+            self.explicit = False
+            self.immediate = False
 
         def __repr__(self) -> str:
-            return f'{self.__class__.__name__}({self.spec!r})'
+            return f'{self.__class__.__name__}<{self.name}{"!" if self.immediate else "+" if self.explicit else ""}>'
 
-    def _get_or_make_module(self, spec: ModuleSpec) -> _Module:
+        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
+
+    #
+
+    @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:
         try:
-            return self._modules_by_spec[spec]
+            return self._modules_by_name[name]
         except KeyError:
             pass
 
-        module = self._Module(
-            spec,
-            getattr_handler=self._handle_module_getattr,
+        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)
+
+        module = _ImportCaptureHook._Module(
+            name,
+            self._handle_module_getattr,
+            parent=parent,
         )
-        self._modules_by_spec[spec] = module
+        self._modules_by_name[name] = module
         self._modules_by_module_obj[module.module_obj] = 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 module
 
-    def _handle_module_getattr(self, module: _Module, attr: str) -> ta.Any:
-        if attr in module.contents:
-            raise ImportCaptureErrors.AttrError(str(module.spec), attr)
+    def _make_child_module(self, module: _Module, attr: str) -> _Module:
+        if attr in module.children:
+            raise ImportCaptureErrors.AttrError(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
+        return self._get_or_make_module(f'{module.name}.{attr}')
 
-        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 +243,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 +287,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 +314,20 @@ 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
+                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`
+            )
 
-        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 +335,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] or None,
+                [(l, r) for l, r in ts if l is not None] or 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,
         )
 
@@ -360,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,
@@ -379,8 +444,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(
@@ -515,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):
@@ -539,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(
@@ -569,39 +648,155 @@ 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)
 
 
 ##
 
 
+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 []),
+                ')',
+            ])
+
+        _root: 'ImportCapture.Module'
+
+        @property
+        def root(self) -> 'ImportCapture.Module':
+            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] | 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_
+            self.attrs = attrs
 
-    class Captured(ta.NamedTuple):
-        imports: ta.Sequence['ImportCapture.Import']
-        unreferenced: ta.Mapping[str, ta.Sequence[str | None]] | None
+        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,
+
+                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 _, a in pi.attrs:
-                    yield a
+            for pi in self.imports.values():
+                if pi.as_:
+                    yield from pi.as_
+                if pi.attrs:
+                    for _, a in pi.attrs:
+                        yield a
+
+    EMPTY_CAPTURED: ta.ClassVar[Captured] = Captured(
+        {},
+        {},
+        {},
+        None,
+    )
 
     #
 
@@ -651,7 +846,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 +854,7 @@ class ImportCapture:
 
         if self._disabled:
             self._result_ = ImportCapture._Result(
-                ImportCapture.Captured(
-                    [],
-                    None,
-                ),
+                ImportCapture.EMPTY_CAPTURED,
             )
             yield self
             return
@@ -683,9 +875,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,