Merge branch 'main' into bugfix/pythongh-127085

Doc/library/asyncio-sync.rst

@@ -259,16 +259,16 @@ Condition
 
       Note that a task *may* return from this call spuriously,
       which is why the caller should always re-check the state
-      and be prepared to :meth:`wait` again. For this reason, you may
-      prefer to use :meth:`wait_for` instead.
+      and be prepared to :meth:`~Condition.wait` again. For this reason, you may
+      prefer to use :meth:`~Condition.wait_for` instead.
 
    .. coroutinemethod:: wait_for(predicate)
 
       Wait until a predicate becomes *true*.
 
       The predicate must be a callable which result will be
       interpreted as a boolean value.  The method will repeatedly
-      :meth:`wait` until the predicate evaluates to *true*. The final value is the
+      :meth:`~Condition.wait` until the predicate evaluates to *true*. The final value is the
       return value.
 
 
@@ -434,7 +434,7 @@ Barrier
    .. coroutinemethod:: abort()
 
       Put the barrier into a broken state.  This causes any active or future
-      calls to :meth:`wait` to fail with the :class:`BrokenBarrierError`.
+      calls to :meth:`~Barrier.wait` to fail with the :class:`BrokenBarrierError`.
       Use this for example if one of the tasks needs to abort, to avoid infinite
       waiting tasks.
 

Lib/pathlib/_abc.py

@@ -438,14 +438,6 @@ def stat(self, *, follow_symlinks=True):
         """
         raise UnsupportedOperation(self._unsupported_msg('stat()'))
 
-    def lstat(self):
-        """
-        Like stat(), except if the path points to a symlink, the symlink's
-        status information is returned, rather than its target's.
-        """
-        return self.stat(follow_symlinks=False)
-
-
     # Convenience functions for querying the stat results
 
     def exists(self, *, follow_symlinks=True):
@@ -505,7 +497,7 @@ def is_symlink(self):
         Whether this path is a symbolic link.
         """
         try:
-            return S_ISLNK(self.lstat().st_mode)
+            return S_ISLNK(self.stat(follow_symlinks=False).st_mode)
         except (OSError, ValueError):
             return False
 
@@ -789,7 +781,7 @@ def raise_error(*args):
             def lstat(path_str):
                 path = self.with_segments(path_str)
                 path._resolving = True
-                return path.lstat()
+                return path.stat(follow_symlinks=False)
 
             def readlink(path_str):
                 path = self.with_segments(path_str)

Lib/pathlib/_local.py

@@ -542,6 +542,13 @@ def stat(self, *, follow_symlinks=True):
         """
         return os.stat(self, follow_symlinks=follow_symlinks)
 
+    def lstat(self):
+        """
+        Like stat(), except if the path points to a symlink, the symlink's
+        status information is returned, rather than its target's.
+        """
+        return os.lstat(self)
+
     def exists(self, *, follow_symlinks=True):
         """
         Whether this path exists.

Lib/test/test_free_threading/test_type.py

@@ -124,6 +124,21 @@ def work():
         for thread in threads:
             thread.join()
 
+    def test_object_class_change(self):
+        class Base:
+            def __init__(self):
+                self.attr = 123
+        class ClassA(Base):
+            pass
+        class ClassB(Base):
+            pass
+
+        obj = ClassA()
+        # keep reference to __dict__
+        d = obj.__dict__
+        obj.__class__ = ClassB
+
+
     def run_one(self, writer_func, reader_func):
         writer = Thread(target=writer_func)
         readers = []

Lib/test/test_import/__init__.py

@@ -1133,6 +1133,19 @@ def test_script_shadowing_stdlib_sys_path_modification(self):
                 stdout, stderr = popen.communicate()
                 self.assertRegex(stdout, expected_error)
 
+    def test_create_dynamic_null(self):
+        with self.assertRaisesRegex(ValueError, 'embedded null character'):
+            class Spec:
+                name = "a\x00b"
+                origin = "abc"
+            _imp.create_dynamic(Spec())
+
+        with self.assertRaisesRegex(ValueError, 'embedded null character'):
+            class Spec2:
+                name = "abc"
+                origin = "a\x00b"
+            _imp.create_dynamic(Spec2())
+
 
 @skip_if_dont_write_bytecode
 class FilePermissionTests(unittest.TestCase):

Lib/test/test_pathlib/test_pathlib.py

@@ -546,12 +546,9 @@ def tempdir(self):
         self.addCleanup(os_helper.rmtree, d)
         return d
 
-    def test_matches_pathbase_api(self):
-        our_names = {name for name in dir(self.cls) if name[0] != '_'}
-        our_names.remove('is_reserved')  # only present in PurePath
+    def test_matches_pathbase_docstrings(self):
         path_names = {name for name in dir(pathlib._abc.PathBase) if name[0] != '_'}
-        self.assertEqual(our_names, path_names)
-        for attr_name in our_names:
+        for attr_name in path_names:
             if attr_name == 'parser':
                 # On Windows, Path.parser is ntpath, but PathBase.parser is
                 # posixpath, and so their docstrings differ.
@@ -1357,6 +1354,17 @@ def test_symlink_to_unsupported(self):
         with self.assertRaises(pathlib.UnsupportedOperation):
             q.symlink_to(p)
 
+    @needs_symlinks
+    def test_lstat(self):
+        p = self.cls(self.base)/ 'linkA'
+        st = p.stat()
+        self.assertNotEqual(st, p.lstat())
+
+    def test_lstat_nosymlink(self):
+        p = self.cls(self.base) / 'fileA'
+        st = p.stat()
+        self.assertEqual(st, p.lstat())
+
     def test_is_junction(self):
         P = self.cls(self.base)
 

Lib/test/test_pathlib/test_pathlib_abc.py

@@ -1351,7 +1351,6 @@ def test_unsupported_operation(self):
         p = self.cls('')
         e = UnsupportedOperation
         self.assertRaises(e, p.stat)
-        self.assertRaises(e, p.lstat)
         self.assertRaises(e, p.exists)
         self.assertRaises(e, p.samefile, 'foo')
         self.assertRaises(e, p.is_dir)
@@ -2671,17 +2670,6 @@ def test_stat_no_follow_symlinks_nosymlink(self):
         st = p.stat()
         self.assertEqual(st, p.stat(follow_symlinks=False))
 
-    @needs_symlinks
-    def test_lstat(self):
-        p = self.cls(self.base)/ 'linkA'
-        st = p.stat()
-        self.assertNotEqual(st, p.lstat())
-
-    def test_lstat_nosymlink(self):
-        p = self.cls(self.base) / 'fileA'
-        st = p.stat()
-        self.assertEqual(st, p.lstat())
-
     def test_is_dir(self):
         P = self.cls(self.base)
         self.assertTrue((P / 'dirA').is_dir())
@@ -2868,11 +2856,13 @@ def test_delete_dir(self):
         base = self.cls(self.base)
         base.joinpath('dirA')._delete()
         self.assertRaises(FileNotFoundError, base.joinpath('dirA').stat)
-        self.assertRaises(FileNotFoundError, base.joinpath('dirA', 'linkC').lstat)
+        self.assertRaises(FileNotFoundError, base.joinpath('dirA', 'linkC').stat,
+                          follow_symlinks=False)
         base.joinpath('dirB')._delete()
         self.assertRaises(FileNotFoundError, base.joinpath('dirB').stat)
         self.assertRaises(FileNotFoundError, base.joinpath('dirB', 'fileB').stat)
-        self.assertRaises(FileNotFoundError, base.joinpath('dirB', 'linkD').lstat)
+        self.assertRaises(FileNotFoundError, base.joinpath('dirB', 'linkD').stat,
+                          follow_symlinks=False)
         base.joinpath('dirC')._delete()
         self.assertRaises(FileNotFoundError, base.joinpath('dirC').stat)
         self.assertRaises(FileNotFoundError, base.joinpath('dirC', 'dirD').stat)

Objects/dictobject.c

@@ -7300,7 +7300,7 @@ _PyDict_DetachFromObject(PyDictObject *mp, PyObject *obj)
 
     // We could be called with an unlocked dict when the caller knows the
     // values are already detached, so we assert after inline values check.
-    _Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(mp);
+    ASSERT_WORLD_STOPPED_OR_OBJ_LOCKED(mp);
     assert(mp->ma_values->embedded == 1);
     assert(mp->ma_values->valid == 1);
     assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES);

Python/import.c

@@ -1157,12 +1157,14 @@ del_extensions_cache_value(struct extensions_cache_value *value)
 static void *
 hashtable_key_from_2_strings(PyObject *str1, PyObject *str2, const char sep)
 {
-    Py_ssize_t str1_len, str2_len;
-    const char *str1_data = PyUnicode_AsUTF8AndSize(str1, &str1_len);
-    const char *str2_data = PyUnicode_AsUTF8AndSize(str2, &str2_len);
+    const char *str1_data = _PyUnicode_AsUTF8NoNUL(str1);
+    const char *str2_data = _PyUnicode_AsUTF8NoNUL(str2);
     if (str1_data == NULL || str2_data == NULL) {
         return NULL;
     }
+    Py_ssize_t str1_len = strlen(str1_data);
+    Py_ssize_t str2_len = strlen(str2_data);
+
     /* Make sure sep and the NULL byte won't cause an overflow. */
     assert(SIZE_MAX - str1_len - str2_len > 2);
     size_t size = str1_len + 1 + str2_len + 1;