feat(parser): expand Python from X import * in import_map

Add three helpers:

- `_resolve_star_imports`: walks top-level `import_from_statement`
  nodes, detects `wildcard_import`, resolves the source module to a
  file, and merges the exported names into the caller's import_map.
- `_get_exported_names`: returns the public names a module exports,
  respecting `__all__` when present. Caches results per resolved path
  with a threading lock so concurrent parses share work safely.
- `_extract_dunder_all`: parses `__all__ = [...]` at module scope.

Wires star-import expansion into `parse_bytes` and the notebook
concat path. Enables resolution of calls that come in via wildcard
imports (e.g. `from constants import *` then `use_constant()`).

Author: gzenz

code_review_graph/parser.py

@@ -10,6 +10,7 @@
 import json
 import logging
 import re
+import threading
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import NamedTuple, Optional
@@ -625,9 +626,11 @@ def __init__(self) -> None:
         self._parsers: dict[str, object] = {}
         self._module_file_cache: dict[str, Optional[str]] = {}
         self._export_symbol_cache: dict[str, Optional[str]] = {}
+        self._star_export_cache: dict[str, set[str]] = {}
         self._tsconfig_resolver = TsconfigResolver()
         # Per-parse cache of Dart pubspec root lookups; see #87
         self._dart_pubspec_cache: dict[tuple[str, str], Optional[Path]] = {}
+        self._lock = threading.Lock()
 
     def _get_parser(self, language: str):  # type: ignore[arg-type]
         if language not in self._parsers:
@@ -708,6 +711,12 @@ def parse_bytes(self, path: Path, source: bytes) -> tuple[list[NodeInfo], list[E
             tree.root_node, language, source,
         )
 
+        # Expand Python `from X import *` into individual import_map entries.
+        if language == "python":
+            self._resolve_star_imports(
+                tree.root_node, file_path_str, language, import_map,
+            )
+
         # Walk the tree
         self._extract_from_tree(
             tree.root_node, source, language, file_path_str, nodes, edges,
@@ -1139,6 +1148,10 @@ def _parse_notebook_cells(
             import_map, defined_names = self._collect_file_scope(
                 tree.root_node, lang, concat_bytes,
             )
+            if lang == "python":
+                self._resolve_star_imports(
+                    tree.root_node, file_path_str, lang, import_map,
+                )
             self._extract_from_tree(
                 tree.root_node, concat_bytes, lang,
                 file_path_str, all_nodes, all_edges,
@@ -3494,6 +3507,99 @@ def _extract_solidity_constructs(
 
         return False
 
+    def _resolve_star_imports(
+        self,
+        root,
+        file_path: str,
+        language: str,
+        import_map: dict[str, str],
+        _resolving: Optional[frozenset[str]] = None,
+    ) -> None:
+        """Expand ``from X import *`` into individual import_map entries."""
+        if _resolving is None:
+            _resolving = frozenset()
+        for child in root.children:
+            if child.type != "import_from_statement":
+                continue
+            has_wildcard = False
+            module = None
+            for sub in child.children:
+                if sub.type == "wildcard_import":
+                    has_wildcard = True
+                elif sub.type == "dotted_name" and module is None:
+                    module = sub.text.decode("utf-8", errors="replace")
+            if not has_wildcard or not module:
+                continue
+            resolved = self._resolve_module_to_file(
+                module, file_path, language,
+            )
+            if not resolved or resolved in _resolving:
+                continue
+            exported = self._get_exported_names(
+                resolved, language, _resolving | {resolved},
+            )
+            for name in exported:
+                if name not in import_map:
+                    import_map[name] = module
+
+    def _get_exported_names(
+        self,
+        resolved_path: str,
+        language: str,
+        _resolving: frozenset[str] = frozenset(),
+    ) -> set[str]:
+        """Return the public names exported by a module file.
+
+        Double-check locking: check cache, do I/O outside lock, store under lock.
+        """
+        if resolved_path in self._star_export_cache:
+            return self._star_export_cache[resolved_path]
+        try:
+            source = Path(resolved_path).read_bytes()
+        except (OSError, PermissionError):
+            return set()
+        parser = self._get_parser(language)
+        if not parser:
+            return set()
+        tree = parser.parse(source)  # type: ignore[union-attr]
+        all_names = self._extract_dunder_all(tree.root_node)
+        if all_names is not None:
+            with self._lock:
+                self._star_export_cache[resolved_path] = all_names
+            return all_names
+        _, defined_names = self._collect_file_scope(
+            tree.root_node, language, source,
+        )
+        result = {n for n in defined_names if not n.startswith("_")}
+        with self._lock:
+            self._star_export_cache[resolved_path] = result
+        return result
+
+    @staticmethod
+    def _extract_dunder_all(root) -> Optional[set[str]]:
+        """Extract names from ``__all__ = [...]``. Returns None if absent."""
+        for child in root.children:
+            if child.type != "assignment":
+                continue
+            left = child.children[0] if child.children else None
+            if not left or left.type != "identifier" or left.text != b"__all__":
+                continue
+            for rhs in child.children:
+                if rhs.type == "list":
+                    names: set[str] = set()
+                    for elem in rhs.children:
+                        if elem.type == "string":
+                            for sc in elem.children:
+                                if sc.type == "string_content":
+                                    val = sc.text.decode(
+                                        "utf-8", errors="replace",
+                                    )
+                                    if val:
+                                        names.add(val)
+                    return names
+            return set()
+        return None
+
     def _collect_file_scope(
         self, root, language: str, source: bytes,
     ) -> tuple[dict[str, str], set[str]]: