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     return abspath(dst).startswith(abspath(src))