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