Vega strike Python Modules doc: posixpath Namespace Reference

All Data Structures Namespaces Files Functions Variables

Functions
def	normcase

def	isabs

def	join

def	split

def	splitext

def	splitdrive

def	basename

def	dirname

def	commonprefix

def	getsize

def	getmtime

def	getatime

def	islink

def	exists

def	isdir

def	isfile

def	samefile

def	sameopenfile

def	samestat

def	ismount

def	walk

def	expanduser

def	expandvars

def	normpath

def	abspath

def	realpath

Variables
list	__all__

	_varprog = None

Detailed Description

Common operations on Posix pathnames.

Instead of importing this module directly, import os and refer to
this module as os.path.  The "os.path" name is an alias for this
module on Posix systems; on other systems (e.g. Mac, Windows),
os.path provides the same operations in a manner specific to that
platform, and is an alias to another module (e.g. macpath, ntpath).

Some of this can actually be useful on non-Posix systems too, e.g.
for manipulation of the pathname component of URLs.

Function Documentation

def posixpath.abspath ( path)

Return an absolute path.

Definition at line 387 of file posixpath.py.

References isabs(), join(), and normpath().

 
 def abspath(path):
     """Return an absolute path."""
     if not isabs(path):
         path = join(os.getcwd(), path)
     return normpath(path)
 
 
 # Return a canonical path (i.e. the absolute location of a file on the
 # filesystem).

def posixpath.basename ( p)

Returns the final component of a pathname

Definition at line 108 of file posixpath.py.

References split().

 
 def basename(p):
     """Returns the final component of a pathname"""
     return split(p)[1]
 
 # Return the head (dirname) part of a path.

def posixpath.commonprefix ( m)

Definition at line 122 of file posixpath.py.

 
 def commonprefix(m):
     "Given a list of pathnames, returns the longest common leading component"
     if not m: return ''
     prefix = m[0]
     for item in m:
         for i in range(len(prefix)):
             if prefix[:i+1] != item[:i+1]:
                 prefix = prefix[:i]
                 if i == 0: return ''
                 break
     return prefix
 
 
 # Get size, mtime, atime of files.

def posixpath.dirname ( p)

Returns the directory component of a pathname

Definition at line 115 of file posixpath.py.

References split().

 
 def dirname(p):
     """Returns the directory component of a pathname"""
     return split(p)[0]
 
 # Return the longest prefix of all list elements.

def posixpath.exists ( path)

Test whether a path exists.  Returns false for broken symbolic links

Definition at line 168 of file posixpath.py.

 
 def exists(path):
     """Test whether a path exists.  Returns false for broken symbolic links"""
     try:
         st = os.stat(path)
     except os.error:
         return 0
     return 1
 
 
 # Is a path a directory?
 # This follows symbolic links, so both islink() and isdir() can be true
 # for the same path.

def posixpath.expanduser ( path)

Expand ~ and ~user constructions.  If user or $HOME is unknown,
do nothing.

Definition at line 299 of file posixpath.py.

 
 def expanduser(path):
     """Expand ~ and ~user constructions.  If user or $HOME is unknown,
     do nothing."""
     if path[:1] != '~':
         return path
     i, n = 1, len(path)
     while i < n and path[i] != '/':
         i = i + 1
     if i == 1:
         if not os.environ.has_key('HOME'):
             return path
         userhome = os.environ['HOME']
     else:
         import pwd
         try:
             pwent = pwd.getpwnam(path[1:i])
         except KeyError:
             return path
         userhome = pwent[5]
     if userhome[-1:] == '/': i = i + 1
     return userhome + path[i:]
 
 
 # Expand paths containing shell variable substitutions.
 # This expands the forms $variable and ${variable} only.
 # Non-existent variables are left unchanged.

def posixpath.expandvars ( path)

Expand shell variables of form $var and ${var}.  Unknown variables
are left unchanged.

Definition at line 328 of file posixpath.py.

 
 def expandvars(path):
     """Expand shell variables of form $var and ${var}.  Unknown variables
     are left unchanged."""
     global _varprog
     if '$' not in path:
         return path
     if not _varprog:
         import re
         _varprog = re.compile(r'\$(\w+|\{[^}]*\})')
     i = 0
     while 1:
         m = _varprog.search(path, i)
         if not m:
             break
         i, j = m.span(0)
         name = m.group(1)
         if name[:1] == '{' and name[-1:] == '}':
             name = name[1:-1]
         if os.environ.has_key(name):
             tail = path[j:]
             path = path[:i] + os.environ[name]
             i = len(path)
             path = path + tail
         else:
             i = j
     return path
 
 
 # Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
 # It should be understood that this may change the meaning of the path
 # if it contains symbolic links!

def posixpath.getatime ( filename)

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

Definition at line 147 of file posixpath.py.

 
 def getatime(filename):
     """Return the last access time of a file, reported by os.stat()."""
     st = os.stat(filename)
     return st[stat.ST_ATIME]
 
 
 # Is a path a symbolic link?
 # This will always return false on systems where os.lstat doesn't exist.

def posixpath.getmtime ( filename)

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

Definition at line 142 of file posixpath.py.

 
 def getmtime(filename):
     """Return the last modification time of a file, reported by os.stat()."""
     st = os.stat(filename)
     return st[stat.ST_MTIME]

def posixpath.getsize ( filename)

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

Definition at line 137 of file posixpath.py.

 
 def getsize(filename):
     """Return the size of a file, reported by os.stat()."""
     st = os.stat(filename)
     return st[stat.ST_SIZE]

def posixpath.isabs ( s)

Test whether a path is absolute

Definition at line 35 of file posixpath.py.

 
 def isabs(s):
     """Test whether a path is absolute"""
     return s[:1] == '/'
 
 
 # Join pathnames.
 # Ignore the previous parts if a part is absolute.
 # Insert a '/' unless the first part is empty or already ends in '/'.

def posixpath.isdir ( path)

Test whether a path is a directory

Definition at line 181 of file posixpath.py.

References stat.S_ISDIR().

 
 def isdir(path):
     """Test whether a path is a directory"""
     try:
         st = os.stat(path)
     except os.error:
         return 0
     return stat.S_ISDIR(st[stat.ST_MODE])
 
 
 # Is a path a regular file?
 # This follows symbolic links, so both islink() and isfile() can be true
 # for the same path.

def posixpath.isfile ( path)

Test whether a path is a regular file

Definition at line 194 of file posixpath.py.

References stat.S_ISREG().

 
 def isfile(path):
     """Test whether a path is a regular file"""
     try:
         st = os.stat(path)
     except os.error:
         return 0
     return stat.S_ISREG(st[stat.ST_MODE])
 
 
 # Are two filenames really pointing to the same file?

def posixpath.islink ( path)

Test whether a path is a symbolic link

Definition at line 156 of file posixpath.py.

References stat.S_ISLNK().

 
 def islink(path):
     """Test whether a path is a symbolic link"""
     try:
         st = os.lstat(path)
     except (os.error, AttributeError):
         return 0
     return stat.S_ISLNK(st[stat.ST_MODE])
 
 
 # Does a path exist?
 # This is false for dangling symbolic links.

def posixpath.ismount ( path)

Test whether a path is a mount point

Definition at line 234 of file posixpath.py.

References join().

 
 def ismount(path):
     """Test whether a path is a mount point"""
     try:
         s1 = os.stat(path)
         s2 = os.stat(join(path, '..'))
     except os.error:
         return 0 # It doesn't exist -- so not a mount point :-)
     dev1 = s1[stat.ST_DEV]
     dev2 = s2[stat.ST_DEV]
     if dev1 != dev2:
         return 1        # path/.. on a different device as path
     ino1 = s1[stat.ST_INO]
     ino2 = s2[stat.ST_INO]
     if ino1 == ino2:
         return 1        # path/.. is the same i-node as path
     return 0
 
 
 # Directory tree walk.
 # For each directory under top (including top itself, but excluding
 # '.' and '..'), func(arg, dirname, filenames) is called, where
 # dirname is the name of the directory and filenames is the list
 # of files (and subdirectories etc.) in the directory.
 # The func may modify the filenames list, to implement a filter,
 # or to impose a different order of visiting.

def posixpath.join	(	a,
		p
	)

Join two or more pathname components, inserting '/' as needed

Definition at line 44 of file posixpath.py.

 
 def join(a, *p):
     """Join two or more pathname components, inserting '/' as needed"""
     path = a
     for b in p:
         if b[:1] == '/':
             path = b
         elif path == '' or path[-1:] == '/':
             path = path + b
         else:
             path = path + '/' + b
     return path
 
 
 # Split a path in head (everything up to the last '/') and tail (the
 # rest).  If the path ends in '/', tail will be empty.  If there is no
 # '/' in the path, head  will be empty.
 # Trailing '/'es are stripped from head unless it is the root.

def posixpath.normcase ( s)

Normalize case of pathname.  Has no effect under Posix

Definition at line 27 of file posixpath.py.

 
 def normcase(s):
     """Normalize case of pathname.  Has no effect under Posix"""
     return s
 
 
 # Return whether a path is absolute.
 # Trivial in Posix, harder on the Mac or MS-DOS.

def posixpath.normpath ( path)

Normalize path, eliminating double slashes, etc.

Definition at line 360 of file posixpath.py.

References join().

 
 def normpath(path):
     """Normalize path, eliminating double slashes, etc."""
     if path == '':
         return '.'
     initial_slashes = path.startswith('/')
     # POSIX allows one or two initial slashes, but treats three or more
     # as single slash.
     if (initial_slashes and
         path.startswith('//') and not path.startswith('///')):
         initial_slashes = 2
     comps = path.split('/')
     new_comps = []
     for comp in comps:
         if comp in ('', '.'):
             continue
         if (comp != '..' or (not initial_slashes and not new_comps) or
              (new_comps and new_comps[-1] == '..')):
             new_comps.append(comp)
         elif new_comps:
             new_comps.pop()
     comps = new_comps
     path = '/'.join(comps)
     if initial_slashes:
         path = '/'*initial_slashes + path
     return path or '.'
 

def posixpath.realpath ( filename)

Return the canonical path of the specified filename, eliminating any
symbolic links encountered in the path.

Definition at line 397 of file posixpath.py.

References abspath(), islink(), join(), normpath(), and split().

 
 def realpath(filename):
     """Return the canonical path of the specified filename, eliminating any
 symbolic links encountered in the path."""
     filename = abspath(filename)
 
     bits = ['/'] + filename.split('/')[1:]
     for i in range(2, len(bits)+1):
         component = join(*bits[0:i])
         if islink(component):
             resolved = os.readlink(component)
             (dir, file) = split(component)
             resolved = normpath(join(dir, resolved))
             newpath = join(*([resolved] + bits[i:]))
             return realpath(newpath)
 
     return filename

def posixpath.samefile	(	f1,
		f2
	)

Test whether two pathnames reference the same actual file

Definition at line 205 of file posixpath.py.

References samestat().

 
 def samefile(f1, f2):
     """Test whether two pathnames reference the same actual file"""
     s1 = os.stat(f1)
     s2 = os.stat(f2)
     return samestat(s1, s2)
 
 
 # Are two open files really referencing the same file?
 # (Not necessarily the same file descriptor!)

def posixpath.sameopenfile	(	fp1,
		fp2
	)

Test whether two open file objects reference the same file

Definition at line 215 of file posixpath.py.

References samestat().

 
 def sameopenfile(fp1, fp2):
     """Test whether two open file objects reference the same file"""
     s1 = os.fstat(fp1)
     s2 = os.fstat(fp2)
     return samestat(s1, s2)
 
 
 # Are two stat buffers (obtained from stat, fstat or lstat)
 # describing the same file?

def posixpath.samestat	(	s1,
		s2
	)

Test whether two stat buffers reference the same file

Definition at line 225 of file posixpath.py.

 
 def samestat(s1, s2):
     """Test whether two stat buffers reference the same file"""
     return s1[stat.ST_INO] == s2[stat.ST_INO] and \
            s1[stat.ST_DEV] == s2[stat.ST_DEV]
 
 
 # Is a path a mount point?
 # (Does this work for all UNIXes?  Is it even guaranteed to work by Posix?)

def posixpath.split ( p)

Split a pathname.  Returns tuple "(head, tail)" where "tail" is
everything after the final slash.  Either part may be empty.

Definition at line 62 of file posixpath.py.

 
 def split(p):
     """Split a pathname.  Returns tuple "(head, tail)" where "tail" is
     everything after the final slash.  Either part may be empty."""
     i = p.rfind('/') + 1
     head, tail = p[:i], p[i:]
     if head and head != '/'*len(head):
         while head[-1] == '/':
             head = head[:-1]
     return head, tail
 
 
 # Split a path in root and extension.
 # The extension is everything starting at the last dot in the last
 # pathname component; the root is everything before that.
 # It is always true that root + ext == p.

def posixpath.splitdrive ( p)

Split a pathname into drive and path. On Posix, drive is always
empty.

Definition at line 100 of file posixpath.py.

 
 def splitdrive(p):
     """Split a pathname into drive and path. On Posix, drive is always
     empty."""
     return '', p
 
 
 # Return the tail (basename) part of a path.

def posixpath.splitext ( p)

Split the extension from a pathname.  Extension is everything from the
last dot to the end.  Returns "(root, ext)", either part may be empty.

Definition at line 78 of file posixpath.py.

 
 def splitext(p):
     """Split the extension from a pathname.  Extension is everything from the
     last dot to the end.  Returns "(root, ext)", either part may be empty."""
     root, ext = '', ''
     for c in p:
         if c == '/':
             root, ext = root + ext + c, ''
         elif c == '.':
             if ext:
                 root, ext = root + ext, c
             else:
                 ext = c
         elif ext:
             ext = ext + c
         else:
             root = root + c
     return root, ext
 
 
 # Split a pathname into a drive specification and the rest of the
 # path.  Useful on DOS/Windows/NT; on Unix, the drive is always empty.

def posixpath.walk	(	top,
		func,
		arg
	)

Directory tree walk with callback function.

For each directory in the directory tree rooted at top (including top
itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
dirname is the name of the directory, and fnames a list of the names of
the files and subdirectories in dirname (excluding '.' and '..').  func
may modify the fnames list in-place (e.g. via del or slice assignment),
and walk will only recurse into the subdirectories whose names remain in
fnames; this can be used to implement a filter, or to impose a specific
order of visiting.  No semantics are defined for, or required of, arg,
beyond that arg is always passed to func.  It can be used, e.g., to pass
a filename pattern, or a mutable object designed to accumulate
statistics.  Passing None for arg is common.

Definition at line 260 of file posixpath.py.

References join(), and stat.S_ISDIR().

 
 def walk(top, func, arg):
     """Directory tree walk with callback function.
 
     For each directory in the directory tree rooted at top (including top
     itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
     dirname is the name of the directory, and fnames a list of the names of
     the files and subdirectories in dirname (excluding '.' and '..').  func
     may modify the fnames list in-place (e.g. via del or slice assignment),
     and walk will only recurse into the subdirectories whose names remain in
     fnames; this can be used to implement a filter, or to impose a specific
     order of visiting.  No semantics are defined for, or required of, arg,
     beyond that arg is always passed to func.  It can be used, e.g., to pass
     a filename pattern, or a mutable object designed to accumulate
     statistics.  Passing None for arg is common."""
 
     try:
         names = os.listdir(top)
     except os.error:
         return
     func(arg, top, names)
     for name in names:
         name = join(top, name)
         try:
             st = os.lstat(name)
         except os.error:
             continue
         if stat.S_ISDIR(st[stat.ST_MODE]):
             walk(name, func, arg)
 
 
 # Expand paths beginning with '~' or '~user'.
 # '~' means $HOME; '~user' means that user's home directory.
 # If the path doesn't begin with '~', or if the user or $HOME is unknown,
 # the path is returned unchanged (leaving error reporting to whatever
 # function is called with the expanded path as argument).
 # See also module 'glob' for expansion of *, ? and [...] in pathnames.
 # (A function should also be defined to do full *sh-style environment
 # variable expansion.)

Functions

Variables

Detailed Description

Function Documentation

Variable Documentation