Merge branch 'main' into gh-100479-add-makepath

python · barneygale · Nov 20, 2022 · Dec 24, 2022 · Dec 24, 2022 · Jan 5, 2023
commit ef6f4c3b6d75ddfa7064f1fb9f88a1fc0965e645
@@ -375,7 +375,7 @@ Pure paths provide the following methods and properties:
    .. versionchanged:: 3.12
       Type changed from a tuple-like immutable sequence to a true tuple.
 
-.. data:: PurePath.parent
+.. attribute:: PurePath.parent
 
    The logical parent of the path::
 
@@ -551,7 +551,7 @@ Pure paths provide the following methods and properties:
 
    Create a new path object of the same type by combining the *other*
    arguments. This method is called whenever a derivative path is created,
-   such as from :data:`parent` and :meth:`relative_to`. Subclasses may
+   such as from :attr:`parent` and :meth:`relative_to`. Subclasses may
    override this method to pass information to derivative paths, for example::
 
       from pathlib import PurePosixPath

@@ -119,7 +119,7 @@ def __init__(self, name, child_parts, flavour):
 
     def _select_from(self, parent_path, is_dir, exists, scandir, normcase):
         try:
-            path = parent_path.joinpath(self.name)
+            path = parent_path._make_child_relpath(self.name)
             if (is_dir if self.dironly else exists)(path):
                 for p in self.successor._select_from(path, is_dir, exists, scandir, normcase):
                     yield p
@@ -153,7 +153,7 @@ def _select_from(self, parent_path, is_dir, exists, scandir, normcase):
                         continue
                 name = entry.name
                 if self.match(normcase(name)):
-                    path = parent_path.joinpath(name)
+                    path = parent_path._make_child_relpath(name)
                     for p in self.successor._select_from(path, is_dir, exists, scandir, normcase):
                         yield p
         except PermissionError:
@@ -180,7 +180,7 @@ def _iterate_directories(self, parent_path, is_dir, scandir):
                     if not _ignore_error(e):
                         raise
                 if entry_is_dir and not entry.is_symlink():
-                    path = parent_path.joinpath(entry.name)
+                    path = parent_path._make_child_relpath(entry.name)
                     for p in self._iterate_directories(path, is_dir, scandir):
                         yield p
         except PermissionError:
@@ -206,7 +206,6 @@ def _select_from(self, parent_path, is_dir, exists, scandir, normcase):
 # Public API
 #
 
-
 class PurePath(object):
     """Base class for manipulating paths without I/O.
 
@@ -230,7 +229,7 @@ def __new__(cls, *args, **kwargs):
         """
         if cls is PurePath:
             cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
-        return super().__new__(cls)
+        return object.__new__(cls)
 
     def __reduce__(self):
         # Using the parts tuple helps share interned path parts
@@ -270,31 +269,20 @@ def _parse_path(cls, path):
         parsed = [sys.intern(x) for x in unfiltered_parsed if x and x != '.']
         return drv, root, parsed
 
-    @classmethod
-    def _parse_args(cls, args):
-        # This is useful when you don't want to create an instance, just
-        # canonicalize some constructor arguments.
-        parts = []
-        for a in args:
-            if isinstance(a, PurePath):
-                parts += a._parts
-            else:
-                a = os.fspath(a)
-                if isinstance(a, str):
-                    # Force-cast str subclasses to str (issue #21127)
-                    parts.append(str(a))
-                else:
-                    raise TypeError(
-                        "argument should be a str object or an os.PathLike "
-                        "object returning str, not %r"
-                        % type(a))
-        return cls._parse_parts(parts)
-
-    def __init__(self, *args):
-        drv, root, parts = self._parse_args(args)
+    def _load_parts(self):
+        drv, root, parts = self._parse_path(self._raw_path)
         self._drv = drv
         self._root = root
-        self._parts = parts
+        self._parts_cached = parts
+
+    def _from_parsed_parts(self, drv, root, parts):
+        path_str = self._format_parsed_parts(drv, root, parts)
+        path = self.makepath(path_str)
+        path._str = path_str or '.'
+        path._drv = drv
+        path._root = root
+        path._parts_cached = parts
+        return path
 
     @classmethod
     def _format_parsed_parts(cls, drv, root, parts):
@@ -477,7 +465,8 @@ def with_name(self, name):
         drv, root, tail = f.splitroot(name)
         if drv or root or not tail or f.sep in tail or (f.altsep and f.altsep in tail):
             raise ValueError("Invalid name %r" % (name))
-        return self.makepath(*self._parts[:-1], name)
+        return self._from_parsed_parts(self.drive, self.root,
+                                       self._parts[:-1] + [name])
 
     def with_stem(self, stem):
         """Return a new path with the stem changed."""
@@ -501,7 +490,8 @@ def with_suffix(self, suffix):
             name = name + suffix
         else:
             name = name[:-len(old_suffix)] + suffix
-        return self.makepath(*self._parts[:-1], name)
+        return self._from_parsed_parts(self.drive, self.root,
+                                       self._parts[:-1] + [name])
 
     def relative_to(self, other, /, *_deprecated, walk_up=False):
         """Return the relative path to another path identified by the passed
@@ -565,7 +555,7 @@ def joinpath(self, *args):
         paths) or a totally different path (if one of the arguments is
         anchored).
         """
-        return self.makepath(*self._parts, *args)
+        return self.makepath(self._raw_path, *args)
 
     def __truediv__(self, key):
         try:
@@ -575,7 +565,7 @@ def __truediv__(self, key):
 
     def __rtruediv__(self, key):
         try:
-            return self.makepath(key, *self._parts)
+            return self.makepath(key, self._raw_path)
         except TypeError:
             return NotImplemented
 
@@ -585,20 +575,19 @@ def parent(self):
         drv = self.drive
         root = self.root
         parts = self._parts
-        if len(parts) == 1 and (drv or root):
+        if len(parts) == bool(drv or root):
             return self
-        return self.makepath(*parts[:-1])
+        return self._from_parsed_parts(drv, root, parts[:-1])
 
     @property
     def parents(self):
         """A tuple of this path's logical parents."""
-        path = self
-        parent = self.parent
-        parents = []
-        while path != parent:
-            parents.append(parent)
-            path, parent = parent, parent.parent
-        return tuple(parents)
+        drv = self.drive
+        root = self.root
+        parts = self._parts
+        return tuple(
+            self._from_parsed_parts(drv, root, parts[:idx])
+            for idx in reversed(range(bool(drv or root), len(parts))))
 
     def is_absolute(self):
         """True if the path is absolute (has both a root and, if applicable,
@@ -692,11 +681,13 @@ def __init__(self, *args, **kwargs):
     def __new__(cls, *args, **kwargs):
         if cls is Path:
             cls = WindowsPath if os.name == 'nt' else PosixPath
-        self = super().__new__(cls)
-        if self._flavour is not os.path:
-            raise NotImplementedError("cannot instantiate %r on your system"
-                                      % (cls.__name__,))
-        return self
+        return object.__new__(cls)
+
+    def _make_child_relpath(self, part):
+        # This is an optimization used for dir walking.  `part` must be
+        # a single part relative to this path.
+        parts = self._parts + [part]
+        return self._from_parsed_parts(self.drive, self.root, parts)
 
     def __enter__(self):
         # In previous versions of pathlib, __exit__() marked this path as
@@ -751,7 +742,7 @@ def iterdir(self):
         special entries '.' and '..' are not included.
         """
         for name in os.listdir(self):
-            yield self.joinpath(name)
+            yield self._make_child_relpath(name)
 
     def _scandir(self):
         # bpo-24132: a future version of pathlib will support subclassing of
@@ -798,7 +789,12 @@ def absolute(self):
         """
         if self.is_absolute():
             return self
-        return self.makepath(os.getcwd(), *self._parts)
+        elif self.drive:
+            # There is a CWD on each drive-letter drive.
+            cwd = self._flavour.abspath(self.drive)
+        else:
+            cwd = os.getcwd()
+        return self.makepath(cwd, self._raw_path)
 
     def resolve(self, strict=False):
         """
@@ -1180,7 +1176,8 @@ def expanduser(self):
             homedir = self._flavour.expanduser(self._parts[0])
             if homedir[:1] == "~":
                 raise RuntimeError("Could not determine home directory.")
-            return self.makepath(homedir, *self._parts[1:])
+            drv, root, parts = self._parse_path(homedir)
+            return self._from_parsed_parts(drv, root, parts + self._parts[1:])
 
         return self
 
@@ -1222,9 +1219,10 @@ def walk(self, top_down=True, on_error=None, follow_symlinks=False):
                     else:
                         filenames.append(entry.name)
 
-        for dirname in dirnames:
-            dirpath = self.joinpath(dirname)
-            yield from dirpath._walk(top_down, on_error, follow_symlinks)
+            if top_down:
+                yield path, dirnames, filenames
+            else:
+                paths.append((path, dirnames, filenames))
 
             paths += [path._make_child_relpath(d) for d in reversed(dirnames)]