home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_587 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  11.3 KB  |  467 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import struct
  5. import sys
  6. import time
  7. import zlib
  8. import __builtin__
  9. __all__ = [
  10.     'GzipFile',
  11.     'open']
  12. (FTEXT, FHCRC, FEXTRA, FNAME, FCOMMENT) = (1, 2, 4, 8, 16)
  13. (READ, WRITE) = (1, 2)
  14.  
  15. def write32u(output, value):
  16.     output.write(struct.pack('<L', value))
  17.  
  18.  
  19. def read32(input):
  20.     return struct.unpack('<I', input.read(4))[0]
  21.  
  22.  
  23. def open(filename, mode = 'rb', compresslevel = 9):
  24.     return GzipFile(filename, mode, compresslevel)
  25.  
  26.  
  27. class GzipFile:
  28.     myfileobj = None
  29.     max_read_chunk = 10485760
  30.     
  31.     def __init__(self, filename = None, mode = None, compresslevel = 9, fileobj = None):
  32.         if mode and 'b' not in mode:
  33.             mode += 'b'
  34.         
  35.         if fileobj is None:
  36.             if not mode:
  37.                 pass
  38.             fileobj = self.myfileobj = __builtin__.open(filename, 'rb')
  39.         
  40.         if filename is None:
  41.             if hasattr(fileobj, 'name'):
  42.                 filename = fileobj.name
  43.             else:
  44.                 filename = ''
  45.         
  46.         if mode is None:
  47.             if hasattr(fileobj, 'mode'):
  48.                 mode = fileobj.mode
  49.             else:
  50.                 mode = 'rb'
  51.         
  52.         if mode[0:1] == 'r':
  53.             self.mode = READ
  54.             self._new_member = True
  55.             self.extrabuf = ''
  56.             self.extrasize = 0
  57.             self.name = filename
  58.             self.min_readsize = 100
  59.         elif mode[0:1] == 'w' or mode[0:1] == 'a':
  60.             self.mode = WRITE
  61.             self._init_write(filename)
  62.             self.compress = zlib.compressobj(compresslevel, zlib.DEFLATED, -(zlib.MAX_WBITS), zlib.DEF_MEM_LEVEL, 0)
  63.         else:
  64.             raise IOError, 'Mode ' + mode + ' not supported'
  65.         self.fileobj = mode[0:1] == 'a'
  66.         self.offset = 0
  67.         if self.mode == WRITE:
  68.             self._write_gzip_header()
  69.         
  70.  
  71.     
  72.     def filename(self):
  73.         import warnings
  74.         warnings.warn('use the name attribute', DeprecationWarning, 2)
  75.         if self.mode == WRITE and self.name[-3:] != '.gz':
  76.             return self.name + '.gz'
  77.         return self.name
  78.  
  79.     filename = property(filename)
  80.     
  81.     def __repr__(self):
  82.         s = repr(self.fileobj)
  83.         return '<gzip ' + s[1:-1] + ' ' + hex(id(self)) + '>'
  84.  
  85.     
  86.     def _init_write(self, filename):
  87.         self.name = filename
  88.         self.crc = zlib.crc32('') & 0xFFFFFFFFL
  89.         self.size = 0
  90.         self.writebuf = []
  91.         self.bufsize = 0
  92.  
  93.     
  94.     def _write_gzip_header(self):
  95.         self.fileobj.write('\x1f\x8b')
  96.         self.fileobj.write('\x08')
  97.         fname = self.name
  98.         if fname.endswith('.gz'):
  99.             fname = fname[:-3]
  100.         
  101.         flags = 0
  102.         if fname:
  103.             flags = FNAME
  104.         
  105.         self.fileobj.write(chr(flags))
  106.         write32u(self.fileobj, long(time.time()))
  107.         self.fileobj.write('\x02')
  108.         self.fileobj.write('\xff')
  109.         if fname:
  110.             self.fileobj.write(fname + '\x00')
  111.         
  112.  
  113.     
  114.     def _init_read(self):
  115.         self.crc = zlib.crc32('') & 0xFFFFFFFFL
  116.         self.size = 0
  117.  
  118.     
  119.     def _read_gzip_header(self):
  120.         magic = self.fileobj.read(2)
  121.         if magic != '\x1f\x8b':
  122.             raise IOError, 'Not a gzipped file'
  123.         magic != '\x1f\x8b'
  124.         method = ord(self.fileobj.read(1))
  125.         if method != 8:
  126.             raise IOError, 'Unknown compression method'
  127.         method != 8
  128.         flag = ord(self.fileobj.read(1))
  129.         self.fileobj.read(6)
  130.         if flag & FEXTRA:
  131.             xlen = ord(self.fileobj.read(1))
  132.             xlen = xlen + 256 * ord(self.fileobj.read(1))
  133.             self.fileobj.read(xlen)
  134.         
  135.         if flag & FNAME:
  136.             while True:
  137.                 s = self.fileobj.read(1)
  138.                 if not s or s == '\x00':
  139.                     break
  140.                     continue
  141.         
  142.         if flag & FCOMMENT:
  143.             while True:
  144.                 s = self.fileobj.read(1)
  145.                 if not s or s == '\x00':
  146.                     break
  147.                     continue
  148.         
  149.         if flag & FHCRC:
  150.             self.fileobj.read(2)
  151.         
  152.  
  153.     
  154.     def write(self, data):
  155.         if self.mode != WRITE:
  156.             import errno
  157.             raise IOError(errno.EBADF, 'write() on read-only GzipFile object')
  158.         self.mode != WRITE
  159.         if self.fileobj is None:
  160.             raise ValueError, 'write() on closed GzipFile object'
  161.         self.fileobj is None
  162.         if len(data) > 0:
  163.             self.size = self.size + len(data)
  164.             self.crc = zlib.crc32(data, self.crc) & 0xFFFFFFFFL
  165.             self.fileobj.write(self.compress.compress(data))
  166.             self.offset += len(data)
  167.         
  168.  
  169.     
  170.     def read(self, size = -1):
  171.         if self.mode != READ:
  172.             import errno
  173.             raise IOError(errno.EBADF, 'read() on write-only GzipFile object')
  174.         self.mode != READ
  175.         if self.extrasize <= 0 and self.fileobj is None:
  176.             return ''
  177.         readsize = 1024
  178.         if size < 0:
  179.             
  180.             try:
  181.                 while True:
  182.                     self._read(readsize)
  183.                     readsize = min(self.max_read_chunk, readsize * 2)
  184.                     continue
  185.                     self.fileobj is None
  186.             except EOFError:
  187.                 self.fileobj is None
  188.                 self.fileobj is None
  189.                 size = self.extrasize
  190.             except:
  191.                 self.fileobj is None<EXCEPTION MATCH>EOFError
  192.             
  193.  
  194.         self.fileobj is None
  195.         
  196.         try:
  197.             while size > self.extrasize:
  198.                 self._read(readsize)
  199.                 readsize = min(self.max_read_chunk, readsize * 2)
  200.                 continue
  201.                 self.fileobj is None
  202.         except EOFError:
  203.             self.fileobj is None
  204.             self.fileobj is None
  205.             if size > self.extrasize:
  206.                 size = self.extrasize
  207.             
  208.         except:
  209.             size > self.extrasize
  210.  
  211.         chunk = self.extrabuf[:size]
  212.         self.extrabuf = self.extrabuf[size:]
  213.         self.extrasize = self.extrasize - size
  214.         self.offset += size
  215.         return chunk
  216.  
  217.     
  218.     def _unread(self, buf):
  219.         self.extrabuf = buf + self.extrabuf
  220.         self.extrasize = len(buf) + self.extrasize
  221.         self.offset -= len(buf)
  222.  
  223.     
  224.     def _read(self, size = 1024):
  225.         if self.fileobj is None:
  226.             raise EOFError, 'Reached EOF'
  227.         self.fileobj is None
  228.         if self._new_member:
  229.             pos = self.fileobj.tell()
  230.             self.fileobj.seek(0, 2)
  231.             if pos == self.fileobj.tell():
  232.                 raise EOFError, 'Reached EOF'
  233.             pos == self.fileobj.tell()
  234.             self.fileobj.seek(pos)
  235.             self._init_read()
  236.             self._read_gzip_header()
  237.             self.decompress = zlib.decompressobj(-(zlib.MAX_WBITS))
  238.             self._new_member = False
  239.         
  240.         buf = self.fileobj.read(size)
  241.         if buf == '':
  242.             uncompress = self.decompress.flush()
  243.             self._read_eof()
  244.             self._add_read_data(uncompress)
  245.             raise EOFError, 'Reached EOF'
  246.         buf == ''
  247.         uncompress = self.decompress.decompress(buf)
  248.         self._add_read_data(uncompress)
  249.         if self.decompress.unused_data != '':
  250.             self.fileobj.seek(-len(self.decompress.unused_data) + 8, 1)
  251.             self._read_eof()
  252.             self._new_member = True
  253.         
  254.  
  255.     
  256.     def _add_read_data(self, data):
  257.         self.crc = zlib.crc32(data, self.crc) & 0xFFFFFFFFL
  258.         self.extrabuf = self.extrabuf + data
  259.         self.extrasize = self.extrasize + len(data)
  260.         self.size = self.size + len(data)
  261.  
  262.     
  263.     def _read_eof(self):
  264.         self.fileobj.seek(-8, 1)
  265.         crc32 = read32(self.fileobj)
  266.         isize = read32(self.fileobj)
  267.         if crc32 != self.crc:
  268.             raise IOError('CRC check failed %s != %s' % (hex(crc32), hex(self.crc)))
  269.         crc32 != self.crc
  270.         if isize != self.size & 0xFFFFFFFFL:
  271.             raise IOError, 'Incorrect length of data produced'
  272.         isize != self.size & 0xFFFFFFFFL
  273.  
  274.     
  275.     def close(self):
  276.         if self.fileobj is None:
  277.             return None
  278.         if self.mode == WRITE:
  279.             self.fileobj.write(self.compress.flush())
  280.             write32u(self.fileobj, self.crc)
  281.             write32u(self.fileobj, self.size & 0xFFFFFFFFL)
  282.             self.fileobj = None
  283.         elif self.mode == READ:
  284.             self.fileobj = None
  285.         
  286.         if self.myfileobj:
  287.             self.myfileobj.close()
  288.             self.myfileobj = None
  289.         
  290.  
  291.     
  292.     def __del__(self):
  293.         
  294.         try:
  295.             if self.myfileobj is None and self.fileobj is None:
  296.                 return None
  297.         except AttributeError:
  298.             return None
  299.  
  300.         self.close()
  301.  
  302.     
  303.     def flush(self, zlib_mode = zlib.Z_SYNC_FLUSH):
  304.         if self.mode == WRITE:
  305.             self.fileobj.write(self.compress.flush(zlib_mode))
  306.         
  307.         self.fileobj.flush()
  308.  
  309.     
  310.     def fileno(self):
  311.         return self.fileobj.fileno()
  312.  
  313.     
  314.     def isatty(self):
  315.         return False
  316.  
  317.     
  318.     def tell(self):
  319.         return self.offset
  320.  
  321.     
  322.     def rewind(self):
  323.         if self.mode != READ:
  324.             raise IOError("Can't rewind in write mode")
  325.         self.mode != READ
  326.         self.fileobj.seek(0)
  327.         self._new_member = True
  328.         self.extrabuf = ''
  329.         self.extrasize = 0
  330.         self.offset = 0
  331.  
  332.     
  333.     def seek(self, offset, whence = 0):
  334.         if whence:
  335.             if whence == 1:
  336.                 offset = self.offset + offset
  337.             else:
  338.                 raise ValueError('Seek from end not supported')
  339.         whence == 1
  340.         if self.mode == WRITE:
  341.             if offset < self.offset:
  342.                 raise IOError('Negative seek in write mode')
  343.             offset < self.offset
  344.             count = offset - self.offset
  345.             for i in range(count // 1024):
  346.                 self.write(1024 * '\x00')
  347.             
  348.             self.write((count % 1024) * '\x00')
  349.         elif self.mode == READ:
  350.             if offset < self.offset:
  351.                 self.rewind()
  352.             
  353.             count = offset - self.offset
  354.             for i in range(count // 1024):
  355.                 self.read(1024)
  356.             
  357.             self.read(count % 1024)
  358.         
  359.  
  360.     
  361.     def readline(self, size = -1):
  362.         if size < 0:
  363.             size = sys.maxint
  364.             readsize = self.min_readsize
  365.         else:
  366.             readsize = size
  367.         bufs = []
  368.         while size != 0:
  369.             c = self.read(readsize)
  370.             i = c.find('\n')
  371.             if (size <= i or i == -1) and len(c) > size:
  372.                 i = size - 1
  373.             
  374.             if i >= 0 or c == '':
  375.                 bufs.append(c[:i + 1])
  376.                 self._unread(c[i + 1:])
  377.                 break
  378.             
  379.             bufs.append(c)
  380.             size = size - len(c)
  381.             readsize = min(size, readsize * 2)
  382.         if readsize > self.min_readsize:
  383.             self.min_readsize = min(readsize, self.min_readsize * 2, 512)
  384.         
  385.         return ''.join(bufs)
  386.  
  387.     
  388.     def readlines(self, sizehint = 0):
  389.         if sizehint <= 0:
  390.             sizehint = sys.maxint
  391.         
  392.         L = []
  393.         while sizehint > 0:
  394.             line = self.readline()
  395.             if line == '':
  396.                 break
  397.             
  398.             L.append(line)
  399.             sizehint = sizehint - len(line)
  400.         return L
  401.  
  402.     
  403.     def writelines(self, L):
  404.         for line in L:
  405.             self.write(line)
  406.         
  407.  
  408.     
  409.     def __iter__(self):
  410.         return self
  411.  
  412.     
  413.     def next(self):
  414.         line = self.readline()
  415.         if line:
  416.             return line
  417.         raise StopIteration
  418.  
  419.  
  420.  
  421. def _test():
  422.     args = sys.argv[1:]
  423.     if args:
  424.         pass
  425.     decompress = args[0] == '-d'
  426.     if decompress:
  427.         args = args[1:]
  428.     
  429.     if not args:
  430.         args = [
  431.             '-']
  432.     
  433.     for arg in args:
  434.         if decompress:
  435.             if arg == '-':
  436.                 f = GzipFile(filename = '', mode = 'rb', fileobj = sys.stdin)
  437.                 g = sys.stdout
  438.             elif arg[-3:] != '.gz':
  439.                 print "filename doesn't end in .gz:", repr(arg)
  440.                 continue
  441.             
  442.             f = open(arg, 'rb')
  443.             g = __builtin__.open(arg[:-3], 'wb')
  444.         elif arg == '-':
  445.             f = sys.stdin
  446.             g = GzipFile(filename = '', mode = 'wb', fileobj = sys.stdout)
  447.         else:
  448.             f = __builtin__.open(arg, 'rb')
  449.             g = open(arg + '.gz', 'wb')
  450.         while True:
  451.             chunk = f.read(1024)
  452.             if not chunk:
  453.                 break
  454.             
  455.             g.write(chunk)
  456.         if g is not sys.stdout:
  457.             g.close()
  458.         
  459.         if f is not sys.stdin:
  460.             f.close()
  461.             continue
  462.     
  463.  
  464. if __name__ == '__main__':
  465.     _test()
  466.  
  467.