1 """Pathname and path-related operations for the Macintosh."""

     2 

     3 import os

     4 from stat import *

     5 

     6 __all__ = ["normcase","isabs","join","splitdrive","split","splitext",

     7            "basename","dirname","commonprefix","getsize","getmtime",

     8            "getatime","getctime", "islink","exists","lexists","isdir","isfile",

     9            "walk","expanduser","expandvars","normpath","abspath",

    10            "curdir","pardir","sep","pathsep","defpath","altsep","extsep",

    11            "devnull","realpath","supports_unicode_filenames"]

    12 

    13 # strings representing various path-related bits and pieces

    14 curdir = ':'

    15 pardir = '::'

    16 extsep = '.'

    17 sep = ':'

    18 pathsep = '\n'

    19 defpath = ':'

    20 altsep = None

    21 devnull = 'Dev:Null'

    22 

    23 # Normalize the case of a pathname.  Dummy in Posix, but <s>.lower() here.

    24 

    25 def normcase(path):

    26     return path.lower()

    27 

    28 

    29 def isabs(s):

    30     """Return true if a path is absolute.

    31     On the Mac, relative paths begin with a colon,

    32     but as a special case, paths with no colons at all are also relative.

    33     Anything else is absolute (the string up to the first colon is the

    34     volume name)."""

    35 

    36     return ':' in s and s[0] != ':'

    37 

    38 

    39 def join(s, *p):

    40     path = s

    41     for t in p:

    42         if (not s) or isabs(t):

    43             path = t

    44             continue

    45         if t[:1] == ':':

    46             t = t[1:]

    47         if ':' not in path:

    48             path = ':' + path

    49         if path[-1:] != ':':

    50             path = path + ':'

    51         path = path + t

    52     return path

    53 

    54 

    55 def split(s):

    56     """Split a pathname into two parts: the directory leading up to the final

    57     bit, and the basename (the filename, without colons, in that directory).

    58     The result (s, t) is such that join(s, t) yields the original argument."""

    59 

    60     if ':' not in s: return '', s

    61     colon = 0

    62     for i in range(len(s)):

    63         if s[i] == ':': colon = i + 1

    64     path, file = s[:colon-1], s[colon:]

    65     if path and not ':' in path:

    66         path = path + ':'

    67     return path, file

    68 

    69 

    70 def splitext(p):

    71     """Split a path into root and extension.

    72     The extension is everything starting at the last dot in the last

    73     pathname component; the root is everything before that.

    74     It is always true that root + ext == p."""

    75 

    76     i = p.rfind('.')

    77     if i<=p.rfind(':'):

    78         return p, ''

    79     else:

    80         return p[:i], p[i:]

    81 

    82 

    83 def splitdrive(p):

    84     """Split a pathname into a drive specification and the rest of the

    85     path.  Useful on DOS/Windows/NT; on the Mac, the drive is always

    86     empty (don't use the volume name -- it doesn't have the same

    87     syntactic and semantic oddities as DOS drive letters, such as there

    88     being a separate current directory per drive)."""

    89 

    90     return '', p

    91 

    92 

    93 # Short interfaces to split()

    94 

    95 def dirname(s): return split(s)[0]

    96 def basename(s): return split(s)[1]

    97 

    98 def ismount(s):

    99     if not isabs(s):

   100         return False

   101     components = split(s)

   102     return len(components) == 2 and components[1] == ''

   103 

   104 def isdir(s):

   105     """Return true if the pathname refers to an existing directory."""

   106 

   107     try:

   108         st = os.stat(s)

   109     except os.error:

   110         return 0

   111     return S_ISDIR(st.st_mode)

   112 

   113 

   114 # Get size, mtime, atime of files.

   115 

   116 def getsize(filename):

   117     """Return the size of a file, reported by os.stat()."""

   118     return os.stat(filename).st_size

   119 

   120 def getmtime(filename):

   121     """Return the last modification time of a file, reported by os.stat()."""

   122     return os.stat(filename).st_mtime

   123 

   124 def getatime(filename):

   125     """Return the last access time of a file, reported by os.stat()."""

   126     return os.stat(filename).st_atime

   127 

   128 

   129 def islink(s):

   130     """Return true if the pathname refers to a symbolic link."""

   131 

   132     try:

   133         import Carbon.File

   134         return Carbon.File.ResolveAliasFile(s, 0)[2]

   135     except:

   136         return False

   137 

   138 

   139 def isfile(s):

   140     """Return true if the pathname refers to an existing regular file."""

   141 

   142     try:

   143         st = os.stat(s)

   144     except os.error:

   145         return False

   146     return S_ISREG(st.st_mode)

   147 

   148 def getctime(filename):

   149     """Return the creation time of a file, reported by os.stat()."""

   150     return os.stat(filename).st_ctime

   151 

   152 def exists(s):

   153     """Test whether a path exists.  Returns False for broken symbolic links"""

   154 

   155     try:

   156         st = os.stat(s)

   157     except os.error:

   158         return False

   159     return True

   160 

   161 # Is `stat`/`lstat` a meaningful difference on the Mac?  This is safe in any

   162 # case.

   163 

   164 def lexists(path):

   165     """Test whether a path exists.  Returns True for broken symbolic links"""

   166 

   167     try:

   168         st = os.lstat(path)

   169     except os.error:

   170         return False

   171     return True

   172 

   173 # Return the longest prefix of all list elements.

   174 

   175 def commonprefix(m):

   176     "Given a list of pathnames, returns the longest common leading component"

   177     if not m: return ''

   178     s1 = min(m)

   179     s2 = max(m)

   180     n = min(len(s1), len(s2))

   181     for i in xrange(n):

   182         if s1[i] != s2[i]:

   183             return s1[:i]

   184     return s1[:n]

   185 

   186 

   187 def expandvars(path):

   188     """Dummy to retain interface-compatibility with other operating systems."""

   189     return path

   190 

   191 

   192 def expanduser(path):

   193     """Dummy to retain interface-compatibility with other operating systems."""

   194     return path

   195 

   196 class norm_error(Exception):

   197     """Path cannot be normalized"""

   198 

   199 def normpath(s):

   200     """Normalize a pathname.  Will return the same result for

   201     equivalent paths."""

   202 

   203     if ":" not in s:

   204         return ":"+s

   205 

   206     comps = s.split(":")

   207     i = 1

   208     while i < len(comps)-1:

   209         if comps[i] == "" and comps[i-1] != "":

   210             if i > 1:

   211                 del comps[i-1:i+1]

   212                 i = i - 1

   213             else:

   214                 # best way to handle this is to raise an exception

   215                 raise norm_error, 'Cannot use :: immediately after volume name'

   216         else:

   217             i = i + 1

   218 

   219     s = ":".join(comps)

   220 

   221     # remove trailing ":" except for ":" and "Volume:"

   222     if s[-1] == ":" and len(comps) > 2 and s != ":"*len(s):

   223         s = s[:-1]

   224     return s

   225 

   226 

   227 def walk(top, func, arg):

   228     """Directory tree walk with callback function.

   229 

   230     For each directory in the directory tree rooted at top (including top

   231     itself, but excluding '.' and '..'), call func(arg, dirname, fnames).

   232     dirname is the name of the directory, and fnames a list of the names of

   233     the files and subdirectories in dirname (excluding '.' and '..').  func

   234     may modify the fnames list in-place (e.g. via del or slice assignment),

   235     and walk will only recurse into the subdirectories whose names remain in

   236     fnames; this can be used to implement a filter, or to impose a specific

   237     order of visiting.  No semantics are defined for, or required of, arg,

   238     beyond that arg is always passed to func.  It can be used, e.g., to pass

   239     a filename pattern, or a mutable object designed to accumulate

   240     statistics.  Passing None for arg is common."""

   241 

   242     try:

   243         names = os.listdir(top)

   244     except os.error:

   245         return

   246     func(arg, top, names)

   247     for name in names:

   248         name = join(top, name)

   249         if isdir(name) and not islink(name):

   250             walk(name, func, arg)

   251 

   252 

   253 def abspath(path):

   254     """Return an absolute path."""

   255     if not isabs(path):

   256         path = join(os.getcwd(), path)

   257     return normpath(path)

   258 

   259 # realpath is a no-op on systems without islink support

   260 def realpath(path):

   261     path = abspath(path)

   262     try:

   263         import Carbon.File

   264     except ImportError:

   265         return path

   266     if not path:

   267         return path

   268     components = path.split(':')

   269     path = components[0] + ':'

   270     for c in components[1:]:

   271         path = join(path, c)

   272         path = Carbon.File.FSResolveAliasFile(path, 1)[0].as_pathname()

   273     return path

   274 

   275 supports_unicode_filenames = False