Lib/dos-8x3/posixpat.py

   1 """Common operations on Posix pathnames.
   2
   3 Instead of importing this module directly, import os and refer to
   4 this module as os.path.  The "os.path" name is an alias for this
   5 module on Posix systems; on other systems (e.g. Mac, Windows),
   6 os.path provides the same operations in a manner specific to that
   7 platform, and is an alias to another module (e.g. macpath, ntpath).
   8
   9 Some of this can actually be useful on non-Posix systems too, e.g.
  10 for manipulation of the pathname component of URLs.
  11 """
  12
  13 import os
  14 import stat
  15
  16
  17 # Normalize the case of a pathname.  Trivial in Posix, string.lower on Mac.
  18 # On MS-DOS this may also turn slashes into backslashes; however, other
  19 # normalizations (such as optimizing '../' away) are not allowed
  20 # (another function should be defined to do that).
  21
  22 def normcase(s):
  23     """Normalize case of pathname.  Has no effect under Posix"""
  24     return s
  25
  26
  27 # Return whether a path is absolute.
  28 # Trivial in Posix, harder on the Mac or MS-DOS.
  29
  30 def isabs(s):
  31     """Test whether a path is absolute"""
  32     return s[:1] == '/'
  33
  34
  35 # Join pathnames.
  36 # Ignore the previous parts if a part is absolute.
  37 # Insert a '/' unless the first part is empty or already ends in '/'.
  38
  39 def join(a, *p):
  40     """Join two or more pathname components, inserting '/' as needed"""
  41     path = a
  42     for b in p:
  43         if b[:1] == '/':
  44             path = b
  45         elif path == '' or path[-1:] == '/':
  46             path = path + b
  47         else:
  48             path = path + '/' + b
  49     return path
  50
  51
  52 # Split a path in head (everything up to the last '/') and tail (the
  53 # rest).  If the path ends in '/', tail will be empty.  If there is no
  54 # '/' in the path, head  will be empty.
  55 # Trailing '/'es are stripped from head unless it is the root.
  56
  57 def split(p):
  58     """Split a pathname.  Returns tuple "(head, tail)" where "tail" is
  59     everything after the final slash.  Either part may be empty."""
  60     i = p.rfind('/') + 1
  61     head, tail = p[:i], p[i:]
  62     if head and head <> '/'*len(head):
  63         while head[-1] == '/':
  64             head = head[:-1]
  65     return head, tail
  66
  67
  68 # Split a path in root and extension.
  69 # The extension is everything starting at the last dot in the last
  70 # pathname component; the root is everything before that.
  71 # It is always true that root + ext == p.
  72
  73 def splitext(p):
  74     """Split the extension from a pathname.  Extension is everything from the
  75     last dot to the end.  Returns "(root, ext)", either part may be empty."""
  76     root, ext = '', ''
  77     for c in p:
  78         if c == '/':
  79             root, ext = root + ext + c, ''
  80         elif c == '.':
  81             if ext:
  82                 root, ext = root + ext, c
  83             else:
  84                 ext = c
  85         elif ext:
  86             ext = ext + c
  87         else:
  88             root = root + c
  89     return root, ext
  90
  91
  92 # Split a pathname into a drive specification and the rest of the
  93 # path.  Useful on DOS/Windows/NT; on Unix, the drive is always empty.
  94
  95 def splitdrive(p):
  96     """Split a pathname into drive and path. On Posix, drive is always
  97     empty."""
  98     return '', p
  99
 100
 101 # Return the tail (basename) part of a path.
 102
 103 def basename(p):
 104     """Returns the final component of a pathname"""
 105     return split(p)[1]
 106
 107
 108 # Return the head (dirname) part of a path.
 109
 110 def dirname(p):
 111     """Returns the directory component of a pathname"""
 112     return split(p)[0]
 113
 114
 115 # Return the longest prefix of all list elements.
 116
 117 def commonprefix(m):
 118     "Given a list of pathnames, returns the longest common leading component"
 119     if not m: return ''
 120     prefix = m[0]
 121     for item in m:
 122         for i in range(len(prefix)):
 123             if prefix[:i+1] <> item[:i+1]:
 124                 prefix = prefix[:i]
 125                 if i == 0: return ''
 126                 break
 127     return prefix
 128
 129
 130 # Get size, mtime, atime of files.
 131
 132 def getsize(filename):
 133     """Return the size of a file, reported by os.stat()."""
 134     st = os.stat(filename)
 135     return st[stat.ST_SIZE]
 136
 137 def getmtime(filename):
 138     """Return the last modification time of a file, reported by os.stat()."""
 139     st = os.stat(filename)
 140     return st[stat.ST_MTIME]
 141
 142 def getatime(filename):
 143     """Return the last access time of a file, reported by os.stat()."""
 144     st = os.stat(filename)
 145     return st[stat.ST_ATIME]
 146
 147
 148 # Is a path a symbolic link?
 149 # This will always return false on systems where os.lstat doesn't exist.
 150
 151 def islink(path):
 152     """Test whether a path is a symbolic link"""
 153     try:
 154         st = os.lstat(path)
 155     except (os.error, AttributeError):
 156         return 0
 157     return stat.S_ISLNK(st[stat.ST_MODE])
 158
 159
 160 # Does a path exist?
 161 # This is false for dangling symbolic links.
 162
 163 def exists(path):
 164     """Test whether a path exists.  Returns false for broken symbolic links"""
 165     try:
 166         st = os.stat(path)
 167     except os.error:
 168         return 0
 169     return 1
 170
 171
 172 # Is a path a directory?
 173 # This follows symbolic links, so both islink() and isdir() can be true
 174 # for the same path.
 175
 176 def isdir(path):
 177     """Test whether a path is a directory"""
 178     try:
 179         st = os.stat(path)
 180     except os.error:
 181         return 0
 182     return stat.S_ISDIR(st[stat.ST_MODE])
 183
 184
 185 # Is a path a regular file?
 186 # This follows symbolic links, so both islink() and isfile() can be true
 187 # for the same path.
 188
 189 def isfile(path):
 190     """Test whether a path is a regular file"""
 191     try:
 192         st = os.stat(path)
 193     except os.error:
 194         return 0
 195     return stat.S_ISREG(st[stat.ST_MODE])
 196
 197
 198 # Are two filenames really pointing to the same file?
 199
 200 def samefile(f1, f2):
 201     """Test whether two pathnames reference the same actual file"""
 202     s1 = os.stat(f1)
 203     s2 = os.stat(f2)
 204     return samestat(s1, s2)
 205
 206
 207 # Are two open files really referencing the same file?
 208 # (Not necessarily the same file descriptor!)
 209
 210 def sameopenfile(fp1, fp2):
 211     """Test whether two open file objects reference the same file"""
 212     s1 = os.fstat(fp1)
 213     s2 = os.fstat(fp2)
 214     return samestat(s1, s2)
 215
 216
 217 # Are two stat buffers (obtained from stat, fstat or lstat)
 218 # describing the same file?
 219
 220 def samestat(s1, s2):
 221     """Test whether two stat buffers reference the same file"""
 222     return s1[stat.ST_INO] == s2[stat.ST_INO] and \
 223            s1[stat.ST_DEV] == s2[stat.ST_DEV]
 224
 225
 226 # Is a path a mount point?
 227 # (Does this work for all UNIXes?  Is it even guaranteed to work by Posix?)
 228
 229 def ismount(path):
 230     """Test whether a path is a mount point"""
 231     try:
 232         s1 = os.stat(path)
 233         s2 = os.stat(join(path, '..'))
 234     except os.error:
 235         return 0 # It doesn't exist -- so not a mount point :-)
 236     dev1 = s1[stat.ST_DEV]
 237     dev2 = s2[stat.ST_DEV]
 238     if dev1 != dev2:
 239         return 1        # path/.. on a different device as path
 240     ino1 = s1[stat.ST_INO]
 241     ino2 = s2[stat.ST_INO]
 242     if ino1 == ino2:
 243         return 1        # path/.. is the same i-node as path
 244     return 0
 245
 246
 247 # Directory tree walk.
 248 # For each directory under top (including top itself, but excluding
 249 # '.' and '..'), func(arg, dirname, filenames) is called, where
 250 # dirname is the name of the directory and filenames is the list
 251 # of files (and subdirectories etc.) in the directory.
 252 # The func may modify the filenames list, to implement a filter,
 253 # or to impose a different order of visiting.
 254
 255 def walk(top, func, arg):
 256     """walk(top,func,arg) calls func(arg, d, files) for each directory "d"
 257     in the tree  rooted at "top" (including "top" itself).  "files" is a list
 258     of all the files and subdirs in directory "d".
 259     """
 260     try:
 261         names = os.listdir(top)
 262     except os.error:
 263         return
 264     func(arg, top, names)
 265     for name in names:
 266             name = join(top, name)
 267             st = os.lstat(name)
 268             if stat.S_ISDIR(st[stat.ST_MODE]):
 269                 walk(name, func, arg)
 270
 271
 272 # Expand paths beginning with '~' or '~user'.
 273 # '~' means $HOME; '~user' means that user's home directory.
 274 # If the path doesn't begin with '~', or if the user or $HOME is unknown,
 275 # the path is returned unchanged (leaving error reporting to whatever
 276 # function is called with the expanded path as argument).
 277 # See also module 'glob' for expansion of *, ? and [...] in pathnames.
 278 # (A function should also be defined to do full *sh-style environment
 279 # variable expansion.)
 280
 281 def expanduser(path):
 282     """Expand ~ and ~user constructions.  If user or $HOME is unknown,
 283     do nothing."""
 284     if path[:1] <> '~':
 285         return path
 286     i, n = 1, len(path)
 287     while i < n and path[i] <> '/':
 288         i = i + 1
 289     if i == 1:
 290         if not os.environ.has_key('HOME'):
 291             return path
 292         userhome = os.environ['HOME']
 293     else:
 294         import pwd
 295         try:
 296             pwent = pwd.getpwnam(path[1:i])
 297         except KeyError:
 298             return path
 299         userhome = pwent[5]
 300     if userhome[-1:] == '/': i = i + 1
 301     return userhome + path[i:]
 302
 303
 304 # Expand paths containing shell variable substitutions.
 305 # This expands the forms $variable and ${variable} only.
 306 # Non-existent variables are left unchanged.
 307
 308 _varprog = None
 309
 310 def expandvars(path):
 311     """Expand shell variables of form $var and ${var}.  Unknown variables
 312     are left unchanged."""
 313     global _varprog
 314     if '$' not in path:
 315         return path
 316     if not _varprog:
 317         import re
 318         _varprog = re.compile(r'\$(\w+|\{[^}]*\})')
 319     i = 0
 320     while 1:
 321         m = _varprog.search(path, i)
 322         if not m:
 323             break
 324         i, j = m.span(0)
 325         name = m.group(1)
 326         if name[:1] == '{' and name[-1:] == '}':
 327             name = name[1:-1]
 328         if os.environ.has_key(name):
 329             tail = path[j:]
 330             path = path[:i] + os.environ[name]
 331             i = len(path)
 332             path = path + tail
 333         else:
 334             i = j
 335     return path
 336
 337
 338 # Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
 339 # It should be understood that this may change the meaning of the path
 340 # if it contains symbolic links!
 341
 342 def normpath(path):
 343     """Normalize path, eliminating double slashes, etc."""
 344     if path == '':
 345         return '.'
 346     initial_slash = (path[0] == '/')
 347     comps = path.split('/')
 348     new_comps = []
 349     for comp in comps:
 350         if comp in ('', '.'):
 351             continue
 352         if (comp != '..' or (not initial_slash and not new_comps) or
 353              (new_comps and new_comps[-1] == '..')):
 354             new_comps.append(comp)
 355         elif new_comps:
 356             new_comps.pop()
 357     comps = new_comps
 358     path = '/'.join(comps)
 359     if initial_slash:
 360         path = '/' + path
 361     return path or '.'
 362
 363
 364 def abspath(path):
 365     """Return an absolute path."""
 366     if not isabs(path):
 367         path = join(os.getcwd(), path)
 368     return normpath(path)