GH-89812: Add pathlib._PathBase

Lib/pathlib.py

@@ -1253,6 +1253,15 @@ def readlink(self):
         Return the path to which the symbolic link points.
         """
         self._unsupported("readlink")
+    readlink._unsupported = True
+
+    def _split_stack(self):
+        """
+        Split the path into a 2-tuple (anchor, parts), where *anchor* is the
+        uppermost parent of the path (equivalent to path.parents[-1]), and
+        *parts* is a reversed list of parts following the anchor.
+        """
+        return self._from_parsed_parts(self.drive, self.root, []), self._tail[::-1]
 
     def resolve(self, strict=False):
         """
@@ -1266,13 +1275,11 @@ def resolve(self, strict=False):
         except UnsupportedOperation:
             path = self
 
-        def split(path):
-            return path._from_parsed_parts(path.drive, path.root, []), path._tail[::-1]
-
+        querying = strict or not getattr(self.readlink, '_unsupported', False)
         link_count = 0
         stat_cache = {}
         target_cache = {}
-        path, parts = split(path)
+        path, parts = path._split_stack()
         while parts:
             part = parts.pop()
             if part == '..':
@@ -1284,38 +1291,33 @@ def split(path):
                     # Delete '..' segment and its predecessor
                     path = path.parent
                     continue
-                path = path._make_child_relpath(part)
-            else:
-                lookup_path = path
-                path = path._make_child_relpath(part)
+            lookup_path = path
+            path = path._make_child_relpath(part)
+            if querying and part != '..':
                 path._resolving = True
-                path_str = str(path)
                 try:
-                    st = stat_cache.get(path_str)
+                    st = stat_cache.get(path)
                     if st is None:
-                        st = stat_cache[path_str] = path.stat(follow_symlinks=False)
+                        st = stat_cache[path] = path.stat(follow_symlinks=False)
                     if S_ISLNK(st.st_mode):
                         # Like Linux and macOS, raise OSError(errno.ELOOP) if too many symlinks are
                         # encountered during resolution.
                         link_count += 1
                         if link_count >= _MAX_SYMLINKS:
-                            raise OSError(ELOOP, "Too many symbolic links in path", path_str)
-                        target = target_cache.get(path_str)
+                            raise OSError(ELOOP, "Too many symbolic links in path", str(path))
+                        target = target_cache.get(path)
                         if target is None:
-                            target = target_cache[path_str] = path.readlink()
-                        target, target_parts = split(target)
+                            target = target_cache[path] = path.readlink()
+                        target, target_parts = target._split_stack()
                         path = target if target.root else lookup_path
                         parts.extend(target_parts)
                     elif parts and not S_ISDIR(st.st_mode):
-                        raise NotADirectoryError(ENOTDIR, "Not a directory", path_str)
+                        raise NotADirectoryError(ENOTDIR, "Not a directory", str(path))
                 except OSError:
                     if strict:
                         raise
                     else:
-                        # Append remaining path segments without further processing.
-                        for part in reversed(parts):
-                            path = path._make_child_relpath(part)
-                        break
+                        querying = False
         path._resolving = False
         return path
 

Lib/test/test_pathlib.py

@@ -2334,6 +2334,38 @@ def test_resolve_dot(self):
         # Non-strict
         self.assertEqual(r.resolve(strict=False), p / '3' / '4')
 
+    def _check_symlink_loop(self, *args):
+        path = self.cls(*args)
+        with self.assertRaises(OSError) as cm:
+            path.resolve(strict=True)
+        self.assertEqual(cm.exception.errno, errno.ELOOP)
+
+    def test_resolve_loop(self):
+        if not self.can_symlink:
+            self.skipTest("symlinks required")
+        if os.name == 'nt' and issubclass(self.cls, pathlib.Path):
+            self.skipTest("symlink loops work differently with concrete Windows paths")
+        # Loops with relative symlinks.
+        self.cls(BASE, 'linkX').symlink_to('linkX/inside')
+        self._check_symlink_loop(BASE, 'linkX')
+        self.cls(BASE, 'linkY').symlink_to('linkY')
+        self._check_symlink_loop(BASE, 'linkY')
+        self.cls(BASE, 'linkZ').symlink_to('linkZ/../linkZ')
+        self._check_symlink_loop(BASE, 'linkZ')
+        # Non-strict
+        p = self.cls(BASE, 'linkZ', 'foo')
+        self.assertEqual(p.resolve(strict=False), p)
+        # Loops with absolute symlinks.
+        self.cls(BASE, 'linkU').symlink_to(join('linkU/inside'))
+        self._check_symlink_loop(BASE, 'linkU')
+        self.cls(BASE, 'linkV').symlink_to(join('linkV'))
+        self._check_symlink_loop(BASE, 'linkV')
+        self.cls(BASE, 'linkW').symlink_to(join('linkW/../linkW'))
+        self._check_symlink_loop(BASE, 'linkW')
+        # Non-strict
+        q = self.cls(BASE, 'linkW', 'foo')
+        self.assertEqual(q.resolve(strict=False), q)
+
     def test_stat(self):
         statA = self.cls(BASE).joinpath('fileA').stat()
         statB = self.cls(BASE).joinpath('dirB', 'fileB').stat()
@@ -3428,12 +3460,6 @@ def test_absolute(self):
         self.assertEqual(str(P('//a').absolute()), '//a')
         self.assertEqual(str(P('//a/b').absolute()), '//a/b')
 
-    def _check_symlink_loop(self, *args):
-        path = self.cls(*args)
-        with self.assertRaises(OSError) as cm:
-            path.resolve(strict=True)
-        self.assertEqual(cm.exception.errno, errno.ELOOP)
-
     @unittest.skipIf(
         is_emscripten or is_wasi,
         "umask is not implemented on Emscripten/WASI."
@@ -3480,30 +3506,6 @@ def test_touch_mode(self):
         st = os.stat(join('masked_new_file'))
         self.assertEqual(stat.S_IMODE(st.st_mode), 0o750)
 
-    def test_resolve_loop(self):
-        if not self.can_symlink:
-            self.skipTest("symlinks required")
-        # Loops with relative symlinks.
-        os.symlink('linkX/inside', join('linkX'))
-        self._check_symlink_loop(BASE, 'linkX')
-        os.symlink('linkY', join('linkY'))
-        self._check_symlink_loop(BASE, 'linkY')
-        os.symlink('linkZ/../linkZ', join('linkZ'))
-        self._check_symlink_loop(BASE, 'linkZ')
-        # Non-strict
-        p = self.cls(BASE, 'linkZ', 'foo')
-        self.assertEqual(p.resolve(strict=False), p)
-        # Loops with absolute symlinks.
-        os.symlink(join('linkU/inside'), join('linkU'))
-        self._check_symlink_loop(BASE, 'linkU')
-        os.symlink(join('linkV'), join('linkV'))
-        self._check_symlink_loop(BASE, 'linkV')
-        os.symlink(join('linkW/../linkW'), join('linkW'))
-        self._check_symlink_loop(BASE, 'linkW')
-        # Non-strict
-        q = self.cls(BASE, 'linkW', 'foo')
-        self.assertEqual(q.resolve(strict=False), q)
-
     def test_glob(self):
         P = self.cls
         p = P(BASE)