mirror of https://github.com/python/cpython
Move pathlib implementation out of `__init__.py` (#118582)
Use the `__init__.py` file only for imports that define the API, following the example of asyncio.
This commit is contained in:
parent
f27f8c790a
commit
d8d94911e2
|
@ -5,865 +5,8 @@ paths with operations that have semantics appropriate for different
|
|||
operating systems.
|
||||
"""
|
||||
|
||||
import io
|
||||
import ntpath
|
||||
import operator
|
||||
import os
|
||||
import posixpath
|
||||
import sys
|
||||
import warnings
|
||||
from itertools import chain
|
||||
from _collections_abc import Sequence
|
||||
from ._abc import *
|
||||
from ._local import *
|
||||
|
||||
try:
|
||||
import pwd
|
||||
except ImportError:
|
||||
pwd = None
|
||||
try:
|
||||
import grp
|
||||
except ImportError:
|
||||
grp = None
|
||||
|
||||
from . import _abc, _glob
|
||||
|
||||
|
||||
__all__ = [
|
||||
"UnsupportedOperation",
|
||||
"PurePath", "PurePosixPath", "PureWindowsPath",
|
||||
"Path", "PosixPath", "WindowsPath",
|
||||
]
|
||||
|
||||
|
||||
class _PathParents(Sequence):
|
||||
"""This object provides sequence-like access to the logical ancestors
|
||||
of a path. Don't try to construct it yourself."""
|
||||
__slots__ = ('_path', '_drv', '_root', '_tail')
|
||||
|
||||
def __init__(self, path):
|
||||
self._path = path
|
||||
self._drv = path.drive
|
||||
self._root = path.root
|
||||
self._tail = path._tail
|
||||
|
||||
def __len__(self):
|
||||
return len(self._tail)
|
||||
|
||||
def __getitem__(self, idx):
|
||||
if isinstance(idx, slice):
|
||||
return tuple(self[i] for i in range(*idx.indices(len(self))))
|
||||
|
||||
if idx >= len(self) or idx < -len(self):
|
||||
raise IndexError(idx)
|
||||
if idx < 0:
|
||||
idx += len(self)
|
||||
return self._path._from_parsed_parts(self._drv, self._root,
|
||||
self._tail[:-idx - 1])
|
||||
|
||||
def __repr__(self):
|
||||
return "<{}.parents>".format(type(self._path).__name__)
|
||||
|
||||
|
||||
UnsupportedOperation = _abc.UnsupportedOperation
|
||||
|
||||
|
||||
class PurePath(_abc.PurePathBase):
|
||||
"""Base class for manipulating paths without I/O.
|
||||
|
||||
PurePath represents a filesystem path and offers operations which
|
||||
don't imply any actual filesystem I/O. Depending on your system,
|
||||
instantiating a PurePath will return either a PurePosixPath or a
|
||||
PureWindowsPath object. You can also instantiate either of these classes
|
||||
directly, regardless of your system.
|
||||
"""
|
||||
|
||||
__slots__ = (
|
||||
# The `_raw_paths` slot stores unnormalized string paths. This is set
|
||||
# in the `__init__()` method.
|
||||
'_raw_paths',
|
||||
|
||||
# The `_drv`, `_root` and `_tail_cached` slots store parsed and
|
||||
# normalized parts of the path. They are set when any of the `drive`,
|
||||
# `root` or `_tail` properties are accessed for the first time. The
|
||||
# three-part division corresponds to the result of
|
||||
# `os.path.splitroot()`, except that the tail is further split on path
|
||||
# separators (i.e. it is a list of strings), and that the root and
|
||||
# tail are normalized.
|
||||
'_drv', '_root', '_tail_cached',
|
||||
|
||||
# The `_str` slot stores the string representation of the path,
|
||||
# computed from the drive, root and tail when `__str__()` is called
|
||||
# for the first time. It's used to implement `_str_normcase`
|
||||
'_str',
|
||||
|
||||
# The `_str_normcase_cached` slot stores the string path with
|
||||
# normalized case. It is set when the `_str_normcase` property is
|
||||
# accessed for the first time. It's used to implement `__eq__()`
|
||||
# `__hash__()`, and `_parts_normcase`
|
||||
'_str_normcase_cached',
|
||||
|
||||
# The `_parts_normcase_cached` slot stores the case-normalized
|
||||
# string path after splitting on path separators. It's set when the
|
||||
# `_parts_normcase` property is accessed for the first time. It's used
|
||||
# to implement comparison methods like `__lt__()`.
|
||||
'_parts_normcase_cached',
|
||||
|
||||
# The `_hash` slot stores the hash of the case-normalized string
|
||||
# path. It's set when `__hash__()` is called for the first time.
|
||||
'_hash',
|
||||
)
|
||||
parser = os.path
|
||||
_globber = _glob.Globber
|
||||
|
||||
def __new__(cls, *args, **kwargs):
|
||||
"""Construct a PurePath from one or several strings and or existing
|
||||
PurePath objects. The strings and path objects are combined so as
|
||||
to yield a canonicalized path, which is incorporated into the
|
||||
new PurePath object.
|
||||
"""
|
||||
if cls is PurePath:
|
||||
cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
|
||||
return object.__new__(cls)
|
||||
|
||||
def __init__(self, *args):
|
||||
paths = []
|
||||
for arg in args:
|
||||
if isinstance(arg, PurePath):
|
||||
if arg.parser is ntpath and self.parser is posixpath:
|
||||
# GH-103631: Convert separators for backwards compatibility.
|
||||
paths.extend(path.replace('\\', '/') for path in arg._raw_paths)
|
||||
else:
|
||||
paths.extend(arg._raw_paths)
|
||||
else:
|
||||
try:
|
||||
path = os.fspath(arg)
|
||||
except TypeError:
|
||||
path = arg
|
||||
if not isinstance(path, str):
|
||||
raise TypeError(
|
||||
"argument should be a str or an os.PathLike "
|
||||
"object where __fspath__ returns a str, "
|
||||
f"not {type(path).__name__!r}")
|
||||
paths.append(path)
|
||||
# Avoid calling super().__init__, as an optimisation
|
||||
self._raw_paths = paths
|
||||
|
||||
def joinpath(self, *pathsegments):
|
||||
"""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).
|
||||
"""
|
||||
return self.with_segments(self, *pathsegments)
|
||||
|
||||
def __truediv__(self, key):
|
||||
try:
|
||||
return self.with_segments(self, key)
|
||||
except TypeError:
|
||||
return NotImplemented
|
||||
|
||||
def __rtruediv__(self, key):
|
||||
try:
|
||||
return self.with_segments(key, self)
|
||||
except TypeError:
|
||||
return NotImplemented
|
||||
|
||||
def __reduce__(self):
|
||||
return self.__class__, tuple(self._raw_paths)
|
||||
|
||||
def __repr__(self):
|
||||
return "{}({!r})".format(self.__class__.__name__, self.as_posix())
|
||||
|
||||
def __fspath__(self):
|
||||
return str(self)
|
||||
|
||||
def __bytes__(self):
|
||||
"""Return the bytes representation of the path. This is only
|
||||
recommended to use under Unix."""
|
||||
return os.fsencode(self)
|
||||
|
||||
@property
|
||||
def _str_normcase(self):
|
||||
# String with normalized case, for hashing and equality checks
|
||||
try:
|
||||
return self._str_normcase_cached
|
||||
except AttributeError:
|
||||
if _abc._is_case_sensitive(self.parser):
|
||||
self._str_normcase_cached = str(self)
|
||||
else:
|
||||
self._str_normcase_cached = str(self).lower()
|
||||
return self._str_normcase_cached
|
||||
|
||||
def __hash__(self):
|
||||
try:
|
||||
return self._hash
|
||||
except AttributeError:
|
||||
self._hash = hash(self._str_normcase)
|
||||
return self._hash
|
||||
|
||||
def __eq__(self, other):
|
||||
if not isinstance(other, PurePath):
|
||||
return NotImplemented
|
||||
return self._str_normcase == other._str_normcase and self.parser is other.parser
|
||||
|
||||
@property
|
||||
def _parts_normcase(self):
|
||||
# Cached parts with normalized case, for comparisons.
|
||||
try:
|
||||
return self._parts_normcase_cached
|
||||
except AttributeError:
|
||||
self._parts_normcase_cached = self._str_normcase.split(self.parser.sep)
|
||||
return self._parts_normcase_cached
|
||||
|
||||
def __lt__(self, other):
|
||||
if not isinstance(other, PurePath) or self.parser is not other.parser:
|
||||
return NotImplemented
|
||||
return self._parts_normcase < other._parts_normcase
|
||||
|
||||
def __le__(self, other):
|
||||
if not isinstance(other, PurePath) or self.parser is not other.parser:
|
||||
return NotImplemented
|
||||
return self._parts_normcase <= other._parts_normcase
|
||||
|
||||
def __gt__(self, other):
|
||||
if not isinstance(other, PurePath) or self.parser is not other.parser:
|
||||
return NotImplemented
|
||||
return self._parts_normcase > other._parts_normcase
|
||||
|
||||
def __ge__(self, other):
|
||||
if not isinstance(other, PurePath) or self.parser is not other.parser:
|
||||
return NotImplemented
|
||||
return self._parts_normcase >= other._parts_normcase
|
||||
|
||||
def __str__(self):
|
||||
"""Return the string representation of the path, suitable for
|
||||
passing to system calls."""
|
||||
try:
|
||||
return self._str
|
||||
except AttributeError:
|
||||
self._str = self._format_parsed_parts(self.drive, self.root,
|
||||
self._tail) or '.'
|
||||
return self._str
|
||||
|
||||
@classmethod
|
||||
def _format_parsed_parts(cls, drv, root, tail):
|
||||
if drv or root:
|
||||
return drv + root + cls.parser.sep.join(tail)
|
||||
elif tail and cls.parser.splitdrive(tail[0])[0]:
|
||||
tail = ['.'] + tail
|
||||
return cls.parser.sep.join(tail)
|
||||
|
||||
def _from_parsed_parts(self, drv, root, tail):
|
||||
path = self._from_parsed_string(self._format_parsed_parts(drv, root, tail))
|
||||
path._drv = drv
|
||||
path._root = root
|
||||
path._tail_cached = tail
|
||||
return path
|
||||
|
||||
def _from_parsed_string(self, path_str):
|
||||
path = self.with_segments(path_str)
|
||||
path._str = path_str or '.'
|
||||
return path
|
||||
|
||||
@classmethod
|
||||
def _parse_path(cls, path):
|
||||
if not path:
|
||||
return '', '', []
|
||||
sep = cls.parser.sep
|
||||
altsep = cls.parser.altsep
|
||||
if altsep:
|
||||
path = path.replace(altsep, sep)
|
||||
drv, root, rel = cls.parser.splitroot(path)
|
||||
if not root and drv.startswith(sep) and not drv.endswith(sep):
|
||||
drv_parts = drv.split(sep)
|
||||
if len(drv_parts) == 4 and drv_parts[2] not in '?.':
|
||||
# e.g. //server/share
|
||||
root = sep
|
||||
elif len(drv_parts) == 6:
|
||||
# e.g. //?/unc/server/share
|
||||
root = sep
|
||||
parsed = [sys.intern(str(x)) for x in rel.split(sep) if x and x != '.']
|
||||
return drv, root, parsed
|
||||
|
||||
@property
|
||||
def _raw_path(self):
|
||||
"""The joined but unnormalized path."""
|
||||
paths = self._raw_paths
|
||||
if len(paths) == 0:
|
||||
path = ''
|
||||
elif len(paths) == 1:
|
||||
path = paths[0]
|
||||
else:
|
||||
path = self.parser.join(*paths)
|
||||
return path
|
||||
|
||||
@property
|
||||
def drive(self):
|
||||
"""The drive prefix (letter or UNC path), if any."""
|
||||
try:
|
||||
return self._drv
|
||||
except AttributeError:
|
||||
self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
|
||||
return self._drv
|
||||
|
||||
@property
|
||||
def root(self):
|
||||
"""The root of the path, if any."""
|
||||
try:
|
||||
return self._root
|
||||
except AttributeError:
|
||||
self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
|
||||
return self._root
|
||||
|
||||
@property
|
||||
def _tail(self):
|
||||
try:
|
||||
return self._tail_cached
|
||||
except AttributeError:
|
||||
self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
|
||||
return self._tail_cached
|
||||
|
||||
@property
|
||||
def anchor(self):
|
||||
"""The concatenation of the drive and root, or ''."""
|
||||
return self.drive + self.root
|
||||
|
||||
@property
|
||||
def parts(self):
|
||||
"""An object providing sequence-like access to the
|
||||
components in the filesystem path."""
|
||||
if self.drive or self.root:
|
||||
return (self.drive + self.root,) + tuple(self._tail)
|
||||
else:
|
||||
return tuple(self._tail)
|
||||
|
||||
@property
|
||||
def parent(self):
|
||||
"""The logical parent of the path."""
|
||||
drv = self.drive
|
||||
root = self.root
|
||||
tail = self._tail
|
||||
if not tail:
|
||||
return self
|
||||
return self._from_parsed_parts(drv, root, tail[:-1])
|
||||
|
||||
@property
|
||||
def parents(self):
|
||||
"""A sequence of this path's logical parents."""
|
||||
# The value of this property should not be cached on the path object,
|
||||
# as doing so would introduce a reference cycle.
|
||||
return _PathParents(self)
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
"""The final path component, if any."""
|
||||
tail = self._tail
|
||||
if not tail:
|
||||
return ''
|
||||
return tail[-1]
|
||||
|
||||
def with_name(self, name):
|
||||
"""Return a new path with the file name changed."""
|
||||
p = self.parser
|
||||
if not name or p.sep in name or (p.altsep and p.altsep in name) or name == '.':
|
||||
raise ValueError(f"Invalid name {name!r}")
|
||||
tail = self._tail.copy()
|
||||
if not tail:
|
||||
raise ValueError(f"{self!r} has an empty name")
|
||||
tail[-1] = name
|
||||
return self._from_parsed_parts(self.drive, self.root, tail)
|
||||
|
||||
def relative_to(self, other, /, *_deprecated, walk_up=False):
|
||||
"""Return the relative path to another path identified by the passed
|
||||
arguments. If the operation is not possible (because this is not
|
||||
related to the other path), raise ValueError.
|
||||
|
||||
The *walk_up* parameter controls whether `..` may be used to resolve
|
||||
the path.
|
||||
"""
|
||||
if _deprecated:
|
||||
msg = ("support for supplying more than one positional argument "
|
||||
"to pathlib.PurePath.relative_to() is deprecated and "
|
||||
"scheduled for removal in Python 3.14")
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
other = self.with_segments(other, *_deprecated)
|
||||
elif not isinstance(other, PurePath):
|
||||
other = self.with_segments(other)
|
||||
for step, path in enumerate(chain([other], other.parents)):
|
||||
if path == self or path in self.parents:
|
||||
break
|
||||
elif not walk_up:
|
||||
raise ValueError(f"{str(self)!r} is not in the subpath of {str(other)!r}")
|
||||
elif path.name == '..':
|
||||
raise ValueError(f"'..' segment in {str(other)!r} cannot be walked")
|
||||
else:
|
||||
raise ValueError(f"{str(self)!r} and {str(other)!r} have different anchors")
|
||||
parts = ['..'] * step + self._tail[len(path._tail):]
|
||||
return self._from_parsed_parts('', '', parts)
|
||||
|
||||
def is_relative_to(self, other, /, *_deprecated):
|
||||
"""Return True if the path is relative to another path or False.
|
||||
"""
|
||||
if _deprecated:
|
||||
msg = ("support for supplying more than one argument to "
|
||||
"pathlib.PurePath.is_relative_to() is deprecated and "
|
||||
"scheduled for removal in Python 3.14")
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
other = self.with_segments(other, *_deprecated)
|
||||
elif not isinstance(other, PurePath):
|
||||
other = self.with_segments(other)
|
||||
return other == self or other in self.parents
|
||||
|
||||
def is_absolute(self):
|
||||
"""True if the path is absolute (has both a root and, if applicable,
|
||||
a drive)."""
|
||||
if self.parser is posixpath:
|
||||
# Optimization: work with raw paths on POSIX.
|
||||
for path in self._raw_paths:
|
||||
if path.startswith('/'):
|
||||
return True
|
||||
return False
|
||||
return self.parser.isabs(self)
|
||||
|
||||
def is_reserved(self):
|
||||
"""Return True if the path contains one of the special names reserved
|
||||
by the system, if any."""
|
||||
msg = ("pathlib.PurePath.is_reserved() is deprecated and scheduled "
|
||||
"for removal in Python 3.15. Use os.path.isreserved() to "
|
||||
"detect reserved paths on Windows.")
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
if self.parser is ntpath:
|
||||
return self.parser.isreserved(self)
|
||||
return False
|
||||
|
||||
def as_uri(self):
|
||||
"""Return the path as a URI."""
|
||||
if not self.is_absolute():
|
||||
raise ValueError("relative path can't be expressed as a file URI")
|
||||
|
||||
drive = self.drive
|
||||
if len(drive) == 2 and drive[1] == ':':
|
||||
# It's a path on a local drive => 'file:///c:/a/b'
|
||||
prefix = 'file:///' + drive
|
||||
path = self.as_posix()[2:]
|
||||
elif drive:
|
||||
# It's a path on a network drive => 'file://host/share/a/b'
|
||||
prefix = 'file:'
|
||||
path = self.as_posix()
|
||||
else:
|
||||
# It's a posix path => 'file:///etc/hosts'
|
||||
prefix = 'file://'
|
||||
path = str(self)
|
||||
from urllib.parse import quote_from_bytes
|
||||
return prefix + quote_from_bytes(os.fsencode(path))
|
||||
|
||||
@property
|
||||
def _pattern_str(self):
|
||||
"""The path expressed as a string, for use in pattern-matching."""
|
||||
# The string representation of an empty path is a single dot ('.'). Empty
|
||||
# paths shouldn't match wildcards, so we change it to the empty string.
|
||||
path_str = str(self)
|
||||
return '' if path_str == '.' else path_str
|
||||
|
||||
# Subclassing os.PathLike makes isinstance() checks slower,
|
||||
# which in turn makes Path construction slower. Register instead!
|
||||
os.PathLike.register(PurePath)
|
||||
|
||||
|
||||
class PurePosixPath(PurePath):
|
||||
"""PurePath subclass for non-Windows systems.
|
||||
|
||||
On a POSIX system, instantiating a PurePath should return this object.
|
||||
However, you can also instantiate it directly on any system.
|
||||
"""
|
||||
parser = posixpath
|
||||
__slots__ = ()
|
||||
|
||||
|
||||
class PureWindowsPath(PurePath):
|
||||
"""PurePath subclass for Windows systems.
|
||||
|
||||
On a Windows system, instantiating a PurePath should return this object.
|
||||
However, you can also instantiate it directly on any system.
|
||||
"""
|
||||
parser = ntpath
|
||||
__slots__ = ()
|
||||
|
||||
|
||||
class Path(_abc.PathBase, PurePath):
|
||||
"""PurePath subclass that can make system calls.
|
||||
|
||||
Path represents a filesystem path but unlike PurePath, also offers
|
||||
methods to do system calls on path objects. Depending on your system,
|
||||
instantiating a Path will return either a PosixPath or a WindowsPath
|
||||
object. You can also instantiate a PosixPath or WindowsPath directly,
|
||||
but cannot instantiate a WindowsPath on a POSIX system or vice versa.
|
||||
"""
|
||||
__slots__ = ()
|
||||
as_uri = PurePath.as_uri
|
||||
|
||||
@classmethod
|
||||
def _unsupported_msg(cls, attribute):
|
||||
return f"{cls.__name__}.{attribute} is unsupported on this system"
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
if kwargs:
|
||||
msg = ("support for supplying keyword arguments to pathlib.PurePath "
|
||||
"is deprecated and scheduled for removal in Python {remove}")
|
||||
warnings._deprecated("pathlib.PurePath(**kwargs)", msg, remove=(3, 14))
|
||||
super().__init__(*args)
|
||||
|
||||
def __new__(cls, *args, **kwargs):
|
||||
if cls is Path:
|
||||
cls = WindowsPath if os.name == 'nt' else PosixPath
|
||||
return object.__new__(cls)
|
||||
|
||||
def stat(self, *, follow_symlinks=True):
|
||||
"""
|
||||
Return the result of the stat() system call on this path, like
|
||||
os.stat() does.
|
||||
"""
|
||||
return os.stat(self, follow_symlinks=follow_symlinks)
|
||||
|
||||
def is_mount(self):
|
||||
"""
|
||||
Check if this path is a mount point
|
||||
"""
|
||||
return os.path.ismount(self)
|
||||
|
||||
def is_junction(self):
|
||||
"""
|
||||
Whether this path is a junction.
|
||||
"""
|
||||
return os.path.isjunction(self)
|
||||
|
||||
def open(self, mode='r', buffering=-1, encoding=None,
|
||||
errors=None, newline=None):
|
||||
"""
|
||||
Open the file pointed to by this path and return a file object, as
|
||||
the built-in open() function does.
|
||||
"""
|
||||
if "b" not in mode:
|
||||
encoding = io.text_encoding(encoding)
|
||||
return io.open(self, mode, buffering, encoding, errors, newline)
|
||||
|
||||
def read_text(self, encoding=None, errors=None, newline=None):
|
||||
"""
|
||||
Open the file in text mode, read it, and close the file.
|
||||
"""
|
||||
# Call io.text_encoding() here to ensure any warning is raised at an
|
||||
# appropriate stack level.
|
||||
encoding = io.text_encoding(encoding)
|
||||
return _abc.PathBase.read_text(self, encoding, errors, newline)
|
||||
|
||||
def write_text(self, data, encoding=None, errors=None, newline=None):
|
||||
"""
|
||||
Open the file in text mode, write to it, and close the file.
|
||||
"""
|
||||
# Call io.text_encoding() here to ensure any warning is raised at an
|
||||
# appropriate stack level.
|
||||
encoding = io.text_encoding(encoding)
|
||||
return _abc.PathBase.write_text(self, data, encoding, errors, newline)
|
||||
|
||||
_remove_leading_dot = operator.itemgetter(slice(2, None))
|
||||
_remove_trailing_slash = operator.itemgetter(slice(-1))
|
||||
|
||||
def _filter_trailing_slash(self, paths):
|
||||
sep = self.parser.sep
|
||||
anchor_len = len(self.anchor)
|
||||
for path_str in paths:
|
||||
if len(path_str) > anchor_len and path_str[-1] == sep:
|
||||
path_str = path_str[:-1]
|
||||
yield path_str
|
||||
|
||||
def iterdir(self):
|
||||
"""Yield path objects of the directory contents.
|
||||
|
||||
The children are yielded in arbitrary order, and the
|
||||
special entries '.' and '..' are not included.
|
||||
"""
|
||||
root_dir = str(self)
|
||||
with os.scandir(root_dir) as scandir_it:
|
||||
paths = [entry.path for entry in scandir_it]
|
||||
if root_dir == '.':
|
||||
paths = map(self._remove_leading_dot, paths)
|
||||
return map(self._from_parsed_string, paths)
|
||||
|
||||
def glob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):
|
||||
"""Iterate over this subtree and yield all existing files (of any
|
||||
kind, including directories) matching the given relative pattern.
|
||||
"""
|
||||
sys.audit("pathlib.Path.glob", self, pattern)
|
||||
if not isinstance(pattern, PurePath):
|
||||
pattern = self.with_segments(pattern)
|
||||
if pattern.anchor:
|
||||
raise NotImplementedError("Non-relative patterns are unsupported")
|
||||
parts = pattern._tail.copy()
|
||||
if not parts:
|
||||
raise ValueError("Unacceptable pattern: {!r}".format(pattern))
|
||||
raw = pattern._raw_path
|
||||
if raw[-1] in (self.parser.sep, self.parser.altsep):
|
||||
# GH-65238: pathlib doesn't preserve trailing slash. Add it back.
|
||||
parts.append('')
|
||||
select = self._glob_selector(parts[::-1], case_sensitive, recurse_symlinks)
|
||||
root = str(self)
|
||||
paths = select(root)
|
||||
|
||||
# Normalize results
|
||||
if root == '.':
|
||||
paths = map(self._remove_leading_dot, paths)
|
||||
if parts[-1] == '':
|
||||
paths = map(self._remove_trailing_slash, paths)
|
||||
elif parts[-1] == '**':
|
||||
paths = self._filter_trailing_slash(paths)
|
||||
paths = map(self._from_parsed_string, paths)
|
||||
return paths
|
||||
|
||||
def rglob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):
|
||||
"""Recursively yield all existing files (of any kind, including
|
||||
directories) matching the given relative pattern, anywhere in
|
||||
this subtree.
|
||||
"""
|
||||
sys.audit("pathlib.Path.rglob", self, pattern)
|
||||
if not isinstance(pattern, PurePath):
|
||||
pattern = self.with_segments(pattern)
|
||||
pattern = '**' / pattern
|
||||
return self.glob(pattern, case_sensitive=case_sensitive, recurse_symlinks=recurse_symlinks)
|
||||
|
||||
def walk(self, top_down=True, on_error=None, follow_symlinks=False):
|
||||
"""Walk the directory tree from this directory, similar to os.walk()."""
|
||||
sys.audit("pathlib.Path.walk", self, on_error, follow_symlinks)
|
||||
root_dir = str(self)
|
||||
results = self._globber.walk(root_dir, top_down, on_error, follow_symlinks)
|
||||
for path_str, dirnames, filenames in results:
|
||||
if root_dir == '.':
|
||||
path_str = path_str[2:]
|
||||
yield self._from_parsed_string(path_str), dirnames, filenames
|
||||
|
||||
def absolute(self):
|
||||
"""Return an absolute version of this path
|
||||
No normalization or symlink resolution is performed.
|
||||
|
||||
Use resolve() to resolve symlinks and remove '..' segments.
|
||||
"""
|
||||
if self.is_absolute():
|
||||
return self
|
||||
if self.root:
|
||||
drive = os.path.splitroot(os.getcwd())[0]
|
||||
return self._from_parsed_parts(drive, self.root, self._tail)
|
||||
if self.drive:
|
||||
# There is a CWD on each drive-letter drive.
|
||||
cwd = os.path.abspath(self.drive)
|
||||
else:
|
||||
cwd = os.getcwd()
|
||||
if not self._tail:
|
||||
# Fast path for "empty" paths, e.g. Path("."), Path("") or Path().
|
||||
# We pass only one argument to with_segments() to avoid the cost
|
||||
# of joining, and we exploit the fact that getcwd() returns a
|
||||
# fully-normalized string by storing it in _str. This is used to
|
||||
# implement Path.cwd().
|
||||
return self._from_parsed_string(cwd)
|
||||
drive, root, rel = os.path.splitroot(cwd)
|
||||
if not rel:
|
||||
return self._from_parsed_parts(drive, root, self._tail)
|
||||
tail = rel.split(self.parser.sep)
|
||||
tail.extend(self._tail)
|
||||
return self._from_parsed_parts(drive, root, tail)
|
||||
|
||||
def resolve(self, strict=False):
|
||||
"""
|
||||
Make the path absolute, resolving all symlinks on the way and also
|
||||
normalizing it.
|
||||
"""
|
||||
|
||||
return self.with_segments(os.path.realpath(self, strict=strict))
|
||||
|
||||
if pwd:
|
||||
def owner(self, *, follow_symlinks=True):
|
||||
"""
|
||||
Return the login name of the file owner.
|
||||
"""
|
||||
uid = self.stat(follow_symlinks=follow_symlinks).st_uid
|
||||
return pwd.getpwuid(uid).pw_name
|
||||
|
||||
if grp:
|
||||
def group(self, *, follow_symlinks=True):
|
||||
"""
|
||||
Return the group name of the file gid.
|
||||
"""
|
||||
gid = self.stat(follow_symlinks=follow_symlinks).st_gid
|
||||
return grp.getgrgid(gid).gr_name
|
||||
|
||||
if hasattr(os, "readlink"):
|
||||
def readlink(self):
|
||||
"""
|
||||
Return the path to which the symbolic link points.
|
||||
"""
|
||||
return self.with_segments(os.readlink(self))
|
||||
|
||||
def touch(self, mode=0o666, exist_ok=True):
|
||||
"""
|
||||
Create this file with the given access mode, if it doesn't exist.
|
||||
"""
|
||||
|
||||
if exist_ok:
|
||||
# First try to bump modification time
|
||||
# Implementation note: GNU touch uses the UTIME_NOW option of
|
||||
# the utimensat() / futimens() functions.
|
||||
try:
|
||||
os.utime(self, None)
|
||||
except OSError:
|
||||
# Avoid exception chaining
|
||||
pass
|
||||
else:
|
||||
return
|
||||
flags = os.O_CREAT | os.O_WRONLY
|
||||
if not exist_ok:
|
||||
flags |= os.O_EXCL
|
||||
fd = os.open(self, flags, mode)
|
||||
os.close(fd)
|
||||
|
||||
def mkdir(self, mode=0o777, parents=False, exist_ok=False):
|
||||
"""
|
||||
Create a new directory at this given path.
|
||||
"""
|
||||
try:
|
||||
os.mkdir(self, mode)
|
||||
except FileNotFoundError:
|
||||
if not parents or self.parent == self:
|
||||
raise
|
||||
self.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.mkdir(mode, parents=False, exist_ok=exist_ok)
|
||||
except OSError:
|
||||
# Cannot rely on checking for EEXIST, since the operating system
|
||||
# could give priority to other errors like EACCES or EROFS
|
||||
if not exist_ok or not self.is_dir():
|
||||
raise
|
||||
|
||||
def chmod(self, mode, *, follow_symlinks=True):
|
||||
"""
|
||||
Change the permissions of the path, like os.chmod().
|
||||
"""
|
||||
os.chmod(self, mode, follow_symlinks=follow_symlinks)
|
||||
|
||||
def unlink(self, missing_ok=False):
|
||||
"""
|
||||
Remove this file or link.
|
||||
If the path is a directory, use rmdir() instead.
|
||||
"""
|
||||
try:
|
||||
os.unlink(self)
|
||||
except FileNotFoundError:
|
||||
if not missing_ok:
|
||||
raise
|
||||
|
||||
def rmdir(self):
|
||||
"""
|
||||
Remove this directory. The directory must be empty.
|
||||
"""
|
||||
os.rmdir(self)
|
||||
|
||||
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.
|
||||
"""
|
||||
os.rename(self, target)
|
||||
return self.with_segments(target)
|
||||
|
||||
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.
|
||||
"""
|
||||
os.replace(self, target)
|
||||
return self.with_segments(target)
|
||||
|
||||
if hasattr(os, "symlink"):
|
||||
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.
|
||||
"""
|
||||
os.symlink(target, self, target_is_directory)
|
||||
|
||||
if hasattr(os, "link"):
|
||||
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.
|
||||
"""
|
||||
os.link(target, self)
|
||||
|
||||
def expanduser(self):
|
||||
""" Return a new path with expanded ~ and ~user constructs
|
||||
(as returned by os.path.expanduser)
|
||||
"""
|
||||
if (not (self.drive or self.root) and
|
||||
self._tail and self._tail[0][:1] == '~'):
|
||||
homedir = os.path.expanduser(self._tail[0])
|
||||
if homedir[:1] == "~":
|
||||
raise RuntimeError("Could not determine home directory.")
|
||||
drv, root, tail = self._parse_path(homedir)
|
||||
return self._from_parsed_parts(drv, root, tail + self._tail[1:])
|
||||
|
||||
return self
|
||||
|
||||
@classmethod
|
||||
def from_uri(cls, uri):
|
||||
"""Return a new path from the given 'file' URI."""
|
||||
if not uri.startswith('file:'):
|
||||
raise ValueError(f"URI does not start with 'file:': {uri!r}")
|
||||
path = uri[5:]
|
||||
if path[:3] == '///':
|
||||
# Remove empty authority
|
||||
path = path[2:]
|
||||
elif path[:12] == '//localhost/':
|
||||
# Remove 'localhost' authority
|
||||
path = path[11:]
|
||||
if path[:3] == '///' or (path[:1] == '/' and path[2:3] in ':|'):
|
||||
# Remove slash before DOS device/UNC path
|
||||
path = path[1:]
|
||||
if path[1:2] == '|':
|
||||
# Replace bar with colon in DOS drive
|
||||
path = path[:1] + ':' + path[2:]
|
||||
from urllib.parse import unquote_to_bytes
|
||||
path = cls(os.fsdecode(unquote_to_bytes(path)))
|
||||
if not path.is_absolute():
|
||||
raise ValueError(f"URI is not absolute: {uri!r}")
|
||||
return path
|
||||
|
||||
|
||||
class PosixPath(Path, PurePosixPath):
|
||||
"""Path subclass for non-Windows systems.
|
||||
|
||||
On a POSIX system, instantiating a Path should return this object.
|
||||
"""
|
||||
__slots__ = ()
|
||||
|
||||
if os.name == 'nt':
|
||||
def __new__(cls, *args, **kwargs):
|
||||
raise UnsupportedOperation(
|
||||
f"cannot instantiate {cls.__name__!r} on your system")
|
||||
|
||||
class WindowsPath(Path, PureWindowsPath):
|
||||
"""Path subclass for Windows systems.
|
||||
|
||||
On a Windows system, instantiating a Path should return this object.
|
||||
"""
|
||||
__slots__ = ()
|
||||
|
||||
if os.name != 'nt':
|
||||
def __new__(cls, *args, **kwargs):
|
||||
raise UnsupportedOperation(
|
||||
f"cannot instantiate {cls.__name__!r} on your system")
|
||||
__all__ = (_abc.__all__ +
|
||||
_local.__all__)
|
||||
|
|
|
@ -12,11 +12,13 @@ resemble pathlib's PurePath and Path respectively.
|
|||
"""
|
||||
|
||||
import functools
|
||||
import operator
|
||||
from errno import ENOENT, ENOTDIR, EBADF, ELOOP, EINVAL
|
||||
from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
|
||||
|
||||
from . import _glob
|
||||
from ._glob import Globber, no_recurse_symlinks
|
||||
|
||||
|
||||
__all__ = ["UnsupportedOperation"]
|
||||
|
||||
#
|
||||
# Internals
|
||||
|
@ -44,30 +46,6 @@ def _is_case_sensitive(parser):
|
|||
return parser.normcase('Aa') == 'Aa'
|
||||
|
||||
|
||||
class Globber(_glob.Globber):
|
||||
lstat = operator.methodcaller('lstat')
|
||||
add_slash = operator.methodcaller('joinpath', '')
|
||||
|
||||
@staticmethod
|
||||
def scandir(path):
|
||||
# Emulate os.scandir(), which returns an object that can be used as a
|
||||
# context manager. This method is called by walk() and glob().
|
||||
from contextlib import nullcontext
|
||||
return 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
|
||||
|
||||
|
||||
class UnsupportedOperation(NotImplementedError):
|
||||
"""An exception that is raised when an unsupported operation is called on
|
||||
a path object.
|
||||
|
@ -693,7 +671,7 @@ class PathBase(PurePathBase):
|
|||
# know the case sensitivity of the underlying filesystem, so we
|
||||
# must use scandir() for everything, including non-wildcard parts.
|
||||
case_pedantic = True
|
||||
recursive = True if recurse_symlinks else _glob.no_recurse_symlinks
|
||||
recursive = True if recurse_symlinks else no_recurse_symlinks
|
||||
globber = self._globber(self.parser.sep, case_sensitive, case_pedantic, recursive)
|
||||
return globber.selector(parts)
|
||||
|
||||
|
|
|
@ -87,24 +87,28 @@ class Globber:
|
|||
|
||||
# Low-level methods
|
||||
|
||||
lstat = staticmethod(os.lstat)
|
||||
scandir = staticmethod(os.scandir)
|
||||
parse_entry = operator.attrgetter('path')
|
||||
concat_path = operator.add
|
||||
lstat = operator.methodcaller('lstat')
|
||||
add_slash = operator.methodcaller('joinpath', '')
|
||||
|
||||
if os.name == 'nt':
|
||||
@staticmethod
|
||||
def add_slash(pathname):
|
||||
tail = os.path.splitroot(pathname)[2]
|
||||
if not tail or tail[-1] in '\\/':
|
||||
return pathname
|
||||
return f'{pathname}\\'
|
||||
else:
|
||||
@staticmethod
|
||||
def add_slash(pathname):
|
||||
if not pathname or pathname[-1] == '/':
|
||||
return pathname
|
||||
return f'{pathname}/'
|
||||
@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().
|
||||
"""
|
||||
from contextlib import nullcontext
|
||||
return 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
|
||||
|
||||
# High-level methods
|
||||
|
||||
|
@ -303,3 +307,24 @@ class Globber:
|
|||
if dirnames:
|
||||
prefix = cls.add_slash(path)
|
||||
paths += [cls.concat_path(prefix, d) for d in reversed(dirnames)]
|
||||
|
||||
|
||||
class StringGlobber(Globber):
|
||||
lstat = staticmethod(os.lstat)
|
||||
scandir = staticmethod(os.scandir)
|
||||
parse_entry = operator.attrgetter('path')
|
||||
concat_path = operator.add
|
||||
|
||||
if os.name == 'nt':
|
||||
@staticmethod
|
||||
def add_slash(pathname):
|
||||
tail = os.path.splitroot(pathname)[2]
|
||||
if not tail or tail[-1] in '\\/':
|
||||
return pathname
|
||||
return f'{pathname}\\'
|
||||
else:
|
||||
@staticmethod
|
||||
def add_slash(pathname):
|
||||
if not pathname or pathname[-1] == '/':
|
||||
return pathname
|
||||
return f'{pathname}/'
|
||||
|
|
|
@ -0,0 +1,859 @@
|
|||
import io
|
||||
import ntpath
|
||||
import operator
|
||||
import os
|
||||
import posixpath
|
||||
import sys
|
||||
import warnings
|
||||
from itertools import chain
|
||||
from _collections_abc import Sequence
|
||||
|
||||
try:
|
||||
import pwd
|
||||
except ImportError:
|
||||
pwd = None
|
||||
try:
|
||||
import grp
|
||||
except ImportError:
|
||||
grp = None
|
||||
|
||||
from ._abc import UnsupportedOperation, PurePathBase, PathBase
|
||||
from ._glob import StringGlobber
|
||||
|
||||
|
||||
__all__ = [
|
||||
"PurePath", "PurePosixPath", "PureWindowsPath",
|
||||
"Path", "PosixPath", "WindowsPath",
|
||||
]
|
||||
|
||||
|
||||
class _PathParents(Sequence):
|
||||
"""This object provides sequence-like access to the logical ancestors
|
||||
of a path. Don't try to construct it yourself."""
|
||||
__slots__ = ('_path', '_drv', '_root', '_tail')
|
||||
|
||||
def __init__(self, path):
|
||||
self._path = path
|
||||
self._drv = path.drive
|
||||
self._root = path.root
|
||||
self._tail = path._tail
|
||||
|
||||
def __len__(self):
|
||||
return len(self._tail)
|
||||
|
||||
def __getitem__(self, idx):
|
||||
if isinstance(idx, slice):
|
||||
return tuple(self[i] for i in range(*idx.indices(len(self))))
|
||||
|
||||
if idx >= len(self) or idx < -len(self):
|
||||
raise IndexError(idx)
|
||||
if idx < 0:
|
||||
idx += len(self)
|
||||
return self._path._from_parsed_parts(self._drv, self._root,
|
||||
self._tail[:-idx - 1])
|
||||
|
||||
def __repr__(self):
|
||||
return "<{}.parents>".format(type(self._path).__name__)
|
||||
|
||||
|
||||
class PurePath(PurePathBase):
|
||||
"""Base class for manipulating paths without I/O.
|
||||
|
||||
PurePath represents a filesystem path and offers operations which
|
||||
don't imply any actual filesystem I/O. Depending on your system,
|
||||
instantiating a PurePath will return either a PurePosixPath or a
|
||||
PureWindowsPath object. You can also instantiate either of these classes
|
||||
directly, regardless of your system.
|
||||
"""
|
||||
|
||||
__slots__ = (
|
||||
# The `_raw_paths` slot stores unnormalized string paths. This is set
|
||||
# in the `__init__()` method.
|
||||
'_raw_paths',
|
||||
|
||||
# The `_drv`, `_root` and `_tail_cached` slots store parsed and
|
||||
# normalized parts of the path. They are set when any of the `drive`,
|
||||
# `root` or `_tail` properties are accessed for the first time. The
|
||||
# three-part division corresponds to the result of
|
||||
# `os.path.splitroot()`, except that the tail is further split on path
|
||||
# separators (i.e. it is a list of strings), and that the root and
|
||||
# tail are normalized.
|
||||
'_drv', '_root', '_tail_cached',
|
||||
|
||||
# The `_str` slot stores the string representation of the path,
|
||||
# computed from the drive, root and tail when `__str__()` is called
|
||||
# for the first time. It's used to implement `_str_normcase`
|
||||
'_str',
|
||||
|
||||
# The `_str_normcase_cached` slot stores the string path with
|
||||
# normalized case. It is set when the `_str_normcase` property is
|
||||
# accessed for the first time. It's used to implement `__eq__()`
|
||||
# `__hash__()`, and `_parts_normcase`
|
||||
'_str_normcase_cached',
|
||||
|
||||
# The `_parts_normcase_cached` slot stores the case-normalized
|
||||
# string path after splitting on path separators. It's set when the
|
||||
# `_parts_normcase` property is accessed for the first time. It's used
|
||||
# to implement comparison methods like `__lt__()`.
|
||||
'_parts_normcase_cached',
|
||||
|
||||
# The `_hash` slot stores the hash of the case-normalized string
|
||||
# path. It's set when `__hash__()` is called for the first time.
|
||||
'_hash',
|
||||
)
|
||||
parser = os.path
|
||||
_globber = StringGlobber
|
||||
|
||||
def __new__(cls, *args, **kwargs):
|
||||
"""Construct a PurePath from one or several strings and or existing
|
||||
PurePath objects. The strings and path objects are combined so as
|
||||
to yield a canonicalized path, which is incorporated into the
|
||||
new PurePath object.
|
||||
"""
|
||||
if cls is PurePath:
|
||||
cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
|
||||
return object.__new__(cls)
|
||||
|
||||
def __init__(self, *args):
|
||||
paths = []
|
||||
for arg in args:
|
||||
if isinstance(arg, PurePath):
|
||||
if arg.parser is ntpath and self.parser is posixpath:
|
||||
# GH-103631: Convert separators for backwards compatibility.
|
||||
paths.extend(path.replace('\\', '/') for path in arg._raw_paths)
|
||||
else:
|
||||
paths.extend(arg._raw_paths)
|
||||
else:
|
||||
try:
|
||||
path = os.fspath(arg)
|
||||
except TypeError:
|
||||
path = arg
|
||||
if not isinstance(path, str):
|
||||
raise TypeError(
|
||||
"argument should be a str or an os.PathLike "
|
||||
"object where __fspath__ returns a str, "
|
||||
f"not {type(path).__name__!r}")
|
||||
paths.append(path)
|
||||
# Avoid calling super().__init__, as an optimisation
|
||||
self._raw_paths = paths
|
||||
|
||||
def joinpath(self, *pathsegments):
|
||||
"""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).
|
||||
"""
|
||||
return self.with_segments(self, *pathsegments)
|
||||
|
||||
def __truediv__(self, key):
|
||||
try:
|
||||
return self.with_segments(self, key)
|
||||
except TypeError:
|
||||
return NotImplemented
|
||||
|
||||
def __rtruediv__(self, key):
|
||||
try:
|
||||
return self.with_segments(key, self)
|
||||
except TypeError:
|
||||
return NotImplemented
|
||||
|
||||
def __reduce__(self):
|
||||
return self.__class__, tuple(self._raw_paths)
|
||||
|
||||
def __repr__(self):
|
||||
return "{}({!r})".format(self.__class__.__name__, self.as_posix())
|
||||
|
||||
def __fspath__(self):
|
||||
return str(self)
|
||||
|
||||
def __bytes__(self):
|
||||
"""Return the bytes representation of the path. This is only
|
||||
recommended to use under Unix."""
|
||||
return os.fsencode(self)
|
||||
|
||||
@property
|
||||
def _str_normcase(self):
|
||||
# String with normalized case, for hashing and equality checks
|
||||
try:
|
||||
return self._str_normcase_cached
|
||||
except AttributeError:
|
||||
if self.parser is posixpath:
|
||||
self._str_normcase_cached = str(self)
|
||||
else:
|
||||
self._str_normcase_cached = str(self).lower()
|
||||
return self._str_normcase_cached
|
||||
|
||||
def __hash__(self):
|
||||
try:
|
||||
return self._hash
|
||||
except AttributeError:
|
||||
self._hash = hash(self._str_normcase)
|
||||
return self._hash
|
||||
|
||||
def __eq__(self, other):
|
||||
if not isinstance(other, PurePath):
|
||||
return NotImplemented
|
||||
return self._str_normcase == other._str_normcase and self.parser is other.parser
|
||||
|
||||
@property
|
||||
def _parts_normcase(self):
|
||||
# Cached parts with normalized case, for comparisons.
|
||||
try:
|
||||
return self._parts_normcase_cached
|
||||
except AttributeError:
|
||||
self._parts_normcase_cached = self._str_normcase.split(self.parser.sep)
|
||||
return self._parts_normcase_cached
|
||||
|
||||
def __lt__(self, other):
|
||||
if not isinstance(other, PurePath) or self.parser is not other.parser:
|
||||
return NotImplemented
|
||||
return self._parts_normcase < other._parts_normcase
|
||||
|
||||
def __le__(self, other):
|
||||
if not isinstance(other, PurePath) or self.parser is not other.parser:
|
||||
return NotImplemented
|
||||
return self._parts_normcase <= other._parts_normcase
|
||||
|
||||
def __gt__(self, other):
|
||||
if not isinstance(other, PurePath) or self.parser is not other.parser:
|
||||
return NotImplemented
|
||||
return self._parts_normcase > other._parts_normcase
|
||||
|
||||
def __ge__(self, other):
|
||||
if not isinstance(other, PurePath) or self.parser is not other.parser:
|
||||
return NotImplemented
|
||||
return self._parts_normcase >= other._parts_normcase
|
||||
|
||||
def __str__(self):
|
||||
"""Return the string representation of the path, suitable for
|
||||
passing to system calls."""
|
||||
try:
|
||||
return self._str
|
||||
except AttributeError:
|
||||
self._str = self._format_parsed_parts(self.drive, self.root,
|
||||
self._tail) or '.'
|
||||
return self._str
|
||||
|
||||
@classmethod
|
||||
def _format_parsed_parts(cls, drv, root, tail):
|
||||
if drv or root:
|
||||
return drv + root + cls.parser.sep.join(tail)
|
||||
elif tail and cls.parser.splitdrive(tail[0])[0]:
|
||||
tail = ['.'] + tail
|
||||
return cls.parser.sep.join(tail)
|
||||
|
||||
def _from_parsed_parts(self, drv, root, tail):
|
||||
path = self._from_parsed_string(self._format_parsed_parts(drv, root, tail))
|
||||
path._drv = drv
|
||||
path._root = root
|
||||
path._tail_cached = tail
|
||||
return path
|
||||
|
||||
def _from_parsed_string(self, path_str):
|
||||
path = self.with_segments(path_str)
|
||||
path._str = path_str or '.'
|
||||
return path
|
||||
|
||||
@classmethod
|
||||
def _parse_path(cls, path):
|
||||
if not path:
|
||||
return '', '', []
|
||||
sep = cls.parser.sep
|
||||
altsep = cls.parser.altsep
|
||||
if altsep:
|
||||
path = path.replace(altsep, sep)
|
||||
drv, root, rel = cls.parser.splitroot(path)
|
||||
if not root and drv.startswith(sep) and not drv.endswith(sep):
|
||||
drv_parts = drv.split(sep)
|
||||
if len(drv_parts) == 4 and drv_parts[2] not in '?.':
|
||||
# e.g. //server/share
|
||||
root = sep
|
||||
elif len(drv_parts) == 6:
|
||||
# e.g. //?/unc/server/share
|
||||
root = sep
|
||||
parsed = [sys.intern(str(x)) for x in rel.split(sep) if x and x != '.']
|
||||
return drv, root, parsed
|
||||
|
||||
@property
|
||||
def _raw_path(self):
|
||||
"""The joined but unnormalized path."""
|
||||
paths = self._raw_paths
|
||||
if len(paths) == 0:
|
||||
path = ''
|
||||
elif len(paths) == 1:
|
||||
path = paths[0]
|
||||
else:
|
||||
path = self.parser.join(*paths)
|
||||
return path
|
||||
|
||||
@property
|
||||
def drive(self):
|
||||
"""The drive prefix (letter or UNC path), if any."""
|
||||
try:
|
||||
return self._drv
|
||||
except AttributeError:
|
||||
self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
|
||||
return self._drv
|
||||
|
||||
@property
|
||||
def root(self):
|
||||
"""The root of the path, if any."""
|
||||
try:
|
||||
return self._root
|
||||
except AttributeError:
|
||||
self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
|
||||
return self._root
|
||||
|
||||
@property
|
||||
def _tail(self):
|
||||
try:
|
||||
return self._tail_cached
|
||||
except AttributeError:
|
||||
self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
|
||||
return self._tail_cached
|
||||
|
||||
@property
|
||||
def anchor(self):
|
||||
"""The concatenation of the drive and root, or ''."""
|
||||
return self.drive + self.root
|
||||
|
||||
@property
|
||||
def parts(self):
|
||||
"""An object providing sequence-like access to the
|
||||
components in the filesystem path."""
|
||||
if self.drive or self.root:
|
||||
return (self.drive + self.root,) + tuple(self._tail)
|
||||
else:
|
||||
return tuple(self._tail)
|
||||
|
||||
@property
|
||||
def parent(self):
|
||||
"""The logical parent of the path."""
|
||||
drv = self.drive
|
||||
root = self.root
|
||||
tail = self._tail
|
||||
if not tail:
|
||||
return self
|
||||
return self._from_parsed_parts(drv, root, tail[:-1])
|
||||
|
||||
@property
|
||||
def parents(self):
|
||||
"""A sequence of this path's logical parents."""
|
||||
# The value of this property should not be cached on the path object,
|
||||
# as doing so would introduce a reference cycle.
|
||||
return _PathParents(self)
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
"""The final path component, if any."""
|
||||
tail = self._tail
|
||||
if not tail:
|
||||
return ''
|
||||
return tail[-1]
|
||||
|
||||
def with_name(self, name):
|
||||
"""Return a new path with the file name changed."""
|
||||
p = self.parser
|
||||
if not name or p.sep in name or (p.altsep and p.altsep in name) or name == '.':
|
||||
raise ValueError(f"Invalid name {name!r}")
|
||||
tail = self._tail.copy()
|
||||
if not tail:
|
||||
raise ValueError(f"{self!r} has an empty name")
|
||||
tail[-1] = name
|
||||
return self._from_parsed_parts(self.drive, self.root, tail)
|
||||
|
||||
def relative_to(self, other, /, *_deprecated, walk_up=False):
|
||||
"""Return the relative path to another path identified by the passed
|
||||
arguments. If the operation is not possible (because this is not
|
||||
related to the other path), raise ValueError.
|
||||
|
||||
The *walk_up* parameter controls whether `..` may be used to resolve
|
||||
the path.
|
||||
"""
|
||||
if _deprecated:
|
||||
msg = ("support for supplying more than one positional argument "
|
||||
"to pathlib.PurePath.relative_to() is deprecated and "
|
||||
"scheduled for removal in Python 3.14")
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
other = self.with_segments(other, *_deprecated)
|
||||
elif not isinstance(other, PurePath):
|
||||
other = self.with_segments(other)
|
||||
for step, path in enumerate(chain([other], other.parents)):
|
||||
if path == self or path in self.parents:
|
||||
break
|
||||
elif not walk_up:
|
||||
raise ValueError(f"{str(self)!r} is not in the subpath of {str(other)!r}")
|
||||
elif path.name == '..':
|
||||
raise ValueError(f"'..' segment in {str(other)!r} cannot be walked")
|
||||
else:
|
||||
raise ValueError(f"{str(self)!r} and {str(other)!r} have different anchors")
|
||||
parts = ['..'] * step + self._tail[len(path._tail):]
|
||||
return self._from_parsed_parts('', '', parts)
|
||||
|
||||
def is_relative_to(self, other, /, *_deprecated):
|
||||
"""Return True if the path is relative to another path or False.
|
||||
"""
|
||||
if _deprecated:
|
||||
msg = ("support for supplying more than one argument to "
|
||||
"pathlib.PurePath.is_relative_to() is deprecated and "
|
||||
"scheduled for removal in Python 3.14")
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
other = self.with_segments(other, *_deprecated)
|
||||
elif not isinstance(other, PurePath):
|
||||
other = self.with_segments(other)
|
||||
return other == self or other in self.parents
|
||||
|
||||
def is_absolute(self):
|
||||
"""True if the path is absolute (has both a root and, if applicable,
|
||||
a drive)."""
|
||||
if self.parser is posixpath:
|
||||
# Optimization: work with raw paths on POSIX.
|
||||
for path in self._raw_paths:
|
||||
if path.startswith('/'):
|
||||
return True
|
||||
return False
|
||||
return self.parser.isabs(self)
|
||||
|
||||
def is_reserved(self):
|
||||
"""Return True if the path contains one of the special names reserved
|
||||
by the system, if any."""
|
||||
msg = ("pathlib.PurePath.is_reserved() is deprecated and scheduled "
|
||||
"for removal in Python 3.15. Use os.path.isreserved() to "
|
||||
"detect reserved paths on Windows.")
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
if self.parser is ntpath:
|
||||
return self.parser.isreserved(self)
|
||||
return False
|
||||
|
||||
def as_uri(self):
|
||||
"""Return the path as a URI."""
|
||||
if not self.is_absolute():
|
||||
raise ValueError("relative path can't be expressed as a file URI")
|
||||
|
||||
drive = self.drive
|
||||
if len(drive) == 2 and drive[1] == ':':
|
||||
# It's a path on a local drive => 'file:///c:/a/b'
|
||||
prefix = 'file:///' + drive
|
||||
path = self.as_posix()[2:]
|
||||
elif drive:
|
||||
# It's a path on a network drive => 'file://host/share/a/b'
|
||||
prefix = 'file:'
|
||||
path = self.as_posix()
|
||||
else:
|
||||
# It's a posix path => 'file:///etc/hosts'
|
||||
prefix = 'file://'
|
||||
path = str(self)
|
||||
from urllib.parse import quote_from_bytes
|
||||
return prefix + quote_from_bytes(os.fsencode(path))
|
||||
|
||||
@property
|
||||
def _pattern_str(self):
|
||||
"""The path expressed as a string, for use in pattern-matching."""
|
||||
# The string representation of an empty path is a single dot ('.'). Empty
|
||||
# paths shouldn't match wildcards, so we change it to the empty string.
|
||||
path_str = str(self)
|
||||
return '' if path_str == '.' else path_str
|
||||
|
||||
# Subclassing os.PathLike makes isinstance() checks slower,
|
||||
# which in turn makes Path construction slower. Register instead!
|
||||
os.PathLike.register(PurePath)
|
||||
|
||||
|
||||
class PurePosixPath(PurePath):
|
||||
"""PurePath subclass for non-Windows systems.
|
||||
|
||||
On a POSIX system, instantiating a PurePath should return this object.
|
||||
However, you can also instantiate it directly on any system.
|
||||
"""
|
||||
parser = posixpath
|
||||
__slots__ = ()
|
||||
|
||||
|
||||
class PureWindowsPath(PurePath):
|
||||
"""PurePath subclass for Windows systems.
|
||||
|
||||
On a Windows system, instantiating a PurePath should return this object.
|
||||
However, you can also instantiate it directly on any system.
|
||||
"""
|
||||
parser = ntpath
|
||||
__slots__ = ()
|
||||
|
||||
|
||||
class Path(PathBase, PurePath):
|
||||
"""PurePath subclass that can make system calls.
|
||||
|
||||
Path represents a filesystem path but unlike PurePath, also offers
|
||||
methods to do system calls on path objects. Depending on your system,
|
||||
instantiating a Path will return either a PosixPath or a WindowsPath
|
||||
object. You can also instantiate a PosixPath or WindowsPath directly,
|
||||
but cannot instantiate a WindowsPath on a POSIX system or vice versa.
|
||||
"""
|
||||
__slots__ = ()
|
||||
as_uri = PurePath.as_uri
|
||||
|
||||
@classmethod
|
||||
def _unsupported_msg(cls, attribute):
|
||||
return f"{cls.__name__}.{attribute} is unsupported on this system"
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
if kwargs:
|
||||
msg = ("support for supplying keyword arguments to pathlib.PurePath "
|
||||
"is deprecated and scheduled for removal in Python {remove}")
|
||||
warnings._deprecated("pathlib.PurePath(**kwargs)", msg, remove=(3, 14))
|
||||
super().__init__(*args)
|
||||
|
||||
def __new__(cls, *args, **kwargs):
|
||||
if cls is Path:
|
||||
cls = WindowsPath if os.name == 'nt' else PosixPath
|
||||
return object.__new__(cls)
|
||||
|
||||
def stat(self, *, follow_symlinks=True):
|
||||
"""
|
||||
Return the result of the stat() system call on this path, like
|
||||
os.stat() does.
|
||||
"""
|
||||
return os.stat(self, follow_symlinks=follow_symlinks)
|
||||
|
||||
def is_mount(self):
|
||||
"""
|
||||
Check if this path is a mount point
|
||||
"""
|
||||
return os.path.ismount(self)
|
||||
|
||||
def is_junction(self):
|
||||
"""
|
||||
Whether this path is a junction.
|
||||
"""
|
||||
return os.path.isjunction(self)
|
||||
|
||||
def open(self, mode='r', buffering=-1, encoding=None,
|
||||
errors=None, newline=None):
|
||||
"""
|
||||
Open the file pointed to by this path and return a file object, as
|
||||
the built-in open() function does.
|
||||
"""
|
||||
if "b" not in mode:
|
||||
encoding = io.text_encoding(encoding)
|
||||
return io.open(self, mode, buffering, encoding, errors, newline)
|
||||
|
||||
def read_text(self, encoding=None, errors=None, newline=None):
|
||||
"""
|
||||
Open the file in text mode, read it, and close the file.
|
||||
"""
|
||||
# Call io.text_encoding() here to ensure any warning is raised at an
|
||||
# appropriate stack level.
|
||||
encoding = io.text_encoding(encoding)
|
||||
return PathBase.read_text(self, encoding, errors, newline)
|
||||
|
||||
def write_text(self, data, encoding=None, errors=None, newline=None):
|
||||
"""
|
||||
Open the file in text mode, write to it, and close the file.
|
||||
"""
|
||||
# Call io.text_encoding() here to ensure any warning is raised at an
|
||||
# appropriate stack level.
|
||||
encoding = io.text_encoding(encoding)
|
||||
return PathBase.write_text(self, data, encoding, errors, newline)
|
||||
|
||||
_remove_leading_dot = operator.itemgetter(slice(2, None))
|
||||
_remove_trailing_slash = operator.itemgetter(slice(-1))
|
||||
|
||||
def _filter_trailing_slash(self, paths):
|
||||
sep = self.parser.sep
|
||||
anchor_len = len(self.anchor)
|
||||
for path_str in paths:
|
||||
if len(path_str) > anchor_len and path_str[-1] == sep:
|
||||
path_str = path_str[:-1]
|
||||
yield path_str
|
||||
|
||||
def iterdir(self):
|
||||
"""Yield path objects of the directory contents.
|
||||
|
||||
The children are yielded in arbitrary order, and the
|
||||
special entries '.' and '..' are not included.
|
||||
"""
|
||||
root_dir = str(self)
|
||||
with os.scandir(root_dir) as scandir_it:
|
||||
paths = [entry.path for entry in scandir_it]
|
||||
if root_dir == '.':
|
||||
paths = map(self._remove_leading_dot, paths)
|
||||
return map(self._from_parsed_string, paths)
|
||||
|
||||
def glob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):
|
||||
"""Iterate over this subtree and yield all existing files (of any
|
||||
kind, including directories) matching the given relative pattern.
|
||||
"""
|
||||
sys.audit("pathlib.Path.glob", self, pattern)
|
||||
if not isinstance(pattern, PurePath):
|
||||
pattern = self.with_segments(pattern)
|
||||
if pattern.anchor:
|
||||
raise NotImplementedError("Non-relative patterns are unsupported")
|
||||
parts = pattern._tail.copy()
|
||||
if not parts:
|
||||
raise ValueError("Unacceptable pattern: {!r}".format(pattern))
|
||||
raw = pattern._raw_path
|
||||
if raw[-1] in (self.parser.sep, self.parser.altsep):
|
||||
# GH-65238: pathlib doesn't preserve trailing slash. Add it back.
|
||||
parts.append('')
|
||||
select = self._glob_selector(parts[::-1], case_sensitive, recurse_symlinks)
|
||||
root = str(self)
|
||||
paths = select(root)
|
||||
|
||||
# Normalize results
|
||||
if root == '.':
|
||||
paths = map(self._remove_leading_dot, paths)
|
||||
if parts[-1] == '':
|
||||
paths = map(self._remove_trailing_slash, paths)
|
||||
elif parts[-1] == '**':
|
||||
paths = self._filter_trailing_slash(paths)
|
||||
paths = map(self._from_parsed_string, paths)
|
||||
return paths
|
||||
|
||||
def rglob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):
|
||||
"""Recursively yield all existing files (of any kind, including
|
||||
directories) matching the given relative pattern, anywhere in
|
||||
this subtree.
|
||||
"""
|
||||
sys.audit("pathlib.Path.rglob", self, pattern)
|
||||
if not isinstance(pattern, PurePath):
|
||||
pattern = self.with_segments(pattern)
|
||||
pattern = '**' / pattern
|
||||
return self.glob(pattern, case_sensitive=case_sensitive, recurse_symlinks=recurse_symlinks)
|
||||
|
||||
def walk(self, top_down=True, on_error=None, follow_symlinks=False):
|
||||
"""Walk the directory tree from this directory, similar to os.walk()."""
|
||||
sys.audit("pathlib.Path.walk", self, on_error, follow_symlinks)
|
||||
root_dir = str(self)
|
||||
results = self._globber.walk(root_dir, top_down, on_error, follow_symlinks)
|
||||
for path_str, dirnames, filenames in results:
|
||||
if root_dir == '.':
|
||||
path_str = path_str[2:]
|
||||
yield self._from_parsed_string(path_str), dirnames, filenames
|
||||
|
||||
def absolute(self):
|
||||
"""Return an absolute version of this path
|
||||
No normalization or symlink resolution is performed.
|
||||
|
||||
Use resolve() to resolve symlinks and remove '..' segments.
|
||||
"""
|
||||
if self.is_absolute():
|
||||
return self
|
||||
if self.root:
|
||||
drive = os.path.splitroot(os.getcwd())[0]
|
||||
return self._from_parsed_parts(drive, self.root, self._tail)
|
||||
if self.drive:
|
||||
# There is a CWD on each drive-letter drive.
|
||||
cwd = os.path.abspath(self.drive)
|
||||
else:
|
||||
cwd = os.getcwd()
|
||||
if not self._tail:
|
||||
# Fast path for "empty" paths, e.g. Path("."), Path("") or Path().
|
||||
# We pass only one argument to with_segments() to avoid the cost
|
||||
# of joining, and we exploit the fact that getcwd() returns a
|
||||
# fully-normalized string by storing it in _str. This is used to
|
||||
# implement Path.cwd().
|
||||
return self._from_parsed_string(cwd)
|
||||
drive, root, rel = os.path.splitroot(cwd)
|
||||
if not rel:
|
||||
return self._from_parsed_parts(drive, root, self._tail)
|
||||
tail = rel.split(self.parser.sep)
|
||||
tail.extend(self._tail)
|
||||
return self._from_parsed_parts(drive, root, tail)
|
||||
|
||||
def resolve(self, strict=False):
|
||||
"""
|
||||
Make the path absolute, resolving all symlinks on the way and also
|
||||
normalizing it.
|
||||
"""
|
||||
|
||||
return self.with_segments(os.path.realpath(self, strict=strict))
|
||||
|
||||
if pwd:
|
||||
def owner(self, *, follow_symlinks=True):
|
||||
"""
|
||||
Return the login name of the file owner.
|
||||
"""
|
||||
uid = self.stat(follow_symlinks=follow_symlinks).st_uid
|
||||
return pwd.getpwuid(uid).pw_name
|
||||
|
||||
if grp:
|
||||
def group(self, *, follow_symlinks=True):
|
||||
"""
|
||||
Return the group name of the file gid.
|
||||
"""
|
||||
gid = self.stat(follow_symlinks=follow_symlinks).st_gid
|
||||
return grp.getgrgid(gid).gr_name
|
||||
|
||||
if hasattr(os, "readlink"):
|
||||
def readlink(self):
|
||||
"""
|
||||
Return the path to which the symbolic link points.
|
||||
"""
|
||||
return self.with_segments(os.readlink(self))
|
||||
|
||||
def touch(self, mode=0o666, exist_ok=True):
|
||||
"""
|
||||
Create this file with the given access mode, if it doesn't exist.
|
||||
"""
|
||||
|
||||
if exist_ok:
|
||||
# First try to bump modification time
|
||||
# Implementation note: GNU touch uses the UTIME_NOW option of
|
||||
# the utimensat() / futimens() functions.
|
||||
try:
|
||||
os.utime(self, None)
|
||||
except OSError:
|
||||
# Avoid exception chaining
|
||||
pass
|
||||
else:
|
||||
return
|
||||
flags = os.O_CREAT | os.O_WRONLY
|
||||
if not exist_ok:
|
||||
flags |= os.O_EXCL
|
||||
fd = os.open(self, flags, mode)
|
||||
os.close(fd)
|
||||
|
||||
def mkdir(self, mode=0o777, parents=False, exist_ok=False):
|
||||
"""
|
||||
Create a new directory at this given path.
|
||||
"""
|
||||
try:
|
||||
os.mkdir(self, mode)
|
||||
except FileNotFoundError:
|
||||
if not parents or self.parent == self:
|
||||
raise
|
||||
self.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.mkdir(mode, parents=False, exist_ok=exist_ok)
|
||||
except OSError:
|
||||
# Cannot rely on checking for EEXIST, since the operating system
|
||||
# could give priority to other errors like EACCES or EROFS
|
||||
if not exist_ok or not self.is_dir():
|
||||
raise
|
||||
|
||||
def chmod(self, mode, *, follow_symlinks=True):
|
||||
"""
|
||||
Change the permissions of the path, like os.chmod().
|
||||
"""
|
||||
os.chmod(self, mode, follow_symlinks=follow_symlinks)
|
||||
|
||||
def unlink(self, missing_ok=False):
|
||||
"""
|
||||
Remove this file or link.
|
||||
If the path is a directory, use rmdir() instead.
|
||||
"""
|
||||
try:
|
||||
os.unlink(self)
|
||||
except FileNotFoundError:
|
||||
if not missing_ok:
|
||||
raise
|
||||
|
||||
def rmdir(self):
|
||||
"""
|
||||
Remove this directory. The directory must be empty.
|
||||
"""
|
||||
os.rmdir(self)
|
||||
|
||||
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.
|
||||
"""
|
||||
os.rename(self, target)
|
||||
return self.with_segments(target)
|
||||
|
||||
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.
|
||||
"""
|
||||
os.replace(self, target)
|
||||
return self.with_segments(target)
|
||||
|
||||
if hasattr(os, "symlink"):
|
||||
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.
|
||||
"""
|
||||
os.symlink(target, self, target_is_directory)
|
||||
|
||||
if hasattr(os, "link"):
|
||||
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.
|
||||
"""
|
||||
os.link(target, self)
|
||||
|
||||
def expanduser(self):
|
||||
""" Return a new path with expanded ~ and ~user constructs
|
||||
(as returned by os.path.expanduser)
|
||||
"""
|
||||
if (not (self.drive or self.root) and
|
||||
self._tail and self._tail[0][:1] == '~'):
|
||||
homedir = os.path.expanduser(self._tail[0])
|
||||
if homedir[:1] == "~":
|
||||
raise RuntimeError("Could not determine home directory.")
|
||||
drv, root, tail = self._parse_path(homedir)
|
||||
return self._from_parsed_parts(drv, root, tail + self._tail[1:])
|
||||
|
||||
return self
|
||||
|
||||
@classmethod
|
||||
def from_uri(cls, uri):
|
||||
"""Return a new path from the given 'file' URI."""
|
||||
if not uri.startswith('file:'):
|
||||
raise ValueError(f"URI does not start with 'file:': {uri!r}")
|
||||
path = uri[5:]
|
||||
if path[:3] == '///':
|
||||
# Remove empty authority
|
||||
path = path[2:]
|
||||
elif path[:12] == '//localhost/':
|
||||
# Remove 'localhost' authority
|
||||
path = path[11:]
|
||||
if path[:3] == '///' or (path[:1] == '/' and path[2:3] in ':|'):
|
||||
# Remove slash before DOS device/UNC path
|
||||
path = path[1:]
|
||||
if path[1:2] == '|':
|
||||
# Replace bar with colon in DOS drive
|
||||
path = path[:1] + ':' + path[2:]
|
||||
from urllib.parse import unquote_to_bytes
|
||||
path = cls(os.fsdecode(unquote_to_bytes(path)))
|
||||
if not path.is_absolute():
|
||||
raise ValueError(f"URI is not absolute: {uri!r}")
|
||||
return path
|
||||
|
||||
|
||||
class PosixPath(Path, PurePosixPath):
|
||||
"""Path subclass for non-Windows systems.
|
||||
|
||||
On a POSIX system, instantiating a Path should return this object.
|
||||
"""
|
||||
__slots__ = ()
|
||||
|
||||
if os.name == 'nt':
|
||||
def __new__(cls, *args, **kwargs):
|
||||
raise UnsupportedOperation(
|
||||
f"cannot instantiate {cls.__name__!r} on your system")
|
||||
|
||||
class WindowsPath(Path, PureWindowsPath):
|
||||
"""Path subclass for Windows systems.
|
||||
|
||||
On a Windows system, instantiating a Path should return this object.
|
||||
"""
|
||||
__slots__ = ()
|
||||
|
||||
if os.name != 'nt':
|
||||
def __new__(cls, *args, **kwargs):
|
||||
raise UnsupportedOperation(
|
||||
f"cannot instantiate {cls.__name__!r} on your system")
|
Loading…
Reference in New Issue