__init__.py

"""
Read and write ZIP files.

XXX references to utf-8 need further investigation.
"""
importbinascii
importimportlib.util
importio
importos
importshutil
importstat
importstruct
importsys
importthreading
importtime

try:
importzlib# We may need its compression method
crc32=zlib.crc32
exceptImportError:
zlib=None
crc32=binascii.crc32

try:
importbz2# We may need its compression method
exceptImportError:
bz2=None

try:
importlzma# We may need its compression method
exceptImportError:
lzma=None

__all__= ["BadZipFile", "BadZipfile", "error",
"ZIP_STORED", "ZIP_DEFLATED", "ZIP_BZIP2", "ZIP_LZMA",
"is_zipfile", "ZipInfo", "ZipFile", "PyZipFile", "LargeZipFile",
"Path"]

classBadZipFile(Exception):
pass


classLargeZipFile(Exception):
"""
 Raised when writing a zipfile, the zipfile requires ZIP64 extensions
 and those extensions are disabled.
 """

error=BadZipfile=BadZipFile# Pre-3.2 compatibility names


ZIP64_LIMIT= (1<<31) -1
ZIP_FILECOUNT_LIMIT= (1<<16) -1
ZIP_MAX_COMMENT= (1<<16) -1

# constants for Zip file compression methods
ZIP_STORED=0
ZIP_DEFLATED=8
ZIP_BZIP2=12
ZIP_LZMA=14
# Other ZIP compression methods not supported

DEFAULT_VERSION=20
ZIP64_VERSION=45
BZIP2_VERSION=46
LZMA_VERSION=63
# we recognize (but not necessarily support) all features up to that version
MAX_EXTRACT_VERSION=63

# Below are some formats and associated data for reading/writing headers using
# the struct module. The names and structures of headers/records are those used
# in the PKWARE description of the ZIP file format:
# http://www.pkware.com/documents/casestudies/APPNOTE.TXT
# (URL valid as of January 2008)

# The "end of central directory" structure, magic number, size, and indices
# (section V.I in the format document)
structEndArchive=b"<4s4H2LH"
stringEndArchive=b"PK\005\006"
sizeEndCentDir=struct.calcsize(structEndArchive)

_ECD_SIGNATURE=0
_ECD_DISK_NUMBER=1
_ECD_DISK_START=2
_ECD_ENTRIES_THIS_DISK=3
_ECD_ENTRIES_TOTAL=4
_ECD_SIZE=5
_ECD_OFFSET=6
_ECD_COMMENT_SIZE=7
# These last two indices are not part of the structure as defined in the
# spec, but they are used internally by this module as a convenience
_ECD_COMMENT=8
_ECD_LOCATION=9

# The "central directory" structure, magic number, size, and indices
# of entries in the structure (section V.F in the format document)
structCentralDir="<4s4B4HL2L5H2L"
stringCentralDir=b"PK\001\002"
sizeCentralDir=struct.calcsize(structCentralDir)

# indexes of entries in the central directory structure
_CD_SIGNATURE=0
_CD_CREATE_VERSION=1
_CD_CREATE_SYSTEM=2
_CD_EXTRACT_VERSION=3
_CD_EXTRACT_SYSTEM=4
_CD_FLAG_BITS=5
_CD_COMPRESS_TYPE=6
_CD_TIME=7
_CD_DATE=8
_CD_CRC=9
_CD_COMPRESSED_SIZE=10
_CD_UNCOMPRESSED_SIZE=11
_CD_FILENAME_LENGTH=12
_CD_EXTRA_FIELD_LENGTH=13
_CD_COMMENT_LENGTH=14
_CD_DISK_NUMBER_START=15
_CD_INTERNAL_FILE_ATTRIBUTES=16
_CD_EXTERNAL_FILE_ATTRIBUTES=17
_CD_LOCAL_HEADER_OFFSET=18

# General purpose bit flags
# Zip Appnote: 4.4.4 general purpose bit flag: (2 bytes)
_MASK_ENCRYPTED=1<<0
# Bits 1 and 2 have different meanings depending on the compression used.
_MASK_COMPRESS_OPTION_1=1<<1
# _MASK_COMPRESS_OPTION_2 = 1 << 2
# _MASK_USE_DATA_DESCRIPTOR: If set, crc-32, compressed size and uncompressed
# size are zero in the local header and the real values are written in the data
# descriptor immediately following the compressed data.
_MASK_USE_DATA_DESCRIPTOR=1<<3
# Bit 4: Reserved for use with compression method 8, for enhanced deflating.
# _MASK_RESERVED_BIT_4 = 1 << 4
_MASK_COMPRESSED_PATCH=1<<5
_MASK_STRONG_ENCRYPTION=1<<6
# _MASK_UNUSED_BIT_7 = 1 << 7
# _MASK_UNUSED_BIT_8 = 1 << 8
# _MASK_UNUSED_BIT_9 = 1 << 9
# _MASK_UNUSED_BIT_10 = 1 << 10
_MASK_UTF_FILENAME=1<<11
# Bit 12: Reserved by PKWARE for enhanced compression.
# _MASK_RESERVED_BIT_12 = 1 << 12
# _MASK_ENCRYPTED_CENTRAL_DIR = 1 << 13
# Bit 14, 15: Reserved by PKWARE
# _MASK_RESERVED_BIT_14 = 1 << 14
# _MASK_RESERVED_BIT_15 = 1 << 15

# The "local file header" structure, magic number, size, and indices
# (section V.A in the format document)
structFileHeader="<4s2B4HL2L2H"
stringFileHeader=b"PK\003\004"
sizeFileHeader=struct.calcsize(structFileHeader)

_FH_SIGNATURE=0
_FH_EXTRACT_VERSION=1
_FH_EXTRACT_SYSTEM=2
_FH_GENERAL_PURPOSE_FLAG_BITS=3
_FH_COMPRESSION_METHOD=4
_FH_LAST_MOD_TIME=5
_FH_LAST_MOD_DATE=6
_FH_CRC=7
_FH_COMPRESSED_SIZE=8
_FH_UNCOMPRESSED_SIZE=9
_FH_FILENAME_LENGTH=10
_FH_EXTRA_FIELD_LENGTH=11

# The "Zip64 end of central directory locator" structure, magic number, and size
structEndArchive64Locator="<4sLQL"
stringEndArchive64Locator=b"PK\x06\x07"
sizeEndCentDir64Locator=struct.calcsize(structEndArchive64Locator)

# The "Zip64 end of central directory" record, magic number, size, and indices
# (section V.G in the format document)
structEndArchive64="<4sQ2H2L4Q"
stringEndArchive64=b"PK\x06\x06"
sizeEndCentDir64=struct.calcsize(structEndArchive64)

_CD64_SIGNATURE=0
_CD64_DIRECTORY_RECSIZE=1
_CD64_CREATE_VERSION=2
_CD64_EXTRACT_VERSION=3
_CD64_DISK_NUMBER=4
_CD64_DISK_NUMBER_START=5
_CD64_NUMBER_ENTRIES_THIS_DISK=6
_CD64_NUMBER_ENTRIES_TOTAL=7
_CD64_DIRECTORY_SIZE=8
_CD64_OFFSET_START_CENTDIR=9

_DD_SIGNATURE=0x08074b50


class_Extra(bytes):
FIELD_STRUCT=struct.Struct('<HH')

def__new__(cls, val, id=None):
returnsuper().__new__(cls, val)

def__init__(self, val, id=None):
self.id=id

@classmethod
defread_one(cls, raw):
try:
xid, xlen=cls.FIELD_STRUCT.unpack(raw[:4])
exceptstruct.error:
xid=None
xlen=0
returncls(raw[:4+xlen], xid), raw[4+xlen:]

@classmethod
defsplit(cls, data):
# use memoryview for zero-copy slices
rest=memoryview(data)
whilerest:
extra, rest=_Extra.read_one(rest)
yieldextra

@classmethod
defstrip(cls, data, xids):
"""Remove Extra fields with specified IDs."""
returnb''.join(
ex
forexincls.split(data)
ifex.idnotinxids
 )


def_check_zipfile(fp):
try:
if_EndRecData(fp):
returnTrue# file has correct magic number
exceptOSError:
pass
returnFalse

defis_zipfile(filename):
"""Quickly see if a file is a ZIP file by checking the magic number.

 The filename argument may be a file or file-like object too.
 """
result=False
try:
ifhasattr(filename, "read"):
result=_check_zipfile(fp=filename)
else:
withopen(filename, "rb") asfp:
result=_check_zipfile(fp)
exceptOSError:
pass
returnresult

def_EndRecData64(fpin, offset, endrec):
"""
 Read the ZIP64 end-of-archive records and use that to update endrec
 """
try:
fpin.seek(offset-sizeEndCentDir64Locator, 2)
exceptOSError:
# If the seek fails, the file is not large enough to contain a ZIP64
# end-of-archive record, so just return the end record we were given.
returnendrec

data=fpin.read(sizeEndCentDir64Locator)
iflen(data) !=sizeEndCentDir64Locator:
returnendrec
sig, diskno, reloff, disks=struct.unpack(structEndArchive64Locator, data)
ifsig!=stringEndArchive64Locator:
returnendrec

ifdiskno!=0ordisks>1:
raiseBadZipFile("zipfiles that span multiple disks are not supported")

# Assume no 'zip64 extensible data'
fpin.seek(offset-sizeEndCentDir64Locator-sizeEndCentDir64, 2)
data=fpin.read(sizeEndCentDir64)
iflen(data) !=sizeEndCentDir64:
returnendrec
sig, sz, create_version, read_version, disk_num, disk_dir, \
dircount, dircount2, dirsize, diroffset= \
struct.unpack(structEndArchive64, data)
ifsig!=stringEndArchive64:
returnendrec

# Update the original endrec using data from the ZIP64 record
endrec[_ECD_SIGNATURE] =sig
endrec[_ECD_DISK_NUMBER] =disk_num
endrec[_ECD_DISK_START] =disk_dir
endrec[_ECD_ENTRIES_THIS_DISK] =dircount
endrec[_ECD_ENTRIES_TOTAL] =dircount2
endrec[_ECD_SIZE] =dirsize
endrec[_ECD_OFFSET] =diroffset
returnendrec


def_EndRecData(fpin):
"""Return data from the "End of Central Directory" record, or None.

 The data is a list of the nine items in the ZIP "End of central dir"
 record followed by a tenth item, the file seek offset of this record."""

# Determine file size
fpin.seek(0, 2)
filesize=fpin.tell()

# Check to see if this is ZIP file with no archive comment (the
# "end of central directory" structure should be the last item in the
# file if this is the case).
try:
fpin.seek(-sizeEndCentDir, 2)
exceptOSError:
returnNone
data=fpin.read(sizeEndCentDir)
if (len(data) ==sizeEndCentDirand
data[0:4] ==stringEndArchiveand
data[-2:] ==b"\000\000"):
# the signature is correct and there's no comment, unpack structure
endrec=struct.unpack(structEndArchive, data)
endrec=list(endrec)

# Append a blank comment and record start offset
endrec.append(b"")
endrec.append(filesize-sizeEndCentDir)

# Try to read the "Zip64 end of central directory" structure
return_EndRecData64(fpin, -sizeEndCentDir, endrec)

# Either this is not a ZIP file, or it is a ZIP file with an archive
# comment. Search the end of the file for the "end of central directory"
# record signature. The comment is the last item in the ZIP file and may be
# up to 64K long. It is assumed that the "end of central directory" magic
# number does not appear in the comment.
maxCommentStart=max(filesize-ZIP_MAX_COMMENT-sizeEndCentDir, 0)
fpin.seek(maxCommentStart, 0)
data=fpin.read(ZIP_MAX_COMMENT+sizeEndCentDir)
start=data.rfind(stringEndArchive)
ifstart>=0:
# found the magic number; attempt to unpack and interpret
recData=data[start:start+sizeEndCentDir]
iflen(recData) !=sizeEndCentDir:
# Zip file is corrupted.
returnNone
endrec=list(struct.unpack(structEndArchive, recData))
commentSize=endrec[_ECD_COMMENT_SIZE] #as claimed by the zip file
comment=data[start+sizeEndCentDir:start+sizeEndCentDir+commentSize]
endrec.append(comment)
endrec.append(maxCommentStart+start)

# Try to read the "Zip64 end of central directory" structure
return_EndRecData64(fpin, maxCommentStart+start-filesize,
endrec)

# Unable to find a valid end of central directory structure
returnNone

def_sanitize_filename(filename):
"""Terminate the file name at the first null byte and
 ensure paths always use forward slashes as the directory separator."""

# Terminate the file name at the first null byte. Null bytes in file
# names are used as tricks by viruses in archives.
null_byte=filename.find(chr(0))
ifnull_byte>=0:
filename=filename[0:null_byte]
# This is used to ensure paths in generated ZIP files always use
# forward slashes as the directory separator, as required by the
# ZIP format specification.
ifos.sep!="/"andos.sepinfilename:
filename=filename.replace(os.sep, "/")
ifos.altsepandos.altsep!="/"andos.altsepinfilename:
filename=filename.replace(os.altsep, "/")
returnfilename


classZipInfo:
"""Class with attributes describing each file in the ZIP archive."""

__slots__= (
'orig_filename',
'filename',
'date_time',
'compress_type',
'compress_level',
'comment',
'extra',
'create_system',
'create_version',
'extract_version',
'reserved',
'flag_bits',
'volume',
'internal_attr',
'external_attr',
'header_offset',
'CRC',
'compress_size',
'file_size',
'_raw_time',
'_end_offset',
 )

def__init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
self.orig_filename=filename# Original file name in archive

# Terminate the file name at the first null byte and
# ensure paths always use forward slashes as the directory separator.
filename=_sanitize_filename(filename)

self.filename=filename# Normalized file name
self.date_time=date_time# year, month, day, hour, min, sec

ifdate_time[0] <1980:
raiseValueError('ZIP does not support timestamps before 1980')

# Standard values:
self.compress_type=ZIP_STORED# Type of compression for the file
self.compress_level=None# Level for the compressor
self.comment=b""# Comment for each file
self.extra=b""# ZIP extra data
ifsys.platform=='win32':
self.create_system=0# System which created ZIP archive
else:
# Assume everything else is unix-y
self.create_system=3# System which created ZIP archive
self.create_version=DEFAULT_VERSION# Version which created ZIP archive
self.extract_version=DEFAULT_VERSION# 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
self.compress_size=0# Size of the compressed file
self.file_size=0# Size of the uncompressed file
self._end_offset=None# Start of the next local header or central directory
# Other attributes are set by class ZipFile:
# header_offset Byte offset to the file header
# CRC CRC-32 of the uncompressed file

# Maintain backward compatibility with the old protected attribute name.
@property
def_compresslevel(self):
returnself.compress_level

@_compresslevel.setter
def_compresslevel(self, value):
self.compress_level=value

def__repr__(self):
result= ['<%s filename=%r'% (self.__class__.__name__, self.filename)]
ifself.compress_type!=ZIP_STORED:
result.append(' compress_type=%s'%
compressor_names.get(self.compress_type,
self.compress_type))
hi=self.external_attr>>16
lo=self.external_attr&0xFFFF
ifhi:
result.append(' filemode=%r'%stat.filemode(hi))
iflo:
result.append(' external_attr=%#x'%lo)
isdir=self.is_dir()
ifnotisdirorself.file_size:
result.append(' file_size=%r'%self.file_size)
if ((notisdirorself.compress_size) and
 (self.compress_type!=ZIP_STOREDor
self.file_size!=self.compress_size)):
result.append(' compress_size=%r'%self.compress_size)
result.append('>')
return''.join(result)

defFileHeader(self, zip64=None):
"""Return the per-file header as a bytes object.

 When the optional zip64 arg is None rather than a bool, we will
 decide based upon the file_size and compress_size, if known,
 False otherwise.
 """
dt=self.date_time
dosdate= (dt[0] -1980) <<9|dt[1] <<5|dt[2]
dostime=dt[3] <<11|dt[4] <<5| (dt[5] //2)
ifself.flag_bits&_MASK_USE_DATA_DESCRIPTOR:
# 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

extra=self.extra

min_version=0
ifzip64isNone:
# We always explicitly pass zip64 within this module.... This
# remains for anyone using ZipInfo.FileHeader as a public API.
zip64=file_size>ZIP64_LIMITorcompress_size>ZIP64_LIMIT
ifzip64:
fmt='<HHQQ'
extra=extra+struct.pack(fmt,
1, struct.calcsize(fmt)-4, file_size, compress_size)
file_size=0xffffffff
compress_size=0xffffffff
min_version=ZIP64_VERSION

ifself.compress_type==ZIP_BZIP2:
min_version=max(BZIP2_VERSION, min_version)
elifself.compress_type==ZIP_LZMA:
min_version=max(LZMA_VERSION, min_version)

self.extract_version=max(min_version, self.extract_version)
self.create_version=max(min_version, self.create_version)
filename, flag_bits=self._encodeFilenameFlags()
header=struct.pack(structFileHeader, stringFileHeader,
self.extract_version, self.reserved, flag_bits,
self.compress_type, dostime, dosdate, CRC,
compress_size, file_size,
len(filename), len(extra))
returnheader+filename+extra

def_encodeFilenameFlags(self):
try:
returnself.filename.encode('ascii'), self.flag_bits
exceptUnicodeEncodeError:
returnself.filename.encode('utf-8'), self.flag_bits|_MASK_UTF_FILENAME

def_decodeExtra(self, filename_crc):
# Try to decode the extra field.
extra=self.extra
unpack=struct.unpack
whilelen(extra) >=4:
tp, ln=unpack('<HH', extra[:4])
ifln+4>len(extra):
raiseBadZipFile("Corrupt extra field %04x (size=%d)"% (tp, ln))
iftp==0x0001:
data=extra[4:ln+4]
# ZIP64 extension (large files and/or large archives)
try:
ifself.file_sizein (0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF):
field="File size"
self.file_size, =unpack('<Q', data[:8])
data=data[8:]
ifself.compress_size==0xFFFF_FFFF:
field="Compress size"
self.compress_size, =unpack('<Q', data[:8])
data=data[8:]
ifself.header_offset==0xFFFF_FFFF:
field="Header offset"
self.header_offset, =unpack('<Q', data[:8])
exceptstruct.error:
raiseBadZipFile(f"Corrupt zip64 extra field. "
f"{field} not found.") fromNone
eliftp==0x7075:
data=extra[4:ln+4]
# Unicode Path Extra Field
try:
up_version, up_name_crc=unpack('<BL', data[:5])
ifup_version==1andup_name_crc==filename_crc:
up_unicode_name=data[5:].decode('utf-8')
ifup_unicode_name:
self.filename=_sanitize_filename(up_unicode_name)
else:
importwarnings
warnings.warn("Empty unicode path extra field (0x7075)", stacklevel=2)
exceptstruct.errorase:
raiseBadZipFile("Corrupt unicode path extra field (0x7075)") frome
exceptUnicodeDecodeErrorase:
raiseBadZipFile('Corrupt unicode path extra field (0x7075): invalid utf-8 bytes') frome

extra=extra[ln+4:]

@classmethod
deffrom_file(cls, filename, arcname=None, *, strict_timestamps=True):
"""Construct an appropriate ZipInfo for a file on the filesystem.

 filename should be the path to a file or directory on the filesystem.

 arcname is the name which it will have within the archive (by default,
 this will be the same as filename, but without a drive letter and with
 leading path separators removed).
 """
ifisinstance(filename, os.PathLike):
filename=os.fspath(filename)
st=os.stat(filename)
isdir=stat.S_ISDIR(st.st_mode)
mtime=time.localtime(st.st_mtime)
date_time=mtime[0:6]
ifnotstrict_timestampsanddate_time[0] <1980:
date_time= (1980, 1, 1, 0, 0, 0)
elifnotstrict_timestampsanddate_time[0] >2107:
date_time= (2107, 12, 31, 23, 59, 59)
# Create ZipInfo instance to store file information
ifarcnameisNone:
arcname=filename
arcname=os.path.normpath(os.path.splitdrive(arcname)[1])
whilearcname[0] in (os.sep, os.altsep):
arcname=arcname[1:]
ifisdir:
arcname+='/'
zinfo=cls(arcname, date_time)
zinfo.external_attr= (st.st_mode&0xFFFF) <<16# Unix attributes
ifisdir:
zinfo.file_size=0
zinfo.external_attr|=0x10# MS-DOS directory flag
else:
zinfo.file_size=st.st_size

returnzinfo

defis_dir(self):
"""Return True if this archive member is a directory."""
ifself.filename.endswith('/'):
returnTrue
# The ZIP format specification requires to use forward slashes
# as the directory separator, but in practice some ZIP files
# created on Windows can use backward slashes. For compatibility
# with the extraction code which already handles this:
ifos.path.altsep:
returnself.filename.endswith((os.path.sep, os.path.altsep))
returnFalse


# ZIP encryption uses the CRC32 one-byte primitive for scrambling some
# internal keys. We noticed that a direct implementation is faster than
# relying on binascii.crc32().

_crctable=None
def_gen_crc(crc):
forjinrange(8):
ifcrc&1:
crc= (crc>>1) ^0xEDB88320
else:
crc>>=1
returncrc

# ZIP supports a password-based form of encryption. Even though known
# plaintext attacks have been found against it, it is still useful
# to be able to get data out of such a file.
#
# Usage:
# zd = _ZipDecrypter(mypwd)
# plain_bytes = zd(cypher_bytes)

def_ZipDecrypter(pwd):
key0=305419896
key1=591751049
key2=878082192

global_crctable
if_crctableisNone:
_crctable=list(map(_gen_crc, range(256)))
crctable=_crctable

defcrc32(ch, crc):
"""Compute the CRC32 primitive on one byte."""
return (crc>>8) ^crctable[(crc^ch) &0xFF]

defupdate_keys(c):
nonlocalkey0, key1, key2
key0=crc32(c, key0)
key1= (key1+ (key0&0xFF)) &0xFFFFFFFF
key1= (key1*134775813+1) &0xFFFFFFFF
key2=crc32(key1>>24, key2)

forpinpwd:
update_keys(p)

defdecrypter(data):
"""Decrypt a bytes object."""
result=bytearray()
append=result.append
forcindata:
k=key2|2
c^= ((k* (k^1)) >>8) &0xFF
update_keys(c)
append(c)
returnbytes(result)

returndecrypter


classLZMACompressor:

def__init__(self):
self._comp=None

def_init(self):
props=lzma._encode_filter_properties({'id': lzma.FILTER_LZMA1})
self._comp=lzma.LZMACompressor(lzma.FORMAT_RAW, filters=[
lzma._decode_filter_properties(lzma.FILTER_LZMA1, props)
 ])
returnstruct.pack('<BBH', 9, 4, len(props)) +props

defcompress(self, data):
ifself._compisNone:
returnself._init() +self._comp.compress(data)
returnself._comp.compress(data)

defflush(self):
ifself._compisNone:
returnself._init() +self._comp.flush()
returnself._comp.flush()


classLZMADecompressor:

def__init__(self):
self._decomp=None
self._unconsumed=b''
self.eof=False

defdecompress(self, data):
ifself._decompisNone:
self._unconsumed+=data
iflen(self._unconsumed) <=4:
returnb''
psize, =struct.unpack('<H', self._unconsumed[2:4])
iflen(self._unconsumed) <=4+psize:
returnb''

self._decomp=lzma.LZMADecompressor(lzma.FORMAT_RAW, filters=[
lzma._decode_filter_properties(lzma.FILTER_LZMA1,
self._unconsumed[4:4+psize])
 ])
data=self._unconsumed[4+psize:]
delself._unconsumed

result=self._decomp.decompress(data)
self.eof=self._decomp.eof
returnresult


compressor_names= {
0: 'store',
1: 'shrink',
2: 'reduce',
3: 'reduce',
4: 'reduce',
5: 'reduce',
6: 'implode',
7: 'tokenize',
8: 'deflate',
9: 'deflate64',
10: 'implode',
12: 'bzip2',
14: 'lzma',
18: 'terse',
19: 'lz77',
97: 'wavpack',
98: 'ppmd',
}

def_check_compression(compression):
ifcompression==ZIP_STORED:
pass
elifcompression==ZIP_DEFLATED:
ifnotzlib:
raiseRuntimeError(
"Compression requires the (missing) zlib module")
elifcompression==ZIP_BZIP2:
ifnotbz2:
raiseRuntimeError(
"Compression requires the (missing) bz2 module")
elifcompression==ZIP_LZMA:
ifnotlzma:
raiseRuntimeError(
"Compression requires the (missing) lzma module")
else:
raiseNotImplementedError("That compression method is not supported")


def_get_compressor(compress_type, compresslevel=None):
ifcompress_type==ZIP_DEFLATED:
ifcompresslevelisnotNone:
returnzlib.compressobj(compresslevel, zlib.DEFLATED, -15)
returnzlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -15)
elifcompress_type==ZIP_BZIP2:
ifcompresslevelisnotNone:
returnbz2.BZ2Compressor(compresslevel)
returnbz2.BZ2Compressor()
# compresslevel is ignored for ZIP_LZMA
elifcompress_type==ZIP_LZMA:
returnLZMACompressor()
else:
returnNone


def_get_decompressor(compress_type):
_check_compression(compress_type)
ifcompress_type==ZIP_STORED:
returnNone
elifcompress_type==ZIP_DEFLATED:
returnzlib.decompressobj(-15)
elifcompress_type==ZIP_BZIP2:
returnbz2.BZ2Decompressor()
elifcompress_type==ZIP_LZMA:
returnLZMADecompressor()
else:
descr=compressor_names.get(compress_type)
ifdescr:
raiseNotImplementedError("compression type %d (%s)"% (compress_type, descr))
else:
raiseNotImplementedError("compression type %d"% (compress_type,))


class_SharedFile:
def__init__(self, file, pos, close, lock, writing):
self._file=file
self._pos=pos
self._close=close
self._lock=lock
self._writing=writing
self.seekable=file.seekable

deftell(self):
returnself._pos

defseek(self, offset, whence=0):
withself._lock:
ifself._writing():
raiseValueError("Can't reposition in the ZIP file while "
"there is an open writing handle on it. "
"Close the writing handle before trying to read.")
ifwhence==os.SEEK_CUR:
self._file.seek(self._pos+offset)
else:
self._file.seek(offset, whence)
self._pos=self._file.tell()
returnself._pos

defread(self, n=-1):
withself._lock:
ifself._writing():
raiseValueError("Can't read from the ZIP file while there "
"is an open writing handle on it. "
"Close the writing handle before trying to read.")
self._file.seek(self._pos)
data=self._file.read(n)
self._pos=self._file.tell()
returndata

defclose(self):
ifself._fileisnotNone:
fileobj=self._file
self._file=None
self._close(fileobj)

# Provide the tell method for unseekable stream
class_Tellable:
def__init__(self, fp):
self.fp=fp
self.offset=0

defwrite(self, data):
n=self.fp.write(data)
self.offset+=n
returnn

deftell(self):
returnself.offset

defflush(self):
self.fp.flush()

defclose(self):
self.fp.close()


classZipExtFile(io.BufferedIOBase):
"""File-like object for reading an archive member.
 Is returned by ZipFile.open().
 """

# Max size supported by decompressor.
MAX_N=1<<31-1

# Read from compressed files in 4k blocks.
MIN_READ_SIZE=4096

# Chunk size to read during seek
MAX_SEEK_READ=1<<24

def__init__(self, fileobj, mode, zipinfo, pwd=None,
close_fileobj=False):
self._fileobj=fileobj
self._pwd=pwd
self._close_fileobj=close_fileobj

self._compress_type=zipinfo.compress_type
self._compress_left=zipinfo.compress_size
self._left=zipinfo.file_size

self._decompressor=_get_decompressor(self._compress_type)

self._eof=False
self._readbuffer=b''
self._offset=0

self.newlines=None

self.mode=mode
self.name=zipinfo.filename

ifhasattr(zipinfo, 'CRC'):
self._expected_crc=zipinfo.CRC
self._running_crc=crc32(b'')
else:
self._expected_crc=None

self._seekable=False
try:
iffileobj.seekable():
self._orig_compress_start=fileobj.tell()
self._orig_compress_size=zipinfo.compress_size
self._orig_file_size=zipinfo.file_size
self._orig_start_crc=self._running_crc
self._orig_crc=self._expected_crc
self._seekable=True
exceptAttributeError:
pass

self._decrypter=None
ifpwd:
ifzipinfo.flag_bits&_MASK_USE_DATA_DESCRIPTOR:
# compare against the file type from extended local headers
check_byte= (zipinfo._raw_time>>8) &0xff
else:
# compare against the CRC otherwise
check_byte= (zipinfo.CRC>>24) &0xff
h=self._init_decrypter()
ifh!=check_byte:
raiseRuntimeError("Bad password for file %r"%zipinfo.orig_filename)


def_init_decrypter(self):
self._decrypter=_ZipDecrypter(self._pwd)
# The first 12 bytes in the cypher stream is an encryption header
# used to strengthen the algorithm. The first 11 bytes are
# completely random, while the 12th contains the MSB of the CRC,
# or the MSB of the file time depending on the header type
# and is used to check the correctness of the password.
header=self._fileobj.read(12)
self._compress_left-=12
returnself._decrypter(header)[11]

def__repr__(self):
result= ['<%s.%s'% (self.__class__.__module__,
self.__class__.__qualname__)]
ifnotself.closed:
result.append(' name=%r'% (self.name,))
ifself._compress_type!=ZIP_STORED:
result.append(' compress_type=%s'%
compressor_names.get(self._compress_type,
self._compress_type))
else:
result.append(' [closed]')
result.append('>')
return''.join(result)

defreadline(self, limit=-1):
"""Read and return a line from the stream.

 If limit is specified, at most limit bytes will be read.
 """

iflimit<0:
# Shortcut common case - newline found in buffer.
i=self._readbuffer.find(b'\n', self._offset) +1
ifi>0:
line=self._readbuffer[self._offset: i]
self._offset=i
returnline

returnio.BufferedIOBase.readline(self, limit)

defpeek(self, n=1):
"""Returns buffered bytes without advancing the position."""
ifn>len(self._readbuffer) -self._offset:
chunk=self.read(n)
iflen(chunk) >self._offset:
self._readbuffer=chunk+self._readbuffer[self._offset:]
self._offset=0
else:
self._offset-=len(chunk)

# Return up to 512 bytes to reduce allocation overhead for tight loops.
returnself._readbuffer[self._offset: self._offset+512]

defreadable(self):
ifself.closed:
raiseValueError("I/O operation on closed file.")
returnTrue

defread(self, n=-1):
"""Read and return up to n bytes.
 If the argument is omitted, None, or negative, data is read and returned until EOF is reached.
 """
ifself.closed:
raiseValueError("read from closed file.")
ifnisNoneorn<0:
buf=self._readbuffer[self._offset:]
self._readbuffer=b''
self._offset=0
whilenotself._eof: