[Patches] Re: New module zipfile.py
James C. Ahlstrom
jim@interet.com
Mon, 28 Feb 2000 14:14:58 -0500
This is a multi-part message in MIME format.
--------------18734A03406EE5D854B4AC13
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Guido van Rossum wrote:
> [A lot of comments on zipfile.py....]
I rewrote zipfile.py and make all the changes you suggested except
as noted below. I think zipfile.py is now a lot better, but since
there are so many changes, it needs more testing. Help with testing
please...
The new zipfile.py, new docs and a ./test/test_zipfile.py is attached.
Please note that the interface changed from the last version.
LEGAL
=====
I confirm that, to the best of my knowledge and belief, this
contribution is free of any claims of third parties under
copyright, patent or other rights or interests ("claims"). To
the extent that I have any such claims, I hereby grant to CNRI a
nonexclusive, irrevocable, royalty-free, worldwide license to
reproduce, distribute, perform and/or display publicly, prepare
derivative versions, and otherwise use this contribution as part
of the Python software and its related documentation, or any
derivative versions thereof, at no cost to CNRI or its licensed
users, and to authorize others to do so.
I acknowledge that CNRI may, at its sole discretion, decide
whether or not to incorporate this contribution in the Python
software and its related documentation. I further grant CNRI
permission to use my name and other identifying information
provided to CNRI by me for use in connection with the Python
software and its related documentation.
DETAILS
=======
> of not indenting doc strings and not leaving a blank line between the
> "summary line" of the doc string (its first line) and the rest. None
> of that is a showstopper, and a separate coding style conformance pass
> can be made to fix these issues.
I'm not sure I got this just right yet. "Not indenting"???
> Also, I noticed that this emits a warning to stdout if the name
> already exists. The idea that the module prints to stdout for various
> reasons is a little scary -- as you often repeat yourself, in GUI
> apps, there may be no stdout, or writing to it may be frowned upon.
> (Maybe _debug should just be set to 0 by default? That would shut up
> everything except writepy() and printdir(), I believe.)
I changed the default debug to zero, but..
In GUI apps it is necessary to capture stdout and present it in
a popup window. Any reasonable Python GUI should do this as a
standard feature. Otherwise tracebacks etc. have no place to go.
So I think writing messages to stdout is OK.
> Another comment: when I use the Unix zipinfo utility to list the
> contents of an archive created with this module, the first character
> of the file mode is listed as '?'. It should be '-', indicating a
> plain file. No idea which flag you should set tohow get this effect,
> but the zip documentation should tell you.
I don't have zipinfo so I couldn't fix this. Where is it?
JimA
--------------18734A03406EE5D854B4AC13
Content-Type: text/plain; charset=us-ascii;
name="zipfile.py"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="zipfile.py"
"Read and write ZIP files"
# Written by James C. Ahlstrom jim@interet.com
# All rights transferred to CNRI pursuant to the Python contribution agreement
import struct, os, time
import binascii, py_compile
try:
import zlib # We may need its compression method
except:
zlib = None
class _BadZipfile(Exception):
pass
error = _BadZipfile # The exception raised by this module
# constants for Zip file compression methods
ZIP_STORED = 0
ZIP_DEFLATED = 8
# Other ZIP compression methods not supported
# Here are some struct module formats for reading headers
structEndArchive = "<4s4H2lH" # 9 items, end of archive, 22 bytes
stringEndArchive = "PK\005\006" # magic number for end of archive record
structCentralDir = "<4s4B4H3l5H2l"# 19 items, central directory, 46 bytes
stringCentralDir = "PK\001\002" # magic number for central directory
structFileHeader = "<4s2B4H3l2H" # 12 items, file header record, 30 bytes
stringFileHeader = "PK\003\004" # magic number for file header
def is_zipfile(filename):
"""Quickly see if file is a ZIP file by checking the magic number.
Will not accept a ZIP archive with an ending comment."""
try:
fpin = open(filename, "rb")
fpin.seek(-22, 2) # Seek to end-of-file record
endrec = fpin.read()
fpin.close()
if endrec[0:4] == "PK\005\006" and endrec[-2:] == "\000\000":
return 1 # file has correct magic number
except:
pass
class ZipInfo:
"Class with attributes describing each file in the ZIP archive"
def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
self.filename = filename # Name of the file in the archive
self.date_time = date_time # year, month, day, hour, min, sec
# Standard values:
self.compress_type = ZIP_STORED # Type of compression for the file
self.comment = "" # Comment for each file
self.extra = "" # ZIP extra data
self.create_system = 0 # System which created ZIP archive
self.create_version = 20 # Version which created ZIP archive
self.extract_version = 20 # Version needed to extract archive
self.reserved = 0 # Must be zero
self.flag_bits = 0 # ZIP flag bits
self.volume = 0 # Volume number of file header
self.internal_attr = 0 # Internal attributes
self.external_attr = 0 # External file attributes
# Other attributes are set by class ZipFile:
# header_offset Byte offset to the file header
# file_offset Byte offset to the start of the file data
# CRC CRC-32 of the uncompressed file
# compress_size Size of the compressed file
# file_size Size of the uncompressed file
def FileHeader(self):
'Return the per-file header as a string'
dt = self.date_time
dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
dostime = dt[3] << 11 | dt[4] << 5 | dt[5] / 2
if self.flag_bits & 0x08:
# Set these to zero because we write them after the file data
CRC = compress_size = file_size = 0
else:
CRC = self.CRC
compress_size = self.compress_size
file_size = self.file_size
header = struct.pack(structFileHeader, stringFileHeader,
self.extract_version, self.reserved, self.flag_bits,
self.compress_type, dostime, dosdate, CRC,
compress_size, file_size,
len(self.filename), len(self.extra))
return header + self.filename + self.extra
class ZipFile:
"Class with methods to open, read, write, close, list zip files"
def __init__(self, filename, mode="r", compression=ZIP_STORED):
'Open the ZIP file with mode read "r", write "w" or append "a".'
if compression == ZIP_STORED:
pass
elif compression == ZIP_DEFLATED:
if not zlib:
raise RuntimeError,\
"Compression requires the (missing) zlib module"
else:
raise RuntimeError, "That compression method is not supported"
self.debug = 0 # Level of printing: 0 through 3
self.NameToInfo = {} # Find file info given name
self.filelist = [] # List of ZipInfo instances for archive
self.compression = compression # Method of compression
self.filename = filename
self.mode = key = mode[0]
if key == 'r':
self.fp = open(filename, "rb")
self._GetContents()
elif key == 'w':
self.fp = open(filename, "wb")
elif key == 'a':
fp = self.fp = open(filename, "r+b")
fp.seek(-22, 2) # Seek to end-of-file record
endrec = fp.read()
if endrec[0:4] == stringEndArchive and \
endrec[-2:] == "\000\000":
self._GetContents() # file is a zip file
# seek to start of directory and overwrite
fp.seek(self.start_dir, 0)
else: # file is not a zip file, just append
fp.seek(0, 2)
else:
raise RuntimeError, 'Mode must be "r", "w" or "a"'
def _GetContents(self):
"Read in the table of contents for the zip file"
fp = self.fp
fp.seek(-22, 2) # Start of end-of-archive record
filesize = fp.tell() + 22 # Get file size
endrec = fp.read(22) # Archive must not end with a comment!
if endrec[0:4] != stringEndArchive or endrec[-2:] != "\000\000":
raise BadZipfile, "File is not a zip file, or ends with a comment"
endrec = struct.unpack(structEndArchive, endrec)
if self.debug > 1:
print endrec
size_cd = endrec[5] # bytes in central directory
offset_cd = endrec[6] # offset of central directory
x = filesize - 22 - size_cd
# "concat" is zero, unless zip was concatenated to another file
concat = x - offset_cd
if self.debug > 2:
print "given, inferred, offset", offset_cd, x, concat
# self.start_dir: Position of start of central directory
self.start_dir = offset_cd + concat
fp.seek(self.start_dir, 0)
total = 0
while total < size_cd:
centdir = fp.read(46)
total = total + 46
if centdir[0:4] != stringCentralDir:
raise BadZipfile, "Bad magic number for central directory"
centdir = struct.unpack(structCentralDir, centdir)
if self.debug > 2:
print centdir
filename = fp.read(centdir[12])
# Create ZipInfo instance to store file information
x = ZipInfo(filename)
x.extra = fp.read(centdir[13])
x.comment = fp.read(centdir[14])
total = total + centdir[12] + centdir[13] + centdir[14]
x.header_offset = centdir[18] + concat
x.file_offset = x.header_offset + 30 + centdir[12] + centdir[13]
(x.create_version, x.create_system, x.extract_version, x.reserved,
x.flag_bits, x.compress_type, t, d,
x.CRC, x.compress_size, x.file_size) = centdir[1:12]
x.volume, x.internal_attr, x.external_attr = centdir[15:18]
# Convert date/time code to (year, month, day, hour, min, sec)
x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
t>>11, (t>>5)&0x3F, t&0x1F * 2 )
self.filelist.append(x)
self.NameToInfo[x.filename] = x
if self.debug > 2:
print "total", total
for data in self.filelist:
fp.seek(data.header_offset, 0)
fheader = fp.read(30)
if fheader[0:4] != stringFileHeader:
raise BadZipfile, "Bad magic number for file header"
fheader = struct.unpack(structFileHeader, fheader)
fname = fp.read(fheader[10])
if fname != data.filename:
raise RuntimeError, \
'File name in Central Directory "%s" and File Header "%s" differ.' % (
data.filename, fname)
def namelist(self):
"Return a list of file names in the archive"
l = []
for data in self.filelist:
l.append(data.filename)
return l
def infolist(self):
"Return a list of class ZipInfo instances for files in the archive"
return self.filelist
def printdir(self):
"Print a table of contents for the zip file"
print "%-46s %19s %12s" % ("File Name", "Modified ", "Size")
for zinfo in self.filelist:
date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time
print "%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size)
def testzip(self):
"Read all the files and check the CRC"
for zinfo in self.filelist:
try:
self.read(zinfo.filename) # Check CRC-32
except:
return zinfo.filename
def getinfo(self, name):
'Return the instance of ZipInfo given "name"'
return self.NameToInfo[name]
def read(self, name):
"Return file bytes (as a string) for name"
if self.mode not in ("r", "a"):
raise RuntimeError, 'read() requires mode "r" or "a"'
if not self.fp:
raise RuntimeError, \
"Attempt to read ZIP archive that was already closed"
zinfo = self.getinfo(name)
filepos = self.fp.tell()
self.fp.seek(zinfo.file_offset, 0)
bytes = self.fp.read(zinfo.compress_size)
self.fp.seek(filepos, 0)
if zinfo.compress_type == ZIP_STORED:
pass
elif zinfo.compress_type == ZIP_DEFLATED:
if not zlib:
raise RuntimeError, \
"De-compression requires the (missing) zlib module"
# zlib compress/decompress code by Jeremy Hylton of CNRI
dc = zlib.decompressobj(-15)
bytes = dc.decompress(bytes)
# need to feed in unused pad byte so that zlib won't choke
ex = dc.decompress('Z') + dc.flush()
if ex:
bytes = bytes + ex
else:
raise BadZipfile, \
"Unsupported compression method %d for file %s" % \
(zinfo.compress_type, name)
crc = binascii.crc32(bytes)
if crc != zinfo.CRC:
raise BadZipfile, "Bad CRC-32 for file %s" % name
return bytes
def _writecheck(self, zinfo):
'Check for errors before writing a file to the archive'
if self.NameToInfo.has_key(zinfo.filename):
if self.debug: # Warning for duplicate names
print "Duplicate name:", zinfo.filename
if self.mode not in ("w", "a"):
raise RuntimeError, 'write() requires mode "w" or "a"'
if not self.fp:
raise RuntimeError, \
"Attempt to write ZIP archive that was already closed"
if zinfo.compress_type == ZIP_DEFLATED and not zlib:
raise RuntimeError, \
"Compression requires the (missing) zlib module"
if zinfo.compress_type not in (ZIP_STORED, ZIP_DEFLATED):
raise RuntimeError, \
"That compression method is not supported"
def write(self, filename, arcname=None, compress_type=None):
'Put the bytes from filename into the archive under the name arcname.'
st = os.stat(filename)
mtime = time.localtime(st[8])
date_time = mtime[0:6]
# Create ZipInfo instance to store file information
if arcname is None:
zinfo = ZipInfo(filename, date_time)
else:
zinfo = ZipInfo(arcname, date_time)
zinfo.external_attr = st[0] << 16 # Unix attributes
if compress_type is None:
zinfo.compress_type = self.compression
else:
zinfo.compress_type = compress_type
self._writecheck(zinfo)
fp = open(filename, "rb")
zinfo.flag_bits = 0x08
zinfo.header_offset = self.fp.tell() # Start of header bytes
self.fp.write(zinfo.FileHeader())
zinfo.file_offset = self.fp.tell() # Start of file bytes
CRC = 0
compress_size = 0
file_size = 0
if zinfo.compress_type == ZIP_DEFLATED:
cmpr = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
zlib.DEFLATED, -15)
else:
cmpr = None
while 1:
buf = fp.read(1024 * 8)
if not buf:
break
file_size = file_size + len(buf)
CRC = binascii.crc32(buf, CRC)
if cmpr:
buf = cmpr.compress(buf)
compress_size = compress_size + len(buf)
self.fp.write(buf)
fp.close()
if cmpr:
buf = cmpr.flush()
compress_size = compress_size + len(buf)
self.fp.write(buf)
zinfo.compress_size = compress_size
else:
zinfo.compress_size = file_size
zinfo.CRC = CRC
zinfo.file_size = file_size
# Write CRC and file sizes after the file data
self.fp.write(struct.pack("<lll", zinfo.CRC, zinfo.compress_size,
zinfo.file_size))
self.filelist.append(zinfo)
self.NameToInfo[zinfo.filename] = zinfo
def writestr(self, zinfo, bytes):
'Write a file into the archive. The contents is the string "bytes"'
self._writecheck(zinfo)
zinfo.file_size = len(bytes) # Uncompressed size
zinfo.CRC = binascii.crc32(bytes) # CRC-32 checksum
if zinfo.compress_type == ZIP_DEFLATED:
co = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
zlib.DEFLATED, -15)
bytes = co.compress(bytes) + co.flush()
zinfo.compress_size = len(bytes) # Compressed size
else:
zinfo.compress_size = zinfo.file_size
zinfo.header_offset = self.fp.tell() # Start of header bytes
self.fp.write(zinfo.FileHeader())
zinfo.file_offset = self.fp.tell() # Start of file bytes
self.fp.write(bytes)
if zinfo.flag_bits & 0x08:
# Write CRC and file sizes after the file data
self.fp.write(struct.pack("<lll", zinfo.CRC, zinfo.compress_size,
zinfo.file_size))
self.filelist.append(zinfo)
self.NameToInfo[zinfo.filename] = zinfo
def __del__(self):
'Call the "close()" method in case the user forgot'
if self.fp:
self.fp.close()
self.fp = None
def close(self):
'Close the file, and for mode "w" and "a" write the ending records'
if self.mode in ("w", "a"): # write ending records
count = 0
pos1 = self.fp.tell()
for zinfo in self.filelist: # write central directory
count = count + 1
dt = zinfo.date_time
dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
dostime = dt[3] << 11 | dt[4] << 5 | dt[5] / 2
centdir = struct.pack(structCentralDir,
stringCentralDir, zinfo.create_version,
zinfo.create_system, zinfo.extract_version, zinfo.reserved,
zinfo.flag_bits, zinfo.compress_type, dostime, dosdate,
zinfo.CRC, zinfo.compress_size, zinfo.file_size,
len(zinfo.filename), len(zinfo.extra), len(zinfo.comment),
0, zinfo.internal_attr, zinfo.external_attr,
zinfo.header_offset)
self.fp.write(centdir)
self.fp.write(zinfo.filename)
self.fp.write(zinfo.extra)
self.fp.write(zinfo.comment)
pos2 = self.fp.tell()
# Write end-of-zip-archive record
endrec = struct.pack(structEndArchive, stringEndArchive,
0, 0, count, count, pos2 - pos1, pos1, 0)
self.fp.write(endrec)
self.fp.close()
self.fp = None
class PyZipFile(ZipFile):
"Class to create ZIP archives with Python library files and packages"
def writepy(self, pathname, basename = ""):
"""Add all files from "pathname" to the ZIP archive.
If pathname is a package directory, search the directory and all
package subdirectories recursively for all *.py and enter the modules into
the archive. If pathname is a plain directory, listdir *.py and enter all
modules. Else, pathname must be a Python *.py file and the module will be
put into the archive. Added modules are always module.pyo or module.pyc.
This method will compile the module.py into module.pyc if necessary."""
dir, name = os.path.split(pathname)
if os.path.isdir(pathname):
initname = os.path.join(pathname, "__init__.py")
if os.path.isfile(initname):
# This is a package directory, add it
if basename:
basename = "%s/%s" % (basename, name)
else:
basename = name
if self.debug:
print "Adding package in", pathname, "as", basename
fname, arcname = self._get_codename(initname[0:-3], basename)
if self.debug:
print "Adding", arcname
self.write(fname, arcname)
dirlist = os.listdir(pathname)
dirlist.remove("__init__.py")
# Add all *.py files and package subdirectories
for filename in dirlist:
path = os.path.join(pathname, filename)
root, ext = os.path.splitext(filename)
if os.path.isdir(path):
if os.path.isfile(os.path.join(path, "__init__.py")):
# This is a package directory, add it
self.writepy(path, basename) # Recursive call
elif ext == ".py":
fname, arcname = self._get_codename(path[0:-3],
basename)
if self.debug:
print "Adding", arcname
self.write(fname, arcname)
else:
# This is NOT a package directory, add its files at top level
if self.debug:
print "Adding files from directory", pathname
for filename in os.listdir(pathname):
path = os.path.join(pathname, filename)
root, ext = os.path.splitext(filename)
if ext == ".py":
fname, arcname = self._get_codename(path[0:-3],
basename)
if self.debug:
print "Adding", arcname
self.write(fname, arcname)
else:
if pathname[-3:] != ".py":
raise RuntimeError, \
'Files added with writepy() must end with ".py"'
fname, arcname = self._get_codename(pathname[0:-3], basename)
if self.debug:
print "Adding file", arcname
self.write(fname, arcname)
def _get_codename(self, pathname, basename):
"""Return (filename, archivename) for the path.
Given a module name path, return the correct file path and archive name,
compiling if necessary. For example, given /python/lib/string,
return (/python/lib/string.pyc, string)"""
file_py = pathname + ".py"
file_pyc = pathname + ".pyc"
file_pyo = pathname + ".pyo"
if os.path.isfile(file_pyo) and \
os.stat(file_pyo)[8] >= os.stat(file_py)[8]:
fname = file_pyo # Use .pyo file
elif not os.path.isfile(file_pyc) or \
os.stat(file_pyc)[8] < os.stat(file_py)[8]:
if self.debug:
print "Compiling", file_py
py_compile.compile(file_py, file_pyc)
fname = file_pyc
else:
fname = file_pyc
archivename = os.path.split(fname)[1]
if basename:
archivename = "%s/%s" % (basename, archivename)
return (fname, archivename)
--------------18734A03406EE5D854B4AC13
Content-Type: text/plain; charset=us-ascii;
name="test_zipfile.py"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="test_zipfile.py"
import zipfile, os
srcname = "junk9630.tmp"
zipname = "junk9708.tmp"
try:
fp = open(srcname, "w") # Make a source file with some lines
for i in range(0, 1000):
fp.write("Test of zipfile line %d.\n" % i)
fp.close()
zip = zipfile.ZipFile(zipname, "w") # Create the ZIP archive
zip.write(srcname, srcname)
zip.write(srcname, "another.name")
zip.close()
zip = zipfile.ZipFile(zipname, "r") # Read the ZIP archive
zip.read("another.name")
zip.read(srcname)
zip.close()
finally:
if os.path.isfile(srcname): # Remove temporary files
os.unlink(srcname)
if os.path.isfile(zipname):
os.unlink(zipname)
--------------18734A03406EE5D854B4AC13
Content-Type: text/plain; charset=us-ascii;
name="zipdocs.txt"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="zipdocs.txt"
Documentation for module zipfile.py
===================================
zipfile -- Read and write files in ZIP format
The ZIP file format is a common archive and compression standard. This
module provides tools to create, read, write, append, and list a ZIP file.
The available attributes of this module are:
error
The error raised for bad ZIP files.
class ZipFile
The class for reading and writing ZIP files.
class PyZipFile(ZipFile)
The class for making ZIP archives of Python libraries and packages.
class ZipInfo
The class for storing information about the files in a ZIP archive.
is_zipfile(path)
Return 1/0 if "path" is/is not a valid ZIP file based on its magic
number. This module does not currently handle ZIP files which have
appended comments.
ZIP_STORED
The numeric constant (zero) for an uncompressed file.
ZIP_DEFLATED
The numeric constant (eight) for the usual ZIP file compression
method. This requires the zlib module. No other
compression methods are currently supported.
The class ZipFile has this data attribute:
------------------------------------------
debug
The level of printing, an integer 0 through 3, default 0.
The class ZipFile has these methods:
------------------------------------
__init__(self, filename, mode="r", compression=ZIP_STORED)
Open a ZIP file named "filename". Mode is "r" to read an existing file,
"w" to truncate and write a new file, or "a" to append. Despite the
lack of a "b", the file is opened in binary mode. For mode "a",
if filename is a ZIP file, then additional files are added to it.
If filename is not a ZIP file, then a new ZIP file is appended to the file.
This is meant for adding a ZIP archive to another file such as python.exe.
But "cat myzip.zip >> python.exe" also works, and at least WinZip can
read such files. The "compression" is the ZIP compression method to use
when writing the archive, and must be ZIP_STORED or ZIP_DEFLATED.
namelist(self)
Return a list of file names in the ZIP archive.
infolist(self)
Return a list of class ZipInfo instances, one for each file in the archive.
Each instance contains information about the file. The list order is the
same as the order of files in the archive.
getinfo(self, name)
Return the instance of ZipInfo given the file name.
printdir(self)
Print a table of contents for the archive to stdout.
testzip(self)
Read all the files and check their CRC's. Return the name of the
first bad file, or else return None.
read(self, name)
Return the bytes of the file in the archive. The archive must be open
for read or append.
write(self, filename, arcname=None, compress_type=None)
Write the file named "filename" to the archive, and give it the archive
name "arcname", default "filename". Use "compress_type" to override the
compression method on a per-file basis. The archive must be open with
mode "w" or "a".
writestr(self, zinfo, bytes):
Write the string "bytes" and the other data to the archive. The "zinfo" is
an instance of class ZipInfo, and you should set at least zinfo.filename
and zinfo.date_time to valid values.
The archive must be open with mode "w" or "a".
close(self)
Close the archive file. You must call close() before exiting your
program or essential records will not be written.
The class PyZipFile has this one method:
----------------------------------------
writepy(self, pathname, basename = "")
Search for files *.py and add the corresponding file to the archive.
The corresponding file is a *.pyo file if available,
else a *.pyc file, compiling if necessary. If the pathname is a file,
the file must end with ".py", and just the (corresponding *.py[oc]) file is
added at the top level (no path information). If it is a directory, and the
directory is not a package directory, then all the files *.py[oc] are
added at the top level.
If the directory is a package directory, then all *.py[oc] are added
under the package
name as a file path, and if any subdirectories are package directories,
all of these are
added recursively. The "basename" is intended for internal use only.
The writepy() method makes archives with file names like this:
string.pyc # Top level name
test/__init__.pyc # Package directory
test/testall.pyc # Package "test.testall" file
test/bogus/__init__.pyc # Subpackage directory
test/bogus/myfile.pyc # Subpackage "test.bogus.myfile" file
The class ZipInfo has these data attributes:
--------------------------------------------
filename Name of the file in the archive.
extra The "extra" ZIP data string.
comment File comment string.
header_offset Byte offset to the file header.
file_offset Byte offset to the start of the file data.
create_version Zip version of the software which created the archive.
create_system Type of system used to create the archive.
extract_version Zip version needed to extract the files in the archive.
reserved Must be zero.
flag_bits Zip flag bits.
compress_type Type of compression for the file.
date_time The file time tuple (year, month, day, hour, min, sec).
CRC CRC-32 of the uncompressed file.
compress_size Size of the compressed file.
file_size Size of the uncompressed file.
volume Disk volume number.
internal_attr Internal file attributes.
external_attr External file attributes.
The class ZipInfo has these methods:
--------------------------------------
__init__(self, filename="NoName", date_time=(1980,1,1,0,0,0))
Create an instance with the specified name and date.
FileHeader(self)
Return the ZIP per-file header as a string. Intended for internal use.
Bugs
====
Flag bit 0x08 is in use, and the DOS version PkZip 2.04g will not be
able to read the archive unless compression methon ZIP_DEFLATED is used.
In the interest of speed, this module does not attempt to read ZIP
archives with an appended archive comment string.
This module puts the Unix file attributes in the top two bytes of the
external_attr, but sets the low-byte DOS attributes (if any) to zero.
Bit 0x01 of internal_attr should be set for a text file, but it
is always zero.
--------------18734A03406EE5D854B4AC13--