home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Inkscape / Inkscape-0.48.2-1-win32.exe / python / Lib / os2emxpath.py < prev    next >
Encoding:
Python Source  |  2010-05-29  |  4.7 KB  |  160 lines
  1. # Module 'os2emxpath' -- common operations on OS/2 pathnames
  2. """Common pathname manipulations, OS/2 EMX 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. from genericpath import *
  11. from ntpath import (expanduser, expandvars, isabs, islink, splitdrive,
  12.                     splitext, split, walk)
  13.  
  14. __all__ = ["normcase","isabs","join","splitdrive","split","splitext",
  15.            "basename","dirname","commonprefix","getsize","getmtime",
  16.            "getatime","getctime", "islink","exists","lexists","isdir","isfile",
  17.            "ismount","walk","expanduser","expandvars","normpath","abspath",
  18.            "splitunc","curdir","pardir","sep","pathsep","defpath","altsep",
  19.            "extsep","devnull","realpath","supports_unicode_filenames"]
  20.  
  21. # strings representing various path-related bits and pieces
  22. curdir = '.'
  23. pardir = '..'
  24. extsep = '.'
  25. sep = '/'
  26. altsep = '\\'
  27. pathsep = ';'
  28. defpath = '.;C:\\bin'
  29. devnull = 'nul'
  30.  
  31. # Normalize the case of a pathname and map slashes to backslashes.
  32. # Other normalizations (such as optimizing '../' away) are not done
  33. # (this is done by normpath).
  34.  
  35. def normcase(s):
  36.     """Normalize case of pathname.
  37.  
  38.     Makes all characters lowercase and all altseps into seps."""
  39.     return s.replace('\\', '/').lower()
  40.  
  41.  
  42. # Join two (or more) paths.
  43.  
  44. def join(a, *p):
  45.     """Join two or more pathname components, inserting sep as needed"""
  46.     path = a
  47.     for b in p:
  48.         if isabs(b):
  49.             path = b
  50.         elif path == '' or path[-1:] in '/\\:':
  51.             path = path + b
  52.         else:
  53.             path = path + '/' + b
  54.     return path
  55.  
  56.  
  57. # Parse UNC paths
  58. def splitunc(p):
  59.     """Split a pathname into UNC mount point and relative path specifiers.
  60.  
  61.     Return a 2-tuple (unc, rest); either part may be empty.
  62.     If unc is not empty, it has the form '//host/mount' (or similar
  63.     using backslashes).  unc+rest is always the input path.
  64.     Paths containing drive letters never have an UNC part.
  65.     """
  66.     if p[1:2] == ':':
  67.         return '', p # Drive letter present
  68.     firstTwo = p[0:2]
  69.     if firstTwo == '/' * 2 or firstTwo == '\\' * 2:
  70.         # is a UNC path:
  71.         # vvvvvvvvvvvvvvvvvvvv equivalent to drive letter
  72.         # \\machine\mountpoint\directories...
  73.         #           directory ^^^^^^^^^^^^^^^
  74.         normp = normcase(p)
  75.         index = normp.find('/', 2)
  76.         if index == -1:
  77.             ##raise RuntimeError, 'illegal UNC path: "' + p + '"'
  78.             return ("", p)
  79.         index = normp.find('/', index + 1)
  80.         if index == -1:
  81.             index = len(p)
  82.         return p[:index], p[index:]
  83.     return '', p
  84.  
  85.  
  86. # Return the tail (basename) part of a path.
  87.  
  88. def basename(p):
  89.     """Returns the final component of a pathname"""
  90.     return split(p)[1]
  91.  
  92.  
  93. # Return the head (dirname) part of a path.
  94.  
  95. def dirname(p):
  96.     """Returns the directory component of a pathname"""
  97.     return split(p)[0]
  98.  
  99.  
  100. # alias exists to lexists
  101. lexists = exists
  102.  
  103.  
  104. # Is a path a directory?
  105.  
  106. # Is a path a mount point?  Either a root (with or without drive letter)
  107. # or an UNC path with at most a / or \ after the mount point.
  108.  
  109. def ismount(path):
  110.     """Test whether a path is a mount point (defined as root of drive)"""
  111.     unc, rest = splitunc(path)
  112.     if unc:
  113.         return rest in ("", "/", "\\")
  114.     p = splitdrive(path)[1]
  115.     return len(p) == 1 and p[0] in '/\\'
  116.  
  117.  
  118. # Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
  119.  
  120. def normpath(path):
  121.     """Normalize path, eliminating double slashes, etc."""
  122.     path = path.replace('\\', '/')
  123.     prefix, path = splitdrive(path)
  124.     while path[:1] == '/':
  125.         prefix = prefix + '/'
  126.         path = path[1:]
  127.     comps = path.split('/')
  128.     i = 0
  129.     while i < len(comps):
  130.         if comps[i] == '.':
  131.             del comps[i]
  132.         elif comps[i] == '..' and i > 0 and comps[i-1] not in ('', '..'):
  133.             del comps[i-1:i+1]
  134.             i = i - 1
  135.         elif comps[i] == '' and i > 0 and comps[i-1] != '':
  136.             del comps[i]
  137.         else:
  138.             i = i + 1
  139.     # If the path is now empty, substitute '.'
  140.     if not prefix and not comps:
  141.         comps.append('.')
  142.     return prefix + '/'.join(comps)
  143.  
  144.  
  145. # Return an absolute path.
  146. def abspath(path):
  147.     """Return the absolute version of a path"""
  148.     if not isabs(path):
  149.         if isinstance(path, unicode):
  150.             cwd = os.getcwdu()
  151.         else:
  152.             cwd = os.getcwd()
  153.         path = join(cwd, path)
  154.     return normpath(path)
  155.  
  156. # realpath is a no-op on systems without islink support
  157. realpath = abspath
  158.  
  159. supports_unicode_filenames = False
  160.