Merge remote-tracking branch 'origin/main' into gh-158195-unpin-type-lock

Author: nascheme

Lib/_pyrepl/_module_completer.py

@@ -83,7 +83,11 @@ def get_completions(
         if not result:
             return None
         try:
-            return self.complete(*result, include_values=include_values)
+            names, values, action = self.complete(
+                *result, include_values=include_values
+            )
+            names = [self._remove_separated_words(line, c) for c in names]
+            return names, values, action
         except Exception:
             # Some unexpected error occurred, make it look like
             # no completions are available
@@ -336,6 +340,26 @@ def _do_import() -> str | None:
 
         return (prompt, _do_import)
 
+    def _remove_separated_words(self, line: str, completion: str) -> str:
+        """Remove completion parts imputed as separate words.
+
+        Needed because the completer insert any completion provided
+        by replacing the stem (eg. word) currently imputed, if any.
+
+        Examples:
+            - 'import foo.', 'foo.bar'    -> 'foo.bar'
+            - 'import foo  .', 'foo.bar'  -> '.bar'
+            - 'from foo import ', 'bar'   -> 'bar'
+            - 'import x.x .x.', 'x.x.x.x' -> '.x.x'
+        """
+        last_word = line.split(" ")[-1]
+        if not last_word:
+            return completion
+        index = completion.rfind(last_word)
+        if index > 0:
+            return completion[index:]
+        return completion
+
 
 class ImportParser:
     """

Lib/bdb.py

@@ -601,6 +601,13 @@ def set_trace(self, frame=None):
 
         If frame is not specified, debugging starts from caller's frame.
         """
+
+        if self.enterframe is not None:
+            # If self.enterframe is not None, it means we are already in
+            # dispatched functions. Tracing is disabled when calling a
+            # trace function, so we just skip this set_trace() call.
+            return
+
         self.stop_trace()
         if frame is None:
             frame = sys._getframe().f_back

Lib/test/test_capi/test_tuple.py

@@ -327,6 +327,10 @@ def test__tuple_resize(self):
         self.assertRaises(MemoryError, resize, a, PY_SSIZE_T_MAX)
         self.assertRaises(SystemError, resize, a, -1)
         self.assertRaises(SystemError, resize, a, PY_SSIZE_T_MIN)
+        a = ([1], [2], [3])
+        self.assertRaises(MemoryError, resize, a, PY_SSIZE_T_MAX)
+        self.assertRaises(SystemError, resize, a, -1)
+        self.assertRaises(SystemError, resize, a, PY_SSIZE_T_MIN)
         # refcount > 1
         a = (1, 2, 3)
         self.assertRaises(SystemError, resize, a, 3, False)

Lib/test/test_interpreters/test_channels.py

@@ -8,7 +8,7 @@
 # Raise SkipTest if subinterpreters not supported.
 _channels = import_helper.import_module('_interpchannels')
 from concurrent import interpreters
-from test.support import channels
+from test.support import channels, force_not_colorized
 from .utils import _run_output, TestBase
 
 
@@ -34,6 +34,39 @@ def test_highlevel_reloaded(self):
             importlib.reload(channels)
             """));
 
+    @force_not_colorized
+    def test_channel_id_types(self):
+        # See https://github.com/python/cpython/issues/143376.
+        code = """\
+        import _interpchannels
+        import re
+        from concurrent import interpreters
+
+        class End:
+            __slots__ = ()
+            def __new__(cls, chan=None):
+                return object.__new__(cls)
+            @property
+            def _id(self):
+                return object()
+
+        class Send(End): pass
+        class Recv(End): pass
+
+        _interpchannels._register_end_types(Send, Recv)
+        chan = _interpchannels._channel_id(_interpchannels.create(), _resolve=True)
+        interp = interpreters.create()
+        try:
+            interp.prepare_main(chan=Send(chan))
+        finally:
+            interp.close()
+        """
+
+        out, err = self.assert_python_failure("-c", code)
+        self.assertEqual(out, '')
+        errmsg = "TypeError: '_id' attribute must be an _interpchannels.ChannelID object, not object"
+        self.assertIn(errmsg, err)
+
 
 class TestChannels(TestBase):
 

Lib/test/test_pdb.py

@@ -4979,6 +4979,18 @@ def foo():
         stdout, _ = self._run_script(script, commands)
         self.assertIn("42", stdout)
 
+    def test_nested_set_trace(self):
+        # Calling breakpoint() in pdb prompt should just be ignored.
+        script = "breakpoint()"
+        commands = """
+            breakpoint()
+            p 40 + 2
+            c
+        """
+        stdout, stderr = self._run_script(script, commands)
+        self.assertIn('42', stdout)
+        self.assertEqual(stderr, '')
+
     def test_readline_not_imported(self):
         """GH-138860
         Directly or indirectly importing readline might deadlock a subprocess

Lib/test/test_pyrepl/test_pyrepl.py

@@ -1238,6 +1238,12 @@ def test_completions(self):
             ("from importlib import res\t\n", "from importlib import resources"),
             ("from importlib.res\t import a\t\n", "from importlib.resources import abc"),
             ("from __phello__ import s\t\n", "from __phello__ import spam"),  # frozen module
+            ("import importlib .res\t\n", "import importlib .resources"),
+            ("import importlib. res\t\n", "import importlib. resources"),
+            ("import importlib . res\t\n", "import importlib . resources"),
+            ("import importlib  .metadata.\t\n", "import importlib  .metadata.diagnose"),
+            ("import importlib .metadata   .\t\n", "import importlib .metadata   .diagnose"),
+            ("from importlib .resources .a\t\n", "from importlib .resources .abc"),
         )
         for code, expected in cases:
             with self.subTest(code=code):
@@ -1629,8 +1635,13 @@ def test_parse(self):
             ('import a.b.c, foo.bar, ', (None, '')),
             ('from foo', ('foo', None)),
             ('from a.', ('a.', None)),
+            ('from a .', ('a.', None)),
+            ('from a   .', ('a.', None)),
+            ('from a .', ('a.', None)),
             ('from a.b', ('a.b', None)),
             ('from a.b.', ('a.b.', None)),
+            ('from a. b.', ('a.b.', None)),
+            ('from a  .  b  .', ('a.b.', None)),
             ('from a.b.c', ('a.b.c', None)),
             ('from foo import ', ('foo', '')),
             ('from foo import a', ('foo', 'a')),

Lib/test/test_traceback.py

@@ -5109,6 +5109,32 @@ def func():
         actual = self.get_suggestion(func)
         self.assertIn("forget to import '_io'", actual)
 
+    def test_name_error_with_bad_getattr(self):
+        class A:
+            def __getattr__(self, x):
+                spam
+
+        actual = self.get_suggestion(A(), "eggs")
+        self.assertIn("name 'spam' is not defined", actual)
+
+    def test_name_error_with_bad_getattribute(self):
+
+        class A:
+            def __getattribute__(self, x):
+                spam
+
+        actual = self.get_suggestion(A(), "eggs")
+        self.assertIn("name 'spam' is not defined", actual)
+
+    def test_name_error_with_bad_property(self):
+        class A:
+            @property
+            def eggs(self):
+                eggs
+
+        actual = self.get_suggestion(A(), "eggs")
+        self.assertIn("name 'eggs' is not defined", actual)
+
 
 
 class PurePythonSuggestionFormattingTests(

Lib/traceback.py

@@ -1954,31 +1954,34 @@ def _compute_suggestion_error(exc_value, tb, wrong_name):
             return None
     else:
         assert isinstance(exc_value, NameError)
-        # find most recent frame
-        if tb is None:
+        try:
+            # find most recent frame
+            if tb is None:
+                return None
+            while tb.tb_next is not None:
+                tb = tb.tb_next
+            frame = tb.tb_frame
+            d = (
+                list(frame.f_locals)
+                + list(frame.f_globals)
+                + list(frame.f_builtins)
+            )
+            d = [x for x in d if isinstance(x, str)]
+            if not_normalized and wrong_name in d:
+                return wrong_name
+
+            # Check first if we are in a method and the instance
+            # has the wrong name as attribute
+            if 'self' in frame.f_locals:
+                self = frame.f_locals['self']
+                try:
+                    has_wrong_name = hasattr(self, wrong_name)
+                except Exception:
+                    has_wrong_name = False
+                if has_wrong_name:
+                    return f"self.{wrong_name}"
+        except Exception:
             return None
-        while tb.tb_next is not None:
-            tb = tb.tb_next
-        frame = tb.tb_frame
-        d = (
-            list(frame.f_locals)
-            + list(frame.f_globals)
-            + list(frame.f_builtins)
-        )
-        d = [x for x in d if isinstance(x, str)]
-        if not_normalized and wrong_name in d:
-            return wrong_name
-
-        # Check first if we are in a method and the instance
-        # has the wrong name as attribute
-        if 'self' in frame.f_locals:
-            self = frame.f_locals['self']
-            try:
-                has_wrong_name = hasattr(self, wrong_name)
-            except Exception:
-                has_wrong_name = False
-            if has_wrong_name:
-                return f"self.{wrong_name}"
 
     if not_normalized and wrong_name in d:
         return wrong_name

Misc/NEWS.d/next/C_API/2026-10-19-21-05-12.gh-issue-159739.Rk3fTq.rst

@@ -0,0 +1,3 @@
+Fix a crash in :c:func:`_PyTuple_Resize` when resizing a non-empty tuple to a
+negative or too large size. It now raises :exc:`SystemError` or
+:exc:`MemoryError` respectively.

Misc/NEWS.d/next/Core_and_Builtins/2026-04-15-21-55-45.gh-issue-69605.NwoP6l.rst

@@ -0,0 +1,2 @@
+Fix :term:`REPL` completions inserted incorrectly when there was spaces in
+import statements.