2024-01-13 04:47:00 -04:00
|
|
|
"""
|
|
|
|
Abstract base classes for rich path objects.
|
|
|
|
|
|
|
|
This module is published as a PyPI package called "pathlib-abc".
|
|
|
|
|
|
|
|
This module is also a *PRIVATE* part of the Python standard library, where
|
|
|
|
it's developed alongside pathlib. If it finds success and maturity as a PyPI
|
|
|
|
package, it could become a public part of the standard library.
|
|
|
|
|
|
|
|
Two base classes are defined here -- PurePathBase and PathBase -- that
|
|
|
|
resemble pathlib's PurePath and Path respectively.
|
|
|
|
"""
|
|
|
|
|
2013-11-22 12:38:12 -04:00
|
|
|
import functools
|
2024-06-07 13:59:34 -03:00
|
|
|
import operator
|
2024-06-05 14:54:50 -03:00
|
|
|
import posixpath
|
2024-06-07 13:59:34 -03:00
|
|
|
from glob import _GlobberBase, _no_recurse_symlinks
|
2013-11-22 12:38:12 -04:00
|
|
|
from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
|
2024-07-03 00:30:29 -03:00
|
|
|
from ._os import UnsupportedOperation, copyfileobj
|
2024-05-03 17:29:25 -03:00
|
|
|
|
2019-02-04 03:08:18 -04:00
|
|
|
|
2023-05-30 17:18:09 -03:00
|
|
|
@functools.cache
|
2024-03-31 15:14:48 -03:00
|
|
|
def _is_case_sensitive(parser):
|
|
|
|
return parser.normcase('Aa') == 'Aa'
|
2023-05-02 18:51:18 -03:00
|
|
|
|
2023-11-25 13:41:05 -04:00
|
|
|
|
2023-06-22 10:35:51 -03:00
|
|
|
|
2024-03-31 15:14:48 -03:00
|
|
|
class ParserBase:
|
|
|
|
"""Base class for path parsers, which do low-level path manipulation.
|
2024-01-14 17:49:53 -04:00
|
|
|
|
2024-03-31 15:14:48 -03:00
|
|
|
Path parsers provide a subset of the os.path API, specifically those
|
2024-01-14 17:49:53 -04:00
|
|
|
functions needed to provide PurePathBase functionality. Each PurePathBase
|
2024-03-31 15:14:48 -03:00
|
|
|
subclass references its path parser via a 'parser' class attribute.
|
2024-01-14 17:49:53 -04:00
|
|
|
|
|
|
|
Every method in this base class raises an UnsupportedOperation exception.
|
|
|
|
"""
|
|
|
|
|
|
|
|
@classmethod
|
2024-01-30 20:38:01 -04:00
|
|
|
def _unsupported_msg(cls, attribute):
|
|
|
|
return f"{cls.__name__}.{attribute} is unsupported"
|
2024-01-14 17:49:53 -04:00
|
|
|
|
|
|
|
@property
|
|
|
|
def sep(self):
|
|
|
|
"""The character used to separate path components."""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('sep'))
|
2024-01-14 17:49:53 -04:00
|
|
|
|
|
|
|
def join(self, path, *paths):
|
|
|
|
"""Join path segments."""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('join()'))
|
2024-01-14 17:49:53 -04:00
|
|
|
|
|
|
|
def split(self, path):
|
|
|
|
"""Split the path into a pair (head, tail), where *head* is everything
|
|
|
|
before the final path separator, and *tail* is everything after.
|
|
|
|
Either part may be empty.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('split()'))
|
2024-01-14 17:49:53 -04:00
|
|
|
|
2024-01-14 19:06:04 -04:00
|
|
|
def splitdrive(self, path):
|
|
|
|
"""Split the path into a 2-item tuple (drive, tail), where *drive* is
|
|
|
|
a device name or mount point, and *tail* is everything after the
|
|
|
|
drive. Either part may be empty."""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('splitdrive()'))
|
2024-01-14 17:49:53 -04:00
|
|
|
|
2024-05-25 17:01:36 -03:00
|
|
|
def splitext(self, path):
|
|
|
|
"""Split the path into a pair (root, ext), where *ext* is empty or
|
|
|
|
begins with a begins with a period and contains at most one period,
|
|
|
|
and *root* is everything before the extension."""
|
|
|
|
raise UnsupportedOperation(self._unsupported_msg('splitext()'))
|
|
|
|
|
2024-01-14 17:49:53 -04:00
|
|
|
def normcase(self, path):
|
|
|
|
"""Normalize the case of the path."""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('normcase()'))
|
2024-01-14 17:49:53 -04:00
|
|
|
|
|
|
|
def isabs(self, path):
|
|
|
|
"""Returns whether the path is absolute, i.e. unaffected by the
|
|
|
|
current directory or drive."""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('isabs()'))
|
2024-01-14 17:49:53 -04:00
|
|
|
|
|
|
|
|
2024-06-07 13:59:34 -03:00
|
|
|
class PathGlobber(_GlobberBase):
|
|
|
|
"""
|
|
|
|
Class providing shell-style globbing for path objects.
|
|
|
|
"""
|
|
|
|
|
|
|
|
lexists = operator.methodcaller('exists', follow_symlinks=False)
|
|
|
|
add_slash = operator.methodcaller('joinpath', '')
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def scandir(path):
|
|
|
|
"""Emulates os.scandir(), which returns an object that can be used as
|
|
|
|
a context manager. This method is called by walk() and glob().
|
|
|
|
"""
|
|
|
|
import contextlib
|
|
|
|
return contextlib.nullcontext(path.iterdir())
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def concat_path(path, text):
|
|
|
|
"""Appends text to the given path."""
|
|
|
|
return path.with_segments(path._raw_path + text)
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def parse_entry(entry):
|
|
|
|
"""Returns the path of an entry yielded from scandir()."""
|
|
|
|
return entry
|
|
|
|
|
|
|
|
|
2023-12-09 11:07:40 -04:00
|
|
|
class PurePathBase:
|
GH-110109: Add `pathlib._PurePathBase` (#110670)
Add private `pathlib._PurePathBase` class: a private superclass of both `PurePath` and `_PathBase`. Unlike `PurePath`, it does not define any of these special methods: `__fspath__`, `__bytes__`, `__reduce__`, `__hash__`, `__eq__`, `__lt__`, `__le__`, `__gt__`, `__ge__`. Its initializer and path joining methods accept only strings, not os.PathLike objects more broadly.
This is important for supporting *virtual paths*: user subclasses of `_PathBase` that provide access to archive files, FTP servers, etc. In these classes, the above methods should be implemented by users only as appropriate, with due consideration for the hash/equality of any backing objects, such as file objects or sockets.
2023-12-08 13:39:04 -04:00
|
|
|
"""Base class for pure path objects.
|
2018-02-18 19:36:32 -04:00
|
|
|
|
GH-110109: Add `pathlib._PurePathBase` (#110670)
Add private `pathlib._PurePathBase` class: a private superclass of both `PurePath` and `_PathBase`. Unlike `PurePath`, it does not define any of these special methods: `__fspath__`, `__bytes__`, `__reduce__`, `__hash__`, `__eq__`, `__lt__`, `__le__`, `__gt__`, `__ge__`. Its initializer and path joining methods accept only strings, not os.PathLike objects more broadly.
This is important for supporting *virtual paths*: user subclasses of `_PathBase` that provide access to archive files, FTP servers, etc. In these classes, the above methods should be implemented by users only as appropriate, with due consideration for the hash/equality of any backing objects, such as file objects or sockets.
2023-12-08 13:39:04 -04:00
|
|
|
This class *does not* provide several magic methods that are defined in
|
|
|
|
its subclass PurePath. They are: __fspath__, __bytes__, __reduce__,
|
|
|
|
__hash__, __eq__, __lt__, __le__, __gt__, __ge__. Its initializer and path
|
|
|
|
joining methods accept only strings, not os.PathLike objects more broadly.
|
2013-11-22 12:38:12 -04:00
|
|
|
"""
|
2023-04-09 14:40:03 -03:00
|
|
|
|
2013-11-22 12:38:12 -04:00
|
|
|
__slots__ = (
|
2024-01-14 17:49:53 -04:00
|
|
|
# The `_raw_path` slot store a joined string path. This is set in the
|
|
|
|
# `__init__()` method.
|
|
|
|
'_raw_path',
|
2023-04-09 14:40:03 -03:00
|
|
|
|
2023-09-30 11:45:01 -03:00
|
|
|
# The '_resolving' slot stores a boolean indicating whether the path
|
2023-12-09 11:07:40 -04:00
|
|
|
# is being processed by `PathBase.resolve()`. This prevents duplicate
|
2023-09-30 11:45:01 -03:00
|
|
|
# work from occurring when `resolve()` calls `stat()` or `readlink()`.
|
|
|
|
'_resolving',
|
2013-11-22 12:38:12 -04:00
|
|
|
)
|
2024-03-31 15:14:48 -03:00
|
|
|
parser = ParserBase()
|
2024-06-07 13:59:34 -03:00
|
|
|
_globber = PathGlobber
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2024-01-14 17:49:53 -04:00
|
|
|
def __init__(self, path, *paths):
|
2024-03-31 15:14:48 -03:00
|
|
|
self._raw_path = self.parser.join(path, *paths) if paths else path
|
2024-01-30 20:59:33 -04:00
|
|
|
if not isinstance(self._raw_path, str):
|
|
|
|
raise TypeError(
|
|
|
|
f"path should be a str, not {type(self._raw_path).__name__!r}")
|
GH-110109: Add `pathlib._PurePathBase` (#110670)
Add private `pathlib._PurePathBase` class: a private superclass of both `PurePath` and `_PathBase`. Unlike `PurePath`, it does not define any of these special methods: `__fspath__`, `__bytes__`, `__reduce__`, `__hash__`, `__eq__`, `__lt__`, `__le__`, `__gt__`, `__ge__`. Its initializer and path joining methods accept only strings, not os.PathLike objects more broadly.
This is important for supporting *virtual paths*: user subclasses of `_PathBase` that provide access to archive files, FTP servers, etc. In these classes, the above methods should be implemented by users only as appropriate, with due consideration for the hash/equality of any backing objects, such as file objects or sockets.
2023-12-08 13:39:04 -04:00
|
|
|
self._resolving = False
|
|
|
|
|
2023-05-05 16:04:53 -03:00
|
|
|
def with_segments(self, *pathsegments):
|
|
|
|
"""Construct a new path object from any number of path-like objects.
|
|
|
|
Subclasses may override this method to customize how new path objects
|
|
|
|
are created from methods like `iterdir()`.
|
|
|
|
"""
|
|
|
|
return type(self)(*pathsegments)
|
|
|
|
|
2013-11-22 12:38:12 -04:00
|
|
|
def __str__(self):
|
|
|
|
"""Return the string representation of the path, suitable for
|
|
|
|
passing to system calls."""
|
2024-01-13 04:03:21 -04:00
|
|
|
return self._raw_path
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
def as_posix(self):
|
|
|
|
"""Return the string representation of the path with forward (/)
|
|
|
|
slashes."""
|
2024-03-31 15:14:48 -03:00
|
|
|
return str(self).replace(self.parser.sep, '/')
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2023-04-03 15:57:11 -03:00
|
|
|
@property
|
|
|
|
def drive(self):
|
|
|
|
"""The drive prefix (letter or UNC path), if any."""
|
2024-03-31 15:14:48 -03:00
|
|
|
return self.parser.splitdrive(self.anchor)[0]
|
2023-04-03 15:57:11 -03:00
|
|
|
|
|
|
|
@property
|
|
|
|
def root(self):
|
|
|
|
"""The root of the path, if any."""
|
2024-03-31 15:14:48 -03:00
|
|
|
return self.parser.splitdrive(self.anchor)[1]
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
@property
|
|
|
|
def anchor(self):
|
|
|
|
"""The concatenation of the drive and root, or ''."""
|
2024-01-14 19:06:04 -04:00
|
|
|
return self._stack[0]
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
@property
|
|
|
|
def name(self):
|
|
|
|
"""The final path component, if any."""
|
2024-03-31 15:14:48 -03:00
|
|
|
return self.parser.split(self._raw_path)[1]
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
@property
|
|
|
|
def suffix(self):
|
2019-11-02 13:46:24 -03:00
|
|
|
"""
|
|
|
|
The final component's last suffix, if any.
|
|
|
|
|
|
|
|
This includes the leading period. For example: '.txt'
|
|
|
|
"""
|
2024-05-25 17:01:36 -03:00
|
|
|
return self.parser.splitext(self.name)[1]
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
@property
|
|
|
|
def suffixes(self):
|
2019-11-02 13:46:24 -03:00
|
|
|
"""
|
|
|
|
A list of the final component's suffixes, if any.
|
|
|
|
|
|
|
|
These include the leading periods. For example: ['.tar', '.gz']
|
|
|
|
"""
|
2024-05-25 17:01:36 -03:00
|
|
|
split = self.parser.splitext
|
|
|
|
stem, suffix = split(self.name)
|
|
|
|
suffixes = []
|
|
|
|
while suffix:
|
|
|
|
suffixes.append(suffix)
|
|
|
|
stem, suffix = split(stem)
|
|
|
|
return suffixes[::-1]
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
@property
|
|
|
|
def stem(self):
|
|
|
|
"""The final path component, minus its last suffix."""
|
2024-05-25 17:01:36 -03:00
|
|
|
return self.parser.splitext(self.name)[0]
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
def with_name(self, name):
|
|
|
|
"""Return a new path with the file name changed."""
|
2024-03-31 15:14:48 -03:00
|
|
|
split = self.parser.split
|
2024-01-14 17:49:53 -04:00
|
|
|
if split(name)[0]:
|
2023-11-25 13:19:38 -04:00
|
|
|
raise ValueError(f"Invalid name {name!r}")
|
2024-01-14 17:49:53 -04:00
|
|
|
return self.with_segments(split(self._raw_path)[0], name)
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2020-04-19 12:29:49 -03:00
|
|
|
def with_stem(self, stem):
|
|
|
|
"""Return a new path with the stem changed."""
|
2024-02-24 15:37:03 -04:00
|
|
|
suffix = self.suffix
|
|
|
|
if not suffix:
|
|
|
|
return self.with_name(stem)
|
|
|
|
elif not stem:
|
|
|
|
# If the suffix is non-empty, we can't make the stem empty.
|
|
|
|
raise ValueError(f"{self!r} has a non-empty suffix")
|
|
|
|
else:
|
|
|
|
return self.with_name(stem + suffix)
|
2020-04-19 12:29:49 -03:00
|
|
|
|
2013-11-22 12:38:12 -04:00
|
|
|
def with_suffix(self, suffix):
|
2018-08-03 17:49:42 -03:00
|
|
|
"""Return a new path with the file suffix changed. If the path
|
|
|
|
has no suffix, add given suffix. If the given suffix is an empty
|
|
|
|
string, remove the suffix from the path.
|
|
|
|
"""
|
2024-01-30 10:25:16 -04:00
|
|
|
stem = self.stem
|
2024-05-19 13:04:56 -03:00
|
|
|
if not stem:
|
2024-02-24 15:37:03 -04:00
|
|
|
# If the stem is empty, we can't make the suffix non-empty.
|
2024-01-30 10:25:16 -04:00
|
|
|
raise ValueError(f"{self!r} has an empty name")
|
2024-05-25 17:01:36 -03:00
|
|
|
elif suffix and not suffix.startswith('.'):
|
2023-11-25 13:19:38 -04:00
|
|
|
raise ValueError(f"Invalid suffix {suffix!r}")
|
2024-05-19 13:04:56 -03:00
|
|
|
else:
|
|
|
|
return self.with_name(stem + suffix)
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2024-01-05 18:56:04 -04:00
|
|
|
def relative_to(self, other, *, walk_up=False):
|
2013-11-22 12:38:12 -04:00
|
|
|
"""Return the relative path to another path identified by the passed
|
|
|
|
arguments. If the operation is not possible (because this is not
|
2022-10-28 20:20:14 -03:00
|
|
|
related to the other path), raise ValueError.
|
|
|
|
|
|
|
|
The *walk_up* parameter controls whether `..` may be used to resolve
|
|
|
|
the path.
|
2013-11-22 12:38:12 -04:00
|
|
|
"""
|
2024-01-05 18:56:04 -04:00
|
|
|
if not isinstance(other, PurePathBase):
|
2023-11-12 18:59:17 -04:00
|
|
|
other = self.with_segments(other)
|
2024-01-09 19:04:14 -04:00
|
|
|
anchor0, parts0 = self._stack
|
|
|
|
anchor1, parts1 = other._stack
|
|
|
|
if anchor0 != anchor1:
|
2024-01-13 04:03:21 -04:00
|
|
|
raise ValueError(f"{self._raw_path!r} and {other._raw_path!r} have different anchors")
|
2024-01-09 19:04:14 -04:00
|
|
|
while parts0 and parts1 and parts0[-1] == parts1[-1]:
|
|
|
|
parts0.pop()
|
|
|
|
parts1.pop()
|
|
|
|
for part in parts1:
|
|
|
|
if not part or part == '.':
|
|
|
|
pass
|
2023-07-26 16:44:55 -03:00
|
|
|
elif not walk_up:
|
2024-01-13 04:03:21 -04:00
|
|
|
raise ValueError(f"{self._raw_path!r} is not in the subpath of {other._raw_path!r}")
|
2024-01-09 19:04:14 -04:00
|
|
|
elif part == '..':
|
2024-01-13 04:03:21 -04:00
|
|
|
raise ValueError(f"'..' segment in {other._raw_path!r} cannot be walked")
|
2024-01-09 19:04:14 -04:00
|
|
|
else:
|
|
|
|
parts0.append('..')
|
|
|
|
return self.with_segments('', *reversed(parts0))
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2024-01-05 18:56:04 -04:00
|
|
|
def is_relative_to(self, other):
|
2019-08-13 16:54:02 -03:00
|
|
|
"""Return True if the path is relative to another path or False.
|
|
|
|
"""
|
2024-01-05 18:56:04 -04:00
|
|
|
if not isinstance(other, PurePathBase):
|
2023-11-12 18:59:17 -04:00
|
|
|
other = self.with_segments(other)
|
2024-01-09 19:04:14 -04:00
|
|
|
anchor0, parts0 = self._stack
|
|
|
|
anchor1, parts1 = other._stack
|
|
|
|
if anchor0 != anchor1:
|
|
|
|
return False
|
|
|
|
while parts0 and parts1 and parts0[-1] == parts1[-1]:
|
|
|
|
parts0.pop()
|
|
|
|
parts1.pop()
|
|
|
|
for part in parts1:
|
|
|
|
if part and part != '.':
|
|
|
|
return False
|
|
|
|
return True
|
2019-08-13 16:54:02 -03:00
|
|
|
|
2013-11-22 12:38:12 -04:00
|
|
|
@property
|
|
|
|
def parts(self):
|
|
|
|
"""An object providing sequence-like access to the
|
|
|
|
components in the filesystem path."""
|
2024-01-09 18:46:50 -04:00
|
|
|
anchor, parts = self._stack
|
|
|
|
if anchor:
|
|
|
|
parts.append(anchor)
|
|
|
|
return tuple(reversed(parts))
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2023-05-05 16:04:53 -03:00
|
|
|
def joinpath(self, *pathsegments):
|
2013-11-22 12:38:12 -04:00
|
|
|
"""Combine this path with one or several arguments, and return a
|
|
|
|
new path representing either a subpath (if all arguments are relative
|
|
|
|
paths) or a totally different path (if one of the arguments is
|
|
|
|
anchored).
|
|
|
|
"""
|
2024-01-14 17:49:53 -04:00
|
|
|
return self.with_segments(self._raw_path, *pathsegments)
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
def __truediv__(self, key):
|
2019-08-08 02:41:10 -03:00
|
|
|
try:
|
2024-01-14 17:49:53 -04:00
|
|
|
return self.with_segments(self._raw_path, key)
|
2019-08-08 02:41:10 -03:00
|
|
|
except TypeError:
|
|
|
|
return NotImplemented
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
def __rtruediv__(self, key):
|
2019-08-08 02:41:10 -03:00
|
|
|
try:
|
2024-01-14 17:49:53 -04:00
|
|
|
return self.with_segments(key, self._raw_path)
|
2019-08-08 02:41:10 -03:00
|
|
|
except TypeError:
|
|
|
|
return NotImplemented
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2024-01-09 15:50:23 -04:00
|
|
|
@property
|
|
|
|
def _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.
|
|
|
|
"""
|
2024-03-31 15:14:48 -03:00
|
|
|
split = self.parser.split
|
2024-01-13 04:03:21 -04:00
|
|
|
path = self._raw_path
|
2024-01-09 15:50:23 -04:00
|
|
|
parent, name = split(path)
|
|
|
|
names = []
|
|
|
|
while path != parent:
|
|
|
|
names.append(name)
|
|
|
|
path = parent
|
|
|
|
parent, name = split(path)
|
|
|
|
return path, names
|
|
|
|
|
2013-11-22 12:38:12 -04:00
|
|
|
@property
|
|
|
|
def parent(self):
|
|
|
|
"""The logical parent of the path."""
|
2024-01-13 04:03:21 -04:00
|
|
|
path = self._raw_path
|
2024-03-31 15:14:48 -03:00
|
|
|
parent = self.parser.split(path)[0]
|
2024-01-06 17:17:51 -04:00
|
|
|
if path != parent:
|
|
|
|
parent = self.with_segments(parent)
|
|
|
|
parent._resolving = self._resolving
|
|
|
|
return parent
|
|
|
|
return self
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
@property
|
|
|
|
def parents(self):
|
|
|
|
"""A sequence of this path's logical parents."""
|
2024-03-31 15:14:48 -03:00
|
|
|
split = self.parser.split
|
2024-01-13 04:03:21 -04:00
|
|
|
path = self._raw_path
|
2024-01-14 17:49:53 -04:00
|
|
|
parent = split(path)[0]
|
2024-01-06 17:17:51 -04:00
|
|
|
parents = []
|
|
|
|
while path != parent:
|
|
|
|
parents.append(self.with_segments(parent))
|
|
|
|
path = parent
|
2024-01-14 17:49:53 -04:00
|
|
|
parent = split(path)[0]
|
2024-01-06 17:17:51 -04:00
|
|
|
return tuple(parents)
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
def is_absolute(self):
|
|
|
|
"""True if the path is absolute (has both a root and, if applicable,
|
|
|
|
a drive)."""
|
2024-03-31 15:14:48 -03:00
|
|
|
return self.parser.isabs(self._raw_path)
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2024-01-25 21:12:46 -04:00
|
|
|
@property
|
|
|
|
def _pattern_str(self):
|
|
|
|
"""The path expressed as a string, for use in pattern-matching."""
|
|
|
|
return str(self)
|
|
|
|
|
2023-05-18 14:59:31 -03:00
|
|
|
def match(self, path_pattern, *, case_sensitive=None):
|
2013-11-22 12:38:12 -04:00
|
|
|
"""
|
2024-01-25 21:12:46 -04:00
|
|
|
Return True if this path matches the given pattern. If the pattern is
|
|
|
|
relative, matching is done from the right; otherwise, the entire path
|
|
|
|
is matched. The recursive wildcard '**' is *not* supported by this
|
|
|
|
method.
|
2013-11-22 12:38:12 -04:00
|
|
|
"""
|
2023-12-09 11:07:40 -04:00
|
|
|
if not isinstance(path_pattern, PurePathBase):
|
2023-05-30 17:18:09 -03:00
|
|
|
path_pattern = self.with_segments(path_pattern)
|
2023-05-18 14:59:31 -03:00
|
|
|
if case_sensitive is None:
|
2024-03-31 15:14:48 -03:00
|
|
|
case_sensitive = _is_case_sensitive(self.parser)
|
|
|
|
sep = path_pattern.parser.sep
|
2024-01-25 21:12:46 -04:00
|
|
|
path_parts = self.parts[::-1]
|
|
|
|
pattern_parts = path_pattern.parts[::-1]
|
|
|
|
if not pattern_parts:
|
2013-11-22 12:38:12 -04:00
|
|
|
raise ValueError("empty pattern")
|
2024-01-25 21:12:46 -04:00
|
|
|
if len(path_parts) < len(pattern_parts):
|
|
|
|
return False
|
|
|
|
if len(path_parts) > len(pattern_parts) and path_pattern.anchor:
|
|
|
|
return False
|
2024-04-10 16:43:07 -03:00
|
|
|
globber = self._globber(sep, case_sensitive)
|
2024-01-25 21:12:46 -04:00
|
|
|
for path_part, pattern_part in zip(path_parts, pattern_parts):
|
2024-04-10 16:43:07 -03:00
|
|
|
match = globber.compile(pattern_part)
|
2024-01-25 21:12:46 -04:00
|
|
|
if match(path_part) is None:
|
|
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
|
|
def full_match(self, pattern, *, case_sensitive=None):
|
|
|
|
"""
|
|
|
|
Return True if this path matches the given glob-style pattern. The
|
|
|
|
pattern is matched against the entire path.
|
|
|
|
"""
|
|
|
|
if not isinstance(pattern, PurePathBase):
|
|
|
|
pattern = self.with_segments(pattern)
|
|
|
|
if case_sensitive is None:
|
2024-03-31 15:14:48 -03:00
|
|
|
case_sensitive = _is_case_sensitive(self.parser)
|
2024-04-10 16:43:07 -03:00
|
|
|
globber = self._globber(pattern.parser.sep, case_sensitive, recursive=True)
|
|
|
|
match = globber.compile(pattern._pattern_str)
|
2024-01-25 21:12:46 -04:00
|
|
|
return match(self._pattern_str) is not None
|
2023-05-30 17:18:09 -03:00
|
|
|
|
GH-110109: Add `pathlib._PurePathBase` (#110670)
Add private `pathlib._PurePathBase` class: a private superclass of both `PurePath` and `_PathBase`. Unlike `PurePath`, it does not define any of these special methods: `__fspath__`, `__bytes__`, `__reduce__`, `__hash__`, `__eq__`, `__lt__`, `__le__`, `__gt__`, `__ge__`. Its initializer and path joining methods accept only strings, not os.PathLike objects more broadly.
This is important for supporting *virtual paths*: user subclasses of `_PathBase` that provide access to archive files, FTP servers, etc. In these classes, the above methods should be implemented by users only as appropriate, with due consideration for the hash/equality of any backing objects, such as file objects or sockets.
2023-12-08 13:39:04 -04:00
|
|
|
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2023-12-09 11:07:40 -04:00
|
|
|
class PathBase(PurePathBase):
|
2023-09-30 11:45:01 -03:00
|
|
|
"""Base class for concrete path objects.
|
2018-02-18 19:36:32 -04:00
|
|
|
|
2023-09-30 11:45:01 -03:00
|
|
|
This class provides dummy implementations for many methods that derived
|
|
|
|
classes can override selectively; the default implementations raise
|
|
|
|
UnsupportedOperation. The most basic methods, such as stat() and open(),
|
|
|
|
directly raise UnsupportedOperation; these basic methods are called by
|
|
|
|
other methods such as is_dir() and read_text().
|
|
|
|
|
|
|
|
The Path class derives this class to implement local filesystem paths.
|
|
|
|
Users may derive their own classes to implement virtual filesystem paths,
|
|
|
|
such as paths in archive files or on remote storage systems.
|
2018-02-18 19:36:32 -04:00
|
|
|
"""
|
2021-04-06 21:26:37 -03:00
|
|
|
__slots__ = ()
|
2023-09-30 11:45:01 -03:00
|
|
|
|
2024-01-08 15:31:52 -04:00
|
|
|
# Maximum number of symlinks to follow in resolve()
|
|
|
|
_max_symlinks = 40
|
|
|
|
|
2023-10-01 12:14:02 -03:00
|
|
|
@classmethod
|
2024-01-30 20:38:01 -04:00
|
|
|
def _unsupported_msg(cls, attribute):
|
|
|
|
return f"{cls.__name__}.{attribute} is unsupported"
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2023-05-07 16:07:07 -03:00
|
|
|
def stat(self, *, follow_symlinks=True):
|
|
|
|
"""
|
|
|
|
Return the result of the stat() system call on this path, like
|
|
|
|
os.stat() does.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('stat()'))
|
2023-04-03 15:57:11 -03:00
|
|
|
|
2023-05-07 16:07:07 -03:00
|
|
|
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)
|
2013-11-22 12:38:12 -04:00
|
|
|
|
|
|
|
|
2023-05-07 16:07:07 -03:00
|
|
|
# Convenience functions for querying the stat results
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2023-05-07 16:07:07 -03:00
|
|
|
def exists(self, *, follow_symlinks=True):
|
|
|
|
"""
|
|
|
|
Whether this path exists.
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2023-05-07 16:07:07 -03:00
|
|
|
This method normally follows symlinks; to check whether a symlink exists,
|
|
|
|
add the argument follow_symlinks=False.
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
self.stat(follow_symlinks=follow_symlinks)
|
2024-05-14 14:53:15 -03:00
|
|
|
except (OSError, ValueError):
|
2023-05-07 16:07:07 -03:00
|
|
|
return False
|
|
|
|
return True
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2023-06-26 13:58:17 -03:00
|
|
|
def is_dir(self, *, follow_symlinks=True):
|
2023-05-07 16:07:07 -03:00
|
|
|
"""
|
|
|
|
Whether this path is a directory.
|
|
|
|
"""
|
|
|
|
try:
|
2023-06-26 13:58:17 -03:00
|
|
|
return S_ISDIR(self.stat(follow_symlinks=follow_symlinks).st_mode)
|
2024-05-14 14:53:15 -03:00
|
|
|
except (OSError, ValueError):
|
2023-05-07 16:07:07 -03:00
|
|
|
return False
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2023-06-26 13:58:17 -03:00
|
|
|
def is_file(self, *, follow_symlinks=True):
|
2015-01-12 16:03:41 -04:00
|
|
|
"""
|
2023-05-07 16:07:07 -03:00
|
|
|
Whether this path is a regular file (also True for symlinks pointing
|
|
|
|
to regular files).
|
|
|
|
"""
|
|
|
|
try:
|
2023-06-26 13:58:17 -03:00
|
|
|
return S_ISREG(self.stat(follow_symlinks=follow_symlinks).st_mode)
|
2024-05-14 14:53:15 -03:00
|
|
|
except (OSError, ValueError):
|
2023-05-07 16:07:07 -03:00
|
|
|
return False
|
|
|
|
|
|
|
|
def is_mount(self):
|
|
|
|
"""
|
|
|
|
Check if this path is a mount point
|
|
|
|
"""
|
2023-09-30 11:45:01 -03:00
|
|
|
# Need to exist and be a dir
|
|
|
|
if not self.exists() or not self.is_dir():
|
|
|
|
return False
|
|
|
|
|
|
|
|
try:
|
|
|
|
parent_dev = self.parent.stat().st_dev
|
|
|
|
except OSError:
|
|
|
|
return False
|
|
|
|
|
|
|
|
dev = self.stat().st_dev
|
|
|
|
if dev != parent_dev:
|
|
|
|
return True
|
|
|
|
ino = self.stat().st_ino
|
|
|
|
parent_ino = self.parent.stat().st_ino
|
|
|
|
return ino == parent_ino
|
2023-05-07 16:07:07 -03:00
|
|
|
|
|
|
|
def is_symlink(self):
|
|
|
|
"""
|
|
|
|
Whether this path is a symbolic link.
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
return S_ISLNK(self.lstat().st_mode)
|
2024-05-14 14:53:15 -03:00
|
|
|
except (OSError, ValueError):
|
2023-05-07 16:07:07 -03:00
|
|
|
return False
|
|
|
|
|
|
|
|
def is_junction(self):
|
|
|
|
"""
|
|
|
|
Whether this path is a junction.
|
|
|
|
"""
|
2023-09-30 11:45:01 -03:00
|
|
|
# Junctions are a Windows-only feature, not present in POSIX nor the
|
|
|
|
# majority of virtual filesystems. There is no cross-platform idiom
|
|
|
|
# to check for junctions (using stat().st_mode).
|
|
|
|
return False
|
2023-05-07 16:07:07 -03:00
|
|
|
|
|
|
|
def is_block_device(self):
|
|
|
|
"""
|
|
|
|
Whether this path is a block device.
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
return S_ISBLK(self.stat().st_mode)
|
2024-05-14 14:53:15 -03:00
|
|
|
except (OSError, ValueError):
|
2023-05-07 16:07:07 -03:00
|
|
|
return False
|
|
|
|
|
|
|
|
def is_char_device(self):
|
|
|
|
"""
|
|
|
|
Whether this path is a character device.
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
return S_ISCHR(self.stat().st_mode)
|
2024-05-14 14:53:15 -03:00
|
|
|
except (OSError, ValueError):
|
2023-05-07 16:07:07 -03:00
|
|
|
return False
|
|
|
|
|
|
|
|
def is_fifo(self):
|
|
|
|
"""
|
|
|
|
Whether this path is a FIFO.
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
return S_ISFIFO(self.stat().st_mode)
|
2024-05-14 14:53:15 -03:00
|
|
|
except (OSError, ValueError):
|
2023-05-07 16:07:07 -03:00
|
|
|
return False
|
|
|
|
|
|
|
|
def is_socket(self):
|
|
|
|
"""
|
|
|
|
Whether this path is a socket.
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
return S_ISSOCK(self.stat().st_mode)
|
2024-05-14 14:53:15 -03:00
|
|
|
except (OSError, ValueError):
|
2023-05-07 16:07:07 -03:00
|
|
|
return False
|
2015-01-12 16:03:41 -04:00
|
|
|
|
2014-05-13 05:50:15 -03:00
|
|
|
def samefile(self, other_path):
|
2015-10-21 21:34:16 -03:00
|
|
|
"""Return whether other_path is the same or not as this file
|
2015-10-21 14:10:24 -03:00
|
|
|
(as returned by os.path.samefile()).
|
2014-05-13 05:50:15 -03:00
|
|
|
"""
|
|
|
|
st = self.stat()
|
|
|
|
try:
|
|
|
|
other_st = other_path.stat()
|
|
|
|
except AttributeError:
|
2023-05-05 16:04:53 -03:00
|
|
|
other_st = self.with_segments(other_path).stat()
|
2023-07-19 14:59:55 -03:00
|
|
|
return (st.st_ino == other_st.st_ino and
|
|
|
|
st.st_dev == other_st.st_dev)
|
2014-05-13 05:50:15 -03:00
|
|
|
|
2024-06-14 13:15:49 -03:00
|
|
|
def _samefile_safe(self, other_path):
|
|
|
|
"""
|
|
|
|
Like samefile(), but returns False rather than raising OSError.
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
return self.samefile(other_path)
|
|
|
|
except (OSError, ValueError):
|
|
|
|
return False
|
|
|
|
|
2023-05-07 16:07:07 -03:00
|
|
|
def open(self, mode='r', buffering=-1, encoding=None,
|
|
|
|
errors=None, newline=None):
|
|
|
|
"""
|
2024-05-02 02:37:12 -03:00
|
|
|
Open the file pointed to by this path and return a file object, as
|
2023-05-07 16:07:07 -03:00
|
|
|
the built-in open() function does.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('open()'))
|
2023-05-07 16:07:07 -03:00
|
|
|
|
|
|
|
def read_bytes(self):
|
|
|
|
"""
|
|
|
|
Open the file in bytes mode, read it, and close the file.
|
|
|
|
"""
|
|
|
|
with self.open(mode='rb') as f:
|
|
|
|
return f.read()
|
|
|
|
|
2023-11-21 18:32:38 -04:00
|
|
|
def read_text(self, encoding=None, errors=None, newline=None):
|
2023-05-07 16:07:07 -03:00
|
|
|
"""
|
|
|
|
Open the file in text mode, read it, and close the file.
|
|
|
|
"""
|
2023-11-21 18:32:38 -04:00
|
|
|
with self.open(mode='r', encoding=encoding, errors=errors, newline=newline) as f:
|
2023-05-07 16:07:07 -03:00
|
|
|
return f.read()
|
|
|
|
|
|
|
|
def write_bytes(self, data):
|
|
|
|
"""
|
|
|
|
Open the file in bytes mode, write to it, and close the file.
|
|
|
|
"""
|
|
|
|
# type-check for the buffer interface before truncating the file
|
|
|
|
view = memoryview(data)
|
|
|
|
with self.open(mode='wb') as f:
|
|
|
|
return f.write(view)
|
|
|
|
|
|
|
|
def write_text(self, data, encoding=None, errors=None, newline=None):
|
|
|
|
"""
|
|
|
|
Open the file in text mode, write to it, and close the file.
|
|
|
|
"""
|
|
|
|
if not isinstance(data, str):
|
|
|
|
raise TypeError('data must be str, not %s' %
|
|
|
|
data.__class__.__name__)
|
|
|
|
with self.open(mode='w', encoding=encoding, errors=errors, newline=newline) as f:
|
|
|
|
return f.write(data)
|
|
|
|
|
2013-11-22 12:38:12 -04:00
|
|
|
def iterdir(self):
|
2022-11-09 18:05:07 -04:00
|
|
|
"""Yield path objects of the directory contents.
|
|
|
|
|
|
|
|
The children are yielded in arbitrary order, and the
|
|
|
|
special entries '.' and '..' are not included.
|
2013-11-22 12:38:12 -04:00
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('iterdir()'))
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2024-04-10 16:43:07 -03:00
|
|
|
def _glob_selector(self, parts, case_sensitive, recurse_symlinks):
|
|
|
|
if case_sensitive is None:
|
|
|
|
case_sensitive = _is_case_sensitive(self.parser)
|
2024-04-12 18:19:21 -03:00
|
|
|
case_pedantic = False
|
|
|
|
else:
|
|
|
|
# The user has expressed a case sensitivity choice, but we don't
|
|
|
|
# know the case sensitivity of the underlying filesystem, so we
|
|
|
|
# must use scandir() for everything, including non-wildcard parts.
|
|
|
|
case_pedantic = True
|
2024-05-06 21:32:48 -03:00
|
|
|
recursive = True if recurse_symlinks else _no_recurse_symlinks
|
2024-04-12 18:19:21 -03:00
|
|
|
globber = self._globber(self.parser.sep, case_sensitive, case_pedantic, recursive)
|
2024-04-10 16:43:07 -03:00
|
|
|
return globber.selector(parts)
|
|
|
|
|
2024-04-05 15:51:54 -03:00
|
|
|
def glob(self, pattern, *, case_sensitive=None, recurse_symlinks=True):
|
2013-11-22 12:38:12 -04:00
|
|
|
"""Iterate over this subtree and yield all existing files (of any
|
2019-02-11 06:47:09 -04:00
|
|
|
kind, including directories) matching the given relative pattern.
|
2013-11-22 12:38:12 -04:00
|
|
|
"""
|
2024-01-19 22:10:25 -04:00
|
|
|
if not isinstance(pattern, PurePathBase):
|
|
|
|
pattern = self.with_segments(pattern)
|
2024-04-10 16:43:07 -03:00
|
|
|
anchor, parts = pattern._stack
|
|
|
|
if anchor:
|
|
|
|
raise NotImplementedError("Non-relative patterns are unsupported")
|
|
|
|
select = self._glob_selector(parts, case_sensitive, recurse_symlinks)
|
2024-04-13 20:08:03 -03:00
|
|
|
return select(self)
|
2013-11-22 12:38:12 -04:00
|
|
|
|
2024-04-05 15:51:54 -03:00
|
|
|
def rglob(self, pattern, *, case_sensitive=None, recurse_symlinks=True):
|
2024-01-05 17:41:19 -04:00
|
|
|
"""Recursively yield all existing files (of any kind, including
|
|
|
|
directories) matching the given relative pattern, anywhere in
|
|
|
|
this subtree.
|
|
|
|
"""
|
2024-01-19 22:10:25 -04:00
|
|
|
if not isinstance(pattern, PurePathBase):
|
|
|
|
pattern = self.with_segments(pattern)
|
|
|
|
pattern = '**' / pattern
|
2024-04-05 15:51:54 -03:00
|
|
|
return self.glob(pattern, case_sensitive=case_sensitive, recurse_symlinks=recurse_symlinks)
|
2024-01-05 17:41:19 -04:00
|
|
|
|
2023-05-07 16:07:07 -03:00
|
|
|
def walk(self, top_down=True, on_error=None, follow_symlinks=False):
|
|
|
|
"""Walk the directory tree from this directory, similar to os.walk()."""
|
2024-05-29 17:51:04 -03:00
|
|
|
paths = [self]
|
|
|
|
while paths:
|
|
|
|
path = paths.pop()
|
|
|
|
if isinstance(path, tuple):
|
|
|
|
yield path
|
|
|
|
continue
|
|
|
|
dirnames = []
|
|
|
|
filenames = []
|
|
|
|
if not top_down:
|
|
|
|
paths.append((path, dirnames, filenames))
|
|
|
|
try:
|
|
|
|
for child in path.iterdir():
|
|
|
|
try:
|
|
|
|
if child.is_dir(follow_symlinks=follow_symlinks):
|
|
|
|
if not top_down:
|
|
|
|
paths.append(child)
|
|
|
|
dirnames.append(child.name)
|
|
|
|
else:
|
|
|
|
filenames.append(child.name)
|
|
|
|
except OSError:
|
|
|
|
filenames.append(child.name)
|
|
|
|
except OSError as error:
|
|
|
|
if on_error is not None:
|
|
|
|
on_error(error)
|
|
|
|
if not top_down:
|
|
|
|
while not isinstance(paths.pop(), tuple):
|
|
|
|
pass
|
|
|
|
continue
|
|
|
|
if top_down:
|
|
|
|
yield path, dirnames, filenames
|
|
|
|
paths += [path.joinpath(d) for d in reversed(dirnames)]
|
2023-05-07 16:07:07 -03:00
|
|
|
|
2023-09-30 11:45:01 -03:00
|
|
|
def absolute(self):
|
|
|
|
"""Return an absolute version of this path
|
|
|
|
No normalization or symlink resolution is performed.
|
2023-05-07 16:07:07 -03:00
|
|
|
|
2023-09-30 11:45:01 -03:00
|
|
|
Use resolve() to resolve symlinks and remove '..' segments.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('absolute()'))
|
2023-05-07 16:07:07 -03:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def cwd(cls):
|
|
|
|
"""Return a new path pointing to the current working directory."""
|
|
|
|
# We call 'absolute()' rather than using 'os.getcwd()' directly to
|
|
|
|
# enable users to replace the implementation of 'absolute()' in a
|
|
|
|
# subclass and benefit from the new behaviour here. This works because
|
|
|
|
# os.path.abspath('.') == os.getcwd().
|
2024-01-09 21:12:58 -04:00
|
|
|
return cls('').absolute()
|
2023-05-07 16:07:07 -03:00
|
|
|
|
2023-09-30 11:45:01 -03:00
|
|
|
def expanduser(self):
|
|
|
|
""" Return a new path with expanded ~ and ~user constructs
|
|
|
|
(as returned by os.path.expanduser)
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('expanduser()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
2023-05-07 16:07:07 -03:00
|
|
|
@classmethod
|
|
|
|
def home(cls):
|
2023-09-30 11:45:01 -03:00
|
|
|
"""Return a new path pointing to expanduser('~').
|
2023-05-07 16:07:07 -03:00
|
|
|
"""
|
|
|
|
return cls("~").expanduser()
|
|
|
|
|
2023-09-30 11:45:01 -03:00
|
|
|
def readlink(self):
|
|
|
|
"""
|
|
|
|
Return the path to which the symbolic link points.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('readlink()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
readlink._supported = False
|
|
|
|
|
|
|
|
def resolve(self, strict=False):
|
|
|
|
"""
|
|
|
|
Make the path absolute, resolving all symlinks on the way and also
|
|
|
|
normalizing it.
|
|
|
|
"""
|
|
|
|
if self._resolving:
|
|
|
|
return self
|
2024-06-05 14:54:50 -03:00
|
|
|
|
|
|
|
def getcwd():
|
|
|
|
return str(self.with_segments().absolute())
|
|
|
|
|
|
|
|
if strict or getattr(self.readlink, '_supported', True):
|
|
|
|
def lstat(path_str):
|
|
|
|
path = self.with_segments(path_str)
|
2024-01-09 15:50:23 -04:00
|
|
|
path._resolving = True
|
2024-06-05 14:54:50 -03:00
|
|
|
return path.lstat()
|
|
|
|
|
|
|
|
def readlink(path_str):
|
|
|
|
path = self.with_segments(path_str)
|
|
|
|
path._resolving = True
|
|
|
|
return str(path.readlink())
|
|
|
|
else:
|
|
|
|
# If the user has *not* overridden the `readlink()` method, then
|
|
|
|
# symlinks are unsupported and (in non-strict mode) we can improve
|
|
|
|
# performance by not calling `path.lstat()`.
|
|
|
|
def skip(path_str):
|
|
|
|
# This exception will be internally consumed by `_realpath()`.
|
|
|
|
raise OSError("Operation skipped.")
|
|
|
|
|
|
|
|
lstat = readlink = skip
|
|
|
|
|
|
|
|
return self.with_segments(posixpath._realpath(
|
|
|
|
str(self), strict, self.parser.sep,
|
|
|
|
getcwd=getcwd, lstat=lstat, readlink=readlink,
|
|
|
|
maxlinks=self._max_symlinks))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
|
|
|
def symlink_to(self, target, target_is_directory=False):
|
|
|
|
"""
|
|
|
|
Make this path a symlink pointing to the target path.
|
|
|
|
Note the order of arguments (link, target) is the reverse of os.symlink.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('symlink_to()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
|
|
|
def hardlink_to(self, target):
|
|
|
|
"""
|
|
|
|
Make this path a hard link pointing to the same file as *target*.
|
|
|
|
|
|
|
|
Note the order of arguments (self, target) is the reverse of os.link's.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('hardlink_to()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
|
|
|
def touch(self, mode=0o666, exist_ok=True):
|
|
|
|
"""
|
|
|
|
Create this file with the given access mode, if it doesn't exist.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('touch()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
|
|
|
def mkdir(self, mode=0o777, parents=False, exist_ok=False):
|
|
|
|
"""
|
|
|
|
Create a new directory at this given path.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('mkdir()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
2024-07-06 13:18:39 -03:00
|
|
|
# Metadata keys supported by this path type.
|
|
|
|
_readable_metadata = _writable_metadata = frozenset()
|
|
|
|
|
|
|
|
def _read_metadata(self, keys=None, *, follow_symlinks=True):
|
|
|
|
"""
|
|
|
|
Returns path metadata as a dict with string keys.
|
|
|
|
"""
|
|
|
|
raise UnsupportedOperation(self._unsupported_msg('_read_metadata()'))
|
|
|
|
|
|
|
|
def _write_metadata(self, metadata, *, follow_symlinks=True):
|
|
|
|
"""
|
|
|
|
Sets path metadata from the given dict with string keys.
|
|
|
|
"""
|
|
|
|
raise UnsupportedOperation(self._unsupported_msg('_write_metadata()'))
|
|
|
|
|
|
|
|
def _copy_metadata(self, target, *, follow_symlinks=True):
|
|
|
|
"""
|
|
|
|
Copies metadata (permissions, timestamps, etc) from this path to target.
|
|
|
|
"""
|
|
|
|
# Metadata types supported by both source and target.
|
|
|
|
keys = self._readable_metadata & target._writable_metadata
|
|
|
|
if keys:
|
|
|
|
metadata = self._read_metadata(keys, follow_symlinks=follow_symlinks)
|
|
|
|
target._write_metadata(metadata, follow_symlinks=follow_symlinks)
|
|
|
|
|
|
|
|
def copy(self, target, *, follow_symlinks=True, preserve_metadata=False):
|
2024-06-14 13:15:49 -03:00
|
|
|
"""
|
2024-06-18 21:59:54 -03:00
|
|
|
Copy the contents of this file to the given target. If this file is a
|
|
|
|
symlink and follow_symlinks is false, a symlink will be created at the
|
|
|
|
target.
|
2024-06-14 13:15:49 -03:00
|
|
|
"""
|
|
|
|
if not isinstance(target, PathBase):
|
|
|
|
target = self.with_segments(target)
|
|
|
|
if self._samefile_safe(target):
|
|
|
|
raise OSError(f"{self!r} and {target!r} are the same file")
|
2024-06-18 21:59:54 -03:00
|
|
|
if not follow_symlinks and self.is_symlink():
|
|
|
|
target.symlink_to(self.readlink())
|
2024-07-06 13:18:39 -03:00
|
|
|
if preserve_metadata:
|
|
|
|
self._copy_metadata(target, follow_symlinks=False)
|
2024-06-18 21:59:54 -03:00
|
|
|
return
|
2024-06-14 13:15:49 -03:00
|
|
|
with self.open('rb') as source_f:
|
|
|
|
try:
|
|
|
|
with target.open('wb') as target_f:
|
|
|
|
copyfileobj(source_f, target_f)
|
|
|
|
except IsADirectoryError as e:
|
|
|
|
if not target.exists():
|
|
|
|
# Raise a less confusing exception.
|
|
|
|
raise FileNotFoundError(
|
|
|
|
f'Directory does not exist: {target}') from e
|
|
|
|
else:
|
|
|
|
raise
|
2024-07-06 13:18:39 -03:00
|
|
|
if preserve_metadata:
|
|
|
|
self._copy_metadata(target)
|
2024-06-14 13:15:49 -03:00
|
|
|
|
2024-06-23 18:01:12 -03:00
|
|
|
def copytree(self, target, *, follow_symlinks=True, dirs_exist_ok=False,
|
|
|
|
ignore=None, on_error=None):
|
|
|
|
"""
|
|
|
|
Recursively copy this directory tree to the given destination.
|
|
|
|
"""
|
|
|
|
if not isinstance(target, PathBase):
|
|
|
|
target = self.with_segments(target)
|
|
|
|
if on_error is None:
|
|
|
|
def on_error(err):
|
|
|
|
raise err
|
|
|
|
stack = [(self, target)]
|
|
|
|
while stack:
|
|
|
|
source_dir, target_dir = stack.pop()
|
|
|
|
try:
|
|
|
|
sources = source_dir.iterdir()
|
|
|
|
target_dir.mkdir(exist_ok=dirs_exist_ok)
|
|
|
|
for source in sources:
|
|
|
|
if ignore and ignore(source):
|
|
|
|
continue
|
|
|
|
try:
|
|
|
|
if source.is_dir(follow_symlinks=follow_symlinks):
|
|
|
|
stack.append((source, target_dir.joinpath(source.name)))
|
|
|
|
else:
|
|
|
|
source.copy(target_dir.joinpath(source.name),
|
|
|
|
follow_symlinks=follow_symlinks)
|
|
|
|
except OSError as err:
|
|
|
|
on_error(err)
|
|
|
|
except OSError as err:
|
|
|
|
on_error(err)
|
|
|
|
|
2023-09-30 11:45:01 -03:00
|
|
|
def rename(self, target):
|
|
|
|
"""
|
|
|
|
Rename this path to the target path.
|
|
|
|
|
|
|
|
The target path may be absolute or relative. Relative paths are
|
|
|
|
interpreted relative to the current working directory, *not* the
|
|
|
|
directory of the Path object.
|
|
|
|
|
|
|
|
Returns the new Path instance pointing to the target path.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('rename()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
|
|
|
def replace(self, target):
|
|
|
|
"""
|
|
|
|
Rename this path to the target path, overwriting if that path exists.
|
|
|
|
|
|
|
|
The target path may be absolute or relative. Relative paths are
|
|
|
|
interpreted relative to the current working directory, *not* the
|
|
|
|
directory of the Path object.
|
|
|
|
|
|
|
|
Returns the new Path instance pointing to the target path.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('replace()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
|
|
|
def chmod(self, mode, *, follow_symlinks=True):
|
|
|
|
"""
|
|
|
|
Change the permissions of the path, like os.chmod().
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('chmod()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
|
|
|
def lchmod(self, mode):
|
|
|
|
"""
|
|
|
|
Like chmod(), except if the path points to a symlink, the symlink's
|
|
|
|
permissions are changed, rather than its target's.
|
|
|
|
"""
|
|
|
|
self.chmod(mode, follow_symlinks=False)
|
|
|
|
|
|
|
|
def unlink(self, missing_ok=False):
|
|
|
|
"""
|
|
|
|
Remove this file or link.
|
|
|
|
If the path is a directory, use rmdir() instead.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('unlink()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
|
|
|
def rmdir(self):
|
|
|
|
"""
|
|
|
|
Remove this directory. The directory must be empty.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('rmdir()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
2023-12-04 15:42:01 -04:00
|
|
|
def owner(self, *, follow_symlinks=True):
|
2023-09-30 11:45:01 -03:00
|
|
|
"""
|
|
|
|
Return the login name of the file owner.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('owner()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
2023-12-04 15:42:01 -04:00
|
|
|
def group(self, *, follow_symlinks=True):
|
2023-09-30 11:45:01 -03:00
|
|
|
"""
|
|
|
|
Return the group name of the file gid.
|
|
|
|
"""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('group()'))
|
2023-09-30 11:45:01 -03:00
|
|
|
|
2023-10-01 12:14:02 -03:00
|
|
|
@classmethod
|
|
|
|
def from_uri(cls, uri):
|
|
|
|
"""Return a new path from the given 'file' URI."""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(cls._unsupported_msg('from_uri()'))
|
2023-10-01 12:14:02 -03:00
|
|
|
|
2023-09-30 11:45:01 -03:00
|
|
|
def as_uri(self):
|
|
|
|
"""Return the path as a URI."""
|
2024-01-30 20:38:01 -04:00
|
|
|
raise UnsupportedOperation(self._unsupported_msg('as_uri()'))
|