Lib/macpath.py

   1 """Pathname and path-related operations for the Macintosh."""
   2
   3 import os
   4 import warnings
   5 from stat import *
   6 import genericpath
   7 from genericpath import *
   8
   9 __all__ = ["normcase","isabs","join","splitdrive","split","splitext",
  10            "basename","dirname","commonprefix","getsize","getmtime",
  11            "getatime","getctime", "islink","exists","lexists","isdir","isfile",
  12            "walk","expanduser","expandvars","normpath","abspath",
  13            "curdir","pardir","sep","pathsep","defpath","altsep","extsep",
  14            "devnull","realpath","supports_unicode_filenames"]
  15
  16 # strings representing various path-related bits and pieces
  17 curdir = ':'
  18 pardir = '::'
  19 extsep = '.'
  20 sep = ':'
  21 pathsep = '\n'
  22 defpath = ':'
  23 altsep = None
  24 devnull = 'Dev:Null'
  25
  26 # Normalize the case of a pathname.  Dummy in Posix, but <s>.lower() here.
  27
  28 def normcase(path):
  29     return path.lower()
  30
  31
  32 def isabs(s):
  33     """Return true if a path is absolute.
  34     On the Mac, relative paths begin with a colon,
  35     but as a special case, paths with no colons at all are also relative.
  36     Anything else is absolute (the string up to the first colon is the
  37     volume name)."""
  38
  39     return ':' in s and s[0] != ':'
  40
  41
  42 def join(s, *p):
  43     path = s
  44     for t in p:
  45         if (not s) or isabs(t):
  46             path = t
  47             continue
  48         if t[:1] == ':':
  49             t = t[1:]
  50         if ':' not in path:
  51             path = ':' + path
  52         if path[-1:] != ':':
  53             path = path + ':'
  54         path = path + t
  55     return path
  56
  57
  58 def split(s):
  59     """Split a pathname into two parts: the directory leading up to the final
  60     bit, and the basename (the filename, without colons, in that directory).
  61     The result (s, t) is such that join(s, t) yields the original argument."""
  62
  63     if ':' not in s: return '', s
  64     colon = 0
  65     for i in range(len(s)):
  66         if s[i] == ':': colon = i + 1
  67     path, file = s[:colon-1], s[colon:]
  68     if path and not ':' in path:
  69         path = path + ':'
  70     return path, file
  71
  72
  73 def splitext(p):
  74     return genericpath._splitext(p, sep, altsep, extsep)
  75 splitext.__doc__ = genericpath._splitext.__doc__
  76
  77 def splitdrive(p):
  78     """Split a pathname into a drive specification and the rest of the
  79     path.  Useful on DOS/Windows/NT; on the Mac, the drive is always
  80     empty (don't use the volume name -- it doesn't have the same
  81     syntactic and semantic oddities as DOS drive letters, such as there
  82     being a separate current directory per drive)."""
  83
  84     return '', p
  85
  86
  87 # Short interfaces to split()
  88
  89 def dirname(s): return split(s)[0]
  90 def basename(s): return split(s)[1]
  91
  92 def ismount(s):
  93     if not isabs(s):
  94         return False
  95     components = split(s)
  96     return len(components) == 2 and components[1] == ''
  97
  98 def islink(s):
  99     """Return true if the pathname refers to a symbolic link."""
 100
 101     try:
 102         import Carbon.File
 103         return Carbon.File.ResolveAliasFile(s, 0)[2]
 104     except:
 105         return False
 106
 107 # Is `stat`/`lstat` a meaningful difference on the Mac?  This is safe in any
 108 # case.
 109
 110 def lexists(path):
 111     """Test whether a path exists.  Returns True for broken symbolic links"""
 112
 113     try:
 114         st = os.lstat(path)
 115     except os.error:
 116         return False
 117     return True
 118
 119 def expandvars(path):
 120     """Dummy to retain interface-compatibility with other operating systems."""
 121     return path
 122
 123
 124 def expanduser(path):
 125     """Dummy to retain interface-compatibility with other operating systems."""
 126     return path
 127
 128 class norm_error(Exception):
 129     """Path cannot be normalized"""
 130
 131 def normpath(s):
 132     """Normalize a pathname.  Will return the same result for
 133     equivalent paths."""
 134
 135     if ":" not in s:
 136         return ":"+s
 137
 138     comps = s.split(":")
 139     i = 1
 140     while i < len(comps)-1:
 141         if comps[i] == "" and comps[i-1] != "":
 142             if i > 1:
 143                 del comps[i-1:i+1]
 144                 i = i - 1
 145             else:
 146                 # best way to handle this is to raise an exception
 147                 raise norm_error, 'Cannot use :: immediately after volume name'
 148         else:
 149             i = i + 1
 150
 151     s = ":".join(comps)
 152
 153     # remove trailing ":" except for ":" and "Volume:"
 154     if s[-1] == ":" and len(comps) > 2 and s != ":"*len(s):
 155         s = s[:-1]
 156     return s
 157
 158
 159 def walk(top, func, arg):
 160     """Directory tree walk with callback function.
 161
 162     For each directory in the directory tree rooted at top (including top
 163     itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
 164     dirname is the name of the directory, and fnames a list of the names of
 165     the files and subdirectories in dirname (excluding '.' and '..').  func
 166     may modify the fnames list in-place (e.g. via del or slice assignment),
 167     and walk will only recurse into the subdirectories whose names remain in
 168     fnames; this can be used to implement a filter, or to impose a specific
 169     order of visiting.  No semantics are defined for, or required of, arg,
 170     beyond that arg is always passed to func.  It can be used, e.g., to pass
 171     a filename pattern, or a mutable object designed to accumulate
 172     statistics.  Passing None for arg is common."""
 173     warnings.warnpy3k("In 3.x, os.path.walk is removed in favor of os.walk.")
 174     try:
 175         names = os.listdir(top)
 176     except os.error:
 177         return
 178     func(arg, top, names)
 179     for name in names:
 180         name = join(top, name)
 181         if isdir(name) and not islink(name):
 182             walk(name, func, arg)
 183
 184
 185 def abspath(path):
 186     """Return an absolute path."""
 187     if not isabs(path):
 188         path = join(os.getcwd(), path)
 189     return normpath(path)
 190
 191 # realpath is a no-op on systems without islink support
 192 def realpath(path):
 193     path = abspath(path)
 194     try:
 195         import Carbon.File
 196     except ImportError:
 197         return path
 198     if not path:
 199         return path
 200     components = path.split(':')
 201     path = components[0] + ':'
 202     for c in components[1:]:
 203         path = join(path, c)
 204         path = Carbon.File.FSResolveAliasFile(path, 1)[0].as_pathname()
 205     return path
 206
 207 supports_unicode_filenames = False