Lib/macpath.py

   1 """Pathname and path-related operations for the Macintosh."""
   2
   3 import os
   4 from stat import *
   5
   6
   7 # Normalize the case of a pathname.  Dummy in Posix, but <s>.lower() here.
   8
   9 def normcase(path):
  10     return path.lower()
  11
  12
  13 def isabs(s):
  14     """Return true if a path is absolute.
  15     On the Mac, relative paths begin with a colon,
  16     but as a special case, paths with no colons at all are also relative.
  17     Anything else is absolute (the string up to the first colon is the
  18     volume name)."""
  19
  20     return ':' in s and s[0] <> ':'
  21
  22
  23 def join(s, *p):
  24     path = s
  25     for t in p:
  26         if (not s) or isabs(t):
  27             path = t
  28             continue
  29         if t[:1] == ':':
  30             t = t[1:]
  31         if ':' not in path:
  32             path = ':' + path
  33         if path[-1:] <> ':':
  34             path = path + ':'
  35         path = path + t
  36     return path
  37
  38
  39 def split(s):
  40     """Split a pathname into two parts: the directory leading up to the final
  41     bit, and the basename (the filename, without colons, in that directory).
  42     The result (s, t) is such that join(s, t) yields the original argument."""
  43
  44     if ':' not in s: return '', s
  45     colon = 0
  46     for i in range(len(s)):
  47         if s[i] == ':': colon = i + 1
  48     path, file = s[:colon-1], s[colon:]
  49     if path and not ':' in path:
  50         path = path + ':'
  51     return path, file
  52
  53
  54 def splitext(p):
  55     """Split a path into root and extension.
  56     The extension is everything starting at the last dot in the last
  57     pathname component; the root is everything before that.
  58     It is always true that root + ext == p."""
  59
  60     root, ext = '', ''
  61     for c in p:
  62         if c == ':':
  63             root, ext = root + ext + c, ''
  64         elif c == '.':
  65             if ext:
  66                 root, ext = root + ext, c
  67             else:
  68                 ext = c
  69         elif ext:
  70             ext = ext + c
  71         else:
  72             root = root + c
  73     return root, ext
  74
  75
  76 def splitdrive(p):
  77     """Split a pathname into a drive specification and the rest of the
  78     path.  Useful on DOS/Windows/NT; on the Mac, the drive is always
  79     empty (don't use the volume name -- it doesn't have the same
  80     syntactic and semantic oddities as DOS drive letters, such as there
  81     being a separate current directory per drive)."""
  82
  83     return '', p
  84
  85
  86 # Short interfaces to split()
  87
  88 def dirname(s): return split(s)[0]
  89 def basename(s): return split(s)[1]
  90
  91
  92 def isdir(s):
  93     """Return true if the pathname refers to an existing directory."""
  94
  95     try:
  96         st = os.stat(s)
  97     except os.error:
  98         return 0
  99     return S_ISDIR(st[ST_MODE])
 100
 101
 102 # Get size, mtime, atime of files.
 103
 104 def getsize(filename):
 105     """Return the size of a file, reported by os.stat()."""
 106     st = os.stat(filename)
 107     return st[ST_SIZE]
 108
 109 def getmtime(filename):
 110     """Return the last modification time of a file, reported by os.stat()."""
 111     st = os.stat(filename)
 112     return st[ST_MTIME]
 113
 114 def getatime(filename):
 115     """Return the last access time of a file, reported by os.stat()."""
 116     st = os.stat(filename)
 117     return st[ST_ATIME]
 118
 119
 120 def islink(s):
 121     """Return true if the pathname refers to a symbolic link.
 122     Always false on the Mac, until we understand Aliases.)"""
 123
 124     return 0
 125
 126
 127 def isfile(s):
 128     """Return true if the pathname refers to an existing regular file."""
 129
 130     try:
 131         st = os.stat(s)
 132     except os.error:
 133         return 0
 134     return S_ISREG(st[ST_MODE])
 135
 136
 137 def exists(s):
 138     """Return true if the pathname refers to an existing file or directory."""
 139
 140     try:
 141         st = os.stat(s)
 142     except os.error:
 143         return 0
 144     return 1
 145
 146 # Return the longest prefix of all list elements.
 147
 148 def commonprefix(m):
 149     "Given a list of pathnames, returns the longest common leading component"
 150     if not m: return ''
 151     prefix = m[0]
 152     for item in m:
 153         for i in range(len(prefix)):
 154             if prefix[:i+1] <> item[:i+1]:
 155                 prefix = prefix[:i]
 156                 if i == 0: return ''
 157                 break
 158     return prefix
 159
 160 def expandvars(path):
 161     """Dummy to retain interface-compatibility with other operating systems."""
 162     return path
 163
 164
 165 def expanduser(path):
 166     """Dummy to retain interface-compatibility with other operating systems."""
 167     return path
 168
 169 norm_error = 'macpath.norm_error: path cannot be normalized'
 170
 171 def normpath(s):
 172     """Normalize a pathname.  Will return the same result for
 173     equivalent paths."""
 174
 175     if ":" not in s:
 176         return ":"+s
 177
 178     comps = s.split(":")
 179     i = 1
 180     while i < len(comps)-1:
 181         if comps[i] == "" and comps[i-1] != "":
 182             if i > 1:
 183                 del comps[i-1:i+1]
 184                 i = i - 1
 185             else:
 186                 # best way to handle this is to raise an exception
 187                 raise norm_error, 'Cannot use :: immedeately after volume name'
 188         else:
 189             i = i + 1
 190
 191     s = ":".join(comps)
 192
 193     # remove trailing ":" except for ":" and "Volume:"
 194     if s[-1] == ":" and len(comps) > 2 and s != ":"*len(s):
 195         s = s[:-1]
 196     return s
 197
 198
 199 def walk(top, func, arg):
 200     """Directory tree walk.
 201     For each directory under top (including top itself),
 202     func(arg, dirname, filenames) is called, where
 203     dirname is the name of the directory and filenames is the list
 204     of files (and subdirectories etc.) in the directory.
 205     The func may modify the filenames list, to implement a filter,
 206     or to impose a different order of visiting."""
 207
 208     try:
 209         names = os.listdir(top)
 210     except os.error:
 211         return
 212     func(arg, top, names)
 213     for name in names:
 214         name = join(top, name)
 215         if isdir(name):
 216             walk(name, func, arg)
 217
 218
 219 def abspath(path):
 220     """Return an absolute path."""
 221     if not isabs(path):
 222         path = join(os.getcwd(), path)
 223     return normpath(path)