Guido van Rossum | e7b146f | 2000-02-04 15:28:42 +0000 | [diff] [blame] | 1 | """Utility functions for copying files and directory trees. |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 2 | |
Guido van Rossum | 959fa01 | 1999-08-18 20:03:17 +0000 | [diff] [blame] | 3 | XXX The functions here don't copy the resource fork or other metadata on Mac. |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 4 | |
| 5 | """ |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 6 | |
Guido van Rossum | c96207a | 1992-03-31 18:55:40 +0000 | [diff] [blame] | 7 | import os |
Guido van Rossum | 83c03e2 | 1999-02-23 23:07:51 +0000 | [diff] [blame] | 8 | import sys |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 9 | import stat |
Brett Cannon | 1c3fa18 | 2004-06-19 21:11:35 +0000 | [diff] [blame] | 10 | from os.path import abspath |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 11 | import fnmatch |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 12 | |
Skip Montanaro | 0de6580 | 2001-02-15 22:15:14 +0000 | [diff] [blame] | 13 | __all__ = ["copyfileobj","copyfile","copymode","copystat","copy","copy2", |
Antoine Pitrou | 7fff096 | 2009-05-01 21:09:44 +0000 | [diff] [blame] | 14 | "copytree","move","rmtree","Error", "SpecialFileError"] |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 15 | |
Neal Norwitz | 4ce69a5 | 2005-09-01 00:45:28 +0000 | [diff] [blame] | 16 | class Error(EnvironmentError): |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 17 | pass |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 18 | |
Antoine Pitrou | 7fff096 | 2009-05-01 21:09:44 +0000 | [diff] [blame] | 19 | class SpecialFileError(EnvironmentError): |
| 20 | """Raised when trying to do a kind of operation (e.g. copying) which is |
| 21 | not supported on a special file (e.g. a named pipe)""" |
| 22 | |
Georg Brandl | 6aa2d1f | 2008-08-12 08:35:52 +0000 | [diff] [blame] | 23 | try: |
| 24 | WindowsError |
| 25 | except NameError: |
| 26 | WindowsError = None |
| 27 | |
Greg Stein | 42bb8b3 | 2000-07-12 09:55:30 +0000 | [diff] [blame] | 28 | def copyfileobj(fsrc, fdst, length=16*1024): |
| 29 | """copy data from file-like object fsrc to file-like object fdst""" |
| 30 | while 1: |
| 31 | buf = fsrc.read(length) |
| 32 | if not buf: |
| 33 | break |
| 34 | fdst.write(buf) |
| 35 | |
Johannes Gijsbers | 46f1459 | 2004-08-14 13:30:02 +0000 | [diff] [blame] | 36 | def _samefile(src, dst): |
| 37 | # Macintosh, Unix. |
| 38 | if hasattr(os.path,'samefile'): |
Johannes Gijsbers | f9a098e | 2004-08-14 14:51:01 +0000 | [diff] [blame] | 39 | try: |
| 40 | return os.path.samefile(src, dst) |
| 41 | except OSError: |
| 42 | return False |
Johannes Gijsbers | 46f1459 | 2004-08-14 13:30:02 +0000 | [diff] [blame] | 43 | |
| 44 | # All other platforms: check for same pathname. |
| 45 | return (os.path.normcase(os.path.abspath(src)) == |
| 46 | os.path.normcase(os.path.abspath(dst))) |
Tim Peters | 495ad3c | 2001-01-15 01:36:40 +0000 | [diff] [blame] | 47 | |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 48 | def copyfile(src, dst): |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 49 | """Copy data from src to dst""" |
Johannes Gijsbers | 46f1459 | 2004-08-14 13:30:02 +0000 | [diff] [blame] | 50 | if _samefile(src, dst): |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 51 | raise Error("`%s` and `%s` are the same file" % (src, dst)) |
Johannes Gijsbers | 46f1459 | 2004-08-14 13:30:02 +0000 | [diff] [blame] | 52 | |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 53 | fsrc = None |
| 54 | fdst = None |
Antoine Pitrou | 7fff096 | 2009-05-01 21:09:44 +0000 | [diff] [blame] | 55 | for fn in [src, dst]: |
| 56 | try: |
| 57 | st = os.stat(fn) |
| 58 | except OSError: |
| 59 | # File most likely does not exist |
| 60 | pass |
Benjamin Peterson | c0d98aa | 2009-06-05 19:13:27 +0000 | [diff] [blame] | 61 | else: |
| 62 | # XXX What about other special files? (sockets, devices...) |
| 63 | if stat.S_ISFIFO(st.st_mode): |
| 64 | raise SpecialFileError("`%s` is a named pipe" % fn) |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 65 | try: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 66 | fsrc = open(src, 'rb') |
| 67 | fdst = open(dst, 'wb') |
Greg Stein | 42bb8b3 | 2000-07-12 09:55:30 +0000 | [diff] [blame] | 68 | copyfileobj(fsrc, fdst) |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 69 | finally: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 70 | if fdst: |
| 71 | fdst.close() |
| 72 | if fsrc: |
| 73 | fsrc.close() |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 74 | |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 75 | def copymode(src, dst): |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 76 | """Copy mode bits from src to dst""" |
Tim Peters | 0c94724 | 2001-01-21 20:00:00 +0000 | [diff] [blame] | 77 | if hasattr(os, 'chmod'): |
| 78 | st = os.stat(src) |
Walter Dörwald | 294bbf3 | 2002-06-06 09:48:13 +0000 | [diff] [blame] | 79 | mode = stat.S_IMODE(st.st_mode) |
Tim Peters | 0c94724 | 2001-01-21 20:00:00 +0000 | [diff] [blame] | 80 | os.chmod(dst, mode) |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 81 | |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 82 | def copystat(src, dst): |
Thomas Wouters | cf297e4 | 2007-02-23 15:07:44 +0000 | [diff] [blame] | 83 | """Copy all stat info (mode bits, atime, mtime, flags) from src to dst""" |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 84 | st = os.stat(src) |
Walter Dörwald | 294bbf3 | 2002-06-06 09:48:13 +0000 | [diff] [blame] | 85 | mode = stat.S_IMODE(st.st_mode) |
Tim Peters | 0c94724 | 2001-01-21 20:00:00 +0000 | [diff] [blame] | 86 | if hasattr(os, 'utime'): |
Walter Dörwald | 294bbf3 | 2002-06-06 09:48:13 +0000 | [diff] [blame] | 87 | os.utime(dst, (st.st_atime, st.st_mtime)) |
Tim Peters | 0c94724 | 2001-01-21 20:00:00 +0000 | [diff] [blame] | 88 | if hasattr(os, 'chmod'): |
| 89 | os.chmod(dst, mode) |
Thomas Wouters | cf297e4 | 2007-02-23 15:07:44 +0000 | [diff] [blame] | 90 | if hasattr(os, 'chflags') and hasattr(st, 'st_flags'): |
| 91 | os.chflags(dst, st.st_flags) |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 92 | |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 93 | |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 94 | def copy(src, dst): |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 95 | """Copy data and mode bits ("cp src dst"). |
Tim Peters | 495ad3c | 2001-01-15 01:36:40 +0000 | [diff] [blame] | 96 | |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 97 | The destination may be a directory. |
| 98 | |
| 99 | """ |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 100 | if os.path.isdir(dst): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 101 | dst = os.path.join(dst, os.path.basename(src)) |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 102 | copyfile(src, dst) |
| 103 | copymode(src, dst) |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 104 | |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 105 | def copy2(src, dst): |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 106 | """Copy data and all stat info ("cp -p src dst"). |
| 107 | |
| 108 | The destination may be a directory. |
| 109 | |
| 110 | """ |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 111 | if os.path.isdir(dst): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 112 | dst = os.path.join(dst, os.path.basename(src)) |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 113 | copyfile(src, dst) |
| 114 | copystat(src, dst) |
Guido van Rossum | c636014 | 1990-10-13 19:23:40 +0000 | [diff] [blame] | 115 | |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 116 | def ignore_patterns(*patterns): |
| 117 | """Function that can be used as copytree() ignore parameter. |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 118 | |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 119 | Patterns is a sequence of glob-style patterns |
| 120 | that are used to exclude files""" |
| 121 | def _ignore_patterns(path, names): |
| 122 | ignored_names = [] |
| 123 | for pattern in patterns: |
| 124 | ignored_names.extend(fnmatch.filter(names, pattern)) |
| 125 | return set(ignored_names) |
| 126 | return _ignore_patterns |
| 127 | |
| 128 | def copytree(src, dst, symlinks=False, ignore=None): |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 129 | """Recursively copy a directory tree using copy2(). |
| 130 | |
| 131 | The destination directory must not already exist. |
Neal Norwitz | a4c93b6 | 2003-02-23 21:36:32 +0000 | [diff] [blame] | 132 | If exception(s) occur, an Error is raised with a list of reasons. |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 133 | |
| 134 | If the optional symlinks flag is true, symbolic links in the |
| 135 | source tree result in symbolic links in the destination tree; if |
| 136 | it is false, the contents of the files pointed to by symbolic |
| 137 | links are copied. |
| 138 | |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 139 | The optional ignore argument is a callable. If given, it |
| 140 | is called with the `src` parameter, which is the directory |
| 141 | being visited by copytree(), and `names` which is the list of |
| 142 | `src` contents, as returned by os.listdir(): |
| 143 | |
| 144 | callable(src, names) -> ignored_names |
| 145 | |
| 146 | Since copytree() is called recursively, the callable will be |
| 147 | called once for each directory that is copied. It returns a |
| 148 | list of names relative to the `src` directory that should |
| 149 | not be copied. |
| 150 | |
Guido van Rossum | 9d0a3df | 1997-04-29 14:45:19 +0000 | [diff] [blame] | 151 | XXX Consider this example code rather than the ultimate tool. |
| 152 | |
| 153 | """ |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 154 | names = os.listdir(src) |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 155 | if ignore is not None: |
| 156 | ignored_names = ignore(src, names) |
| 157 | else: |
| 158 | ignored_names = set() |
| 159 | |
Johannes Gijsbers | e4172ea | 2005-01-08 12:31:29 +0000 | [diff] [blame] | 160 | os.makedirs(dst) |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 161 | errors = [] |
Guido van Rossum | a2baf46 | 1997-04-29 14:06:46 +0000 | [diff] [blame] | 162 | for name in names: |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 163 | if name in ignored_names: |
| 164 | continue |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 165 | srcname = os.path.join(src, name) |
| 166 | dstname = os.path.join(dst, name) |
| 167 | try: |
| 168 | if symlinks and os.path.islink(srcname): |
| 169 | linkto = os.readlink(srcname) |
| 170 | os.symlink(linkto, dstname) |
| 171 | elif os.path.isdir(srcname): |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 172 | copytree(srcname, dstname, symlinks, ignore) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 173 | else: |
Antoine Pitrou | 7fff096 | 2009-05-01 21:09:44 +0000 | [diff] [blame] | 174 | # Will raise a SpecialFileError for unsupported file types |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 175 | copy2(srcname, dstname) |
Georg Brandl | a1be88e | 2005-08-31 22:48:45 +0000 | [diff] [blame] | 176 | # catch the Error from the recursive copytree so that we can |
| 177 | # continue with other files |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 178 | except Error as err: |
Georg Brandl | a1be88e | 2005-08-31 22:48:45 +0000 | [diff] [blame] | 179 | errors.extend(err.args[0]) |
Antoine Pitrou | 7fff096 | 2009-05-01 21:09:44 +0000 | [diff] [blame] | 180 | except EnvironmentError as why: |
| 181 | errors.append((srcname, dstname, str(why))) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 182 | try: |
| 183 | copystat(src, dst) |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 184 | except OSError as why: |
Georg Brandl | 6aa2d1f | 2008-08-12 08:35:52 +0000 | [diff] [blame] | 185 | if WindowsError is not None and isinstance(why, WindowsError): |
| 186 | # Copying file access times may fail on Windows |
| 187 | pass |
| 188 | else: |
| 189 | errors.extend((src, dst, str(why))) |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 190 | if errors: |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 191 | raise Error(errors) |
Guido van Rossum | d767329 | 1998-02-06 21:38:09 +0000 | [diff] [blame] | 192 | |
Barry Warsaw | 234d9a9 | 2003-01-24 17:36:15 +0000 | [diff] [blame] | 193 | def rmtree(path, ignore_errors=False, onerror=None): |
Guido van Rossum | d767329 | 1998-02-06 21:38:09 +0000 | [diff] [blame] | 194 | """Recursively delete a directory tree. |
| 195 | |
Johannes Gijsbers | ef5ffc4 | 2004-10-31 12:05:31 +0000 | [diff] [blame] | 196 | If ignore_errors is set, errors are ignored; otherwise, if onerror |
| 197 | is set, it is called to handle the error with arguments (func, |
| 198 | path, exc_info) where func is os.listdir, os.remove, or os.rmdir; |
| 199 | path is the argument to that function that caused it to fail; and |
| 200 | exc_info is a tuple returned by sys.exc_info(). If ignore_errors |
| 201 | is false and onerror is None, an exception is raised. |
| 202 | |
Guido van Rossum | d767329 | 1998-02-06 21:38:09 +0000 | [diff] [blame] | 203 | """ |
Johannes Gijsbers | ef5ffc4 | 2004-10-31 12:05:31 +0000 | [diff] [blame] | 204 | if ignore_errors: |
| 205 | def onerror(*args): |
Barry Warsaw | 234d9a9 | 2003-01-24 17:36:15 +0000 | [diff] [blame] | 206 | pass |
Johannes Gijsbers | ef5ffc4 | 2004-10-31 12:05:31 +0000 | [diff] [blame] | 207 | elif onerror is None: |
| 208 | def onerror(*args): |
| 209 | raise |
Christian Heimes | 9bd667a | 2008-01-20 15:14:11 +0000 | [diff] [blame] | 210 | try: |
| 211 | if os.path.islink(path): |
| 212 | # symlinks to directories are forbidden, see bug #1669 |
| 213 | raise OSError("Cannot call rmtree on a symbolic link") |
| 214 | except OSError: |
| 215 | onerror(os.path.islink, path, sys.exc_info()) |
| 216 | # can't continue even if onerror hook returns |
| 217 | return |
Johannes Gijsbers | ef5ffc4 | 2004-10-31 12:05:31 +0000 | [diff] [blame] | 218 | names = [] |
| 219 | try: |
| 220 | names = os.listdir(path) |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 221 | except os.error as err: |
Johannes Gijsbers | ef5ffc4 | 2004-10-31 12:05:31 +0000 | [diff] [blame] | 222 | onerror(os.listdir, path, sys.exc_info()) |
| 223 | for name in names: |
| 224 | fullname = os.path.join(path, name) |
| 225 | try: |
| 226 | mode = os.lstat(fullname).st_mode |
| 227 | except os.error: |
| 228 | mode = 0 |
| 229 | if stat.S_ISDIR(mode): |
| 230 | rmtree(fullname, ignore_errors, onerror) |
Barry Warsaw | 234d9a9 | 2003-01-24 17:36:15 +0000 | [diff] [blame] | 231 | else: |
Johannes Gijsbers | ef5ffc4 | 2004-10-31 12:05:31 +0000 | [diff] [blame] | 232 | try: |
| 233 | os.remove(fullname) |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 234 | except os.error as err: |
Johannes Gijsbers | ef5ffc4 | 2004-10-31 12:05:31 +0000 | [diff] [blame] | 235 | onerror(os.remove, fullname, sys.exc_info()) |
| 236 | try: |
| 237 | os.rmdir(path) |
| 238 | except os.error: |
| 239 | onerror(os.rmdir, path, sys.exc_info()) |
Guido van Rossum | d767329 | 1998-02-06 21:38:09 +0000 | [diff] [blame] | 240 | |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 241 | |
Christian Heimes | ada8c3b | 2008-03-18 18:26:33 +0000 | [diff] [blame] | 242 | def _basename(path): |
| 243 | # A basename() variant which first strips the trailing slash, if present. |
| 244 | # Thus we always get the last component of the path, even for directories. |
| 245 | return os.path.basename(path.rstrip(os.path.sep)) |
| 246 | |
| 247 | def move(src, dst): |
| 248 | """Recursively move a file or directory to another location. This is |
| 249 | similar to the Unix "mv" command. |
| 250 | |
| 251 | If the destination is a directory or a symlink to a directory, the source |
| 252 | is moved inside the directory. The destination path must not already |
| 253 | exist. |
| 254 | |
| 255 | If the destination already exists but is not a directory, it may be |
| 256 | overwritten depending on os.rename() semantics. |
| 257 | |
| 258 | If the destination is on our current filesystem, then rename() is used. |
| 259 | Otherwise, src is copied to the destination and then removed. |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 260 | A lot more could be done here... A look at a mv.c shows a lot of |
| 261 | the issues this implementation glosses over. |
| 262 | |
| 263 | """ |
Christian Heimes | ada8c3b | 2008-03-18 18:26:33 +0000 | [diff] [blame] | 264 | real_dst = dst |
| 265 | if os.path.isdir(dst): |
| 266 | real_dst = os.path.join(dst, _basename(src)) |
| 267 | if os.path.exists(real_dst): |
| 268 | raise Error("Destination path '%s' already exists" % real_dst) |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 269 | try: |
Christian Heimes | ada8c3b | 2008-03-18 18:26:33 +0000 | [diff] [blame] | 270 | os.rename(src, real_dst) |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 271 | except OSError: |
| 272 | if os.path.isdir(src): |
Benjamin Peterson | 247a9b8 | 2009-02-20 04:09:19 +0000 | [diff] [blame] | 273 | if _destinsrc(src, dst): |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 274 | raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst)) |
Christian Heimes | ada8c3b | 2008-03-18 18:26:33 +0000 | [diff] [blame] | 275 | copytree(src, real_dst, symlinks=True) |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 276 | rmtree(src) |
| 277 | else: |
Christian Heimes | ada8c3b | 2008-03-18 18:26:33 +0000 | [diff] [blame] | 278 | copy2(src, real_dst) |
Martin v. Löwis | e9ce0b0 | 2002-10-07 13:23:24 +0000 | [diff] [blame] | 279 | os.unlink(src) |
Brett Cannon | 1c3fa18 | 2004-06-19 21:11:35 +0000 | [diff] [blame] | 280 | |
Benjamin Peterson | 247a9b8 | 2009-02-20 04:09:19 +0000 | [diff] [blame] | 281 | def _destinsrc(src, dst): |
Antoine Pitrou | 0dcc3cd | 2009-01-29 20:26:59 +0000 | [diff] [blame] | 282 | src = abspath(src) |
| 283 | dst = abspath(dst) |
| 284 | if not src.endswith(os.path.sep): |
| 285 | src += os.path.sep |
| 286 | if not dst.endswith(os.path.sep): |
| 287 | dst += os.path.sep |
| 288 | return dst.startswith(src) |