home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / MacHacksBug / Python 1.5.2c1 / Lib / gzip.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2000-06-23  |  11.8 KB  |  354 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 1.5)
  3.  
  4. import time
  5. import string
  6. import zlib
  7. import struct
  8. import __builtin__
  9. (FTEXT, FHCRC, FEXTRA, FNAME, FCOMMENT) = (1, 2, 4, 8, 16)
  10. (READ, WRITE) = (1, 2)
  11.  
  12. def write32(output, value):
  13.     output.write(struct.pack('<l', value))
  14.  
  15.  
  16. def write32u(output, value):
  17.     output.write(struct.pack('<L', value))
  18.  
  19.  
  20. def read32(input):
  21.     return struct.unpack('<l', input.read(4))[0]
  22.  
  23.  
  24. def open(filename, mode = 'rb', compresslevel = 9):
  25.     return GzipFile(filename, mode, compresslevel)
  26.  
  27.  
  28. class GzipFile:
  29.     myfileobj = None
  30.     
  31.     def __init__(self, filename = None, mode = None, compresslevel = 9, fileobj = None):
  32.         if fileobj is None:
  33.             if not mode:
  34.                 pass
  35.             fileobj = self.myfileobj = __builtin__.open(filename, 'rb')
  36.         
  37.         if filename is None:
  38.             if hasattr(fileobj, 'name'):
  39.                 filename = fileobj.name
  40.             else:
  41.                 filename = ''
  42.         
  43.         if mode is None:
  44.             if hasattr(fileobj, 'mode'):
  45.                 mode = fileobj.mode
  46.             else:
  47.                 mode = 'rb'
  48.         
  49.         if mode[0:1] == 'r':
  50.             self.mode = READ
  51.             self._new_member = 1
  52.             self.extrabuf = ''
  53.             self.extrasize = 0
  54.             self.filename = filename
  55.         elif mode[0:1] == 'w' or mode[0:1] == 'a':
  56.             self.mode = WRITE
  57.             self._init_write(filename)
  58.             self.compress = zlib.compressobj(compresslevel, zlib.DEFLATED, -(zlib.MAX_WBITS), zlib.DEF_MEM_LEVEL, 0)
  59.         else:
  60.             raise ValueError, 'Mode ' + mode + ' not supported'
  61.         self.fileobj = fileobj
  62.         if self.mode == WRITE:
  63.             self._write_gzip_header()
  64.         
  65.  
  66.     
  67.     def __repr__(self):
  68.         s = repr(self.fileobj)
  69.         return '<gzip ' + s[1:-1] + ' ' + hex(id(self)) + '>'
  70.  
  71.     
  72.     def _init_write(self, filename):
  73.         if filename[-3:] != '.gz':
  74.             filename = filename + '.gz'
  75.         
  76.         self.filename = filename
  77.         self.crc = zlib.crc32('')
  78.         self.size = 0
  79.         self.writebuf = []
  80.         self.bufsize = 0
  81.  
  82.     
  83.     def _write_gzip_header(self):
  84.         self.fileobj.write('\x1f\x8b')
  85.         self.fileobj.write('\x08')
  86.         fname = self.filename[:-3]
  87.         flags = 0
  88.         if fname:
  89.             flags = FNAME
  90.         
  91.         self.fileobj.write(chr(flags))
  92.         write32u(self.fileobj, long(time.time()))
  93.         self.fileobj.write('\x02')
  94.         self.fileobj.write('\xff')
  95.         if fname:
  96.             self.fileobj.write(fname + '\x00')
  97.         
  98.  
  99.     
  100.     def _init_read(self):
  101.         self.crc = zlib.crc32('')
  102.         self.size = 0
  103.  
  104.     
  105.     def _read_gzip_header(self):
  106.         magic = self.fileobj.read(2)
  107.         if magic != '\x1f\x8b':
  108.             raise IOError, 'Not a gzipped file'
  109.         
  110.         method = ord(self.fileobj.read(1))
  111.         if method != 8:
  112.             raise IOError, 'Unknown compression method'
  113.         
  114.         flag = ord(self.fileobj.read(1))
  115.         self.fileobj.read(6)
  116.         if flag & FEXTRA:
  117.             xlen = ord(self.fileobj.read(1))
  118.             xlen = xlen + 256 * ord(self.fileobj.read(1))
  119.             self.fileobj.read(xlen)
  120.         
  121.         if flag & FNAME:
  122.             while 1:
  123.                 s = self.fileobj.read(1)
  124.                 if not s or s == '\x00':
  125.                     break
  126.                 
  127.         
  128.         if flag & FCOMMENT:
  129.             while 1:
  130.                 s = self.fileobj.read(1)
  131.                 if not s or s == '\x00':
  132.                     break
  133.                 
  134.         
  135.         if flag & FHCRC:
  136.             self.fileobj.read(2)
  137.         
  138.  
  139.     
  140.     def write(self, data):
  141.         if self.fileobj is None:
  142.             raise ValueError, 'write() on closed GzipFile object'
  143.         
  144.         if len(data) > 0:
  145.             self.size = self.size + len(data)
  146.             self.crc = zlib.crc32(data, self.crc)
  147.             self.fileobj.write(self.compress.compress(data))
  148.         
  149.  
  150.     
  151.     def writelines(self, lines):
  152.         self.write(string.join(lines))
  153.  
  154.     
  155.     def read(self, size = None):
  156.         if self.extrasize <= 0 and self.fileobj is None:
  157.             return ''
  158.         
  159.         readsize = 1024
  160.         if not size:
  161.             
  162.             try:
  163.                 while 1:
  164.                     self._read(readsize)
  165.                     readsize = readsize * 2
  166.             except EOFError:
  167.                 size = self.extrasize
  168.  
  169.         else:
  170.             
  171.             try:
  172.                 while size > self.extrasize:
  173.                     self._read(readsize)
  174.                     readsize = readsize * 2
  175.             except EOFError:
  176.                 if size > self.extrasize:
  177.                     size = self.extrasize
  178.                 
  179.             except:
  180.                 size > self.extrasize
  181.  
  182.         chunk = self.extrabuf[:size]
  183.         self.extrabuf = self.extrabuf[size:]
  184.         self.extrasize = self.extrasize - size
  185.         return chunk
  186.  
  187.     
  188.     def _unread(self, buf):
  189.         self.extrabuf = buf + self.extrabuf
  190.         self.extrasize = len(buf) + self.extrasize
  191.  
  192.     
  193.     def _read(self, size = 1024):
  194.         if self.fileobj is None:
  195.             raise EOFError, 'Reached EOF'
  196.         
  197.         if self._new_member:
  198.             pos = self.fileobj.tell()
  199.             self.fileobj.seek(0, 2)
  200.             if pos == self.fileobj.tell():
  201.                 self.fileobj = None
  202.                 return (EOFError, 'Reached EOF')
  203.             else:
  204.                 self.fileobj.seek(pos)
  205.             self._init_read()
  206.             self._read_gzip_header()
  207.             self.decompress = zlib.decompressobj(-(zlib.MAX_WBITS))
  208.             self._new_member = 0
  209.         
  210.         buf = self.fileobj.read(size)
  211.         if buf == '':
  212.             uncompress = self.decompress.flush()
  213.             self._read_eof()
  214.             self.fileobj = None
  215.             self._add_read_data(uncompress)
  216.             raise EOFError, 'Reached EOF'
  217.         
  218.         uncompress = self.decompress.decompress(buf)
  219.         self._add_read_data(uncompress)
  220.         if self.decompress.unused_data != '':
  221.             self.fileobj.seek(-len(self.decompress.unused_data) + 8, 1)
  222.             self._read_eof()
  223.             self._new_member = 1
  224.         
  225.  
  226.     
  227.     def _add_read_data(self, data):
  228.         self.crc = zlib.crc32(data, self.crc)
  229.         self.extrabuf = self.extrabuf + data
  230.         self.extrasize = self.extrasize + len(data)
  231.         self.size = self.size + len(data)
  232.  
  233.     
  234.     def _read_eof(self):
  235.         self.fileobj.seek(-8, 1)
  236.         crc32 = read32(self.fileobj)
  237.         isize = read32(self.fileobj)
  238.         if crc32 != self.crc:
  239.             raise ValueError, 'CRC check failed'
  240.         elif isize != self.size:
  241.             raise ValueError, 'Incorrect length of data produced'
  242.         
  243.  
  244.     
  245.     def close(self):
  246.         if self.mode == WRITE:
  247.             self.fileobj.write(self.compress.flush())
  248.             write32(self.fileobj, self.crc)
  249.             write32(self.fileobj, self.size)
  250.             self.fileobj = None
  251.         elif self.mode == READ:
  252.             self.fileobj = None
  253.         
  254.         if self.myfileobj:
  255.             self.myfileobj.close()
  256.             self.myfileobj = None
  257.         
  258.  
  259.     
  260.     def flush(self):
  261.         self.fileobj.flush()
  262.  
  263.     
  264.     def seek(self):
  265.         raise IOError, 'Random access not allowed in gzip files'
  266.  
  267.     
  268.     def tell(self):
  269.         raise IOError, "I won't tell() you for gzip files"
  270.  
  271.     
  272.     def isatty(self):
  273.         return 0
  274.  
  275.     
  276.     def readline(self):
  277.         bufs = []
  278.         readsize = 100
  279.         while 1:
  280.             c = self.read(readsize)
  281.             i = string.find(c, '\n')
  282.             if i >= 0 or c == '':
  283.                 bufs.append(c[:i + 1])
  284.                 self._unread(c[i + 1:])
  285.                 return string.join(bufs, '')
  286.             
  287.             bufs.append(c)
  288.             readsize = readsize * 2
  289.  
  290.     
  291.     def readlines(self):
  292.         buf = self.read()
  293.         lines = string.split(buf, '\n')
  294.         for i in range(len(lines) - 1):
  295.             lines[i] = lines[i] + '\n'
  296.         
  297.         return lines
  298.  
  299.     
  300.     def writelines(self, L):
  301.         for line in L:
  302.             self.write(line)
  303.         
  304.  
  305.  
  306.  
  307. def _test():
  308.     import sys
  309.     args = sys.argv[1:]
  310.     if args:
  311.         pass
  312.     decompress = args[0] == '-d'
  313.     if decompress:
  314.         args = args[1:]
  315.     
  316.     if not args:
  317.         args = [
  318.             '-']
  319.     
  320.     for arg in args:
  321.         if decompress:
  322.             if arg == '-':
  323.                 f = GzipFile(filename = '', mode = 'rb', fileobj = sys.stdin)
  324.                 g = sys.stdout
  325.             elif arg[-3:] != '.gz':
  326.                 print "filename doesn't end in .gz:", `arg`
  327.                 continue
  328.             
  329.             f = open(arg, 'rb')
  330.             g = __builtin__.open(arg[:-3], 'wb')
  331.         elif arg == '-':
  332.             f = sys.stdin
  333.             g = GzipFile(filename = '', mode = 'wb', fileobj = sys.stdout)
  334.         else:
  335.             f = __builtin__.open(arg, 'rb')
  336.             g = open(arg + '.gz', 'wb')
  337.         while 1:
  338.             chunk = f.read(1024)
  339.             if not chunk:
  340.                 break
  341.             
  342.             g.write(chunk)
  343.         if g is not sys.stdout:
  344.             g.close()
  345.         
  346.         if f is not sys.stdin:
  347.             f.close()
  348.         
  349.     
  350.  
  351. if __name__ == '__main__':
  352.     _test()
  353.  
  354.