{'CON', 'PRN', 'AUX', 'NUL', 'CONIN$', 'CONOUT$'} |

{f'COM{c}' for c in '123456789\xb9\xb2\xb3'} |

{f'LPT{c}' for c in '123456789\xb9\xb2\xb3'}

pat = pattern_parts[0]

child_parts = pattern_parts[1:]

if not pat:

return _TerminatingSelector()

if pat == '**':

cls = _RecursiveWildcardSelector

elif '**' in pat:

raise ValueError("Invalid pattern: '**' can only be an entire path component")

elif _is_wildcard_pattern(pat):

cls = _WildcardSelector

else:

cls = _PreciseSelector

"""A selector matches a specific glob pattern part against the children

def __init__(self, child_parts, flavour):

self.child_parts = child_parts

if child_parts:

self.successor = _make_selector(child_parts, flavour)

self.dironly = True

else:

self.successor = _TerminatingSelector()

self.dironly = False

def select_from(self, parent_path):

"""Iterate over all child paths of `parent_path` matched by this

path_cls = type(parent_path)

is_dir = path_cls.is_dir

exists = path_cls.exists

scandir = path_cls._scandir

normcase = path_cls._flavour.normcase

if not is_dir(parent_path):

return iter([])

def __init__(self, name, child_parts, flavour):

self.name = name

_Selector.__init__(self, child_parts, flavour)

def _select_from(self, parent_path, is_dir, exists, scandir, normcase):

try:

path = parent_path._make_child_relpath(self.name)

if (is_dir if self.dironly else exists)(path):

for p in self.successor._select_from(path, is_dir, exists, scandir, normcase):

yield p

except PermissionError:

def __init__(self, pat, child_parts, flavour):

self.match = re.compile(fnmatch.translate(flavour.normcase(pat))).fullmatch

_Selector.__init__(self, child_parts, flavour)

def _select_from(self, parent_path, is_dir, exists, scandir, normcase):

try:

# We must close the scandir() object before proceeding to

# avoid exhausting file descriptors when globbing deep trees.

with scandir(parent_path) as scandir_it:

entries = list(scandir_it)

for entry in entries:

if self.dironly:

try:

# "entry.is_dir()" can raise PermissionError

# in some cases (see bpo-38894), which is not

# among the errors ignored by _ignore_error()

if not entry.is_dir():

continue

except OSError as e:

if not _ignore_error(e):

raise

continue

name = entry.name

if self.match(normcase(name)):

path = parent_path._make_child_relpath(name)

for p in self.successor._select_from(path, is_dir, exists, scandir, normcase):

yield p

except PermissionError:

def __init__(self, pat, child_parts, flavour):

_Selector.__init__(self, child_parts, flavour)

def _iterate_directories(self, parent_path, is_dir, scandir):

yield parent_path

try:

# We must close the scandir() object before proceeding to

# avoid exhausting file descriptors when globbing deep trees.

with scandir(parent_path) as scandir_it:

entries = list(scandir_it)

for entry in entries:

entry_is_dir = False

try:

entry_is_dir = entry.is_dir()

except OSError as e:

if not _ignore_error(e):

raise

if entry_is_dir and not entry.is_symlink():

path = parent_path._make_child_relpath(entry.name)

for p in self._iterate_directories(path, is_dir, scandir):

yield p

except PermissionError:

return

def _select_from(self, parent_path, is_dir, exists, scandir, normcase):

try:

yielded = set()

try:

successor_select = self.successor._select_from

for starting_point in self._iterate_directories(parent_path, is_dir, scandir):

for p in successor_select(starting_point, is_dir, exists, scandir, normcase):

if p not in yielded:

yield p

yielded.add(p)

finally:

yielded.clear()

except PermissionError:

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

__slots__ = ('_pathcls', '_drv', '_root', '_parts')

def __init__(self, path):

# We don't store the instance to avoid reference cycles

self._pathcls = type(path)

self._drv = path._drv

self._root = path._root

self._parts = path._parts

def __len__(self):

if self._drv or self._root:

return len(self._parts) - 1

else:

return len(self._parts)

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._pathcls._from_parsed_parts(self._drv, self._root,

self._parts[:-idx - 1])

def __repr__(self):

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

__slots__ = (

'_drv', '_root', '_parts',

'_str', '_hash', '_parts_tuple', '_parts_normcase_cached',

)

_flavour = os.path

def __new__(cls, *args):

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

if cls is PurePath:

cls = PureWindowsPath if os.name == 'nt' else PurePosixPath

return cls._from_parts(args)

def __reduce__(self):

# Using the parts tuple helps share interned path parts

# when pickling related paths.

return (self.__class__, tuple(self._parts))

@classmethod

def _parse_parts(cls, parts):

if not parts:

return '', '', []

elif len(parts) == 1:

path = os.fspath(parts[0])

else:

path = cls._flavour.join(*parts)

sep = cls._flavour.sep

altsep = cls._flavour.altsep

if isinstance(path, str):

# Force-cast str subclasses to str (issue #21127)

path = str(path)

else:

raise TypeError(

"argument should be a str or an os.PathLike "

"object where __fspath__ returns a str, "

f"not {type(path).__name__!r}")

if altsep:

path = path.replace(altsep, sep)

drv, root, rel = cls._flavour.splitroot(path)

if drv.startswith(sep):

# pathlib assumes that UNC paths always have a root.

root = sep

unfiltered_parsed = [drv + root] + rel.split(sep)

parsed = [sys.intern(x) for x in unfiltered_parsed if x and x != '.']

return drv, root, parsed

@classmethod

def _from_parts(cls, args):

self = object.__new__(cls)

drv, root, parts = self._parse_parts(args)

self._drv = drv

self._root = root

self._parts = parts

return self

@classmethod

def _from_parsed_parts(cls, drv, root, parts):

self = object.__new__(cls)

self._drv = drv

self._root = root

self._parts = parts

return self

@classmethod

def _format_parsed_parts(cls, drv, root, parts):

if drv or root:

return drv + root + cls._flavour.sep.join(parts[1:])

else:

return cls._flavour.sep.join(parts)

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._drv, self._root,

self._parts) or '.'

return self._str

def __fspath__(self):

return str(self)

def as_posix(self):

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

f = self._flavour

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

def __bytes__(self):

"""Return the bytes representation of the path. This is only

return os.fsencode(self)

def __repr__(self):

return "{}({!r})".format(self.__class__.__name__, self.as_posix())

def as_uri(self):

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

if not self.is_absolute():

raise ValueError("relative path can't be expressed as a file URI")

drive = self._drv

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)

return prefix + urlquote_from_bytes(os.fsencode(path))

@property

def _parts_normcase(self):

# Cached parts with normalized case, for hashing and comparison.

try:

return self._parts_normcase_cached

except AttributeError:

self._parts_normcase_cached = [self._flavour.normcase(p) for p in self._parts]

return self._parts_normcase_cached

def __eq__(self, other):

if not isinstance(other, PurePath):

return NotImplemented

return self._parts_normcase == other._parts_normcase and self._flavour is other._flavour

def __hash__(self):

try:

return self._hash

except AttributeError:

self._hash = hash(tuple(self._parts_normcase))

return self._hash

def __lt__(self, other):

if not isinstance(other, PurePath) or self._flavour is not other._flavour:

return NotImplemented

return self._parts_normcase < other._parts_normcase

def __le__(self, other):

if not isinstance(other, PurePath) or self._flavour is not other._flavour:

return NotImplemented

return self._parts_normcase <= other._parts_normcase

def __gt__(self, other):

if not isinstance(other, PurePath) or self._flavour is not other._flavour:

return NotImplemented

return self._parts_normcase > other._parts_normcase

def __ge__(self, other):

if not isinstance(other, PurePath) or self._flavour is not other._flavour:

return NotImplemented

return self._parts_normcase >= other._parts_normcase

drive = property(attrgetter('_drv'),

doc="""The drive prefix (letter or UNC path), if any.""")

root = property(attrgetter('_root'),

doc="""The root of the path, if any.""")

@property

def anchor(self):

"""The concatenation of the drive and root, or ''."""

anchor = self._drv + self._root

return anchor

@property

def name(self):

"""The final path component, if any."""

parts = self._parts

if len(parts) == (1 if (self._drv or self._root) else 0):

return ''

return parts[-1]

@property

def suffix(self):

"""

name = self.name

i = name.rfind('.')

if 0 < i < len(name) - 1:

return name[i:]

else:

return ''

@property

def suffixes(self):

"""

name = self.name

if name.endswith('.'):

return []

name = name.lstrip('.')

return ['.' + suffix for suffix in name.split('.')[1:]]

@property

def stem(self):

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

name = self.name

i = name.rfind('.')

if 0 < i < len(name) - 1:

return name[:i]

else:

return name

def with_name(self, name):

"""Return a new path with the file name changed."""

if not self.name:

raise ValueError("%r has an empty name" % (self,))

f = self._flavour

drv, root, tail = f.splitroot(name)

if drv or root or not tail or f.sep in tail or (f.altsep and f.altsep in tail):

raise ValueError("Invalid name %r" % (name))

return self._from_parsed_parts(self._drv, self._root,

self._parts[:-1] + [name])

def with_stem(self, stem):

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

return self.with_name(stem + self.suffix)

def with_suffix(self, suffix):

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

f = self._flavour

if f.sep in suffix or f.altsep and f.altsep in suffix:

raise ValueError("Invalid suffix %r" % (suffix,))

if suffix and not suffix.startswith('.') or suffix == '.':

raise ValueError("Invalid suffix %r" % (suffix))

name = self.name

if not name:

raise ValueError("%r has an empty name" % (self,))

old_suffix = self.suffix

if not old_suffix:

name = name + suffix

else:

name = name[:-len(old_suffix)] + suffix

return self._from_parsed_parts(self._drv, self._root,

self._parts[:-1] + [name])

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

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

if _deprecated:

msg = ("support for supplying more than one positional argument "

"to pathlib.PurePath.relative_to() is deprecated and "

"scheduled for removal in Python {remove}")

warnings._deprecated("pathlib.PurePath.relative_to(*args)", msg,

remove=(3, 14))

path_cls = type(self)

other = path_cls(other, *_deprecated)

for step, path in enumerate([other] + list(other.parents)):

if self.is_relative_to(path):

break

else:

raise ValueError(f"{str(self)!r} and {str(other)!r} have different anchors")

if step and not walk_up:

raise ValueError(f"{str(self)!r} is not in the subpath of {str(other)!r}")

parts = ('..',) * step + self.parts[len(path.parts):]

return path_cls(*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 {remove}")

warnings._deprecated("pathlib.PurePath.is_relative_to(*args)",

msg, remove=(3, 14))

other = type(self)(other, *_deprecated)

return other == self or other in self.parents

@property

def parts(self):

"""An object providing sequence-like access to the

# We cache the tuple to avoid building a new one each time .parts

# is accessed. XXX is this necessary?

try:

return self._parts_tuple

except AttributeError:

self._parts_tuple = tuple(self._parts)

return self._parts_tuple

def joinpath(self, *args):

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

drv1, root1, parts1 = self._drv, self._root, self._parts

drv2, root2, parts2 = self._parse_parts(args)

if root2:

if not drv2 and drv1:

return self._from_parsed_parts(drv1, root2, [drv1 + root2] + parts2[1:])

else:

return self._from_parsed_parts(drv2, root2, parts2)

elif drv2:

if drv2 == drv1 or self._flavour.normcase(drv2) == self._flavour.normcase(drv1):

# Same drive => second path is relative to the first.

return self._from_parsed_parts(drv1, root1, parts1 + parts2[1:])

else:

return self._from_parsed_parts(drv2, root2, parts2)

else:

# Second path is non-anchored (common case).

return self._from_parsed_parts(drv1, root1, parts1 + parts2)

def __truediv__(self, key):

try:

return self.joinpath(key)

except TypeError:

return NotImplemented

def __rtruediv__(self, key):

try:

return self._from_parts([key] + self._parts)

except TypeError:

return NotImplemented

@property

def parent(self):

"""The logical parent of the path."""

drv = self._drv

root = self._root

parts = self._parts

if len(parts) == 1 and (drv or root):

return self

return self._from_parsed_parts(drv, root, parts[:-1])

@property

def parents(self):

"""A sequence of this path's logical parents."""

return _PathParents(self)

def is_absolute(self):

"""True if the path is absolute (has both a root and, if applicable,

# ntpath.isabs() is defective - see GH-44626 .

if self._flavour is ntpath:

return bool(self._drv and self._root)

return self._flavour.isabs(self)

def is_reserved(self):

"""Return True if the path contains one of the special names reserved

if self._flavour is posixpath or not self._parts:

return False

# NOTE: the rules for reserved names seem somewhat complicated

# (e.g. r"..\NUL" is reserved but not r"foo\NUL" if "foo" does not

# exist). We err on the side of caution and return True for paths

# which are not considered reserved by Windows.

if self._parts[0].startswith('\\\\'):

# UNC paths are never reserved.

return False

name = self._parts[-1].partition('.')[0].partition(':')[0].rstrip(' ')

return name.upper() in _WIN_RESERVED_NAMES

def match(self, path_pattern):

"""

path_pattern = self._flavour.normcase(path_pattern)

drv, root, pat_parts = self._parse_parts((path_pattern,))

if not pat_parts:

raise ValueError("empty pattern")

parts = self._parts_normcase

if drv or root:

if len(pat_parts) != len(parts):

return False

elif len(pat_parts) > len(parts):

return False

for part, pat in zip(reversed(parts), reversed(pat_parts)):

if not fnmatch.fnmatchcase(part, pat):

return False

"""PurePath subclass for non-Windows systems.

_flavour = posixpath

"""PurePath subclass for Windows systems.

_flavour = ntpath

"""PurePath subclass that can make system calls.

__slots__ = ()

def __new__(cls, *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))

if cls is Path:

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

return cls._from_parts(args)

def _make_child_relpath(self, part):

# This is an optimization used for dir walking. `part` must be

# a single part relative to this path.

parts = self._parts + [part]

return self._from_parsed_parts(self._drv, self._root, parts)

def __enter__(self):

# In previous versions of pathlib, __exit__() marked this path as

# closed; subsequent attempts to perform I/O would raise an IOError.

# This functionality was never documented, and had the effect of

# making Path objects mutable, contrary to PEP 428.

# In Python 3.9 __exit__() was made a no-op.

# In Python 3.11 __enter__() began emitting DeprecationWarning.

# In Python 3.13 __enter__() and __exit__() should be removed.

warnings.warn("pathlib.Path.__enter__() is deprecated and scheduled "

"for removal in Python 3.13; Path objects as a context "

"manager is a no-op",

DeprecationWarning, stacklevel=2)

return self

def __exit__(self, t, v, tb):

pass

# Public API

@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().

return cls().absolute()

@classmethod

def home(cls):

"""Return a new path pointing to the user's home directory (as

return cls("~").expanduser()

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.__class__(other_path).stat()

return self._flavour.samestat(st, other_st)

def iterdir(self):

"""Yield path objects of the directory contents.

for name in os.listdir(self):

yield self._make_child_relpath(name)

def _scandir(self):

# bpo-24132: a future version of pathlib will support subclassing of

# pathlib.Path to customize how the filesystem is accessed. This

# includes scandir(), which is used to implement glob().

return os.scandir(self)

def glob(self, pattern):

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

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

if not pattern:

raise ValueError("Unacceptable pattern: {!r}".format(pattern))

drv, root, pattern_parts = self._parse_parts((pattern,))

if drv or root:

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

if pattern[-1] in (self._flavour.sep, self._flavour.altsep):

pattern_parts.append('')

selector = _make_selector(tuple(pattern_parts), self._flavour)

for p in selector.select_from(self):

yield p

def rglob(self, pattern):

"""Recursively yield all existing files (of any kind, including

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

drv, root, pattern_parts = self._parse_parts((pattern,))

if drv or root:

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

if pattern and pattern[-1] in (self._flavour.sep, self._flavour.altsep):

pattern_parts.append('')

selector = _make_selector(("**",) + tuple(pattern_parts), self._flavour)

for p in selector.select_from(self):

yield p

def absolute(self):

"""Return an absolute version of this path by prepending the current

if self.is_absolute():

return self

elif self._drv:

# There is a CWD on each drive-letter drive.

cwd = self._flavour.abspath(self._drv)

else:

cwd = os.getcwd()

return self._from_parts([cwd] + self._parts)

def resolve(self, strict=False):

"""

def check_eloop(e):

winerror = getattr(e, 'winerror', 0)

if e.errno == ELOOP or winerror == _WINERROR_CANT_RESOLVE_FILENAME:

raise RuntimeError("Symlink loop from %r" % e.filename)

try:

s = self._flavour.realpath(self, strict=strict)

except OSError as e:

check_eloop(e)

raise

p = self._from_parts((s,))

# In non-strict mode, realpath() doesn't raise on symlink loops.

# Ensure we get an exception by calling stat()

if not strict:

try:

p.stat()

except OSError as e:

check_eloop(e)

return p

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

"""

return os.stat(self, follow_symlinks=follow_symlinks)

def owner(self):

"""

try:

import pwd

return pwd.getpwuid(self.stat().st_uid).pw_name

except ImportError:

raise NotImplementedError("Path.owner() is unsupported on this system")

def group(self):

"""

try:

import grp

return grp.getgrgid(self.stat().st_gid).gr_name

except ImportError:

raise NotImplementedError("Path.group() is unsupported on this system")

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') as f:

return f.read()

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

"""

encoding = io.text_encoding(encoding)

with self.open(mode='r', encoding=encoding, errors=errors) 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):

"""

if not isinstance(data, str):

raise TypeError('data must be str, not %s' %

data.__class__.__name__)

encoding = io.text_encoding(encoding)

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

return f.write(data)

def readlink(self):

"""

if not hasattr(os, "readlink"):

raise NotImplementedError("os.readlink() not available on this system")

return self._from_parts((os.readlink(self),))

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

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

"""

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

"""

os.chmod(self, mode, follow_symlinks=follow_symlinks)

def lchmod(self, mode):

"""

self.chmod(mode, follow_symlinks=False)

def unlink(self, missing_ok=False):

"""

try:

os.unlink(self)

except FileNotFoundError:

if not missing_ok:

raise

def rmdir(self):

"""

os.rmdir(self)

def lstat(self):

"""

return self.stat(follow_symlinks=False)

def rename(self, target):

"""