Sync pre-release CPython 3.15 branch from GitHub (2026-06-17)

Summary:
Imported python/cpython `3.15.0b2+dev` from upstream rev [`8fe5897`](https://www.github.com/python/cpython/commit/8fe5897853b1f5d8b7a1dc9fc2b72c6244a74983) (committed 2026-06-17 18:40:33+00:00).

# Commit Info

- Base: (`3.15.0b2+dev`) - [`ff6e973`](https://www.github.com/python/cpython/commit/ff6e973c3bbe419ff8aef16b05a1c77749c073c2) (commit date: 2026-06-16 16:48:56+00:00)
- Imported: (`3.15.0b2+dev`) - [`8fe5897`](https://www.github.com/python/cpython/commit/8fe5897853b1f5d8b7a1dc9fc2b72c6244a74983) (commit date: 2026-06-17 18:40:33+00:00)

# Noteworthy file changes

- Low-signal files (5 added) (NEWS.d, docs, .github)

Complete list of added/removed files: https://www.internalfb.com/intern/everpaste/?color=0&handle=GIDWfSILYS1aSKoEAAwdGYaOLpt8br0LAAAz

Reviewed By: yoney

Differential Revision: D108979122

fbshipit-source-id: e286d2b26425f315d5e5826febff4575e8e99738

Author: ambv

.github/workflows/reusable-san.yml

@@ -86,12 +86,12 @@ jobs:
       run: >-
         ./python -m test
         ${{ inputs.sanitizer == 'TSan' && '--tsan' || '' }}
-        -j4 -W
+        -j4 -W --timeout=900 --slowest
     - name: Parallel tests
       if: >-
         inputs.sanitizer == 'TSan'
         && fromJSON(inputs.free-threading)
-      run: ./python -m test --tsan-parallel --parallel-threads=4 -j4 -W
+      run: ./python -m test --tsan-parallel --parallel-threads=4 -j4 -W --timeout=600 --slowest
     - name: Display logs
       if: always()
       run: find "${GITHUB_WORKSPACE}" -name 'san_log.*' | xargs head -n 1000

Lib/test/test_dtrace.py

@@ -1,6 +1,7 @@
 import dis
 import os.path
 import re
+import signal
 import subprocess
 import sys
 import sysconfig
@@ -50,6 +51,24 @@ def normalize_trace_output(output):
         )
 
 
+USE_PROCESS_GROUP = (hasattr(os, "setsid") and hasattr(os, "killpg"))
+
+def create_process_group(*args, **kwargs):
+    if USE_PROCESS_GROUP:
+        kwargs['start_new_session'] = True
+    return subprocess.Popen(*args, **kwargs)
+
+def kill_process_group(proc):
+    if USE_PROCESS_GROUP:
+        try:
+            os.killpg(proc.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+    else:
+        proc.kill()
+    proc.communicate()  # Clean up
+
+
 class TraceBackend:
     EXTENSION = None
     COMMAND = None
@@ -205,15 +224,15 @@ def run_case(self, name, optimize_python=None):
         program = self.PROGRAMS[name].format(python=sys.executable)
 
         try:
-            proc = subprocess.Popen(
+            proc = create_process_group(
                 ["bpftrace", "-e", program, "-c", " ".join(subcommand)],
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 universal_newlines=True,
             )
             stdout, stderr = proc.communicate(timeout=60)
         except subprocess.TimeoutExpired:
-            proc.kill()
+            kill_process_group(proc)
             raise AssertionError("bpftrace timed out")
         except (FileNotFoundError, PermissionError) as e:
             raise unittest.SkipTest(f"bpftrace not available: {e}")
@@ -243,16 +262,15 @@ def assert_usable(self):
         # Check if bpftrace is available and can attach to USDT probes
         program = f'usdt:{sys.executable}:python:function__entry {{ printf("probe: success\\n"); exit(); }}'
         try:
-            proc = subprocess.Popen(
+            proc = create_process_group(
                 ["bpftrace", "-e", program, "-c", f"{sys.executable} -c pass"],
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 universal_newlines=True,
             )
             stdout, stderr = proc.communicate(timeout=10)
         except subprocess.TimeoutExpired:
-            proc.kill()
-            proc.communicate()  # Clean up
+            kill_process_group(proc)
             raise unittest.SkipTest("bpftrace timed out during usability check")
         except OSError as e:
             raise unittest.SkipTest(f"bpftrace not available: {e}")

Lib/test/test_lazy_import/__init__.py

@@ -1957,6 +1957,17 @@ def filter(*args):
     def test_set_bad_filter(self):
         self.assertRaises(ValueError, _testcapi.PyImport_SetLazyImportsFilter, 42)
 
+    def test_dunder_lazy_import_without_frame(self):
+        # gh-151510: __lazy_import__() called with no globals and no running
+        # Python frame must raise TypeError instead of crashing.
+        with self.assertRaisesRegex(
+            TypeError,
+            r"__lazy_import__\(\) missing globals when called without a frame",
+        ):
+            _testcapi.lazy_import_without_frame(
+                "test.test_lazy_import.data.basic2"
+            )
+
 
 if __name__ == '__main__':
     unittest.main()

Lib/test/test_profiling/test_sampling_profiler/test_live_collector_ui.py

@@ -825,17 +825,34 @@ def test_get_all_lines_full_display(self):
 class TestLiveModeErrors(unittest.TestCase):
     """Tests running error commands in the live mode fails gracefully."""
 
+    class QuitWhenFinishedDisplay(MockDisplay):
+        def __init__(self, collector):
+            super().__init__()
+            self.collector = collector
+
+        def get_input(self):
+            ch = super().get_input()
+            if ch != -1:
+                return ch
+            # Sampling only stops once the target process has exited, at
+            # which point the collector is marked finished. Quit then so the
+            # run can surface the target's stderr. We must not rely on the
+            # target's pid still being signalable: once it exits it lingers
+            # as a zombie (it is reaped after sample_live returns), so a
+            # liveness check would never observe it gone and would hang.
+            if self.collector.finished:
+                return ord('q')
+            return -1
+
     def mock_curses_wrapper(self, func):
         func(mock.MagicMock())
 
     def mock_init_curses_side_effect(self, n_times, mock_self, stdscr):
-        mock_self.display = MockDisplay()
-        # Allow the loop to run for a bit (approx 0.5s) before quitting
-        # This ensures we don't exit too early while the subprocess is
-        # still failing
+        mock_self.display = self.QuitWhenFinishedDisplay(mock_self)
+        # Feed non-input events so live mode keeps polling while the target
+        # process is still running; once it exits the display quits on its own.
         for _ in range(n_times):
             mock_self.display.simulate_input(-1)
-        mock_self.display.simulate_input(ord('q'))
 
     def test_run_failed_module_live(self):
         """Test that running a existing module that fails exits with clean error."""

Lib/test/test_unittest/test_loader.py

@@ -1,3 +1,4 @@
+import abc
 import functools
 import sys
 import types
@@ -98,6 +99,22 @@ def test_loadTestsFromTestCase__from_FunctionTestCase(self):
         self.assertIsInstance(suite, loader.suiteClass)
         self.assertEqual(list(suite), [])
 
+    # "Do not load any tests from a TestCase-derived class that is an abstract
+    # base class."
+    def test_loadTestsFromTestCase__from_abc_TestCase(self):
+        class FooBase(unittest.TestCase, metaclass=abc.ABCMeta):
+            @abc.abstractmethod
+            def test(self): ...
+        class Foo(FooBase):
+            def test(self): pass
+
+        empty_suite = unittest.TestSuite()
+
+        loader = unittest.TestLoader()
+        suite = loader.loadTestsFromTestCase(Foo)
+        self.assertEqual(loader.loadTestsFromTestCase(FooBase), empty_suite)
+        self.assertEqual(list(suite), [Foo('test')])
+
     ################################################################
     ### /Tests for TestLoader.loadTestsFromTestCase
 
@@ -252,6 +269,24 @@ def load_tests(loader, tests, pattern):
 
         self.assertRaisesRegex(TypeError, "some failure", test.m)
 
+    # Check that loadTestsFromModule skips abstract base classes derived from
+    # TestCase, which can't be instantiated.
+    def test_loadTestsFromModule__skip_abc_TestCase(self):
+        m = types.ModuleType('m')
+        class MyTestCaseBase(unittest.TestCase, metaclass=abc.ABCMeta):
+            @abc.abstractmethod
+            def test(self):
+                ...
+        class MyTestCase(MyTestCaseBase):
+            def test(self):
+                pass
+        m.testcase_1 = MyTestCaseBase
+        m.testcase_2 = MyTestCase
+        loader = unittest.TestLoader()
+        suite = loader.loadTestsFromModule(m)
+        expected = [loader.suiteClass([MyTestCase('test')])]
+        self.assertEqual(list(suite), expected)
+
     ################################################################
     ### /Tests for TestLoader.loadTestsFromModule()
 
@@ -1052,6 +1087,22 @@ def test_loadTestsFromNames__module_not_loaded(self):
             if module_name in sys.modules:
                 del sys.modules[module_name]
 
+    # "The specifier should not refer to a test method in a TestCase-derived
+    # subclass that is an abstract base class"
+    def test_loadTestsFromNames__testmethod_in_abc_TestCase(self):
+        m = types.ModuleType('m')
+        class Foo(unittest.TestCase, metaclass=abc.ABCMeta):
+            @abc.abstractmethod
+            def test_1(self): ...
+            def test_2(self): pass
+        m.Foo = Foo
+
+        loader = unittest.TestLoader()
+        for name in 'Foo.test_1', 'Foo.test_2':
+            with self.subTest(name=name), self.assertRaisesRegex(TypeError,
+                    "Cannot instantiate abstract test case Foo"):
+                loader.loadTestsFromNames([name], m)
+
     ################################################################
     ### /Tests for TestLoader.loadTestsFromNames()
 

Lib/unittest/loader.py

@@ -1,5 +1,6 @@
 """Loading unittests."""
 
+import inspect
 import os
 import re
 import sys
@@ -84,8 +85,10 @@ def loadTestsFromTestCase(self, testCaseClass):
             raise TypeError("Test cases should not be derived from "
                             "TestSuite. Maybe you meant to derive from "
                             "TestCase?")
-        if testCaseClass in (case.TestCase, case.FunctionTestCase):
-            # We don't load any tests from base types that should not be loaded.
+        if (testCaseClass in (case.TestCase, case.FunctionTestCase) or
+            inspect.isabstract(testCaseClass)):
+            # We don't load any tests from base types that should not be loaded,
+            # and abstract base classes that can't be instantiated
             testCaseNames = []
         else:
             testCaseNames = self.getTestCaseNames(testCaseClass)
@@ -103,6 +106,7 @@ def loadTestsFromModule(self, module, *, pattern=None):
                 isinstance(obj, type)
                 and issubclass(obj, case.TestCase)
                 and obj not in (case.TestCase, case.FunctionTestCase)
+                and not inspect.isabstract(obj)
             ):
                 tests.append(self.loadTestsFromTestCase(obj))
 
@@ -181,6 +185,9 @@ def loadTestsFromName(self, name, module=None):
         elif (isinstance(obj, types.FunctionType) and
               isinstance(parent, type) and
               issubclass(parent, case.TestCase)):
+            if inspect.isabstract(parent):
+                raise TypeError(
+                    "Cannot instantiate abstract test case %s" % parent.__name__)
             name = parts[-1]
             inst = parent(name)
             # static methods follow a different path

Makefile.pre.in

@@ -1709,6 +1709,8 @@ Programs/_bootstrap_python.o: Programs/_bootstrap_python.c $(BOOTSTRAP_HEADERS)
 _bootstrap_python: $(LIBRARY_OBJS_OMIT_FROZEN) Programs/_bootstrap_python.o Modules/getpath.o Modules/Setup.local
 	$(LINKCC) $(PY_LDFLAGS_NOLTO) -o $@ $(LIBRARY_OBJS_OMIT_FROZEN) \
 		Programs/_bootstrap_python.o Modules/getpath.o $(LIBS) $(MODLIBS) $(SYSLIBS)
+	# Dummy pybuilddir.txt  is needed for _bootstrap_python to be runnable
+	@echo "none" > ./pybuilddir.txt
 
 
 ############################################################################

Misc/NEWS.d/next/Core_and_Builtins/2026-06-16-00-45-42.gh-issue-151510.HJ-kGn.rst

@@ -0,0 +1,2 @@
+Fix a crash in :func:`!__lazy_import__` when called without an explicit
+``globals`` argument and without a current Python frame.

Misc/NEWS.d/next/Core_and_Builtins/2026-06-16-17-23-37.gh-issue-151546.LhiaZz.rst

@@ -0,0 +1,3 @@
+Fix the stack limit check if Python is linked to musl (ex: Alpine Linux).
+Use the stack size set by the linker to compute the stack limits. Patch by
+Victor Stinner.

Misc/NEWS.d/next/Library/2024-06-18-04-08-37.gh-issue-120665.x7T1hV.rst

@@ -0,0 +1 @@
+Fixed an issue where ``unittest`` loaders would load and instantiate :class:`unittest.TestCase`-derived subclasses that are also abstract base classes, which can't be instantiated.