# Module 'ntpath' -- common operations on WinNT/Win95 pathnames | |
"""Common pathname manipulations, WindowsNT/95 version. | |
Instead of importing this module directly, import os and refer to this | |
module as os.path. | |
""" | |
import os | |
import sys | |
import stat | |
import genericpath | |
import warnings | |
from genericpath import * | |
__all__ = ["normcase","isabs","join","splitdrive","split","splitext", | |
"basename","dirname","commonprefix","getsize","getmtime", | |
"getatime","getctime", "islink","exists","lexists","isdir","isfile", | |
"ismount","walk","expanduser","expandvars","normpath","abspath", | |
"splitunc","curdir","pardir","sep","pathsep","defpath","altsep", | |
"extsep","devnull","realpath","supports_unicode_filenames","relpath"] | |
# strings representing various path-related bits and pieces | |
curdir = '.' | |
pardir = '..' | |
extsep = '.' | |
sep = '\\' | |
pathsep = ';' | |
altsep = '/' | |
defpath = '.;C:\\bin' | |
if 'ce' in sys.builtin_module_names: | |
defpath = '\\Windows' | |
elif 'os2' in sys.builtin_module_names: | |
# OS/2 w/ VACPP | |
altsep = '/' | |
devnull = 'nul' | |
# Normalize the case of a pathname and map slashes to backslashes. | |
# Other normalizations (such as optimizing '../' away) are not done | |
# (this is done by normpath). | |
def normcase(s): | |
"""Normalize case of pathname. | |
Makes all characters lowercase and all slashes into backslashes.""" | |
return s.replace("/", "\\").lower() | |
# Return whether a path is absolute. | |
# Trivial in Posix, harder on the Mac or MS-DOS. | |
# For DOS it is absolute if it starts with a slash or backslash (current | |
# volume), or if a pathname after the volume letter and colon / UNC resource | |
# starts with a slash or backslash. | |
def isabs(s): | |
"""Test whether a path is absolute""" | |
s = splitdrive(s)[1] | |
return s != '' and s[:1] in '/\\' | |
# Join two (or more) paths. | |
def join(a, *p): | |
"""Join two or more pathname components, inserting "\\" as needed. | |
If any component is an absolute path, all previous path components | |
will be discarded.""" | |
path = a | |
for b in p: | |
b_wins = 0 # set to 1 iff b makes path irrelevant | |
if path == "": | |
b_wins = 1 | |
elif isabs(b): | |
# This probably wipes out path so far. However, it's more | |
# complicated if path begins with a drive letter: | |
# 1. join('c:', '/a') == 'c:/a' | |
# 2. join('c:/', '/a') == 'c:/a' | |
# But | |
# 3. join('c:/a', '/b') == '/b' | |
# 4. join('c:', 'd:/') = 'd:/' | |
# 5. join('c:/', 'd:/') = 'd:/' | |
if path[1:2] != ":" or b[1:2] == ":": | |
# Path doesn't start with a drive letter, or cases 4 and 5. | |
b_wins = 1 | |
# Else path has a drive letter, and b doesn't but is absolute. | |
elif len(path) > 3 or (len(path) == 3 and | |
path[-1] not in "/\\"): | |
# case 3 | |
b_wins = 1 | |
if b_wins: | |
path = b | |
else: | |
# Join, and ensure there's a separator. | |
assert len(path) > 0 | |
if path[-1] in "/\\": | |
if b and b[0] in "/\\": | |
path += b[1:] | |
else: | |
path += b | |
elif path[-1] == ":": | |
path += b | |
elif b: | |
if b[0] in "/\\": | |
path += b | |
else: | |
path += "\\" + b | |
else: | |
# path is not empty and does not end with a backslash, | |
# but b is empty; since, e.g., split('a/') produces | |
# ('a', ''), it's best if join() adds a backslash in | |
# this case. | |
path += '\\' | |
return path | |
# Split a path in a drive specification (a drive letter followed by a | |
# colon) and the path specification. | |
# It is always true that drivespec + pathspec == p | |
def splitdrive(p): | |
"""Split a pathname into drive and path specifiers. Returns a 2-tuple | |
"(drive,path)"; either part may be empty""" | |
if p[1:2] == ':': | |
return p[0:2], p[2:] | |
return '', p | |
# Parse UNC paths | |
def splitunc(p): | |
"""Split a pathname into UNC mount point and relative path specifiers. | |
Return a 2-tuple (unc, rest); either part may be empty. | |
If unc is not empty, it has the form '//host/mount' (or similar | |
using backslashes). unc+rest is always the input path. | |
Paths containing drive letters never have an UNC part. | |
""" | |
if p[1:2] == ':': | |
return '', p # Drive letter present | |
firstTwo = p[0:2] | |
if firstTwo == '//' or firstTwo == '\\\\': | |
# is a UNC path: | |
# vvvvvvvvvvvvvvvvvvvv equivalent to drive letter | |
# \\machine\mountpoint\directories... | |
# directory ^^^^^^^^^^^^^^^ | |
normp = normcase(p) | |
index = normp.find('\\', 2) | |
if index == -1: | |
##raise RuntimeError, 'illegal UNC path: "' + p + '"' | |
return ("", p) | |
index = normp.find('\\', index + 1) | |
if index == -1: | |
index = len(p) | |
return p[:index], p[index:] | |
return '', p | |
# Split a path in head (everything up to the last '/') and tail (the | |
# rest). After the trailing '/' is stripped, the invariant | |
# join(head, tail) == p holds. | |
# The resulting head won't end in '/' unless it is the root. | |
def split(p): | |
"""Split a pathname. | |
Return tuple (head, tail) where tail is everything after the final slash. | |
Either part may be empty.""" | |
d, p = splitdrive(p) | |
# set i to index beyond p's last slash | |
i = len(p) | |
while i and p[i-1] not in '/\\': | |
i = i - 1 | |
head, tail = p[:i], p[i:] # now tail has no slashes | |
# remove trailing slashes from head, unless it's all slashes | |
head2 = head | |
while head2 and head2[-1] in '/\\': | |
head2 = head2[:-1] | |
head = head2 or head | |
return d + head, tail | |
# Split a path in root and extension. | |
# The extension is everything starting at the last dot in the last | |
# pathname component; the root is everything before that. | |
# It is always true that root + ext == p. | |
def splitext(p): | |
return genericpath._splitext(p, sep, altsep, extsep) | |
splitext.__doc__ = genericpath._splitext.__doc__ | |
# Return the tail (basename) part of a path. | |
def basename(p): | |
"""Returns the final component of a pathname""" | |
return split(p)[1] | |
# Return the head (dirname) part of a path. | |
def dirname(p): | |
"""Returns the directory component of a pathname""" | |
return split(p)[0] | |
# Is a path a symbolic link? | |
# This will always return false on systems where posix.lstat doesn't exist. | |
def islink(path): | |
"""Test for symbolic link. | |
On WindowsNT/95 and OS/2 always returns false | |
""" | |
return False | |
# alias exists to lexists | |
lexists = exists | |
# Is a path a mount point? Either a root (with or without drive letter) | |
# or an UNC path with at most a / or \ after the mount point. | |
def ismount(path): | |
"""Test whether a path is a mount point (defined as root of drive)""" | |
unc, rest = splitunc(path) | |
if unc: | |
return rest in ("", "/", "\\") | |
p = splitdrive(path)[1] | |
return len(p) == 1 and p[0] in '/\\' | |
# Directory tree walk. | |
# For each directory under top (including top itself, but excluding | |
# '.' and '..'), func(arg, dirname, filenames) is called, where | |
# dirname is the name of the directory and filenames is the list | |
# of files (and subdirectories etc.) in the directory. | |
# The func may modify the filenames list, to implement a filter, | |
# or to impose a different order of visiting. | |
def walk(top, func, arg): | |
"""Directory tree walk with callback function. | |
For each directory in the directory tree rooted at top (including top | |
itself, but excluding '.' and '..'), call func(arg, dirname, fnames). | |
dirname is the name of the directory, and fnames a list of the names of | |
the files and subdirectories in dirname (excluding '.' and '..'). func | |
may modify the fnames list in-place (e.g. via del or slice assignment), | |
and walk will only recurse into the subdirectories whose names remain in | |
fnames; this can be used to implement a filter, or to impose a specific | |
order of visiting. No semantics are defined for, or required of, arg, | |
beyond that arg is always passed to func. It can be used, e.g., to pass | |
a filename pattern, or a mutable object designed to accumulate | |
statistics. Passing None for arg is common.""" | |
warnings.warnpy3k("In 3.x, os.path.walk is removed in favor of os.walk.", | |
stacklevel=2) | |
try: | |
names = os.listdir(top) | |
except os.error: | |
return | |
func(arg, top, names) | |
for name in names: | |
name = join(top, name) | |
if isdir(name): | |
walk(name, func, arg) | |
# Expand paths beginning with '~' or '~user'. | |
# '~' means $HOME; '~user' means that user's home directory. | |
# If the path doesn't begin with '~', or if the user or $HOME is unknown, | |
# the path is returned unchanged (leaving error reporting to whatever | |
# function is called with the expanded path as argument). | |
# See also module 'glob' for expansion of *, ? and [...] in pathnames. | |
# (A function should also be defined to do full *sh-style environment | |
# variable expansion.) | |
def expanduser(path): | |
"""Expand ~ and ~user constructs. | |
If user or $HOME is unknown, do nothing.""" | |
if path[:1] != '~': | |
return path | |
i, n = 1, len(path) | |
while i < n and path[i] not in '/\\': | |
i = i + 1 | |
if 'HOME' in os.environ: | |
userhome = os.environ['HOME'] | |
elif 'USERPROFILE' in os.environ: | |
userhome = os.environ['USERPROFILE'] | |
elif not 'HOMEPATH' in os.environ: | |
return path | |
else: | |
try: | |
drive = os.environ['HOMEDRIVE'] | |
except KeyError: | |
drive = '' | |
userhome = join(drive, os.environ['HOMEPATH']) | |
if i != 1: #~user | |
userhome = join(dirname(userhome), path[1:i]) | |
return userhome + path[i:] | |
# Expand paths containing shell variable substitutions. | |
# The following rules apply: | |
# - no expansion within single quotes | |
# - '$$' is translated into '$' | |
# - '%%' is translated into '%' if '%%' are not seen in %var1%%var2% | |
# - ${varname} is accepted. | |
# - $varname is accepted. | |
# - %varname% is accepted. | |
# - varnames can be made out of letters, digits and the characters '_-' | |
# (though is not verified in the ${varname} and %varname% cases) | |
# XXX With COMMAND.COM you can use any characters in a variable name, | |
# XXX except '^|<>='. | |
def expandvars(path): | |
"""Expand shell variables of the forms $var, ${var} and %var%. | |
Unknown variables are left unchanged.""" | |
if '$' not in path and '%' not in path: | |
return path | |
import string | |
varchars = string.ascii_letters + string.digits + '_-' | |
res = '' | |
index = 0 | |
pathlen = len(path) | |
while index < pathlen: | |
c = path[index] | |
if c == '\'': # no expansion within single quotes | |
path = path[index + 1:] | |
pathlen = len(path) | |
try: | |
index = path.index('\'') | |
res = res + '\'' + path[:index + 1] | |
except ValueError: | |
res = res + path | |
index = pathlen - 1 | |
elif c == '%': # variable or '%' | |
if path[index + 1:index + 2] == '%': | |
res = res + c | |
index = index + 1 | |
else: | |
path = path[index+1:] | |
pathlen = len(path) | |
try: | |
index = path.index('%') | |
except ValueError: | |
res = res + '%' + path | |
index = pathlen - 1 | |
else: | |
var = path[:index] | |
if var in os.environ: | |
res = res + os.environ[var] | |
else: | |
res = res + '%' + var + '%' | |
elif c == '$': # variable or '$$' | |
if path[index + 1:index + 2] == '$': | |
res = res + c | |
index = index + 1 | |
elif path[index + 1:index + 2] == '{': | |
path = path[index+2:] | |
pathlen = len(path) | |
try: | |
index = path.index('}') | |
var = path[:index] | |
if var in os.environ: | |
res = res + os.environ[var] | |
else: | |
res = res + '${' + var + '}' | |
except ValueError: | |
res = res + '${' + path | |
index = pathlen - 1 | |
else: | |
var = '' | |
index = index + 1 | |
c = path[index:index + 1] | |
while c != '' and c in varchars: | |
var = var + c | |
index = index + 1 | |
c = path[index:index + 1] | |
if var in os.environ: | |
res = res + os.environ[var] | |
else: | |
res = res + '$' + var | |
if c != '': | |
index = index - 1 | |
else: | |
res = res + c | |
index = index + 1 | |
return res | |
# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A\B. | |
# Previously, this function also truncated pathnames to 8+3 format, | |
# but as this module is called "ntpath", that's obviously wrong! | |
def normpath(path): | |
"""Normalize path, eliminating double slashes, etc.""" | |
# Preserve unicode (if path is unicode) | |
backslash, dot = (u'\\', u'.') if isinstance(path, unicode) else ('\\', '.') | |
if path.startswith(('\\\\.\\', '\\\\?\\')): | |
# in the case of paths with these prefixes: | |
# \\.\ -> device names | |
# \\?\ -> literal paths | |
# do not do any normalization, but return the path unchanged | |
return path | |
path = path.replace("/", "\\") | |
prefix, path = splitdrive(path) | |
# We need to be careful here. If the prefix is empty, and the path starts | |
# with a backslash, it could either be an absolute path on the current | |
# drive (\dir1\dir2\file) or a UNC filename (\\server\mount\dir1\file). It | |
# is therefore imperative NOT to collapse multiple backslashes blindly in | |
# that case. | |
# The code below preserves multiple backslashes when there is no drive | |
# letter. This means that the invalid filename \\\a\b is preserved | |
# unchanged, where a\\\b is normalised to a\b. It's not clear that there | |
# is any better behaviour for such edge cases. | |
if prefix == '': | |
# No drive letter - preserve initial backslashes | |
while path[:1] == "\\": | |
prefix = prefix + backslash | |
path = path[1:] | |
else: | |
# We have a drive letter - collapse initial backslashes | |
if path.startswith("\\"): | |
prefix = prefix + backslash | |
path = path.lstrip("\\") | |
comps = path.split("\\") | |
i = 0 | |
while i < len(comps): | |
if comps[i] in ('.', ''): | |
del comps[i] | |
elif comps[i] == '..': | |
if i > 0 and comps[i-1] != '..': | |
del comps[i-1:i+1] | |
i -= 1 | |
elif i == 0 and prefix.endswith("\\"): | |
del comps[i] | |
else: | |
i += 1 | |
else: | |
i += 1 | |
# If the path is now empty, substitute '.' | |
if not prefix and not comps: | |
comps.append(dot) | |
return prefix + backslash.join(comps) | |
# Return an absolute path. | |
try: | |
from nt import _getfullpathname | |
except ImportError: # not running on Windows - mock up something sensible | |
def abspath(path): | |
"""Return the absolute version of a path.""" | |
if not isabs(path): | |
if isinstance(path, unicode): | |
cwd = os.getcwdu() | |
else: | |
cwd = os.getcwd() | |
path = join(cwd, path) | |
return normpath(path) | |
else: # use native Windows method on Windows | |
def abspath(path): | |
"""Return the absolute version of a path.""" | |
if path: # Empty path must return current working directory. | |
try: | |
path = _getfullpathname(path) | |
except WindowsError: | |
pass # Bad path - return unchanged. | |
elif isinstance(path, unicode): | |
path = os.getcwdu() | |
else: | |
path = os.getcwd() | |
return normpath(path) | |
# realpath is a no-op on systems without islink support | |
realpath = abspath | |
# Win9x family and earlier have no Unicode filename support. | |
supports_unicode_filenames = (hasattr(sys, "getwindowsversion") and | |
sys.getwindowsversion()[3] >= 2) | |
def _abspath_split(path): | |
abs = abspath(normpath(path)) | |
prefix, rest = splitunc(abs) | |
is_unc = bool(prefix) | |
if not is_unc: | |
prefix, rest = splitdrive(abs) | |
return is_unc, prefix, [x for x in rest.split(sep) if x] | |
def relpath(path, start=curdir): | |
"""Return a relative version of a path""" | |
if not path: | |
raise ValueError("no path specified") | |
start_is_unc, start_prefix, start_list = _abspath_split(start) | |
path_is_unc, path_prefix, path_list = _abspath_split(path) | |
if path_is_unc ^ start_is_unc: | |
raise ValueError("Cannot mix UNC and non-UNC paths (%s and %s)" | |
% (path, start)) | |
if path_prefix.lower() != start_prefix.lower(): | |
if path_is_unc: | |
raise ValueError("path is on UNC root %s, start on UNC root %s" | |
% (path_prefix, start_prefix)) | |
else: | |
raise ValueError("path is on drive %s, start on drive %s" | |
% (path_prefix, start_prefix)) | |
# 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 e1.lower() != e2.lower(): | |
break | |
i += 1 | |
rel_list = [pardir] * (len(start_list)-i) + path_list[i:] | |
if not rel_list: | |
return curdir | |
return join(*rel_list) |