"basename","dirname","commonprefix","getsize","getmtime",

"getatime","getctime", "islink","exists","lexists","isdir","isfile",

"ismount","isreserved","expanduser","expandvars","normpath",

"abspath","curdir","pardir","sep","pathsep","defpath","altsep",

"extsep","devnull","realpath","supports_unicode_filenames","relpath",

"samefile", "sameopenfile", "samestat", "commonpath", "isjunction",

if isinstance(path, bytes):

return b'\\/'

else:

"""Normalize case of pathname.

s = os.fspath(s)

if not s:

return s

if isinstance(s, bytes):

encoding = sys.getfilesystemencoding()

s = s.decode(encoding, 'surrogateescape').replace('/', '\\')

s = _LCMapStringEx(_LOCALE_NAME_INVARIANT,

_LCMAP_LOWERCASE, s)

return s.encode(encoding, 'surrogateescape')

else:

return _LCMapStringEx(_LOCALE_NAME_INVARIANT,

_LCMAP_LOWERCASE,

"""Normalize case of pathname.

s = os.fspath(s)

if isinstance(s, bytes):

return os.fsencode(os.fsdecode(s).replace('/', '\\').lower())

"""Test whether a path is absolute"""

s = os.fspath(s)

if isinstance(s, bytes):

sep = b'\\'

altsep = b'/'

colon_sep = b':\\'

double_sep = b'\\\\'

else:

sep = '\\'

altsep = '/'

colon_sep = ':\\'

double_sep = '\\\\'

s = s[:3].replace(altsep, sep)

# Absolute: UNC, device, and paths with a drive and root.

path = os.fspath(path)

if isinstance(path, bytes):

sep = b'\\'

seps = b'\\/'

colon_seps = b':\\/'

else:

sep = '\\'

seps = '\\/'

colon_seps = ':\\/'

try:

result_drive, result_root, result_path = splitroot(path)

for p in paths:

p_drive, p_root, p_path = splitroot(p)

if p_root:

# Second path is absolute

if p_drive or not result_drive:

result_drive = p_drive

result_root = p_root

result_path = p_path

continue

elif p_drive and p_drive != result_drive:

if p_drive.lower() != result_drive.lower():

# Different drives => ignore the first path entirely

result_drive = p_drive

result_root = p_root

result_path = p_path

continue

# Same drive in different case

result_drive = p_drive

# Second path is relative to the first

if result_path and result_path[-1] not in seps:

result_path = result_path + sep

result_path = result_path + p_path

## add separator between UNC and non-absolute path

if (result_path and not result_root and

result_drive and result_drive[-1] not in colon_seps):

return result_drive + sep + result_path

return result_drive + result_root + result_path

except (TypeError, AttributeError, BytesWarning):

genericpath._check_arg_types('join', path, *paths)

"""Split a pathname into drive/UNC sharepoint and relative path specifiers.

drive, root, tail = splitroot(p)

"""Split a pathname into drive, root and tail.

p = os.fspath(p)

if isinstance(p, bytes):

sep = b'\\'

altsep = b'/'

colon = b':'

unc_prefix = b'\\\\?\\UNC\\'

empty = b''

else:

sep = '\\'

altsep = '/'

colon = ':'

unc_prefix = '\\\\?\\UNC\\'

empty = ''

normp = p.replace(altsep, sep)

if normp[:1] == sep:

if normp[1:2] == sep:

# UNC drives, e.g. \\server\share or \\?\UNC\server\share

# Device drives, e.g. \\.\device or \\?\device

start = 8 if normp[:8].upper() == unc_prefix else 2

index = normp.find(sep, start)

if index == -1:

return p, empty, empty

index2 = normp.find(sep, index + 1)

if index2 == -1:

return p, empty, empty

return p[:index2], p[index2:index2 + 1], p[index2 + 1:]

else:

# Relative path with root, e.g. \Windows

return empty, p[:1], p[1:]

elif normp[1:2] == colon:

if normp[2:3] == sep:

# Absolute drive-letter path, e.g. X:\Windows

return p[:2], p[2:3], p[3:]

else:

# Relative path with drive, e.g. X:Windows

return p[:2], empty, p[2:]

else:

# Relative path, e.g. Windows

"""Split a pathname.

p = os.fspath(p)

seps = _get_bothseps(p)

d, r, p = splitroot(p)

# set i to index beyond p's last slash

i = len(p)

while i and p[i-1] not in seps:

i -= 1

head, tail = p[:i], p[i:] # now tail has no slashes

p = os.fspath(p)

if isinstance(p, bytes):

return genericpath._splitext(p, b'\\', b'/', b'.')

else:

"""Test whether a path is a mount point (a drive root, the root of a

path = os.fspath(path)

seps = _get_bothseps(path)

path = abspath(path)

drive, root, rest = splitroot(path)

if drive and drive[0] in seps:

return not rest

if root and not rest:

return True

if _getvolumepathname:

x = path.rstrip(seps)

y =_getvolumepathname(path).rstrip(seps)

return x.casefold() == y.casefold()

else:

{'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'}

"""Return true if the pathname is reserved by the system."""

# Refer to "Naming Files, Paths, and Namespaces":

# https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file

path = os.fsdecode(splitroot(path)[2]).replace(altsep, sep)

"""Return true if the filename is reserved by the system."""

# Trailing dots and spaces are reserved.

if name[-1:] in ('.', ' '):

return name not in ('.', '..')

# Wildcards, separators, colon, and pipe (*?"<>/\:|) are reserved.

# ASCII control characters (0-31) are reserved.

# Colon is reserved for file streams (e.g. "name:stream[:type]").

if _reserved_chars.intersection(name):

return True

# DOS device names are reserved (e.g. "nul" or "nul .txt"). The rules

# are complex and vary across Windows versions. On the side of

# caution, return True for names that may not be reserved.

"""Expand ~ and ~user constructs.

path = os.fspath(path)

if isinstance(path, bytes):

seps = b'\\/'

tilde = b'~'

else:

seps = '\\/'

tilde = '~'

if not path.startswith(tilde):

return path

i, n = 1, len(path)

while i < n and path[i] not in seps:

i += 1

if 'USERPROFILE' in os.environ:

userhome = os.environ['USERPROFILE']

elif 'HOMEPATH' not in os.environ:

return path

else:

drive = os.environ.get('HOMEDRIVE', '')

userhome = join(drive, os.environ['HOMEPATH'])

if i != 1: #~user

target_user = path[1:i]

if isinstance(target_user, bytes):

target_user = os.fsdecode(target_user)

current_user = os.environ.get('USERNAME')

if target_user != current_user:

# Try to guess user home directory. By default all user

# profile directories are located in the same place and are

# named by corresponding usernames. If userhome isn't a

# normal profile directory, this guess is likely wrong,

# so we bail out.

if current_user != basename(userhome):

return path

userhome = join(dirname(userhome), target_user)

if isinstance(path, bytes):

userhome = os.fsencode(userhome)

"""Expand shell variables of the forms $var, ${var} and %var%.

path = os.fspath(path)

global _varsub, _varsubb

if isinstance(path, bytes):

if b'$' not in path and b'%' not in path:

return path

if not _varsubb:

import re

_varsubb = re.compile(_varpattern.encode(), re.ASCII).sub

sub = _varsubb

percent = b'%'

brace = b'{'

rbrace = b'}'

dollar = b'$'

environ = getattr(os, 'environb', None)

else:

if '$' not in path and '%' not in path:

return path

if not _varsub:

import re

_varsub = re.compile(_varpattern, re.ASCII).sub

sub = _varsub

percent = '%'

brace = '{'

rbrace = '}'

dollar = '$'

environ = os.environ

def repl(m):

lastindex = m.lastindex

if lastindex is None:

return m[0]

name = m[lastindex]

if lastindex == 1:

if name == percent:

return name

if not name.endswith(percent):

return m[0]

name = name[:-1]

else:

if name == dollar:

return name

if name.startswith(brace):

if not name.endswith(rbrace):

return m[0]

name = name[1:-1]

try:

if environ is None:

return os.fsencode(os.environ[os.fsdecode(name)])

else:

return environ[name]

except KeyError:

return m[0]

"""Normalize path, eliminating double slashes, etc."""

path = os.fspath(path)

if isinstance(path, bytes):

sep = b'\\'

altsep = b'/'

curdir = b'.'

pardir = b'..'

else:

sep = '\\'

altsep = '/'

curdir = '.'

pardir = '..'

path = path.replace(altsep, sep)

drive, root, path = splitroot(path)

prefix = drive + root

comps = path.split(sep)

i = 0

while i < len(comps):

if not comps[i] or comps[i] == curdir:

del comps[i]

elif comps[i] == pardir:

if i > 0 and comps[i-1] != pardir:

del comps[i-1:i+1]

i -= 1

elif i == 0 and root:

del comps[i]

else:

i += 1

else:

i += 1

# If the path is now empty, substitute '.'

if not prefix and not comps:

comps.append(curdir)

"""Return the absolute version of a path."""

path = os.fspath(path)

if not isabs(path):

if isinstance(path, bytes):

cwd = os.getcwdb()

else:

cwd = os.getcwd()

path = join(cwd, path)

"""Return the absolute version of a path."""

try:

return _getfullpathname(normpath(path))

except (OSError, ValueError):

# See gh-75230, handle outside for cleaner traceback

pass

path = os.fspath(path)

if not isabs(path):

if isinstance(path, bytes):

sep = b'\\'

getcwd = os.getcwdb

else:

sep = '\\'

getcwd = os.getcwd

drive, root, path = splitroot(path)

# Either drive or root can be nonempty, but not both.

if drive or root:

try:

path = join(_getfullpathname(drive + root), path)

except (OSError, ValueError):

# Drive "\0:" cannot exist; use the root directory.

path = drive + sep + path

else:

path = join(getcwd(), path)

# These error codes indicate that we should stop reading links and

# return the path we currently have.

# 1: ERROR_INVALID_FUNCTION

# 2: ERROR_FILE_NOT_FOUND

# 3: ERROR_DIRECTORY_NOT_FOUND

# 5: ERROR_ACCESS_DENIED

# 21: ERROR_NOT_READY (implies drive with no media)

# 32: ERROR_SHARING_VIOLATION (probably an NTFS paging file)

# 50: ERROR_NOT_SUPPORTED (implies no support for reparse points)

# 67: ERROR_BAD_NET_NAME (implies remote server unavailable)

# 87: ERROR_INVALID_PARAMETER

# 4390: ERROR_NOT_A_REPARSE_POINT

# 4392: ERROR_INVALID_REPARSE_DATA

# 4393: ERROR_REPARSE_TAG_INVALID

allowed_winerror = 1, 2, 3, 5, 21, 32, 50, 67, 87, 4390, 4392, 4393

seen = set()

while normcase(path) not in seen:

seen.add(normcase(path))

try:

old_path = path

path = _nt_readlink(path)

# Links may be relative, so resolve them against their

# own location

if not isabs(path):

# If it's something other than a symlink, we don't know

# what it's actually going to be resolved against, so

# just return the old path.

if not islink(old_path):

path = old_path

break

path = normpath(join(dirname(old_path), path))

except ignored_error as ex:

if ex.winerror in allowed_winerror:

break

raise

except ValueError:

# Stop on reparse points that are not symlinks

break

# These error codes indicate that we should stop resolving the path

# and return the value we currently have.

# 1: ERROR_INVALID_FUNCTION

# 2: ERROR_FILE_NOT_FOUND

# 3: ERROR_DIRECTORY_NOT_FOUND

# 5: ERROR_ACCESS_DENIED

# 21: ERROR_NOT_READY (implies drive with no media)

# 32: ERROR_SHARING_VIOLATION (probably an NTFS paging file)

# 50: ERROR_NOT_SUPPORTED

# 53: ERROR_BAD_NETPATH

# 65: ERROR_NETWORK_ACCESS_DENIED

# 67: ERROR_BAD_NET_NAME (implies remote server unavailable)

# 87: ERROR_INVALID_PARAMETER

# 123: ERROR_INVALID_NAME

# 161: ERROR_BAD_PATHNAME

# 1005: ERROR_UNRECOGNIZED_VOLUME

# 1920: ERROR_CANT_ACCESS_FILE

# 1921: ERROR_CANT_RESOLVE_FILENAME (implies unfollowable symlink)

allowed_winerror = 1, 2, 3, 5, 21, 32, 50, 53, 65, 67, 87, 123, 161, 1005, 1920, 1921

# Non-strict algorithm is to find as much of the target directory

# as we can and join the rest. join() is not used, because the tail

# can contain a colon and be mistaken for a drive (gh-102475).

if isinstance(path, bytes):

sep = b'\\'

else:

sep = '\\'

def join(path, tail):

if path[-1:] == sep or not tail:

return path + tail

return path + sep + tail

tail = path[:0]

while path:

try:

path = _getfinalpathname(path)

return join(path, tail)

except ignored_error as ex:

if ex.winerror not in allowed_winerror:

raise

try:

# The OS could not resolve this path fully, so we attempt

# to follow the link ourselves. If we succeed, join the tail

# and return.

new_path = _readlink_deep(path,

ignored_error=ignored_error)

if new_path != path:

return join(new_path, tail)

except ignored_error:

# If we fail to readlink(), let's keep traversing

pass

# If we get these errors, try to get the real name of the file without accessing it.

if ex.winerror in (1, 5, 32, 50, 87, 1920, 1921):

try:

name = _findfirstfile(path)

path, _ = split(path)

except ignored_error:

path, name = split(path)

else:

path, name = split(path)

if path and not name:

return path + tail

tail = join(name, tail)

path = normpath(path)

if isinstance(path, bytes):

prefix = b'\\\\?\\'

unc_prefix = b'\\\\?\\UNC\\'

new_unc_prefix = b'\\\\'

colon_sep = b':\\'

# bpo-38081: Special case for realpath(b'nul')

devnull = b'nul'

if normcase(path) == devnull:

return b'\\\\.\\NUL'

else:

prefix = '\\\\?\\'

unc_prefix = '\\\\?\\UNC\\'

new_unc_prefix = '\\\\'

colon_sep = ':\\'

# bpo-38081: Special case for realpath('nul')

devnull = 'nul'

if normcase(path) == devnull:

return '\\\\.\\NUL'

had_prefix = path.startswith(prefix)

if strict is ALLOW_MISSING:

ignored_error = FileNotFoundError

strict = True

elif strict:

ignored_error = ()

else:

ignored_error = OSError

if not had_prefix and not isabs(path):

# abspath() is used instead of join(cwd, path), because the path

# can be relative to another drive (gh-102475).

path = abspath(path)

try:

path = _getfinalpathname(path)

initial_winerror = 0

except ValueError as ex:

# gh-106242: Raised for embedded null characters

# In strict modes, we convert into an OSError.

# Non-strict mode returns the path as-is, since we've already

# made it absolute.

if strict:

raise OSError(str(ex)) from None

path = normpath(path)

except ignored_error as ex:

initial_winerror = ex.winerror

path = _getfinalpathname_nonstrict(path,

ignored_error=ignored_error)

# The path returned by _getfinalpathname will always start with \\?\ -

# strip off that prefix unless it was already provided on the original

# path.

if not had_prefix and path.startswith(prefix):

# For UNC drives, the path starts with \\?\UNC\.

if path.startswith(unc_prefix):

spath = new_unc_prefix + path[len(unc_prefix):]

# For drive-letter drives, the path starts with \\?\<letter>:\.

elif path.startswith(colon_sep, len(prefix) + 1):

spath = path[len(prefix):]

# For all others, e.g. volume GUID paths, it cannot be stripped.

else:

spath = None

if spath is not None:

# Ensure that the non-prefixed path resolves to the same path

try:

if _getfinalpathname(spath) == path:

path = spath

except ValueError:

# Unexpected, as an invalid path should not have gained a

# prefix at any point, but we ignore this error just in case.

pass

except OSError as ex:

# If the path does not exist and originally did not exist,

# then strip the prefix anyway.

if ex.winerror == initial_winerror:

path = spath

"""Return a relative version of a path"""

path = os.fspath(path)

if not path:

raise ValueError("no path specified")

if isinstance(path, bytes):

sep = b'\\'

curdir = b'.'

pardir = b'..'

else:

sep = '\\'

curdir = '.'

pardir = '..'

if start is None:

start = curdir

else:

start = os.fspath(start)

try:

start_abs = abspath(start)

path_abs = abspath(path)

start_drive, _, start_rest = splitroot(start_abs)

path_drive, _, path_rest = splitroot(path_abs)

if normcase(start_drive) != normcase(path_drive):

raise ValueError("path is on mount %r, start on mount %r" % (

path_drive, start_drive))

start_list = start_rest.split(sep) if start_rest else []

path_list = path_rest.split(sep) if path_rest else []

# Work out how much of the filepath is shared by start and path.

i = 0

for e1, e2 in zip(start_list, path_list):

if normcase(e1) != normcase(e2):

break

i += 1

rel_list = [pardir] * (len(start_list)-i) + path_list[i:]

if not rel_list:

return curdir

return sep.join(rel_list)

except (TypeError, ValueError, AttributeError, BytesWarning, DeprecationWarning):

genericpath._check_arg_types('relpath', path, start)

"""Given an iterable of path names, returns the longest common sub-path."""

paths = tuple(map(os.fspath, paths))

if not paths:

raise ValueError('commonpath() arg is an empty iterable')

if isinstance(paths[0], bytes):

sep = b'\\'

altsep = b'/'

curdir = b'.'

else:

sep = '\\'

altsep = '/'

curdir = '.'

try:

drivesplits = [splitroot(p.replace(altsep, sep).lower()) for p in paths]

split_paths = [p.split(sep) for d, r, p in drivesplits]

# Check that all drive letters or UNC paths match. The check is made only

# now otherwise type errors for mixing strings and bytes would not be

# caught.

if len({d for d, r, p in drivesplits}) != 1:

raise ValueError("Paths don't have the same drive")

drive, root, path = splitroot(paths[0].replace(altsep, sep))

if len({r for d, r, p in drivesplits}) != 1:

if drive:

raise ValueError("Can't mix absolute and relative paths")

else:

raise ValueError("Can't mix rooted and not-rooted paths")

common = path.split(sep)

common = [c for c in common if c and c != curdir]

split_paths = [[c for c in s if c and c != curdir] for s in split_paths]

s1 = min(split_paths)

s2 = max(split_paths)

for i, c in enumerate(s1):

if c != s2[i]:

common = common[:i]

break

else:

common = common[:len(s1)]

return drive + root + sep.join(common)

except (TypeError, AttributeError):

genericpath._check_arg_types('commonpath', *paths)

"""Determines whether the specified path is on a Windows Dev Drive."""

try:

return _path_isdevdrive(abspath(path))

except OSError: