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 / shutil.py < prev    next >
Encoding:
Python Source  |  2010-05-29  |  8.7 KB  |  275 lines
  1. """Utility functions for copying files and directory trees.
  2.  
  3. XXX The functions here don't copy the resource fork or other metadata on Mac.
  4.  
  5. """
  6.  
  7. import os
  8. import sys
  9. import stat
  10. from os.path import abspath
  11. import fnmatch
  12.  
  13. __all__ = ["copyfileobj","copyfile","copymode","copystat","copy","copy2",
  14.            "copytree","move","rmtree","Error"]
  15.  
  16. class Error(EnvironmentError):
  17.     pass
  18.  
  19. try:
  20.     WindowsError
  21. except NameError:
  22.     WindowsError = None
  23.  
  24. def copyfileobj(fsrc, fdst, length=16*1024):
  25.     """copy data from file-like object fsrc to file-like object fdst"""
  26.     while 1:
  27.         buf = fsrc.read(length)
  28.         if not buf:
  29.             break
  30.         fdst.write(buf)
  31.  
  32. def _samefile(src, dst):
  33.     # Macintosh, Unix.
  34.     if hasattr(os.path,'samefile'):
  35.         try:
  36.             return os.path.samefile(src, dst)
  37.         except OSError:
  38.             return False
  39.  
  40.     # All other platforms: check for same pathname.
  41.     return (os.path.normcase(os.path.abspath(src)) ==
  42.             os.path.normcase(os.path.abspath(dst)))
  43.  
  44. def copyfile(src, dst):
  45.     """Copy data from src to dst"""
  46.     if _samefile(src, dst):
  47.         raise Error, "`%s` and `%s` are the same file" % (src, dst)
  48.  
  49.     fsrc = None
  50.     fdst = None
  51.     try:
  52.         fsrc = open(src, 'rb')
  53.         fdst = open(dst, 'wb')
  54.         copyfileobj(fsrc, fdst)
  55.     finally:
  56.         if fdst:
  57.             fdst.close()
  58.         if fsrc:
  59.             fsrc.close()
  60.  
  61. def copymode(src, dst):
  62.     """Copy mode bits from src to dst"""
  63.     if hasattr(os, 'chmod'):
  64.         st = os.stat(src)
  65.         mode = stat.S_IMODE(st.st_mode)
  66.         os.chmod(dst, mode)
  67.  
  68. def copystat(src, dst):
  69.     """Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""
  70.     st = os.stat(src)
  71.     mode = stat.S_IMODE(st.st_mode)
  72.     if hasattr(os, 'utime'):
  73.         os.utime(dst, (st.st_atime, st.st_mtime))
  74.     if hasattr(os, 'chmod'):
  75.         os.chmod(dst, mode)
  76.     if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
  77.         os.chflags(dst, st.st_flags)
  78.  
  79.  
  80. def copy(src, dst):
  81.     """Copy data and mode bits ("cp src dst").
  82.  
  83.     The destination may be a directory.
  84.  
  85.     """
  86.     if os.path.isdir(dst):
  87.         dst = os.path.join(dst, os.path.basename(src))
  88.     copyfile(src, dst)
  89.     copymode(src, dst)
  90.  
  91. def copy2(src, dst):
  92.     """Copy data and all stat info ("cp -p src dst").
  93.  
  94.     The destination may be a directory.
  95.  
  96.     """
  97.     if os.path.isdir(dst):
  98.         dst = os.path.join(dst, os.path.basename(src))
  99.     copyfile(src, dst)
  100.     copystat(src, dst)
  101.  
  102. def ignore_patterns(*patterns):
  103.     """Function that can be used as copytree() ignore parameter.
  104.  
  105.     Patterns is a sequence of glob-style patterns
  106.     that are used to exclude files"""
  107.     def _ignore_patterns(path, names):
  108.         ignored_names = []
  109.         for pattern in patterns:
  110.             ignored_names.extend(fnmatch.filter(names, pattern))
  111.         return set(ignored_names)
  112.     return _ignore_patterns
  113.  
  114. def copytree(src, dst, symlinks=False, ignore=None):
  115.     """Recursively copy a directory tree using copy2().
  116.  
  117.     The destination directory must not already exist.
  118.     If exception(s) occur, an Error is raised with a list of reasons.
  119.  
  120.     If the optional symlinks flag is true, symbolic links in the
  121.     source tree result in symbolic links in the destination tree; if
  122.     it is false, the contents of the files pointed to by symbolic
  123.     links are copied.
  124.  
  125.     The optional ignore argument is a callable. If given, it
  126.     is called with the `src` parameter, which is the directory
  127.     being visited by copytree(), and `names` which is the list of
  128.     `src` contents, as returned by os.listdir():
  129.  
  130.         callable(src, names) -> ignored_names
  131.  
  132.     Since copytree() is called recursively, the callable will be
  133.     called once for each directory that is copied. It returns a
  134.     list of names relative to the `src` directory that should
  135.     not be copied.
  136.  
  137.     XXX Consider this example code rather than the ultimate tool.
  138.  
  139.     """
  140.     names = os.listdir(src)
  141.     if ignore is not None:
  142.         ignored_names = ignore(src, names)
  143.     else:
  144.         ignored_names = set()
  145.  
  146.     os.makedirs(dst)
  147.     errors = []
  148.     for name in names:
  149.         if name in ignored_names:
  150.             continue
  151.         srcname = os.path.join(src, name)
  152.         dstname = os.path.join(dst, name)
  153.         try:
  154.             if symlinks and os.path.islink(srcname):
  155.                 linkto = os.readlink(srcname)
  156.                 os.symlink(linkto, dstname)
  157.             elif os.path.isdir(srcname):
  158.                 copytree(srcname, dstname, symlinks, ignore)
  159.             else:
  160.                 copy2(srcname, dstname)
  161.             # XXX What about devices, sockets etc.?
  162.         except (IOError, os.error), why:
  163.             errors.append((srcname, dstname, str(why)))
  164.         # catch the Error from the recursive copytree so that we can
  165.         # continue with other files
  166.         except Error, err:
  167.             errors.extend(err.args[0])
  168.     try:
  169.         copystat(src, dst)
  170.     except OSError, why:
  171.         if WindowsError is not None and isinstance(why, WindowsError):
  172.             # Copying file access times may fail on Windows
  173.             pass
  174.         else:
  175.             errors.extend((src, dst, str(why)))
  176.     if errors:
  177.         raise Error, errors
  178.  
  179. def rmtree(path, ignore_errors=False, onerror=None):
  180.     """Recursively delete a directory tree.
  181.  
  182.     If ignore_errors is set, errors are ignored; otherwise, if onerror
  183.     is set, it is called to handle the error with arguments (func,
  184.     path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
  185.     path is the argument to that function that caused it to fail; and
  186.     exc_info is a tuple returned by sys.exc_info().  If ignore_errors
  187.     is false and onerror is None, an exception is raised.
  188.  
  189.     """
  190.     if ignore_errors:
  191.         def onerror(*args):
  192.             pass
  193.     elif onerror is None:
  194.         def onerror(*args):
  195.             raise
  196.     try:
  197.         if os.path.islink(path):
  198.             # symlinks to directories are forbidden, see bug #1669
  199.             raise OSError("Cannot call rmtree on a symbolic link")
  200.     except OSError:
  201.         onerror(os.path.islink, path, sys.exc_info())
  202.         # can't continue even if onerror hook returns
  203.         return
  204.     names = []
  205.     try:
  206.         names = os.listdir(path)
  207.     except os.error, err:
  208.         onerror(os.listdir, path, sys.exc_info())
  209.     for name in names:
  210.         fullname = os.path.join(path, name)
  211.         try:
  212.             mode = os.lstat(fullname).st_mode
  213.         except os.error:
  214.             mode = 0
  215.         if stat.S_ISDIR(mode):
  216.             rmtree(fullname, ignore_errors, onerror)
  217.         else:
  218.             try:
  219.                 os.remove(fullname)
  220.             except os.error, err:
  221.                 onerror(os.remove, fullname, sys.exc_info())
  222.     try:
  223.         os.rmdir(path)
  224.     except os.error:
  225.         onerror(os.rmdir, path, sys.exc_info())
  226.  
  227.  
  228. def _basename(path):
  229.     # A basename() variant which first strips the trailing slash, if present.
  230.     # Thus we always get the last component of the path, even for directories.
  231.     return os.path.basename(path.rstrip(os.path.sep))
  232.  
  233. def move(src, dst):
  234.     """Recursively move a file or directory to another location. This is
  235.     similar to the Unix "mv" command.
  236.  
  237.     If the destination is a directory or a symlink to a directory, the source
  238.     is moved inside the directory. The destination path must not already
  239.     exist.
  240.  
  241.     If the destination already exists but is not a directory, it may be
  242.     overwritten depending on os.rename() semantics.
  243.  
  244.     If the destination is on our current filesystem, then rename() is used.
  245.     Otherwise, src is copied to the destination and then removed.
  246.     A lot more could be done here...  A look at a mv.c shows a lot of
  247.     the issues this implementation glosses over.
  248.  
  249.     """
  250.     real_dst = dst
  251.     if os.path.isdir(dst):
  252.         real_dst = os.path.join(dst, _basename(src))
  253.         if os.path.exists(real_dst):
  254.             raise Error, "Destination path '%s' already exists" % real_dst
  255.     try:
  256.         os.rename(src, real_dst)
  257.     except OSError:
  258.         if os.path.isdir(src):
  259.             if destinsrc(src, dst):
  260.                 raise Error, "Cannot move a directory '%s' into itself '%s'." % (src, dst)
  261.             copytree(src, real_dst, symlinks=True)
  262.             rmtree(src)
  263.         else:
  264.             copy2(src, real_dst)
  265.             os.unlink(src)
  266.  
  267. def destinsrc(src, dst):
  268.     src = abspath(src)
  269.     dst = abspath(dst)
  270.     if not src.endswith(os.path.sep):
  271.         src += os.path.sep
  272.     if not dst.endswith(os.path.sep):
  273.         dst += os.path.sep
  274.     return dst.startswith(src)
  275.