Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 1 | """Utilities for comparing files and directories. |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 2 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 3 | Classes: |
| 4 | dircmp |
| 5 | |
| 6 | Functions: |
Georg Brandl | 55689c9 | 2009-05-17 12:19:44 +0000 | [diff] [blame] | 7 | cmp(f1, f2, shallow=True) -> int |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 8 | cmpfiles(a, b, common) -> ([], [], []) |
Ned Deily | 7bff3cb | 2013-06-14 15:19:11 -0700 | [diff] [blame] | 9 | clear_cache() |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 10 | |
| 11 | """ |
| 12 | |
| 13 | import os |
| 14 | import stat |
Raymond Hettinger | 736c0ab | 2008-03-13 02:09:15 +0000 | [diff] [blame] | 15 | from itertools import filterfalse |
Ethan Smith | e3ec44d | 2020-04-09 21:47:31 -0700 | [diff] [blame] | 16 | from types import GenericAlias |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 17 | |
Ned Deily | 7bff3cb | 2013-06-14 15:19:11 -0700 | [diff] [blame] | 18 | __all__ = ['clear_cache', 'cmp', 'dircmp', 'cmpfiles', 'DEFAULT_IGNORES'] |
Skip Montanaro | eccd02a | 2001-01-20 23:34:12 +0000 | [diff] [blame] | 19 | |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 20 | _cache = {} |
Georg Brandl | 55689c9 | 2009-05-17 12:19:44 +0000 | [diff] [blame] | 21 | BUFSIZE = 8*1024 |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 22 | |
Eli Bendersky | eb2884a | 2013-01-12 06:13:32 -0800 | [diff] [blame] | 23 | DEFAULT_IGNORES = [ |
| 24 | 'RCS', 'CVS', 'tags', '.git', '.hg', '.bzr', '_darcs', '__pycache__'] |
| 25 | |
Ned Deily | 7bff3cb | 2013-06-14 15:19:11 -0700 | [diff] [blame] | 26 | def clear_cache(): |
| 27 | """Clear the filecmp cache.""" |
| 28 | _cache.clear() |
Eli Bendersky | eb2884a | 2013-01-12 06:13:32 -0800 | [diff] [blame] | 29 | |
Georg Brandl | 55689c9 | 2009-05-17 12:19:44 +0000 | [diff] [blame] | 30 | def cmp(f1, f2, shallow=True): |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 31 | """Compare two files. |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 32 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 33 | Arguments: |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 34 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 35 | f1 -- First file name |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 36 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 37 | f2 -- Second file name |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 38 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 39 | shallow -- Just check stat signature (do not read the files). |
Benjamin Peterson | d4992dc | 2014-04-26 13:36:21 -0400 | [diff] [blame] | 40 | defaults to True. |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 41 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 42 | Return value: |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 43 | |
Tim Peters | bc0e910 | 2002-04-04 22:55:58 +0000 | [diff] [blame] | 44 | True if the files are the same, False otherwise. |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 45 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 46 | This function uses a cache for past comparisons and the results, |
R David Murray | 4885f49 | 2014-02-02 11:11:01 -0500 | [diff] [blame] | 47 | with cache entries invalidated if their stat information |
| 48 | changes. The cache may be cleared by calling clear_cache(). |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 49 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 50 | """ |
Andrew M. Kuchling | 83e879d | 2003-02-06 19:38:45 +0000 | [diff] [blame] | 51 | |
Andrew M. Kuchling | 8eb4044 | 2003-02-06 17:50:01 +0000 | [diff] [blame] | 52 | s1 = _sig(os.stat(f1)) |
| 53 | s2 = _sig(os.stat(f2)) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 54 | if s1[0] != stat.S_IFREG or s2[0] != stat.S_IFREG: |
Tim Peters | bc0e910 | 2002-04-04 22:55:58 +0000 | [diff] [blame] | 55 | return False |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 56 | if shallow and s1 == s2: |
Tim Peters | bc0e910 | 2002-04-04 22:55:58 +0000 | [diff] [blame] | 57 | return True |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 58 | if s1[1] != s2[1]: |
Tim Peters | bc0e910 | 2002-04-04 22:55:58 +0000 | [diff] [blame] | 59 | return False |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 60 | |
Raymond Hettinger | 7079719 | 2011-06-25 17:20:21 +0200 | [diff] [blame] | 61 | outcome = _cache.get((f1, f2, s1, s2)) |
| 62 | if outcome is None: |
| 63 | outcome = _do_cmp(f1, f2) |
| 64 | if len(_cache) > 100: # limit the maximum size of the cache |
Ned Deily | 7bff3cb | 2013-06-14 15:19:11 -0700 | [diff] [blame] | 65 | clear_cache() |
Raymond Hettinger | 7079719 | 2011-06-25 17:20:21 +0200 | [diff] [blame] | 66 | _cache[f1, f2, s1, s2] = outcome |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 67 | return outcome |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 68 | |
| 69 | def _sig(st): |
Raymond Hettinger | 32200ae | 2002-06-01 19:51:15 +0000 | [diff] [blame] | 70 | return (stat.S_IFMT(st.st_mode), |
| 71 | st.st_size, |
| 72 | st.st_mtime) |
Guido van Rossum | 2d72687 | 1999-10-26 14:02:01 +0000 | [diff] [blame] | 73 | |
| 74 | def _do_cmp(f1, f2): |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 75 | bufsize = BUFSIZE |
Raymond Hettinger | 686057b | 2009-06-04 00:11:54 +0000 | [diff] [blame] | 76 | with open(f1, 'rb') as fp1, open(f2, 'rb') as fp2: |
Benjamin Peterson | f07d002 | 2009-03-21 17:31:58 +0000 | [diff] [blame] | 77 | while True: |
| 78 | b1 = fp1.read(bufsize) |
| 79 | b2 = fp2.read(bufsize) |
| 80 | if b1 != b2: |
| 81 | return False |
| 82 | if not b1: |
| 83 | return True |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 84 | |
| 85 | # Directory comparison class. |
| 86 | # |
| 87 | class dircmp: |
| 88 | """A class that manages the comparison of 2 directories. |
| 89 | |
Georg Brandl | 55689c9 | 2009-05-17 12:19:44 +0000 | [diff] [blame] | 90 | dircmp(a, b, ignore=None, hide=None) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 91 | A and B are directories. |
| 92 | IGNORE is a list of names to ignore, |
Eli Bendersky | eb2884a | 2013-01-12 06:13:32 -0800 | [diff] [blame] | 93 | defaults to DEFAULT_IGNORES. |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 94 | HIDE is a list of names to hide, |
| 95 | defaults to [os.curdir, os.pardir]. |
| 96 | |
| 97 | High level usage: |
| 98 | x = dircmp(dir1, dir2) |
| 99 | x.report() -> prints a report on the differences between dir1 and dir2 |
| 100 | or |
| 101 | x.report_partial_closure() -> prints report on differences between dir1 |
| 102 | and dir2, and reports on common immediate subdirectories. |
| 103 | x.report_full_closure() -> like report_partial_closure, |
| 104 | but fully recursive. |
| 105 | |
| 106 | Attributes: |
| 107 | left_list, right_list: The files in dir1 and dir2, |
| 108 | filtered by hide and ignore. |
| 109 | common: a list of names in both dir1 and dir2. |
| 110 | left_only, right_only: names only in dir1, dir2. |
| 111 | common_dirs: subdirectories in both dir1 and dir2. |
| 112 | common_files: files in both dir1 and dir2. |
| 113 | common_funny: names in both dir1 and dir2 where the type differs between |
| 114 | dir1 and dir2, or the name is not stat-able. |
| 115 | same_files: list of identical files. |
| 116 | diff_files: list of filenames which differ. |
| 117 | funny_files: list of files which could not be compared. |
Nick Crews | 2f2f9d0 | 2020-11-23 09:29:37 -0700 | [diff] [blame] | 118 | subdirs: a dictionary of dircmp instances (or MyDirCmp instances if this |
| 119 | object is of type MyDirCmp, a subclass of dircmp), keyed by names |
| 120 | in common_dirs. |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 121 | """ |
| 122 | |
| 123 | def __init__(self, a, b, ignore=None, hide=None): # Initialize |
| 124 | self.left = a |
| 125 | self.right = b |
| 126 | if hide is None: |
| 127 | self.hide = [os.curdir, os.pardir] # Names never to be shown |
| 128 | else: |
| 129 | self.hide = hide |
| 130 | if ignore is None: |
Eli Bendersky | eb2884a | 2013-01-12 06:13:32 -0800 | [diff] [blame] | 131 | self.ignore = DEFAULT_IGNORES |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 132 | else: |
| 133 | self.ignore = ignore |
| 134 | |
| 135 | def phase0(self): # Compare everything except common subdirectories |
| 136 | self.left_list = _filter(os.listdir(self.left), |
| 137 | self.hide+self.ignore) |
| 138 | self.right_list = _filter(os.listdir(self.right), |
| 139 | self.hide+self.ignore) |
| 140 | self.left_list.sort() |
| 141 | self.right_list.sort() |
| 142 | |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 143 | def phase1(self): # Compute common names |
Raymond Hettinger | 736c0ab | 2008-03-13 02:09:15 +0000 | [diff] [blame] | 144 | a = dict(zip(map(os.path.normcase, self.left_list), self.left_list)) |
| 145 | b = dict(zip(map(os.path.normcase, self.right_list), self.right_list)) |
Raymond Hettinger | 17301e9 | 2008-03-13 00:19:26 +0000 | [diff] [blame] | 146 | self.common = list(map(a.__getitem__, filter(b.__contains__, a))) |
Raymond Hettinger | b0002d2 | 2008-03-13 01:41:43 +0000 | [diff] [blame] | 147 | self.left_only = list(map(a.__getitem__, filterfalse(b.__contains__, a))) |
| 148 | self.right_only = list(map(b.__getitem__, filterfalse(a.__contains__, b))) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 149 | |
| 150 | def phase2(self): # Distinguish files, directories, funnies |
| 151 | self.common_dirs = [] |
| 152 | self.common_files = [] |
| 153 | self.common_funny = [] |
| 154 | |
| 155 | for x in self.common: |
| 156 | a_path = os.path.join(self.left, x) |
| 157 | b_path = os.path.join(self.right, x) |
| 158 | |
| 159 | ok = 1 |
| 160 | try: |
Andrew M. Kuchling | 8eb4044 | 2003-02-06 17:50:01 +0000 | [diff] [blame] | 161 | a_stat = os.stat(a_path) |
Pablo Galindo | 293dd23 | 2019-11-19 21:34:03 +0000 | [diff] [blame] | 162 | except OSError: |
Georg Brandl | d11b68a | 2008-01-06 21:13:42 +0000 | [diff] [blame] | 163 | # print('Can\'t stat', a_path, ':', why.args[1]) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 164 | ok = 0 |
| 165 | try: |
Andrew M. Kuchling | 8eb4044 | 2003-02-06 17:50:01 +0000 | [diff] [blame] | 166 | b_stat = os.stat(b_path) |
Pablo Galindo | 293dd23 | 2019-11-19 21:34:03 +0000 | [diff] [blame] | 167 | except OSError: |
Georg Brandl | d11b68a | 2008-01-06 21:13:42 +0000 | [diff] [blame] | 168 | # print('Can\'t stat', b_path, ':', why.args[1]) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 169 | ok = 0 |
| 170 | |
| 171 | if ok: |
Raymond Hettinger | 32200ae | 2002-06-01 19:51:15 +0000 | [diff] [blame] | 172 | a_type = stat.S_IFMT(a_stat.st_mode) |
| 173 | b_type = stat.S_IFMT(b_stat.st_mode) |
Fred Drake | 8152d32 | 2000-12-12 23:20:45 +0000 | [diff] [blame] | 174 | if a_type != b_type: |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 175 | self.common_funny.append(x) |
| 176 | elif stat.S_ISDIR(a_type): |
| 177 | self.common_dirs.append(x) |
| 178 | elif stat.S_ISREG(a_type): |
| 179 | self.common_files.append(x) |
| 180 | else: |
| 181 | self.common_funny.append(x) |
| 182 | else: |
| 183 | self.common_funny.append(x) |
| 184 | |
| 185 | def phase3(self): # Find out differences between common files |
| 186 | xx = cmpfiles(self.left, self.right, self.common_files) |
| 187 | self.same_files, self.diff_files, self.funny_files = xx |
| 188 | |
| 189 | def phase4(self): # Find out differences between common subdirectories |
Nick Crews | 2f2f9d0 | 2020-11-23 09:29:37 -0700 | [diff] [blame] | 190 | # A new dircmp (or MyDirCmp if dircmp was subclassed) object is created |
| 191 | # for each common subdirectory, |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 192 | # these are stored in a dictionary indexed by filename. |
| 193 | # The hide and ignore properties are inherited from the parent |
| 194 | self.subdirs = {} |
| 195 | for x in self.common_dirs: |
| 196 | a_x = os.path.join(self.left, x) |
| 197 | b_x = os.path.join(self.right, x) |
Nick Crews | 2f2f9d0 | 2020-11-23 09:29:37 -0700 | [diff] [blame] | 198 | self.subdirs[x] = self.__class__(a_x, b_x, self.ignore, self.hide) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 199 | |
| 200 | def phase4_closure(self): # Recursively call phase4() on subdirectories |
| 201 | self.phase4() |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 202 | for sd in self.subdirs.values(): |
Raymond Hettinger | e0d4972 | 2002-06-02 18:55:56 +0000 | [diff] [blame] | 203 | sd.phase4_closure() |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 204 | |
| 205 | def report(self): # Print a report on the differences between a and b |
| 206 | # Output format is purposely lousy |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 207 | print('diff', self.left, self.right) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 208 | if self.left_only: |
| 209 | self.left_only.sort() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 210 | print('Only in', self.left, ':', self.left_only) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 211 | if self.right_only: |
| 212 | self.right_only.sort() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 213 | print('Only in', self.right, ':', self.right_only) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 214 | if self.same_files: |
| 215 | self.same_files.sort() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 216 | print('Identical files :', self.same_files) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 217 | if self.diff_files: |
| 218 | self.diff_files.sort() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 219 | print('Differing files :', self.diff_files) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 220 | if self.funny_files: |
| 221 | self.funny_files.sort() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 222 | print('Trouble with common files :', self.funny_files) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 223 | if self.common_dirs: |
| 224 | self.common_dirs.sort() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 225 | print('Common subdirectories :', self.common_dirs) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 226 | if self.common_funny: |
| 227 | self.common_funny.sort() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 228 | print('Common funny cases :', self.common_funny) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 229 | |
| 230 | def report_partial_closure(self): # Print reports on self and on subdirs |
| 231 | self.report() |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 232 | for sd in self.subdirs.values(): |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 233 | print() |
Raymond Hettinger | e0d4972 | 2002-06-02 18:55:56 +0000 | [diff] [blame] | 234 | sd.report() |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 235 | |
| 236 | def report_full_closure(self): # Report on self and subdirs recursively |
| 237 | self.report() |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 238 | for sd in self.subdirs.values(): |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 239 | print() |
Raymond Hettinger | e0d4972 | 2002-06-02 18:55:56 +0000 | [diff] [blame] | 240 | sd.report_full_closure() |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 241 | |
Raymond Hettinger | 05595e9 | 2003-02-27 00:05:31 +0000 | [diff] [blame] | 242 | methodmap = dict(subdirs=phase4, |
| 243 | same_files=phase3, diff_files=phase3, funny_files=phase3, |
| 244 | common_dirs = phase2, common_files=phase2, common_funny=phase2, |
| 245 | common=phase1, left_only=phase1, right_only=phase1, |
| 246 | left_list=phase0, right_list=phase0) |
| 247 | |
| 248 | def __getattr__(self, attr): |
| 249 | if attr not in self.methodmap: |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 250 | raise AttributeError(attr) |
Raymond Hettinger | 05595e9 | 2003-02-27 00:05:31 +0000 | [diff] [blame] | 251 | self.methodmap[attr](self) |
| 252 | return getattr(self, attr) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 253 | |
Ethan Smith | e3ec44d | 2020-04-09 21:47:31 -0700 | [diff] [blame] | 254 | __class_getitem__ = classmethod(GenericAlias) |
| 255 | |
| 256 | |
Georg Brandl | 55689c9 | 2009-05-17 12:19:44 +0000 | [diff] [blame] | 257 | def cmpfiles(a, b, common, shallow=True): |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 258 | """Compare common files in two directories. |
| 259 | |
Fred Drake | 2b0d98b | 2000-07-03 08:18:47 +0000 | [diff] [blame] | 260 | a, b -- directory names |
| 261 | common -- list of file names found in both directories |
| 262 | shallow -- if true, do comparison based solely on stat() information |
Fred Drake | 2b0d98b | 2000-07-03 08:18:47 +0000 | [diff] [blame] | 263 | |
| 264 | Returns a tuple of three lists: |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 265 | files that compare equal |
| 266 | files that are different |
Fred Drake | 2b0d98b | 2000-07-03 08:18:47 +0000 | [diff] [blame] | 267 | filenames that aren't regular files. |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 268 | |
Fred Drake | 2b0d98b | 2000-07-03 08:18:47 +0000 | [diff] [blame] | 269 | """ |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 270 | res = ([], [], []) |
| 271 | for x in common: |
Fred Drake | 2b0d98b | 2000-07-03 08:18:47 +0000 | [diff] [blame] | 272 | ax = os.path.join(a, x) |
| 273 | bx = os.path.join(b, x) |
Andrew M. Kuchling | 8eb4044 | 2003-02-06 17:50:01 +0000 | [diff] [blame] | 274 | res[_cmp(ax, bx, shallow)].append(x) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 275 | return res |
| 276 | |
| 277 | |
| 278 | # Compare two files. |
| 279 | # Return: |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 280 | # 0 for equal |
| 281 | # 1 for different |
| 282 | # 2 for funny cases (can't stat, etc.) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 283 | # |
Raymond Hettinger | 05595e9 | 2003-02-27 00:05:31 +0000 | [diff] [blame] | 284 | def _cmp(a, b, sh, abs=abs, cmp=cmp): |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 285 | try: |
Andrew M. Kuchling | 8eb4044 | 2003-02-06 17:50:01 +0000 | [diff] [blame] | 286 | return not abs(cmp(a, b, sh)) |
Andrew Svetlov | 22f36ee | 2012-12-14 18:02:27 +0200 | [diff] [blame] | 287 | except OSError: |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 288 | return 2 |
| 289 | |
| 290 | |
| 291 | # Return a copy with items that occur in skip removed. |
| 292 | # |
Raymond Hettinger | 05595e9 | 2003-02-27 00:05:31 +0000 | [diff] [blame] | 293 | def _filter(flist, skip): |
Raymond Hettinger | b0002d2 | 2008-03-13 01:41:43 +0000 | [diff] [blame] | 294 | return list(filterfalse(skip.__contains__, flist)) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 295 | |
| 296 | |
| 297 | # Demonstration and testing. |
| 298 | # |
| 299 | def demo(): |
| 300 | import sys |
| 301 | import getopt |
| 302 | options, args = getopt.getopt(sys.argv[1:], 'r') |
Fred Drake | 8152d32 | 2000-12-12 23:20:45 +0000 | [diff] [blame] | 303 | if len(args) != 2: |
Andrew M. Kuchling | 83e879d | 2003-02-06 19:38:45 +0000 | [diff] [blame] | 304 | raise getopt.GetoptError('need exactly two args', None) |
Guido van Rossum | 63b08ac | 2000-06-29 14:13:28 +0000 | [diff] [blame] | 305 | dd = dircmp(args[0], args[1]) |
| 306 | if ('-r', '') in options: |
| 307 | dd.report_full_closure() |
| 308 | else: |
| 309 | dd.report() |
| 310 | |
| 311 | if __name__ == '__main__': |
| 312 | demo() |