home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / filecmp.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  9.6 KB  |  328 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Utilities for comparing files and directories.
  5.  
  6. Classes:
  7.     dircmp
  8.  
  9. Functions:
  10.     cmp(f1, f2, shallow=1) -> int
  11.     cmpfiles(a, b, common) -> ([], [], [])
  12.  
  13. '''
  14. import os
  15. import stat
  16. import warnings
  17. from itertools import ifilter, ifilterfalse, imap, izip
  18. __all__ = [
  19.     'cmp',
  20.     'dircmp',
  21.     'cmpfiles']
  22. _cache = { }
  23. BUFSIZE = 8 * 1024
  24.  
  25. def cmp(f1, f2, shallow = 1, use_statcache = None):
  26.     '''Compare two files.
  27.  
  28.     Arguments:
  29.  
  30.     f1 -- First file name
  31.  
  32.     f2 -- Second file name
  33.  
  34.     shallow -- Just check stat signature (do not read the files).
  35.                defaults to 1.
  36.  
  37.     use_statcache -- obsolete argument.
  38.  
  39.     Return value:
  40.  
  41.     True if the files are the same, False otherwise.
  42.  
  43.     This function uses a cache for past comparisons and the results,
  44.     with a cache invalidation mechanism relying on stale signatures.
  45.  
  46.     '''
  47.     if use_statcache is not None:
  48.         warnings.warn('use_statcache argument is deprecated', DeprecationWarning)
  49.     
  50.     s1 = _sig(os.stat(f1))
  51.     s2 = _sig(os.stat(f2))
  52.     if s1[0] != stat.S_IFREG or s2[0] != stat.S_IFREG:
  53.         return False
  54.     
  55.     if shallow and s1 == s2:
  56.         return True
  57.     
  58.     if s1[1] != s2[1]:
  59.         return False
  60.     
  61.     result = _cache.get((f1, f2))
  62.     if result and (s1, s2) == result[:2]:
  63.         return result[2]
  64.     
  65.     outcome = _do_cmp(f1, f2)
  66.     _cache[(f1, f2)] = (s1, s2, outcome)
  67.     return outcome
  68.  
  69.  
  70. def _sig(st):
  71.     return (stat.S_IFMT(st.st_mode), st.st_size, st.st_mtime)
  72.  
  73.  
  74. def _do_cmp(f1, f2):
  75.     bufsize = BUFSIZE
  76.     fp1 = open(f1, 'rb')
  77.     fp2 = open(f2, 'rb')
  78.     while True:
  79.         b1 = fp1.read(bufsize)
  80.         b2 = fp2.read(bufsize)
  81.         if b1 != b2:
  82.             return False
  83.         
  84.         if not b1:
  85.             return True
  86.             continue
  87.  
  88.  
  89. class dircmp:
  90.     """A class that manages the comparison of 2 directories.
  91.  
  92.     dircmp(a,b,ignore=None,hide=None)
  93.       A and B are directories.
  94.       IGNORE is a list of names to ignore,
  95.         defaults to ['RCS', 'CVS', 'tags'].
  96.       HIDE is a list of names to hide,
  97.         defaults to [os.curdir, os.pardir].
  98.  
  99.     High level usage:
  100.       x = dircmp(dir1, dir2)
  101.       x.report() -> prints a report on the differences between dir1 and dir2
  102.        or
  103.       x.report_partial_closure() -> prints report on differences between dir1
  104.             and dir2, and reports on common immediate subdirectories.
  105.       x.report_full_closure() -> like report_partial_closure,
  106.             but fully recursive.
  107.  
  108.     Attributes:
  109.      left_list, right_list: The files in dir1 and dir2,
  110.         filtered by hide and ignore.
  111.      common: a list of names in both dir1 and dir2.
  112.      left_only, right_only: names only in dir1, dir2.
  113.      common_dirs: subdirectories in both dir1 and dir2.
  114.      common_files: files in both dir1 and dir2.
  115.      common_funny: names in both dir1 and dir2 where the type differs between
  116.         dir1 and dir2, or the name is not stat-able.
  117.      same_files: list of identical files.
  118.      diff_files: list of filenames which differ.
  119.      funny_files: list of files which could not be compared.
  120.      subdirs: a dictionary of dircmp objects, keyed by names in common_dirs.
  121.      """
  122.     
  123.     def __init__(self, a, b, ignore = None, hide = None):
  124.         self.left = a
  125.         self.right = b
  126.         if hide is None:
  127.             self.hide = [
  128.                 os.curdir,
  129.                 os.pardir]
  130.         else:
  131.             self.hide = hide
  132.         if ignore is None:
  133.             self.ignore = [
  134.                 'RCS',
  135.                 'CVS',
  136.                 'tags']
  137.         else:
  138.             self.ignore = ignore
  139.  
  140.     
  141.     def phase0(self):
  142.         self.left_list = _filter(os.listdir(self.left), self.hide + self.ignore)
  143.         self.right_list = _filter(os.listdir(self.right), self.hide + self.ignore)
  144.         self.left_list.sort()
  145.         self.right_list.sort()
  146.  
  147.     
  148.     def phase1(self):
  149.         a = dict(izip(imap(os.path.normcase, self.left_list), self.left_list))
  150.         b = dict(izip(imap(os.path.normcase, self.right_list), self.right_list))
  151.         self.common = map(a.__getitem__, ifilter(b.has_key, a))
  152.         self.left_only = map(a.__getitem__, ifilterfalse(b.has_key, a))
  153.         self.right_only = map(b.__getitem__, ifilterfalse(a.has_key, b))
  154.  
  155.     
  156.     def phase2(self):
  157.         self.common_dirs = []
  158.         self.common_files = []
  159.         self.common_funny = []
  160.         for x in self.common:
  161.             a_path = os.path.join(self.left, x)
  162.             b_path = os.path.join(self.right, x)
  163.             ok = 1
  164.             
  165.             try:
  166.                 a_stat = os.stat(a_path)
  167.             except os.error:
  168.                 why = None
  169.                 ok = 0
  170.  
  171.             
  172.             try:
  173.                 b_stat = os.stat(b_path)
  174.             except os.error:
  175.                 why = None
  176.                 ok = 0
  177.  
  178.             if ok:
  179.                 a_type = stat.S_IFMT(a_stat.st_mode)
  180.                 b_type = stat.S_IFMT(b_stat.st_mode)
  181.                 if a_type != b_type:
  182.                     self.common_funny.append(x)
  183.                 elif stat.S_ISDIR(a_type):
  184.                     self.common_dirs.append(x)
  185.                 elif stat.S_ISREG(a_type):
  186.                     self.common_files.append(x)
  187.                 else:
  188.                     self.common_funny.append(x)
  189.             a_type != b_type
  190.             self.common_funny.append(x)
  191.         
  192.  
  193.     
  194.     def phase3(self):
  195.         xx = cmpfiles(self.left, self.right, self.common_files)
  196.         (self.same_files, self.diff_files, self.funny_files) = xx
  197.  
  198.     
  199.     def phase4(self):
  200.         self.subdirs = { }
  201.         for x in self.common_dirs:
  202.             a_x = os.path.join(self.left, x)
  203.             b_x = os.path.join(self.right, x)
  204.             self.subdirs[x] = dircmp(a_x, b_x, self.ignore, self.hide)
  205.         
  206.  
  207.     
  208.     def phase4_closure(self):
  209.         self.phase4()
  210.         for sd in self.subdirs.itervalues():
  211.             sd.phase4_closure()
  212.         
  213.  
  214.     
  215.     def report(self):
  216.         print 'diff', self.left, self.right
  217.         if self.left_only:
  218.             self.left_only.sort()
  219.             print 'Only in', self.left, ':', self.left_only
  220.         
  221.         if self.right_only:
  222.             self.right_only.sort()
  223.             print 'Only in', self.right, ':', self.right_only
  224.         
  225.         if self.same_files:
  226.             self.same_files.sort()
  227.             print 'Identical files :', self.same_files
  228.         
  229.         if self.diff_files:
  230.             self.diff_files.sort()
  231.             print 'Differing files :', self.diff_files
  232.         
  233.         if self.funny_files:
  234.             self.funny_files.sort()
  235.             print 'Trouble with common files :', self.funny_files
  236.         
  237.         if self.common_dirs:
  238.             self.common_dirs.sort()
  239.             print 'Common subdirectories :', self.common_dirs
  240.         
  241.         if self.common_funny:
  242.             self.common_funny.sort()
  243.             print 'Common funny cases :', self.common_funny
  244.         
  245.  
  246.     
  247.     def report_partial_closure(self):
  248.         self.report()
  249.         for sd in self.subdirs.itervalues():
  250.             print 
  251.             sd.report()
  252.         
  253.  
  254.     
  255.     def report_full_closure(self):
  256.         self.report()
  257.         for sd in self.subdirs.itervalues():
  258.             print 
  259.             sd.report_full_closure()
  260.         
  261.  
  262.     methodmap = dict(subdirs = phase4, same_files = phase3, diff_files = phase3, funny_files = phase3, common_dirs = phase2, common_files = phase2, common_funny = phase2, common = phase1, left_only = phase1, right_only = phase1, left_list = phase0, right_list = phase0)
  263.     
  264.     def __getattr__(self, attr):
  265.         if attr not in self.methodmap:
  266.             raise AttributeError, attr
  267.         
  268.         self.methodmap[attr](self)
  269.         return getattr(self, attr)
  270.  
  271.  
  272.  
  273. def cmpfiles(a, b, common, shallow = 1, use_statcache = None):
  274.     """Compare common files in two directories.
  275.  
  276.     a, b -- directory names
  277.     common -- list of file names found in both directories
  278.     shallow -- if true, do comparison based solely on stat() information
  279.     use_statcache -- obsolete argument
  280.  
  281.     Returns a tuple of three lists:
  282.       files that compare equal
  283.       files that are different
  284.       filenames that aren't regular files.
  285.  
  286.     """
  287.     if use_statcache is not None:
  288.         warnings.warn('use_statcache argument is deprecated', DeprecationWarning)
  289.     
  290.     res = ([], [], [])
  291.     for x in common:
  292.         ax = os.path.join(a, x)
  293.         bx = os.path.join(b, x)
  294.         res[_cmp(ax, bx, shallow)].append(x)
  295.     
  296.     return res
  297.  
  298.  
  299. def _cmp(a, b, sh, abs = abs, cmp = cmp):
  300.     
  301.     try:
  302.         return not abs(cmp(a, b, sh))
  303.     except os.error:
  304.         return 2
  305.  
  306.  
  307.  
  308. def _filter(flist, skip):
  309.     return list(ifilterfalse(skip.__contains__, flist))
  310.  
  311.  
  312. def demo():
  313.     import sys
  314.     import getopt
  315.     (options, args) = getopt.getopt(sys.argv[1:], 'r')
  316.     if len(args) != 2:
  317.         raise getopt.GetoptError('need exactly two args', None)
  318.     
  319.     dd = dircmp(args[0], args[1])
  320.     if ('-r', '') in options:
  321.         dd.report_full_closure()
  322.     else:
  323.         dd.report()
  324.  
  325. if __name__ == '__main__':
  326.     demo()
  327.  
  328.