Import CPython 3.14.5+ stable branch (2026-05-24)

Summary:
Imported python/cpython `3.14.5+` from upstream rev [`5676bfc`](https://www.github.com/python/cpython/commit/5676bfcf859529b9ddd9a74b3199f2d932992458) (committed 2026-05-24 07:42:21+00:00).

# Commit Info

Base: (`3.14.5+`) - [`2dd91d2`](https://www.github.com/python/cpython/commit/2dd91d2b92a6c74d78cd3385ede328190cd8eaa9) (commit date: 2026-05-22 14:28:43+00:00)
Imported: (`3.14.5+`) - [`5676bfc`](https://www.github.com/python/cpython/commit/5676bfcf859529b9ddd9a74b3199f2d932992458) (commit date: 2026-05-24 07:42:21+00:00)

# Noteworthy file changes

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

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

Reviewed By: itamaro

Differential Revision: D106240554

fbshipit-source-id: 5f92d83756f3f4184d83c645cc67703774bc90be

Author: generatedunixname1734921407115435

Doc/library/threading.rst

@@ -512,7 +512,7 @@ since it is impossible to detect the termination of alien threads.
    This constructor should always be called with keyword arguments.  Arguments
    are:
 
-   *group* should be ``None``; reserved for future extension when a
+   *group* must be ``None`` as it is reserved for future extension when a
    :class:`!ThreadGroup` class is implemented.
 
    *target* is the callable object to be invoked by the :meth:`run` method.

Lib/asyncio/coroutines.py

@@ -18,8 +18,8 @@ def _is_debug_mode():
 
 
 def iscoroutinefunction(func):
-    import warnings
     """Return True if func is a decorated coroutine function."""
+    import warnings
     warnings._deprecated("asyncio.iscoroutinefunction",
                          f"{warnings._DEPRECATED_MSG}; "
                          "use inspect.iscoroutinefunction() instead",

Lib/test/test_type_cache.py

@@ -1,4 +1,5 @@
 """ Tests for the internal type cache in CPython. """
+import collections.abc
 import dis
 import unittest
 import warnings
@@ -114,6 +115,25 @@ class HolderSub(Holder):
             Holder.set_value()
             HolderSub.value
 
+    def test_abc_register_invalidates_subclass_versions(self):
+        class Parent:
+            pass
+
+        class Child(Parent):
+            pass
+
+        type_assign_version(Parent)
+        type_assign_version(Child)
+        parent_version = type_get_version(Parent)
+        child_version = type_get_version(Child)
+        if parent_version == 0 or child_version == 0:
+            self.skipTest("Could not assign valid type versions")
+
+        collections.abc.Mapping.register(Parent)
+
+        self.assertEqual(type_get_version(Parent), 0)
+        self.assertEqual(type_get_version(Child), 0)
+
 @support.cpython_only
 class TypeCacheWithSpecializationTests(unittest.TestCase):
     def tearDown(self):

Misc/NEWS.d/next/Core_and_Builtins/2026-04-15-15-48-04.gh-issue-148450.2MEVqH.rst

@@ -0,0 +1 @@
+Fix ``abc.register()`` so it invalidates type version tags for registered classes.

Misc/NEWS.d/next/Library/2026-05-18-15-30-34.gh-issue-146452.RM0EVJ.rst

@@ -1497,7 +1497,9 @@ buffered_iternext(PyObject *op)
         tp == state->PyBufferedRandom_Type)
     {
         /* Skip method call overhead for speed */
+        Py_BEGIN_CRITICAL_SECTION(self);
         line = _buffered_readline(self, -1);
+        Py_END_CRITICAL_SECTION();
     }
     else {
         line = PyObject_CallMethodNoArgs((PyObject *)self,

Modules/_io/bufferedio.c

@@ -3351,12 +3351,9 @@ batch_dict(PickleState *state, PicklerObject *self, PyObject *iter, PyObject *or
  * Returns 0 on success, -1 on error.
  *
  * Note that this currently doesn't work for protocol 0.
-
- * gh-146452: Wrap the dict iteration in a critical sections to prevent
- * concurrent mutation from invalidating PyDict_Next() iteration state.
  */
 static int
-batch_dict_exact(PickleState *state, PicklerObject *self, PyObject *obj)
+batch_dict_exact_impl(PickleState *state, PicklerObject *self, PyObject *obj)
 {
     PyObject *key = NULL, *value = NULL;
     int i;
@@ -3373,19 +3370,9 @@ batch_dict_exact(PickleState *state, PicklerObject *self, PyObject *obj)
 
     /* Special-case len(d) == 1 to save space. */
     if (dict_size == 1) {
-        int next;
-        Py_BEGIN_CRITICAL_SECTION(obj);
-        next = PyDict_Next(obj, &ppos, &key, &value);
-        if (next) {
-            Py_INCREF(key);
-            Py_INCREF(value);
-        }
-        Py_END_CRITICAL_SECTION();
-        if (!next) {
-            PyErr_SetString(PyExc_RuntimeError,
-                            "dictionary changed size during iteration");
-            goto error;
-        }
+        PyDict_Next(obj, &ppos, &key, &value);
+        Py_INCREF(key);
+        Py_INCREF(value);
         if (save(state, self, key, 0) < 0) {
             goto error;
         }
@@ -3405,18 +3392,9 @@ batch_dict_exact(PickleState *state, PicklerObject *self, PyObject *obj)
         i = 0;
         if (_Pickler_Write(self, &mark_op, 1) < 0)
             return -1;
-        int next;
-        while (1) {
-            Py_BEGIN_CRITICAL_SECTION(obj);
-            next = PyDict_Next(obj, &ppos, &key, &value);
-            if (next) {
-                Py_INCREF(key);
-                Py_INCREF(value);
-            }
-            Py_END_CRITICAL_SECTION();
-            if (!next) {
-                break;
-            }
+        while (PyDict_Next(obj, &ppos, &key, &value)) {
+            Py_INCREF(key);
+            Py_INCREF(value);
             if (save(state, self, key, 0) < 0) {
                 goto error;
             }
@@ -3446,6 +3424,18 @@ batch_dict_exact(PickleState *state, PicklerObject *self, PyObject *obj)
     return -1;
 }
 
+/* gh-146452: Wrap the dict iteration in a critical section to prevent
+   concurrent mutation from invalidating PyDict_Next() iteration state. */
+static int
+batch_dict_exact(PickleState *state, PicklerObject *self, PyObject *obj)
+{
+    int ret;
+    Py_BEGIN_CRITICAL_SECTION(obj);
+    ret = batch_dict_exact_impl(state, self, obj);
+    Py_END_CRITICAL_SECTION();
+    return ret;
+}
+
 static int
 save_dict(PickleState *state, PicklerObject *self, PyObject *obj)
 {

Modules/_pickle.c

@@ -6074,6 +6074,15 @@ void
 _PyType_SetFlagsRecursive(PyTypeObject *self, unsigned long mask, unsigned long flags)
 {
     BEGIN_TYPE_LOCK();
+    /* Ideally, changing flags and invalidating the old version tag would happen
+       in one step. In 3.14, invalidate first while holding TYPE_LOCK so readers
+       cannot assign a fresh tag from stale flags. Immutable types are skipped by
+       set_flags_recursive(). */
+    if (!PyType_HasFeature(self, Py_TPFLAGS_IMMUTABLETYPE) &&
+        (self->tp_flags & mask) != flags)
+    {
+        type_modified_unlocked(self);
+    }
     set_flags_recursive(self, mask, flags);
     END_TYPE_LOCK();
 }

Objects/typeobject.c

@@ -701,6 +701,7 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
 
             PyHamtNode_Bitmap *ret = hamt_node_bitmap_clone(self);
             if (ret == NULL) {
+                Py_DECREF(sub_node);
                 return NULL;
             }
             Py_SETREF(ret->b_array[val_idx], (PyObject*)sub_node);
@@ -993,6 +994,7 @@ hamt_node_bitmap_without(PyHamtNode_Bitmap *self,
 
                 PyHamtNode_Bitmap *clone = hamt_node_bitmap_clone(self);
                 if (clone == NULL) {
+                    Py_DECREF(sub_node);
                     return W_ERROR;
                 }