fife-parpg: utils/util_scripts/path.py comparison

comparison utils/util_scripts/path.py @ 0:4a0efb7baf70

* Datasets becomes the new trunk and retires after that :-)

author	mvbarracuda@33b003aa-7bff-0310-803a-e67f0ece8222
date	Sun, 29 Jun 2008 18:44:17 +0000
parents
children	8a9cab8f8868

comparison

equal deleted inserted replaced

--1:000000000000
+:4a0efb7baf70
+""" path.py - An object representing a path to a file or directory.
+Example:
+from path import path
+d = path('/home/guido/bin')
+for f in d.files('*.py'):
+f.chmod(0755)
+This module requires Python 2.2 or later.
+URL:     http://www.jorendorff.com/articles/python/path
+Author:  Jason Orendorff <jason.orendorff\x40gmail\x2ecom> (and others - see the url!)
+Date:    9 Mar 2007
+"""
+# TODO
+#   - Tree-walking functions don't avoid symlink loops.  Matt Harrison
+#     sent me a patch for this.
+#   - Bug in write_text().  It doesn't support Universal newline mode.
+#   - Better error message in listdir() when self isn't a
+#     directory. (On Windows, the error message really sucks.)
+#   - Make sure everything has a good docstring.
+#   - Add methods for regex find and replace.
+#   - guess_content_type() method?
+#   - Perhaps support arguments to touch().
+from __future__ import generators
+import sys, warnings, os, fnmatch, glob, shutil, codecs, md5
+__version__ = '2.2'
+__all__ = ['path']
+# Platform-specific support for path.owner
+if os.name == 'nt':
+try:
+import win32security
+except ImportError:
+win32security = None
+else:
+try:
+import pwd
+except ImportError:
+pwd = None
+# Pre-2.3 support.  Are unicode filenames supported?
+_base = str
+_getcwd = os.getcwd
+try:
+if os.path.supports_unicode_filenames:
+_base = unicode
+_getcwd = os.getcwdu
+except AttributeError:
+pass
+# Pre-2.3 workaround for booleans
+try:
+True, False
+except NameError:
+True, False = 1, 0
+# Pre-2.3 workaround for basestring.
+try:
+basestring
+except NameError:
+basestring = (str, unicode)
+# Universal newline support
+_textmode = 'r'
+if hasattr(file, 'newlines'):
+_textmode = 'U'
+class TreeWalkWarning(Warning):
+pass
+class path(_base):
+""" Represents a filesystem path.
+For documentation on individual methods, consult their
+counterparts in os.path.
+"""
+# --- Special Python methods.
+def __repr__(self):
+return 'path(%s)' % _base.__repr__(self)
+# Adding a path and a string yields a path.
+def __add__(self, more):
+try:
+resultStr = _base.__add__(self, more)
+except TypeError:  #Python bug
+resultStr = NotImplemented
+if resultStr is NotImplemented:
+return resultStr
+return self.__class__(resultStr)
+def __radd__(self, other):
+if isinstance(other, basestring):
+return self.__class__(other.__add__(self))
+else:
+return NotImplemented
+# The / operator joins paths.
+def __div__(self, rel):
+""" fp.__div__(rel) == fp / rel == fp.joinpath(rel)
+Join two path components, adding a separator character if
+needed.
+"""
+return self.__class__(os.path.join(self, rel))
+# Make the / operator work even when true division is enabled.
+__truediv__ = __div__
+def getcwd(cls):
+""" Return the current working directory as a path object. """
+return cls(_getcwd())
+getcwd = classmethod(getcwd)
+# --- Operations on path strings.
+isabs = os.path.isabs
+def abspath(self):       return self.__class__(os.path.abspath(self))
+def normcase(self):      return self.__class__(os.path.normcase(self))
+def normpath(self):      return self.__class__(os.path.normpath(self))
+def realpath(self):      return self.__class__(os.path.realpath(self))
+def expanduser(self):    return self.__class__(os.path.expanduser(self))
+def expandvars(self):    return self.__class__(os.path.expandvars(self))
+def dirname(self):       return self.__class__(os.path.dirname(self))
+basename = os.path.basename
+def expand(self):
+""" Clean up a filename by calling expandvars(),
+expanduser(), and normpath() on it.
+This is commonly everything needed to clean up a filename
+read from a configuration file, for example.
+"""
+return self.expandvars().expanduser().normpath()
+def _get_namebase(self):
+base, ext = os.path.splitext(self.name)
+return base
+def _get_ext(self):
+f, ext = os.path.splitext(_base(self))
+return ext
+def _get_drive(self):
+drive, r = os.path.splitdrive(self)
+return self.__class__(drive)
+parent = property(
+dirname, None, None,
+""" This path's parent directory, as a new path object.
+For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')
+""")
+name = property(
+basename, None, None,
+""" The name of this file or directory without the full path.
+For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'
+""")
+namebase = property(
+_get_namebase, None, None,
+""" The same as path.name, but with one file extension stripped off.
+For example, path('/home/guido/python.tar.gz').name     == 'python.tar.gz',
+but          path('/home/guido/python.tar.gz').namebase == 'python.tar'
+""")
+ext = property(
+_get_ext, None, None,
+""" The file extension, for example '.py'. """)
+drive = property(
+_get_drive, None, None,
+""" The drive specifier, for example 'C:'.
+This is always empty on systems that don't use drive specifiers.
+""")
+def splitpath(self):
+""" p.splitpath() -> Return (p.parent, p.name). """
+parent, child = os.path.split(self)
+return self.__class__(parent), child
+def splitdrive(self):
+""" p.splitdrive() -> Return (p.drive, <the rest of p>).
+Split the drive specifier from this path.  If there is
+no drive specifier, p.drive is empty, so the return value
+is simply (path(''), p).  This is always the case on Unix.
+"""
+drive, rel = os.path.splitdrive(self)
+return self.__class__(drive), rel
+def splitext(self):
+""" p.splitext() -> Return (p.stripext(), p.ext).
+Split the filename extension from this path and return
+the two parts.  Either part may be empty.
+The extension is everything from '.' to the end of the
+last path segment.  This has the property that if
+(a, b) == p.splitext(), then a + b == p.
+"""
+filename, ext = os.path.splitext(self)
+return self.__class__(filename), ext
+def stripext(self):
+""" p.stripext() -> Remove one file extension from the path.
+For example, path('/home/guido/python.tar.gz').stripext()
+returns path('/home/guido/python.tar').
+"""
+return self.splitext()[0]
+if hasattr(os.path, 'splitunc'):
+def splitunc(self):
+unc, rest = os.path.splitunc(self)
+return self.__class__(unc), rest
+def _get_uncshare(self):
+unc, r = os.path.splitunc(self)
+return self.__class__(unc)
+uncshare = property(
+_get_uncshare, None, None,
+""" The UNC mount point for this path.
+This is empty for paths on local drives. """)
+def joinpath(self, *args):
+""" Join two or more path components, adding a separator
+character (os.sep) if needed.  Returns a new path
+object.
+"""
+return self.__class__(os.path.join(self, *args))
+def splitall(self):
+r""" Return a list of the path components in this path.
+The first item in the list will be a path.  Its value will be
+either os.curdir, os.pardir, empty, or the root directory of
+this path (for example, '/' or 'C:\\').  The other items in
+the list will be strings.
+path.path.joinpath(*result) will yield the original path.
+"""
+parts = []
+loc = self
+while loc != os.curdir and loc != os.pardir:
+prev = loc
+loc, child = prev.splitpath()
+if loc == prev:
+break
+parts.append(child)
+parts.append(loc)
+parts.reverse()
+return parts
+def relpath(self):
+""" Return this path as a relative path,
+based from the current working directory.
+"""
+cwd = self.__class__(os.getcwd())
+return cwd.relpathto(self)
+def relpathto(self, dest):
+""" Return a relative path from self to dest.
+If there is no relative path from self to dest, for example if
+they reside on different drives in Windows, then this returns
+dest.abspath().
+"""
+origin = self.abspath()
+dest = self.__class__(dest).abspath()
+orig_list = origin.normcase().splitall()
+# Don't normcase dest!  We want to preserve the case.
+dest_list = dest.splitall()
+if orig_list[0] != os.path.normcase(dest_list[0]):
+# Can't get here from there.
+return dest
+# Find the location where the two paths start to differ.
+i = 0
+for start_seg, dest_seg in zip(orig_list, dest_list):
+if start_seg != os.path.normcase(dest_seg):
+break
+i += 1
+# Now i is the point where the two paths diverge.
+# Need a certain number of "os.pardir"s to work up
+# from the origin to the point of divergence.
+segments = [os.pardir] * (len(orig_list) - i)
+# Need to add the diverging part of dest_list.
+segments += dest_list[i:]
+if len(segments) == 0:
+# If they happen to be identical, use os.curdir.
+relpath = os.curdir
+else:
+relpath = os.path.join(*segments)
+return self.__class__(relpath)
+# --- Listing, searching, walking, and matching
+def listdir(self, pattern=None):
+""" D.listdir() -> List of items in this directory.
+Use D.files() or D.dirs() instead if you want a listing
+of just files or just subdirectories.
+The elements of the list are path objects.
+With the optional 'pattern' argument, this only lists
+items whose names match the given pattern.
+"""
+names = os.listdir(self)
+if pattern is not None:
+names = fnmatch.filter(names, pattern)
+return [self / child for child in names]
+def dirs(self, pattern=None):
+""" D.dirs() -> List of this directory's subdirectories.
+The elements of the list are path objects.
+This does not walk recursively into subdirectories
+(but see path.walkdirs).
+With the optional 'pattern' argument, this only lists
+directories whose names match the given pattern.  For
+example, d.dirs('build-*').
+"""
+return [p for p in self.listdir(pattern) if p.isdir()]
+def files(self, pattern=None):
+""" D.files() -> List of the files in this directory.
+The elements of the list are path objects.
+This does not walk into subdirectories (see path.walkfiles).
+With the optional 'pattern' argument, this only lists files
+whose names match the given pattern.  For example,
+d.files('*.pyc').
+"""
+return [p for p in self.listdir(pattern) if p.isfile()]
+def walk(self, pattern=None, errors='strict'):
+""" D.walk() -> iterator over files and subdirs, recursively.
+The iterator yields path objects naming each child item of
+this directory and its descendants.  This requires that
+D.isdir().
+This performs a depth-first traversal of the directory tree.
+Each directory is returned just before all its children.
+The errors= keyword argument controls behavior when an
+error occurs.  The default is 'strict', which causes an
+exception.  The other allowed values are 'warn', which
+reports the error via warnings.warn(), and 'ignore'.
+"""
+if errors not in ('strict', 'warn', 'ignore'):
+raise ValueError("invalid errors parameter")
+try:
+childList = self.listdir()
+except Exception:
+if errors == 'ignore':
+return
+elif errors == 'warn':
+warnings.warn(
+"Unable to list directory '%s': %s"
+% (self, sys.exc_info()[1]),
+TreeWalkWarning)
+return
+else:
+raise
+for child in childList:
+if pattern is None or child.fnmatch(pattern):
+yield child
+try:
+isdir = child.isdir()
+except Exception:
+if errors == 'ignore':
+isdir = False
+elif errors == 'warn':
+warnings.warn(
+"Unable to access '%s': %s"
+% (child, sys.exc_info()[1]),
+TreeWalkWarning)
+isdir = False
+else:
+raise
+if isdir:
+for item in child.walk(pattern, errors):
+yield item
+def walkdirs(self, pattern=None, errors='strict'):
+""" D.walkdirs() -> iterator over subdirs, recursively.
+With the optional 'pattern' argument, this yields only
+directories whose names match the given pattern.  For
+example, mydir.walkdirs('*test') yields only directories
+with names ending in 'test'.
+The errors= keyword argument controls behavior when an
+error occurs.  The default is 'strict', which causes an
+exception.  The other allowed values are 'warn', which
+reports the error via warnings.warn(), and 'ignore'.
+"""
+if errors not in ('strict', 'warn', 'ignore'):
+raise ValueError("invalid errors parameter")
+try:
+dirs = self.dirs()
+except Exception:
+if errors == 'ignore':
+return
+elif errors == 'warn':
+warnings.warn(
+"Unable to list directory '%s': %s"
+% (self, sys.exc_info()[1]),
+TreeWalkWarning)
+return
+else:
+raise
+for child in dirs:
+if pattern is None or child.fnmatch(pattern):
+yield child
+for subsubdir in child.walkdirs(pattern, errors):
+yield subsubdir
+def walkfiles(self, pattern=None, errors='strict'):
+""" D.walkfiles() -> iterator over files in D, recursively.
+The optional argument, pattern, limits the results to files
+with names that match the pattern.  For example,
+mydir.walkfiles('*.tmp') yields only files with the .tmp
+extension.
+"""
+if errors not in ('strict', 'warn', 'ignore'):
+raise ValueError("invalid errors parameter")
+try:
+childList = self.listdir()
+except Exception:
+if errors == 'ignore':
+return
+elif errors == 'warn':
+warnings.warn(
+"Unable to list directory '%s': %s"
+% (self, sys.exc_info()[1]),
+TreeWalkWarning)
+return
+else:
+raise
+for child in childList:
+try:
+isfile = child.isfile()
+isdir = not isfile and child.isdir()
+except:
+if errors == 'ignore':
+continue
+elif errors == 'warn':
+warnings.warn(
+"Unable to access '%s': %s"
+% (self, sys.exc_info()[1]),
+TreeWalkWarning)
+continue
+else:
+raise
+if isfile:
+if pattern is None or child.fnmatch(pattern):
+yield child
+elif isdir:
+for f in child.walkfiles(pattern, errors):
+yield f
+def fnmatch(self, pattern):
+""" Return True if self.name matches the given pattern.
+pattern - A filename pattern with wildcards,
+for example '*.py'.
+"""
+return fnmatch.fnmatch(self.name, pattern)
+def glob(self, pattern):
+""" Return a list of path objects that match the pattern.
+pattern - a path relative to this directory, with wildcards.
+For example, path('/users').glob('*/bin/*') returns a list
+of all the files users have in their bin directories.
+"""
+cls = self.__class__
+return [cls(s) for s in glob.glob(_base(self / pattern))]
+# --- Reading or writing an entire file at once.
+def open(self, mode='r'):
+""" Open this file.  Return a file object. """
+return file(self, mode)
+def bytes(self):
+""" Open this file, read all bytes, return them as a string. """
+f = self.open('rb')
+try:
+return f.read()
+finally:
+f.close()
+def write_bytes(self, bytes, append=False):
+""" Open this file and write the given bytes to it.
+Default behavior is to overwrite any existing file.
+Call p.write_bytes(bytes, append=True) to append instead.
+"""
+if append:
+mode = 'ab'
+else:
+mode = 'wb'
+f = self.open(mode)
+try:
+f.write(bytes)
+finally:
+f.close()
+def text(self, encoding=None, errors='strict'):
+r""" Open this file, read it in, return the content as a string.
+This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r'
+are automatically translated to '\n'.
+Optional arguments:
+encoding - The Unicode encoding (or character set) of
+the file.  If present, the content of the file is
+decoded and returned as a unicode object; otherwise
+it is returned as an 8-bit str.
+errors - How to handle Unicode errors; see help(str.decode)
+for the options.  Default is 'strict'.
+"""
+if encoding is None:
+# 8-bit
+f = self.open(_textmode)
+try:
+return f.read()
+finally:
+f.close()
+else:
+# Unicode
+f = codecs.open(self, 'r', encoding, errors)
+# (Note - Can't use 'U' mode here, since codecs.open
+# doesn't support 'U' mode, even in Python 2.3.)
+try:
+t = f.read()
+finally:
+f.close()
+return (t.replace(u'\r\n', u'\n')
+.replace(u'\r\x85', u'\n')
+.replace(u'\r', u'\n')
+.replace(u'\x85', u'\n')
+.replace(u'\u2028', u'\n'))
+def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False):
+r""" Write the given text to this file.
+The default behavior is to overwrite any existing file;
+to append instead, use the 'append=True' keyword argument.
+There are two differences between path.write_text() and
+path.write_bytes(): newline handling and Unicode handling.
+See below.
+Parameters:
+- text - str/unicode - The text to be written.
+- encoding - str - The Unicode encoding that will be used.
+This is ignored if 'text' isn't a Unicode string.
+- errors - str - How to handle Unicode encoding errors.
+Default is 'strict'.  See help(unicode.encode) for the
+options.  This is ignored if 'text' isn't a Unicode
+string.
+- linesep - keyword argument - str/unicode - The sequence of
+characters to be used to mark end-of-line.  The default is
+os.linesep.  You can also specify None; this means to
+leave all newlines as they are in 'text'.
+- append - keyword argument - bool - Specifies what to do if
+the file already exists (True: append to the end of it;
+False: overwrite it.)  The default is False.
+--- Newline handling.
+write_text() converts all standard end-of-line sequences
+('\n', '\r', and '\r\n') to your platform's default end-of-line
+sequence (see os.linesep; on Windows, for example, the
+end-of-line marker is '\r\n').
+If you don't like your platform's default, you can override it
+using the 'linesep=' keyword argument.  If you specifically want
+write_text() to preserve the newlines as-is, use 'linesep=None'.
+This applies to Unicode text the same as to 8-bit text, except
+there are three additional standard Unicode end-of-line sequences:
+u'\x85', u'\r\x85', and u'\u2028'.
+(This is slightly different from when you open a file for
+writing with fopen(filename, "w") in C or file(filename, 'w')
+in Python.)
+--- Unicode
+If 'text' isn't Unicode, then apart from newline handling, the
+bytes are written verbatim to the file.  The 'encoding' and
+'errors' arguments are not used and must be omitted.
+If 'text' is Unicode, it is first converted to bytes using the
+specified 'encoding' (or the default encoding if 'encoding'
+isn't specified).  The 'errors' argument applies only to this
+conversion.
+"""
+if isinstance(text, unicode):
+if linesep is not None:
+# Convert all standard end-of-line sequences to
+# ordinary newline characters.
+text = (text.replace(u'\r\n', u'\n')
+.replace(u'\r\x85', u'\n')
+.replace(u'\r', u'\n')
+.replace(u'\x85', u'\n')
+.replace(u'\u2028', u'\n'))
+text = text.replace(u'\n', linesep)
+if encoding is None:
+encoding = sys.getdefaultencoding()
+bytes = text.encode(encoding, errors)
+else:
+# It is an error to specify an encoding if 'text' is
+# an 8-bit string.
+assert encoding is None
+if linesep is not None:
+text = (text.replace('\r\n', '\n')
+.replace('\r', '\n'))
+bytes = text.replace('\n', linesep)
+self.write_bytes(bytes, append)
+def lines(self, encoding=None, errors='strict', retain=True):
+r""" Open this file, read all lines, return them in a list.
+Optional arguments:
+encoding - The Unicode encoding (or character set) of
+the file.  The default is None, meaning the content
+of the file is read as 8-bit characters and returned
+as a list of (non-Unicode) str objects.
+errors - How to handle Unicode errors; see help(str.decode)
+for the options.  Default is 'strict'
+retain - If true, retain newline characters; but all newline
+character combinations ('\r', '\n', '\r\n') are
+translated to '\n'.  If false, newline characters are
+stripped off.  Default is True.
+This uses 'U' mode in Python 2.3 and later.
+"""
+if encoding is None and retain:
+f = self.open(_textmode)
+try:
+return f.readlines()
+finally:
+f.close()
+else:
+return self.text(encoding, errors).splitlines(retain)
+def write_lines(self, lines, encoding=None, errors='strict',
+linesep=os.linesep, append=False):
+r""" Write the given lines of text to this file.
+By default this overwrites any existing file at this path.
+This puts a platform-specific newline sequence on every line.
+See 'linesep' below.
+lines - A list of strings.
+encoding - A Unicode encoding to use.  This applies only if
+'lines' contains any Unicode strings.
+errors - How to handle errors in Unicode encoding.  This
+also applies only to Unicode strings.
+linesep - The desired line-ending.  This line-ending is
+applied to every line.  If a line already has any
+standard line ending ('\r', '\n', '\r\n', u'\x85',
+u'\r\x85', u'\u2028'), that will be stripped off and
+this will be used instead.  The default is os.linesep,
+which is platform-dependent ('\r\n' on Windows, '\n' on
+Unix, etc.)  Specify None to write the lines as-is,
+like file.writelines().
+Use the keyword argument append=True to append lines to the
+file.  The default is to overwrite the file.  Warning:
+When you use this with Unicode data, if the encoding of the
+existing data in the file is different from the encoding
+you specify with the encoding= parameter, the result is
+mixed-encoding data, which can really confuse someone trying
+to read the file later.
+"""
+if append:
+mode = 'ab'
+else:
+mode = 'wb'
+f = self.open(mode)
+try:
+for line in lines:
+isUnicode = isinstance(line, unicode)
+if linesep is not None:
+# Strip off any existing line-end and add the
+# specified linesep string.
+if isUnicode:
+if line[-2:] in (u'\r\n', u'\x0d\x85'):
+line = line[:-2]
+elif line[-1:] in (u'\r', u'\n',
+u'\x85', u'\u2028'):
+line = line[:-1]
+else:
+if line[-2:] == '\r\n':
+line = line[:-2]
+elif line[-1:] in ('\r', '\n'):
+line = line[:-1]
+line += linesep
+if isUnicode:
+if encoding is None:
+encoding = sys.getdefaultencoding()
+line = line.encode(encoding, errors)
+f.write(line)
+finally:
+f.close()
+def read_md5(self):
+""" Calculate the md5 hash for this file.
+This reads through the entire file.
+"""
+f = self.open('rb')
+try:
+m = md5.new()
+while True:
+d = f.read(8192)
+if not d:
+break
+m.update(d)
+finally:
+f.close()
+return m.digest()
+# --- Methods for querying the filesystem.
+exists = os.path.exists
+isdir = os.path.isdir
+isfile = os.path.isfile
+islink = os.path.islink
+ismount = os.path.ismount
+if hasattr(os.path, 'samefile'):
+samefile = os.path.samefile
+getatime = os.path.getatime
+atime = property(
+getatime, None, None,
+""" Last access time of the file. """)
+getmtime = os.path.getmtime
+mtime = property(
+getmtime, None, None,
+""" Last-modified time of the file. """)
+if hasattr(os.path, 'getctime'):
+getctime = os.path.getctime
+ctime = property(
+getctime, None, None,
+""" Creation time of the file. """)
+getsize = os.path.getsize
+size = property(
+getsize, None, None,
+""" Size of the file, in bytes. """)
+if hasattr(os, 'access'):
+def access(self, mode):
+""" Return true if current user has access to this path.
+mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK
+"""
+return os.access(self, mode)
+def stat(self):
+""" Perform a stat() system call on this path. """
+return os.stat(self)
+def lstat(self):
+""" Like path.stat(), but do not follow symbolic links. """
+return os.lstat(self)
+def get_owner(self):
+r""" Return the name of the owner of this file or directory.
+This follows symbolic links.
+On Windows, this returns a name of the form ur'DOMAIN\User Name'.
+On Windows, a group can own a file or directory.
+"""
+if os.name == 'nt':
+if win32security is None:
+raise Exception("path.owner requires win32all to be installed")
+desc = win32security.GetFileSecurity(
+self, win32security.OWNER_SECURITY_INFORMATION)
+sid = desc.GetSecurityDescriptorOwner()
+account, domain, typecode = win32security.LookupAccountSid(None, sid)
+return domain + u'\\' + account
+else:
+if pwd is None:
+raise NotImplementedError("path.owner is not implemented on this platform.")
+st = self.stat()
+return pwd.getpwuid(st.st_uid).pw_name
+owner = property(
+get_owner, None, None,
+""" Name of the owner of this file or directory. """)
+if hasattr(os, 'statvfs'):
+def statvfs(self):
+""" Perform a statvfs() system call on this path. """
+return os.statvfs(self)
+if hasattr(os, 'pathconf'):
+def pathconf(self, name):
+return os.pathconf(self, name)
+# --- Modifying operations on files and directories
+def utime(self, times):
+""" Set the access and modified times of this file. """
+os.utime(self, times)
+def chmod(self, mode):
+os.chmod(self, mode)
+if hasattr(os, 'chown'):
+def chown(self, uid, gid):
+os.chown(self, uid, gid)
+def rename(self, new):
+os.rename(self, new)
+def renames(self, new):
+os.renames(self, new)
+# --- Create/delete operations on directories
+def mkdir(self, mode=0777):
+os.mkdir(self, mode)
+def makedirs(self, mode=0777):
+os.makedirs(self, mode)
+def rmdir(self):
+os.rmdir(self)
+def removedirs(self):
+os.removedirs(self)
+# --- Modifying operations on files
+def touch(self):
+""" Set the access/modified times of this file to the current time.
+Create the file if it does not exist.
+"""
+fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
+os.close(fd)
+os.utime(self, None)
+def remove(self):
+os.remove(self)
+def unlink(self):
+os.unlink(self)
+# --- Links
+if hasattr(os, 'link'):
+def link(self, newpath):
+""" Create a hard link at 'newpath', pointing to this file. """
+os.link(self, newpath)
+if hasattr(os, 'symlink'):
+def symlink(self, newlink):
+""" Create a symbolic link at 'newlink', pointing here. """
+os.symlink(self, newlink)
+if hasattr(os, 'readlink'):
+def readlink(self):
+""" Return the path to which this symbolic link points.
+The result may be an absolute or a relative path.
+"""
+return self.__class__(os.readlink(self))
+def readlinkabs(self):
+""" Return the path to which this symbolic link points.
+The result is always an absolute path.
+"""
+p = self.readlink()
+if p.isabs():
+return p
+else:
+return (self.parent / p).abspath()
+# --- High-level functions from shutil
+copyfile = shutil.copyfile
+copymode = shutil.copymode
+copystat = shutil.copystat
+copy = shutil.copy
+copy2 = shutil.copy2
+copytree = shutil.copytree
+if hasattr(shutil, 'move'):
+move = shutil.move
+rmtree = shutil.rmtree
+# --- Special stuff from os
+if hasattr(os, 'chroot'):
+def chroot(self):
+os.chroot(self)
+if hasattr(os, 'startfile'):
+def startfile(self):
+os.startfile(self)

Mercurial > fife-parpg

comparison utils/util_scripts/path.py @ 0:4a0efb7baf70