Fix pyrepl import completion edge cases

Tighten the pyrepl completer around a few import-completion edge cases.
Relative imports now share one resolver, find_spec failures no longer
bubble out, failed-import tracking resets when sys.path changes, and
double-tab import actions are cleared once consumed.

The patch also keeps empty message lines intact in reader output and
updates the targeted tests and comments to match the intended behavior.

Author: pablogsal

Lib/_pyrepl/_module_completer.py

@@ -122,23 +122,25 @@ def _find_modules(self, path: str, prefix: str) -> list[str]:
                                    if self.is_suggestion_match(module.name, prefix)]
             return sorted(builtin_modules + third_party_modules)
 
-        if path.startswith('.'):
-            # Convert relative path to absolute path
-            package = self.namespace.get('__package__', '')
-            path = self.resolve_relative_name(path, package)  # type: ignore[assignment]
-            if path is None:
-                return []
+        path = self._resolve_relative_path(path)  # type: ignore[assignment]
+        if path is None:
+            return []
 
         modules: Iterable[pkgutil.ModuleInfo] = self.global_cache
         imported_module = sys.modules.get(path.split('.')[0])
         if imported_module:
-            # Filter modules to those who name and specs match the
+            # Filter modules to those whose name and specs match the
             # imported module to avoid invalid suggestions
             spec = imported_module.__spec__
             if spec:
+                def _safe_find_spec(mod: pkgutil.ModuleInfo) -> bool:
+                    try:
+                        return mod.module_finder.find_spec(mod.name, None) == spec
+                    except Exception:
+                        return False
                 modules = [mod for mod in modules
                            if mod.name == spec.name
-                           and mod.module_finder.find_spec(mod.name, None) == spec]
+                           and _safe_find_spec(mod)]
             else:
                 modules = []
 
@@ -171,12 +173,9 @@ def find_attributes(self, path: str, prefix: str) -> tuple[list[str], Completion
         return [attr for attr in attributes if attr.isidentifier()], action
 
     def _find_attributes(self, path: str, prefix: str) -> tuple[list[str], CompletionAction | None]:
-        if path.startswith('.'):
-            # Convert relative path to absolute path
-            package = self.namespace.get('__package__', '')
-            path = self.resolve_relative_name(path, package)  # type: ignore[assignment]
-            if path is None:
-                return [], None
+        path = self._resolve_relative_path(path)  # type: ignore[assignment]
+        if path is None:
+            return [], None
 
         imported_module = sys.modules.get(path)
         if not imported_module:
@@ -236,6 +235,13 @@ def format_completion(self, path: str, module: str) -> str:
             return f'{path}{module}'
         return f'{path}.{module}'
 
+    def _resolve_relative_path(self, path: str) -> str | None:
+        """Resolve a relative import path to absolute. Returns None if unresolvable."""
+        if path.startswith('.'):
+            package = self.namespace.get('__package__', '')
+            return self.resolve_relative_name(path, package)
+        return path
+
     def resolve_relative_name(self, name: str, package: str) -> str | None:
         """Resolve a relative module name to an absolute name.
 
@@ -260,6 +266,7 @@ def global_cache(self) -> list[pkgutil.ModuleInfo]:
         if not self._global_cache or self._curr_sys_path != sys.path:
             self._curr_sys_path = sys.path[:]
             self._global_cache = list(pkgutil.iter_modules())
+            self._failed_imports.clear()  # retry on sys.path change
         return self._global_cache
 
     def _maybe_import_module(self, fqname: str) -> ModuleType | None:

Lib/_pyrepl/completing_reader.py

@@ -172,6 +172,7 @@ def do(self) -> None:
         if r.cmpltn_action:
             if last_is_completer:  # double-tab: execute action
                 msg = r.cmpltn_action[1]()
+                r.cmpltn_action = None  # consumed
                 if msg:
                     r.msg = msg
             else:  # other input since last tab: cancel action

Lib/_pyrepl/reader.py

@@ -383,10 +383,14 @@ def calc_screen(self) -> list[str]:
         if self.msg:
             width = self.console.width
             for mline in self.msg.split("\n"):
-                # If self.msg is larger that console width, make it fit
+                # If self.msg is larger than console width, make it fit
                 # TODO: try to split between words?
+                if not mline:
+                    screen.append("")
+                    screeninfo.append((0, []))
+                    continue
                 for r in range((len(mline) - 1) // width + 1):
-                    screen.append(mline[r * width : (r + 1) * width:])
+                    screen.append(mline[r * width : (r + 1) * width])
                     screeninfo.append((0, []))
 
         self.last_refresh_cache.update_cache(self, screen, screeninfo)
@@ -632,7 +636,6 @@ def suspend_colorization(self) -> SimpleContextManager:
         finally:
             self.can_colorize = old_can_colorize
 
-
     def finish(self) -> None:
         """Called when a command signals that we're finished."""
         pass

Lib/test/test_pyrepl/test_pyrepl.py

@@ -1190,8 +1190,8 @@ def test_global_cache(self):
         with (tempfile.TemporaryDirectory() as _dir1,
               patch.object(sys, "path", [_dir1, *sys.path])):
             dir1 = pathlib.Path(_dir1)
-            (dir1 / "mod_aa.py").mkdir()
-            (dir1 / "mod_bb.py").mkdir()
+            (dir1 / "mod_aa.py").touch()
+            (dir1 / "mod_bb.py").touch()
             events = code_to_events("import mod_a\t\nimport mod_b\t\n")
             reader = self.prepare_reader(events, namespace={})
             output_1, output_2 = reader.readline(), reader.readline()
@@ -1559,7 +1559,7 @@ def test_suggestions_and_messages(self) -> None:
         # more unitary tests checking the exact suggestions provided
         # (sorting, de-duplication, import action...)
         _prompt = ("[ module not imported, press again to import it "
-                          "and propose attributes ]")
+                   "and propose attributes ]")
         _error = "[ error during import: division by zero ]"
         with tempfile.TemporaryDirectory() as _dir:
             dir = pathlib.Path(_dir)
@@ -1572,6 +1572,9 @@ def test_suggestions_and_messages(self) -> None:
             sys.modules.pop("string.templatelib", None)
             with patch.object(sys, "path", [_dir, *sys.path]):
                 pkgutil.get_importer(_dir).invalidate_caches()
+                # NOTE: Cases are intentionally sequential and share completer
+                # state. Earlier cases may import modules that later cases
+                # depend on. Do NOT reorder without understanding dependencies.
                 cases = (
                     # no match != not an import
                     ("import nope", ([], None), set()),
@@ -1619,6 +1622,8 @@ def test_suggestions_and_messages(self) -> None:
 # Audit hook used to check for stdlib modules import side-effects
 # Defined globally to avoid adding one hook per test run (refleak)
 _audit_events: set[str] | None = None
+
+
 def _hook(name: str, _args: tuple):
     if _audit_events is not None:  # No-op when not activated
         _audit_events.add(name)