Lib/ntpath.py

   1 # Module 'ntpath' -- common operations on WinNT/Win95 pathnames
   2 """Common pathname manipulations, WindowsNT/95 version.
   3
   4 Instead of importing this module directly, import os and refer to this
   5 module as os.path.
   6 """
   7
   8 import os
   9 import stat
  10
  11 __all__ = ["normcase","isabs","join","splitdrive","split","splitext",
  12            "basename","dirname","commonprefix","getsize","getmtime",
  13            "getatime","islink","exists","isdir","isfile","ismount",
  14            "walk","expanduser","expandvars","normpath","abspath","splitunc"]
  15
  16 # Normalize the case of a pathname and map slashes to backslashes.
  17 # Other normalizations (such as optimizing '../' away) are not done
  18 # (this is done by normpath).
  19
  20 def normcase(s):
  21     """Normalize case of pathname.
  22
  23     Makes all characters lowercase and all slashes into backslashes."""
  24     return s.replace("/", "\\").lower()
  25
  26
  27 # Return whether a path is absolute.
  28 # Trivial in Posix, harder on the Mac or MS-DOS.
  29 # For DOS it is absolute if it starts with a slash or backslash (current
  30 # volume), or if a pathname after the volume letter and colon / UNC resource
  31 # starts with a slash or backslash.
  32
  33 def isabs(s):
  34     """Test whether a path is absolute"""
  35     s = splitdrive(s)[1]
  36     return s != '' and s[:1] in '/\\'
  37
  38
  39 # Join two (or more) paths.
  40
  41 def join(a, *p):
  42     """Join two or more pathname components, inserting "\\" as needed"""
  43     path = a
  44     for b in p:
  45         b_wins = 0  # set to 1 iff b makes path irrelevant
  46         if path == "":
  47             b_wins = 1
  48
  49         elif isabs(b):
  50             # This probably wipes out path so far.  However, it's more
  51             # complicated if path begins with a drive letter:
  52             #     1. join('c:', '/a') == 'c:/a'
  53             #     2. join('c:/', '/a') == 'c:/a'
  54             # But
  55             #     3. join('c:/a', '/b') == '/b'
  56             #     4. join('c:', 'd:/') = 'd:/'
  57             #     5. join('c:/', 'd:/') = 'd:/'
  58             if path[1:2] != ":" or b[1:2] == ":":
  59                 # Path doesn't start with a drive letter, or cases 4 and 5.
  60                 b_wins = 1
  61
  62             # Else path has a drive letter, and b doesn't but is absolute.
  63             elif len(path) > 3 or (len(path) == 3 and
  64                                    path[-1] not in "/\\"):
  65                 # case 3
  66                 b_wins = 1
  67
  68         if b_wins:
  69             path = b
  70         else:
  71             # Join, and ensure there's a separator.
  72             assert len(path) > 0
  73             if path[-1] in "/\\":
  74                 if b and b[0] in "/\\":
  75                     path += b[1:]
  76                 else:
  77                     path += b
  78             elif path[-1] == ":":
  79                 path += b
  80             elif b:
  81                 if b[0] in "/\\":
  82                     path += b
  83                 else:
  84                     path += "\\" + b
  85
  86     return path
  87
  88
  89 # Split a path in a drive specification (a drive letter followed by a
  90 # colon) and the path specification.
  91 # It is always true that drivespec + pathspec == p
  92 def splitdrive(p):
  93     """Split a pathname into drive and path specifiers. Returns a 2-tuple
  94 "(drive,path)";  either part may be empty"""
  95     if p[1:2] == ':':
  96         return p[0:2], p[2:]
  97     return '', p
  98
  99
 100 # Parse UNC paths
 101 def splitunc(p):
 102     """Split a pathname into UNC mount point and relative path specifiers.
 103
 104     Return a 2-tuple (unc, rest); either part may be empty.
 105     If unc is not empty, it has the form '//host/mount' (or similar
 106     using backslashes).  unc+rest is always the input path.
 107     Paths containing drive letters never have an UNC part.
 108     """
 109     if p[1:2] == ':':
 110         return '', p # Drive letter present
 111     firstTwo = p[0:2]
 112     if firstTwo == '//' or firstTwo == '\\\\':
 113         # is a UNC path:
 114         # vvvvvvvvvvvvvvvvvvvv equivalent to drive letter
 115         # \\machine\mountpoint\directories...
 116         #           directory ^^^^^^^^^^^^^^^
 117         normp = normcase(p)
 118         index = normp.find('\\', 2)
 119         if index == -1:
 120             ##raise RuntimeError, 'illegal UNC path: "' + p + '"'
 121             return ("", p)
 122         index = normp.find('\\', index + 1)
 123         if index == -1:
 124             index = len(p)
 125         return p[:index], p[index:]
 126     return '', p
 127
 128
 129 # Split a path in head (everything up to the last '/') and tail (the
 130 # rest).  After the trailing '/' is stripped, the invariant
 131 # join(head, tail) == p holds.
 132 # The resulting head won't end in '/' unless it is the root.
 133
 134 def split(p):
 135     """Split a pathname.
 136
 137     Return tuple (head, tail) where tail is everything after the final slash.
 138     Either part may be empty."""
 139
 140     d, p = splitdrive(p)
 141     # set i to index beyond p's last slash
 142     i = len(p)
 143     while i and p[i-1] not in '/\\':
 144         i = i - 1
 145     head, tail = p[:i], p[i:]  # now tail has no slashes
 146     # remove trailing slashes from head, unless it's all slashes
 147     head2 = head
 148     while head2 and head2[-1] in '/\\':
 149         head2 = head2[:-1]
 150     head = head2 or head
 151     return d + head, tail
 152
 153
 154 # Split a path in root and extension.
 155 # The extension is everything starting at the last dot in the last
 156 # pathname component; the root is everything before that.
 157 # It is always true that root + ext == p.
 158
 159 def splitext(p):
 160     """Split the extension from a pathname.
 161
 162     Extension is everything from the last dot to the end.
 163     Return (root, ext), either part may be empty."""
 164     root, ext = '', ''
 165     for c in p:
 166         if c in ['/','\\']:
 167             root, ext = root + ext + c, ''
 168         elif c == '.':
 169             if ext:
 170                 root, ext = root + ext, c
 171             else:
 172                 ext = c
 173         elif ext:
 174             ext = ext + c
 175         else:
 176             root = root + c
 177     return root, ext
 178
 179
 180 # Return the tail (basename) part of a path.
 181
 182 def basename(p):
 183     """Returns the final component of a pathname"""
 184     return split(p)[1]
 185
 186
 187 # Return the head (dirname) part of a path.
 188
 189 def dirname(p):
 190     """Returns the directory component of a pathname"""
 191     return split(p)[0]
 192
 193
 194 # Return the longest prefix of all list elements.
 195
 196 def commonprefix(m):
 197     "Given a list of pathnames, returns the longest common leading component"
 198     if not m: return ''
 199     prefix = m[0]
 200     for item in m:
 201         for i in range(len(prefix)):
 202             if prefix[:i+1] != item[:i+1]:
 203                 prefix = prefix[:i]
 204                 if i == 0: return ''
 205                 break
 206     return prefix
 207
 208
 209 # Get size, mtime, atime of files.
 210
 211 def getsize(filename):
 212     """Return the size of a file, reported by os.stat()"""
 213     st = os.stat(filename)
 214     return st[stat.ST_SIZE]
 215
 216 def getmtime(filename):
 217     """Return the last modification time of a file, reported by os.stat()"""
 218     st = os.stat(filename)
 219     return st[stat.ST_MTIME]
 220
 221 def getatime(filename):
 222     """Return the last access time of a file, reported by os.stat()"""
 223     st = os.stat(filename)
 224     return st[stat.ST_ATIME]
 225
 226
 227 # Is a path a symbolic link?
 228 # This will always return false on systems where posix.lstat doesn't exist.
 229
 230 def islink(path):
 231     """Test for symbolic link.  On WindowsNT/95 always returns false"""
 232     return 0
 233
 234
 235 # Does a path exist?
 236 # This is false for dangling symbolic links.
 237
 238 def exists(path):
 239     """Test whether a path exists"""
 240     try:
 241         st = os.stat(path)
 242     except os.error:
 243         return 0
 244     return 1
 245
 246
 247 # Is a path a dos directory?
 248 # This follows symbolic links, so both islink() and isdir() can be true
 249 # for the same path.
 250
 251 def isdir(path):
 252     """Test whether a path is a directory"""
 253     try:
 254         st = os.stat(path)
 255     except os.error:
 256         return 0
 257     return stat.S_ISDIR(st[stat.ST_MODE])
 258
 259
 260 # Is a path a regular file?
 261 # This follows symbolic links, so both islink() and isdir() can be true
 262 # for the same path.
 263
 264 def isfile(path):
 265     """Test whether a path is a regular file"""
 266     try:
 267         st = os.stat(path)
 268     except os.error:
 269         return 0
 270     return stat.S_ISREG(st[stat.ST_MODE])
 271
 272
 273 # Is a path a mount point?  Either a root (with or without drive letter)
 274 # or an UNC path with at most a / or \ after the mount point.
 275
 276 def ismount(path):
 277     """Test whether a path is a mount point (defined as root of drive)"""
 278     unc, rest = splitunc(path)
 279     if unc:
 280         return rest in ("", "/", "\\")
 281     p = splitdrive(path)[1]
 282     return len(p) == 1 and p[0] in '/\\'
 283
 284
 285 # Directory tree walk.
 286 # For each directory under top (including top itself, but excluding
 287 # '.' and '..'), func(arg, dirname, filenames) is called, where
 288 # dirname is the name of the directory and filenames is the list
 289 # files files (and subdirectories etc.) in the directory.
 290 # The func may modify the filenames list, to implement a filter,
 291 # or to impose a different order of visiting.
 292
 293 def walk(top, func, arg):
 294     """Directory tree walk whth callback function.
 295
 296     walk(top, func, arg) calls func(arg, d, files) for each directory d
 297     in the tree rooted at top (including top itself); files is a list
 298     of all the files and subdirs in directory d."""
 299     try:
 300         names = os.listdir(top)
 301     except os.error:
 302         return
 303     func(arg, top, names)
 304     exceptions = ('.', '..')
 305     for name in names:
 306         if name not in exceptions:
 307             name = join(top, name)
 308             if isdir(name):
 309                 walk(name, func, arg)
 310
 311
 312 # Expand paths beginning with '~' or '~user'.
 313 # '~' means $HOME; '~user' means that user's home directory.
 314 # If the path doesn't begin with '~', or if the user or $HOME is unknown,
 315 # the path is returned unchanged (leaving error reporting to whatever
 316 # function is called with the expanded path as argument).
 317 # See also module 'glob' for expansion of *, ? and [...] in pathnames.
 318 # (A function should also be defined to do full *sh-style environment
 319 # variable expansion.)
 320
 321 def expanduser(path):
 322     """Expand ~ and ~user constructs.
 323
 324     If user or $HOME is unknown, do nothing."""
 325     if path[:1] != '~':
 326         return path
 327     i, n = 1, len(path)
 328     while i < n and path[i] not in '/\\':
 329         i = i + 1
 330     if i == 1:
 331         if os.environ.has_key('HOME'):
 332             userhome = os.environ['HOME']
 333         elif not os.environ.has_key('HOMEPATH'):
 334             return path
 335         else:
 336             try:
 337                 drive = os.environ['HOMEDRIVE']
 338             except KeyError:
 339                 drive = ''
 340             userhome = join(drive, os.environ['HOMEPATH'])
 341     else:
 342         return path
 343     return userhome + path[i:]
 344
 345
 346 # Expand paths containing shell variable substitutions.
 347 # The following rules apply:
 348 #       - no expansion within single quotes
 349 #       - no escape character, except for '$$' which is translated into '$'
 350 #       - ${varname} is accepted.
 351 #       - varnames can be made out of letters, digits and the character '_'
 352 # XXX With COMMAND.COM you can use any characters in a variable name,
 353 # XXX except '^|<>='.
 354
 355 def expandvars(path):
 356     """Expand shell variables of form $var and ${var}.
 357
 358     Unknown variables are left unchanged."""
 359     if '$' not in path:
 360         return path
 361     import string
 362     varchars = string.ascii_letters + string.digits + '_-'
 363     res = ''
 364     index = 0
 365     pathlen = len(path)
 366     while index < pathlen:
 367         c = path[index]
 368         if c == '\'':   # no expansion within single quotes
 369             path = path[index + 1:]
 370             pathlen = len(path)
 371             try:
 372                 index = path.index('\'')
 373                 res = res + '\'' + path[:index + 1]
 374             except ValueError:
 375                 res = res + path
 376                 index = pathlen - 1
 377         elif c == '$':  # variable or '$$'
 378             if path[index + 1:index + 2] == '$':
 379                 res = res + c
 380                 index = index + 1
 381             elif path[index + 1:index + 2] == '{':
 382                 path = path[index+2:]
 383                 pathlen = len(path)
 384                 try:
 385                     index = path.index('}')
 386                     var = path[:index]
 387                     if os.environ.has_key(var):
 388                         res = res + os.environ[var]
 389                 except ValueError:
 390                     res = res + path
 391                     index = pathlen - 1
 392             else:
 393                 var = ''
 394                 index = index + 1
 395                 c = path[index:index + 1]
 396                 while c != '' and c in varchars:
 397                     var = var + c
 398                     index = index + 1
 399                     c = path[index:index + 1]
 400                 if os.environ.has_key(var):
 401                     res = res + os.environ[var]
 402                 if c != '':
 403                     res = res + c
 404         else:
 405             res = res + c
 406         index = index + 1
 407     return res
 408
 409
 410 # Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
 411 # Previously, this function also truncated pathnames to 8+3 format,
 412 # but as this module is called "ntpath", that's obviously wrong!
 413
 414 def normpath(path):
 415     """Normalize path, eliminating double slashes, etc."""
 416     path = path.replace("/", "\\")
 417     prefix, path = splitdrive(path)
 418     while path[:1] == "\\":
 419         prefix = prefix + "\\"
 420         path = path[1:]
 421     comps = path.split("\\")
 422     i = 0
 423     while i < len(comps):
 424         if comps[i] == '.':
 425             del comps[i]
 426         elif comps[i] == '..' and i > 0 and comps[i-1] not in ('', '..'):
 427             del comps[i-1:i+1]
 428             i = i - 1
 429         elif comps[i] == '' and i > 0 and comps[i-1] != '':
 430             del comps[i]
 431         else:
 432             i = i + 1
 433     # If the path is now empty, substitute '.'
 434     if not prefix and not comps:
 435         comps.append('.')
 436     return prefix + "\\".join(comps)
 437
 438
 439 # Return an absolute path.
 440 def abspath(path):
 441     """Return the absolute version of a path"""
 442     if path: # Empty path must return current working directory.
 443         from nt import _getfullpathname
 444         try:
 445             path = _getfullpathname(path)
 446         except WindowsError:
 447             pass # Bad path - return unchanged.
 448     else:
 449         path = os.getcwd()
 450     return normpath(path)