Merge branch 'main' into deprecate_unicode_capi

Author: vstinner

Doc/c-api/exceptions.rst

@@ -1034,6 +1034,10 @@ because the :ref:`call protocol <call>` takes care of recursion handling.
    case, a :exc:`RecursionError` is set and a nonzero value is returned.
    Otherwise, zero is returned.
 
+   The check is based on the remaining C stack space of the current thread,
+   not on a count of calls, so it is unaffected by
+   :c:func:`Py_SetRecursionLimit` and :func:`sys.setrecursionlimit`.
+
    *where* should be a UTF-8 encoded string such as ``" in instance check"`` to
    be concatenated to the :exc:`RecursionError` message caused by the recursion
    depth limit.
@@ -1044,6 +1048,10 @@ because the :ref:`call protocol <call>` takes care of recursion handling.
    .. versionchanged:: 3.9
       This function is now also available in the :ref:`limited API <limited-c-api>`.
 
+   .. versionchanged:: 3.14
+      The check is based on the remaining C stack space.  Previously, a
+      separate counter of C-level calls was used.
+
 .. c:function:: void Py_LeaveRecursiveCall(void)
 
    Ends a :c:func:`Py_EnterRecursiveCall`.  Must be called once for each

Doc/c-api/interp-lifecycle.rst

@@ -514,7 +514,7 @@ Process-wide parameters
    Return the version of this Python interpreter.  This is a string that looks
    something like ::
 
-      "3.0a5+ (py3k:63103M, May 12 2008, 00:53:55) \n[GCC 4.2.3]"
+      "3.15.0rc2 (3.15.0~rc2-1.fc44.x86_64, Sep  3 2026, 00:00:00) [GCC 16.2.1 20260819 (Red Hat 16.2.1-2)]"
 
    .. index:: single: version (in module sys)
 

Doc/whatsnew/3.15.rst

@@ -188,10 +188,10 @@ name:
    lazy import json
    lazy from pathlib import Path
 
-   print("Starting up...")  # json and pathlib not loaded yet
+   print("Starting up...")  # json and pathlib are not fully imported yet
 
-   data = json.loads('{"key": "value"}')  # json loads here
-   p = Path(".")  # pathlib loads here
+   data = json.loads('{"key": "value"}')  # json gets fully imported here
+   p = Path(".")  # pathlib gets fully imported here
 
 This mechanism is particularly useful for applications that import many
 modules at the top level but may only use a subset of them in any given run.

Include/internal/pycore_pylifecycle.h

@@ -23,7 +23,7 @@ extern int _Py_IsLocaleCoercionTarget(const char *ctype_loc);
 
 /* Various one-time initializers */
 
-extern void _Py_InitVersion(void);
+extern PyStatus _Py_GetVersion_Init(void);
 extern PyStatus _PyFaulthandler_Init(int enable);
 extern PyObject * _PyBuiltin_Init(PyInterpreterState *interp);
 extern int _PyBuiltin_InitPythonFunctions(PyObject *dict);
@@ -43,6 +43,7 @@ extern PyStatus _PyDateTime_InitTypes(PyInterpreterState *interp);
 
 /* Various internal finalizers */
 
+extern void _Py_GetVersion_Fini(void);
 extern int _PySignal_Init(int install_signal_handlers);
 extern void _PySignal_Fini(void);
 

Lib/asyncio/tasks.py

@@ -786,7 +786,7 @@ def cancel(self, msg=None):
         return ret
 
 
-def _discard_awaited_by(children, waiter, outer):
+def _discard_awaited_by(children, waiter):
     for fut in children:
         futures.future_discard_from_awaited_by(fut, waiter)
 
@@ -852,11 +852,14 @@ def _done_callback(fut, cur_task=cur_task):
                 # 'fut.exception()' will *raise* a CancelledError
                 # instead of returning it.
                 exc = fut._make_cancelled_error()
+                # gh-157213: children outliving gather() must lose the edge
+                _discard_awaited_by(children, cur_task)
                 outer.set_exception(exc)
                 return
             else:
                 exc = fut.exception()
                 if exc is not None:
+                    _discard_awaited_by(children, cur_task)
                     outer.set_exception(exc)
                     return
 
@@ -924,10 +927,6 @@ def _done_callback(fut, cur_task=cur_task):
         children.append(fut)
 
     outer = _GatheringFuture(children, loop=loop)
-    if cur_task is not None:
-        # gh-157213: a child outliving gather() must lose the awaited-by edge
-        outer.add_done_callback(
-            functools.partial(_discard_awaited_by, children, cur_task))
     # Run done callbacks after GatheringFuture created so any post-processing
     # can be performed at this point
     # optimization: in the special case that *all* futures finished eagerly,

Lib/inspect.py

@@ -2348,6 +2348,8 @@ def _signature_from_function(cls, func, skip_bound_arg=True,
         return _signature_fromstr(cls, func, s, skip_bound_arg)
 
     Parameter = cls._parameter_cls
+    if Parameter is Signature._parameter_cls and not is_duck_function:
+        Parameter = Parameter._from_code
 
     # Parameter information.
     func_code = func.__code__
@@ -2746,6 +2748,18 @@ def __init__(self, name, kind, *, default=_empty, annotation=_empty):
 
         self._name = name
 
+    @classmethod
+    def _from_code(cls, name, kind, *, default=_empty, annotation=_empty):
+        # Fast path for Python functions: only the name needs validation.
+        if iskeyword(name) or not name.isidentifier():
+            return cls(name, kind, default=default, annotation=annotation)
+        self = object.__new__(cls)
+        self._name = name
+        self._kind = kind
+        self._default = default
+        self._annotation = annotation
+        return self
+
     def __reduce__(self):
         return (type(self),
                 (self._name, self._kind),

Lib/test/libregrtest/findtests.py

@@ -21,6 +21,7 @@
     "test_asyncio",
     "test_concurrent_futures",
     "test_doctests",
+    "test_free_threading",
     "test_future_stmt",
     "test_gdb",
     "test_inspect",

Lib/test/test_asyncio/test_tasks.py

@@ -1250,6 +1250,37 @@ async def coro():
 
         self.loop.run_until_complete(self.new_task(self.loop, coro()))
 
+    def test_gather_discards_awaited_by_for_cancelled_sibling(self):
+        # gh-157213: same, when gather() is ended by a cancelled child
+        async def survivor():
+            await asyncio.Future()
+
+        async def coro():
+            t = self.new_task(self.loop, survivor())
+            victim = self.new_task(self.loop, asyncio.sleep(10))
+            victim.cancel()
+            with self.assertRaises(asyncio.CancelledError):
+                await asyncio.gather(t, victim)
+            self.assertFalse(t._asyncio_awaited_by)
+            t.cancel()
+            with self.assertRaises(asyncio.CancelledError):
+                await t
+
+        self.loop.run_until_complete(self.new_task(self.loop, coro()))
+
+    def test_gather_does_not_add_callback_to_outer(self):
+        # gh-158239: gather() must not add an internal done callback to
+        # the outer future just to maintain the await graph.
+        async def child():
+            await asyncio.sleep(0)
+
+        async def coro():
+            outer = asyncio.gather(child(), child())
+            self.assertFalse(outer._callbacks)
+            await outer
+
+        self.loop.run_until_complete(self.new_task(self.loop, coro()))
+
     def test_wait_really_done(self):
         # there is possibility that some tasks in the pending list
         # became done but their callbacks haven't all been called yet

Lib/test/test_bytes.py

@@ -518,6 +518,15 @@ def test_fromhex(self):
                 self.type2test.fromhex(data)
             self.assertIn('at position %s' % pos, str(cm.exception))
 
+        # gh-158583: Check for out of bounds reads (uninitialized bytes).
+        # Create an array from a list to not overallocate.
+        a = array.array('B', list(b'1234  '))  # Py_ISSPACE() loop
+        self.assertEqual(self.type2test.fromhex(a), b'\x12\x34')
+
+        a = array.array('B', list(b'12345'))  # Missing second digit
+        with self.assertRaises(ValueError):
+            self.type2test.fromhex(a)
+
     def test_hex(self):
         self.assertRaises(TypeError, self.type2test.hex)
         self.assertRaises(TypeError, self.type2test.hex, 1)

Lib/test/test_capi/test_build.py

@@ -20,15 +20,11 @@ def test_getcopyright(self):
 
     # Test Py_GetCompiler()
     def test_getcompiler(self):
-        compiler = _testlimitedcapi.py_getcompiler()
-        self.assertIsInstance(compiler, str)
-        self.assertNotEqual(compiler, '')
+        self.assertIn(_testlimitedcapi.py_getcompiler(), sys.version)
 
     # Test Py_GetBuildInfo()
     def test_getbuildinfo(self):
-        buildinfo = _testlimitedcapi.py_getbuildinfo()
-        self.assertIsInstance(buildinfo, str)
-        self.assertNotEqual(buildinfo, '')
+        self.assertIn(_testlimitedcapi.py_getbuildinfo(), sys.version)
 
     # Test internal _Py_GetBuiltWithAssert()
     def test__getbuiltwithassert(self):