"UnsupportedOperation",

"PurePath", "PurePosixPath", "PureWindowsPath",

"Path", "PosixPath", "WindowsPath",

"""This object provides sequence-like access to the logical ancestors

__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):

"""Base class for manipulating paths without I/O.

__slots__ = (

# The `_raw_paths` slot stores unjoined 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

def __new__(cls, *args, **kwargs):

"""Construct a PurePath from one or several strings and or existing

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 not self.parser:

# GH-103631: Convert separators for backwards compatibility.

paths.append(arg.as_posix())

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)

self._raw_paths = paths

def with_segments(self, *pathsegments):

"""Construct a new path object from any number of path-like objects.

return type(self)(*pathsegments)

def joinpath(self, *pathsegments):

"""Combine this path with one or several arguments, and return a

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

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

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

return drv, root, [x for x in rel.split(sep) if x and x != '.']

@classmethod

def _parse_pattern(cls, pattern):

"""Parse a glob pattern to a list of parts. This is much like

drv, root, rel = cls.parser.splitroot(pattern)

if root or drv:

raise NotImplementedError("Non-relative patterns are unsupported")

sep = cls.parser.sep

altsep = cls.parser.altsep

if altsep:

rel = rel.replace(altsep, sep)

parts = [x for x in rel.split(sep) if x and x != '.']

if not parts:

raise ValueError(f"Unacceptable pattern: {str(pattern)!r}")

elif rel.endswith(sep):

# GH-65238: preserve trailing slash in glob patterns.

parts.append('')

return parts

def as_posix(self):

"""Return the string representation of the path with forward (/)

return str(self).replace(self.parser.sep, '/')

@property

def _raw_path(self):

paths = self._raw_paths

if len(paths) == 1:

return paths[0]

elif paths:

# Join path segments from the initializer.

return self.parser.join(*paths)

else:

return ''

@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

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 with_stem(self, stem):

"""Return a new path with the stem changed."""

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)

def with_suffix(self, suffix):

"""Return a new path with the file suffix changed. If the path

stem = self.stem

if not stem:

# If the stem is empty, we can't make the suffix non-empty.

raise ValueError(f"{self!r} has an empty name")

elif suffix and not suffix.startswith('.'):

raise ValueError(f"Invalid suffix {suffix!r}")

else:

return self.with_name(stem + suffix)

@property

def stem(self):

"""The final path component, minus its last suffix."""

name = self.name

i = name.rfind('.')

if i != -1:

stem = name[:i]

# Stem must contain at least one non-dot character.

if stem.lstrip('.'):

return stem

return name

@property

def suffix(self):

"""

name = self.name.lstrip('.')

i = name.rfind('.')

if i != -1:

return name[i:]

return ''

@property

def suffixes(self):

"""

return ['.' + ext for ext in self.name.lstrip('.').split('.')[1:]]

def relative_to(self, other, *, walk_up=False):

"""Return the relative path to another path identified by the passed

if not hasattr(other, 'with_segments'):

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):

"""Return True if the path is relative to another path or False.

if not hasattr(other, 'with_segments'):

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,

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

import warnings

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._deprecated("pathlib.PurePath.is_reserved", msg, remove=(3, 15))

if self.parser is ntpath:

return self.parser.isreserved(self)

return False

def as_uri(self):

"""Return the path as a URI."""

import warnings

msg = ("pathlib.PurePath.as_uri() is deprecated and scheduled "

"for removal in Python 3.19. Use pathlib.Path.as_uri().")

warnings._deprecated("pathlib.PurePath.as_uri", msg, remove=(3, 19))

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))

def full_match(self, pattern, *, case_sensitive=None):

"""

if not hasattr(pattern, 'with_segments'):

pattern = self.with_segments(pattern)

if case_sensitive is None:

case_sensitive = self.parser is posixpath

# 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(self) if self.parts else ''

pattern = str(pattern) if pattern.parts else ''

globber = _StringGlobber(self.parser.sep, case_sensitive, recursive=True)

return globber.compile(pattern)(path) is not None

def match(self, path_pattern, *, case_sensitive=None):

"""

if not hasattr(path_pattern, 'with_segments'):

path_pattern = self.with_segments(path_pattern)

if case_sensitive is None:

case_sensitive = self.parser is posixpath

path_parts = self.parts[::-1]

pattern_parts = path_pattern.parts[::-1]

if not pattern_parts:

raise ValueError("empty pattern")

if len(path_parts) < len(pattern_parts):

return False

if len(path_parts) > len(pattern_parts) and path_pattern.anchor:

return False

globber = _StringGlobber(self.parser.sep, case_sensitive)

for path_part, pattern_part in zip(path_parts, pattern_parts):

match = globber.compile(pattern_part)

if match(path_part) is None:

return False

"""PurePath subclass for non-Windows systems.

parser = posixpath

"""PurePath subclass for Windows systems.

parser = ntpath

"""PurePath subclass that can make system calls.

__slots__ = ('_info',)

def __new__(cls, *args, **kwargs):

if cls is Path:

cls = WindowsPath if os.name == 'nt' else PosixPath

return object.__new__(cls)

@property

def info(self):

"""

try:

return self._info

except AttributeError:

self._info = PathInfo(self)

return self._info

def stat(self, *, follow_symlinks=True):

"""

return os.stat(self, follow_symlinks=follow_symlinks)

def lstat(self):

"""

return os.lstat(self)

def exists(self, *, follow_symlinks=True):

"""

if follow_symlinks:

return os.path.exists(self)

return os.path.lexists(self)

def is_dir(self, *, follow_symlinks=True):

"""

if follow_symlinks:

return os.path.isdir(self)

try:

return S_ISDIR(self.stat(follow_symlinks=follow_symlinks).st_mode)

except (OSError, ValueError):

return False

def is_file(self, *, follow_symlinks=True):

"""

if follow_symlinks:

return os.path.isfile(self)

try:

return S_ISREG(self.stat(follow_symlinks=follow_symlinks).st_mode)

except (OSError, ValueError):

return False

def is_mount(self):

"""

return os.path.ismount(self)

def is_symlink(self):

"""

return os.path.islink(self)

def is_junction(self):

"""

return os.path.isjunction(self)

def is_block_device(self):

"""

try:

return S_ISBLK(self.stat().st_mode)

except (OSError, ValueError):

return False

def is_char_device(self):

"""

try:

return S_ISCHR(self.stat().st_mode)

except (OSError, ValueError):

return False

def is_fifo(self):

"""

try:

return S_ISFIFO(self.stat().st_mode)

except (OSError, ValueError):

return False

def is_socket(self):

"""

try:

return S_ISSOCK(self.stat().st_mode)

except (OSError, ValueError):

return False

def samefile(self, other_path):

"""Return whether other_path is the same or not as this file

st = self.stat()

try:

other_st = other_path.stat()

except AttributeError:

other_st = self.with_segments(other_path).stat()

return (st.st_ino == other_st.st_ino and

st.st_dev == other_st.st_dev)

def open(self, mode='r', buffering=-1, encoding=None,

errors=None, newline=None):

"""

if "b" not in mode:

encoding = io.text_encoding(encoding)

return io.open(self, mode, buffering, encoding, errors, newline)

def read_bytes(self):

"""

with self.open(mode='rb', buffering=0) as f:

return f.read()

def read_text(self, encoding=None, errors=None, newline=None):

"""

# Call io.text_encoding() here to ensure any warning is raised at an

# appropriate stack level.

encoding = io.text_encoding(encoding)

with self.open(mode='r', encoding=encoding, errors=errors, newline=newline) as f:

return f.read()

def write_bytes(self, data):

"""

# 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):

"""

# Call io.text_encoding() here to ensure any warning is raised at an

# appropriate stack level.

encoding = io.text_encoding(encoding)

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)

_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 _from_dir_entry(self, dir_entry, path_str):

path = self.with_segments(path_str)

path._str = path_str

path._info = DirEntryInfo(dir_entry)

return path

def iterdir(self):

"""Yield path objects of the directory contents.

root_dir = str(self)

with os.scandir(root_dir) as scandir_it:

entries = list(scandir_it)

if root_dir == '.':

return (self._from_dir_entry(e, e.name) for e in entries)

else:

return (self._from_dir_entry(e, e.path) for e in entries)

def glob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):

"""Iterate over this subtree and yield all existing files (of any

sys.audit("pathlib.Path.glob", self, pattern)

if case_sensitive is None:

case_sensitive = self.parser is posixpath

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

parts = self._parse_pattern(pattern)

recursive = True if recurse_symlinks else _no_recurse_symlinks

globber = _StringGlobber(self.parser.sep, case_sensitive, case_pedantic, recursive)

select = globber.selector(parts[::-1])

root = str(self)

paths = select(self.parser.join(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

sys.audit("pathlib.Path.rglob", self, pattern)

pattern = self.parser.join('**', 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)

if not follow_symlinks:

follow_symlinks = os._walk_symlinks_as_files

results = os.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

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)

@classmethod

def cwd(cls):

"""Return a new path pointing to the current working directory."""

cwd = os.getcwd()

path = cls(cwd)

path._str = cwd # getcwd() returns a normalized path

return path

def resolve(self, strict=False):

"""

return self.with_segments(os.path.realpath(self, strict=strict))

if pwd:

def owner(self, *, follow_symlinks=True):

"""

uid = self.stat(follow_symlinks=follow_symlinks).st_uid

return pwd.getpwuid(uid).pw_name

else:

def owner(self, *, follow_symlinks=True):

"""

f = f"{type(self).__name__}.owner()"

raise UnsupportedOperation(f"{f} is unsupported on this system")

if grp:

def group(self, *, follow_symlinks=True):

"""

gid = self.stat(follow_symlinks=follow_symlinks).st_gid

return grp.getgrgid(gid).gr_name

else:

def group(self, *, follow_symlinks=True):

"""

f = f"{type(self).__name__}.group()"

raise UnsupportedOperation(f"{f} is unsupported on this system")

if hasattr(os, "readlink"):

def readlink(self):

"""

return self.with_segments(os.readlink(self))

else:

def readlink(self):

"""

f = f"{type(self).__name__}.readlink()"

raise UnsupportedOperation(f"{f} is unsupported on this system")

def touch(self, mode=0o666, exist_ok=True):

"""

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