home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_699 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  6.1 KB  |  280 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import sys
  6. import stat
  7. from os.path import abspath
  8. import fnmatch
  9. __all__ = [
  10.     'copyfileobj',
  11.     'copyfile',
  12.     'copymode',
  13.     'copystat',
  14.     'copy',
  15.     'copy2',
  16.     'copytree',
  17.     'move',
  18.     'rmtree',
  19.     'Error']
  20.  
  21. class Error(EnvironmentError):
  22.     pass
  23.  
  24.  
  25. try:
  26.     WindowsError
  27. except NameError:
  28.     WindowsError = None
  29.  
  30.  
  31. def copyfileobj(fsrc, fdst, length = 16384):
  32.     while None:
  33.         buf = fsrc.read(length)
  34.         if not buf:
  35.             break
  36.         
  37.         continue
  38.         return None
  39.  
  40.  
  41. def _samefile(src, dst):
  42.     if hasattr(os.path, 'samefile'):
  43.         
  44.         try:
  45.             return os.path.samefile(src, dst)
  46.         except OSError:
  47.             return False
  48.         
  49.  
  50.     None<EXCEPTION MATCH>OSError
  51.     return os.path.normcase(os.path.abspath(src)) == os.path.normcase(os.path.abspath(dst))
  52.  
  53.  
  54. def copyfile(src, dst):
  55.     if _samefile(src, dst):
  56.         raise Error, '`%s` and `%s` are the same file' % (src, dst)
  57.     _samefile(src, dst)
  58.     fsrc = None
  59.     fdst = None
  60.     
  61.     try:
  62.         fsrc = open(src, 'rb')
  63.         fdst = open(dst, 'wb')
  64.         copyfileobj(fsrc, fdst)
  65.     finally:
  66.         if fdst:
  67.             fdst.close()
  68.         
  69.         if fsrc:
  70.             fsrc.close()
  71.         
  72.  
  73.  
  74.  
  75. def copymode(src, dst):
  76.     if hasattr(os, 'chmod'):
  77.         st = os.stat(src)
  78.         mode = stat.S_IMODE(st.st_mode)
  79.         os.chmod(dst, mode)
  80.     
  81.  
  82.  
  83. def copystat(src, dst):
  84.     st = os.stat(src)
  85.     mode = stat.S_IMODE(st.st_mode)
  86.     if hasattr(os, 'utime'):
  87.         os.utime(dst, (st.st_atime, st.st_mtime))
  88.     
  89.     if hasattr(os, 'chmod'):
  90.         os.chmod(dst, mode)
  91.     
  92.     if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
  93.         os.chflags(dst, st.st_flags)
  94.     
  95.  
  96.  
  97. def copy(src, dst):
  98.     if os.path.isdir(dst):
  99.         dst = os.path.join(dst, os.path.basename(src))
  100.     
  101.     copyfile(src, dst)
  102.     copymode(src, dst)
  103.  
  104.  
  105. def copy2(src, dst):
  106.     if os.path.isdir(dst):
  107.         dst = os.path.join(dst, os.path.basename(src))
  108.     
  109.     copyfile(src, dst)
  110.     copystat(src, dst)
  111.  
  112.  
  113. def ignore_patterns(*patterns):
  114.     
  115.     def _ignore_patterns(path, names):
  116.         ignored_names = []
  117.         for pattern in patterns:
  118.             ignored_names.extend(fnmatch.filter(names, pattern))
  119.         
  120.         return set(ignored_names)
  121.  
  122.     return _ignore_patterns
  123.  
  124.  
  125. def copytree(src, dst, symlinks = False, ignore = None):
  126.     names = os.listdir(src)
  127.     if ignore is not None:
  128.         ignored_names = ignore(src, names)
  129.     else:
  130.         ignored_names = set()
  131.     os.makedirs(dst)
  132.     errors = []
  133.     for name in names:
  134.         if name in ignored_names:
  135.             continue
  136.         
  137.         srcname = os.path.join(src, name)
  138.         dstname = os.path.join(dst, name)
  139.         
  140.         try:
  141.             if symlinks and os.path.islink(srcname):
  142.                 linkto = os.readlink(srcname)
  143.                 os.symlink(linkto, dstname)
  144.             elif os.path.isdir(srcname):
  145.                 copytree(srcname, dstname, symlinks, ignore)
  146.             else:
  147.                 copy2(srcname, dstname)
  148.         continue
  149.         except (IOError, os.error):
  150.             why = None
  151.             errors.append((srcname, dstname, str(why)))
  152.             continue
  153.             except Error:
  154.                 err = None
  155.                 errors.extend(err.args[0])
  156.                 continue
  157.             
  158.         try:
  159.             copystat(src, dst)
  160.         except OSError:
  161.             None<EXCEPTION MATCH>(IOError, os.error)
  162.             why = None<EXCEPTION MATCH>(IOError, os.error)
  163.             if WindowsError is not None and isinstance(why, WindowsError):
  164.                 pass
  165.             else:
  166.                 errors.extend((src, dst, str(why)))
  167.         except:
  168.             isinstance(why, WindowsError)
  169.  
  170.         if errors:
  171.             raise Error, errors
  172.         errors
  173.         return None
  174.  
  175.  
  176. def rmtree(path, ignore_errors = False, onerror = None):
  177.     if ignore_errors:
  178.         
  179.         def onerror(*args):
  180.             pass
  181.  
  182.     elif onerror is None:
  183.         
  184.         def onerror(*args):
  185.             raise 
  186.  
  187.     
  188.     
  189.     try:
  190.         if os.path.islink(path):
  191.             raise OSError('Cannot call rmtree on a symbolic link')
  192.         os.path.islink(path)
  193.     except OSError:
  194.         onerror(os.path.islink, path, sys.exc_info())
  195.         return None
  196.  
  197.     names = []
  198.     
  199.     try:
  200.         names = os.listdir(path)
  201.     except os.error:
  202.         err = None
  203.         onerror(os.listdir, path, sys.exc_info())
  204.  
  205.     for name in names:
  206.         fullname = os.path.join(path, name)
  207.         
  208.         try:
  209.             mode = os.lstat(fullname).st_mode
  210.         except os.error:
  211.             mode = 0
  212.  
  213.         if stat.S_ISDIR(mode):
  214.             rmtree(fullname, ignore_errors, onerror)
  215.             continue
  216.         
  217.         try:
  218.             os.remove(fullname)
  219.         continue
  220.         except os.error:
  221.             err = None
  222.             onerror(os.remove, fullname, sys.exc_info())
  223.             continue
  224.         
  225.  
  226.     
  227.     
  228.     try:
  229.         os.rmdir(path)
  230.     except os.error:
  231.         None<EXCEPTION MATCH>os.error
  232.         None<EXCEPTION MATCH>os.error
  233.         onerror(os.rmdir, path, sys.exc_info())
  234.     except:
  235.         None<EXCEPTION MATCH>os.error
  236.  
  237.  
  238.  
  239. def _basename(path):
  240.     return os.path.basename(path.rstrip(os.path.sep))
  241.  
  242.  
  243. def move(src, dst):
  244.     real_dst = dst
  245.     if os.path.isdir(dst):
  246.         real_dst = os.path.join(dst, _basename(src))
  247.         if os.path.exists(real_dst):
  248.             raise Error, "Destination path '%s' already exists" % real_dst
  249.         os.path.exists(real_dst)
  250.     
  251.     
  252.     try:
  253.         os.rename(src, real_dst)
  254.     except OSError:
  255.         if os.path.isdir(src):
  256.             if destinsrc(src, dst):
  257.                 raise Error, "Cannot move a directory '%s' into itself '%s'." % (src, dst)
  258.             destinsrc(src, dst)
  259.             copytree(src, real_dst, symlinks = True)
  260.             rmtree(src)
  261.         else:
  262.             copy2(src, real_dst)
  263.             os.unlink(src)
  264.     except:
  265.         os.path.isdir(src)
  266.  
  267.  
  268.  
  269. def destinsrc(src, dst):
  270.     src = abspath(src)
  271.     dst = abspath(dst)
  272.     if not src.endswith(os.path.sep):
  273.         src += os.path.sep
  274.     
  275.     if not dst.endswith(os.path.sep):
  276.         dst += os.path.sep
  277.     
  278.     return dst.startswith(src)
  279.  
  280.