fixup! Add news entry

pablogsal · pablogsal · commit 0b2982430d51 · 2026-05-05T02:10:53.000+01:00
diff --git a/Lib/_pyrepl/_module_completer.py b/Lib/_pyrepl/_module_completer.py
@@ -72,32 +72,43 @@ def __init__(self, namespace: Mapping[str, Any] | None = None) -> None:
         self._curr_sys_path: list[str] = sys.path[:]
         self._stdlib_path = os.path.dirname(importlib.__path__[0])
 
-    def get_completions(self, line: str) -> tuple[list[str], list[Any], CompletionAction | None] | None:
+    def get_completions(
+        self, line: str, *, include_values: bool = True
+    ) -> tuple[list[str], list[Any], CompletionAction | None] | None:
         """Return the next possible import completions for 'line'.
 
         For attributes completion, if the module to complete from is not
         imported, also return an action (prompt + callback to run if the
         user press TAB again) to import the module.
+
+        If *include_values* is false, the returned values list is empty and
+        attribute values are not resolved.
         """
         result = ImportParser(line).parse()
         if not result:
             return None
         try:
-            return self.complete(*result)
+            return self.complete(*result, include_values=include_values)
         except Exception:
             # Some unexpected error occurred, make it look like
             # no completions are available
             return [], [], None
 
-    def complete(self, from_name: str | None, name: str | None) -> tuple[list[str], list[Any], CompletionAction | None]:
+    def complete(
+        self,
+        from_name: str | None,
+        name: str | None,
+        *,
+        include_values: bool = True,
+    ) -> tuple[list[str], list[Any], CompletionAction | None]:
         if from_name is None:
             # import x.y.z<tab>
             assert name is not None
             path, prefix = self.get_path_and_prefix(name)
             modules = self.find_modules(path, prefix)
             names = [self.format_completion(path, module) for module in modules]
             # These are always modules, use dummy values to get the right color
-            values = [sys] * len(names)
+            values = [sys] * len(names) if include_values else []
             return names, values, None
 
         if name is None:
@@ -106,18 +117,22 @@ def complete(self, from_name: str | None, name: str | None) -> tuple[list[str],
             modules = self.find_modules(path, prefix)
             names = [self.format_completion(path, module) for module in modules]
             # These are always modules, use dummy values to get the right color
-            values = [sys] * len(names)
+            values = [sys] * len(names) if include_values else []
             return names, values, None
 
         # from x.y import z<tab>
         submodules = self.find_modules(from_name, name)
-        attr_names, attr_values, action = self.find_attributes(from_name, name)
+        attr_names, attr_module, action = self._find_attributes(from_name, name)
         all_names = sorted({*submodules, *attr_names})
+        if not include_values:
+            return all_names, [], action
+
         # Build values list matching the sorted order:
         # submodules use `sys` as a dummy value so they get the 'module' color,
         # attributes use their actual value.
-        submodule_set = set(submodules)
-        attr_map = dict(zip(attr_names, attr_values))
+        attr_map = {}
+        if attr_module is not None:
+            attr_map = {n: safe_getattr(attr_module, n) for n in attr_names}
         all_values = [attr_map[n] if n in attr_map else sys for n in all_names]
         return all_names, all_values, action
 
@@ -180,43 +195,43 @@ def _is_stdlib_module(self, module_info: pkgutil.ModuleInfo) -> bool:
         return (isinstance(module_info.module_finder, FileFinder)
                 and module_info.module_finder.path == self._stdlib_path)
 
-    def find_attributes(self, path: str, prefix: str) -> tuple[list[str], list[Any], CompletionAction | None]:
+    def find_attributes(
+        self, path: str, prefix: str
+    ) -> tuple[list[str], list[Any], CompletionAction | None]:
         """Find all attributes of module 'path' that start with 'prefix'."""
-        attributes, values, action = self._find_attributes(path, prefix)
-        # Filter out invalid attribute names
-        # (for example those containing dashes that cannot be imported with 'import')
-        filtered_names = []
-        filtered_values = []
-        for attr, val in zip(attributes, values):
-            if attr.isidentifier():
-                filtered_names.append(attr)
-                filtered_values.append(val)
-        return filtered_names, filtered_values, action
-
-    def _find_attributes(self, path: str, prefix: str) -> tuple[list[str], list[Any], CompletionAction | None]:
+        attributes, module, action = self._find_attributes(path, prefix)
+        if module is not None:
+            values = [safe_getattr(module, attr) for attr in attributes]
+        else:
+            values = []
+        return attributes, values, action
+
+    def _find_attributes(
+        self, path: str, prefix: str
+    ) -> tuple[list[str], ModuleType | None, CompletionAction | None]:
         path = self._resolve_relative_path(path)  # type: ignore[assignment]
         if path is None:
-            return [], [], None
+            return [], None, None
 
         imported_module = sys.modules.get(path)
         if not imported_module:
             if path in self._failed_imports:  # Do not propose to import again
-                return [], [], None
+                return [], None, None
             imported_module = self._maybe_import_module(path)
         if not imported_module:
-            return [], [], self._get_import_completion_action(path)
+            return [], None, self._get_import_completion_action(path)
         try:
             module_attributes = dir(imported_module)
         except Exception:
             module_attributes = []
-        names = []
-        values = []
-        for attr_name in module_attributes:
-            if not self.is_suggestion_match(attr_name, prefix):
-                continue
-            names.append(attr_name)
-            values.append(safe_getattr(imported_module, attr_name))
-        return names, values, None
+        # Filter out invalid attribute names, such as dashes that cannot be
+        # imported with 'import'.
+        names = [
+            attr_name for attr_name in module_attributes
+            if (self.is_suggestion_match(attr_name, prefix)
+                and attr_name.isidentifier())
+        ]
+        return names, imported_module, None
 
     def is_suggestion_match(self, module_name: str, prefix: str) -> bool:
         if prefix:
diff --git a/Lib/_pyrepl/fancycompleter.py b/Lib/_pyrepl/fancycompleter.py
@@ -3,6 +3,8 @@
 #
 #                        All Rights Reserved
 """Colorful tab completion for Python prompt"""
+from __future__ import annotations
+
 from _colorize import ANSIColors, get_colors, get_theme
 import rlcompleter
 import keyword
diff --git a/Lib/_pyrepl/readline.py b/Lib/_pyrepl/readline.py
@@ -171,12 +171,15 @@ def get_completions(self, stem: str) -> tuple[list[str], CompletionAction | None
 
     def get_module_completions(self) -> tuple[list[str], CompletionAction | None] | None:
         line = stripcolor(self.get_line())
-        result = self.config.module_completer.get_completions(line)
+        colorize_completions = self.config.colorize_completions
+        result = self.config.module_completer.get_completions(
+            line, include_values=bool(colorize_completions)
+        )
         if result is None:
             return None
         names, values, action = result
-        if self.config.colorize_completions:
-            names = self.config.colorize_completions(names, values)
+        if colorize_completions:
+            names = colorize_completions(names, values)
         return names, action
 
     def get_trimmed_history(self, maxlength: int) -> list[str]:
diff --git a/Lib/test/test_pyrepl/test_fancycompleter.py b/Lib/test/test_pyrepl/test_fancycompleter.py
@@ -1,11 +1,17 @@
 import importlib
+import inspect
 import os
 import types
 import unittest
 
 from _colorize import ANSIColors, get_theme
 from _pyrepl.completing_reader import stripcolor
-from _pyrepl.fancycompleter import Completer, commonprefix, _color_for_obj
+from _pyrepl.fancycompleter import (
+    Completer,
+    colorize_matches,
+    commonprefix,
+    _color_for_obj,
+)
 from test.support.import_helper import ready_to_import
 
 class MockPatch:
@@ -36,6 +42,11 @@ def test_commonprefix(self):
         self.assertEqual(commonprefix(['isalpha', 'isdigit']), 'is')
         self.assertEqual(commonprefix([]), '')
 
+    def test_colorize_matches_signature(self):
+        signature = inspect.signature(colorize_matches)
+
+        self.assertEqual(list(signature.parameters), ["names", "values", "theme"])
+
     def test_complete_attribute(self):
         compl = Completer({'a': None}, use_colors=False)
         self.assertEqual(compl.attr_matches('a.'), ['a.__'])

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,8 @@`
`3`	`3`	`#`
`4`	`4`	`# All Rights Reserved`
`5`	`5`	`"""Colorful tab completion for Python prompt"""`
	`6`	`+from __future__ import annotations`
	`7`	`+`
`6`	`8`	`from _colorize import ANSIColors, get_colors, get_theme`
`7`	`9`	`import rlcompleter`
`8`	`10`	`import keyword`