Merge branch 'main' into fix/subi/channel-id-attr-143376

Author: picnixz

Doc/library/ctypes.rst

@@ -2052,7 +2052,11 @@ See :ref:`ctypes-callback-functions` for examples.
 .. function:: PYFUNCTYPE(restype, *argtypes)
 
    The returned function prototype creates functions that use the Python calling
-   convention.  The function will *not* release the GIL during the call.
+   convention.  Unlike :func:`CFUNCTYPE` and :func:`WINFUNCTYPE`, ctypes does
+   *not* release the GIL before calling the foreign function, so the function
+   may safely use the Python C API. Note that this does not prevent the GIL
+   from being released *during* the call.
+
 
 Function prototypes created by these factory functions can be instantiated in
 different ways, depending on the type and number of the parameters in the call:

Doc/library/gc.rst

@@ -75,6 +75,12 @@ The :mod:`!gc` module provides the following functions:
    returned. If *generation* is not ``None``, return only the objects tracked by
    the collector that are in that generation.
 
+   .. warning::
+      Care must be taken when using objects returned by :func:`get_objects` because
+      some of them could still be under construction and hence in a temporarily
+      invalid state. Avoid using :func:`get_objects` for any purpose other than
+      debugging.
+
    .. versionchanged:: 3.8
       New *generation* parameter.
 

Lib/test/test_free_threading/test_monitoring.py

@@ -1,6 +1,7 @@
 """Tests monitoring, sys.settrace, and sys.setprofile in a multi-threaded
 environment to verify things are thread-safe in a free-threaded build"""
 
+import dis
 import sys
 import threading
 import time
@@ -251,6 +252,62 @@ def append(self, trace):
 
 @threading_helper.requires_working_threading()
 class MonitoringMisc(MonitoringTestMixin, TestCase):
+    def test_disable_line_keeps_instruction_events(self):
+        def func(x):
+            a = x + 1
+            b = a * 2
+            return b
+
+        code = func.__code__
+        expected = [instr.offset for instr in dis.get_instructions(func)
+                    if instr.opname != "RESUME"]
+        # Two threads, each with two lists of instruction offsets (one per call).
+        # Check that disabling LINE preserves INSTRUCTION events in every
+        # thread-local bytecode copy, including on subsequent calls.
+        records = [[[], []] for _ in range(2)]
+        local = threading.local()
+        ready = Barrier(len(records) + 1)
+        start = threading.Event()
+
+        def worker(calls):
+            # Create each thread's bytecode copy before enabling monitoring.
+            func(1)
+            ready.wait()
+            start.wait()
+            for instructions in calls:
+                local.instructions = instructions
+                func(1)
+
+        def instruction(code, offset):
+            local.instructions.append(offset)
+
+        def line(code, lineno):
+            return monitoring.DISABLE
+
+        threads = [Thread(target=worker, args=(calls,)) for calls in records]
+        try:
+            with threading_helper.start_threads(threads, unlock=start.set):
+                ready.wait()
+                monitoring.register_callback(
+                    self.tool_id, monitoring.events.INSTRUCTION, instruction)
+                monitoring.register_callback(
+                    self.tool_id, monitoring.events.LINE, line)
+                monitoring.set_local_events(
+                    self.tool_id, code,
+                    monitoring.events.INSTRUCTION | monitoring.events.LINE)
+                start.set()
+        finally:
+            monitoring.set_local_events(self.tool_id, code, 0)
+            monitoring.register_callback(
+                self.tool_id, monitoring.events.INSTRUCTION, None)
+            monitoring.register_callback(
+                self.tool_id, monitoring.events.LINE, None)
+            monitoring.restart_events()
+
+        for calls in records:
+            for instructions in calls:
+                self.assertEqual(instructions, expected)
+
     def register_callback(self, barrier):
         barrier.wait()
 

Lib/test/test_monitoring.py

@@ -1192,6 +1192,80 @@ def __call__(self, code, offset):
 class TestLineAndInstructionEvents(CheckEvents):
     maxDiff = None
 
+    def test_disable_line_keeps_instruction_events(self):
+        for local in (False, True):
+            # Use the same tool or different tools for LINE and INSTRUCTION.
+            for line_tool, instr_tool in (
+                (TEST_TOOL, TEST_TOOL),
+                (TEST_TOOL2, TEST_TOOL),
+            ):
+                with self.subTest(local=local, line_tool=line_tool,
+                                  instr_tool=instr_tool):
+                    self.check_disable_line_keeps_instruction_events(
+                        local, line_tool, instr_tool)
+
+    def check_disable_line_keeps_instruction_events(self, local, line_tool,
+                                                   instr_tool):
+        def func(x):
+            a = x + 1
+            # Split the assignment so line events also move backwards from
+            # the expression's line to the assignment's line.
+            b = (
+                a * 2
+            )
+            return b
+
+        code = func.__code__
+        instructions = []
+        lines = []
+        disable = False
+
+        def instruction(code_arg, offset):
+            if code_arg is code:
+                instructions.append(offset)
+
+        def line(code_arg, lineno):
+            if code_arg is code:
+                lines.append(lineno)
+                if disable:
+                    return sys.monitoring.DISABLE
+
+        sys.monitoring.register_callback(instr_tool, E.INSTRUCTION, instruction)
+        sys.monitoring.register_callback(line_tool, E.LINE, line)
+        events = {instr_tool: E.INSTRUCTION}
+        events[line_tool] = events.get(line_tool, 0) | E.LINE
+        try:
+            for tool, mask in events.items():
+                if local:
+                    sys.monitoring.set_local_events(tool, code, mask)
+                else:
+                    sys.monitoring.set_events(tool, mask)
+            func(1)
+            expected_instructions = instructions[:]
+            expected_lines = lines[:]
+            self.assertEqual(expected_instructions, [
+                inst.offset for inst in dis.get_instructions(func)
+                if inst.opname != "RESUME"
+            ])
+            self.assertTrue(expected_lines)
+            disable = True
+            for restart in (False, True):
+                if restart:
+                    sys.monitoring.restart_events()
+                for call in range(2):
+                    instructions.clear()
+                    lines.clear()
+                    func(1)
+                    self.assertEqual(instructions, expected_instructions)
+                    self.assertEqual(lines, expected_lines if call == 0 else [])
+        finally:
+            for tool in events:
+                sys.monitoring.set_local_events(tool, code, 0)
+                sys.monitoring.set_events(tool, 0)
+            sys.monitoring.register_callback(instr_tool, E.INSTRUCTION, None)
+            sys.monitoring.register_callback(line_tool, E.LINE, None)
+            sys.monitoring.restart_events()
+
     def test_simple(self):
 
         def func1():

Lib/test/test_sax.py

@@ -24,8 +24,8 @@
 import sys
 from urllib.error import URLError
 import urllib.request
-from test.support import os_helper
-from test.support import findfile, check__all__
+from test.support import (check__all__, cpython_only, findfile,
+                          import_helper, os_helper)
 from test.support.os_helper import FakePath, TESTFN
 
 
@@ -1600,6 +1600,12 @@ def test_deprecated__version__and__date__(self):
                     getattr(module, "version")
                 self.assertEqual(cm.filename, __file__)
 
+    @cpython_only
+    def test_lazy_import(self):
+        import_helper.ensure_lazy_imports(
+            "xml.sax.saxutils", {"urllib.parse", "urllib.request"}
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_ssl.py

@@ -1135,6 +1135,16 @@ def test_set_server_sigalgs(self):
         if CAN_IGNORE_UNKNOWN_OPENSSL_SIGALGS:
             self.assertIsNone(ctx.set_server_sigalgs('rsa_pss_rsae_sha256:?foo'))
 
+    @unittest.skipUnless(CAN_GET_SELECTED_OPENSSL_GROUP,
+                         "SSL library doesn't support getting selected group")
+    def test_no_session_group_does_not_crash(self):
+        # Ensure that .group() does not crash because of OpenSSL itself.
+        # See https://github.com/python/cpython/issues/155782.
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        obj = ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO())
+        self.assertIsNone(obj.group())
+
     def test_options(self):
         # Test default SSLContext options
         ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)

Lib/xml/sax/saxutils.py

@@ -3,9 +3,12 @@
 convenience of application and driver writers.
 """
 
-import os, urllib.parse, urllib.request
-import io
 import codecs
+import io
+import os
+import sys
+lazy import urllib.parse
+lazy import urllib.request
 from . import handler
 from . import xmlreader
 
@@ -70,7 +73,6 @@ def quoteattr(data, entities={}):
 
 def _gettextwriter(out, encoding):
     if out is None:
-        import sys
         return sys.stdout
 
     if isinstance(out, io.TextIOBase):

Misc/NEWS.d/next/Core_and_Builtins/2026-09-29-14-35-00.gh-issue-158121.Kj4nQ8.rst

@@ -0,0 +1,2 @@
+Fix missing :mod:`sys.monitoring` ``INSTRUCTION`` events when a ``LINE``
+callback returns :data:`sys.monitoring.DISABLE`.

Misc/NEWS.d/next/Library/2026-08-15-11-30-42.gh-issue-155782.JUmDP4.rst

@@ -0,0 +1,2 @@
+:mod:`ssl`: prevent a crash in :meth:`~ssl.SSLSocket.group`
+for session-less objects on OpenSSL 3.2 and later. Patch by Bénédikt Tran.

Misc/NEWS.d/next/Library/2026-08-15-11-49-30.gh-issue-155830.cY5xgK.rst

@@ -0,0 +1,2 @@
+:mod:`!_blake2`: Ensure that BLAKE-2 objects are correctly initialized
+before being tracked by the garbage collector. Patch by Bénédikt Tran.