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